Coverage Report - org.webslinger.rules.Rules
 
Classes in this File Line Coverage Branch Coverage Complexity
Rules
51%
565/1099
52%
127/246
7.485
Rules$1
100%
2/2
N/A
N/A
7.485
Rules$2
100%
2/2
N/A
N/A
7.485
Rules$JJCalls
100%
1/1
N/A
N/A
7.485
Rules$LookaheadSuccess
100%
1/1
N/A
N/A
7.485
Rules$PathFactory
N/A
N/A
N/A
N/A
7.485
 
 1   
 /* Generated By:JJTree&JavaCC: Do not edit this line. Rules.java */
 2   
 package org.webslinger.rules;
 3   
 
 4   
 import java.io.*;
 5   
 import java.util.LinkedList;
 6   
 
 7   
 public class Rules/*@bgen(jjtree)*/implements RulesTreeConstants, RulesConstants {/*@bgen(jjtree)*/
 8  22 
   protected JJTRulesState jjtree = new JJTRulesState();public Rules(String fileName) {
 9  0 
         this(System.in);
 10  0 
         try { ReInit(new FileInputStream(new File(fileName))); }
 11  0 
         catch(Exception e) { e.printStackTrace(); }
 12   
 //        allowed[TEXT] = 1;
 13   
 //        allowed[FIRST_COLUMN_TEXT] = 1;
 14  0 
     }
 15   
 
 16   
     interface PathFactory {
 17   
         PathMatcher getMatcher(String s);
 18   
     }
 19   
 
 20  22 
     PathFactory CONSTANT = new PathFactory() {
 21   
         public PathMatcher getMatcher(String s) {
 22  11 
             return new ConstantMatcher(s);
 23   
         }
 24   
     };
 25   
 
 26  22 
     PathFactory REGEX = new PathFactory() {
 27   
         public PathMatcher getMatcher(String s) {
 28  2 
             return new RegexMatcher(s);
 29   
         }
 30   
     };
 31   
 
 32   
   final public CSSRules Rules() throws ParseException {
 33   
  /*@bgen(jjtree) Rules */
 34  22 
   CSSRules jjtn000 = new CSSRules(this, JJTRULES);
 35  22 
   boolean jjtc000 = true;
 36  22 
   jjtree.openNodeScope(jjtn000);
 37   
     try {
 38   
       label_1:
 39   
       while (true) {
 40  44 
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 41   
         case CONFIG_START:
 42   
           ;
 43  22 
           break;
 44   
         default:
 45  22 
           jj_la1[0] = jj_gen;
 46  22 
           break label_1;
 47   
         }
 48  22 
         Config(jjtn000);
 49   
       }
 50   
       label_2:
 51   
       while (true) {
 52  119 
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 53   
         case CHILD:
 54   
         case SIBLING:
 55   
         case ROOT:
 56   
         case TYPE:
 57   
         case CLASS:
 58   
         case ALL:
 59   
         case ATTRIBUTE_START:
 60   
         case COMMAND_START:
 61   
         case MODE_START:
 62   
         case REQ_ATTR_START:
 63   
         case REQ_PARAM_START:
 64   
         case REGEX_START:
 65   
         case THEME_START:
 66   
         case QUOTE_START:
 67   
           ;
 68  97 
           break;
 69   
         default:
 70  22 
           jj_la1[1] = jj_gen;
 71  22 
           break label_2;
 72   
         }
 73  97 
         Rule();
 74   
       }
 75  22 
       jj_consume_token(0);
 76  22 
     jjtree.closeNodeScope(jjtn000, true);
 77  22 
     jjtc000 = false;
 78  22 
     {if (true) return jjtn000;}
 79  0 
     } catch (Throwable jjte000) {
 80  0 
     if (jjtc000) {
 81  0 
       jjtree.clearNodeScope(jjtn000);
 82  0 
       jjtc000 = false;
 83   
     } else {
 84  0 
       jjtree.popNode();
 85   
     }
 86  0 
     if (jjte000 instanceof RuntimeException) {
 87  0 
       {if (true) throw (RuntimeException)jjte000;}
 88   
     }
 89  0 
     if (jjte000 instanceof ParseException) {
 90  0 
       {if (true) throw (ParseException)jjte000;}
 91   
     }
 92  0 
     {if (true) throw (Error)jjte000;}
 93   
     } finally {
 94  22 
     if (jjtc000) {
 95  0 
       jjtree.closeNodeScope(jjtn000, true);
 96   
     }
 97   
     }
 98   
     throw new Error("Missing return statement in function");
 99   
   }
 100   
 
 101   
   final public void Config(CSSRules rules) throws ParseException {
 102   
   String n, v;
 103  22 
     jj_consume_token(CONFIG_START);
 104  22 
     n = Quoted();
 105  22 
     jj_consume_token(SEP);
 106  22 
     v = Quoted();
 107  22 
     jj_consume_token(CALL_END);
 108  22 
     rules.addSetting(n, v);
 109  22 
   }
 110   
 
 111   
   final public void Rule() throws ParseException {
 112   
  /*@bgen(jjtree) Rule */
 113  97 
   CSSRule jjtn000 = new CSSRule(this, JJTRULE);
 114  97 
   boolean jjtc000 = true;
 115  97 
   jjtree.openNodeScope(jjtn000);
 116   
     try {
 117  97 
       Selectors();
 118  97 
       jj_consume_token(RULE_START);
 119   
       label_3:
 120   
       while (true) {
 121  221 
         if (jj_2_1(3)) {
 122   
           ;
 123   
         } else {
 124   
           break label_3;
 125   
         }
 126  124 
         Action();
 127   
       }
 128  97 
       jj_consume_token(RULE_END);
 129  0 
     } catch (Throwable jjte000) {
 130  0 
     if (jjtc000) {
 131  0 
       jjtree.clearNodeScope(jjtn000);
 132  0 
       jjtc000 = false;
 133   
     } else {
 134  0 
       jjtree.popNode();
 135   
     }
 136  0 
     if (jjte000 instanceof RuntimeException) {
 137  0 
       {if (true) throw (RuntimeException)jjte000;}
 138   
     }
 139  0 
     if (jjte000 instanceof ParseException) {
 140  0 
       {if (true) throw (ParseException)jjte000;}
 141   
     }
 142  0 
     {if (true) throw (Error)jjte000;}
 143   
     } finally {
 144  97 
     if (jjtc000) {
 145  97 
       jjtree.closeNodeScope(jjtn000, true);
 146   
     }
 147   
     }
 148  97 
   }
 149   
 
 150   
   final public void Action() throws ParseException {
 151  124 
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 152   
     case ACTION_TRANSFORM:
 153  22 
       TransformAction();
 154  22 
       break;
 155   
     case ACTION_WRAP:
 156  40 
       WrapAction();
 157  40 
       break;
 158   
     case ACTION_TEMPLATE:
 159  21 
       TemplateAction();
 160  21 
       break;
 161   
     case ACTION_TRIGGER:
 162  38 
       TriggerAction();
 163  38 
       break;
 164   
     case ACTION_REPLACE:
 165  1 
       ReplaceAction();
 166  1 
       break;
 167   
     case ACTION_RESPONSE:
 168  2 
       ResponseAction();
 169  2 
       break;
 170   
     default:
 171  0 
       jj_la1[2] = jj_gen;
 172  0 
       jj_consume_token(-1);
 173  0 
       throw new ParseException();
 174   
     }
 175  124 
     jj_consume_token(ACTION_END);
 176  124 
   }
 177   
 
 178   
   final public void TransformAction() throws ParseException {
 179   
  /*@bgen(jjtree) Action */
 180  22 
   CSSAction jjtn000 = new CSSAction(this, JJTACTION);
 181  22 
   boolean jjtc000 = true;
 182  22 
   jjtree.openNodeScope(jjtn000);
 183   
     try {
 184  22 
       jj_consume_token(ACTION_TRANSFORM);
 185  22 
       jj_consume_token(ACTION_SEP);
 186  22 
       Values();
 187  22 
     jjtree.closeNodeScope(jjtn000, true);
 188  22 
     jjtc000 = false;
 189  22 
     jjtn000.setAction(Action.TRANSFORM);
 190  0 
     } catch (Throwable jjte000) {
 191  0 
     if (jjtc000) {
 192  0 
       jjtree.clearNodeScope(jjtn000);
 193  0 
       jjtc000 = false;
 194   
     } else {
 195  0 
       jjtree.popNode();
 196   
     }
 197  0 
     if (jjte000 instanceof RuntimeException) {
 198  0 
       {if (true) throw (RuntimeException)jjte000;}
 199   
     }
 200  0 
     if (jjte000 instanceof ParseException) {
 201  0 
       {if (true) throw (ParseException)jjte000;}
 202   
     }
 203  0 
     {if (true) throw (Error)jjte000;}
 204   
     } finally {
 205  22 
     if (jjtc000) {
 206  0 
       jjtree.closeNodeScope(jjtn000, true);
 207   
     }
 208   
     }
 209  22 
   }
 210   
 
 211   
   final public void WrapAction() throws ParseException {
 212   
  /*@bgen(jjtree) Action */
 213  40 
   CSSAction jjtn000 = new CSSAction(this, JJTACTION);
 214  40 
   boolean jjtc000 = true;
 215  40 
   jjtree.openNodeScope(jjtn000);
 216   
     try {
 217  40 
       jj_consume_token(ACTION_WRAP);
 218  40 
       jj_consume_token(ACTION_SEP);
 219  40 
       Values();
 220  40 
     jjtree.closeNodeScope(jjtn000, true);
 221  40 
     jjtc000 = false;
 222  40 
     jjtn000.setAction(Action.WRAP);
 223  0 
     } catch (Throwable jjte000) {
 224  0 
     if (jjtc000) {
 225  0 
       jjtree.clearNodeScope(jjtn000);
 226  0 
       jjtc000 = false;
 227   
     } else {
 228  0 
       jjtree.popNode();
 229   
     }
 230  0 
     if (jjte000 instanceof RuntimeException) {
 231  0 
       {if (true) throw (RuntimeException)jjte000;}
 232   
     }
 233  0 
     if (jjte000 instanceof ParseException) {
 234  0 
       {if (true) throw (ParseException)jjte000;}
 235   
     }
 236  0 
     {if (true) throw (Error)jjte000;}
 237   
     } finally {
 238  40 
     if (jjtc000) {
 239  0 
       jjtree.closeNodeScope(jjtn000, true);
 240   
     }
 241   
     }
 242  40 
   }
 243   
 
 244   
   final public void TemplateAction() throws ParseException {
 245   
  /*@bgen(jjtree) Action */
 246  21 
   CSSAction jjtn000 = new CSSAction(this, JJTACTION);
 247  21 
   boolean jjtc000 = true;
 248  21 
   jjtree.openNodeScope(jjtn000);
 249   
     try {
 250  21 
       jj_consume_token(ACTION_TEMPLATE);
 251  21 
       jj_consume_token(ACTION_SEP);
 252  21 
       Values();
 253  21 
     jjtree.closeNodeScope(jjtn000, true);
 254  21 
     jjtc000 = false;
 255  21 
     jjtn000.setAction(Action.TEMPLATE);
 256  0 
     } catch (Throwable jjte000) {
 257  0 
     if (jjtc000) {
 258  0 
       jjtree.clearNodeScope(jjtn000);
 259  0 
       jjtc000 = false;
 260   
     } else {
 261  0 
       jjtree.popNode();
 262   
     }
 263  0 
     if (jjte000 instanceof RuntimeException) {
 264  0 
       {if (true) throw (RuntimeException)jjte000;}
 265   
     }
 266  0 
     if (jjte000 instanceof ParseException) {
 267  0 
       {if (true) throw (ParseException)jjte000;}
 268   
     }
 269  0 
     {if (true) throw (Error)jjte000;}
 270   
     } finally {
 271  21 
     if (jjtc000) {
 272  0 
       jjtree.closeNodeScope(jjtn000, true);
 273   
     }
 274   
     }
 275  21 
   }
 276   
 
 277   
   final public void TriggerAction() throws ParseException {
 278   
  /*@bgen(jjtree) Action */
 279  38 
   CSSAction jjtn000 = new CSSAction(this, JJTACTION);
 280  38 
   boolean jjtc000 = true;
 281  38 
   jjtree.openNodeScope(jjtn000);
 282   
     try {
 283  38 
       jj_consume_token(ACTION_TRIGGER);
 284  38 
       jj_consume_token(ACTION_SEP);
 285  38 
       Values();
 286  38 
     jjtree.closeNodeScope(jjtn000, true);
 287  38 
     jjtc000 = false;
 288  38 
     jjtn000.setAction(Action.TRIGGER);
 289  0 
     } catch (Throwable jjte000) {
 290  0 
     if (jjtc000) {
 291  0 
       jjtree.clearNodeScope(jjtn000);
 292  0 
       jjtc000 = false;
 293   
     } else {
 294  0 
       jjtree.popNode();
 295   
     }
 296  0 
     if (jjte000 instanceof RuntimeException) {
 297  0 
       {if (true) throw (RuntimeException)jjte000;}
 298   
     }
 299  0 
     if (jjte000 instanceof ParseException) {
 300  0 
       {if (true) throw (ParseException)jjte000;}
 301   
     }
 302  0 
     {if (true) throw (Error)jjte000;}
 303   
     } finally {
 304  38 
     if (jjtc000) {
 305  0 
       jjtree.closeNodeScope(jjtn000, true);
 306   
     }
 307   
     }
 308  38 
   }
 309   
 
 310   
   final public void ReplaceAction() throws ParseException {
 311   
  /*@bgen(jjtree) Action */
 312  1 
   CSSAction jjtn000 = new CSSAction(this, JJTACTION);
 313  1 
   boolean jjtc000 = true;
 314  1 
   jjtree.openNodeScope(jjtn000);
 315   
     try {
 316  1 
       jj_consume_token(ACTION_REPLACE);
 317  1 
       jj_consume_token(ACTION_SEP);
 318  1 
       StringValues();
 319  1 
                                                  jjtree.closeNodeScope(jjtn000, true);
 320  1 
                                                  jjtc000 = false;
 321  1 
                                                  jjtn000.setAction(Action.REPLACE);
 322  0 
     } catch (Throwable jjte000) {
 323  0 
     if (jjtc000) {
 324  0 
       jjtree.clearNodeScope(jjtn000);
 325  0 
       jjtc000 = false;
 326   
     } else {
 327  0 
       jjtree.popNode();
 328   
     }
 329  0 
     if (jjte000 instanceof RuntimeException) {
 330  0 
       {if (true) throw (RuntimeException)jjte000;}
 331   
     }
 332  0 
     if (jjte000 instanceof ParseException) {
 333  0 
       {if (true) throw (ParseException)jjte000;}
 334   
     }
 335  0 
     {if (true) throw (Error)jjte000;}
 336   
     } finally {
 337  1 
     if (jjtc000) {
 338  0 
       jjtree.closeNodeScope(jjtn000, true);
 339   
     }
 340   
     }
 341  1 
   }
 342   
 
 343   
   final public void ResponseAction() throws ParseException {
 344   
  /*@bgen(jjtree) ResponseAction */
 345  2 
   CSSResponseAction jjtn000 = new CSSResponseAction(this, JJTRESPONSEACTION);
 346  2 
   boolean jjtc000 = true;
 347  2 
   jjtree.openNodeScope(jjtn000);
 348   
     try {
 349  2 
       jj_consume_token(ACTION_RESPONSE);
 350  2 
       jj_consume_token(ACTION_SEP);
 351  2 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 352   
       case NUMBER:
 353  1 
         jj_consume_token(NUMBER);
 354  1 
                jjtree.closeNodeScope(jjtn000, true);
 355  1 
                jjtc000 = false;
 356  1 
                jjtn000.setNumber(getToken(0).image);
 357  1 
         break;
 358   
       case KEYWORD_NONE:
 359  1 
         jj_consume_token(KEYWORD_NONE);
 360  1 
         break;
 361   
       default:
 362  0 
         jj_la1[3] = jj_gen;
 363  0 
         jj_consume_token(-1);
 364  0 
         throw new ParseException();
 365   
       }
 366   
     } finally {
 367  2 
     if (jjtc000) {
 368  1 
       jjtree.closeNodeScope(jjtn000, true);
 369   
     }
 370   
     }
 371  2 
   }
 372   
 
 373   
   final public void Values() throws ParseException {
 374  121 
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 375   
     case RESOLVE_START:
 376  43 
       ResolveValue();
 377  43 
       break;
 378   
     case THEME_START:
 379   
     case QUOTE_START:
 380   
     case LOOKUP:
 381   
     case SPLIT_START:
 382   
     case KEYWORD_NONE:
 383  78 
       ListValues();
 384  78 
       break;
 385   
     default:
 386  0 
       jj_la1[4] = jj_gen;
 387  0 
       jj_consume_token(-1);
 388  0 
       throw new ParseException();
 389   
     }
 390  121 
   }
 391   
 
 392   
   final public void ListValues() throws ParseException {
 393  164 
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 394   
     case SPLIT_START:
 395  23 
       SplitValue();
 396  23 
       break;
 397   
     case THEME_START:
 398   
     case QUOTE_START:
 399   
     case LOOKUP:
 400   
     case KEYWORD_NONE:
 401  141 
       StringValues();
 402  141 
       break;
 403   
     default:
 404  0 
       jj_la1[5] = jj_gen;
 405  0 
       jj_consume_token(-1);
 406  0 
       throw new ParseException();
 407   
     }
 408  164 
   }
 409   
 
 410   
   final public void StringValues() throws ParseException {
 411  165 
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 412   
     case LOOKUP:
 413  87 
       LookupValue();
 414  87 
       break;
 415   
     case THEME_START:
 416  43 
       ThemeValue();
 417  43 
       break;
 418   
     case QUOTE_START:
 419   
     case KEYWORD_NONE:
 420  35 
       ConstantValues();
 421  35 
       break;
 422   
     default:
 423  0 
       jj_la1[6] = jj_gen;
 424  0 
       jj_consume_token(-1);
 425  0 
       throw new ParseException();
 426   
     }
 427  165 
   }
 428   
 
 429   
   final public void ConstantValues() throws ParseException {
 430  35 
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 431   
     case KEYWORD_NONE:
 432  19 
       jj_consume_token(KEYWORD_NONE);
 433  19 
       break;
 434   
     case QUOTE_START:
 435  16 
       StringValue();
 436  16 
       break;
 437   
     default:
 438  0 
       jj_la1[7] = jj_gen;
 439  0 
       jj_consume_token(-1);
 440  0 
       throw new ParseException();
 441   
     }
 442  35 
   }
 443   
 
 444   
   final public void StringValue() throws ParseException {
 445   
  /*@bgen(jjtree) StringValue */
 446  16 
   CSSStringValue jjtn000 = new CSSStringValue(this, JJTSTRINGVALUE);
 447  16 
   boolean jjtc000 = true;
 448  16 
   jjtree.openNodeScope(jjtn000);String s;
 449   
     try {
 450  16 
       s = Quoted();
 451  16 
                jjtree.closeNodeScope(jjtn000, true);
 452  16 
                jjtc000 = false;
 453  16 
                jjtn000.setValue(s);
 454  0 
     } catch (Throwable jjte000) {
 455  0 
     if (jjtc000) {
 456  0 
       jjtree.clearNodeScope(jjtn000);
 457  0 
       jjtc000 = false;
 458   
     } else {
 459  0 
       jjtree.popNode();
 460   
     }
 461  0 
     if (jjte000 instanceof RuntimeException) {
 462  0 
       {if (true) throw (RuntimeException)jjte000;}
 463   
     }
 464  0 
     if (jjte000 instanceof ParseException) {
 465  0 
       {if (true) throw (ParseException)jjte000;}
 466   
     }
 467  0 
     {if (true) throw (Error)jjte000;}
 468   
     } finally {
 469  16 
     if (jjtc000) {
 470  0 
       jjtree.closeNodeScope(jjtn000, true);
 471   
     }
 472   
     }
 473  16 
   }
 474   
 
 475   
   final public void LookupValue() throws ParseException {
 476   
  /*@bgen(jjtree) LookupValue */
 477  87 
   CSSLookupValue jjtn000 = new CSSLookupValue(this, JJTLOOKUPVALUE);
 478  87 
   boolean jjtc000 = true;
 479  87 
   jjtree.openNodeScope(jjtn000);String s;
 480   
     try {
 481  87 
       jj_consume_token(LOOKUP);
 482  87 
       s = Quoted();
 483  87 
                jjtn000.setAttribute(s);
 484  87 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 485   
       case SEP:
 486  21 
         jj_consume_token(SEP);
 487  21 
         s = Quoted();
 488  21 
                       jjtn000.setDefault(s);
 489  21 
         break;
 490   
       default:
 491  66 
         jj_la1[8] = jj_gen;
 492   
         ;
 493   
       }
 494  87 
       jj_consume_token(CALL_END);
 495  0 
     } catch (Throwable jjte000) {
 496  0 
     if (jjtc000) {
 497  0 
       jjtree.clearNodeScope(jjtn000);
 498  0 
       jjtc000 = false;
 499   
     } else {
 500  0 
       jjtree.popNode();
 501   
     }
 502  0 
     if (jjte000 instanceof RuntimeException) {
 503  0 
       {if (true) throw (RuntimeException)jjte000;}
 504   
     }
 505  0 
     if (jjte000 instanceof ParseException) {
 506  0 
       {if (true) throw (ParseException)jjte000;}
 507   
     }
 508  0 
     {if (true) throw (Error)jjte000;}
 509   
     } finally {
 510  87 
     if (jjtc000) {
 511  87 
       jjtree.closeNodeScope(jjtn000, true);
 512   
     }
 513   
     }
 514  87 
   }
 515   
 
 516   
   final public void SplitValue() throws ParseException {
 517   
  /*@bgen(jjtree) SplitValue */
 518  23 
   CSSSplitValue jjtn000 = new CSSSplitValue(this, JJTSPLITVALUE);
 519  23 
   boolean jjtc000 = true;
 520  23 
   jjtree.openNodeScope(jjtn000);
 521   
     try {
 522  23 
       jj_consume_token(SPLIT_START);
 523  23 
       StringValues();
 524  23 
       jj_consume_token(CALL_END);
 525  0 
     } catch (Throwable jjte000) {
 526  0 
     if (jjtc000) {
 527  0 
       jjtree.clearNodeScope(jjtn000);
 528  0 
       jjtc000 = false;
 529   
     } else {
 530  0 
       jjtree.popNode();
 531   
     }
 532  0 
     if (jjte000 instanceof RuntimeException) {
 533  0 
       {if (true) throw (RuntimeException)jjte000;}
 534   
     }
 535  0 
     if (jjte000 instanceof ParseException) {
 536  0 
       {if (true) throw (ParseException)jjte000;}
 537   
     }
 538  0 
     {if (true) throw (Error)jjte000;}
 539   
     } finally {
 540  23 
     if (jjtc000) {
 541  23 
       jjtree.closeNodeScope(jjtn000, true);
 542   
     }
 543   
     }
 544  23 
   }
 545   
 
 546   
   final public void ResolveValue() throws ParseException {
 547   
  /*@bgen(jjtree) ResolveValue */
 548  43 
   CSSResolveValue jjtn000 = new CSSResolveValue(this, JJTRESOLVEVALUE);
 549  43 
   boolean jjtc000 = true;
 550  43 
   jjtree.openNodeScope(jjtn000);
 551   
     try {
 552  43 
       jj_consume_token(RESOLVE_START);
 553  43 
       ListValues();
 554  43 
       jj_consume_token(SEP);
 555  43 
       ListValues();
 556  43 
       jj_consume_token(CALL_END);
 557  0 
     } catch (Throwable jjte000) {
 558  0 
     if (jjtc000) {
 559  0 
       jjtree.clearNodeScope(jjtn000);
 560  0 
       jjtc000 = false;
 561   
     } else {
 562  0 
       jjtree.popNode();
 563   
     }
 564  0 
     if (jjte000 instanceof RuntimeException) {
 565  0 
       {if (true) throw (RuntimeException)jjte000;}
 566   
     }
 567  0 
     if (jjte000 instanceof ParseException) {
 568  0 
       {if (true) throw (ParseException)jjte000;}
 569   
     }
 570  0 
     {if (true) throw (Error)jjte000;}
 571   
     } finally {
 572  43 
     if (jjtc000) {
 573  43 
       jjtree.closeNodeScope(jjtn000, true);
 574   
     }
 575   
     }
 576  43 
   }
 577   
 
 578   
   final public void Selectors() throws ParseException {
 579  97 
     Selector();
 580   
     label_4:
 581   
     while (true) {
 582  116 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 583   
       case SEP:
 584   
         ;
 585  19 
         break;
 586   
       default:
 587  97 
         jj_la1[9] = jj_gen;
 588  97 
         break label_4;
 589   
       }
 590  19 
       jj_consume_token(SEP);
 591  19 
       Selector();
 592   
     }
 593  97 
   }
 594   
 
 595   
   final public void Selector() throws ParseException {
 596   
  /*@bgen(jjtree) Selector */
 597  116 
   CSSSelector jjtn000 = new CSSSelector(this, JJTSELECTOR);
 598  116 
   boolean jjtc000 = true;
 599  116 
   jjtree.openNodeScope(jjtn000);
 600   
     try {
 601  116 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 602   
       case ROOT:
 603  1 
         Root();
 604  1 
         break;
 605   
       case CHILD:
 606   
       case SIBLING:
 607   
       case TYPE:
 608   
       case CLASS:
 609   
       case ALL:
 610   
       case ATTRIBUTE_START:
 611   
       case COMMAND_START:
 612   
       case MODE_START:
 613   
       case REQ_ATTR_START:
 614   
       case REQ_PARAM_START:
 615   
       case REGEX_START:
 616   
       case THEME_START:
 617   
       case QUOTE_START:
 618   
         label_5:
 619   
         while (true) {
 620  115 
           ComponentSegment();
 621  115 
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 622   
           case CHILD:
 623   
           case SIBLING:
 624   
           case TYPE:
 625   
           case CLASS:
 626   
           case ALL:
 627   
           case ATTRIBUTE_START:
 628   
           case COMMAND_START:
 629   
           case MODE_START:
 630   
           case REQ_ATTR_START:
 631   
           case REQ_PARAM_START:
 632   
           case REGEX_START:
 633   
           case THEME_START:
 634   
           case QUOTE_START:
 635   
             ;
 636  0 
             break;
 637   
           default:
 638  115 
             jj_la1[10] = jj_gen;
 639  115 
             break label_5;
 640   
           }
 641   
         }
 642   
         break;
 643   
       default:
 644  0 
         jj_la1[11] = jj_gen;
 645  0 
         jj_consume_token(-1);
 646  0 
         throw new ParseException();
 647   
       }
 648  0 
     } catch (Throwable jjte000) {
 649  0 
     if (jjtc000) {
 650  0 
       jjtree.clearNodeScope(jjtn000);
 651  0 
       jjtc000 = false;
 652   
     } else {
 653  0 
       jjtree.popNode();
 654   
     }
 655  0 
     if (jjte000 instanceof RuntimeException) {
 656  0 
       {if (true) throw (RuntimeException)jjte000;}
 657   
     }
 658  0 
     if (jjte000 instanceof ParseException) {
 659  0 
       {if (true) throw (ParseException)jjte000;}
 660   
     }
 661  0 
     {if (true) throw (Error)jjte000;}
 662   
     } finally {
 663  116 
     if (jjtc000) {
 664  116 
       jjtree.closeNodeScope(jjtn000, true);
 665   
     }
 666   
     }
 667  116 
   }
 668   
 
 669   
   final public void Root() throws ParseException {
 670   
  /*@bgen(jjtree) Root */
 671  1 
   CSSRoot jjtn000 = new CSSRoot(this, JJTROOT);
 672  1 
   boolean jjtc000 = true;
 673  1 
   jjtree.openNodeScope(jjtn000);
 674   
     try {
 675  1 
       jj_consume_token(ROOT);
 676   
       label_6:
 677   
       while (true) {
 678  1 
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 679   
         case CHILD:
 680   
         case SIBLING:
 681   
         case TYPE:
 682   
         case CLASS:
 683   
         case ALL:
 684   
         case ATTRIBUTE_START:
 685   
         case COMMAND_START:
 686   
         case MODE_START:
 687   
         case REQ_ATTR_START:
 688   
         case REQ_PARAM_START:
 689   
         case REGEX_START:
 690   
         case THEME_START:
 691   
         case QUOTE_START:
 692   
           ;
 693  0 
           break;
 694   
         default:
 695  1 
           jj_la1[12] = jj_gen;
 696  1 
           break label_6;
 697   
         }
 698  0 
         ComponentSegment();
 699   
       }
 700  0 
     } catch (Throwable jjte000) {
 701  0 
     if (jjtc000) {
 702  0 
       jjtree.clearNodeScope(jjtn000);
 703  0 
       jjtc000 = false;
 704   
     } else {
 705  0 
       jjtree.popNode();
 706   
     }
 707  0 
     if (jjte000 instanceof RuntimeException) {
 708  0 
       {if (true) throw (RuntimeException)jjte000;}
 709   
     }
 710  0 
     if (jjte000 instanceof ParseException) {
 711  0 
       {if (true) throw (ParseException)jjte000;}
 712   
     }
 713  0 
     {if (true) throw (Error)jjte000;}
 714   
     } finally {
 715  1 
     if (jjtc000) {
 716  1 
       jjtree.closeNodeScope(jjtn000, true);
 717   
     }
 718   
     }
 719  1 
   }
 720   
 
 721   
   final public void ComponentSegment() throws ParseException {
 722  120 
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 723   
     case CHILD:
 724  4 
       Child();
 725  4 
       break;
 726   
     case SIBLING:
 727  1 
       Sibling();
 728  1 
       break;
 729   
     case TYPE:
 730   
     case CLASS:
 731   
     case ALL:
 732   
     case ATTRIBUTE_START:
 733   
     case COMMAND_START:
 734   
     case MODE_START:
 735   
     case REQ_ATTR_START:
 736   
     case REQ_PARAM_START:
 737   
     case REGEX_START:
 738   
     case THEME_START:
 739   
     case QUOTE_START:
 740  115 
       Component();
 741  115 
       break;
 742   
     default:
 743  0 
       jj_la1[13] = jj_gen;
 744  0 
       jj_consume_token(-1);
 745  0 
       throw new ParseException();
 746   
     }
 747  120 
   }
 748   
 
 749   
   final public void Component() throws ParseException {
 750  120 
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 751   
     case REGEX_START:
 752   
     case THEME_START:
 753   
     case QUOTE_START:
 754  13 
       PathSelector();
 755  13 
       break;
 756   
     case TYPE:
 757   
     case CLASS:
 758   
     case ALL:
 759   
     case ATTRIBUTE_START:
 760   
     case COMMAND_START:
 761  86 
       AllSelector();
 762  86 
       break;
 763   
     case MODE_START:
 764  20 
       ModeSelector();
 765  20 
       break;
 766   
     case REQ_ATTR_START:
 767  1 
       ReqAttrSelector();
 768  1 
       break;
 769   
     case REQ_PARAM_START:
 770  0 
       ReqParamSelector();
 771  0 
       break;
 772   
     default:
 773  0 
       jj_la1[14] = jj_gen;
 774  0 
       jj_consume_token(-1);
 775  0 
       throw new ParseException();
 776   
     }
 777  120 
   }
 778   
 
 779   
   final public void ReqAttrSelector() throws ParseException {
 780   
  /*@bgen(jjtree) ReqAttrSelector */
 781  1 
   CSSReqAttrSelector jjtn000 = new CSSReqAttrSelector(this, JJTREQATTRSELECTOR);
 782  1 
   boolean jjtc000 = true;
 783  1 
   jjtree.openNodeScope(jjtn000);String s;
 784   
     try {
 785  1 
       jj_consume_token(REQ_ATTR_START);
 786  1 
       s = Quoted();
 787  1 
                jjtn000.setName(s);
 788  1 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 789   
       case OPERATOR_EQUALS:
 790   
       case OPERATOR_CONTAINS:
 791  0 
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 792   
         case OPERATOR_EQUALS:
 793  0 
           jj_consume_token(OPERATOR_EQUALS);
 794  0 
                                   jjtn000.setOperator(Operator.EQUALS);
 795  0 
           break;
 796   
         case OPERATOR_CONTAINS:
 797  0 
           jj_consume_token(OPERATOR_CONTAINS);
 798  0 
                                   jjtn000.setOperator(Operator.CONTAINS);
 799  0 
           break;
 800   
         default:
 801  0 
           jj_la1[15] = jj_gen;
 802  0 
           jj_consume_token(-1);
 803  0 
           throw new ParseException();
 804   
         }
 805  0 
         s = Quoted();
 806  0 
                  jjtn000.setValue(s);
 807  0 
         break;
 808   
       default:
 809  1 
         jj_la1[16] = jj_gen;
 810   
         ;
 811   
       }
 812  1 
       jj_consume_token(CALL_END);
 813  1 
       SelectorRest();
 814  0 
     } catch (Throwable jjte000) {
 815  0 
     if (jjtc000) {
 816  0 
       jjtree.clearNodeScope(jjtn000);
 817  0 
       jjtc000 = false;
 818   
     } else {
 819  0 
       jjtree.popNode();
 820   
     }
 821  0 
     if (jjte000 instanceof RuntimeException) {
 822  0 
       {if (true) throw (RuntimeException)jjte000;}
 823   
     }
 824  0 
     if (jjte000 instanceof ParseException) {
 825  0 
       {if (true) throw (ParseException)jjte000;}
 826   
     }
 827  0 
     {if (true) throw (Error)jjte000;}
 828   
     } finally {
 829  1 
     if (jjtc000) {
 830  1 
       jjtree.closeNodeScope(jjtn000, true);
 831   
     }
 832   
     }
 833  1 
   }
 834   
 
 835   
   final public void ReqParamSelector() throws ParseException {
 836   
  /*@bgen(jjtree) ReqParamSelector */
 837  0 
   CSSReqParamSelector jjtn000 = new CSSReqParamSelector(this, JJTREQPARAMSELECTOR);
 838  0 
   boolean jjtc000 = true;
 839  0 
   jjtree.openNodeScope(jjtn000);String s;
 840   
     try {
 841  0 
       jj_consume_token(REQ_PARAM_START);
 842  0 
       s = Quoted();
 843  0 
                jjtn000.setName(s);
 844  0 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 845   
       case OPERATOR_EQUALS:
 846   
       case OPERATOR_CONTAINS:
 847  0 
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 848   
         case OPERATOR_EQUALS:
 849  0 
           jj_consume_token(OPERATOR_EQUALS);
 850  0 
                                   jjtn000.setOperator(Operator.EQUALS);
 851  0 
           break;
 852   
         case OPERATOR_CONTAINS:
 853  0 
           jj_consume_token(OPERATOR_CONTAINS);
 854  0 
                                   jjtn000.setOperator(Operator.CONTAINS);
 855  0 
           break;
 856   
         default:
 857  0 
           jj_la1[17] = jj_gen;
 858  0 
           jj_consume_token(-1);
 859  0 
           throw new ParseException();
 860   
         }
 861  0 
         s = Quoted();
 862  0 
                  jjtn000.setValue(s);
 863  0 
         break;
 864   
       default:
 865  0 
         jj_la1[18] = jj_gen;
 866   
         ;
 867   
       }
 868  0 
       jj_consume_token(CALL_END);
 869  0 
       SelectorRest();
 870  0 
     } catch (Throwable jjte000) {
 871  0 
     if (jjtc000) {
 872  0 
       jjtree.clearNodeScope(jjtn000);
 873  0 
       jjtc000 = false;
 874   
     } else {
 875  0 
       jjtree.popNode();
 876   
     }
 877  0 
     if (jjte000 instanceof RuntimeException) {
 878  0 
       {if (true) throw (RuntimeException)jjte000;}
 879   
     }
 880  0 
     if (jjte000 instanceof ParseException) {
 881  0 
       {if (true) throw (ParseException)jjte000;}
 882   
     }
 883  0 
     {if (true) throw (Error)jjte000;}
 884   
     } finally {
 885  0 
     if (jjtc000) {
 886  0 
       jjtree.closeNodeScope(jjtn000, true);
 887   
     }
 888   
     }
 889  0 
   }
 890   
 
 891   
   final public void ModeSelector() throws ParseException {
 892   
  /*@bgen(jjtree) ModeSelector */
 893  20 
   CSSModeSelector jjtn000 = new CSSModeSelector(this, JJTMODESELECTOR);
 894  20 
   boolean jjtc000 = true;
 895  20 
   jjtree.openNodeScope(jjtn000);
 896   
     try {
 897  20 
       jj_consume_token(MODE_START);
 898  20 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 899   
       case MODE_CAPTURE:
 900  19 
         jj_consume_token(MODE_CAPTURE);
 901  19 
                      jjtn000.setAction(Action.CAPTURE);
 902  19 
         break;
 903   
       case MODE_CONTENT:
 904  1 
         jj_consume_token(MODE_CONTENT);
 905  1 
                      jjtn000.setAction(Action.CONTENT);
 906  1 
         break;
 907   
       case MODE_REPLACE:
 908  0 
         jj_consume_token(MODE_REPLACE);
 909  0 
                      jjtn000.setAction(Action.REPLACE);
 910  0 
         break;
 911   
       case MODE_RESPONSE:
 912  0 
         jj_consume_token(MODE_RESPONSE);
 913  0 
                       jjtn000.setAction(Action.RESPONSE);
 914  0 
         break;
 915   
       case MODE_TEMPLATE:
 916  0 
         jj_consume_token(MODE_TEMPLATE);
 917  0 
                       jjtn000.setAction(Action.TEMPLATE);
 918  0 
         break;
 919   
       case MODE_TRANSFORM:
 920  0 
         jj_consume_token(MODE_TRANSFORM);
 921  0 
                        jjtn000.setAction(Action.TRANSFORM);
 922  0 
         break;
 923   
       case MODE_TRIGGER:
 924  0 
         jj_consume_token(MODE_TRIGGER);
 925  0 
                      jjtn000.setAction(Action.TRIGGER);
 926  0 
         break;
 927   
       case MODE_WRAP:
 928  0 
         jj_consume_token(MODE_WRAP);
 929  0 
                   jjtn000.setAction(Action.WRAP);
 930  0 
         break;
 931   
       default:
 932  0 
         jj_la1[19] = jj_gen;
 933  0 
         jj_consume_token(-1);
 934  0 
         throw new ParseException();
 935   
       }
 936  20 
       jj_consume_token(CALL_END);
 937  20 
       SelectorRest();
 938  0 
     } catch (Throwable jjte000) {
 939  0 
     if (jjtc000) {
 940  0 
       jjtree.clearNodeScope(jjtn000);
 941  0 
       jjtc000 = false;
 942   
     } else {
 943  0 
       jjtree.popNode();
 944   
     }
 945  0 
     if (jjte000 instanceof RuntimeException) {
 946  0 
       {if (true) throw (RuntimeException)jjte000;}
 947   
     }
 948  0 
     if (jjte000 instanceof ParseException) {
 949  0 
       {if (true) throw (ParseException)jjte000;}
 950   
     }
 951  0 
     {if (true) throw (Error)jjte000;}
 952   
     } finally {
 953  20 
     if (jjtc000) {
 954  20 
       jjtree.closeNodeScope(jjtn000, true);
 955   
     }
 956   
     }
 957  20 
   }
 958   
 
 959   
   final public void SelectorRest() throws ParseException {
 960   
     label_7:
 961   
     while (true) {
 962  138 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 963   
       case TYPE:
 964   
       case CLASS:
 965   
       case ATTRIBUTE_START:
 966   
       case COMMAND_START:
 967   
         ;
 968  18 
         break;
 969   
       default:
 970  120 
         jj_la1[20] = jj_gen;
 971  120 
         break label_7;
 972   
       }
 973  18 
       Restrictions();
 974   
     }
 975   
     label_8:
 976   
     while (true) {
 977  125 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 978   
       case CHILD:
 979   
       case SIBLING:
 980   
       case TYPE:
 981   
       case CLASS:
 982   
       case ALL:
 983   
       case ATTRIBUTE_START:
 984   
       case COMMAND_START:
 985   
       case MODE_START:
 986   
       case REQ_ATTR_START:
 987   
       case REQ_PARAM_START:
 988   
       case REGEX_START:
 989   
       case THEME_START:
 990   
       case QUOTE_START:
 991   
         ;
 992  5 
         break;
 993   
       default:
 994  120 
         jj_la1[21] = jj_gen;
 995  120 
         break label_8;
 996   
       }
 997  5 
       ComponentSegment();
 998   
     }
 999  120 
   }
 1000   
 
 1001   
   final public void AllSelector() throws ParseException {
 1002   
  /*@bgen(jjtree) AllSelector */
 1003  86 
   CSSAllSelector jjtn000 = new CSSAllSelector(this, JJTALLSELECTOR);
 1004  86 
   boolean jjtc000 = true;
 1005  86 
   jjtree.openNodeScope(jjtn000);
 1006   
     try {
 1007  86 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1008   
       case ALL:
 1009  24 
         jj_consume_token(ALL);
 1010  24 
         break;
 1011   
       case TYPE:
 1012   
       case CLASS:
 1013   
       case ATTRIBUTE_START:
 1014   
       case COMMAND_START:
 1015  62 
         Restrictions();
 1016  62 
         break;
 1017   
       default:
 1018  0 
         jj_la1[22] = jj_gen;
 1019  0 
         jj_consume_token(-1);
 1020  0 
         throw new ParseException();
 1021   
       }
 1022  86 
       SelectorRest();
 1023  0 
     } catch (Throwable jjte000) {
 1024  0 
     if (jjtc000) {
 1025  0 
       jjtree.clearNodeScope(jjtn000);
 1026  0 
       jjtc000 = false;
 1027   
     } else {
 1028  0 
       jjtree.popNode();
 1029   
     }
 1030  0 
     if (jjte000 instanceof RuntimeException) {
 1031  0 
       {if (true) throw (RuntimeException)jjte000;}
 1032   
     }
 1033  0 
     if (jjte000 instanceof ParseException) {
 1034  0 
       {if (true) throw (ParseException)jjte000;}
 1035   
     }
 1036  0 
     {if (true) throw (Error)jjte000;}
 1037   
     } finally {
 1038  86 
     if (jjtc000) {
 1039  86 
       jjtree.closeNodeScope(jjtn000, true);
 1040   
     }
 1041   
     }
 1042  86 
   }
 1043   
 
 1044   
   final public void AttributeRestriction() throws ParseException {
 1045   
  /*@bgen(jjtree) AttributeRestriction */
 1046  21 
   CSSAttributeRestriction jjtn000 = new CSSAttributeRestriction(this, JJTATTRIBUTERESTRICTION);
 1047  21 
   boolean jjtc000 = true;
 1048  21 
   jjtree.openNodeScope(jjtn000);String s;
 1049   
     try {
 1050  21 
       jj_consume_token(ATTRIBUTE_START);
 1051  21 
       s = Quoted();
 1052  21 
                jjtn000.setName(s);
 1053  21 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1054   
       case OPERATOR_EQUALS:
 1055   
       case OPERATOR_CONTAINS:
 1056  20 
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1057   
         case OPERATOR_EQUALS:
 1058  1 
           jj_consume_token(OPERATOR_EQUALS);
 1059  1 
                                   jjtn000.setOperator(Operator.EQUALS);
 1060  1 
           break;
 1061   
         case OPERATOR_CONTAINS:
 1062  19 
           jj_consume_token(OPERATOR_CONTAINS);
 1063  19 
                                   jjtn000.setOperator(Operator.CONTAINS);
 1064  19 
           break;
 1065   
         default:
 1066  0 
           jj_la1[23] = jj_gen;
 1067  0 
           jj_consume_token(-1);
 1068  0 
           throw new ParseException();
 1069   
         }
 1070  20 
         s = Quoted();
 1071  20 
                  jjtn000.setValue(s);
 1072  20 
         break;
 1073   
       default:
 1074  1 
         jj_la1[24] = jj_gen;
 1075   
         ;
 1076   
       }
 1077  21 
       jj_consume_token(ATTRIBUTE_END);
 1078  0 
     } catch (Throwable jjte000) {
 1079  0 
     if (jjtc000) {
 1080  0 
       jjtree.clearNodeScope(jjtn000);
 1081  0 
       jjtc000 = false;
 1082   
     } else {
 1083  0 
       jjtree.popNode();
 1084   
     }
 1085  0 
     if (jjte000 instanceof RuntimeException) {
 1086  0 
       {if (true) throw (RuntimeException)jjte000;}
 1087   
     }
 1088  0 
     if (jjte000 instanceof ParseException) {
 1089  0 
       {if (true) throw (ParseException)jjte000;}
 1090   
     }
 1091  0 
     {if (true) throw (Error)jjte000;}
 1092   
     } finally {
 1093  21 
     if (jjtc000) {
 1094  21 
       jjtree.closeNodeScope(jjtn000, true);
 1095   
     }
 1096   
     }
 1097  21 
   }
 1098   
 
 1099   
   final public void Restrictions() throws ParseException {
 1100  80 
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1101   
     case TYPE:
 1102  40 
       TypeRestriction();
 1103  40 
       break;
 1104   
     case CLASS:
 1105  1 
       ClassRestriction();
 1106  1 
       break;
 1107   
     case ATTRIBUTE_START:
 1108  21 
       AttributeRestriction();
 1109  21 
       break;
 1110   
     case COMMAND_START:
 1111  18 
       CommandRestriction();
 1112  18 
       break;
 1113   
     default:
 1114  0 
       jj_la1[25] = jj_gen;
 1115  0 
       jj_consume_token(-1);
 1116  0 
       throw new ParseException();
 1117   
     }
 1118  80 
   }
 1119   
 
 1120   
   final public void PathSelector() throws ParseException {
 1121   
  /*@bgen(jjtree) PathSelector */
 1122  13 
   CSSPathSelector jjtn000 = new CSSPathSelector(this, JJTPATHSELECTOR);
 1123  13 
   boolean jjtc000 = true;
 1124  13 
   jjtree.openNodeScope(jjtn000);PathMatcher matcher;
 1125   
     try {
 1126  13 
       matcher = Matcher();
 1127  13 
                       jjtn000.setMatcher(matcher);
 1128  13 
       SelectorRest();
 1129  0 
     } catch (Throwable jjte000) {
 1130  0 
     if (jjtc000) {
 1131  0 
       jjtree.clearNodeScope(jjtn000);
 1132  0 
       jjtc000 = false;
 1133   
     } else {
 1134  0 
       jjtree.popNode();
 1135   
     }
 1136  0 
     if (jjte000 instanceof RuntimeException) {
 1137  0 
       {if (true) throw (RuntimeException)jjte000;}
 1138   
     }
 1139  0 
     if (jjte000 instanceof ParseException) {
 1140  0 
       {if (true) throw (ParseException)jjte000;}
 1141   
     }
 1142  0 
     {if (true) throw (Error)jjte000;}
 1143   
     } finally {
 1144  13 
     if (jjtc000) {
 1145  13 
       jjtree.closeNodeScope(jjtn000, true);
 1146   
     }
 1147   
     }
 1148  13 
   }
 1149   
 
 1150   
   final public PathMatcher Matcher() throws ParseException {
 1151   
   PathMatcher matcher;
 1152  13 
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1153   
     case REGEX_START:
 1154  2 
       matcher = RegexMatcher();
 1155  2 
       break;
 1156   
     case THEME_START:
 1157  1 
       matcher = ThemeMatcher(CONSTANT);
 1158  1 
       break;
 1159   
     case QUOTE_START:
 1160  10 
       matcher = ConstantMatcher(CONSTANT);
 1161  10 
       break;
 1162   
     default:
 1163  0 
       jj_la1[26] = jj_gen;
 1164  0 
       jj_consume_token(-1);
 1165  0 
       throw new ParseException();
 1166   
     }
 1167  13 
       {if (true) return matcher;}
 1168   
     throw new Error("Missing return statement in function");
 1169   
   }
 1170   
 
 1171   
   final public PathMatcher RegexMatcher() throws ParseException {
 1172   
   PathMatcher matcher;
 1173  2 
     jj_consume_token(REGEX_START);
 1174  2 
     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1175   
     case QUOTE_START:
 1176  1 
       matcher = ConstantMatcher(REGEX);
 1177  1 
       break;
 1178   
     case THEME_START:
 1179  1 
       matcher = ThemeMatcher(REGEX);
 1180  1 
       break;
 1181   
     default:
 1182  0 
       jj_la1[27] = jj_gen;
 1183  0 
       jj_consume_token(-1);
 1184  0 
       throw new ParseException();
 1185   
     }
 1186  2 
     jj_consume_token(CALL_END);
 1187  2 
     {if (true) return matcher;}
 1188   
     throw new Error("Missing return statement in function");
 1189   
   }
 1190   
 
 1191   
   final public PathMatcher ConstantMatcher(PathFactory factory) throws ParseException {
 1192   
   String s;
 1193  13 
     s = Quoted();
 1194  13 
                {if (true) return factory.getMatcher(s);}
 1195   
     throw new Error("Missing return statement in function");
 1196   
   }
 1197   
 
 1198   
   final public PathMatcher ThemeMatcher(PathFactory factory) throws ParseException {
 1199   
   PathMatcher matcher;
 1200  2 
     jj_consume_token(THEME_START);
 1201  2 
     matcher = ConstantMatcher(factory);
 1202  2 
     jj_consume_token(CALL_END);
 1203  2 
     {if (true) return new ThemeMatcher(matcher);}
 1204   
     throw new Error("Missing return statement in function");
 1205   
   }
 1206   
 
 1207   
   final public void ThemeValue() throws ParseException {
 1208   
  /*@bgen(jjtree) ThemeValue */
 1209  43 
   CSSThemeValue jjtn000 = new CSSThemeValue(this, JJTTHEMEVALUE);
 1210  43 
   boolean jjtc000 = true;
 1211  43 
   jjtree.openNodeScope(jjtn000);String s;
 1212   
     try {
 1213  43 
       jj_consume_token(THEME_START);
 1214  43 
       s = Quoted();
 1215  43 
                              jjtn000.setPath(s);
 1216  43 
       jj_consume_token(CALL_END);
 1217  0 
     } catch (Throwable jjte000) {
 1218  0 
     if (jjtc000) {
 1219  0 
       jjtree.clearNodeScope(jjtn000);
 1220  0 
       jjtc000 = false;
 1221   
     } else {
 1222  0 
       jjtree.popNode();
 1223   
     }
 1224  0 
     if (jjte000 instanceof RuntimeException) {
 1225  0 
       {if (true) throw (RuntimeException)jjte000;}
 1226   
     }
 1227  0 
     if (jjte000 instanceof ParseException) {
 1228  0 
       {if (true) throw (ParseException)jjte000;}
 1229   
     }
 1230  0 
     {if (true) throw (Error)jjte000;}
 1231   
     } finally {
 1232  43 
     if (jjtc000) {
 1233  43 
       jjtree.closeNodeScope(jjtn000, true);
 1234   
     }
 1235   
     }
 1236  43 
   }
 1237   
 
 1238   
   final public void Sibling() throws ParseException {
 1239   
  /*@bgen(jjtree) Sibling */
 1240  1 
   CSSSibling jjtn000 = new CSSSibling(this, JJTSIBLING);
 1241  1 
   boolean jjtc000 = true;
 1242  1 
   jjtree.openNodeScope(jjtn000);
 1243   
     try {
 1244  1 
       jj_consume_token(SIBLING);
 1245  1 
       Component();
 1246  0 
     } catch (Throwable jjte000) {
 1247  0 
     if (jjtc000) {
 1248  0 
       jjtree.clearNodeScope(jjtn000);
 1249  0 
       jjtc000 = false;
 1250   
     } else {
 1251  0 
       jjtree.popNode();
 1252   
     }
 1253  0 
     if (jjte000 instanceof RuntimeException) {
 1254  0 
       {if (true) throw (RuntimeException)jjte000;}
 1255   
     }
 1256  0 
     if (jjte000 instanceof ParseException) {
 1257  0 
       {if (true) throw (ParseException)jjte000;}
 1258   
     }
 1259  0 
     {if (true) throw (Error)jjte000;}
 1260   
     } finally {
 1261  1 
     if (jjtc000) {
 1262  1 
       jjtree.closeNodeScope(jjtn000, true);
 1263   
     }
 1264   
     }
 1265  1 
   }
 1266   
 
 1267   
   final public void Child() throws ParseException {
 1268   
  /*@bgen(jjtree) Child */
 1269  4 
   CSSChild jjtn000 = new CSSChild(this, JJTCHILD);
 1270  4 
   boolean jjtc000 = true;
 1271  4 
   jjtree.openNodeScope(jjtn000);
 1272   
     try {
 1273  4 
       jj_consume_token(CHILD);
 1274  4 
       Component();
 1275  0 
     } catch (Throwable jjte000) {
 1276  0 
     if (jjtc000) {
 1277  0 
       jjtree.clearNodeScope(jjtn000);
 1278  0 
       jjtc000 = false;
 1279   
     } else {
 1280  0 
       jjtree.popNode();
 1281   
     }
 1282  0 
     if (jjte000 instanceof RuntimeException) {
 1283  0 
       {if (true) throw (RuntimeException)jjte000;}
 1284   
     }
 1285  0 
     if (jjte000 instanceof ParseException) {
 1286  0 
       {if (true) throw (ParseException)jjte000;}
 1287   
     }
 1288  0 
     {if (true) throw (Error)jjte000;}
 1289   
     } finally {
 1290  4 
     if (jjtc000) {
 1291  4 
       jjtree.closeNodeScope(jjtn000, true);
 1292   
     }
 1293   
     }
 1294  4 
   }
 1295   
 
 1296   
   final public void TypeRestriction() throws ParseException {
 1297   
  /*@bgen(jjtree) AttributeRestriction */
 1298  40 
   CSSAttributeRestriction jjtn000 = new CSSAttributeRestriction(this, JJTATTRIBUTERESTRICTION);
 1299  40 
   boolean jjtc000 = true;
 1300  40 
   jjtree.openNodeScope(jjtn000);jjtn000.setName("type");
 1301  40 
   jjtn000.setOperator(Operator.EQUALS);
 1302   
   String s;
 1303   
     try {
 1304  40 
       jj_consume_token(TYPE);
 1305  40 
       s = Quoted();
 1306  40 
                       jjtree.closeNodeScope(jjtn000, true);
 1307  40 
                       jjtc000 = false;
 1308  40 
                       jjtn000.setValue(s);
 1309  0 
     } catch (Throwable jjte000) {
 1310  0 
     if (jjtc000) {
 1311  0 
       jjtree.clearNodeScope(jjtn000);
 1312  0 
       jjtc000 = false;
 1313   
     } else {
 1314  0 
       jjtree.popNode();
 1315   
     }
 1316  0 
     if (jjte000 instanceof RuntimeException) {
 1317  0 
       {if (true) throw (RuntimeException)jjte000;}
 1318   
     }
 1319  0 
     if (jjte000 instanceof ParseException) {
 1320  0 
       {if (true) throw (ParseException)jjte000;}
 1321   
     }
 1322  0 
     {if (true) throw (Error)jjte000;}
 1323   
     } finally {
 1324  40 
     if (jjtc000) {
 1325  0 
       jjtree.closeNodeScope(jjtn000, true);
 1326   
     }
 1327   
     }
 1328  40 
   }
 1329   
 
 1330   
   final public void ClassRestriction() throws ParseException {
 1331   
  /*@bgen(jjtree) AttributeRestriction */
 1332  1 
   CSSAttributeRestriction jjtn000 = new CSSAttributeRestriction(this, JJTATTRIBUTERESTRICTION);
 1333  1 
   boolean jjtc000 = true;
 1334  1 
   jjtree.openNodeScope(jjtn000);jjtn000.setName("class");
 1335  1 
   jjtn000.setOperator(Operator.CONTAINS);
 1336   
   String s;
 1337   
     try {
 1338  1 
       jj_consume_token(CLASS);
 1339  1 
       s = Quoted();
 1340  1 
                        jjtree.closeNodeScope(jjtn000, true);
 1341  1 
                        jjtc000 = false;
 1342  1 
                        jjtn000.setValue(s);
 1343  0 
     } catch (Throwable jjte000) {
 1344  0 
     if (jjtc000) {
 1345  0 
       jjtree.clearNodeScope(jjtn000);
 1346  0 
       jjtc000 = false;
 1347   
     } else {
 1348  0 
       jjtree.popNode();
 1349   
     }
 1350  0 
     if (jjte000 instanceof RuntimeException) {
 1351  0 
       {if (true) throw (RuntimeException)jjte000;}
 1352   
     }
 1353  0 
     if (jjte000 instanceof ParseException) {
 1354  0 
       {if (true) throw (ParseException)jjte000;}
 1355   
     }
 1356  0 
     {if (true) throw (Error)jjte000;}
 1357   
     } finally {
 1358  1 
     if (jjtc000) {
 1359  0 
       jjtree.closeNodeScope(jjtn000, true);
 1360   
     }
 1361   
     }
 1362  1 
   }
 1363   
 
 1364   
   final public void CommandRestriction() throws ParseException {
 1365   
  /*@bgen(jjtree) CommandRestriction */
 1366  18 
   CSSCommandRestriction jjtn000 = new CSSCommandRestriction(this, JJTCOMMANDRESTRICTION);
 1367  18 
   boolean jjtc000 = true;
 1368  18 
   jjtree.openNodeScope(jjtn000);String command;
 1369   
     try {
 1370  18 
       jj_consume_token(COMMAND_START);
 1371  18 
       command = Quoted();
 1372  18 
       jj_consume_token(CALL_END);
 1373  18 
                                                 jjtree.closeNodeScope(jjtn000, true);
 1374  18 
                                                 jjtc000 = false;
 1375  18 
                                                 jjtn000.setCommand(command);
 1376  0 
     } catch (Throwable jjte000) {
 1377  0 
     if (jjtc000) {
 1378  0 
       jjtree.clearNodeScope(jjtn000);
 1379  0 
       jjtc000 = false;
 1380   
     } else {
 1381  0 
       jjtree.popNode();
 1382   
     }
 1383  0 
     if (jjte000 instanceof RuntimeException) {
 1384  0 
       {if (true) throw (RuntimeException)jjte000;}
 1385   
     }
 1386  0 
     if (jjte000 instanceof ParseException) {
 1387  0 
       {if (true) throw (ParseException)jjte000;}
 1388   
     }
 1389  0 
     {if (true) throw (Error)jjte000;}
 1390   
     } finally {
 1391  18 
     if (jjtc000) {
 1392  0 
       jjtree.closeNodeScope(jjtn000, true);
 1393   
     }
 1394   
     }
 1395  18 
   }
 1396   
 
 1397   
   final public String Quoted() throws ParseException {
 1398  325 
   StringBuilder sb = new StringBuilder();
 1399  325 
     jj_consume_token(QUOTE_START);
 1400   
     label_9:
 1401   
     while (true) {
 1402  3473 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1403   
       case ESCAPED:
 1404   
       case TEXT:
 1405   
         ;
 1406  3148 
         break;
 1407   
       default:
 1408  325 
         jj_la1[28] = jj_gen;
 1409  325 
         break label_9;
 1410   
       }
 1411  3148 
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 1412   
       case TEXT:
 1413  3148 
         jj_consume_token(TEXT);
 1414  3148 
                           sb.append(getToken(0).image);
 1415  3148 
         break;
 1416   
       case ESCAPED:
 1417  0 
         jj_consume_token(ESCAPED);
 1418  0 
                                                                         sb.append(getToken(0).image);
 1419  0 
         break;
 1420   
       default:
 1421  0 
         jj_la1[29] = jj_gen;
 1422  0 
         jj_consume_token(-1);
 1423  0 
         throw new ParseException();
 1424   
       }
 1425   
     }
 1426  325 
     jj_consume_token(QUOTE_END);
 1427  325 
     {if (true) return sb.toString();}
 1428   
     throw new Error("Missing return statement in function");
 1429   
   }
 1430   
 
 1431   
   final private boolean jj_2_1(int xla) {
 1432  221 
     jj_la = xla; jj_lastpos = jj_scanpos = token;
 1433  221 
     try { return !jj_3_1(); }
 1434  124 
     catch(LookaheadSuccess ls) { return true; }
 1435  221 
     finally { jj_save(0, xla); }
 1436   
   }
 1437   
 
 1438   
   final private boolean jj_3R_21() {
 1439  100 
     if (jj_scan_token(ACTION_REPLACE)) return true;
 1440  1 
     if (jj_scan_token(ACTION_SEP)) return true;
 1441  1 
     if (jj_3R_24()) return true;
 1442  0 
     return false;
 1443   
   }
 1444   
 
 1445   
   final private boolean jj_3_1() {
 1446  221 
     if (jj_3R_10()) return true;
 1447  0 
     return false;
 1448   
   }
 1449   
 
 1450   
   final private boolean jj_3R_41() {
 1451  16 
     if (jj_scan_token(QUOTE_START)) return true;
 1452  0 
     return false;
 1453   
   }
 1454   
 
 1455   
   final private boolean jj_3R_33() {
 1456  57 
     if (jj_scan_token(LOOKUP)) return true;
 1457  0 
     return false;
 1458   
   }
 1459   
 
 1460   
   final private boolean jj_3R_29() {
 1461  35 
     if (jj_3R_34()) return true;
 1462  0 
     return false;
 1463   
   }
 1464   
 
 1465   
   final private boolean jj_3R_20() {
 1466  138 
     if (jj_scan_token(ACTION_TRIGGER)) return true;
 1467  38 
     if (jj_scan_token(ACTION_SEP)) return true;
 1468  38 
     if (jj_3R_23()) return true;
 1469  0 
     return false;
 1470   
   }
 1471   
 
 1472   
   final private boolean jj_3R_40() {
 1473  16 
     if (jj_3R_41()) return true;
 1474  0 
     return false;
 1475   
   }
 1476   
 
 1477   
   final private boolean jj_3R_37() {
 1478  56 
     if (jj_3R_24()) return true;
 1479  0 
     return false;
 1480   
   }
 1481   
 
 1482   
   final private boolean jj_3R_35() {
 1483   
     Token xsp;
 1484  35 
     xsp = jj_scanpos;
 1485  35 
     if (jj_scan_token(46)) {
 1486  16 
     jj_scanpos = xsp;
 1487  16 
     if (jj_3R_38()) return true;
 1488   
     }
 1489  0 
     return false;
 1490   
   }
 1491   
 
 1492   
   final private boolean jj_3R_19() {
 1493  159 
     if (jj_scan_token(ACTION_TEMPLATE)) return true;
 1494  21 
     if (jj_scan_token(ACTION_SEP)) return true;
 1495  21 
     if (jj_3R_23()) return true;
 1496  0 
     return false;
 1497   
   }
 1498   
 
 1499   
   final private boolean jj_3R_27() {
 1500  78 
     if (jj_3R_32()) return true;
 1501  0 
     return false;
 1502   
   }
 1503   
 
 1504   
   final private boolean jj_3R_28() {
 1505  57 
     if (jj_3R_33()) return true;
 1506  0 
     return false;
 1507   
   }
 1508   
 
 1509   
   final private boolean jj_3R_24() {
 1510   
     Token xsp;
 1511  57 
     xsp = jj_scanpos;
 1512  57 
     if (jj_3R_28()) {
 1513  35 
     jj_scanpos = xsp;
 1514  35 
     if (jj_3R_29()) {
 1515  35 
     jj_scanpos = xsp;
 1516  35 
     if (jj_3R_30()) return true;
 1517   
     }
 1518   
     }
 1519  0 
     return false;
 1520   
   }
 1521   
 
 1522   
   final private boolean jj_3R_18() {
 1523  199 
     if (jj_scan_token(ACTION_WRAP)) return true;
 1524  40 
     if (jj_scan_token(ACTION_SEP)) return true;
 1525  40 
     if (jj_3R_23()) return true;
 1526  0 
     return false;
 1527   
   }
 1528   
 
 1529   
   final private boolean jj_3R_36() {
 1530  78 
     if (jj_3R_39()) return true;
 1531  0 
     return false;
 1532   
   }
 1533   
 
 1534   
   final private boolean jj_3R_32() {
 1535   
     Token xsp;
 1536  78 
     xsp = jj_scanpos;
 1537  78 
     if (jj_3R_36()) {
 1538  56 
     jj_scanpos = xsp;
 1539  56 
     if (jj_3R_37()) return true;
 1540   
     }
 1541  0 
     return false;
 1542   
   }
 1543   
 
 1544   
   final private boolean jj_3R_17() {
 1545  221 
     if (jj_scan_token(ACTION_TRANSFORM)) return true;
 1546  22 
     if (jj_scan_token(ACTION_SEP)) return true;
 1547  22 
     if (jj_3R_23()) return true;
 1548  0 
     return false;
 1549   
   }
 1550   
 
 1551   
   final private boolean jj_3R_31() {
 1552  121 
     if (jj_scan_token(RESOLVE_START)) return true;
 1553  0 
     return false;
 1554   
   }
 1555   
 
 1556   
   final private boolean jj_3R_26() {
 1557  121 
     if (jj_3R_31()) return true;
 1558  0 
     return false;
 1559   
   }
 1560   
 
 1561   
   final private boolean jj_3R_23() {
 1562   
     Token xsp;
 1563  121 
     xsp = jj_scanpos;
 1564  121 
     if (jj_3R_26()) {
 1565  78 
     jj_scanpos = xsp;
 1566  78 
     if (jj_3R_27()) return true;
 1567   
     }
 1568  0 
     return false;
 1569   
   }
 1570   
 
 1571   
   final private boolean jj_3R_16() {
 1572  99 
     if (jj_3R_22()) return true;
 1573  0 
     return false;
 1574   
   }
 1575   
 
 1576   
   final private boolean jj_3R_15() {
 1577  100 
     if (jj_3R_21()) return true;
 1578  0 
     return false;
 1579   
   }
 1580   
 
 1581   
   final private boolean jj_3R_30() {
 1582  35 
     if (jj_3R_35()) return true;
 1583  0 
     return false;
 1584   
   }
 1585   
 
 1586   
   final private boolean jj_3R_14() {
 1587  138 
     if (jj_3R_20()) return true;
 1588  0 
     return false;
 1589   
   }
 1590   
 
 1591   
   final private boolean jj_3R_13() {
 1592  159 
     if (jj_3R_19()) return true;
 1593  0 
     return false;
 1594   
   }
 1595   
 
 1596   
   final private boolean jj_3R_12() {
 1597  199 
     if (jj_3R_18()) return true;
 1598  0 
     return false;
 1599   
   }
 1600   
 
 1601   
   final private boolean jj_3R_25() {
 1602  2 
     if (jj_scan_token(NUMBER)) return true;
 1603  0 
     return false;
 1604   
   }
 1605   
 
 1606   
   final private boolean jj_3R_11() {
 1607  221 
     if (jj_3R_17()) return true;
 1608  0 
     return false;
 1609   
   }
 1610   
 
 1611   
   final private boolean jj_3R_39() {
 1612  78 
     if (jj_scan_token(SPLIT_START)) return true;
 1613  0 
     return false;
 1614   
   }
 1615   
 
 1616   
   final private boolean jj_3R_22() {
 1617  99 
     if (jj_scan_token(ACTION_RESPONSE)) return true;
 1618  2 
     if (jj_scan_token(ACTION_SEP)) return true;
 1619   
     Token xsp;
 1620  2 
     xsp = jj_scanpos;
 1621  2 
     if (jj_3R_25()) {
 1622  1 
     jj_scanpos = xsp;
 1623  1 
     if (jj_scan_token(46)) return true;
 1624   
     }
 1625  0 
     return false;
 1626   
   }
 1627   
 
 1628   
   final private boolean jj_3R_10() {
 1629   
     Token xsp;
 1630  221 
     xsp = jj_scanpos;
 1631  221 
     if (jj_3R_11()) {
 1632  199 
     jj_scanpos = xsp;
 1633  199 
     if (jj_3R_12()) {
 1634  159 
     jj_scanpos = xsp;
 1635  159 
     if (jj_3R_13()) {
 1636  138 
     jj_scanpos = xsp;
 1637  138 
     if (jj_3R_14()) {
 1638  100 
     jj_scanpos = xsp;
 1639  100 
     if (jj_3R_15()) {
 1640  99 
     jj_scanpos = xsp;
 1641  99 
     if (jj_3R_16()) return true;
 1642   
     }
 1643   
     }
 1644   
     }
 1645   
     }
 1646   
     }
 1647  0 
     return false;
 1648   
   }
 1649   
 
 1650   
   final private boolean jj_3R_38() {
 1651  16 
     if (jj_3R_40()) return true;
 1652  0 
     return false;
 1653   
   }
 1654   
 
 1655   
   final private boolean jj_3R_34() {
 1656  35 
     if (jj_scan_token(THEME_START)) return true;
 1657  0 
     return false;
 1658   
   }
 1659   
 
 1660   
   public RulesTokenManager token_source;
 1661   
   SimpleCharStream jj_input_stream;
 1662   
   public Token token, jj_nt;
 1663   
   private int jj_ntk;
 1664   
   private Token jj_scanpos, jj_lastpos;
 1665   
   private int jj_la;
 1666  22 
   public boolean lookingAhead = false;
 1667   
   private boolean jj_semLA;
 1668   
   private int jj_gen;
 1669  22 
   final private int[] jj_la1 = new int[30];
 1670   
   static private int[] jj_la1_0;
 1671   
   static private int[] jj_la1_1;
 1672   
   static {
 1673  1 
       jj_la1_0();
 1674  1 
       jj_la1_1();
 1675  1 
    }
 1676   
    private static void jj_la1_0() {
 1677  1 
       jj_la1_0 = new int[] {0x2000,0xc001df70,0x0,0x0,0x80000000,0x80000000,0x80000000,0x0,0x4000000,0x4000000,0xc001df30,0xc001df70,0xc001df30,0xc001df30,0xc001df00,0x6,0x6,0x6,0x6,0x3fc0000,0x1b00,0xc001df30,0x1f00,0x6,0x6,0x1b00,0xc0000000,0x80000000,0x0,0x0,};
 1678  1 
    }
 1679   
    private static void jj_la1_1() {
 1680  1 
       jj_la1_1 = new int[] {0x0,0x2,0x3f00,0x24000,0x40e2,0x4062,0x4022,0x4002,0x0,0x0,0x2,0x2,0x2,0x2,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x2,0x2,0x80008,0x80008,};
 1681  1 
    }
 1682  22 
   final private JJCalls[] jj_2_rtns = new JJCalls[1];
 1683  22 
   private boolean jj_rescan = false;
 1684  22 
   private int jj_gc = 0;
 1685   
 
 1686   
   public Rules(java.io.InputStream stream) {
 1687  0 
      this(stream, null);
 1688  0 
   }
 1689  0 
   public Rules(java.io.InputStream stream, String encoding) {
 1690  0 
     try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
 1691  0 
     token_source = new RulesTokenManager(jj_input_stream);
 1692  0 
     token = new Token();
 1693  0 
     jj_ntk = -1;
 1694  0 
     jj_gen = 0;
 1695  0 
     for (int i = 0; i < 30; i++) jj_la1[i] = -1;
 1696  0 
     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 1697  0 
   }
 1698   
 
 1699   
   public void ReInit(java.io.InputStream stream) {
 1700  0 
      ReInit(stream, null);
 1701  0 
   }
 1702   
   public void ReInit(java.io.InputStream stream, String encoding) {
 1703  0 
     try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
 1704  0 
     token_source.ReInit(jj_input_stream);
 1705  0 
     token = new Token();
 1706  0 
     jj_ntk = -1;
 1707  0 
     jjtree.reset();
 1708  0 
     jj_gen = 0;
 1709  0 
     for (int i = 0; i < 30; i++) jj_la1[i] = -1;
 1710  0 
     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 1711  0 
   }
 1712   
 
 1713  22 
   public Rules(java.io.Reader stream) {
 1714  22 
     jj_input_stream = new SimpleCharStream(stream, 1, 1);
 1715  22 
     token_source = new RulesTokenManager(jj_input_stream);
 1716  22 
     token = new Token();
 1717  22 
     jj_ntk = -1;
 1718  22 
     jj_gen = 0;
 1719  22 
     for (int i = 0; i < 30; i++) jj_la1[i] = -1;
 1720  22 
     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 1721  22 
   }
 1722   
 
 1723   
   public void ReInit(java.io.Reader stream) {
 1724  0 
     jj_input_stream.ReInit(stream, 1, 1);
 1725  0 
     token_source.ReInit(jj_input_stream);
 1726  0 
     token = new Token();
 1727  0 
     jj_ntk = -1;
 1728  0 
     jjtree.reset();
 1729  0 
     jj_gen = 0;
 1730  0 
     for (int i = 0; i < 30; i++) jj_la1[i] = -1;
 1731  0 
     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 1732  0 
   }
 1733   
 
 1734  0 
   public Rules(RulesTokenManager tm) {
 1735  0 
     token_source = tm;
 1736  0 
     token = new Token();
 1737  0 
     jj_ntk = -1;
 1738  0 
     jj_gen = 0;
 1739  0 
     for (int i = 0; i < 30; i++) jj_la1[i] = -1;
 1740  0 
     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 1741  0 
   }
 1742   
 
 1743   
   public void ReInit(RulesTokenManager tm) {
 1744  0 
     token_source = tm;
 1745  0 
     token = new Token();
 1746  0 
     jj_ntk = -1;
 1747  0 
     jjtree.reset();
 1748  0 
     jj_gen = 0;
 1749  0 
     for (int i = 0; i < 30; i++) jj_la1[i] = -1;
 1750  0 
     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 1751  0 
   }
 1752   
 
 1753   
   final private Token jj_consume_token(int kind) throws ParseException {
 1754   
     Token oldToken;
 1755  5187 
     if ((oldToken = token).next != null) token = token.next;
 1756  701 
     else token = token.next = token_source.getNextToken();
 1757  5187 
     jj_ntk = -1;
 1758  5187 
     if (token.kind == kind) {
 1759  5187 
       jj_gen++;
 1760  5187 
       if (++jj_gc > 100) {
 1761  47 
         jj_gc = 0;
 1762  94 
         for (int i = 0; i < jj_2_rtns.length; i++) {
 1763  47 
           JJCalls c = jj_2_rtns[i];
 1764  94 
           while (c != null) {
 1765  47 
             if (c.gen < jj_gen) c.first = null;
 1766  47 
             c = c.next;
 1767   
           }
 1768   
         }
 1769   
       }
 1770  5187 
       return token;
 1771   
     }
 1772  0 
     token = oldToken;
 1773  0 
     jj_kind = kind;
 1774  0 
     throw generateParseException();
 1775   
   }
 1776   
 
 1777  44 
   static private final class LookaheadSuccess extends java.lang.Error { }
 1778  22 
   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
 1779   
   final private boolean jj_scan_token(int kind) {
 1780  1385 
     if (jj_scanpos == jj_lastpos) {
 1781  469 
       jj_la--;
 1782  469 
       if (jj_scanpos.next == null) {
 1783  469 
         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
 1784   
       } else {
 1785  0 
         jj_lastpos = jj_scanpos = jj_scanpos.next;
 1786   
       }
 1787   
     } else {
 1788  916 
       jj_scanpos = jj_scanpos.next;
 1789   
     }
 1790  1385 
     if (jj_rescan) {
 1791  0 
       int i = 0; Token tok = token;
 1792  0 
       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
 1793  0 
       if (tok != null) jj_add_error_token(kind, i);
 1794   
     }
 1795  1385 
     if (jj_scanpos.kind != kind) return true;
 1796  372 
     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
 1797  248 
     return false;
 1798   
   }
 1799   
 
 1800   
   final public Token getNextToken() {
 1801  0 
     if (token.next != null) token = token.next;
 1802  0 
     else token = token.next = token_source.getNextToken();
 1803  0 
     jj_ntk = -1;
 1804  0 
     jj_gen++;
 1805  0 
     return token;
 1806   
   }
 1807   
 
 1808   
   final public Token getToken(int index) {
 1809  3149 
     Token t = lookingAhead ? jj_scanpos : token;
 1810  3149 
     for (int i = 0; i < index; i++) {
 1811  0 
       if (t.next != null) t = t.next;
 1812  0 
       else t = t.next = token_source.getNextToken();
 1813   
     }
 1814  3149 
     return t;
 1815   
   }
 1816   
 
 1817   
   final private int jj_ntk() {
 1818  4265 
     if ((jj_nt=token.next) == null)
 1819  4017 
       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
 1820   
     else
 1821  248 
       return (jj_ntk = jj_nt.kind);
 1822   
   }
 1823   
 
 1824  22 
   private java.util.Vector jj_expentries = new java.util.Vector();
 1825   
   private int[] jj_expentry;
 1826  22 
   private int jj_kind = -1;
 1827  22 
   private int[] jj_lasttokens = new int[100];
 1828   
   private int jj_endpos;
 1829   
 
 1830   
   private void jj_add_error_token(int kind, int pos) {
 1831  0 
     if (pos >= 100) return;
 1832  0 
     if (pos == jj_endpos + 1) {
 1833  0 
       jj_lasttokens[jj_endpos++] = kind;
 1834  0 
     } else if (jj_endpos != 0) {
 1835  0 
       jj_expentry = new int[jj_endpos];
 1836  0 
       for (int i = 0; i < jj_endpos; i++) {
 1837  0 
         jj_expentry[i] = jj_lasttokens[i];
 1838   
       }
 1839  0 
       boolean exists = false;
 1840  0 
       for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
 1841  0 
         int[] oldentry = (int[])(e.nextElement());
 1842  0 
         if (oldentry.length == jj_expentry.length) {
 1843  0 
           exists = true;
 1844  0 
           for (int i = 0; i < jj_expentry.length; i++) {
 1845  0 
             if (oldentry[i] != jj_expentry[i]) {
 1846  0 
               exists = false;
 1847  0 
               break;
 1848   
             }
 1849   
           }
 1850  0 
           if (exists) break;
 1851   
         }
 1852  0 
       }
 1853  0 
       if (!exists) jj_expentries.addElement(jj_expentry);
 1854  0 
       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
 1855   
     }
 1856  0 
   }
 1857   
 
 1858   
   public ParseException generateParseException() {
 1859  0 
     jj_expentries.removeAllElements();
 1860  0 
     boolean[] la1tokens = new boolean[52];
 1861  0 
     for (int i = 0; i < 52; i++) {
 1862  0 
       la1tokens[i] = false;
 1863   
     }
 1864  0 
     if (jj_kind >= 0) {
 1865  0 
       la1tokens[jj_kind] = true;
 1866  0 
       jj_kind = -1;
 1867   
     }
 1868  0 
     for (int i = 0; i < 30; i++) {
 1869  0 
       if (jj_la1[i] == jj_gen) {
 1870  0 
         for (int j = 0; j < 32; j++) {
 1871  0 
           if ((jj_la1_0[i] & (1<<j)) != 0) {
 1872  0 
             la1tokens[j] = true;
 1873   
           }
 1874  0 
           if ((jj_la1_1[i] & (1<<j)) != 0) {
 1875  0 
             la1tokens[32+j] = true;
 1876   
           }
 1877   
         }
 1878   
       }
 1879   
     }
 1880  0 
     for (int i = 0; i < 52; i++) {
 1881  0 
       if (la1tokens[i]) {
 1882  0 
         jj_expentry = new int[1];
 1883  0 
         jj_expentry[0] = i;
 1884  0 
         jj_expentries.addElement(jj_expentry);
 1885   
       }
 1886   
     }
 1887  0 
     jj_endpos = 0;
 1888  0 
     jj_rescan_token();
 1889  0 
     jj_add_error_token(0, 0);
 1890  0 
     int[][] exptokseq = new int[jj_expentries.size()][];
 1891  0 
     for (int i = 0; i < jj_expentries.size(); i++) {
 1892  0 
       exptokseq[i] = (int[])jj_expentries.elementAt(i);
 1893   
     }
 1894  0 
     return new ParseException(token, exptokseq, tokenImage);
 1895   
   }
 1896   
 
 1897   
   final public void enable_tracing() {
 1898  0 
   }
 1899   
 
 1900   
   final public void disable_tracing() {
 1901  0 
   }
 1902   
 
 1903   
   final private void jj_rescan_token() {
 1904  0 
     jj_rescan = true;
 1905  0 
     for (int i = 0; i < 1; i++) {
 1906   
     try {
 1907  0 
       JJCalls p = jj_2_rtns[i];
 1908   
       do {
 1909  0 
         if (p.gen > jj_gen) {
 1910  0 
           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
 1911  0 
           switch (i) {
 1912  0 
             case 0: jj_3_1(); break;
 1913   
           }
 1914   
         }
 1915  0 
         p = p.next;
 1916  0 
       } while (p != null);
 1917  0 
       } catch(LookaheadSuccess ls) { }
 1918   
     }
 1919  0 
     jj_rescan = false;
 1920  0 
   }
 1921   
 
 1922   
   final private void jj_save(int index, int xla) {
 1923  221 
     JJCalls p = jj_2_rtns[index];
 1924  221 
     while (p.gen > jj_gen) {
 1925  0 
       if (p.next == null) { p = p.next = new JJCalls(); break; }
 1926  0 
       p = p.next;
 1927   
     }
 1928  221 
     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
 1929  221 
   }
 1930   
 
 1931  22 
   static final class JJCalls {
 1932   
     int gen;
 1933   
     Token first;
 1934   
     int arg;
 1935   
     JJCalls next;
 1936   
   }
 1937   
 
 1938   
 }
Report generated by Cobertura 1.8 on 1/14/08 5:40 PM.