src/main/java/org/xerial/silk/impl/SilkLexer.java

   1 // $ANTLR 3.1.1 F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g 2009-01-30 20:53:33
   2
   3 /*--------------------------------------------------------------------------
   4  *  Copyright 2009 Taro L. Saito
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License.
  17  *--------------------------------------------------------------------------*/
  18 //--------------------------------------
  19 // XerialJ
  20 //
  21 // SilkLexer.java
  22 // Since: Jan 28, 2009 1:00:02 PM
  23 //
  24 //--------------------------------------
  25
  26 package org.xerial.silk.impl;
  27 import org.xerial.util.log.Logger;
  28 import org.xerial.silk.impl.SilkLexerState;
  29 import org.xerial.silk.impl.SilkLexerState.State;
  30 import org.xerial.silk.impl.SilkLexerState.Symbol;
  31
  32
  33 import org.antlr.runtime.*;
  34 import java.util.Stack;
  35 import java.util.List;
  36 import java.util.ArrayList;
  37
  38 public class SilkLexer extends Lexer {
  39     public static final int Key=14;
  40     public static final int PlainUnsafeChar=47;
  41     public static final int PlainSafeKey=48;
  42     public static final int DataType=10;
  43     public static final int SilkNode=5;
  44     public static final int SilkLine=6;
  45     public static final int LBracket=31;
  46     public static final int Digit=34;
  47     public static final int NodeIndent=19;
  48     public static final int HexDigit=36;
  49     public static final int PlainOneLine=52;
  50     public static final int Plus=30;
  51     public static final int Occurrence=9;
  52     public static final int Argument=12;
  53     public static final int FlowIndicator=46;
  54     public static final int Separation=54;
  55     public static final int Letter=35;
  56     public static final int PlainSafeIn=49;
  57     public static final int Comma=25;
  58     public static final int EscapeSequence=38;
  59     public static final int NonSpaceChar=40;
  60     public static final int DataLine=22;
  61     public static final int PlainFirst=44;
  62     public static final int WhiteSpace=20;
  63     public static final int PlainSafeOut=50;
  64     public static final int JSON=53;
  65     public static final int Question=33;
  66     public static final int LineComment=15;
  67     public static final int Colon=26;
  68     public static final int At=29;
  69     public static final int KeyValuePair=13;
  70     public static final int Star=28;
  71     public static final int Preamble=16;
  72     public static final int Seq=27;
  73     public static final int RParen=24;
  74     public static final int Indicator=43;
  75     public static final int UnicodeChar=37;
  76     public static final int Silk=4;
  77     public static final int BlankLine=21;
  78     public static final int StringChar=39;
  79     public static final int LineBreak=18;
  80     public static final int Name=7;
  81     public static final int Function=11;
  82     public static final int LParen=23;
  83     public static final int String=42;
  84     public static final int LineBreakChar=17;
  85     public static final int ScopeIndicator=45;
  86     public static final int EOF=-1;
  87     public static final int StringChar_s=41;
  88     public static final int Value=8;
  89     public static final int RBracket=32;
  90     public static final int PlainSafe=51;
  91
  92
  93     private static Logger _logger = Logger.getLogger(SilkLexer.class);
  94     //public static final int JSON_CHANNEL = 1;
  95
  96     private SilkLexerState lexerContext = new SilkLexerState();
  97
  98     private State currentState() { return lexerContext.getCurrentState(); }
  99     private void transit(Symbol token) { lexerContext.transit(token); }
 100     private void resetContext() { lexerContext.reset(); }
 101     private boolean isKey() { return currentState() == State.IN_KEY || currentState() == State.OUT_KEY; }
 102     //private boolean isValue() { return currentState() == State.IN_VALUE || currentState() == State.OUT_VALUE || currentState() == State.JSON; }
 103     private boolean isValue() { return currentState() == State.IN_VALUE || currentState() == State.OUT_VALUE; }
 104     private boolean isInValue() { return currentState() == State.IN_VALUE; }
 105     private boolean isOutValue() { return currentState() == State.OUT_VALUE; }
 106     //private boolean isJSON() { return currentState() == State.JSON; }
 107     private boolean isHead() { return getCharPositionInLine() == 0; }
 108
 109
 110     // delegates
 111     // delegators
 112
 113     public SilkLexer() {;}
 114     public SilkLexer(CharStream input) {
 115         this(input, new RecognizerSharedState());
 116     }
 117     public SilkLexer(CharStream input, RecognizerSharedState state) {
 118         super(input,state);
 119
 120     }
 121     public String getGrammarFileName() { return "F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g"; }
 122
 123     // $ANTLR start "LineComment"
 124     public final void mLineComment() throws RecognitionException {
 125         try {
 126             int _type = LineComment;
 127             int _channel = DEFAULT_TOKEN_CHANNEL;
 128             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:136:12: ( '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
 129             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:136:14: '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
 130             {
 131             match('#');
 132             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:136:18: (~ ( '\\n' | '\\r' ) )*
 133             loop1:
 134             do {
 135                 int alt1=2;
 136                 int LA1_0 = input.LA(1);
 137
 138                 if ( ((LA1_0>='\u0000' && LA1_0<='\t')||(LA1_0>='\u000B' && LA1_0<='\f')||(LA1_0>='\u000E' && LA1_0<='\uFFFF')) ) {
 139                     alt1=1;
 140                 }
 141
 142
 143                 switch (alt1) {
 144                 case 1 :
 145                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:136:18: ~ ( '\\n' | '\\r' )
 146                     {
 147                     if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
 148                         input.consume();
 149
 150                     }
 151                     else {
 152                         MismatchedSetException mse = new MismatchedSetException(null,input);
 153                         recover(mse);
 154                         throw mse;}
 155
 156
 157                     }
 158                     break;
 159
 160                 default :
 161                     break loop1;
 162                 }
 163             } while (true);
 164
 165             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:136:32: ( '\\r' )?
 166             int alt2=2;
 167             int LA2_0 = input.LA(1);
 168
 169             if ( (LA2_0=='\r') ) {
 170                 alt2=1;
 171             }
 172             switch (alt2) {
 173                 case 1 :
 174                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:136:32: '\\r'
 175                     {
 176                     match('\r');
 177
 178                     }
 179                     break;
 180
 181             }
 182
 183             match('\n');
 184              _channel=HIDDEN;
 185
 186             }
 187
 188             state.type = _type;
 189             state.channel = _channel;
 190         }
 191         finally {
 192         }
 193     }
 194     // $ANTLR end "LineComment"
 195
 196     // $ANTLR start "Preamble"
 197     public final void mPreamble() throws RecognitionException {
 198         try {
 199             int _type = Preamble;
 200             int _channel = DEFAULT_TOKEN_CHANNEL;
 201             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:137:9: ( '%' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
 202             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:137:11: '%' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
 203             {
 204             match('%');
 205             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:137:15: (~ ( '\\n' | '\\r' ) )*
 206             loop3:
 207             do {
 208                 int alt3=2;
 209                 int LA3_0 = input.LA(1);
 210
 211                 if ( ((LA3_0>='\u0000' && LA3_0<='\t')||(LA3_0>='\u000B' && LA3_0<='\f')||(LA3_0>='\u000E' && LA3_0<='\uFFFF')) ) {
 212                     alt3=1;
 213                 }
 214
 215
 216                 switch (alt3) {
 217                 case 1 :
 218                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:137:15: ~ ( '\\n' | '\\r' )
 219                     {
 220                     if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
 221                         input.consume();
 222
 223                     }
 224                     else {
 225                         MismatchedSetException mse = new MismatchedSetException(null,input);
 226                         recover(mse);
 227                         throw mse;}
 228
 229
 230                     }
 231                     break;
 232
 233                 default :
 234                     break loop3;
 235                 }
 236             } while (true);
 237
 238             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:137:29: ( '\\r' )?
 239             int alt4=2;
 240             int LA4_0 = input.LA(1);
 241
 242             if ( (LA4_0=='\r') ) {
 243                 alt4=1;
 244             }
 245             switch (alt4) {
 246                 case 1 :
 247                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:137:29: '\\r'
 248                     {
 249                     match('\r');
 250
 251                     }
 252                     break;
 253
 254             }
 255
 256             match('\n');
 257
 258             }
 259
 260             state.type = _type;
 261             state.channel = _channel;
 262         }
 263         finally {
 264         }
 265     }
 266     // $ANTLR end "Preamble"
 267
 268     // $ANTLR start "LineBreakChar"
 269     public final void mLineBreakChar() throws RecognitionException {
 270         try {
 271             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:140:23: ( '\\n' | '\\r' )
 272             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
 273             {
 274             if ( input.LA(1)=='\n'||input.LA(1)=='\r' ) {
 275                 input.consume();
 276
 277             }
 278             else {
 279                 MismatchedSetException mse = new MismatchedSetException(null,input);
 280                 recover(mse);
 281                 throw mse;}
 282
 283
 284             }
 285
 286         }
 287         finally {
 288         }
 289     }
 290     // $ANTLR end "LineBreakChar"
 291
 292     // $ANTLR start "LineBreak"
 293     public final void mLineBreak() throws RecognitionException {
 294         try {
 295             int _type = LineBreak;
 296             int _channel = DEFAULT_TOKEN_CHANNEL;
 297             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:143:2: ( ( '\\r' '\\n' | '\\r' | '\\n' ) )
 298             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:143:4: ( '\\r' '\\n' | '\\r' | '\\n' )
 299             {
 300             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:143:4: ( '\\r' '\\n' | '\\r' | '\\n' )
 301             int alt5=3;
 302             int LA5_0 = input.LA(1);
 303
 304             if ( (LA5_0=='\r') ) {
 305                 int LA5_1 = input.LA(2);
 306
 307                 if ( (LA5_1=='\n') ) {
 308                     alt5=1;
 309                 }
 310                 else {
 311                     alt5=2;}
 312             }
 313             else if ( (LA5_0=='\n') ) {
 314                 alt5=3;
 315             }
 316             else {
 317                 NoViableAltException nvae =
 318                     new NoViableAltException("", 5, 0, input);
 319
 320                 throw nvae;
 321             }
 322             switch (alt5) {
 323                 case 1 :
 324                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:143:5: '\\r' '\\n'
 325                     {
 326                     match('\r');
 327                     match('\n');
 328
 329                     }
 330                     break;
 331                 case 2 :
 332                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:143:17: '\\r'
 333                     {
 334                     match('\r');
 335
 336                     }
 337                     break;
 338                 case 3 :
 339                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:143:24: '\\n'
 340                     {
 341                     match('\n');
 342
 343                     }
 344                     break;
 345
 346             }
 347
 348              _channel=HIDDEN; resetContext();
 349
 350             }
 351
 352             state.type = _type;
 353             state.channel = _channel;
 354         }
 355         finally {
 356         }
 357     }
 358     // $ANTLR end "LineBreak"
 359
 360     // $ANTLR start "NodeIndent"
 361     public final void mNodeIndent() throws RecognitionException {
 362         try {
 363             int _type = NodeIndent;
 364             int _channel = DEFAULT_TOKEN_CHANNEL;
 365             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:148:11: ({...}? ( ' ' )* '-' )
 366             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:148:13: {...}? ( ' ' )* '-'
 367             {
 368             if ( !(( isHead() )) ) {
 369                 throw new FailedPredicateException(input, "NodeIndent", " isHead() ");
 370             }
 371             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:148:27: ( ' ' )*
 372             loop6:
 373             do {
 374                 int alt6=2;
 375                 int LA6_0 = input.LA(1);
 376
 377                 if ( (LA6_0==' ') ) {
 378                     alt6=1;
 379                 }
 380
 381
 382                 switch (alt6) {
 383                 case 1 :
 384                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:148:28: ' '
 385                     {
 386                     match(' ');
 387
 388                     }
 389                     break;
 390
 391                 default :
 392                     break loop6;
 393                 }
 394             } while (true);
 395
 396             match('-');
 397              transit(Symbol.NodeStart);
 398
 399             }
 400
 401             state.type = _type;
 402             state.channel = _channel;
 403         }
 404         finally {
 405         }
 406     }
 407     // $ANTLR end "NodeIndent"
 408
 409     // $ANTLR start "BlankLine"
 410     public final void mBlankLine() throws RecognitionException {
 411         try {
 412             int _type = BlankLine;
 413             int _channel = DEFAULT_TOKEN_CHANNEL;
 414             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:149:10: ({...}? ( WhiteSpace )* LineBreak )
 415             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:149:12: {...}? ( WhiteSpace )* LineBreak
 416             {
 417             if ( !(( isHead() )) ) {
 418                 throw new FailedPredicateException(input, "BlankLine", " isHead() ");
 419             }
 420             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:149:26: ( WhiteSpace )*
 421             loop7:
 422             do {
 423                 int alt7=2;
 424                 int LA7_0 = input.LA(1);
 425
 426                 if ( (LA7_0=='\t'||LA7_0==' ') ) {
 427                     alt7=1;
 428                 }
 429
 430
 431                 switch (alt7) {
 432                 case 1 :
 433                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:149:26: WhiteSpace
 434                     {
 435                     mWhiteSpace();
 436
 437                     }
 438                     break;
 439
 440                 default :
 441                     break loop7;
 442                 }
 443             } while (true);
 444
 445             mLineBreak();
 446
 447             }
 448
 449             state.type = _type;
 450             state.channel = _channel;
 451         }
 452         finally {
 453         }
 454     }
 455     // $ANTLR end "BlankLine"
 456
 457     // $ANTLR start "DataLine"
 458     public final void mDataLine() throws RecognitionException {
 459         try {
 460             int _type = DataLine;
 461             int _channel = DEFAULT_TOKEN_CHANNEL;
 462             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:9: ({...}? => ( WhiteSpace )* ~ ( '-' | '%' | '#' | WhiteSpace | LineBreakChar ) (~ ( '\\n' | '\\r' ) )* LineBreak )
 463             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:11: {...}? => ( WhiteSpace )* ~ ( '-' | '%' | '#' | WhiteSpace | LineBreakChar ) (~ ( '\\n' | '\\r' ) )* LineBreak
 464             {
 465             if ( !(( isHead() )) ) {
 466                 throw new FailedPredicateException(input, "DataLine", " isHead() ");
 467             }
 468             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:28: ( WhiteSpace )*
 469             loop8:
 470             do {
 471                 int alt8=2;
 472                 int LA8_0 = input.LA(1);
 473
 474                 if ( (LA8_0=='\t'||LA8_0==' ') ) {
 475                     alt8=1;
 476                 }
 477
 478
 479                 switch (alt8) {
 480                 case 1 :
 481                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:28: WhiteSpace
 482                     {
 483                     mWhiteSpace();
 484
 485                     }
 486                     break;
 487
 488                 default :
 489                     break loop8;
 490                 }
 491             } while (true);
 492
 493             if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\u001F')||(input.LA(1)>='!' && input.LA(1)<='\"')||input.LA(1)=='$'||(input.LA(1)>='&' && input.LA(1)<=',')||(input.LA(1)>='.' && input.LA(1)<='\uFFFF') ) {
 494                 input.consume();
 495
 496             }
 497             else {
 498                 MismatchedSetException mse = new MismatchedSetException(null,input);
 499                 recover(mse);
 500                 throw mse;}
 501
 502             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:88: (~ ( '\\n' | '\\r' ) )*
 503             loop9:
 504             do {
 505                 int alt9=2;
 506                 int LA9_0 = input.LA(1);
 507
 508                 if ( ((LA9_0>='\u0000' && LA9_0<='\t')||(LA9_0>='\u000B' && LA9_0<='\f')||(LA9_0>='\u000E' && LA9_0<='\uFFFF')) ) {
 509                     alt9=1;
 510                 }
 511
 512
 513                 switch (alt9) {
 514                 case 1 :
 515                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:151:88: ~ ( '\\n' | '\\r' )
 516                     {
 517                     if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
 518                         input.consume();
 519
 520                     }
 521                     else {
 522                         MismatchedSetException mse = new MismatchedSetException(null,input);
 523                         recover(mse);
 524                         throw mse;}
 525
 526
 527                     }
 528                     break;
 529
 530                 default :
 531                     break loop9;
 532                 }
 533             } while (true);
 534
 535             mLineBreak();
 536
 537             }
 538
 539             state.type = _type;
 540             state.channel = _channel;
 541         }
 542         finally {
 543         }
 544     }
 545     // $ANTLR end "DataLine"
 546
 547     // $ANTLR start "LParen"
 548     public final void mLParen() throws RecognitionException {
 549         try {
 550             int _type = LParen;
 551             int _channel = DEFAULT_TOKEN_CHANNEL;
 552             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:153:7: ( '(' )
 553             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:153:9: '('
 554             {
 555             match('(');
 556              transit(Symbol.EnterParen);
 557
 558             }
 559
 560             state.type = _type;
 561             state.channel = _channel;
 562         }
 563         finally {
 564         }
 565     }
 566     // $ANTLR end "LParen"
 567
 568     // $ANTLR start "RParen"
 569     public final void mRParen() throws RecognitionException {
 570         try {
 571             int _type = RParen;
 572             int _channel = DEFAULT_TOKEN_CHANNEL;
 573             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:154:7: ( ')' )
 574             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:154:9: ')'
 575             {
 576             match(')');
 577
 578             }
 579
 580             state.type = _type;
 581             state.channel = _channel;
 582         }
 583         finally {
 584         }
 585     }
 586     // $ANTLR end "RParen"
 587
 588     // $ANTLR start "Comma"
 589     public final void mComma() throws RecognitionException {
 590         try {
 591             int _type = Comma;
 592             int _channel = DEFAULT_TOKEN_CHANNEL;
 593             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:155:6: ( ',' )
 594             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:155:9: ','
 595             {
 596             match(',');
 597
 598             }
 599
 600             state.type = _type;
 601             state.channel = _channel;
 602         }
 603         finally {
 604         }
 605     }
 606     // $ANTLR end "Comma"
 607
 608     // $ANTLR start "Colon"
 609     public final void mColon() throws RecognitionException {
 610         try {
 611             int _type = Colon;
 612             int _channel = DEFAULT_TOKEN_CHANNEL;
 613             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:156:6: ( ':' )
 614             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:156:8: ':'
 615             {
 616             match(':');
 617              transit(Symbol.Colon);
 618
 619             }
 620
 621             state.type = _type;
 622             state.channel = _channel;
 623         }
 624         finally {
 625         }
 626     }
 627     // $ANTLR end "Colon"
 628
 629     // $ANTLR start "Seq"
 630     public final void mSeq() throws RecognitionException {
 631         try {
 632             int _type = Seq;
 633             int _channel = DEFAULT_TOKEN_CHANNEL;
 634             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:157:4: ( '>' )
 635             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:157:7: '>'
 636             {
 637             match('>');
 638
 639             }
 640
 641             state.type = _type;
 642             state.channel = _channel;
 643         }
 644         finally {
 645         }
 646     }
 647     // $ANTLR end "Seq"
 648
 649     // $ANTLR start "Star"
 650     public final void mStar() throws RecognitionException {
 651         try {
 652             int _type = Star;
 653             int _channel = DEFAULT_TOKEN_CHANNEL;
 654             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:158:5: ( '*' )
 655             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:158:8: '*'
 656             {
 657             match('*');
 658
 659             }
 660
 661             state.type = _type;
 662             state.channel = _channel;
 663         }
 664         finally {
 665         }
 666     }
 667     // $ANTLR end "Star"
 668
 669     // $ANTLR start "At"
 670     public final void mAt() throws RecognitionException {
 671         try {
 672             int _type = At;
 673             int _channel = DEFAULT_TOKEN_CHANNEL;
 674             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:159:3: ( '@' )
 675             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:159:6: '@'
 676             {
 677             match('@');
 678
 679             }
 680
 681             state.type = _type;
 682             state.channel = _channel;
 683         }
 684         finally {
 685         }
 686     }
 687     // $ANTLR end "At"
 688
 689     // $ANTLR start "Plus"
 690     public final void mPlus() throws RecognitionException {
 691         try {
 692             int _type = Plus;
 693             int _channel = DEFAULT_TOKEN_CHANNEL;
 694             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:160:5: ( '+' )
 695             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:160:7: '+'
 696             {
 697             match('+');
 698
 699             }
 700
 701             state.type = _type;
 702             state.channel = _channel;
 703         }
 704         finally {
 705         }
 706     }
 707     // $ANTLR end "Plus"
 708
 709     // $ANTLR start "LBracket"
 710     public final void mLBracket() throws RecognitionException {
 711         try {
 712             int _type = LBracket;
 713             int _channel = DEFAULT_TOKEN_CHANNEL;
 714             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:161:9: ( '[' )
 715             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:161:11: '['
 716             {
 717             match('[');
 718              transit(Symbol.EnterParen);
 719
 720             }
 721
 722             state.type = _type;
 723             state.channel = _channel;
 724         }
 725         finally {
 726         }
 727     }
 728     // $ANTLR end "LBracket"
 729
 730     // $ANTLR start "RBracket"
 731     public final void mRBracket() throws RecognitionException {
 732         try {
 733             int _type = RBracket;
 734             int _channel = DEFAULT_TOKEN_CHANNEL;
 735             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:162:9: ( ']' )
 736             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:162:11: ']'
 737             {
 738             match(']');
 739
 740             }
 741
 742             state.type = _type;
 743             state.channel = _channel;
 744         }
 745         finally {
 746         }
 747     }
 748     // $ANTLR end "RBracket"
 749
 750     // $ANTLR start "Question"
 751     public final void mQuestion() throws RecognitionException {
 752         try {
 753             int _type = Question;
 754             int _channel = DEFAULT_TOKEN_CHANNEL;
 755             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:163:9: ( '?' )
 756             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:163:11: '?'
 757             {
 758             match('?');
 759
 760             }
 761
 762             state.type = _type;
 763             state.channel = _channel;
 764         }
 765         finally {
 766         }
 767     }
 768     // $ANTLR end "Question"
 769
 770     // $ANTLR start "Digit"
 771     public final void mDigit() throws RecognitionException {
 772         try {
 773             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:165:15: ( '0' .. '9' )
 774             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:165:17: '0' .. '9'
 775             {
 776             matchRange('0','9');
 777
 778             }
 779
 780         }
 781         finally {
 782         }
 783     }
 784     // $ANTLR end "Digit"
 785
 786     // $ANTLR start "Letter"
 787     public final void mLetter() throws RecognitionException {
 788         try {
 789             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:166:16: ( 'A' .. 'F' | 'a' .. 'f' )
 790             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
 791             {
 792             if ( (input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {
 793                 input.consume();
 794
 795             }
 796             else {
 797                 MismatchedSetException mse = new MismatchedSetException(null,input);
 798                 recover(mse);
 799                 throw mse;}
 800
 801
 802             }
 803
 804         }
 805         finally {
 806         }
 807     }
 808     // $ANTLR end "Letter"
 809
 810     // $ANTLR start "HexDigit"
 811     public final void mHexDigit() throws RecognitionException {
 812         try {
 813             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:167:18: ( Digit | Letter )
 814             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
 815             {
 816             if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {
 817                 input.consume();
 818
 819             }
 820             else {
 821                 MismatchedSetException mse = new MismatchedSetException(null,input);
 822                 recover(mse);
 823                 throw mse;}
 824
 825
 826             }
 827
 828         }
 829         finally {
 830         }
 831     }
 832     // $ANTLR end "HexDigit"
 833
 834     // $ANTLR start "UnicodeChar"
 835     public final void mUnicodeChar() throws RecognitionException {
 836         try {
 837             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:168:21: (~ ( '\"' | '\\\\' | LineBreakChar ) )
 838             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:168:23: ~ ( '\"' | '\\\\' | LineBreakChar )
 839             {
 840             if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
 841                 input.consume();
 842
 843             }
 844             else {
 845                 MismatchedSetException mse = new MismatchedSetException(null,input);
 846                 recover(mse);
 847                 throw mse;}
 848
 849
 850             }
 851
 852         }
 853         finally {
 854         }
 855     }
 856     // $ANTLR end "UnicodeChar"
 857
 858     // $ANTLR start "EscapeSequence"
 859     public final void mEscapeSequence() throws RecognitionException {
 860         try {
 861             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:170:2: ( '\\\\' ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit ) )
 862             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:170:4: '\\\\' ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit )
 863             {
 864             match('\\');
 865             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:170:9: ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit )
 866             int alt10=9;
 867             switch ( input.LA(1) ) {
 868             case '\"':
 869                 {
 870                 alt10=1;
 871                 }
 872                 break;
 873             case '\\':
 874                 {
 875                 alt10=2;
 876                 }
 877                 break;
 878             case '/':
 879                 {
 880                 alt10=3;
 881                 }
 882                 break;
 883             case 'b':
 884                 {
 885                 alt10=4;
 886                 }
 887                 break;
 888             case 'f':
 889                 {
 890                 alt10=5;
 891                 }
 892                 break;
 893             case 'n':
 894                 {
 895                 alt10=6;
 896                 }
 897                 break;
 898             case 'r':
 899                 {
 900                 alt10=7;
 901                 }
 902                 break;
 903             case 't':
 904                 {
 905                 alt10=8;
 906                 }
 907                 break;
 908             case 'u':
 909                 {
 910                 alt10=9;
 911                 }
 912                 break;
 913             default:
 914                 NoViableAltException nvae =
 915                     new NoViableAltException("", 10, 0, input);
 916
 917                 throw nvae;
 918             }
 919
 920             switch (alt10) {
 921                 case 1 :
 922                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:170:10: '\\\"'
 923                     {
 924                     match('\"');
 925
 926                     }
 927                     break;
 928                 case 2 :
 929                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:170:17: '\\\\'
 930                     {
 931                     match('\\');
 932
 933                     }
 934                     break;
 935                 case 3 :
 936                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:170:24: '/'
 937                     {
 938                     match('/');
 939
 940                     }
 941                     break;
 942                 case 4 :
 943                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:170:30: 'b'
 944                     {
 945                     match('b');
 946
 947                     }
 948                     break;
 949                 case 5 :
 950                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:170:36: 'f'
 951                     {
 952                     match('f');
 953
 954                     }
 955                     break;
 956                 case 6 :
 957                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:170:42: 'n'
 958                     {
 959                     match('n');
 960
 961                     }
 962                     break;
 963                 case 7 :
 964                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:170:48: 'r'
 965                     {
 966                     match('r');
 967
 968                     }
 969                     break;
 970                 case 8 :
 971                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:170:54: 't'
 972                     {
 973                     match('t');
 974
 975                     }
 976                     break;
 977                 case 9 :
 978                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:170:60: 'u' HexDigit HexDigit HexDigit HexDigit
 979                     {
 980                     match('u');
 981                     mHexDigit();
 982                     mHexDigit();
 983                     mHexDigit();
 984                     mHexDigit();
 985
 986                     }
 987                     break;
 988
 989             }
 990
 991
 992             }
 993
 994         }
 995         finally {
 996         }
 997     }
 998     // $ANTLR end "EscapeSequence"
 999
