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

   1 // $ANTLR 3.1.3 Mar 17, 2009 19:23:44 SilkLine.g 2009-10-13 17:21:59\r
   2 \r
   3 /*--------------------------------------------------------------------------\r
   4  *  Copyright 2009 Taro L. Saito\r
   5  *\r
   6  *  Licensed under the Apache License, Version 2.0 (the "License");\r
   7  *  you may not use this file except in compliance with the License.\r
   8  *  You may obtain a copy of the License at\r
   9  *\r
  10  *     http://www.apache.org/licenses/LICENSE-2.0\r
  11  *\r
  12  *  Unless required by applicable law or agreed to in writing, software\r
  13  *  distributed under the License is distributed on an "AS IS" BASIS,\r
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  15  *  See the License for the specific language governing permissions and\r
  16  *  limitations under the License.\r
  17  *--------------------------------------------------------------------------*/\r
  18 //--------------------------------------\r
  19 // XerialJ\r
  20 //\r
  21 // SilkLexer.java\r
  22 // Since: Jan 28, 2009 1:00:02 PM\r
  23 //\r
  24 //--------------------------------------\r
  25 \r
  26 package org.xerial.silk.impl;\r
  27 import org.xerial.core.XerialError;\r
  28 import org.xerial.core.XerialErrorCode;\r
  29 import org.xerial.util.log.Logger;\r
  30 import org.xerial.silk.impl.SilkLexerState;\r
  31 import org.xerial.silk.impl.SilkLexerState.State;\r
  32 import org.xerial.silk.impl.SilkLexerState.Symbol;\r
  33 \r
  34 \r
  35 import org.antlr.runtime.*;\r
  36 import java.util.Stack;\r
  37 import java.util.List;\r
  38 import java.util.ArrayList;\r
  39 \r
  40 public class SilkLineLexer extends Lexer {\r
  41     public static final int Key=14;\r
  42     public static final int PlainUnsafeChar=45;\r
  43     public static final int PlainSafeKey=46;\r
  44     public static final int DataType=10;\r
  45     public static final int EqEq=25;\r
  46     public static final int SilkNode=5;\r
  47     public static final int SilkLine=6;\r
  48     public static final int LBracket=31;\r
  49     public static final int Digit=34;\r
  50     public static final int NodeIndent=18;\r
  51     public static final int HexDigit=36;\r
  52     public static final int PlainOneLine=51;\r
  53     public static final int Plus=30;\r
  54     public static final int Occurrence=9;\r
  55     public static final int Argument=12;\r
  56     public static final int Separation=53;\r
  57     public static final int FlowIndicator=43;\r
  58     public static final int Letter=35;\r
  59     public static final int PlainSafeIn=47;\r
  60     public static final int Comma=23;\r
  61     public static final int TabSeq=27;\r
  62     public static final int NonSpaceChar=49;\r
  63     public static final int EscapeSequence=38;\r
  64     public static final int PlainFirst=50;\r
  65     public static final int WhiteSpace=15;\r
  66     public static final int PlainSafeOut=48;\r
  67     public static final int JSON=52;\r
  68     public static final int Question=33;\r
  69     public static final int LineComment=17;\r
  70     public static final int Colon=24;\r
  71     public static final int At=29;\r
  72     public static final int KeyValuePair=13;\r
  73     public static final int Star=28;\r
  74     public static final int Seq=26;\r
  75     public static final int FunctionIndent=19;\r
  76     public static final int Indicator=44;\r
  77     public static final int RParen=22;\r
  78     public static final int UnicodeChar=37;\r
  79     public static final int StringChar=39;\r
  80     public static final int Silk=4;\r
  81     public static final int BlankLine=20;\r
  82     public static final int Name=7;\r
  83     public static final int Function=11;\r
  84     public static final int LParen=21;\r
  85     public static final int String=41;\r
  86     public static final int LineBreakChar=16;\r
  87     public static final int ScopeIndicator=42;\r
  88     public static final int EOF=-1;\r
  89     public static final int StringChar_s=40;\r
  90     public static final int Value=8;\r
  91     public static final int RBracket=32;\r
  92 \r
  93 \r
  94     private static Logger _logger = Logger.getLogger(SilkLineLexer.class);\r
  95 \r
  96     private SilkLexerState lexerContext = new SilkLexerState();\r
  97 \r
  98     private void transit(Symbol token) { lexerContext.transit(token); } \r
  99     private boolean isKey() { return lexerContext.isInKey(); }\r
 100     private boolean isValue() { return lexerContext.isValue(); }\r
 101     private boolean isInValue() { return lexerContext.isInValue(); }\r
 102     private boolean isOutValue() { return lexerContext.isOutValue(); }\r
 103     private boolean isHead() { return getCharPositionInLine() == 0; }\r
 104 \r
 105       public void resetContext() { lexerContext.reset(); }\r
 106 \r
 107       @Override\r
 108       public void reportError(RecognitionException e) {\r
 109             String message = "line=" + getLine() + "(" + getCharPositionInLine() + "): " + e.toString();;\r
 110             throw new XerialError(XerialErrorCode.INVALID_TOKEN, message);\r
 111       } \r
 112       \r
 113       public static String sanitizeDataLine(String line)\r
 114       {\r
 115           line = line.trim();\r
 116           if (line.startsWith("\\"))\r
 117               return line.substring(1);\r
 118           else\r
 119               return line;\r
 120       }\r
 121       \r
 122       \r
 123 \r
 124 \r
 125     // delegates\r
 126     // delegators\r
 127 \r
 128     public SilkLineLexer() {;} \r
 129     public SilkLineLexer(CharStream input) {\r
 130         this(input, new RecognizerSharedState());\r
 131     }\r
 132     public SilkLineLexer(CharStream input, RecognizerSharedState state) {\r
 133         super(input,state);\r
 134 \r
 135     }\r
 136     public String getGrammarFileName() { return "SilkLine.g"; }\r
 137 \r
 138     // $ANTLR start "WhiteSpace"\r
 139     public final void mWhiteSpace() throws RecognitionException {\r
 140         try {\r
 141             // SilkLine.g:155:2: ( ( ' ' | '\\t' ) )\r
 142             // SilkLine.g:155:4: ( ' ' | '\\t' )\r
 143             {\r
 144             if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {\r
 145                 input.consume();\r
 146 \r
 147             }\r
 148             else {\r
 149                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
 150                 recover(mse);\r
 151                 throw mse;}\r
 152 \r
 153 \r
 154             }\r
 155 \r
 156         }\r
 157         finally {\r
 158         }\r
 159     }\r
 160     // $ANTLR end "WhiteSpace"\r
 161 \r
 162     // $ANTLR start "LineComment"\r
 163     public final void mLineComment() throws RecognitionException {\r
 164         try {\r
 165             int _type = LineComment;\r
 166             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 167             // SilkLine.g:159:12: ( '#' (~ ( LineBreakChar ) )* )\r
 168             // SilkLine.g:159:14: '#' (~ ( LineBreakChar ) )*\r
 169             {\r
 170             match('#'); \r
 171             // SilkLine.g:159:18: (~ ( LineBreakChar ) )*\r
 172             loop1:\r
 173             do {\r
 174                 int alt1=2;\r
 175                 int LA1_0 = input.LA(1);\r
 176 \r
 177                 if ( ((LA1_0>='\u0000' && LA1_0<='\t')||(LA1_0>='\u000B' && LA1_0<='\f')||(LA1_0>='\u000E' && LA1_0<='\uFFFF')) ) {\r
 178                     alt1=1;\r
 179                 }\r
 180 \r
 181 \r
 182                 switch (alt1) {\r
 183                 case 1 :\r
 184                     // SilkLine.g:159:18: ~ ( LineBreakChar )\r
 185                     {\r
 186                     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') ) {\r
 187                         input.consume();\r
 188 \r
 189                     }\r
 190                     else {\r
 191                         MismatchedSetException mse = new MismatchedSetException(null,input);\r
 192                         recover(mse);\r
 193                         throw mse;}\r
 194 \r
 195 \r
 196                     }\r
 197                     break;\r
 198 \r
 199                 default :\r
 200                     break loop1;\r
 201                 }\r
 202             } while (true);\r
 203 \r
 204 \r
 205             }\r
 206 \r
 207             state.type = _type;\r
 208             state.channel = _channel;\r
 209         }\r
 210         finally {\r
 211         }\r
 212     }\r
 213     // $ANTLR end "LineComment"\r
 214 \r
 215     // $ANTLR start "LineBreakChar"\r
 216     public final void mLineBreakChar() throws RecognitionException {\r
 217         try {\r
 218             // SilkLine.g:163:23: ( '\\n' | '\\r' )\r
 219             // SilkLine.g:\r
 220             {\r
 221             if ( input.LA(1)=='\n'||input.LA(1)=='\r' ) {\r
 222                 input.consume();\r
 223 \r
 224             }\r
 225             else {\r
 226                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
 227                 recover(mse);\r
 228                 throw mse;}\r
 229 \r
 230 \r
 231             }\r
 232 \r
 233         }\r
 234         finally {\r
 235         }\r
 236     }\r
 237     // $ANTLR end "LineBreakChar"\r
 238 \r
 239     // $ANTLR start "NodeIndent"\r
 240     public final void mNodeIndent() throws RecognitionException {\r
 241         try {\r
 242             int _type = NodeIndent;\r
 243             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 244             // SilkLine.g:175:11: ({...}? => ( ' ' )* '-' )\r
 245             // SilkLine.g:175:13: {...}? => ( ' ' )* '-'\r
 246             {\r
 247             if ( !(( isHead() )) ) {\r
 248                 throw new FailedPredicateException(input, "NodeIndent", " isHead() ");\r
 249             }\r
 250             // SilkLine.g:175:30: ( ' ' )*\r
 251             loop2:\r
 252             do {\r
 253                 int alt2=2;\r
 254                 int LA2_0 = input.LA(1);\r
 255 \r
 256                 if ( (LA2_0==' ') ) {\r
 257                     alt2=1;\r
 258                 }\r
 259 \r
 260 \r
 261                 switch (alt2) {\r
 262                 case 1 :\r
 263                     // SilkLine.g:175:31: ' '\r
 264                     {\r
 265                     match(' '); \r
 266 \r
 267                     }\r
 268                     break;\r
 269 \r
 270                 default :\r
 271                     break loop2;\r
 272                 }\r
 273             } while (true);\r
 274 \r
 275             match('-'); \r
 276              transit(Symbol.NodeStart); \r
 277 \r
 278             }\r
 279 \r
 280             state.type = _type;\r
 281             state.channel = _channel;\r
 282         }\r
 283         finally {\r
 284         }\r
 285     }\r
 286     // $ANTLR end "NodeIndent"\r
 287 \r
 288     // $ANTLR start "FunctionIndent"\r
 289     public final void mFunctionIndent() throws RecognitionException {\r
 290         try {\r
 291             int _type = FunctionIndent;\r
 292             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 293             // SilkLine.g:176:15: ({...}? => ( ' ' )* '@' )\r
 294             // SilkLine.g:176:17: {...}? => ( ' ' )* '@'\r
 295             {\r
 296             if ( !(( isHead() )) ) {\r
 297                 throw new FailedPredicateException(input, "FunctionIndent", " isHead() ");\r
 298             }\r
 299             // SilkLine.g:176:34: ( ' ' )*\r
 300             loop3:\r
 301             do {\r
 302                 int alt3=2;\r
 303                 int LA3_0 = input.LA(1);\r
 304 \r
 305                 if ( (LA3_0==' ') ) {\r
 306                     alt3=1;\r
 307                 }\r
 308 \r
 309 \r
 310                 switch (alt3) {\r
 311                 case 1 :\r
 312                     // SilkLine.g:176:35: ' '\r
 313                     {\r
 314                     match(' '); \r
 315 \r
 316                     }\r
 317                     break;\r
 318 \r
 319                 default :\r
 320                     break loop3;\r
 321                 }\r
 322             } while (true);\r
 323 \r
 324             match('@'); \r
 325              transit(Symbol.NodeStart); \r
 326 \r
 327             }\r
 328 \r
 329             state.type = _type;\r
 330             state.channel = _channel;\r
 331         }\r
 332         finally {\r
 333         }\r
 334     }\r
 335     // $ANTLR end "FunctionIndent"\r
 336 \r
 337     // $ANTLR start "BlankLine"\r
 338     public final void mBlankLine() throws RecognitionException {\r
 339         try {\r
 340             int _type = BlankLine;\r
 341             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 342             // SilkLine.g:177:10: ({...}? => ( WhiteSpace )* )\r
 343             // SilkLine.g:177:12: {...}? => ( WhiteSpace )*\r
 344             {\r
 345             if ( !(( isHead() )) ) {\r
 346                 throw new FailedPredicateException(input, "BlankLine", " isHead() ");\r
 347             }\r
 348             // SilkLine.g:177:29: ( WhiteSpace )*\r
 349             loop4:\r
 350             do {\r
 351                 int alt4=2;\r
 352                 int LA4_0 = input.LA(1);\r
 353 \r
 354                 if ( (LA4_0=='\t'||LA4_0==' ') ) {\r
 355                     alt4=1;\r
 356                 }\r
 357 \r
 358 \r
 359                 switch (alt4) {\r
 360                 case 1 :\r
 361                     // SilkLine.g:177:29: WhiteSpace\r
 362                     {\r
 363                     mWhiteSpace(); \r
 364 \r
 365                     }\r
 366                     break;\r
 367 \r
 368                 default :\r
 369                     break loop4;\r
 370                 }\r
 371             } while (true);\r
 372 \r
 373 \r
 374             }\r
 375 \r
 376             state.type = _type;\r
 377             state.channel = _channel;\r
 378         }\r
 379         finally {\r
 380         }\r
 381     }\r
 382     // $ANTLR end "BlankLine"\r
 383 \r
 384     // $ANTLR start "LParen"\r
 385     public final void mLParen() throws RecognitionException {\r
 386         try {\r
 387             int _type = LParen;\r
 388             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 389             // SilkLine.g:183:7: ( '(' )\r
 390             // SilkLine.g:183:9: '('\r
 391             {\r
 392             match('('); \r
 393              transit(Symbol.EnterParen); \r
 394 \r
 395             }\r
 396 \r
 397             state.type = _type;\r
 398             state.channel = _channel;\r
 399         }\r
 400         finally {\r
 401         }\r
 402     }\r
 403     // $ANTLR end "LParen"\r
 404 \r
 405     // $ANTLR start "RParen"\r
 406     public final void mRParen() throws RecognitionException {\r
 407         try {\r
 408             int _type = RParen;\r
 409             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 410             // SilkLine.g:184:7: ( ')' )\r
 411             // SilkLine.g:184:9: ')'\r
 412             {\r
 413             match(')'); \r
 414              transit(Symbol.LeaveParen); \r
 415 \r
 416             }\r
 417 \r
 418             state.type = _type;\r
 419             state.channel = _channel;\r
 420         }\r
 421         finally {\r
 422         }\r
 423     }\r
 424     // $ANTLR end "RParen"\r
 425 \r
 426     // $ANTLR start "Comma"\r
 427     public final void mComma() throws RecognitionException {\r
 428         try {\r
 429             int _type = Comma;\r
 430             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 431             // SilkLine.g:185:6: ( ',' )\r
 432             // SilkLine.g:185:9: ','\r
 433             {\r
 434             match(','); \r
 435 \r
 436             }\r
 437 \r
 438             state.type = _type;\r
 439             state.channel = _channel;\r
 440         }\r
 441         finally {\r
 442         }\r
 443     }\r
 444     // $ANTLR end "Comma"\r
 445 \r
 446     // $ANTLR start "Colon"\r
 447     public final void mColon() throws RecognitionException {\r
 448         try {\r
 449             int _type = Colon;\r
 450             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 451             // SilkLine.g:186:6: ( ':' )\r
 452             // SilkLine.g:186:8: ':'\r
 453             {\r
 454             match(':'); \r
 455              transit(Symbol.Colon); \r
 456 \r
 457             }\r
 458 \r
 459             state.type = _type;\r
 460             state.channel = _channel;\r
 461         }\r
 462         finally {\r
 463         }\r
 464     }\r
 465     // $ANTLR end "Colon"\r
 466 \r
 467     // $ANTLR start "EqEq"\r
 468     public final void mEqEq() throws RecognitionException {\r
 469         try {\r
 470             int _type = EqEq;\r
 471             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 472             // SilkLine.g:188:5: ( '==' )\r
 473             // SilkLine.g:188:7: '=='\r
 474             {\r
 475             match("=="); \r
 476 \r
 477 \r
 478             }\r
 479 \r
 480             state.type = _type;\r
 481             state.channel = _channel;\r
 482         }\r
 483         finally {\r
 484         }\r
 485     }\r
 486     // $ANTLR end "EqEq"\r
 487 \r
 488     // $ANTLR start "Seq"\r
 489     public final void mSeq() throws RecognitionException {\r
 490         try {\r
 491             int _type = Seq;\r
 492             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 493             // SilkLine.g:189:4: ( '>' )\r
 494             // SilkLine.g:189:7: '>'\r
 495             {\r
 496             match('>'); \r
 497 \r
 498             }\r
 499 \r
 500             state.type = _type;\r
 501             state.channel = _channel;\r
 502         }\r
 503         finally {\r
 504         }\r
 505     }\r
 506     // $ANTLR end "Seq"\r
 507 \r
 508     // $ANTLR start "TabSeq"\r
 509     public final void mTabSeq() throws RecognitionException {\r
 510         try {\r
 511             int _type = TabSeq;\r
 512             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 513             // SilkLine.g:190:7: ( '|' )\r
 514             // SilkLine.g:190:9: '|'\r
 515             {\r
 516             match('|'); \r
 517 \r
 518             }\r
 519 \r
 520             state.type = _type;\r
 521             state.channel = _channel;\r
 522         }\r
 523         finally {\r
 524         }\r
 525     }\r
 526     // $ANTLR end "TabSeq"\r
 527 \r
 528     // $ANTLR start "Star"\r
 529     public final void mStar() throws RecognitionException {\r
 530         try {\r
 531             int _type = Star;\r
 532             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 533             // SilkLine.g:191:5: ( '*' )\r
 534             // SilkLine.g:191:8: '*'\r
 535             {\r
 536             match('*'); \r
 537 \r
 538             }\r
 539 \r
 540             state.type = _type;\r
 541             state.channel = _channel;\r
 542         }\r
 543         finally {\r
 544         }\r
 545     }\r
 546     // $ANTLR end "Star"\r
 547 \r
 548     // $ANTLR start "At"\r
 549     public final void mAt() throws RecognitionException {\r
 550         try {\r
 551             int _type = At;\r
 552             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 553             // SilkLine.g:192:3: ( '@' )\r
 554             // SilkLine.g:192:6: '@'\r
 555             {\r
 556             match('@'); \r
 557              transit(Symbol.At); \r
 558 \r
 559             }\r
 560 \r
 561             state.type = _type;\r
 562             state.channel = _channel;\r
 563         }\r
 564         finally {\r
 565         }\r
 566     }\r
 567     // $ANTLR end "At"\r
 568 \r
 569     // $ANTLR start "Plus"\r
 570     public final void mPlus() throws RecognitionException {\r
 571         try {\r
 572             int _type = Plus;\r
 573             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 574             // SilkLine.g:193:5: ( '+' )\r
 575             // SilkLine.g:193:7: '+'\r
 576             {\r
 577             match('+'); \r
 578 \r
 579             }\r
 580 \r
 581             state.type = _type;\r
 582             state.channel = _channel;\r
 583         }\r
 584         finally {\r
 585         }\r
 586     }\r
 587     // $ANTLR end "Plus"\r
 588 \r
 589     // $ANTLR start "LBracket"\r
 590     public final void mLBracket() throws RecognitionException {\r
 591         try {\r
 592             int _type = LBracket;\r
 593             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 594             // SilkLine.g:194:9: ( '[' )\r
 595             // SilkLine.g:194:11: '['\r
 596             {\r
 597             match('['); \r
 598              transit(Symbol.EnterParen); \r
 599 \r
 600             }\r
 601 \r
 602             state.type = _type;\r
 603             state.channel = _channel;\r
 604         }\r
 605         finally {\r
 606         }\r
 607     }\r
 608     // $ANTLR end "LBracket"\r
 609 \r
 610     // $ANTLR start "RBracket"\r
 611     public final void mRBracket() throws RecognitionException {\r
 612         try {\r
 613             int _type = RBracket;\r
 614             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 615             // SilkLine.g:195:9: ( ']' )\r
 616             // SilkLine.g:195:11: ']'\r
 617             {\r
 618             match(']'); \r
 619 \r
 620             }\r
 621 \r
 622             state.type = _type;\r
 623             state.channel = _channel;\r
 624         }\r
 625         finally {\r
 626         }\r
 627     }\r
 628     // $ANTLR end "RBracket"\r
 629 \r
 630     // $ANTLR start "Question"\r
 631     public final void mQuestion() throws RecognitionException {\r
 632         try {\r
 633             int _type = Question;\r
 634             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 635             // SilkLine.g:196:9: ( '?' )\r
 636             // SilkLine.g:196:11: '?'\r
 637             {\r
 638             match('?'); \r
 639 \r
 640             }\r
 641 \r
 642             state.type = _type;\r
 643             state.channel = _channel;\r
 644         }\r
 645         finally {\r
 646         }\r
 647     }\r
 648     // $ANTLR end "Question"\r
 649 \r
 650     // $ANTLR start "Digit"\r
 651     public final void mDigit() throws RecognitionException {\r
 652         try {\r
 653             // SilkLine.g:198:15: ( '0' .. '9' )\r
 654             // SilkLine.g:198:17: '0' .. '9'\r
 655             {\r
 656             matchRange('0','9'); \r
 657 \r
 658             }\r
 659 \r
 660         }\r
 661         finally {\r
 662         }\r
 663     }\r
 664     // $ANTLR end "Digit"\r
 665 \r
 666     // $ANTLR start "Letter"\r
 667     public final void mLetter() throws RecognitionException {\r
 668         try {\r
 669             // SilkLine.g:199:16: ( 'A' .. 'F' | 'a' .. 'f' )\r
 670             // SilkLine.g:\r
 671             {\r
 672             if ( (input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {\r
 673                 input.consume();\r
 674 \r
 675             }\r
 676             else {\r
 677                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
 678                 recover(mse);\r
 679                 throw mse;}\r
 680 \r
 681 \r
 682             }\r
 683 \r
 684         }\r
 685         finally {\r
 686         }\r
 687     }\r
 688     // $ANTLR end "Letter"\r
 689 \r
 690     // $ANTLR start "HexDigit"\r
 691     public final void mHexDigit() throws RecognitionException {\r
 692         try {\r
 693             // SilkLine.g:200:18: ( Digit | Letter )\r
 694             // SilkLine.g:\r
 695             {\r
 696             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') ) {\r
 697                 input.consume();\r
 698 \r
 699             }\r
 700             else {\r
 701                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
 702                 recover(mse);\r
 703                 throw mse;}\r
 704 \r
 705 \r
 706             }\r
 707 \r
 708         }\r
 709         finally {\r
 710         }\r
 711     }\r
 712     // $ANTLR end "HexDigit"\r
 713 \r
 714     // $ANTLR start "UnicodeChar"\r
 715     public final void mUnicodeChar() throws RecognitionException {\r
 716         try {\r
 717             // SilkLine.g:201:21: (~ ( '\"' | '\\\\' ) )\r
 718             // SilkLine.g:201:23: ~ ( '\"' | '\\\\' )\r
 719             {\r
 720             if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {\r
 721                 input.consume();\r
 722 \r
 723             }\r
 724             else {\r
 725                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
 726                 recover(mse);\r
 727                 throw mse;}\r
 728 \r
 729 \r
 730             }\r
 731 \r
 732         }\r
 733         finally {\r
 734         }\r
 735     }\r
 736     // $ANTLR end "UnicodeChar"\r
 737 \r
 738     // $ANTLR start "EscapeSequence"\r
 739     public final void mEscapeSequence() throws RecognitionException {\r
 740         try {\r
 741             // SilkLine.g:203:2: ( '\\\\' ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit ) )\r
 742             // SilkLine.g:203:4: '\\\\' ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit )\r
 743             {\r
 744             match('\\'); \r
 745             // SilkLine.g:203:9: ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit )\r
 746             int alt5=9;\r
 747             switch ( input.LA(1) ) {\r
 748             case '\"':\r
 749                 {\r
 750                 alt5=1;\r
 751                 }\r
 752                 break;\r
 753             case '\\':\r
 754                 {\r
 755                 alt5=2;\r
 756                 }\r
 757                 break;\r
 758             case '/':\r
 759                 {\r
 760                 alt5=3;\r
 761                 }\r
 762                 break;\r
 763             case 'b':\r
 764                 {\r
 765                 alt5=4;\r
 766                 }\r
 767                 break;\r
 768             case 'f':\r
 769                 {\r
 770                 alt5=5;\r
 771                 }\r
 772                 break;\r
 773             case 'n':\r
 774                 {\r
 775                 alt5=6;\r
 776                 }\r
 777                 break;\r
 778             case 'r':\r
 779                 {\r
 780                 alt5=7;\r
 781                 }\r
 782                 break;\r
 783             case 't':\r
 784                 {\r
 785                 alt5=8;\r
 786                 }\r
 787                 break;\r
 788             case 'u':\r
 789                 {\r
 790                 alt5=9;\r
 791                 }\r
 792                 break;\r
 793             default:\r
 794                 NoViableAltException nvae =\r
 795                     new NoViableAltException("", 5, 0, input);\r
 796 \r
 797                 throw nvae;\r
 798             }\r
 799 \r
 800             switch (alt5) {\r
 801                 case 1 :\r
 802                     // SilkLine.g:203:10: '\\\"'\r
 803                     {\r
 804                     match('\"'); \r
 805 \r
 806                     }\r
 807                     break;\r
 808                 case 2 :\r
 809                     // SilkLine.g:203:17: '\\\\'\r
 810                     {\r
 811                     match('\\'); \r
 812 \r
 813                     }\r
 814                     break;\r
 815                 case 3 :\r
 816                     // SilkLine.g:203:24: '/'\r
 817                     {\r
 818                     match('/'); \r
 819 \r
 820                     }\r
 821                     break;\r
 822                 case 4 :\r
 823                     // SilkLine.g:203:30: 'b'\r
 824                     {\r
 825                     match('b'); \r
 826 \r
 827                     }\r
 828                     break;\r
 829                 case 5 :\r
 830                     // SilkLine.g:203:36: 'f'\r
 831                     {\r
 832                     match('f'); \r
 833 \r
 834                     }\r
 835                     break;\r
 836                 case 6 :\r
 837                     // SilkLine.g:203:42: 'n'\r
 838                     {\r
 839                     match('n'); \r
 840 \r
 841                     }\r
 842                     break;\r
 843                 case 7 :\r
 844                     // SilkLine.g:203:48: 'r'\r
 845                     {\r
 846                     match('r'); \r
 847 \r
 848                     }\r
 849                     break;\r
 850                 case 8 :\r
 851                     // SilkLine.g:203:54: 't'\r
 852                     {\r
 853                     match('t'); \r
 854 \r
 855                     }\r
 856                     break;\r
 857                 case 9 :\r
 858                     // SilkLine.g:203:60: 'u' HexDigit HexDigit HexDigit HexDigit\r
 859                     {\r
 860                     match('u'); \r
 861                     mHexDigit(); \r
 862                     mHexDigit(); \r
 863                     mHexDigit(); \r
 864                     mHexDigit(); \r
 865 \r
 866                     }\r
 867                     break;\r
 868 \r
 869             }\r
 870 \r
 871 \r
 872             }\r
 873 \r
 874         }\r
 875         finally {\r
 876         }\r
 877     }\r
 878     // $ANTLR end "EscapeSequence"\r
 879 \r
 880     // $ANTLR start "StringChar"\r
 881     public final void mStringChar() throws RecognitionException {\r
 882         try {\r
 883             // SilkLine.g:205:21: ( UnicodeChar | EscapeSequence )\r
 884             int alt6=2;\r
 885             int LA6_0 = input.LA(1);\r
 886 \r
 887             if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>=']' && LA6_0<='\uFFFF')) ) {\r
 888                 alt6=1;\r
 889             }\r
 890             else if ( (LA6_0=='\\') ) {\r
 891                 alt6=2;\r
 892             }\r
 893             else {\r
 894                 NoViableAltException nvae =\r
 895                     new NoViableAltException("", 6, 0, input);\r
 896 \r
 897                 throw nvae;\r
 898             }\r
 899             switch (alt6) {\r
 900                 case 1 :\r
 901                     // SilkLine.g:205:24: UnicodeChar\r
 902                     {\r
 903                     mUnicodeChar(); \r
 904 \r
 905                     }\r
 906                     break;\r
 907                 case 2 :\r
 908                     // SilkLine.g:205:38: EscapeSequence\r
 909                     {\r
 910                     mEscapeSequence(); \r
 911 \r
 912                     }\r
 913                     break;\r
 914 \r
 915             }\r
 916         }\r
 917         finally {\r
 918         }\r
 919     }\r
 920     // $ANTLR end "StringChar"\r
 921 \r
 922     // $ANTLR start "StringChar_s"\r
 923     public final void mStringChar_s() throws RecognitionException {\r
 924         try {\r
 925             // SilkLine.g:206:22: ( ( StringChar )* )\r
 926             // SilkLine.g:206:24: ( StringChar )*\r
 927             {\r
 928             // SilkLine.g:206:24: ( StringChar )*\r
 929             loop7:\r
 930             do {\r
 931                 int alt7=2;\r
 932                 int LA7_0 = input.LA(1);\r
 933 \r
 934                 if ( ((LA7_0>='\u0000' && LA7_0<='!')||(LA7_0>='#' && LA7_0<='\uFFFF')) ) {\r
 935                     alt7=1;\r
 936                 }\r
 937 \r
 938 \r
 939                 switch (alt7) {\r
 940                 case 1 :\r
 941                     // SilkLine.g:206:24: StringChar\r
 942                     {\r
 943                     mStringChar(); \r
 944 \r
 945                     }\r
 946                     break;\r
 947 \r
 948                 default :\r
 949                     break loop7;\r
 950                 }\r
 951             } while (true);\r
 952 \r
 953 \r
 954             }\r
 955 \r
 956         }\r
 957         finally {\r
 958         }\r
 959     }\r
 960     // $ANTLR end "StringChar_s"\r
 961 \r
 962     // $ANTLR start "String"\r
 963     public final void mString() throws RecognitionException {\r
 964         try {\r
 965             int _type = String;\r
 966             int _channel = DEFAULT_TOKEN_CHANNEL;\r
 967             Token s=null;\r
 968 \r
 969             // SilkLine.g:207:7: ( '\"' s= StringChar_s '\"' )\r
 970             // SilkLine.g:207:9: '\"' s= StringChar_s '\"'\r
 971             {\r
 972             match('\"'); \r
 973             int sStart413 = getCharIndex();\r
 974             mStringChar_s(); \r
 975             s = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, sStart413, getCharIndex()-1);\r
 976             match('\"'); \r
 977              setText((s!=null?s.getText():null));  transit(Symbol.LeaveValue); \r
 978 \r
 979             }\r
 980 \r
 981             state.type = _type;\r
 982             state.channel = _channel;\r
 983         }\r
 984         finally {\r
 985         }\r
 986     }\r
 987     // $ANTLR end "String"\r
 988 \r
 989     // $ANTLR start "ScopeIndicator"\r
 990     public final void mScopeIndicator() throws RecognitionException {\r
 991         try {\r
 992             // SilkLine.g:210:24: ( '(' | ')' )\r
 993             // SilkLine.g:\r
 994             {\r
 995             if ( (input.LA(1)>='(' && input.LA(1)<=')') ) {\r
 996                 input.consume();\r
 997 \r
 998             }\r
 999             else {\r
1000                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1001                 recover(mse);\r
1002                 throw mse;}\r
1003 \r
1004 \r
1005             }\r
1006 \r
1007         }\r
1008         finally {\r
1009         }\r
1010     }\r
1011     // $ANTLR end "ScopeIndicator"\r
1012 \r
1013     // $ANTLR start "FlowIndicator"\r
1014     public final void mFlowIndicator() throws RecognitionException {\r
1015         try {\r
1016             // SilkLine.g:211:23: ( '[' | ']' | '{' | '}' )\r
1017             // SilkLine.g:\r
1018             {\r
1019             if ( input.LA(1)=='['||input.LA(1)==']'||input.LA(1)=='{'||input.LA(1)=='}' ) {\r
1020                 input.consume();\r
1021 \r
1022             }\r
1023             else {\r
1024                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1025                 recover(mse);\r
1026                 throw mse;}\r
1027 \r
1028 \r
1029             }\r
1030 \r
1031         }\r
1032         finally {\r
1033         }\r
1034     }\r
1035     // $ANTLR end "FlowIndicator"\r
1036 \r
1037     // $ANTLR start "Indicator"\r
1038     public final void mIndicator() throws RecognitionException {\r
1039         try {\r
1040             // SilkLine.g:212:19: ( FlowIndicator | ScopeIndicator | ',' | ':' | '#' | '>' | '|' | '*' | '\\'' | '\"' | '@' | '%' | '\\\\' | '=' )\r
1041             // SilkLine.g:\r
1042             {\r
1043             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)<='}') ) {\r
1044                 input.consume();\r
1045 \r
1046             }\r
1047             else {\r
1048                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1049                 recover(mse);\r
1050                 throw mse;}\r
1051 \r
1052 \r
1053             }\r
1054 \r
1055         }\r
1056         finally {\r
1057         }\r
1058     }\r
1059     // $ANTLR end "Indicator"\r
1060 \r
1061     // $ANTLR start "PlainUnsafeChar"\r
1062     public final void mPlainUnsafeChar() throws RecognitionException {\r
1063         try {\r
1064             // SilkLine.g:215:25: ( '\"' | '\\\\' | '#' )\r
1065             // SilkLine.g:\r
1066             {\r
1067             if ( (input.LA(1)>='\"' && input.LA(1)<='#')||input.LA(1)=='\\' ) {\r
1068                 input.consume();\r
1069 \r
1070             }\r
1071             else {\r
1072                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1073                 recover(mse);\r
1074                 throw mse;}\r
1075 \r
1076 \r
1077             }\r
1078 \r
1079         }\r
1080         finally {\r
1081         }\r
1082     }\r
1083     // $ANTLR end "PlainUnsafeChar"\r
1084 \r
1085     // $ANTLR start "PlainSafeKey"\r
1086     public final void mPlainSafeKey() throws RecognitionException {\r
1087         try {\r
1088             // SilkLine.g:217:22: (~ ( PlainUnsafeChar | ScopeIndicator | FlowIndicator | ',' | ':' | '>' | '*' | '|' | '=' ) )\r
1089             // SilkLine.g:217:24: ~ ( PlainUnsafeChar | ScopeIndicator | FlowIndicator | ',' | ':' | '>' | '*' | '|' | '=' )\r
1090             {\r
1091             if ( (input.LA(1)>='\u0000' && 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)<='\uFFFF') ) {\r
1092                 input.consume();\r
1093 \r
1094             }\r
1095             else {\r
1096                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1097                 recover(mse);\r
1098                 throw mse;}\r
1099 \r
1100 \r
1101             }\r
1102 \r
1103         }\r
1104         finally {\r
1105         }\r
1106     }\r
1107     // $ANTLR end "PlainSafeKey"\r
1108 \r
1109     // $ANTLR start "PlainSafeIn"\r
1110     public final void mPlainSafeIn() throws RecognitionException {\r
1111         try {\r
1112             // SilkLine.g:218:21: (~ ( PlainUnsafeChar | ScopeIndicator | ',' ) )\r
1113             // SilkLine.g:218:23: ~ ( PlainUnsafeChar | ScopeIndicator | ',' )\r
1114             {\r
1115             if ( (input.LA(1)>='\u0000' && 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') ) {\r
1116                 input.consume();\r
1117 \r
1118             }\r
1119             else {\r
1120                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1121                 recover(mse);\r
1122                 throw mse;}\r
1123 \r
1124 \r
1125             }\r
1126 \r
1127         }\r
1128         finally {\r
1129         }\r
1130     }\r
1131     // $ANTLR end "PlainSafeIn"\r
1132 \r
1133     // $ANTLR start "PlainSafeOut"\r
1134     public final void mPlainSafeOut() throws RecognitionException {\r
1135         try {\r
1136             // SilkLine.g:219:22: (~ ( PlainUnsafeChar ) )\r
1137             // SilkLine.g:219:24: ~ ( PlainUnsafeChar )\r
1138             {\r
1139             if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='$' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {\r
1140                 input.consume();\r
1141 \r
1142             }\r
1143             else {\r
1144                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1145                 recover(mse);\r
1146                 throw mse;}\r
1147 \r
1148 \r
1149             }\r
1150 \r
1151         }\r
1152         finally {\r
1153         }\r
1154     }\r
1155     // $ANTLR end "PlainSafeOut"\r
1156 \r
1157     // $ANTLR start "NonSpaceChar"\r
1158     public final void mNonSpaceChar() throws RecognitionException {\r
1159         try {\r
1160             // SilkLine.g:221:22: (~ ( '\"' | '\\\\' | WhiteSpace ) )\r
1161             // SilkLine.g:221:24: ~ ( '\"' | '\\\\' | WhiteSpace )\r
1162             {\r
1163             if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\n' && input.LA(1)<='\u001F')||input.LA(1)=='!'||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {\r
1164                 input.consume();\r
1165 \r
1166             }\r
1167             else {\r
1168                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1169                 recover(mse);\r
1170                 throw mse;}\r
1171 \r
1172 \r
1173             }\r
1174 \r
1175         }\r
1176         finally {\r
1177         }\r
1178     }\r
1179     // $ANTLR end "NonSpaceChar"\r
1180 \r
1181     // $ANTLR start "PlainFirst"\r
1182     public final void mPlainFirst() throws RecognitionException {\r
1183         try {\r
1184             // SilkLine.g:223:2: (~ ( '-' | '+' | '?' | PlainUnsafeChar | WhiteSpace | Indicator ) | {...}? => ( '-' | '+' | ( ':' | '?' ) NonSpaceChar ) )\r
1185             int alt9=2;\r
1186             int LA9_0 = input.LA(1);\r
1187 \r
1188             if ( ((LA9_0>='\u0000' && LA9_0<='\b')||(LA9_0>='\n' && LA9_0<='\u001F')||LA9_0=='!'||LA9_0=='$'||LA9_0=='&'||(LA9_0>='.' && LA9_0<='9')||(LA9_0>=';' && LA9_0<='<')||(LA9_0>='A' && LA9_0<='Z')||(LA9_0>='^' && LA9_0<='z')||(LA9_0>='~' && LA9_0<='\uFFFF')) ) {\r
1189                 alt9=1;\r
1190             }\r
1191             else if ( (LA9_0=='+'||LA9_0=='-'||LA9_0==':'||LA9_0=='?') && (( isValue() ))) {\r
1192                 alt9=2;\r
1193             }\r
1194             else {\r
1195                 NoViableAltException nvae =\r
1196                     new NoViableAltException("", 9, 0, input);\r
1197 \r
1198                 throw nvae;\r
1199             }\r
1200             switch (alt9) {\r
1201                 case 1 :\r
1202                     // SilkLine.g:223:5: ~ ( '-' | '+' | '?' | PlainUnsafeChar | WhiteSpace | Indicator )\r
1203                     {\r
1204                     if ( (input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\n' && input.LA(1)<='\u001F')||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)>='A' && input.LA(1)<='Z')||(input.LA(1)>='^' && input.LA(1)<='z')||(input.LA(1)>='~' && input.LA(1)<='\uFFFF') ) {\r
1205                         input.consume();\r
1206 \r
1207                     }\r
1208                     else {\r
1209                         MismatchedSetException mse = new MismatchedSetException(null,input);\r
1210                         recover(mse);\r
1211                         throw mse;}\r
1212 \r
1213 \r
1214                     }\r
1215                     break;\r
1216                 case 2 :\r
1217                     // SilkLine.g:224:4: {...}? => ( '-' | '+' | ( ':' | '?' ) NonSpaceChar )\r
1218                     {\r
1219                     if ( !(( isValue() )) ) {\r
1220                         throw new FailedPredicateException(input, "PlainFirst", " isValue() ");\r
1221                     }\r
1222                     // SilkLine.g:224:22: ( '-' | '+' | ( ':' | '?' ) NonSpaceChar )\r
1223                     int alt8=3;\r
1224                     switch ( input.LA(1) ) {\r
1225                     case '-':\r
1226                         {\r
1227                         alt8=1;\r
1228                         }\r
1229                         break;\r
1230                     case '+':\r
1231                         {\r
1232                         alt8=2;\r
1233                         }\r
1234                         break;\r
1235                     case ':':\r
1236                     case '?':\r
1237                         {\r
1238                         alt8=3;\r
1239                         }\r
1240                         break;\r
1241                     default:\r
1242                         NoViableAltException nvae =\r
1243                             new NoViableAltException("", 8, 0, input);\r
1244 \r
1245                         throw nvae;\r
1246                     }\r
1247 \r
1248                     switch (alt8) {\r
1249                         case 1 :\r
1250                             // SilkLine.g:224:23: '-'\r
1251                             {\r
1252                             match('-'); \r
1253 \r
1254                             }\r
1255                             break;\r
1256                         case 2 :\r
1257                             // SilkLine.g:224:29: '+'\r
1258                             {\r
1259                             match('+'); \r
1260 \r
1261                             }\r
1262                             break;\r
1263                         case 3 :\r
1264                             // SilkLine.g:224:35: ( ':' | '?' ) NonSpaceChar\r
1265                             {\r
1266                             if ( input.LA(1)==':'||input.LA(1)=='?' ) {\r
1267                                 input.consume();\r
1268 \r
1269                             }\r
1270                             else {\r
1271                                 MismatchedSetException mse = new MismatchedSetException(null,input);\r
1272                                 recover(mse);\r
1273                                 throw mse;}\r
1274 \r
1275                             mNonSpaceChar(); \r
1276 \r
1277                             }\r
1278                             break;\r
1279 \r
1280                     }\r
1281 \r
1282 \r
1283                     }\r
1284                     break;\r
1285 \r
1286             }\r
1287         }\r
1288         finally {\r
1289         }\r
1290     }\r
1291     // $ANTLR end "PlainFirst"\r
1292 \r
1293     // $ANTLR start "PlainOneLine"\r
1294     public final void mPlainOneLine() throws RecognitionException {\r
1295         try {\r
1296             int _type = PlainOneLine;\r
1297             int _channel = DEFAULT_TOKEN_CHANNEL;\r
1298             // SilkLine.g:228:2: ({...}? => PlainFirst ( PlainSafeKey )* | {...}? => PlainFirst ( PlainSafeIn )* | {...}? => PlainFirst ( PlainSafeOut )* )\r
1299             int alt13=3;\r
1300             int LA13_0 = input.LA(1);\r
1301 \r
1302             if ( ((LA13_0>='\u0000' && LA13_0<='\b')||(LA13_0>='\n' && LA13_0<='\u001F')||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<='\uFFFF')) && ((( isInValue() )||( isOutValue() )||( isKey() )))) {\r
1303                 int LA13_1 = input.LA(2);\r
1304 \r
1305                 if ( (( isKey() )) ) {\r
1306                     alt13=1;\r
1307                 }\r
1308                 else if ( (( isInValue() )) ) {\r
1309                     alt13=2;\r
1310                 }\r
1311                 else if ( (( isOutValue() )) ) {\r
1312                     alt13=3;\r
1313                 }\r
1314                 else {\r
1315                     NoViableAltException nvae =\r
1316                         new NoViableAltException("", 13, 1, input);\r
1317 \r
1318                     throw nvae;\r
1319                 }\r
1320             }\r
1321             else if ( (LA13_0=='-') && (((( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))))) {\r
1322                 int LA13_2 = input.LA(2);\r
1323 \r
1324                 if ( ((( isKey() )&&( isValue() ))) ) {\r
1325                     alt13=1;\r
1326                 }\r
1327                 else if ( ((( isInValue() )&&( isValue() ))) ) {\r
1328                     alt13=2;\r
1329                 }\r
1330                 else if ( ((( isOutValue() )&&( isValue() ))) ) {\r
1331                     alt13=3;\r
1332                 }\r
1333                 else {\r
1334                     NoViableAltException nvae =\r
1335                         new NoViableAltException("", 13, 2, input);\r
1336 \r
1337                     throw nvae;\r
1338                 }\r
1339             }\r
1340             else if ( (LA13_0=='+') && (((( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))))) {\r
1341                 int LA13_3 = input.LA(2);\r
1342 \r
1343                 if ( ((( isKey() )&&( isValue() ))) ) {\r
1344                     alt13=1;\r
1345                 }\r
1346                 else if ( ((( isInValue() )&&( isValue() ))) ) {\r
1347                     alt13=2;\r
1348                 }\r
1349                 else if ( ((( isOutValue() )&&( isValue() ))) ) {\r
1350                     alt13=3;\r
1351                 }\r
1352                 else {\r
1353                     NoViableAltException nvae =\r
1354                         new NoViableAltException("", 13, 3, input);\r
1355 \r
1356                     throw nvae;\r
1357                 }\r
1358             }\r
1359             else if ( (LA13_0==':'||LA13_0=='?') && (((( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))))) {\r
1360                 int LA13_4 = input.LA(2);\r
1361 \r
1362                 if ( ((LA13_4>='\u0000' && LA13_4<='\b')||(LA13_4>='\n' && LA13_4<='\u001F')||LA13_4=='!'||(LA13_4>='#' && LA13_4<='[')||(LA13_4>=']' && LA13_4<='\uFFFF')) && (((( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))))) {\r
1363                     int LA13_8 = input.LA(3);\r
1364 \r
1365                     if ( ((( isKey() )&&( isValue() ))) ) {\r
1366                         alt13=1;\r
1367                     }\r
1368                     else if ( ((( isInValue() )&&( isValue() ))) ) {\r
1369                         alt13=2;\r
1370                     }\r
1371                     else if ( ((( isOutValue() )&&( isValue() ))) ) {\r
1372                         alt13=3;\r
1373                     }\r
1374                     else {\r
1375                         NoViableAltException nvae =\r
1376                             new NoViableAltException("", 13, 8, input);\r
1377 \r
1378                         throw nvae;\r
1379                     }\r
1380                 }\r
1381                 else {\r
1382                     NoViableAltException nvae =\r
1383                         new NoViableAltException("", 13, 4, input);\r
1384 \r
1385                     throw nvae;\r
1386                 }\r
1387             }\r
1388             else {\r
1389                 NoViableAltException nvae =\r
1390                     new NoViableAltException("", 13, 0, input);\r
1391 \r
1392                 throw nvae;\r
1393             }\r
1394             switch (alt13) {\r
1395                 case 1 :\r
1396                     // SilkLine.g:228:4: {...}? => PlainFirst ( PlainSafeKey )*\r
1397                     {\r
1398                     if ( !(( isKey() )) ) {\r
1399                         throw new FailedPredicateException(input, "PlainOneLine", " isKey() ");\r
1400                     }\r
1401                     mPlainFirst(); \r
1402                     // SilkLine.g:228:32: ( PlainSafeKey )*\r
1403                     loop10:\r
1404                     do {\r
1405                         int alt10=2;\r
1406                         int LA10_0 = input.LA(1);\r
1407 \r
1408                         if ( ((LA10_0>='\u0000' && LA10_0<='!')||(LA10_0>='$' && LA10_0<='\'')||LA10_0=='+'||(LA10_0>='-' && LA10_0<='9')||(LA10_0>=';' && LA10_0<='<')||(LA10_0>='?' && LA10_0<='Z')||(LA10_0>='^' && LA10_0<='z')||(LA10_0>='~' && LA10_0<='\uFFFF')) ) {\r
1409                             alt10=1;\r
1410                         }\r
1411 \r
1412 \r
1413                         switch (alt10) {\r
1414                         case 1 :\r
1415                             // SilkLine.g:228:32: PlainSafeKey\r
1416                             {\r
1417                             mPlainSafeKey(); \r
1418 \r
1419                             }\r
1420                             break;\r
1421 \r
1422                         default :\r
1423                             break loop10;\r
1424                         }\r
1425                     } while (true);\r
1426 \r
1427                      transit(Symbol.LeaveValue); \r
1428 \r
1429                     }\r
1430                     break;\r
1431                 case 2 :\r
1432                     // SilkLine.g:229:5: {...}? => PlainFirst ( PlainSafeIn )*\r
1433                     {\r
1434                     if ( !(( isInValue() )) ) {\r
1435                         throw new FailedPredicateException(input, "PlainOneLine", " isInValue() ");\r
1436                     }\r
1437                     mPlainFirst(); \r
1438                     // SilkLine.g:229:37: ( PlainSafeIn )*\r
1439                     loop11:\r
1440                     do {\r
1441                         int alt11=2;\r
1442                         int LA11_0 = input.LA(1);\r
1443 \r
1444                         if ( ((LA11_0>='\u0000' && LA11_0<='!')||(LA11_0>='$' && LA11_0<='\'')||(LA11_0>='*' && LA11_0<='+')||(LA11_0>='-' && LA11_0<='[')||(LA11_0>=']' && LA11_0<='\uFFFF')) ) {\r
1445                             alt11=1;\r
1446                         }\r
1447 \r
1448 \r
1449                         switch (alt11) {\r
1450                         case 1 :\r
1451                             // SilkLine.g:229:37: PlainSafeIn\r
1452                             {\r
1453                             mPlainSafeIn(); \r
1454 \r
1455                             }\r
1456                             break;\r
1457 \r
1458                         default :\r
1459                             break loop11;\r
1460                         }\r
1461                     } while (true);\r
1462 \r
1463                      transit(Symbol.LeaveValue); \r
1464 \r
1465                     }\r
1466                     break;\r
1467                 case 3 :\r
1468                     // SilkLine.g:230:5: {...}? => PlainFirst ( PlainSafeOut )*\r
1469                     {\r
1470                     if ( !(( isOutValue() )) ) {\r
1471                         throw new FailedPredicateException(input, "PlainOneLine", " isOutValue() ");\r
1472                     }\r
1473                     mPlainFirst(); \r
1474                     // SilkLine.g:230:38: ( PlainSafeOut )*\r
1475                     loop12:\r
1476                     do {\r
1477                         int alt12=2;\r
1478                         int LA12_0 = input.LA(1);\r
1479 \r
1480                         if ( ((LA12_0>='\u0000' && LA12_0<='!')||(LA12_0>='$' && LA12_0<='[')||(LA12_0>=']' && LA12_0<='\uFFFF')) ) {\r
1481                             alt12=1;\r
1482                         }\r
1483 \r
1484 \r
1485                         switch (alt12) {\r
1486                         case 1 :\r
1487                             // SilkLine.g:230:38: PlainSafeOut\r
1488                             {\r
1489                             mPlainSafeOut(); \r
1490 \r
1491                             }\r
1492                             break;\r
1493 \r
1494                         default :\r
1495                             break loop12;\r
1496                         }\r
1497                     } while (true);\r
1498 \r
1499                      transit(Symbol.LeaveValue); \r
1500 \r
1501                     }\r
1502                     break;\r
1503 \r
1504             }\r
1505             state.type = _type;\r
1506             state.channel = _channel;\r
1507         }\r
1508         finally {\r
1509         }\r
1510     }\r
1511     // $ANTLR end "PlainOneLine"\r
1512 \r
1513     // $ANTLR start "JSON"\r
1514     public final void mJSON() throws RecognitionException {\r
1515         try {\r
1516             int _type = JSON;\r
1517             int _channel = DEFAULT_TOKEN_CHANNEL;\r
1518             // SilkLine.g:235:2: ({...}? => '{' | {...}? => '[' )\r
1519             int alt14=2;\r
1520             int LA14_0 = input.LA(1);\r
1521 \r
1522             if ( (LA14_0=='{') && (( isValue() ))) {\r
1523                 alt14=1;\r
1524             }\r
1525             else if ( (LA14_0=='[') && (( isValue() ))) {\r
1526                 alt14=2;\r
1527             }\r
1528             else {\r
1529                 NoViableAltException nvae =\r
1530                     new NoViableAltException("", 14, 0, input);\r
1531 \r
1532                 throw nvae;\r
1533             }\r
1534             switch (alt14) {\r
1535                 case 1 :\r
1536                     // SilkLine.g:235:4: {...}? => '{'\r
1537                     {\r
1538                     if ( !(( isValue() )) ) {\r
1539                         throw new FailedPredicateException(input, "JSON", " isValue() ");\r
1540                     }\r
1541                     match('{'); \r
1542 \r
1543                                 //_logger.info("enter JSON object");\r
1544                                 InLineJSONLexer l = new InLineJSONLexer(input);\r
1545                                 CommonTokenStream tokens = new CommonTokenStream(l);\r
1546                                 InLineJSONParser p = new InLineJSONParser(tokens);\r
1547                                 p.jsonObjectFragment();\r
1548                                 \r
1549                                 //_channel = JSON_CHANNEL;\r
1550                                 emit(new CommonToken(JSON, getText())); \r
1551                         \r
1552 \r
1553                     }\r
1554                     break;\r
1555                 case 2 :\r
1556                     // SilkLine.g:246:4: {...}? => '['\r
1557                     {\r
1558                     if ( !(( isValue() )) ) {\r
1559                         throw new FailedPredicateException(input, "JSON", " isValue() ");\r
1560                     }\r
1561                     match('['); \r
1562 \r
1563                                 //_logger.info("enter JSON array");\r
1564                                 InLineJSONLexer l = new InLineJSONLexer(input);\r
1565                                 CommonTokenStream tokens = new CommonTokenStream(l);\r
1566                                 InLineJSONParser p = new InLineJSONParser(tokens);\r
1567                                 p.jsonArrayFragment();\r
1568                                 \r
1569                                 //_channel = JSON_CHANNEL;\r
1570                                 emit(new CommonToken(JSON, getText())); \r
1571                         \r
1572 \r
1573                     }\r
1574                     break;\r
1575 \r
1576             }\r
1577             state.type = _type;\r
1578             state.channel = _channel;\r
1579         }\r
1580         finally {\r
1581         }\r
1582     }\r
1583     // $ANTLR end "JSON"\r
1584 \r
1585     // $ANTLR start "Separation"\r
1586     public final void mSeparation() throws RecognitionException {\r
1587         try {\r
1588             int _type = Separation;\r
1589             int _channel = DEFAULT_TOKEN_CHANNEL;\r
1590             // SilkLine.g:259:11: ({...}? => ( WhiteSpace )+ )\r
1591             // SilkLine.g:259:13: {...}? => ( WhiteSpace )+\r
1592             {\r
1593             if ( !(( !isHead() )) ) {\r
1594                 throw new FailedPredicateException(input, "Separation", " !isHead() ");\r
1595             }\r
1596             // SilkLine.g:259:31: ( WhiteSpace )+\r
1597             int cnt15=0;\r
1598             loop15:\r
1599             do {\r
1600                 int alt15=2;\r
1601                 int LA15_0 = input.LA(1);\r
1602 \r
1603                 if ( (LA15_0=='\t'||LA15_0==' ') ) {\r
1604                     alt15=1;\r
1605                 }\r
1606 \r
1607 \r
1608                 switch (alt15) {\r
1609                 case 1 :\r
1610                     // SilkLine.g:259:31: WhiteSpace\r
1611                     {\r
1612                     mWhiteSpace(); \r
1613 \r
1614                     }\r
1615                     break;\r
1616 \r
1617                 default :\r
1618                     if ( cnt15 >= 1 ) break loop15;\r
1619                         EarlyExitException eee =\r
1620                             new EarlyExitException(15, input);\r
1621                         throw eee;\r
1622                 }\r
1623                 cnt15++;\r
1624             } while (true);\r
1625 \r
1626              _channel=HIDDEN; \r
1627 \r
1628             }\r
1629 \r
1630             state.type = _type;\r
1631             state.channel = _channel;\r
1632         }\r
1633         finally {\r
1634         }\r
1635     }\r
1636     // $ANTLR end "Separation"\r
1637 \r
1638     public void mTokens() throws RecognitionException {\r
1639         // SilkLine.g:1:8: ( LineComment | NodeIndent | FunctionIndent | BlankLine | LParen | RParen | Comma | Colon | EqEq | Seq | TabSeq | Star | At | Plus | LBracket | RBracket | Question | String | PlainOneLine | JSON | Separation )\r
1640         int alt16=21;\r
1641         alt16 = dfa16.predict(input);\r
1642         switch (alt16) {\r
1643             case 1 :\r
1644                 // SilkLine.g:1:10: LineComment\r
1645                 {\r
1646                 mLineComment(); \r
1647 \r
1648                 }\r
1649                 break;\r
1650             case 2 :\r
1651                 // SilkLine.g:1:22: NodeIndent\r
1652                 {\r
1653                 mNodeIndent(); \r
1654 \r
1655                 }\r
1656                 break;\r
1657             case 3 :\r
1658                 // SilkLine.g:1:33: FunctionIndent\r
1659                 {\r
1660                 mFunctionIndent(); \r
1661 \r
1662                 }\r
1663                 break;\r
1664             case 4 :\r
1665                 // SilkLine.g:1:48: BlankLine\r
1666                 {\r
1667                 mBlankLine(); \r
1668 \r
1669                 }\r
1670                 break;\r
1671             case 5 :\r
1672                 // SilkLine.g:1:58: LParen\r
1673                 {\r
1674                 mLParen(); \r
1675 \r
1676                 }\r
1677                 break;\r
1678             case 6 :\r
1679                 // SilkLine.g:1:65: RParen\r
1680                 {\r
1681                 mRParen(); \r
1682 \r
1683                 }\r
1684                 break;\r
1685             case 7 :\r
1686                 // SilkLine.g:1:72: Comma\r
1687                 {\r
1688                 mComma(); \r
1689 \r
1690                 }\r
1691                 break;\r
1692             case 8 :\r
1693                 // SilkLine.g:1:78: Colon\r
1694                 {\r
1695                 mColon(); \r
1696 \r
1697                 }\r
1698                 break;\r
1699             case 9 :\r
1700                 // SilkLine.g:1:84: EqEq\r
1701                 {\r
1702                 mEqEq(); \r
1703 \r
1704                 }\r
1705                 break;\r
1706             case 10 :\r
1707                 // SilkLine.g:1:89: Seq\r
1708                 {\r
1709                 mSeq(); \r
1710 \r
1711                 }\r
1712                 break;\r
1713             case 11 :\r
1714                 // SilkLine.g:1:93: TabSeq\r
1715                 {\r
1716                 mTabSeq(); \r
1717 \r
1718                 }\r
1719                 break;\r
1720             case 12 :\r
1721                 // SilkLine.g:1:100: Star\r
1722                 {\r
1723                 mStar(); \r
1724 \r
1725                 }\r
1726                 break;\r
1727             case 13 :\r
1728                 // SilkLine.g:1:105: At\r
1729                 {\r
1730                 mAt(); \r
1731 \r
1732                 }\r
1733                 break;\r
1734             case 14 :\r
1735                 // SilkLine.g:1:108: Plus\r
1736                 {\r
1737                 mPlus(); \r
1738 \r
1739                 }\r
1740                 break;\r
1741             case 15 :\r
1742                 // SilkLine.g:1:113: LBracket\r
1743                 {\r
1744                 mLBracket(); \r
1745 \r
1746                 }\r
1747                 break;\r
1748             case 16 :\r
1749                 // SilkLine.g:1:122: RBracket\r
1750                 {\r
1751                 mRBracket(); \r
1752 \r
1753                 }\r
1754                 break;\r
1755             case 17 :\r
1756                 // SilkLine.g:1:131: Question\r
1757                 {\r
1758                 mQuestion(); \r
1759 \r
1760                 }\r
1761                 break;\r
1762             case 18 :\r
1763                 // SilkLine.g:1:140: String\r
1764                 {\r
1765                 mString(); \r
1766 \r
1767                 }\r
1768                 break;\r
1769             case 19 :\r
1770                 // SilkLine.g:1:147: PlainOneLine\r
1771                 {\r
1772                 mPlainOneLine(); \r
1773 \r
1774                 }\r
1775                 break;\r
1776             case 20 :\r
1777                 // SilkLine.g:1:160: JSON\r
1778                 {\r
1779                 mJSON(); \r
1780 \r
1781                 }\r
1782                 break;\r
1783             case 21 :\r
1784                 // SilkLine.g:1:165: Separation\r
1785                 {\r
1786                 mSeparation(); \r
1787 \r
1788                 }\r
1789                 break;\r
1790 \r
1791         }\r
1792 \r
1793     }\r
1794 \r
1795 \r
1796     protected DFA16 dfa16 = new DFA16(this);\r
1797     static final String DFA16_eotS =\r
1798         "\1\6\1\uffff\1\26\1\31\1\35\1\26\4\uffff\1\37\4\uffff\1\40\1\41"+\r
1799         "\1\uffff\1\42\24\uffff";\r
1800     static final String DFA16_eofS =\r
1801         "\47\uffff";\r
1802     static final String DFA16_minS =\r
1803         "\1\0\1\uffff\1\11\2\0\1\11\4\uffff\1\0\4\uffff\2\0\1\uffff\1\0"+\r
1804         "\3\uffff\1\0\2\uffff\1\0\3\uffff\1\0\2\uffff\2\0\5\uffff";\r
1805     static final String DFA16_maxS =\r
1806         "\1\uffff\1\uffff\1\100\1\uffff\1\0\1\40\4\uffff\1\uffff\4\uffff"+\r
1807         "\1\uffff\1\0\1\uffff\1\uffff\3\uffff\1\0\2\uffff\1\0\3\uffff\1\0"+\r
1808         "\2\uffff\2\0\5\uffff";\r
1809     static final String DFA16_acceptS =\r
1810         "\1\uffff\1\1\4\uffff\1\4\1\5\1\6\1\7\1\uffff\1\11\1\12\1\13\1\14"+\r
1811         "\2\uffff\1\20\1\uffff\1\22\1\23\1\24\1\uffff\1\2\1\3\1\uffff\3\23"+\r
1812         "\1\uffff\1\23\1\10\2\uffff\1\21\1\25\1\15\1\16\1\17";\r
1813     static final String DFA16_specialS =\r
1814         "\1\7\1\uffff\1\4\1\11\1\uffff\1\3\4\uffff\1\12\4\uffff\1\13\2\uffff"+\r
1815         "\1\1\3\uffff\1\2\2\uffff\1\10\3\uffff\1\0\2\uffff\1\6\1\5\5\uffff}>";\r
1816     static final String[] DFA16_transitionS = {\r
1817             "\11\24\1\5\26\24\1\2\1\24\1\23\1\1\1\24\1\uffff\1\24\1\uffff"+\r
1818             "\1\7\1\10\1\16\1\17\1\11\1\3\14\24\1\12\2\24\1\13\1\14\1\22"+\r
1819             "\1\4\32\24\1\20\1\uffff\1\21\35\24\1\25\1\15\1\uffff\uff82\24",\r
1820             "",\r
1821             "\1\5\26\uffff\1\2\14\uffff\1\27\22\uffff\1\30",\r
1822             "\42\32\2\uffff\4\32\2\34\1\33\1\32\1\34\15\32\1\33\2\32\2"+\r
1823             "\33\34\32\1\33\1\uffff\1\33\35\32\3\33\uff82\32",\r
1824             "\1\uffff",\r
1825             "\1\5\26\uffff\1\5",\r
1826             "",\r
1827             "",\r
1828             "",\r
1829             "",\r
1830             "\11\36\1\uffff\26\36\1\uffff\1\36\1\uffff\71\36\1\uffff\uffa3"+\r
1831             "\36",\r
1832             "",\r
1833             "",\r
1834             "",\r
1835             "",\r
1836             "\42\32\2\uffff\4\32\2\34\1\33\1\32\1\34\15\32\1\33\2\32\2"+\r
1837             "\33\34\32\1\33\1\uffff\1\33\35\32\3\33\uff82\32",\r
1838             "\1\uffff",\r
1839             "",\r
1840             "\11\36\1\uffff\26\36\1\uffff\1\36\1\uffff\71\36\1\uffff\uffa3"+\r
1841             "\36",\r
1842             "",\r
1843             "",\r
1844             "",\r
1845             "\1\uffff",\r
1846             "",\r
1847             "",\r
1848             "\1\uffff",\r
1849             "",\r
1850             "",\r
1851             "",\r
1852             "\1\uffff",\r
1853             "",\r
1854             "",\r
1855             "\1\uffff",\r
1856             "\1\uffff",\r
1857             "",\r
1858             "",\r
1859             "",\r
1860             "",\r
1861             ""\r
1862     };\r
1863 \r
1864     static final short[] DFA16_eot = DFA.unpackEncodedString(DFA16_eotS);\r
1865     static final short[] DFA16_eof = DFA.unpackEncodedString(DFA16_eofS);\r
1866     static final char[] DFA16_min = DFA.unpackEncodedStringToUnsignedChars(DFA16_minS);\r
1867     static final char[] DFA16_max = DFA.unpackEncodedStringToUnsignedChars(DFA16_maxS);\r
1868     static final short[] DFA16_accept = DFA.unpackEncodedString(DFA16_acceptS);\r
1869     static final short[] DFA16_special = DFA.unpackEncodedString(DFA16_specialS);\r
1870     static final short[][] DFA16_transition;\r
1871 \r
1872     static {\r
1873         int numStates = DFA16_transitionS.length;\r
1874         DFA16_transition = new short[numStates][];\r
1875         for (int i=0; i<numStates; i++) {\r
1876             DFA16_transition[i] = DFA.unpackEncodedString(DFA16_transitionS[i]);\r
1877         }\r
1878     }\r
1879 \r
1880     class DFA16 extends DFA {\r
1881 \r
1882         public DFA16(BaseRecognizer recognizer) {\r
1883             this.recognizer = recognizer;\r
1884             this.decisionNumber = 16;\r
1885             this.eot = DFA16_eot;\r
1886             this.eof = DFA16_eof;\r
1887             this.min = DFA16_min;\r
1888             this.max = DFA16_max;\r
1889             this.accept = DFA16_accept;\r
1890             this.special = DFA16_special;\r
1891             this.transition = DFA16_transition;\r
1892         }\r
1893         public String getDescription() {\r
1894             return "1:1: Tokens : ( LineComment | NodeIndent | FunctionIndent | BlankLine | LParen | RParen | Comma | Colon | EqEq | Seq | TabSeq | Star | At | Plus | LBracket | RBracket | Question | String | PlainOneLine | JSON | Separation );";\r
1895         }\r
1896         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {\r
1897             IntStream input = _input;\r
1898                 int _s = s;\r
1899             switch ( s ) {\r
1900                     case 0 : \r
1901                         int LA16_29 = input.LA(1);\r
1902 \r
1903                          \r
1904                         int index16_29 = input.index();\r
1905                         input.rewind();\r
1906                         s = -1;\r
1907                         if ( (( isHead() )) ) {s = 24;}\r
1908 \r
1909                         else if ( (true) ) {s = 36;}\r
1910 \r
1911                          \r
1912                         input.seek(index16_29);\r
1913                         if ( s>=0 ) return s;\r
1914                         break;\r
1915                     case 1 : \r
1916                         int LA16_18 = input.LA(1);\r
1917 \r
1918                          \r
1919                         int index16_18 = input.index();\r
1920                         input.rewind();\r
1921                         s = -1;\r
1922                         if ( ((LA16_18>='\u0000' && LA16_18<='\b')||(LA16_18>='\n' && LA16_18<='\u001F')||LA16_18=='!'||(LA16_18>='#' && LA16_18<='[')||(LA16_18>=']' && LA16_18<='\uFFFF')) && (((( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))))) {s = 30;}\r
1923 \r
1924                         else s = 34;\r
1925 \r
1926                          \r
1927                         input.seek(index16_18);\r
1928                         if ( s>=0 ) return s;\r
1929                         break;\r
1930                     case 2 : \r
1931                         int LA16_22 = input.LA(1);\r
1932 \r
1933                          \r
1934                         int index16_22 = input.index();\r
1935                         input.rewind();\r
1936                         s = -1;\r
1937                         if ( (( isHead() )) ) {s = 6;}\r
1938 \r
1939                         else if ( (( !isHead() )) ) {s = 35;}\r
1940 \r
1941                          \r
1942                         input.seek(index16_22);\r
1943                         if ( s>=0 ) return s;\r
1944                         break;\r
1945                     case 3 : \r
1946                         int LA16_5 = input.LA(1);\r
1947 \r
1948                          \r
1949                         int index16_5 = input.index();\r
1950                         input.rewind();\r
1951                         s = -1;\r
1952                         if ( (LA16_5=='\t'||LA16_5==' ') && ((( !isHead() )||( isHead() )))) {s = 5;}\r
1953 \r
1954                         else s = 22;\r
1955 \r
1956                          \r
1957                         input.seek(index16_5);\r
1958                         if ( s>=0 ) return s;\r
1959                         break;\r
1960                     case 4 : \r
1961                         int LA16_2 = input.LA(1);\r
1962 \r
1963                          \r
1964                         int index16_2 = input.index();\r
1965                         input.rewind();\r
1966                         s = -1;\r
1967                         if ( (LA16_2==' ') && ((( !isHead() )||( isHead() )))) {s = 2;}\r
1968 \r
1969                         else if ( (LA16_2=='-') && (( isHead() ))) {s = 23;}\r
1970 \r
1971                         else if ( (LA16_2=='\t') && ((( !isHead() )||( isHead() )))) {s = 5;}\r
1972 \r
1973                         else if ( (LA16_2=='@') && (( isHead() ))) {s = 24;}\r
1974 \r
1975                         else s = 22;\r
1976 \r
1977                          \r
1978                         input.seek(index16_2);\r
1979                         if ( s>=0 ) return s;\r
1980                         break;\r
1981                     case 5 : \r
1982                         int LA16_33 = input.LA(1);\r
1983 \r
1984                          \r
1985                         int index16_33 = input.index();\r
1986                         input.rewind();\r
1987                         s = -1;\r
1988                         if ( (!((( isValue() )))) ) {s = 38;}\r
1989 \r
1990                         else if ( (( isValue() )) ) {s = 21;}\r
1991 \r
1992                          \r
1993                         input.seek(index16_33);\r
1994                         if ( s>=0 ) return s;\r
1995                         break;\r
1996                     case 6 : \r
1997                         int LA16_32 = input.LA(1);\r
1998 \r
1999                          \r
2000                         int index16_32 = input.index();\r
2001                         input.rewind();\r
2002                         s = -1;\r
2003                         if ( (!((((( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() )))))) ) {s = 37;}\r
2004 \r
2005                         else if ( (((( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() )))) ) {s = 30;}\r
2006 \r
2007                          \r
2008                         input.seek(index16_32);\r
2009                         if ( s>=0 ) return s;\r
2010                         break;\r
2011                     case 7 : \r
2012                         int LA16_0 = input.LA(1);\r
2013 \r
2014                          \r
2015                         int index16_0 = input.index();\r
2016                         input.rewind();\r
2017                         s = -1;\r
2018                         if ( (LA16_0=='#') ) {s = 1;}\r
2019 \r
2020                         else if ( (LA16_0==' ') && ((( !isHead() )||( isHead() )))) {s = 2;}\r
2021 \r
2022                         else if ( (LA16_0=='-') && (((( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||( isHead() )||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))))) {s = 3;}\r
2023 \r
2024                         else if ( (LA16_0=='@') ) {s = 4;}\r
2025 \r
2026                         else if ( (LA16_0=='\t') && ((( !isHead() )||( isHead() )))) {s = 5;}\r
2027 \r
2028                         else if ( (LA16_0=='(') ) {s = 7;}\r
2029 \r
2030                         else if ( (LA16_0==')') ) {s = 8;}\r
2031 \r
2032                         else if ( (LA16_0==',') ) {s = 9;}\r
2033 \r
2034                         else if ( (LA16_0==':') ) {s = 10;}\r
2035 \r
2036                         else if ( (LA16_0=='=') ) {s = 11;}\r
2037 \r
2038                         else if ( (LA16_0=='>') ) {s = 12;}\r
2039 \r
2040                         else if ( (LA16_0=='|') ) {s = 13;}\r
2041 \r
2042                         else if ( (LA16_0=='*') ) {s = 14;}\r
2043 \r
2044                         else if ( (LA16_0=='+') ) {s = 15;}\r
2045 \r
2046                         else if ( (LA16_0=='[') ) {s = 16;}\r
2047 \r
2048                         else if ( (LA16_0==']') ) {s = 17;}\r
2049 \r
2050                         else if ( (LA16_0=='?') ) {s = 18;}\r
2051 \r
2052                         else if ( (LA16_0=='\"') ) {s = 19;}\r
2053 \r
2054                         else if ( ((LA16_0>='\u0000' && LA16_0<='\b')||(LA16_0>='\n' && LA16_0<='\u001F')||LA16_0=='!'||LA16_0=='$'||LA16_0=='&'||(LA16_0>='.' && LA16_0<='9')||(LA16_0>=';' && LA16_0<='<')||(LA16_0>='A' && LA16_0<='Z')||(LA16_0>='^' && LA16_0<='z')||(LA16_0>='~' && LA16_0<='\uFFFF')) && ((( isInValue() )||( isOutValue() )||( isKey() )))) {s = 20;}\r
2055 \r
2056                         else if ( (LA16_0=='{') && (( isValue() ))) {s = 21;}\r
2057 \r
2058                         else s = 6;\r
2059 \r
2060                          \r
2061                         input.seek(index16_0);\r
2062                         if ( s>=0 ) return s;\r
2063                         break;\r
2064                     case 8 : \r
2065                         int LA16_25 = input.LA(1);\r
2066 \r
2067                          \r
2068                         int index16_25 = input.index();\r
2069                         input.rewind();\r
2070                         s = -1;\r
2071                         if ( (( isHead() )) ) {s = 23;}\r
2072 \r
2073                         else if ( (((( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() )))) ) {s = 30;}\r
2074 \r
2075                          \r
2076                         input.seek(index16_25);\r
2077                         if ( s>=0 ) return s;\r
2078                         break;\r
2079                     case 9 : \r
2080                         int LA16_3 = input.LA(1);\r
2081 \r
2082                          \r
2083                         int index16_3 = input.index();\r
2084                         input.rewind();\r
2085                         s = -1;\r
2086                         if ( ((LA16_3>='\u0000' && LA16_3<='!')||(LA16_3>='$' && LA16_3<='\'')||LA16_3=='+'||(LA16_3>='-' && LA16_3<='9')||(LA16_3>=';' && LA16_3<='<')||(LA16_3>='?' && LA16_3<='Z')||(LA16_3>='^' && LA16_3<='z')||(LA16_3>='~' && LA16_3<='\uFFFF')) && (((( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))))) {s = 26;}\r
2087 \r
2088                         else if ( (LA16_3=='*'||LA16_3==':'||(LA16_3>='=' && LA16_3<='>')||LA16_3=='['||LA16_3==']'||(LA16_3>='{' && LA16_3<='}')) && (((( isInValue() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))))) {s = 27;}\r
2089 \r
2090                         else if ( ((LA16_3>='(' && LA16_3<=')')||LA16_3==',') && ((( isOutValue() )&&( isValue() )))) {s = 28;}\r
2091 \r
2092                         else s = 25;\r
2093 \r
2094                          \r
2095                         input.seek(index16_3);\r
2096                         if ( s>=0 ) return s;\r
2097                         break;\r
2098                     case 10 : \r
2099                         int LA16_10 = input.LA(1);\r
2100 \r
2101                          \r
2102                         int index16_10 = input.index();\r
2103                         input.rewind();\r
2104                         s = -1;\r
2105                         if ( ((LA16_10>='\u0000' && LA16_10<='\b')||(LA16_10>='\n' && LA16_10<='\u001F')||LA16_10=='!'||(LA16_10>='#' && LA16_10<='[')||(LA16_10>=']' && LA16_10<='\uFFFF')) && (((( isOutValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isInValue() )&&( isValue() ))))) {s = 30;}\r
2106 \r
2107                         else s = 31;\r
2108 \r
2109                          \r
2110                         input.seek(index16_10);\r
2111                         if ( s>=0 ) return s;\r
2112                         break;\r
2113                     case 11 : \r
2114                         int LA16_15 = input.LA(1);\r
2115 \r
2116                          \r
2117                         int index16_15 = input.index();\r
2118                         input.rewind();\r
2119                         s = -1;\r
2120                         if ( ((LA16_15>='\u0000' && LA16_15<='!')||(LA16_15>='$' && LA16_15<='\'')||LA16_15=='+'||(LA16_15>='-' && LA16_15<='9')||(LA16_15>=';' && LA16_15<='<')||(LA16_15>='?' && LA16_15<='Z')||(LA16_15>='^' && LA16_15<='z')||(LA16_15>='~' && LA16_15<='\uFFFF')) && (((( isInValue() )&&( isValue() ))||(( isKey() )&&( isValue() ))||(( isOutValue() )&&( isValue() ))))) {s = 26;}\r
2121 \r
2122                         else if ( (LA16_15=='*'||LA16_15==':'||(LA16_15>='=' && LA16_15<='>')||LA16_15=='['||LA16_15==']'||(LA16_15>='{' && LA16_15<='}')) && (((( isOutValue() )&&( isValue() ))||(( isInValue() )&&( isValue() ))))) {s = 27;}\r
2123 \r
2124                         else if ( ((LA16_15>='(' && LA16_15<=')')||LA16_15==',') && ((( isOutValue() )&&( isValue() )))) {s = 28;}\r
2125 \r
2126                         else s = 32;\r
2127 \r
2128                          \r
2129                         input.seek(index16_15);\r
2130                         if ( s>=0 ) return s;\r
2131                         break;\r
2132             }\r
2133             NoViableAltException nvae =\r
2134                 new NoViableAltException(getDescription(), 16, _s, input);\r
2135             error(nvae);\r
2136             throw nvae;\r
2137         }\r
2138     }\r
2139  \r
2140 \r
2141 }