1000     // $ANTLR start "StringChar"
1001     public final void mStringChar() throws RecognitionException {
1002         try {
1003             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:174:21: ( UnicodeChar | EscapeSequence )
1004             int alt11=2;
1005             int LA11_0 = input.LA(1);
1006
1007             if ( ((LA11_0>='\u0000' && LA11_0<='\t')||(LA11_0>='\u000B' && LA11_0<='\f')||(LA11_0>='\u000E' && LA11_0<='!')||(LA11_0>='#' && LA11_0<='[')||(LA11_0>=']' && LA11_0<='\uFFFF')) ) {
1008                 alt11=1;
1009             }
1010             else if ( (LA11_0=='\\') ) {
1011                 alt11=2;
1012             }
1013             else {
1014                 NoViableAltException nvae =
1015                     new NoViableAltException("", 11, 0, input);
1016
1017                 throw nvae;
1018             }
1019             switch (alt11) {
1020                 case 1 :
1021                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:174:24: UnicodeChar
1022                     {
1023                     mUnicodeChar();
1024
1025                     }
1026                     break;
1027                 case 2 :
1028                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:174:38: EscapeSequence
1029                     {
1030                     mEscapeSequence();
1031
1032                     }
1033                     break;
1034
1035             }
1036         }
1037         finally {
1038         }
1039     }
1040     // $ANTLR end "StringChar"
1041
1042     // $ANTLR start "NonSpaceChar"
1043     public final void mNonSpaceChar() throws RecognitionException {
1044         try {
1045             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:175:22: (~ ( '\"' | '\\\\' | LineBreakChar | WhiteSpace ) )
1046             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:175:24: ~ ( '\"' | '\\\\' | LineBreakChar | WhiteSpace )
1047             {
1048             if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\u001F')||input.LA(1)=='!'||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
1049                 input.consume();
1050
1051             }
1052             else {
1053                 MismatchedSetException mse = new MismatchedSetException(null,input);
1054                 recover(mse);
1055                 throw mse;}
1056
1057
1058             }
1059
1060         }
1061         finally {
1062         }
1063     }
1064     // $ANTLR end "NonSpaceChar"
1065
1066     // $ANTLR start "StringChar_s"
1067     public final void mStringChar_s() throws RecognitionException {
1068         try {
1069             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:177:22: ( ( StringChar )* )
1070             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:177:24: ( StringChar )*
1071             {
1072             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:177:24: ( StringChar )*
1073             loop12:
1074             do {
1075                 int alt12=2;
1076                 int LA12_0 = input.LA(1);
1077
1078                 if ( ((LA12_0>='\u0000' && LA12_0<='\t')||(LA12_0>='\u000B' && LA12_0<='\f')||(LA12_0>='\u000E' && LA12_0<='!')||(LA12_0>='#' && LA12_0<='\uFFFF')) ) {
1079                     alt12=1;
1080                 }
1081
1082
1083                 switch (alt12) {
1084                 case 1 :
1085                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:177:24: StringChar
1086                     {
1087                     mStringChar();
1088
1089                     }
1090                     break;
1091
1092                 default :
1093                     break loop12;
1094                 }
1095             } while (true);
1096
1097
1098             }
1099
1100         }
1101         finally {
1102         }
1103     }
1104     // $ANTLR end "StringChar_s"
1105
1106     // $ANTLR start "String"
1107     public final void mString() throws RecognitionException {
1108         try {
1109             int _type = String;
1110             int _channel = DEFAULT_TOKEN_CHANNEL;
1111             Token s=null;
1112
1113             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:178:7: ( '\"' s= StringChar_s '\"' )
1114             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:178:9: '\"' s= StringChar_s '\"'
1115             {
1116             match('\"');
1117             int sStart473 = getCharIndex();
1118             mStringChar_s();
1119             s = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, sStart473, getCharIndex()-1);
1120             match('\"');
1121              setText((s!=null?s.getText():null));
1122
1123             }
1124
1125             state.type = _type;
1126             state.channel = _channel;
1127         }
1128         finally {
1129         }
1130     }
1131     // $ANTLR end "String"
1132
1133     // $ANTLR start "PlainFirst"
1134     public final void mPlainFirst() throws RecognitionException {
1135         try {
1136             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:182:2: (~ ( '\"' | '\\\\' | LineBreakChar | WhiteSpace | Indicator ) | {...}? => ( ':' | '?' ) NonSpaceChar )
1137             int alt13=2;
1138             int LA13_0 = input.LA(1);
1139
1140             if ( (LA13_0=='?') ) {
1141                 int LA13_1 = input.LA(2);
1142
1143                 if ( ((LA13_1>='\u0000' && LA13_1<='\b')||(LA13_1>='\u000B' && LA13_1<='\f')||(LA13_1>='\u000E' && LA13_1<='\u001F')||LA13_1=='!'||(LA13_1>='#' && LA13_1<='[')||(LA13_1>=']' && LA13_1<='\uFFFF')) && (( isValue() ))) {
1144                     alt13=2;
1145                 }
1146                 else {
1147                     alt13=1;}
1148             }
1149             else if ( ((LA13_0>='\u0000' && LA13_0<='\b')||(LA13_0>='\u000B' && LA13_0<='\f')||(LA13_0>='\u000E' && LA13_0<='\u001F')||LA13_0=='!'||LA13_0=='$'||LA13_0=='&'||(LA13_0>='*' && LA13_0<='+')||(LA13_0>='.' && LA13_0<='9')||(LA13_0>=';' && LA13_0<='=')||(LA13_0>='A' && LA13_0<='Z')||(LA13_0>='^' && LA13_0<='z')||LA13_0=='|'||(LA13_0>='~' && LA13_0<='\uFFFF')) ) {
1150                 alt13=1;
1151             }
1152             else if ( (LA13_0==':') && (( isValue() ))) {
1153                 alt13=2;
1154             }
1155             else {
1156                 NoViableAltException nvae =
1157                     new NoViableAltException("", 13, 0, input);
1158
1159                 throw nvae;
1160             }
1161             switch (alt13) {
1162                 case 1 :
1163                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:182:4: ~ ( '\"' | '\\\\' | LineBreakChar | WhiteSpace | Indicator )
1164                     {
1165                     if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\u001F')||input.LA(1)=='!'||input.LA(1)=='$'||input.LA(1)=='&'||(input.LA(1)>='*' && input.LA(1)<='+')||(input.LA(1)>='.' && input.LA(1)<='9')||(input.LA(1)>=';' && input.LA(1)<='=')||input.LA(1)=='?'||(input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='^' && input.LA(1)<='z')||input.LA(1)=='|'||(input.LA(1)>='~' && input.LA(1)<='\uFFFF') ) {
1166                         input.consume();
1167
1168                     }
1169                     else {
1170                         MismatchedSetException mse = new MismatchedSetException(null,input);
1171                         recover(mse);
1172                         throw mse;}
1173
1174
1175                     }
1176                     break;
1177                 case 2 :
1178                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:183:4: {...}? => ( ':' | '?' ) NonSpaceChar
1179                     {
1180                     if ( !(( isValue() )) ) {
1181                         throw new FailedPredicateException(input, "PlainFirst", " isValue() ");
1182                     }
1183                     if ( input.LA(1)==':'||input.LA(1)=='?' ) {
1184                         input.consume();
1185
1186                     }
1187                     else {
1188                         MismatchedSetException mse = new MismatchedSetException(null,input);
1189                         recover(mse);
1190                         throw mse;}
1191
1192                     mNonSpaceChar();
1193
1194                     }
1195                     break;
1196
1197             }
1198         }
1199         finally {
1200         }
1201     }
1202     // $ANTLR end "PlainFirst"
1203
1204     // $ANTLR start "ScopeIndicator"
1205     public final void mScopeIndicator() throws RecognitionException {
1206         try {
1207             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:186:24: ( '(' | ')' )
1208             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
1209             {
1210             if ( (input.LA(1)>='(' && input.LA(1)<=')') ) {
1211                 input.consume();
1212
1213             }
1214             else {
1215                 MismatchedSetException mse = new MismatchedSetException(null,input);
1216                 recover(mse);
1217                 throw mse;}
1218
1219
1220             }
1221
1222         }
1223         finally {
1224         }
1225     }
1226     // $ANTLR end "ScopeIndicator"
1227
1228     // $ANTLR start "FlowIndicator"
1229     public final void mFlowIndicator() throws RecognitionException {
1230         try {
1231             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:187:23: ( '[' | ']' | '{' | '}' )
1232             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
1233             {
1234             if ( input.LA(1)=='['||input.LA(1)==']'||input.LA(1)=='{'||input.LA(1)=='}' ) {
1235                 input.consume();
1236
1237             }
1238             else {
1239                 MismatchedSetException mse = new MismatchedSetException(null,input);
1240                 recover(mse);
1241                 throw mse;}
1242
1243
1244             }
1245
1246         }
1247         finally {
1248         }
1249     }
1250     // $ANTLR end "FlowIndicator"
1251
1252     // $ANTLR start "Indicator"
1253     public final void mIndicator() throws RecognitionException {
1254         try {
1255             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:188:19: ( FlowIndicator | ScopeIndicator | ',' | '-' | ':' | '#' | '>' | '\\'' | '\"' | '@' | '%' | '\\\\' )
1256             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
1257             {
1258             if ( (input.LA(1)>='\"' && input.LA(1)<='#')||input.LA(1)=='%'||(input.LA(1)>='\'' && input.LA(1)<=')')||(input.LA(1)>=',' && input.LA(1)<='-')||input.LA(1)==':'||input.LA(1)=='>'||input.LA(1)=='@'||(input.LA(1)>='[' && input.LA(1)<=']')||input.LA(1)=='{'||input.LA(1)=='}' ) {
1259                 input.consume();
1260
1261             }
1262             else {
1263                 MismatchedSetException mse = new MismatchedSetException(null,input);
1264                 recover(mse);
1265                 throw mse;}
1266
1267
1268             }
1269
1270         }
1271         finally {
1272         }
1273     }
1274     // $ANTLR end "Indicator"
1275
1276     // $ANTLR start "PlainUnsafeChar"
1277     public final void mPlainUnsafeChar() throws RecognitionException {
1278         try {
1279             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:191:25: ( '\"' | '\\\\' | LineBreakChar | WhiteSpace | '#' | ScopeIndicator )
1280             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:
1281             {
1282             if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' '||(input.LA(1)>='\"' && input.LA(1)<='#')||(input.LA(1)>='(' && input.LA(1)<=')')||input.LA(1)=='\\' ) {
1283                 input.consume();
1284
1285             }
1286             else {
1287                 MismatchedSetException mse = new MismatchedSetException(null,input);
1288                 recover(mse);
1289                 throw mse;}
1290
1291
1292             }
1293
1294         }
1295         finally {
1296         }
1297     }
1298     // $ANTLR end "PlainUnsafeChar"
1299
1300     // $ANTLR start "PlainSafeKey"
1301     public final void mPlainSafeKey() throws RecognitionException {
1302         try {
1303             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:193:22: (~ ( PlainUnsafeChar | FlowIndicator | ',' | ':' | '>' ) )
1304             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:193:24: ~ ( PlainUnsafeChar | FlowIndicator | ',' | ':' | '>' )
1305             {
1306             if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\u001F')||input.LA(1)=='!'||(input.LA(1)>='$' && input.LA(1)<='\'')||(input.LA(1)>='*' && input.LA(1)<='+')||(input.LA(1)>='-' && input.LA(1)<='9')||(input.LA(1)>=';' && input.LA(1)<='=')||(input.LA(1)>='?' && input.LA(1)<='Z')||(input.LA(1)>='^' && input.LA(1)<='z')||input.LA(1)=='|'||(input.LA(1)>='~' && input.LA(1)<='\uFFFF') ) {
1307                 input.consume();
1308
1309             }
1310             else {
1311                 MismatchedSetException mse = new MismatchedSetException(null,input);
1312                 recover(mse);
1313                 throw mse;}
1314
1315
1316             }
1317
1318         }
1319         finally {
1320         }
1321     }
1322     // $ANTLR end "PlainSafeKey"
1323
1324     // $ANTLR start "PlainSafeIn"
1325     public final void mPlainSafeIn() throws RecognitionException {
1326         try {
1327             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:194:21: (~ ( PlainUnsafeChar | ',' ) )
1328             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:194:23: ~ ( PlainUnsafeChar | ',' )
1329             {
1330             if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\u001F')||input.LA(1)=='!'||(input.LA(1)>='$' && input.LA(1)<='\'')||(input.LA(1)>='*' && input.LA(1)<='+')||(input.LA(1)>='-' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
1331                 input.consume();
1332
1333             }
1334             else {
1335                 MismatchedSetException mse = new MismatchedSetException(null,input);
1336                 recover(mse);
1337                 throw mse;}
1338
1339
1340             }
1341
1342         }
1343         finally {
1344         }
1345     }
1346     // $ANTLR end "PlainSafeIn"
1347
1348     // $ANTLR start "PlainSafeOut"
1349     public final void mPlainSafeOut() throws RecognitionException {
1350         try {
1351             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:195:22: (~ ( PlainUnsafeChar ) )
1352             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:195:24: ~ ( PlainUnsafeChar )
1353             {
1354             if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\u001F')||input.LA(1)=='!'||(input.LA(1)>='$' && input.LA(1)<='\'')||(input.LA(1)>='*' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
1355                 input.consume();
1356
1357             }
1358             else {
1359                 MismatchedSetException mse = new MismatchedSetException(null,input);
1360                 recover(mse);
1361                 throw mse;}
1362
1363
1364             }
1365
1366         }
1367         finally {
1368         }
1369     }
1370     // $ANTLR end "PlainSafeOut"
1371
1372     // $ANTLR start "PlainSafe"
1373     public final void mPlainSafe() throws RecognitionException {
1374         try {
1375             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:199:2: ({...}? => PlainSafeKey | {...}? => PlainSafeIn | {...}? => PlainSafeOut )
1376             int alt14=3;
1377             int LA14_0 = input.LA(1);
1378
1379             if ( ((LA14_0>='\u0000' && LA14_0<='\b')||(LA14_0>='\u000B' && LA14_0<='\f')||(LA14_0>='\u000E' && LA14_0<='\u001F')||LA14_0=='!'||(LA14_0>='$' && LA14_0<='\'')||(LA14_0>='*' && LA14_0<='+')||(LA14_0>='-' && LA14_0<='9')||(LA14_0>=';' && LA14_0<='=')||(LA14_0>='?' && LA14_0<='Z')||(LA14_0>='^' && LA14_0<='z')||LA14_0=='|'||(LA14_0>='~' && LA14_0<='\uFFFF')) && ((( isInValue() )||( isOutValue() )||( isKey() )))) {
1380                 int LA14_1 = input.LA(2);
1381
1382                 if ( (( isKey() )) ) {
1383                     alt14=1;
1384                 }
1385                 else if ( (( isInValue() )) ) {
1386                     alt14=2;
1387                 }
1388                 else if ( (( isOutValue() )) ) {
1389                     alt14=3;
1390                 }
1391                 else {
1392                     NoViableAltException nvae =
1393                         new NoViableAltException("", 14, 1, input);
1394
1395                     throw nvae;
1396                 }
1397             }
1398             else if ( (LA14_0==':'||LA14_0=='>'||LA14_0=='['||LA14_0==']'||LA14_0=='{'||LA14_0=='}') && ((( isInValue() )||( isOutValue() )))) {
1399                 int LA14_2 = input.LA(2);
1400
1401                 if ( (( isInValue() )) ) {
1402                     alt14=2;
1403                 }
1404                 else if ( (( isOutValue() )) ) {
1405                     alt14=3;
1406                 }
1407                 else {
1408                     NoViableAltException nvae =
1409                         new NoViableAltException("", 14, 2, input);
1410
1411                     throw nvae;
1412                 }
1413             }
1414             else if ( (LA14_0==',') && (( isOutValue() ))) {
1415                 alt14=3;
1416             }
1417             else {
1418                 NoViableAltException nvae =
1419                     new NoViableAltException("", 14, 0, input);
1420
1421                 throw nvae;
1422             }
1423             switch (alt14) {
1424                 case 1 :
1425                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:199:4: {...}? => PlainSafeKey
1426                     {
1427                     if ( !(( isKey() )) ) {
1428                         throw new FailedPredicateException(input, "PlainSafe", " isKey() ");
1429                     }
1430                     mPlainSafeKey();
1431
1432                     }
1433                     break;
1434                 case 2 :
1435                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:200:4: {...}? => PlainSafeIn
1436                     {
1437                     if ( !(( isInValue() )) ) {
1438                         throw new FailedPredicateException(input, "PlainSafe", " isInValue() ");
1439                     }
1440                     mPlainSafeIn();
1441
1442                     }
1443                     break;
1444                 case 3 :
1445                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:201:4: {...}? => PlainSafeOut
1446                     {
1447                     if ( !(( isOutValue() )) ) {
1448                         throw new FailedPredicateException(input, "PlainSafe", " isOutValue() ");
1449                     }
1450                     mPlainSafeOut();
1451
1452                     }
1453                     break;
1454
1455             }
1456         }
1457         finally {
1458         }
1459     }
1460     // $ANTLR end "PlainSafe"
1461
1462     // $ANTLR start "PlainOneLine"
1463     public final void mPlainOneLine() throws RecognitionException {
1464         try {
1465             int _type = PlainOneLine;
1466             int _channel = DEFAULT_TOKEN_CHANNEL;
1467             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:205:13: ( PlainFirst ( ( WhiteSpace )* PlainSafe )* )
1468             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:205:15: PlainFirst ( ( WhiteSpace )* PlainSafe )*
1469             {
1470             mPlainFirst();
1471             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:205:26: ( ( WhiteSpace )* PlainSafe )*
1472             loop16:
1473             do {
1474                 int alt16=2;
1475                 int LA16_0 = input.LA(1);
1476
1477                 if ( (LA16_0=='\t'||LA16_0==' ') ) {
1478                     alt16=1;
1479                 }
1480                 else if ( ((LA16_0>='\u0000' && LA16_0<='\b')||(LA16_0>='\u000B' && LA16_0<='\f')||(LA16_0>='\u000E' && LA16_0<='\u001F')||LA16_0=='!'||(LA16_0>='$' && LA16_0<='\'')||(LA16_0>='*' && LA16_0<='+')||(LA16_0>='-' && LA16_0<='9')||(LA16_0>=';' && LA16_0<='=')||(LA16_0>='?' && LA16_0<='Z')||(LA16_0>='^' && LA16_0<='z')||LA16_0=='|'||(LA16_0>='~' && LA16_0<='\uFFFF')) && ((( isInValue() )||( isOutValue() )||( isKey() )))) {
1481                     alt16=1;
1482                 }
1483                 else if ( (LA16_0==':'||LA16_0=='>'||LA16_0=='['||LA16_0==']'||LA16_0=='{'||LA16_0=='}') && ((( isInValue() )||( isOutValue() )))) {
1484                     alt16=1;
1485                 }
1486                 else if ( (LA16_0==',') && (( isOutValue() ))) {
1487                     alt16=1;
1488                 }
1489
1490
1491                 switch (alt16) {
1492                 case 1 :
1493                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:205:27: ( WhiteSpace )* PlainSafe
1494                     {
1495                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:205:27: ( WhiteSpace )*
1496                     loop15:
1497                     do {
1498                         int alt15=2;
1499                         int LA15_0 = input.LA(1);
1500
1501                         if ( (LA15_0=='\t'||LA15_0==' ') ) {
1502                             alt15=1;
1503                         }
1504
1505
1506                         switch (alt15) {
1507                         case 1 :
1508                             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:205:27: WhiteSpace
1509                             {
1510                             mWhiteSpace();
1511
1512                             }
1513                             break;
1514
1515                         default :
1516                             break loop15;
1517                         }
1518                     } while (true);
1519
1520                     mPlainSafe();
1521
1522                     }
1523                     break;
1524
1525                 default :
1526                     break loop16;
1527                 }
1528             } while (true);
1529
1530              transit(Symbol.LeaveValue);
1531
1532             }
1533
1534             state.type = _type;
1535             state.channel = _channel;
1536         }
1537         finally {
1538         }
1539     }
1540     // $ANTLR end "PlainOneLine"
1541
1542     // $ANTLR start "JSON"
1543     public final void mJSON() throws RecognitionException {
1544         try {
1545             int _type = JSON;
1546             int _channel = DEFAULT_TOKEN_CHANNEL;
1547             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:209:2: ({...}? => '{' | {...}? => '[' )
1548             int alt17=2;
1549             int LA17_0 = input.LA(1);
1550
1551             if ( (LA17_0=='{') && (( isValue() ))) {
1552                 alt17=1;
1553             }
1554             else if ( (LA17_0=='[') && (( isValue() ))) {
1555                 alt17=2;
1556             }
1557             else {
1558                 NoViableAltException nvae =
1559                     new NoViableAltException("", 17, 0, input);
1560
1561                 throw nvae;
1562             }
1563             switch (alt17) {
1564                 case 1 :
1565                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:209:4: {...}? => '{'
1566                     {
1567                     if ( !(( isValue() )) ) {
1568                         throw new FailedPredicateException(input, "JSON", " isValue() ");
1569                     }
1570                     match('{');
1571
1572                                 //_logger.info("enter JSON object");
1573                                 InLineJSONLexer l = new InLineJSONLexer(input);
1574                                 CommonTokenStream tokens = new CommonTokenStream(l);
1575                                 InLineJSONParser p = new InLineJSONParser(tokens);
1576                                 p.jsonObjectFragment();
1577
1578                                 //_channel = JSON_CHANNEL;
1579                                 emit(new CommonToken(JSON, getText()));
1580
1581
1582                     }
1583                     break;
1584                 case 2 :
1585                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:220:4: {...}? => '['
1586                     {
1587                     if ( !(( isValue() )) ) {
1588                         throw new FailedPredicateException(input, "JSON", " isValue() ");
1589                     }
1590                     match('[');
1591
1592                                 //_logger.info("enter JSON array");
1593                                 InLineJSONLexer l = new InLineJSONLexer(input);
1594                                 CommonTokenStream tokens = new CommonTokenStream(l);
1595                                 InLineJSONParser p = new InLineJSONParser(tokens);
1596                                 p.jsonArrayFragment();
1597
1598                                 //_channel = JSON_CHANNEL;
1599                                 emit(new CommonToken(JSON, getText()));
1600
1601
1602                     }
1603                     break;
1604
1605             }
1606             state.type = _type;
1607             state.channel = _channel;
1608         }
1609         finally {
1610         }
1611     }
1612     // $ANTLR end "JSON"
1613
1614     // $ANTLR start "Separation"
1615     public final void mSeparation() throws RecognitionException {
1616         try {
1617             int _type = Separation;
1618             int _channel = DEFAULT_TOKEN_CHANNEL;
1619             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:233:11: ({...}? ( WhiteSpace )+ )
1620             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:233:13: {...}? ( WhiteSpace )+
1621             {
1622             if ( !(( currentState() != State.INIT )) ) {
1623                 throw new FailedPredicateException(input, "Separation", " currentState() != State.INIT ");
1624             }
1625             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:233:47: ( WhiteSpace )+
1626             int cnt18=0;
1627             loop18:
1628             do {
1629                 int alt18=2;
1630                 int LA18_0 = input.LA(1);
1631
1632                 if ( (LA18_0=='\t'||LA18_0==' ') ) {
1633                     alt18=1;
1634                 }
1635
1636
1637                 switch (alt18) {
1638                 case 1 :
1639                     // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:233:47: WhiteSpace
1640                     {
1641                     mWhiteSpace();
1642
1643                     }
1644                     break;
1645
1646                 default :
1647                     if ( cnt18 >= 1 ) break loop18;
1648                         EarlyExitException eee =
1649                             new EarlyExitException(18, input);
1650                         throw eee;
1651                 }
1652                 cnt18++;
1653             } while (true);
1654
1655              _channel=HIDDEN;
1656
1657             }
1658
1659             state.type = _type;
1660             state.channel = _channel;
1661         }
1662         finally {
1663         }
1664     }
1665     // $ANTLR end "Separation"
1666
1667     // $ANTLR start "WhiteSpace"
1668     public final void mWhiteSpace() throws RecognitionException {
1669         try {
1670             int _type = WhiteSpace;
1671             int _channel = DEFAULT_TOKEN_CHANNEL;
1672             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:236:2: ( ( ' ' | '\\t' ) )
1673             // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:236:4: ( ' ' | '\\t' )
1674             {
1675             if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
1676                 input.consume();
1677
1678             }
1679             else {
1680                 MismatchedSetException mse = new MismatchedSetException(null,input);
1681                 recover(mse);
1682                 throw mse;}
1683
1684
1685             }
1686
1687             state.type = _type;
1688             state.channel = _channel;
1689         }
1690         finally {
1691         }
1692     }
1693     // $ANTLR end "WhiteSpace"
1694
1695     public void mTokens() throws RecognitionException {
1696         // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:8: ( LineComment | Preamble | LineBreak | NodeIndent | BlankLine | DataLine | LParen | RParen | Comma | Colon | Seq | Star | At | Plus | LBracket | RBracket | Question | String | PlainOneLine | JSON | Separation | WhiteSpace )
1697         int alt19=22;
1698         alt19 = dfa19.predict(input);
1699         switch (alt19) {
1700             case 1 :
1701                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:10: LineComment
1702                 {
1703                 mLineComment();
1704
1705                 }
1706                 break;
1707             case 2 :
1708                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:22: Preamble
1709                 {
1710                 mPreamble();
1711
1712                 }
1713                 break;
1714             case 3 :
1715                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:31: LineBreak
1716                 {
1717                 mLineBreak();
1718
1719                 }
1720                 break;
1721             case 4 :
1722                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:41: NodeIndent
1723                 {
1724                 mNodeIndent();
1725
1726                 }
1727                 break;
1728             case 5 :
1729                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:52: BlankLine
1730                 {
1731                 mBlankLine();
1732
1733                 }
1734                 break;
1735             case 6 :
1736                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:62: DataLine
1737                 {
1738                 mDataLine();
1739
1740                 }
1741                 break;
1742             case 7 :
1743                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:71: LParen
1744                 {
1745                 mLParen();
1746
1747                 }
1748                 break;
1749             case 8 :
1750                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:78: RParen
1751                 {
1752                 mRParen();
1753
1754                 }
1755                 break;
1756             case 9 :
1757                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:85: Comma
1758                 {
1759                 mComma();
1760
1761                 }
1762                 break;
1763             case 10 :
1764                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:91: Colon
1765                 {
1766                 mColon();
1767
1768                 }
1769                 break;
1770             case 11 :
1771                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:97: Seq
1772                 {
1773                 mSeq();
1774
1775                 }
1776                 break;
1777             case 12 :
1778                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:101: Star
1779                 {
1780                 mStar();
1781
1782                 }
1783                 break;
1784             case 13 :
1785                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:106: At
1786                 {
1787                 mAt();
1788
1789                 }
1790                 break;
1791             case 14 :
1792                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:109: Plus
1793                 {
1794                 mPlus();
1795
1796                 }
1797                 break;
1798             case 15 :
1799                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:114: LBracket
1800                 {
1801                 mLBracket();
1802
1803                 }
1804                 break;
1805             case 16 :
1806                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:123: RBracket
1807                 {
1808                 mRBracket();
1809
1810                 }
1811                 break;
1812             case 17 :
1813                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:132: Question
1814                 {
1815                 mQuestion();
1816
1817                 }
1818                 break;
1819             case 18 :
1820                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:141: String
1821                 {
1822                 mString();
1823
1824                 }
1825                 break;
1826             case 19 :
1827                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:148: PlainOneLine
1828                 {
1829                 mPlainOneLine();
1830
1831                 }
1832                 break;
1833             case 20 :
1834                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:161: JSON
1835                 {
1836                 mJSON();
1837
1838                 }
1839                 break;
1840             case 21 :
1841                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:166: Separation
1842                 {
1843                 mSeparation();
1844
1845                 }
1846                 break;
1847             case 22 :
1848                 // F:\\cygwin\\home\\leo\\work\\eclipse\\workspace\\xerial\\xerial-core\\src\\main\\java\\org\\xerial\\silk\\impl\\Silk.g:1:177: WhiteSpace
1849                 {
1850                 mWhiteSpace();
1851
1852                 }
1853                 break;
1854
1855         }
1856
1857     }
1858
1859
1860     protected DFA19 dfa19 = new DFA19(this);
1861     static final String DFA19_eotS =
1862         "\3\uffff\1\30\1\31\1\32\1\uffff\1\32\1\36\1\37\1\40\1\41\1\43\1"+
1863         "\44\1\51\1\52\1\53\1\54\1\55\1\uffff\1\64\1\65\1\uffff\1\66\4\uffff"+
1864         "\2\70\4\uffff\1\73\3\uffff\3\64\5\uffff\3\100\2\uffff\1\116\10\uffff"+
1865         "\3\73\3\uffff\3\100\16\uffff";
1866     static final String DFA19_eofS =
1867         "\123\uffff";
1868     static final String DFA19_minS =
1869         "\1\0\2\uffff\1\12\2\0\1\uffff\17\0\1\uffff\4\0\1\uffff\2\0\4\uffff"+
1870         "\1\0\2\uffff\4\0\2\uffff\1\0\2\uffff\6\0\2\uffff\1\0\3\uffff\1\0"+
1871         "\1\uffff\3\0\2\uffff\15\0\1\uffff\4\0";
1872     static final String DFA19_maxS =
1873         "\1\uffff\2\uffff\1\12\1\0\1\uffff\1\uffff\17\uffff\1\uffff\4\0"+
1874         "\1\uffff\2\uffff\4\uffff\1\uffff\2\uffff\4\uffff\2\uffff\1\0\2\uffff"+
1875         "\6\uffff\2\uffff\1\0\3\uffff\1\uffff\1\uffff\3\uffff\2\uffff\15"+
1876         "\uffff\1\uffff\4\uffff";
1877     static final String DFA19_acceptS =
1878         "\1\uffff\1\1\1\2\3\uffff\1\4\17\uffff\1\6\4\uffff\1\5\2\uffff\1"+
1879         "\7\1\10\1\11\1\12\1\uffff\1\13\1\14\4\uffff\1\15\1\16\1\uffff\1"+
1880         "\20\1\21\6\uffff\1\23\1\24\1\uffff\1\3\1\25\1\26\1\uffff\1\23\3"+
1881         "\uffff\1\17\1\23\15\uffff\1\22\4\uffff";
1882     static final String DFA19_specialS =
1883         "\1\3\4\uffff\1\12\1\uffff\1\35\1\37\1\50\1\67\1\7\1\63\1\4\1\57"+
1884         "\1\41\1\47\1\20\1\56\1\61\1\30\1\15\2\uffff\1\54\1\55\1\36\1\uffff"+
1885         "\1\66\1\24\4\uffff\1\5\2\uffff\1\45\1\33\1\64\1\22\2\uffff\1\13"+
1886         "\2\uffff\1\43\1\17\1\42\1\25\1\1\1\11\2\uffff\1\53\3\uffff\1\44"+
1887         "\1\uffff\1\32\1\62\1\21\2\uffff\1\14\1\27\1\16\1\23\1\26\1\46\1"+
1888         "\34\1\40\1\52\1\65\1\31\1\6\1\60\1\uffff\1\10\1\2\1\0\1\51}>";
1889     static final String[] DFA19_transitionS = {
1890             "\11\24\1\7\1\4\2\24\1\3\22\24\1\5\1\24\1\23\1\1\1\24\1\2\1"+
1891             "\24\1\26\1\10\1\11\1\15\1\17\1\12\1\6\14\24\1\13\3\24\1\14\1"+
1892             "\22\1\16\32\24\1\20\1\26\1\21\35\24\1\25\1\24\1\26\uff82\24",
1893             "",
1894             "",
1895             "\1\27",
1896             "\1\uffff",
1897             "\11\26\1\35\1\33\2\26\1\33\22\26\1\34\2\26\1\uffff\1\26\1"+
1898             "\uffff\7\26\1\6\uffd2\26",
1899             "",
1900             "\11\26\1\35\1\33\2\26\1\33\22\26\1\35\2\26\1\uffff\1\26\1"+
1901             "\uffff\7\26\1\uffff\uffd2\26",
1902             "\0\26",
1903             "\0\26",
1904             "\0\26",
1905             "\11\42\2\26\2\42\1\26\22\42\1\26\1\42\1\26\71\42\1\26\uffa3"+
1906             "\42",
1907             "\0\26",
1908             "\11\46\1\45\1\26\2\46\1\26\22\46\1\45\1\46\2\26\4\46\2\26"+
1909             "\2\46\1\50\15\46\1\47\3\46\1\47\34\46\1\47\1\26\1\47\35\46\1"+
1910             "\47\1\46\1\47\uff82\46",
1911             "\0\26",
1912             "\11\46\1\45\1\26\2\46\1\26\22\46\1\45\1\46\2\26\4\46\2\26"+
1913             "\2\46\1\50\15\46\1\47\3\46\1\47\34\46\1\47\1\26\1\47\35\46\1"+
1914             "\47\1\46\1\47\uff82\46",
1915             "\0\26",
1916             "\0\26",
1917             "\11\56\1\45\1\26\2\56\1\26\22\56\1\45\1\56\1\26\1\42\4\56"+
1918             "\2\42\2\56\1\60\15\56\1\57\3\56\1\57\34\56\1\57\1\26\1\57\35"+
1919             "\56\1\57\1\56\1\57\uff82\56",
1920             "\12\61\1\26\2\61\1\26\24\61\1\63\71\61\1\62\uffa3\61",
1921             "\11\46\1\45\1\26\2\46\1\26\22\46\1\45\1\46\2\26\4\46\2\26"+
1922             "\2\46\1\50\15\46\1\47\3\46\1\47\34\46\1\47\1\26\1\47\35\46\1"+
1923             "\47\1\46\1\47\uff82\46",
1924             "\0\26",
1925             "",
1926             "\1\uffff",
1927             "\1\uffff",
1928             "\1\uffff",
1929             "\1\uffff",
1930             "",
1931             "\11\26\1\35\1\33\2\26\1\33\22\26\1\34\2\26\1\uffff\1\26\1"+
1932             "\uffff\7\26\1\6\uffd2\26",
1933             "\11\26\1\35\1\33\2\26\1\33\22\26\1\35\2\26\1\uffff\1\26\1"+
1934             "\uffff\7\26\1\uffff\uffd2\26",
1935             "",
1936             "",
1937             "",
1938             "",
1939             "\11\74\1\72\1\26\2\74\1\26\22\74\1\72\1\74\2\26\4\74\2\26"+
1940             "\2\74\1\76\15\74\1\75\3\74\1\75\34\74\1\75\1\26\1\75\35\74\1"+
1941             "\75\1\74\1\75\uff82\74",
1942             "",
1943             "",
1944             "\11\46\1\45\1\26\2\46\1\26\22\46\1\45\1\46\2\26\4\46\2\26"+
1945             "\2\46\1\50\15\46\1\47\3\46\1\47\34\46\1\47\1\26\1\47\35\46\1"+
1946             "\47\1\46\1\47\uff82\46",
1947             "\11\46\1\45\1\26\2\46\1\26\22\46\1\45\1\46\2\26\4\46\2\26"+
1948             "\2\46\1\50\15\46\1\47\3\46\1\47\34\46\1\47\1\26\1\47\35\46\1"+
1949             "\47\1\46\1\47\uff82\46",
1950             "\11\46\1\45\1\26\2\46\1\26\22\46\1\45\1\46\2\26\4\46\2\26"+
1951             "\2\46\1\50\15\46\1\47\3\46\1\47\34\46\1\47\1\26\1\47\35\46\1"+
1952             "\47\1\46\1\47\uff82\46",
1953             "\11\46\1\45\1\26\2\46\1\26\22\46\1\45\1\46\2\26\4\46\2\26"+
1954             "\2\46\1\50\15\46\1\47\3\46\1\47\34\46\1\47\1\26\1\47\35\46\1"+
1955             "\47\1\46\1\47\uff82\46",
1956             "",
1957             "",
1958             "\1\uffff",
1959             "",
1960             "",
1961             "\11\102\1\101\1\26\2\102\1\26\22\102\1\101\1\102\2\26\4\102"+
1962             "\2\26\2\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103\1\26"+
1963             "\1\103\35\102\1\103\1\102\1\103\uff82\102",
1964             "\11\102\1\101\1\26\2\102\1\26\22\102\1\101\1\102\2\26\4\102"+
1965             "\2\26\2\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103\1\26"+
1966             "\1\103\35\102\1\103\1\102\1\103\uff82\102",
1967             "\11\102\1\101\1\26\2\102\1\26\22\102\1\101\1\102\2\26\4\102"+
1968             "\2\26\2\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103\1\26"+
1969             "\1\103\35\102\1\103\1\102\1\103\uff82\102",
1970             "\12\61\1\26\2\61\1\26\24\61\1\63\71\61\1\62\uffa3\61",
1971             "\42\26\1\105\14\26\1\107\54\26\1\106\5\26\1\110\3\26\1\111"+
1972             "\7\26\1\112\3\26\1\113\1\26\1\114\1\115\uff8a\26",
1973             "\0\26",
1974             "",
1975             "",
1976             "\1\uffff",
1977             "",
1978             "",
1979             "",
1980             "\11\74\1\72\1\26\2\74\1\26\22\74\1\72\1\74\2\26\4\74\2\26"+
1981             "\2\74\1\76\15\74\1\75\3\74\1\75\34\74\1\75\1\26\1\75\35\74\1"+
1982             "\75\1\74\1\75\uff82\74",
1983             "",
1984             "\11\74\1\72\1\26\2\74\1\26\22\74\1\72\1\74\2\26\4\74\2\26"+
1985             "\2\74\1\76\15\74\1\75\3\74\1\75\34\74\1\75\1\26\1\75\35\74\1"+
1986             "\75\1\74\1\75\uff82\74",
1987             "\11\74\1\72\1\26\2\74\1\26\22\74\1\72\1\74\2\26\4\74\2\26"+
1988             "\2\74\1\76\15\74\1\75\3\74\1\75\34\74\1\75\1\26\1\75\35\74\1"+
1989             "\75\1\74\1\75\uff82\74",
1990             "\11\74\1\72\1\26\2\74\1\26\22\74\1\72\1\74\2\26\4\74\2\26"+
1991             "\2\74\1\76\15\74\1\75\3\74\1\75\34\74\1\75\1\26\1\75\35\74\1"+
1992             "\75\1\74\1\75\uff82\74",
1993             "",
1994             "",
1995             "\11\102\1\101\1\26\2\102\1\26\22\102\1\101\1\102\2\26\4\102"+
1996             "\2\26\2\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103\1\26"+
1997             "\1\103\35\102\1\103\1\102\1\103\uff82\102",
1998             "\11\102\1\101\1\26\2\102\1\26\22\102\1\101\1\102\2\26\4\102"+
1999             "\2\26\2\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103\1\26"+
2000             "\1\103\35\102\1\103\1\102\1\103\uff82\102",
2001             "\11\102\1\101\1\26\2\102\1\26\22\102\1\101\1\102\2\26\4\102"+
2002             "\2\26\2\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103\1\26"+
2003             "\1\103\35\102\1\103\1\102\1\103\uff82\102",
2004             "\11\102\1\101\1\26\2\102\1\26\22\102\1\101\1\102\2\26\4\102"+
2005             "\2\26\2\102\1\104\15\102\1\103\3\102\1\103\34\102\1\103\1\26"+
2006             "\1\103\35\102\1\103\1\102\1\103\uff82\102",
2007             "\12\61\1\26\2\61\1\26\24\61\1\63\71\61\1\62\uffa3\61",
2008             "\12\61\1\26\2\61\1\26\24\61\1\63\71\61\1\62\uffa3\61",
2009             "\12\61\1\26\2\61\1\26\24\61\1\63\71\61\1\62\uffa3\61",
2010             "\12\61\1\26\2\61\1\26\24\61\1\63\71\61\1\62\uffa3\61",
2011             "\12\61\1\26\2\61\1\26\24\61\1\63\71\61\1\62\uffa3\61",
2012             "\12\61\1\26\2\61\1\26\24\61\1\63\71\61\1\62\uffa3\61",
2013             "\12\61\1\26\2\61\1\26\24\61\1\63\71\61\1\62\uffa3\61",
2014             "\12\61\1\26\2\61\1\26\24\61\1\63\71\61\1\62\uffa3\61",
2015             "\60\26\12\117\7\26\6\117\32\26\6\117\uff99\26",
2016             "",
2017             "\60\26\12\120\7\26\6\120\32\26\6\120\uff99\26",
2018             "\60\26\12\121\7\26\6\121\32\26\6\121\uff99\26",
2019             "\60\26\12\122\7\26\6\122\32\26\6\122\uff99\26",
2020             "\12\61\1\26\2\61\1\26\24\61\1\63\71\61\1\62\uffa3\61"
2021     };
2022
2023     static final short[] DFA19_eot = DFA.unpackEncodedString(DFA19_eotS);
2024     static final short[] DFA19_eof = DFA.unpackEncodedString(DFA19_eofS);
2025     static final char[] DFA19_min = DFA.unpackEncodedStringToUnsignedChars(DFA19_minS);
2026     static final char[] DFA19_max = DFA.unpackEncodedStringToUnsignedChars(DFA19_maxS);
2027     static final short[] DFA19_accept = DFA.unpackEncodedString(DFA19_acceptS);
2028     static final short[] DFA19_special = DFA.unpackEncodedString(DFA19_specialS);
2029     static final short[][] DFA19_transition;
2030
2031     static {
2032         int numStates = DFA19_transitionS.length;
2033         DFA19_transition = new short[numStates][];
2034         for (int i=0; i<numStates; i++) {
2035             DFA19_transition[i] = DFA.unpackEncodedString(DFA19_transitionS[i]);
2036         }
2037     }
2038
2039     class DFA19 extends DFA {
2040
2041         public DFA19(BaseRecognizer recognizer) {
2042             this.recognizer = recognizer;
2043             this.decisionNumber = 19;
2044             this.eot = DFA19_eot;
2045             this.eof = DFA19_eof;
2046             this.min = DFA19_min;
2047             this.max = DFA19_max;
2048             this.accept = DFA19_accept;
2049             this.special = DFA19_special;
2050             this.transition = DFA19_transition;
2051         }
2052         public String getDescription() {
2053             return "1:1: Tokens : ( LineComment | Preamble | LineBreak | NodeIndent | BlankLine | DataLine | LParen | RParen | Comma | Colon | Seq | Star | At | Plus | LBracket | RBracket | Question | String | PlainOneLine | JSON | Separation | WhiteSpace );";
2054         }
2055         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
2056             IntStream input = _input;
2057                 int _s = s;
2058             switch ( s ) {
2059                     case 0 :
2060                         int LA19_81 = input.LA(1);
2061
2062
2063                         int index19_81 = input.index();
2064                         input.rewind();
2065                         s = -1;
2066                         if ( ((LA19_81>='\u0000' && LA19_81<='/')||(LA19_81>=':' && LA19_81<='@')||(LA19_81>='G' && LA19_81<='`')||(LA19_81>='g' && LA19_81<='\uFFFF')) && (( isHead() ))) {s = 22;}
2067
2068                         else if ( ((LA19_81>='0' && LA19_81<='9')||(LA19_81>='A' && LA19_81<='F')||(LA19_81>='a' && LA19_81<='f')) ) {s = 82;}
2069
2070
2071                         input.seek(index19_81);
2072                         if ( s>=0 ) return s;
2073                         break;
2074                     case 1 :
2075                         int LA19_50 = input.LA(1);
2076
2077
2078                         int index19_50 = input.index();
2079                         input.rewind();
2080                         s = -1;
2081                         if ( (LA19_50=='\"') ) {s = 69;}
2082
2083                         else if ( (LA19_50=='\\') ) {s = 70;}
2084
2085                         else if ( (LA19_50=='/') ) {s = 71;}
2086
2087                         else if ( (LA19_50=='b') ) {s = 72;}
2088
2089                         else if ( (LA19_50=='f') ) {s = 73;}
2090
2091                         else if ( (LA19_50=='n') ) {s = 74;}
2092
2093                         else if ( (LA19_50=='r') ) {s = 75;}
2094
2095                         else if ( (LA19_50=='t') ) {s = 76;}
2096
2097                         else if ( (LA19_50=='u') ) {s = 77;}
2098
2099                         else if ( ((LA19_50>='\u0000' && LA19_50<='!')||(LA19_50>='#' && LA19_50<='.')||(LA19_50>='0' && LA19_50<='[')||(LA19_50>=']' && LA19_50<='a')||(LA19_50>='c' && LA19_50<='e')||(LA19_50>='g' && LA19_50<='m')||(LA19_50>='o' && LA19_50<='q')||LA19_50=='s'||(LA19_50>='v' && LA19_50<='\uFFFF')) && (( isHead() ))) {s = 22;}
2100
2101
2102                         input.seek(index19_50);
2103                         if ( s>=0 ) return s;
2104                         break;
2105                     case 2 :
2106                         int LA19_80 = input.LA(1);
2107
2108
2109                         int index19_80 = input.index();
2110                         input.rewind();
2111                         s = -1;
2112                         if ( ((LA19_80>='\u0000' && LA19_80<='/')||(LA19_80>=':' && LA19_80<='@')||(LA19_80>='G' && LA19_80<='`')||(LA19_80>='g' && LA19_80<='\uFFFF')) && (( isHead() ))) {s = 22;}
2113
2114                         else if ( ((LA19_80>='0' && LA19_80<='9')||(LA19_80>='A' && LA19_80<='F')||(LA19_80>='a' && LA19_80<='f')) ) {s = 81;}
2115
2116
2117                         input.seek(index19_80);
2118                         if ( s>=0 ) return s;
2119                         break;
2120                     case 3 :
2121                         int LA19_0 = input.LA(1);
2122
2123
2124                         int index19_0 = input.index();
2125                         input.rewind();
2126                         s = -1;
2127                         if ( (LA19_0=='#') ) {s = 1;}
2128
2129                         else if ( (LA19_0=='%') ) {s = 2;}
2130
2131                         else if ( (LA19_0=='\r') ) {s = 3;}
2132
2133                         else if ( (LA19_0=='\n') ) {s = 4;}
2134
2135                         else if ( (LA19_0==' ') ) {s = 5;}
2136
2137                         else if ( (LA19_0=='-') ) {s = 6;}
2138
2139                         else if ( (LA19_0=='\t') ) {s = 7;}
2140
2141                         else if ( (LA19_0=='(') ) {s = 8;}
2142
2143                         else if ( (LA19_0==')') ) {s = 9;}
2144
2145                         else if ( (LA19_0==',') ) {s = 10;}
2146
2147                         else if ( (LA19_0==':') ) {s = 11;}
2148
2149                         else if ( (LA19_0=='>') ) {s = 12;}
2150
2151                         else if ( (LA19_0=='*') ) {s = 13;}
2152
2153                         else if ( (LA19_0=='@') ) {s = 14;}
2154
2155                         else if ( (LA19_0=='+') ) {s = 15;}
2156
2157                         else if ( (LA19_0=='[') ) {s = 16;}
2158
2159                         else if ( (LA19_0==']') ) {s = 17;}
2160
2161                         else if ( (LA19_0=='?') ) {s = 18;}
2162
2163                         else if ( (LA19_0=='\"') ) {s = 19;}
2164
2165                         else if ( ((LA19_0>='\u0000' && LA19_0<='\b')||(LA19_0>='\u000B' && LA19_0<='\f')||(LA19_0>='\u000E' && LA19_0<='\u001F')||LA19_0=='!'||LA19_0=='$'||LA19_0=='&'||(LA19_0>='.' && LA19_0<='9')||(LA19_0>=';' && LA19_0<='=')||(LA19_0>='A' && LA19_0<='Z')||(LA19_0>='^' && LA19_0<='z')||LA19_0=='|'||(LA19_0>='~' && LA19_0<='\uFFFF')) ) {s = 20;}
2166
2167                         else if ( (LA19_0=='{') && ((( isHead() )||( isValue() )))) {s = 21;}
2168
2169                         else if ( (LA19_0=='\''||LA19_0=='\\'||LA19_0=='}') && (( isHead() ))) {s = 22;}
2170
2171
2172                         input.seek(index19_0);
2173                         if ( s>=0 ) return s;
2174                         break;
2175                     case 4 :
2176                         int LA19_13 = input.LA(1);
2177
2178
2179                         int index19_13 = input.index();
2180                         input.rewind();
2181                         s = -1;
2182                         if ( (LA19_13=='\t'||LA19_13==' ') ) {s = 37;}
2183
2184                         else if ( ((LA19_13>='\u0000' && LA19_13<='\b')||(LA19_13>='\u000B' && LA19_13<='\f')||(LA19_13>='\u000E' && LA19_13<='\u001F')||LA19_13=='!'||(LA19_13>='$' && LA19_13<='\'')||(LA19_13>='*' && LA19_13<='+')||(LA19_13>='-' && LA19_13<='9')||(LA19_13>=';' && LA19_13<='=')||(LA19_13>='?' && LA19_13<='Z')||(LA19_13>='^' && LA19_13<='z')||LA19_13=='|'||(LA19_13>='~' && LA19_13<='\uFFFF')) ) {s = 38;}
2185
2186                         else if ( (LA19_13==':'||LA19_13=='>'||LA19_13=='['||LA19_13==']'||LA19_13=='{'||LA19_13=='}') ) {s = 39;}
2187
2188                         else if ( (LA19_13==',') ) {s = 40;}
2189
2190                         else if ( (LA19_13=='\n'||LA19_13=='\r'||(LA19_13>='\"' && LA19_13<='#')||(LA19_13>='(' && LA19_13<=')')||LA19_13=='\\') && (( isHead() ))) {s = 22;}
2191
2192                         else s = 36;
2193
2194
2195                         input.seek(index19_13);
2196                         if ( s>=0 ) return s;
2197                         break;
2198                     case 5 :
2199                         int LA19_34 = input.LA(1);
2200
2201
2202                         int index19_34 = input.index();
2203                         input.rewind();
2204                         s = -1;
2205                         if ( (LA19_34=='\n'||LA19_34=='\r'||(LA19_34>='\"' && LA19_34<='#')||(LA19_34>='(' && LA19_34<=')')||LA19_34=='\\') && (( isHead() ))) {s = 22;}
2206
2207                         else if ( (LA19_34=='\t'||LA19_34==' ') && ((( isValue() )||( isHead() )))) {s = 58;}
2208
2209                         else if ( ((LA19_34>='\u0000' && LA19_34<='\b')||(LA19_34>='\u000B' && LA19_34<='\f')||(LA19_34>='\u000E' && LA19_34<='\u001F')||LA19_34=='!'||(LA19_34>='$' && LA19_34<='\'')||(LA19_34>='*' && LA19_34<='+')||(LA19_34>='-' && LA19_34<='9')||(LA19_34>=';' && LA19_34<='=')||(LA19_34>='?' && LA19_34<='Z')||(LA19_34>='^' && LA19_34<='z')||LA19_34=='|'||(LA19_34>='~' && LA19_34<='\uFFFF')) && ((( isValue() )||( isHead() )))) {s = 60;}
2210
2211                         else if ( (LA19_34==':'||LA19_34=='>'||LA19_34=='['||LA19_34==']'||LA19_34=='{'||LA19_34=='}') && ((( isHead() )||( isValue() )))) {s = 61;}
2212
2213                         else if ( (LA19_34==',') && ((( isValue() )||( isHead() )))) {s = 62;}
2214
2215                         else s = 59;
2216
2217
2218                         input.seek(index19_34);
2219                         if ( s>=0 ) return s;
2220                         break;
2221                     case 6 :
2222                         int LA19_76 = input.LA(1);
2223
2224
2225                         int index19_76 = input.index();
2226                         input.rewind();
2227                         s = -1;
2228                         if ( (LA19_76=='\n'||LA19_76=='\r') && (( isHead() ))) {s = 22;}
2229
2230                         else if ( (LA19_76=='\"') ) {s = 51;}
2231
2232                         else if ( ((LA19_76>='\u0000' && LA19_76<='\t')||(LA19_76>='\u000B' && LA19_76<='\f')||(LA19_76>='\u000E' && LA19_76<='!')||(LA19_76>='#' && LA19_76<='[')||(LA19_76>=']' && LA19_76<='\uFFFF')) ) {s = 49;}
2233
2234                         else if ( (LA19_76=='\\') ) {s = 50;}
2235
2236
2237                         input.seek(index19_76);
2238                         if ( s>=0 ) return s;
2239                         break;
2240                     case 7 :
2241                         int LA19_11 = input.LA(1);
2242
2243
2244                         int index19_11 = input.index();
2245                         input.rewind();
2246                         s = -1;
2247                         if ( ((LA19_11>='\u0000' && LA19_11<='\b')||(LA19_11>='\u000B' && LA19_11<='\f')||(LA19_11>='\u000E' && LA19_11<='\u001F')||LA19_11=='!'||(LA19_11>='#' && LA19_11<='[')||(LA19_11>=']' && LA19_11<='\uFFFF')) && ((( isValue() )||( isHead() )))) {s = 34;}
2248
2249                         else if ( ((LA19_11>='\t' && LA19_11<='\n')||LA19_11=='\r'||LA19_11==' '||LA19_11=='\"'||LA19_11=='\\') && (( isHead() ))) {s = 22;}
2250
2251                         else s = 33;
2252
2253
2254                         input.seek(index19_11);
2255                         if ( s>=0 ) return s;
2256                         break;
2257                     case 8 :
2258                         int LA19_79 = input.LA(1);
2259
2260
2261                         int index19_79 = input.index();
2262                         input.rewind();
2263                         s = -1;
2264                         if ( ((LA19_79>='\u0000' && LA19_79<='/')||(LA19_79>=':' && LA19_79<='@')||(LA19_79>='G' && LA19_79<='`')||(LA19_79>='g' && LA19_79<='\uFFFF')) && (( isHead() ))) {s = 22;}
2265
2266                         else if ( ((LA19_79>='0' && LA19_79<='9')||(LA19_79>='A' && LA19_79<='F')||(LA19_79>='a' && LA19_79<='f')) ) {s = 80;}
2267
2268
2269                         input.seek(index19_79);
2270                         if ( s>=0 ) return s;
2271                         break;
2272                     case 9 :
2273                         int LA19_51 = input.LA(1);
2274
2275
2276                         int index19_51 = input.index();
2277                         input.rewind();
2278                         s = -1;
2279                         if ( ((LA19_51>='\u0000' && LA19_51<='\uFFFF')) && (( isHead() ))) {s = 22;}
2280
2281                         else s = 78;
2282
2283
2284                         input.seek(index19_51);
2285                         if ( s>=0 ) return s;
2286                         break;
2287                     case 10 :
2288                         int LA19_5 = input.LA(1);
2289
2290
2291                         int index19_5 = input.index();
2292                         input.rewind();
2293                         s = -1;
2294                         if ( (LA19_5=='\n'||LA19_5=='\r') ) {s = 27;}
2295
2296                         else if ( (LA19_5==' ') ) {s = 28;}
2297
2298                         else if ( (LA19_5=='-') ) {s = 6;}
2299
2300                         else if ( (LA19_5=='\t') ) {s = 29;}
2301
2302                         else if ( ((LA19_5>='\u0000' && LA19_5<='\b')||(LA19_5>='\u000B' && LA19_5<='\f')||(LA19_5>='\u000E' && LA19_5<='\u001F')||(LA19_5>='!' && LA19_5<='\"')||LA19_5=='$'||(LA19_5>='&' && LA19_5<=',')||(LA19_5>='.' && LA19_5<='\uFFFF')) && (( isHead() ))) {s = 22;}
2303
2304                         else s = 26;
2305
2306
2307                         input.seek(index19_5);
2308                         if ( s>=0 ) return s;
2309                         break;
2310                     case 11 :
2311                         int LA19_43 = input.LA(1);
2312
2313
2314                         int index19_43 = input.index();
2315                         input.rewind();
2316                         s = -1;
2317                         if ( (!((( isValue() )))) ) {s = 63;}
2318
2319                         else if ( (( isValue() )) ) {s = 53;}
2320
2321
2322                         input.seek(index19_43);
2323                         if ( s>=0 ) return s;
2324                         break;
2325                     case 12 :
2326                         int LA19_65 = input.LA(1);
2327
2328
2329                         int index19_65 = input.index();
2330                         input.rewind();
2331                         s = -1;
2332                         if ( ((LA19_65>='\u0000' && LA19_65<='\b')||(LA19_65>='\u000B' && LA19_65<='\f')||(LA19_65>='\u000E' && LA19_65<='\u001F')||LA19_65=='!'||(LA19_65>='$' && LA19_65<='\'')||(LA19_65>='*' && LA19_65<='+')||(LA19_65>='-' && LA19_65<='9')||(LA19_65>=';' && LA19_65<='=')||(LA19_65>='?' && LA19_65<='Z')||(LA19_65>='^' && LA19_65<='z')||LA19_65=='|'||(LA19_65>='~' && LA19_65<='\uFFFF')) ) {s = 66;}
2333
2334                         else if ( (LA19_65==':'||LA19_65=='>'||LA19_65=='['||LA19_65==']'||LA19_65=='{'||LA19_65=='}') ) {s = 67;}
2335
2336                         else if ( (LA19_65==',') ) {s = 68;}
2337
2338                         else if ( (LA19_65=='\t'||LA19_65==' ') ) {s = 65;}
2339
2340                         else if ( (LA19_65=='\n'||LA19_65=='\r'||(LA19_65>='\"' && LA19_65<='#')||(LA19_65>='(' && LA19_65<=')')||LA19_65=='\\') && (( isHead() ))) {s = 22;}
2341
2342
2343                         input.seek(index19_65);
2344                         if ( s>=0 ) return s;
2345                         break;
2346                     case 13 :
2347                         int LA19_21 = input.LA(1);
2348
2349
2350                         int index19_21 = input.index();
2351                         input.rewind();
2352                         s = -1;
2353                         if ( ((LA19_21>='\u0000' && LA19_21<='\uFFFF')) && (( isHead() ))) {s = 22;}
2354
2355                         else s = 53;
2356
2357
2358                         input.seek(index19_21);
2359                         if ( s>=0 ) return s;
2360                         break;
2361                     case 14 :
2362                         int LA19_67 = input.LA(1);
2363
2364
2365                         int index19_67 = input.index();
2366                         input.rewind();
2367                         s = -1;
2368                         if ( (LA19_67=='\t'||LA19_67==' ') ) {s = 65;}
2369
2370                         else if ( ((LA19_67>='\u0000' && LA19_67<='\b')||(LA19_67>='\u000B' && LA19_67<='\f')||(LA19_67>='\u000E' && LA19_67<='\u001F')||LA19_67=='!'||(LA19_67>='$' && LA19_67<='\'')||(LA19_67>='*' && LA19_67<='+')||(LA19_67>='-' && LA19_67<='9')||(LA19_67>=';' && LA19_67<='=')||(LA19_67>='?' && LA19_67<='Z')||(LA19_67>='^' && LA19_67<='z')||LA19_67=='|'||(LA19_67>='~' && LA19_67<='\uFFFF')) ) {s = 66;}
2371
2372                         else if ( (LA19_67==':'||LA19_67=='>'||LA19_67=='['||LA19_67==']'||LA19_67=='{'||LA19_67=='}') ) {s = 67;}
2373
2374                         else if ( (LA19_67==',') ) {s = 68;}
2375
2376                         else if ( (LA19_67=='\n'||LA19_67=='\r'||(LA19_67>='\"' && LA19_67<='#')||(LA19_67>='(' && LA19_67<=')')||LA19_67=='\\') && (( isHead() ))) {s = 22;}
2377
2378                         else s = 64;
2379
2380
2381                         input.seek(index19_67);
2382                         if ( s>=0 ) return s;
2383                         break;
2384                     case 15 :
2385                         int LA19_47 = input.LA(1);
2386
2387
2388                         int index19_47 = input.index();
2389                         input.rewind();
2390                         s = -1;
2391                         if ( (LA19_47=='\t'||LA19_47==' ') ) {s = 65;}
2392
2393                         else if ( ((LA19_47>='\u0000' && LA19_47<='\b')||(LA19_47>='\u000B' && LA19_47<='\f')||(LA19_47>='\u000E' && LA19_47<='\u001F')||LA19_47=='!'||(LA19_47>='$' && LA19_47<='\'')||(LA19_47>='*' && LA19_47<='+')||(LA19_47>='-' && LA19_47<='9')||(LA19_47>=';' && LA19_47<='=')||(LA19_47>='?' && LA19_47<='Z')||(LA19_47>='^' && LA19_47<='z')||LA19_47=='|'||(LA19_47>='~' && LA19_47<='\uFFFF')) ) {s = 66;}
2394
2395                         else if ( (LA19_47==':'||LA19_47=='>'||LA19_47=='['||LA19_47==']'||LA19_47=='{'||LA19_47=='}') ) {s = 67;}
2396
2397                         else if ( (LA19_47==',') ) {s = 68;}
2398
2399                         else if ( (LA19_47=='\n'||LA19_47=='\r'||(LA19_47>='\"' && LA19_47<='#')||(LA19_47>='(' && LA19_47<=')')||LA19_47=='\\') && (( isHead() ))) {s = 22;}
2400
2401                         else s = 64;
2402
2403
2404                         input.seek(index19_47);
2405                         if ( s>=0 ) return s;
2406                         break;
2407                     case 16 :
2408                         int LA19_17 = input.LA(1);
2409
2410
2411                         int index19_17 = input.index();
2412                         input.rewind();
2413                         s = -1;
2414                         if ( ((LA19_17>='\u0000' && LA19_17<='\uFFFF')) && (( isHead() ))) {s = 22;}
2415
2416                         else s = 44;
2417
2418
2419                         input.seek(index19_17);
2420                         if ( s>=0 ) return s;
2421                         break;
2422                     case 17 :
2423                         int LA19_62 = input.LA(1);
2424
2425
2426                         int index19_62 = input.index();
2427                         input.rewind();
2428                         s = -1;
2429                         if ( (LA19_62=='\t'||LA19_62==' ') && ((( isValue() )||( isHead() )))) {s = 58;}
2430
2431                         else if ( ((LA19_62>='\u0000' && LA19_62<='\b')||(LA19_62>='\u000B' && LA19_62<='\f')||(LA19_62>='\u000E' && LA19_62<='\u001F')||LA19_62=='!'||(LA19_62>='$' && LA19_62<='\'')||(LA19_62>='*' && LA19_62<='+')||(LA19_62>='-' && LA19_62<='9')||(LA19_62>=';' && LA19_62<='=')||(LA19_62>='?' && LA19_62<='Z')||(LA19_62>='^' && LA19_62<='z')||LA19_62=='|'||(LA19_62>='~' && LA19_62<='\uFFFF')) && ((( isValue() )||( isHead() )))) {s = 60;}
2432
2433                         else if ( (LA19_62==':'||LA19_62=='>'||LA19_62=='['||LA19_62==']'||LA19_62=='{'||LA19_62=='}') && ((( isHead() )||( isValue() )))) {s = 61;}
2434
2435                         else if ( (LA19_62==',') && ((( isValue() )||( isHead() )))) {s = 62;}
2436
2437                         else if ( (LA19_62=='\n'||LA19_62=='\r'||(LA19_62>='\"' && LA19_62<='#')||(LA19_62>='(' && LA19_62<=')')||LA19_62=='\\') && (( isHead() ))) {s = 22;}
2438
2439                         else s = 59;
2440
2441
2442                         input.seek(index19_62);
2443                         if ( s>=0 ) return s;
2444                         break;
2445                     case 18 :
2446                         int LA19_40 = input.LA(1);
2447
2448
2449                         int index19_40 = input.index();
2450                         input.rewind();
2451                         s = -1;
2452                         if ( (LA19_40=='\t'||LA19_40==' ') ) {s = 37;}
2453
2454                         else if ( ((LA19_40>='\u0000' && LA19_40<='\b')||(LA19_40>='\u000B' && LA19_40<='\f')||(LA19_40>='\u000E' && LA19_40<='\u001F')||LA19_40=='!'||(LA19_40>='$' && LA19_40<='\'')||(LA19_40>='*' && LA19_40<='+')||(LA19_40>='-' && LA19_40<='9')||(LA19_40>=';' && LA19_40<='=')||(LA19_40>='?' && LA19_40<='Z')||(LA19_40>='^' && LA19_40<='z')||LA19_40=='|'||(LA19_40>='~' && LA19_40<='\uFFFF')) ) {s = 38;}
2455
2456                         else if ( (LA19_40==':'||LA19_40=='>'||LA19_40=='['||LA19_40==']'||LA19_40=='{'||LA19_40=='}') ) {s = 39;}
2457
2458                         else if ( (LA19_40==',') ) {s = 40;}
2459
2460                         else if ( (LA19_40=='\n'||LA19_40=='\r'||(LA19_40>='\"' && LA19_40<='#')||(LA19_40>='(' && LA19_40<=')')||LA19_40=='\\') && (( isHead() ))) {s = 22;}
2461
2462                         else s = 52;
2463
2464
2465                         input.seek(index19_40);
2466                         if ( s>=0 ) return s;
2467                         break;
2468                     case 19 :
2469                         int LA19_68 = input.LA(1);
2470
2471
2472                         int index19_68 = input.index();
2473                         input.rewind();
2474                         s = -1;
2475                         if ( (LA19_68=='\t'||LA19_68==' ') ) {s = 65;}
2476
2477                         else if ( ((LA19_68>='\u0000' && LA19_68<='\b')||(LA19_68>='\u000B' && LA19_68<='\f')||(LA19_68>='\u000E' && LA19_68<='\u001F')||LA19_68=='!'||(LA19_68>='$' && LA19_68<='\'')||(LA19_68>='*' && LA19_68<='+')||(LA19_68>='-' && LA19_68<='9')||(LA19_68>=';' && LA19_68<='=')||(LA19_68>='?' && LA19_68<='Z')||(LA19_68>='^' && LA19_68<='z')||LA19_68=='|'||(LA19_68>='~' && LA19_68<='\uFFFF')) ) {s = 66;}
2478
2479                         else if ( (LA19_68==':'||LA19_68=='>'||LA19_68=='['||LA19_68==']'||LA19_68=='{'||LA19_68=='}') ) {s = 67;}
2480
2481                         else if ( (LA19_68==',') ) {s = 68;}
2482
2483                         else if ( (LA19_68=='\n'||LA19_68=='\r'||(LA19_68>='\"' && LA19_68<='#')||(LA19_68>='(' && LA19_68<=')')||LA19_68=='\\') && (( isHead() ))) {s = 22;}
2484
2485                         else s = 64;
2486
2487
2488                         input.seek(index19_68);
2489                         if ( s>=0 ) return s;
2490                         break;
2491                     case 20 :
2492                         int LA19_29 = input.LA(1);
2493
2494
2495                         int index19_29 = input.index();
2496                         input.rewind();
2497                         s = -1;
2498                         if ( (LA19_29=='\n'||LA19_29=='\r') ) {s = 27;}
2499
2500                         else if ( (LA19_29=='\t'||LA19_29==' ') ) {s = 29;}
2501
2502                         else if ( ((LA19_29>='\u0000' && LA19_29<='\b')||(LA19_29>='\u000B' && LA19_29<='\f')||(LA19_29>='\u000E' && LA19_29<='\u001F')||(LA19_29>='!' && LA19_29<='\"')||LA19_29=='$'||(LA19_29>='&' && LA19_29<=',')||(LA19_29>='.' && LA19_29<='\uFFFF')) && (( isHead() ))) {s = 22;}
2503
2504                         else s = 56;
2505
2506
2507                         input.seek(index19_29);
2508                         if ( s>=0 ) return s;
2509                         break;
2510                     case 21 :
2511                         int LA19_49 = input.LA(1);
2512
2513
2514                         int index19_49 = input.index();
2515                         input.rewind();
2516                         s = -1;
2517                         if ( (LA19_49=='\n'||LA19_49=='\r') && (( isHead() ))) {s = 22;}
2518
2519                         else if ( (LA19_49=='\"') ) {s = 51;}
2520
2521                         else if ( ((LA19_49>='\u0000' && LA19_49<='\t')||(LA19_49>='\u000B' && LA19_49<='\f')||(LA19_49>='\u000E' && LA19_49<='!')||(LA19_49>='#' && LA19_49<='[')||(LA19_49>=']' && LA19_49<='\uFFFF')) ) {s = 49;}
2522
2523                         else if ( (LA19_49=='\\') ) {s = 50;}
2524
2525
2526                         input.seek(index19_49);
2527                         if ( s>=0 ) return s;
2528                         break;
2529                     case 22 :
2530                         int LA19_69 = input.LA(1);
2531
2532
2533                         int index19_69 = input.index();
2534                         input.rewind();
2535                         s = -1;
2536                         if ( (LA19_69=='\n'||LA19_69=='\r') && (( isHead() ))) {s = 22;}
2537
2538                         else if ( (LA19_69=='\"') ) {s = 51;}
2539
2540                         else if ( ((LA19_69>='\u0000' && LA19_69<='\t')||(LA19_69>='\u000B' && LA19_69<='\f')||(LA19_69>='\u000E' && LA19_69<='!')||(LA19_69>='#' && LA19_69<='[')||(LA19_69>=']' && LA19_69<='\uFFFF')) ) {s = 49;}
2541
2542                         else if ( (LA19_69=='\\') ) {s = 50;}
2543
2544
2545                         input.seek(index19_69);
2546                         if ( s>=0 ) return s;
2547                         break;
2548                     case 23 :
2549                         int LA19_66 = input.LA(1);
2550
2551
2552                         int index19_66 = input.index();
2553                         input.rewind();
2554                         s = -1;
2555                         if ( (LA19_66=='\t'||LA19_66==' ') ) {s = 65;}
2556
2557                         else if ( ((LA19_66>='\u0000' && LA19_66<='\b')||(LA19_66>='\u000B' && LA19_66<='\f')||(LA19_66>='\u000E' && LA19_66<='\u001F')||LA19_66=='!'||(LA19_66>='$' && LA19_66<='\'')||(LA19_66>='*' && LA19_66<='+')||(LA19_66>='-' && LA19_66<='9')||(LA19_66>=';' && LA19_66<='=')||(LA19_66>='?' && LA19_66<='Z')||(LA19_66>='^' && LA19_66<='z')||LA19_66=='|'||(LA19_66>='~' && LA19_66<='\uFFFF')) ) {s = 66;}
2558
2559                         else if ( (LA19_66==':'||LA19_66=='>'||LA19_66=='['||LA19_66==']'||LA19_66=='{'||LA19_66=='}') ) {s = 67;}
2560
2561                         else if ( (LA19_66==',') ) {s = 68;}
2562
2563                         else if ( (LA19_66=='\n'||LA19_66=='\r'||(LA19_66>='\"' && LA19_66<='#')||(LA19_66>='(' && LA19_66<=')')||LA19_66=='\\') && (( isHead() ))) {s = 22;}
2564
2565                         else s = 64;
2566
2567
2568                         input.seek(index19_66);
2569                         if ( s>=0 ) return s;
2570                         break;
2571                     case 24 :
2572                         int LA19_20 = input.LA(1);
2573
2574
2575                         int index19_20 = input.index();
2576                         input.rewind();
2577                         s = -1;
2578                         if ( (LA19_20=='\t'||LA19_20==' ') ) {s = 37;}
2579
2580                         else if ( ((LA19_20>='\u0000' && LA19_20<='\b')||(LA19_20>='\u000B' && LA19_20<='\f')||(LA19_20>='\u000E' && LA19_20<='\u001F')||LA19_20=='!'||(LA19_20>='$' && LA19_20<='\'')||(LA19_20>='*' && LA19_20<='+')||(LA19_20>='-' && LA19_20<='9')||(LA19_20>=';' && LA19_20<='=')||(LA19_20>='?' && LA19_20<='Z')||(LA19_20>='^' && LA19_20<='z')||LA19_20=='|'||(LA19_20>='~' && LA19_20<='\uFFFF')) ) {s = 38;}
2581
2582                         else if ( (LA19_20==':'||LA19_20=='>'||LA19_20=='['||LA19_20==']'||LA19_20=='{'||LA19_20=='}') ) {s = 39;}
2583
2584                         else if ( (LA19_20==',') ) {s = 40;}
2585
2586                         else if ( (LA19_20=='\n'||LA19_20=='\r'||(LA19_20>='\"' && LA19_20<='#')||(LA19_20>='(' && LA19_20<=')')||LA19_20=='\\') && (( isHead() ))) {s = 22;}
2587
2588                         else s = 52;
2589
2590
2591                         input.seek(index19_20);
2592                         if ( s>=0 ) return s;
2593                         break;
2594                     case 25 :
2595                         int LA19_75 = input.LA(1);
2596
2597
2598                         int index19_75 = input.index();
2599                         input.rewind();
2600                         s = -1;
2601                         if ( (LA19_75=='\n'||LA19_75=='\r') && (( isHead() ))) {s = 22;}
2602
2603                         else if ( (LA19_75=='\"') ) {s = 51;}
2604
2605                         else if ( ((LA19_75>='\u0000' && LA19_75<='\t')||(LA19_75>='\u000B' && LA19_75<='\f')||(LA19_75>='\u000E' && LA19_75<='!')||(LA19_75>='#' && LA19_75<='[')||(LA19_75>=']' && LA19_75<='\uFFFF')) ) {s = 49;}
2606
2607                         else if ( (LA19_75=='\\') ) {s = 50;}
2608
2609
2610                         input.seek(index19_75);
2611                         if ( s>=0 ) return s;
2612                         break;
2613                     case 26 :
2614                         int LA19_60 = input.LA(1);
2615
2616
2617                         int index19_60 = input.index();
2618                         input.rewind();
2619                         s = -1;
2620                         if ( (LA19_60=='\t'||LA19_60==' ') && ((( isValue() )||( isHead() )))) {s = 58;}
2621
2622                         else if ( ((LA19_60>='\u0000' && LA19_60<='\b')||(LA19_60>='\u000B' && LA19_60<='\f')||(LA19_60>='\u000E' && LA19_60<='\u001F')||LA19_60=='!'||(LA19_60>='$' && LA19_60<='\'')||(LA19_60>='*' && LA19_60<='+')||(LA19_60>='-' && LA19_60<='9')||(LA19_60>=';' && LA19_60<='=')||(LA19_60>='?' && LA19_60<='Z')||(LA19_60>='^' && LA19_60<='z')||LA19_60=='|'||(LA19_60>='~' && LA19_60<='\uFFFF')) && ((( isValue() )||( isHead() )))) {s = 60;}
2623
2624                         else if ( (LA19_60==':'||LA19_60=='>'||LA19_60=='['||LA19_60==']'||LA19_60=='{'||LA19_60=='}') && ((( isHead() )||( isValue() )))) {s = 61;}
2625
2626                         else if ( (LA19_60==',') && ((( isValue() )||( isHead() )))) {s = 62;}
2627
2628                         else if ( (LA19_60=='\n'||LA19_60=='\r'||(LA19_60>='\"' && LA19_60<='#')||(LA19_60>='(' && LA19_60<=')')||LA19_60=='\\') && (( isHead() ))) {s = 22;}
2629
2630                         else s = 59;
2631
2632
2633                         input.seek(index19_60);
2634                         if ( s>=0 ) return s;
2635                         break;
2636                     case 27 :
2637                         int LA19_38 = input.LA(1);
2638
2639
2640                         int index19_38 = input.index();
2641                         input.rewind();
2642                         s = -1;
2643                         if ( (LA19_38=='\t'||LA19_38==' ') ) {s = 37;}
2644
2645                         else if ( ((LA19_38>='\u0000' && LA19_38<='\b')||(LA19_38>='\u000B' && LA19_38<='\f')||(LA19_38>='\u000E' && LA19_38<='\u001F')||LA19_38=='!'||(LA19_38>='$' && LA19_38<='\'')||(LA19_38>='*' && LA19_38<='+')||(LA19_38>='-' && LA19_38<='9')||(LA19_38>=';' && LA19_38<='=')||(LA19_38>='?' && LA19_38<='Z')||(LA19_38>='^' && LA19_38<='z')||LA19_38=='|'||(LA19_38>='~' && LA19_38<='\uFFFF')) ) {s = 38;}
2646
2647                         else if ( (LA19_38==':'||LA19_38=='>'||LA19_38=='['||LA19_38==']'||LA19_38=='{'||LA19_38=='}') ) {s = 39;}
2648
2649                         else if ( (LA19_38==',') ) {s = 40;}
2650
2651                         else if ( (LA19_38=='\n'||LA19_38=='\r'||(LA19_38>='\"' && LA19_38<='#')||(LA19_38>='(' && LA19_38<=')')||LA19_38=='\\') && (( isHead() ))) {s = 22;}
2652
2653                         else s = 52;
2654
2655
2656                         input.seek(index19_38);
2657                         if ( s>=0 ) return s;
2658                         break;
2659                     case 28 :
2660                         int LA19_71 = input.LA(1);
2661
2662
2663                         int index19_71 = input.index();
2664                         input.rewind();
2665                         s = -1;
2666                         if ( (LA19_71=='\n'||LA19_71=='\r') && (( isHead() ))) {s = 22;}
2667
2668                         else if ( (LA19_71=='\"') ) {s = 51;}
2669
2670                         else if ( ((LA19_71>='\u0000' && LA19_71<='\t')||(LA19_71>='\u000B' && LA19_71<='\f')||(LA19_71>='\u000E' && LA19_71<='!')||(LA19_71>='#' && LA19_71<='[')||(LA19_71>=']' && LA19_71<='\uFFFF')) ) {s = 49;}
2671
2672                         else if ( (LA19_71=='\\') ) {s = 50;}
2673
2674
2675                         input.seek(index19_71);
2676                         if ( s>=0 ) return s;
2677                         break;
2678                     case 29 :
2679                         int LA19_7 = input.LA(1);
2680
2681
2682                         int index19_7 = input.index();
2683                         input.rewind();
2684                         s = -1;
2685                         if ( (LA19_7=='\n'||LA19_7=='\r') ) {s = 27;}
2686
2687                         else if ( (LA19_7=='\t'||LA19_7==' ') ) {s = 29;}
2688
2689                         else if ( ((LA19_7>='\u0000' && LA19_7<='\b')||(LA19_7>='\u000B' && LA19_7<='\f')||(LA19_7>='\u000E' && LA19_7<='\u001F')||(LA19_7>='!' && LA19_7<='\"')||LA19_7=='$'||(LA19_7>='&' && LA19_7<=',')||(LA19_7>='.' && LA19_7<='\uFFFF')) && (( isHead() ))) {s = 22;}
2690
2691                         else s = 26;
2692
2693
2694                         input.seek(index19_7);
2695                         if ( s>=0 ) return s;
2696                         break;
2697                     case 30 :
2698                         int LA19_26 = input.LA(1);
2699
2700
2701                         int index19_26 = input.index();
2702                         input.rewind();
2703                         s = -1;
2704                         if ( (( currentState() != State.INIT )) ) {s = 56;}
2705
2706                         else if ( (true) ) {s = 57;}
2707
2708
2709                         input.seek(index19_26);
2710                         if ( s>=0 ) return s;
2711                         break;
2712                     case 31 :
2713                         int LA19_8 = input.LA(1);
2714
2715
2716                         int index19_8 = input.index();
2717                         input.rewind();
2718                         s = -1;
2719                         if ( ((LA19_8>='\u0000' && LA19_8<='\uFFFF')) && (( isHead() ))) {s = 22;}
2720
2721                         else s = 30;
2722
2723
2724                         input.seek(index19_8);
2725                         if ( s>=0 ) return s;
2726                         break;
2727                     case 32 :
2728                         int LA19_72 = input.LA(1);
2729
2730
2731                         int index19_72 = input.index();
2732                         input.rewind();
2733                         s = -1;
2734                         if ( (LA19_72=='\n'||LA19_72=='\r') && (( isHead() ))) {s = 22;}
2735
2736                         else if ( (LA19_72=='\"') ) {s = 51;}
2737
2738                         else if ( ((LA19_72>='\u0000' && LA19_72<='\t')||(LA19_72>='\u000B' && LA19_72<='\f')||(LA19_72>='\u000E' && LA19_72<='!')||(LA19_72>='#' && LA19_72<='[')||(LA19_72>=']' && LA19_72<='\uFFFF')) ) {s = 49;}
2739
2740                         else if ( (LA19_72=='\\') ) {s = 50;}
2741
2742
2743                         input.seek(index19_72);
2744                         if ( s>=0 ) return s;
2745                         break;
2746                     case 33 :
2747                         int LA19_15 = input.LA(1);
2748
2749
2750                         int index19_15 = input.index();
2751                         input.rewind();
2752                         s = -1;
2753                         if ( (LA19_15=='\t'||LA19_15==' ') ) {s = 37;}
2754
2755                         else if ( ((LA19_15>='\u0000' && LA19_15<='\b')||(LA19_15>='\u000B' && LA19_15<='\f')||(LA19_15>='\u000E' && LA19_15<='\u001F')||LA19_15=='!'||(LA19_15>='$' && LA19_15<='\'')||(LA19_15>='*' && LA19_15<='+')||(LA19_15>='-' && LA19_15<='9')||(LA19_15>=';' && LA19_15<='=')||(LA19_15>='?' && LA19_15<='Z')||(LA19_15>='^' && LA19_15<='z')||LA19_15=='|'||(LA19_15>='~' && LA19_15<='\uFFFF')) ) {s = 38;}
2756
2757                         else if ( (LA19_15==':'||LA19_15=='>'||LA19_15=='['||LA19_15==']'||LA19_15=='{'||LA19_15=='}') ) {s = 39;}
2758
2759                         else if ( (LA19_15==',') ) {s = 40;}
2760
2761                         else if ( (LA19_15=='\n'||LA19_15=='\r'||(LA19_15>='\"' && LA19_15<='#')||(LA19_15>='(' && LA19_15<=')')||LA19_15=='\\') && (( isHead() ))) {s = 22;}
2762
2763                         else s = 42;
2764
2765
2766                         input.seek(index19_15);
2767                         if ( s>=0 ) return s;
2768                         break;
2769                     case 34 :
2770                         int LA19_48 = input.LA(1);
2771
2772
2773                         int index19_48 = input.index();
2774                         input.rewind();
2775                         s = -1;
2776                         if ( (LA19_48=='\t'||LA19_48==' ') ) {s = 65;}
2777
2778                         else if ( ((LA19_48>='\u0000' && LA19_48<='\b')||(LA19_48>='\u000B' && LA19_48<='\f')||(LA19_48>='\u000E' && LA19_48<='\u001F')||LA19_48=='!'||(LA19_48>='$' && LA19_48<='\'')||(LA19_48>='*' && LA19_48<='+')||(LA19_48>='-' && LA19_48<='9')||(LA19_48>=';' && LA19_48<='=')||(LA19_48>='?' && LA19_48<='Z')||(LA19_48>='^' && LA19_48<='z')||LA19_48=='|'||(LA19_48>='~' && LA19_48<='\uFFFF')) ) {s = 66;}
2779
2780                         else if ( (LA19_48==':'||LA19_48=='>'||LA19_48=='['||LA19_48==']'||LA19_48=='{'||LA19_48=='}') ) {s = 67;}
2781
2782                         else if ( (LA19_48==',') ) {s = 68;}
2783
2784                         else if ( (LA19_48=='\n'||LA19_48=='\r'||(LA19_48>='\"' && LA19_48<='#')||(LA19_48>='(' && LA19_48<=')')||LA19_48=='\\') && (( isHead() ))) {s = 22;}
2785
2786                         else s = 64;
2787
2788
2789                         input.seek(index19_48);
2790                         if ( s>=0 ) return s;
2791                         break;
2792                     case 35 :
2793                         int LA19_46 = input.LA(1);
2794
2795
2796                         int index19_46 = input.index();
2797                         input.rewind();
2798                         s = -1;
2799                         if ( (LA19_46=='\t'||LA19_46==' ') ) {s = 65;}
2800
2801                         else if ( ((LA19_46>='\u0000' && LA19_46<='\b')||(LA19_46>='\u000B' && LA19_46<='\f')||(LA19_46>='\u000E' && LA19_46<='\u001F')||LA19_46=='!'||(LA19_46>='$' && LA19_46<='\'')||(LA19_46>='*' && LA19_46<='+')||(LA19_46>='-' && LA19_46<='9')||(LA19_46>=';' && LA19_46<='=')||(LA19_46>='?' && LA19_46<='Z')||(LA19_46>='^' && LA19_46<='z')||LA19_46=='|'||(LA19_46>='~' && LA19_46<='\uFFFF')) ) {s = 66;}
2802
2803                         else if ( (LA19_46==':'||LA19_46=='>'||LA19_46=='['||LA19_46==']'||LA19_46=='{'||LA19_46=='}') ) {s = 67;}
2804
2805                         else if ( (LA19_46==',') ) {s = 68;}
2806
2807                         else if ( (LA19_46=='\n'||LA19_46=='\r'||(LA19_46>='\"' && LA19_46<='#')||(LA19_46>='(' && LA19_46<=')')||LA19_46=='\\') && (( isHead() ))) {s = 22;}
2808
2809                         else s = 64;
2810
2811
2812                         input.seek(index19_46);
2813                         if ( s>=0 ) return s;
2814                         break;
2815                     case 36 :
2816                         int LA19_58 = input.LA(1);
2817
2818
2819                         int index19_58 = input.index();
2820                         input.rewind();
2821                         s = -1;
2822                         if ( ((LA19_58>='\u0000' && LA19_58<='\b')||(LA19_58>='\u000B' && LA19_58<='\f')||(LA19_58>='\u000E' && LA19_58<='\u001F')||LA19_58=='!'||(LA19_58>='$' && LA19_58<='\'')||(LA19_58>='*' && LA19_58<='+')||(LA19_58>='-' && LA19_58<='9')||(LA19_58>=';' && LA19_58<='=')||(LA19_58>='?' && LA19_58<='Z')||(LA19_58>='^' && LA19_58<='z')||LA19_58=='|'||(LA19_58>='~' && LA19_58<='\uFFFF')) && ((( isValue() )||( isHead() )))) {s = 60;}
2823
2824                         else if ( (LA19_58==':'||LA19_58=='>'||LA19_58=='['||LA19_58==']'||LA19_58=='{'||LA19_58=='}') && ((( isHead() )||( isValue() )))) {s = 61;}
2825
2826                         else if ( (LA19_58==',') && ((( isValue() )||( isHead() )))) {s = 62;}
2827
2828                         else if ( (LA19_58=='\t'||LA19_58==' ') && ((( isValue() )||( isHead() )))) {s = 58;}
2829
2830                         else if ( (LA19_58=='\n'||LA19_58=='\r'||(LA19_58>='\"' && LA19_58<='#')||(LA19_58>='(' && LA19_58<=')')||LA19_58=='\\') && (( isHead() ))) {s = 22;}
2831
2832
2833                         input.seek(index19_58);
2834                         if ( s>=0 ) return s;
2835                         break;
2836                     case 37 :
2837                         int LA19_37 = input.LA(1);
2838
2839
2840                         int index19_37 = input.index();
2841                         input.rewind();
2842                         s = -1;
2843                         if ( (LA19_37=='\n'||LA19_37=='\r'||(LA19_37>='\"' && LA19_37<='#')||(LA19_37>='(' && LA19_37<=')')||LA19_37=='\\') && (( isHead() ))) {s = 22;}
2844
2845                         else if ( ((LA19_37>='\u0000' && LA19_37<='\b')||(LA19_37>='\u000B' && LA19_37<='\f')||(LA19_37>='\u000E' && LA19_37<='\u001F')||LA19_37=='!'||(LA19_37>='$' && LA19_37<='\'')||(LA19_37>='*' && LA19_37<='+')||(LA19_37>='-' && LA19_37<='9')||(LA19_37>=';' && LA19_37<='=')||(LA19_37>='?' && LA19_37<='Z')||(LA19_37>='^' && LA19_37<='z')||LA19_37=='|'||(LA19_37>='~' && LA19_37<='\uFFFF')) ) {s = 38;}
2846
2847                         else if ( (LA19_37==':'||LA19_37=='>'||LA19_37=='['||LA19_37==']'||LA19_37=='{'||LA19_37=='}') ) {s = 39;}
2848
2849                         else if ( (LA19_37==',') ) {s = 40;}
2850
2851                         else if ( (LA19_37=='\t'||LA19_37==' ') ) {s = 37;}
2852
2853
2854                         input.seek(index19_37);
2855                         if ( s>=0 ) return s;
2856                         break;
2857                     case 38 :
2858                         int LA19_70 = input.LA(1);
2859
2860
2861                         int index19_70 = input.index();
2862                         input.rewind();
2863                         s = -1;
2864                         if ( (LA19_70=='\n'||LA19_70=='\r') && (( isHead() ))) {s = 22;}
2865
2866                         else if ( (LA19_70=='\"') ) {s = 51;}
2867
2868                         else if ( ((LA19_70>='\u0000' && LA19_70<='\t')||(LA19_70>='\u000B' && LA19_70<='\f')||(LA19_70>='\u000E' && LA19_70<='!')||(LA19_70>='#' && LA19_70<='[')||(LA19_70>=']' && LA19_70<='\uFFFF')) ) {s = 49;}
2869
2870                         else if ( (LA19_70=='\\') ) {s = 50;}
2871
2872
2873                         input.seek(index19_70);
2874                         if ( s>=0 ) return s;
2875                         break;
2876                     case 39 :
2877                         int LA19_16 = input.LA(1);
2878
2879
2880                         int index19_16 = input.index();
2881                         input.rewind();
2882                         s = -1;
2883                         if ( ((LA19_16>='\u0000' && LA19_16<='\uFFFF')) && (( isHead() ))) {s = 22;}
2884
2885                         else s = 43;
2886
2887
2888                         input.seek(index19_16);
2889                         if ( s>=0 ) return s;
2890                         break;
2891                     case 40 :
2892                         int LA19_9 = input.LA(1);
2893
2894
2895                         int index19_9 = input.index();
2896                         input.rewind();
2897                         s = -1;
2898                         if ( ((LA19_9>='\u0000' && LA19_9<='\uFFFF')) && (( isHead() ))) {s = 22;}
2899
2900                         else s = 31;
2901
2902
2903                         input.seek(index19_9);
2904                         if ( s>=0 ) return s;
2905                         break;
2906                     case 41 :
2907                         int LA19_82 = input.LA(1);
2908
2909
2910                         int index19_82 = input.index();
2911                         input.rewind();
2912                         s = -1;
2913                         if ( (LA19_82=='\n'||LA19_82=='\r') && (( isHead() ))) {s = 22;}
2914
2915                         else if ( (LA19_82=='\"') ) {s = 51;}
2916
2917                         else if ( ((LA19_82>='\u0000' && LA19_82<='\t')||(LA19_82>='\u000B' && LA19_82<='\f')||(LA19_82>='\u000E' && LA19_82<='!')||(LA19_82>='#' && LA19_82<='[')||(LA19_82>=']' && LA19_82<='\uFFFF')) ) {s = 49;}
2918
2919                         else if ( (LA19_82=='\\') ) {s = 50;}
2920
2921
2922                         input.seek(index19_82);
2923                         if ( s>=0 ) return s;
2924                         break;
2925                     case 42 :
2926                         int LA19_73 = input.LA(1);
2927
2928
2929                         int index19_73 = input.index();
2930                         input.rewind();
2931                         s = -1;
2932                         if ( (LA19_73=='\n'||LA19_73=='\r') && (( isHead() ))) {s = 22;}
2933
2934                         else if ( (LA19_73=='\"') ) {s = 51;}
2935
2936                         else if ( ((LA19_73>='\u0000' && LA19_73<='\t')||(LA19_73>='\u000B' && LA19_73<='\f')||(LA19_73>='\u000E' && LA19_73<='!')||(LA19_73>='#' && LA19_73<='[')||(LA19_73>=']' && LA19_73<='\uFFFF')) ) {s = 49;}
2937
2938                         else if ( (LA19_73=='\\') ) {s = 50;}
2939
2940
2941                         input.seek(index19_73);
2942                         if ( s>=0 ) return s;
2943                         break;
2944                     case 43 :
2945                         int LA19_54 = input.LA(1);
2946
2947
2948                         int index19_54 = input.index();
2949                         input.rewind();
2950                         s = -1;
2951                         if ( (!((( isHead() )))) ) {s = 55;}
2952
2953                         else if ( (( isHead() )) ) {s = 27;}
2954
2955
2956                         input.seek(index19_54);
2957                         if ( s>=0 ) return s;
2958                         break;
2959                     case 44 :
2960                         int LA19_24 = input.LA(1);
2961
2962
2963                         int index19_24 = input.index();
2964                         input.rewind();
2965                         s = -1;
2966                         if ( (!((( isHead() )))) ) {s = 55;}
2967
2968                         else if ( (( isHead() )) ) {s = 27;}
2969
2970
2971                         input.seek(index19_24);
2972                         if ( s>=0 ) return s;
2973                         break;
2974                     case 45 :
2975                         int LA19_25 = input.LA(1);
2976
2977
2978                         int index19_25 = input.index();
2979                         input.rewind();
2980                         s = -1;
2981                         if ( (!((( isHead() )))) ) {s = 55;}
2982
2983                         else if ( (( isHead() )) ) {s = 27;}
2984
2985
2986                         input.seek(index19_25);
2987                         if ( s>=0 ) return s;
2988                         break;
2989                     case 46 :
2990                         int LA19_18 = input.LA(1);
2991
2992
2993                         int index19_18 = input.index();
2994                         input.rewind();
2995                         s = -1;
2996                         if ( (LA19_18=='\t'||LA19_18==' ') ) {s = 37;}
2997
2998                         else if ( ((LA19_18>='\u0000' && LA19_18<='\b')||(LA19_18>='\u000B' && LA19_18<='\f')||(LA19_18>='\u000E' && LA19_18<='\u001F')||LA19_18=='!'||(LA19_18>='$' && LA19_18<='\'')||(LA19_18>='*' && LA19_18<='+')||(LA19_18>='-' && LA19_18<='9')||(LA19_18>=';' && LA19_18<='=')||(LA19_18>='?' && LA19_18<='Z')||(LA19_18>='^' && LA19_18<='z')||LA19_18=='|'||(LA19_18>='~' && LA19_18<='\uFFFF')) ) {s = 46;}
2999
3000                         else if ( (LA19_18==':'||LA19_18=='>'||LA19_18=='['||LA19_18==']'||LA19_18=='{'||LA19_18=='}') ) {s = 47;}
3001
3002                         else if ( (LA19_18==',') ) {s = 48;}
3003
3004                         else if ( (LA19_18=='#'||(LA19_18>='(' && LA19_18<=')')) && ((( isValue() )||( isHead() )))) {s = 34;}
3005
3006                         else if ( (LA19_18=='\n'||LA19_18=='\r'||LA19_18=='\"'||LA19_18=='\\') && (( isHead() ))) {s = 22;}
3007
3008                         else s = 45;
3009
3010
3011                         input.seek(index19_18);
3012                         if ( s>=0 ) return s;
3013                         break;
3014                     case 47 :
3015                         int LA19_14 = input.LA(1);
3016
3017
3018                         int index19_14 = input.index();
3019                         input.rewind();
3020                         s = -1;
3021                         if ( ((LA19_14>='\u0000' && LA19_14<='\uFFFF')) && (( isHead() ))) {s = 22;}
3022
3023                         else s = 41;
3024
3025
3026                         input.seek(index19_14);
3027                         if ( s>=0 ) return s;
3028                         break;
3029                     case 48 :
3030                         int LA19_77 = input.LA(1);
3031
3032
3033                         int index19_77 = input.index();
3034                         input.rewind();
3035                         s = -1;
3036                         if ( ((LA19_77>='0' && LA19_77<='9')||(LA19_77>='A' && LA19_77<='F')||(LA19_77>='a' && LA19_77<='f')) ) {s = 79;}
3037
3038                         else if ( ((LA19_77>='\u0000' && LA19_77<='/')||(LA19_77>=':' && LA19_77<='@')||(LA19_77>='G' && LA19_77<='`')||(LA19_77>='g' && LA19_77<='\uFFFF')) && (( isHead() ))) {s = 22;}
3039
3040
3041                         input.seek(index19_77);
3042                         if ( s>=0 ) return s;
3043                         break;
3044                     case 49 :
3045                         int LA19_19 = input.LA(1);
3046
3047
3048                         int index19_19 = input.index();
3049                         input.rewind();
3050                         s = -1;
3051                         if ( ((LA19_19>='\u0000' && LA19_19<='\t')||(LA19_19>='\u000B' && LA19_19<='\f')||(LA19_19>='\u000E' && LA19_19<='!')||(LA19_19>='#' && LA19_19<='[')||(LA19_19>=']' && LA19_19<='\uFFFF')) ) {s = 49;}
3052
3053                         else if ( (LA19_19=='\\') ) {s = 50;}
3054
3055                         else if ( (LA19_19=='\"') ) {s = 51;}
3056
3057                         else if ( (LA19_19=='\n'||LA19_19=='\r') && (( isHead() ))) {s = 22;}
3058
3059
3060                         input.seek(index19_19);
3061                         if ( s>=0 ) return s;
3062                         break;
3063                     case 50 :
3064                         int LA19_61 = input.LA(1);
3065
3066
3067                         int index19_61 = input.index();
3068                         input.rewind();
3069                         s = -1;
3070                         if ( (LA19_61=='\t'||LA19_61==' ') && ((( isValue() )||( isHead() )))) {s = 58;}
3071
3072                         else if ( ((LA19_61>='\u0000' && LA19_61<='\b')||(LA19_61>='\u000B' && LA19_61<='\f')||(LA19_61>='\u000E' && LA19_61<='\u001F')||LA19_61=='!'||(LA19_61>='$' && LA19_61<='\'')||(LA19_61>='*' && LA19_61<='+')||(LA19_61>='-' && LA19_61<='9')||(LA19_61>=';' && LA19_61<='=')||(LA19_61>='?' && LA19_61<='Z')||(LA19_61>='^' && LA19_61<='z')||LA19_61=='|'||(LA19_61>='~' && LA19_61<='\uFFFF')) && ((( isValue() )||( isHead() )))) {s = 60;}
3073
3074                         else if ( (LA19_61==':'||LA19_61=='>'||LA19_61=='['||LA19_61==']'||LA19_61=='{'||LA19_61=='}') && ((( isHead() )||( isValue() )))) {s = 61;}
3075
3076                         else if ( (LA19_61==',') && ((( isValue() )||( isHead() )))) {s = 62;}
3077
3078                         else if ( (LA19_61=='\n'||LA19_61=='\r'||(LA19_61>='\"' && LA19_61<='#')||(LA19_61>='(' && LA19_61<=')')||LA19_61=='\\') && (( isHead() ))) {s = 22;}
3079
3080                         else s = 59;
3081
3082
3083                         input.seek(index19_61);
3084                         if ( s>=0 ) return s;
3085                         break;
3086                     case 51 :
3087                         int LA19_12 = input.LA(1);
3088
3089
3090                         int index19_12 = input.index();
3091                         input.rewind();
3092                         s = -1;
3093                         if ( ((LA19_12>='\u0000' && LA19_12<='\uFFFF')) && (( isHead() ))) {s = 22;}
3094
3095                         else s = 35;
3096
3097
3098                         input.seek(index19_12);
3099                         if ( s>=0 ) return s;
3100                         break;
3101                     case 52 :
3102                         int LA19_39 = input.LA(1);
3103
3104
3105                         int index19_39 = input.index();
3106                         input.rewind();
3107                         s = -1;
3108                         if ( (LA19_39=='\t'||LA19_39==' ') ) {s = 37;}
3109
3110                         else if ( ((LA19_39>='\u0000' && LA19_39<='\b')||(LA19_39>='\u000B' && LA19_39<='\f')||(LA19_39>='\u000E' && LA19_39<='\u001F')||LA19_39=='!'||(LA19_39>='$' && LA19_39<='\'')||(LA19_39>='*' && LA19_39<='+')||(LA19_39>='-' && LA19_39<='9')||(LA19_39>=';' && LA19_39<='=')||(LA19_39>='?' && LA19_39<='Z')||(LA19_39>='^' && LA19_39<='z')||LA19_39=='|'||(LA19_39>='~' && LA19_39<='\uFFFF')) ) {s = 38;}
3111
3112                         else if ( (LA19_39==':'||LA19_39=='>'||LA19_39=='['||LA19_39==']'||LA19_39=='{'||LA19_39=='}') ) {s = 39;}
3113
3114                         else if ( (LA19_39==',') ) {s = 40;}
3115
3116                         else if ( (LA19_39=='\n'||LA19_39=='\r'||(LA19_39>='\"' && LA19_39<='#')||(LA19_39>='(' && LA19_39<=')')||LA19_39=='\\') && (( isHead() ))) {s = 22;}
3117
3118                         else s = 52;
3119
3120
3121                         input.seek(index19_39);
3122                         if ( s>=0 ) return s;
3123                         break;
3124                     case 53 :
3125                         int LA19_74 = input.LA(1);
3126
3127
3128                         int index19_74 = input.index();
3129                         input.rewind();
3130                         s = -1;
3131                         if ( (LA19_74=='\n'||LA19_74=='\r') && (( isHead() ))) {s = 22;}
3132
3133                         else if ( (LA19_74=='\"') ) {s = 51;}
3134
3135                         else if ( ((LA19_74>='\u0000' && LA19_74<='\t')||(LA19_74>='\u000B' && LA19_74<='\f')||(LA19_74>='\u000E' && LA19_74<='!')||(LA19_74>='#' && LA19_74<='[')||(LA19_74>=']' && LA19_74<='\uFFFF')) ) {s = 49;}
3136
3137                         else if ( (LA19_74=='\\') ) {s = 50;}
3138
3139
3140                         input.seek(index19_74);
3141                         if ( s>=0 ) return s;
3142                         break;
3143                     case 54 :
3144                         int LA19_28 = input.LA(1);
3145
3146
3147                         int index19_28 = input.index();
3148                         input.rewind();
3149                         s = -1;
3150                         if ( (LA19_28=='\n'||LA19_28=='\r') ) {s = 27;}
3151
3152                         else if ( (LA19_28==' ') ) {s = 28;}
3153
3154                         else if ( (LA19_28=='-') ) {s = 6;}
3155
3156                         else if ( (LA19_28=='\t') ) {s = 29;}
3157
3158                         else if ( ((LA19_28>='\u0000' && LA19_28<='\b')||(LA19_28>='\u000B' && LA19_28<='\f')||(LA19_28>='\u000E' && LA19_28<='\u001F')||(LA19_28>='!' && LA19_28<='\"')||LA19_28=='$'||(LA19_28>='&' && LA19_28<=',')||(LA19_28>='.' && LA19_28<='\uFFFF')) && (( isHead() ))) {s = 22;}
3159
3160                         else s = 56;
3161
3162
3163                         input.seek(index19_28);
3164                         if ( s>=0 ) return s;
3165                         break;
3166                     case 55 :
3167                         int LA19_10 = input.LA(1);
3168
3169
3170                         int index19_10 = input.index();
3171                         input.rewind();
3172                         s = -1;
3173                         if ( ((LA19_10>='\u0000' && LA19_10<='\uFFFF')) && (( isHead() ))) {s = 22;}
3174
3175                         else s = 32;
3176
3177
3178                         input.seek(index19_10);
3179                         if ( s>=0 ) return s;
3180                         break;
3181             }
3182             NoViableAltException nvae =
3183                 new NoViableAltException(getDescription(), 19, _s, input);
3184             error(nvae);
3185             throw nvae;
3186         }
3187     }
3188
3189
3190 }