001/* 002MIT License 003 004Copyright (c) 2020 FBSQL Team 005 006Permission is hereby granted, free of charge, to any person obtaining a copy 007of this software and associated documentation files (the "Software"), to deal 008in the Software without restriction, including without limitation the rights 009to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 010copies of the Software, and to permit persons to whom the Software is 011furnished to do so, subject to the following conditions: 012 013The above copyright notice and this permission notice shall be included in all 014copies or substantial portions of the Software. 015 016THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 017IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 018FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 019AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 020LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 021OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 022SOFTWARE. 023 024Home: https://fbsql.github.io 025E-Mail: fbsql.team@gmail.com 026*/ 027 028package org.fbsql.antlr4.generated; 029 030import org.antlr.v4.runtime.atn.*; 031import org.antlr.v4.runtime.dfa.DFA; 032import org.antlr.v4.runtime.*; 033import org.antlr.v4.runtime.misc.*; 034import org.antlr.v4.runtime.tree.*; 035import java.util.List; 036import java.util.Iterator; 037import java.util.ArrayList; 038 039@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) 040public class FbsqlParser extends Parser { 041 static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } 042 043 protected static final DFA[] _decisionToDFA; 044 protected static final PredictionContextCache _sharedContextCache = 045 new PredictionContextCache(); 046 public static final int 047 T__0=1, T__1=2, T__2=3, T__3=4, STATIC=5, ROLES=6, TRIGGER=7, BEFORE=8, 048 AFTER=9, AS=10, NO=11, COMPRESSION=12, BEST=13, SPEED=14, DECLARE=15, 049 PROCEDURE=16, TYPE=17, JAVA=18, JS=19, EXEC=20, URL=21, OPTIONS=22, FILE=23, 050 STATEMENT=24, CONNECT=25, TO=26, USER=27, PASSWORD=28, PROPERTIES=29, 051 DRIVER=30, LIB=31, CONNECTION=32, POOL=33, SIZE=34, MIN=35, MAX=36, UNDECLARED=37, 052 STATEMENTS=38, INCOMING=39, CONNECTIONS=40, ALLOW=41, REJECT=42, IF=43, 053 EXISTS=44, SWITCH=45, SCHEDULE=46, AT=47, INCLUDE=48, NULL=49, IDENTIFIER=50, 054 NUMERIC_LITERAL=51, STRING_LITERAL=52, SINGLE_LINE_COMMENT=53, MULTILINE_COMMENT=54, 055 SPACES=55, UNEXPECTED_CHAR=56; 056 public static final int 057 RULE_native_sql = 0, RULE_parameter = 1, RULE_procedure = 2, RULE_role_name = 3, 058 RULE_trigger_before_procedure_name = 4, RULE_trigger_after_procedure_name = 5, 059 RULE_compression_level = 6, RULE_connection_alias = 7, RULE_statement_alias = 8, 060 RULE_procedure_name = 9, RULE_json = 10, RULE_jdbc_url = 11, RULE_user = 12, 061 RULE_password = 13, RULE_jdbc_connection_properties = 14, RULE_jdbc_driver_class_name = 15, 062 RULE_jar_file = 16, RULE_connection_pool_size_min = 17, RULE_connection_pool_size_max = 18, 063 RULE_sql_script_file = 19, RULE_json_file = 20, RULE_cron_expression = 21, 064 RULE_connect_to_stmt = 22, RULE_switch_to_stmt = 23, RULE_declare_statement_stmt = 24, 065 RULE_declare_procedure_stmt = 25, RULE_include_script_file_stmt = 26, 066 RULE_schedule_stmt = 27, RULE_native_stmt = 28; 067 private static String[] makeRuleNames() { 068 return new String[] { 069 "native_sql", "parameter", "procedure", "role_name", "trigger_before_procedure_name", 070 "trigger_after_procedure_name", "compression_level", "connection_alias", 071 "statement_alias", "procedure_name", "json", "jdbc_url", "user", "password", 072 "jdbc_connection_properties", "jdbc_driver_class_name", "jar_file", "connection_pool_size_min", 073 "connection_pool_size_max", "sql_script_file", "json_file", "cron_expression", 074 "connect_to_stmt", "switch_to_stmt", "declare_statement_stmt", "declare_procedure_stmt", 075 "include_script_file_stmt", "schedule_stmt", "native_stmt" 076 }; 077 } 078 public static final String[] ruleNames = makeRuleNames(); 079 080 private static String[] makeLiteralNames() { 081 return new String[] { 082 null, "':'", "'('", "','", "')'" 083 }; 084 } 085 private static final String[] _LITERAL_NAMES = makeLiteralNames(); 086 private static String[] makeSymbolicNames() { 087 return new String[] { 088 null, null, null, null, null, "STATIC", "ROLES", "TRIGGER", "BEFORE", 089 "AFTER", "AS", "NO", "COMPRESSION", "BEST", "SPEED", "DECLARE", "PROCEDURE", 090 "TYPE", "JAVA", "JS", "EXEC", "URL", "OPTIONS", "FILE", "STATEMENT", 091 "CONNECT", "TO", "USER", "PASSWORD", "PROPERTIES", "DRIVER", "LIB", "CONNECTION", 092 "POOL", "SIZE", "MIN", "MAX", "UNDECLARED", "STATEMENTS", "INCOMING", 093 "CONNECTIONS", "ALLOW", "REJECT", "IF", "EXISTS", "SWITCH", "SCHEDULE", 094 "AT", "INCLUDE", "NULL", "IDENTIFIER", "NUMERIC_LITERAL", "STRING_LITERAL", 095 "SINGLE_LINE_COMMENT", "MULTILINE_COMMENT", "SPACES", "UNEXPECTED_CHAR" 096 }; 097 } 098 private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); 099 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 100 101 /** 102 * @deprecated Use {@link #VOCABULARY} instead. 103 */ 104 @Deprecated 105 public static final String[] tokenNames; 106 static { 107 tokenNames = new String[_SYMBOLIC_NAMES.length]; 108 for (int i = 0; i < tokenNames.length; i++) { 109 tokenNames[i] = VOCABULARY.getLiteralName(i); 110 if (tokenNames[i] == null) { 111 tokenNames[i] = VOCABULARY.getSymbolicName(i); 112 } 113 114 if (tokenNames[i] == null) { 115 tokenNames[i] = "<INVALID>"; 116 } 117 } 118 } 119 120 @Override 121 @Deprecated 122 public String[] getTokenNames() { 123 return tokenNames; 124 } 125 126 @Override 127 128 public Vocabulary getVocabulary() { 129 return VOCABULARY; 130 } 131 132 @Override 133 public String getGrammarFileName() { return "Fbsql.g4"; } 134 135 @Override 136 public String[] getRuleNames() { return ruleNames; } 137 138 @Override 139 public String getSerializedATN() { return _serializedATN; } 140 141 @Override 142 public ATN getATN() { return _ATN; } 143 144 public FbsqlParser(TokenStream input) { 145 super(input); 146 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 147 } 148 149 public static class Native_sqlContext extends ParserRuleContext { 150 public Native_sqlContext(ParserRuleContext parent, int invokingState) { 151 super(parent, invokingState); 152 } 153 @Override public int getRuleIndex() { return RULE_native_sql; } 154 @Override 155 public void enterRule(ParseTreeListener listener) { 156 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterNative_sql(this); 157 } 158 @Override 159 public void exitRule(ParseTreeListener listener) { 160 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitNative_sql(this); 161 } 162 @Override 163 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 164 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitNative_sql(this); 165 else return visitor.visitChildren(this); 166 } 167 } 168 169 public final Native_sqlContext native_sql() throws RecognitionException { 170 Native_sqlContext _localctx = new Native_sqlContext(_ctx, getState()); 171 enterRule(_localctx, 0, RULE_native_sql); 172 try { 173 int _alt; 174 enterOuterAlt(_localctx, 1); 175 { 176 setState(61); 177 _errHandler.sync(this); 178 _alt = getInterpreter().adaptivePredict(_input,0,_ctx); 179 while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 180 if ( _alt==1+1 ) { 181 { 182 { 183 setState(58); 184 matchWildcard(); 185 } 186 } 187 } 188 setState(63); 189 _errHandler.sync(this); 190 _alt = getInterpreter().adaptivePredict(_input,0,_ctx); 191 } 192 } 193 } 194 catch (RecognitionException re) { 195 _localctx.exception = re; 196 _errHandler.reportError(this, re); 197 _errHandler.recover(this, re); 198 } 199 finally { 200 exitRule(); 201 } 202 return _localctx; 203 } 204 205 public static class ParameterContext extends ParserRuleContext { 206 public TerminalNode IDENTIFIER() { return getToken(FbsqlParser.IDENTIFIER, 0); } 207 public TerminalNode NUMERIC_LITERAL() { return getToken(FbsqlParser.NUMERIC_LITERAL, 0); } 208 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 209 public TerminalNode NULL() { return getToken(FbsqlParser.NULL, 0); } 210 public ProcedureContext procedure() { 211 return getRuleContext(ProcedureContext.class,0); 212 } 213 public ParameterContext(ParserRuleContext parent, int invokingState) { 214 super(parent, invokingState); 215 } 216 @Override public int getRuleIndex() { return RULE_parameter; } 217 @Override 218 public void enterRule(ParseTreeListener listener) { 219 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterParameter(this); 220 } 221 @Override 222 public void exitRule(ParseTreeListener listener) { 223 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitParameter(this); 224 } 225 @Override 226 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 227 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitParameter(this); 228 else return visitor.visitChildren(this); 229 } 230 } 231 232 public final ParameterContext parameter() throws RecognitionException { 233 ParameterContext _localctx = new ParameterContext(_ctx, getState()); 234 enterRule(_localctx, 2, RULE_parameter); 235 try { 236 setState(70); 237 _errHandler.sync(this); 238 switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) { 239 case 1: 240 enterOuterAlt(_localctx, 1); 241 { 242 setState(64); 243 match(T__0); 244 setState(65); 245 match(IDENTIFIER); 246 } 247 break; 248 case 2: 249 enterOuterAlt(_localctx, 2); 250 { 251 setState(66); 252 match(NUMERIC_LITERAL); 253 } 254 break; 255 case 3: 256 enterOuterAlt(_localctx, 3); 257 { 258 setState(67); 259 match(STRING_LITERAL); 260 } 261 break; 262 case 4: 263 enterOuterAlt(_localctx, 4); 264 { 265 setState(68); 266 match(NULL); 267 } 268 break; 269 case 5: 270 enterOuterAlt(_localctx, 5); 271 { 272 setState(69); 273 procedure(); 274 } 275 break; 276 } 277 } 278 catch (RecognitionException re) { 279 _localctx.exception = re; 280 _errHandler.reportError(this, re); 281 _errHandler.recover(this, re); 282 } 283 finally { 284 exitRule(); 285 } 286 return _localctx; 287 } 288 289 public static class ProcedureContext extends ParserRuleContext { 290 public Procedure_nameContext procedure_name() { 291 return getRuleContext(Procedure_nameContext.class,0); 292 } 293 public List<ParameterContext> parameter() { 294 return getRuleContexts(ParameterContext.class); 295 } 296 public ParameterContext parameter(int i) { 297 return getRuleContext(ParameterContext.class,i); 298 } 299 public ProcedureContext(ParserRuleContext parent, int invokingState) { 300 super(parent, invokingState); 301 } 302 @Override public int getRuleIndex() { return RULE_procedure; } 303 @Override 304 public void enterRule(ParseTreeListener listener) { 305 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterProcedure(this); 306 } 307 @Override 308 public void exitRule(ParseTreeListener listener) { 309 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitProcedure(this); 310 } 311 @Override 312 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 313 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitProcedure(this); 314 else return visitor.visitChildren(this); 315 } 316 } 317 318 public final ProcedureContext procedure() throws RecognitionException { 319 ProcedureContext _localctx = new ProcedureContext(_ctx, getState()); 320 enterRule(_localctx, 4, RULE_procedure); 321 int _la; 322 try { 323 enterOuterAlt(_localctx, 1); 324 { 325 setState(72); 326 procedure_name(); 327 setState(73); 328 match(T__1); 329 setState(75); 330 _errHandler.sync(this); 331 _la = _input.LA(1); 332 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << NULL) | (1L << IDENTIFIER) | (1L << NUMERIC_LITERAL) | (1L << STRING_LITERAL))) != 0)) { 333 { 334 setState(74); 335 parameter(); 336 } 337 } 338 339 setState(81); 340 _errHandler.sync(this); 341 _la = _input.LA(1); 342 while (_la==T__2) { 343 { 344 { 345 setState(77); 346 match(T__2); 347 setState(78); 348 parameter(); 349 } 350 } 351 setState(83); 352 _errHandler.sync(this); 353 _la = _input.LA(1); 354 } 355 setState(84); 356 match(T__3); 357 } 358 } 359 catch (RecognitionException re) { 360 _localctx.exception = re; 361 _errHandler.reportError(this, re); 362 _errHandler.recover(this, re); 363 } 364 finally { 365 exitRule(); 366 } 367 return _localctx; 368 } 369 370 public static class Role_nameContext extends ParserRuleContext { 371 public TerminalNode IDENTIFIER() { return getToken(FbsqlParser.IDENTIFIER, 0); } 372 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 373 public Role_nameContext(ParserRuleContext parent, int invokingState) { 374 super(parent, invokingState); 375 } 376 @Override public int getRuleIndex() { return RULE_role_name; } 377 @Override 378 public void enterRule(ParseTreeListener listener) { 379 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterRole_name(this); 380 } 381 @Override 382 public void exitRule(ParseTreeListener listener) { 383 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitRole_name(this); 384 } 385 @Override 386 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 387 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitRole_name(this); 388 else return visitor.visitChildren(this); 389 } 390 } 391 392 public final Role_nameContext role_name() throws RecognitionException { 393 Role_nameContext _localctx = new Role_nameContext(_ctx, getState()); 394 enterRule(_localctx, 6, RULE_role_name); 395 int _la; 396 try { 397 enterOuterAlt(_localctx, 1); 398 { 399 setState(86); 400 _la = _input.LA(1); 401 if ( !(_la==IDENTIFIER || _la==STRING_LITERAL) ) { 402 _errHandler.recoverInline(this); 403 } 404 else { 405 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 406 _errHandler.reportMatch(this); 407 consume(); 408 } 409 } 410 } 411 catch (RecognitionException re) { 412 _localctx.exception = re; 413 _errHandler.reportError(this, re); 414 _errHandler.recover(this, re); 415 } 416 finally { 417 exitRule(); 418 } 419 return _localctx; 420 } 421 422 public static class Trigger_before_procedure_nameContext extends ParserRuleContext { 423 public TerminalNode IDENTIFIER() { return getToken(FbsqlParser.IDENTIFIER, 0); } 424 public Trigger_before_procedure_nameContext(ParserRuleContext parent, int invokingState) { 425 super(parent, invokingState); 426 } 427 @Override public int getRuleIndex() { return RULE_trigger_before_procedure_name; } 428 @Override 429 public void enterRule(ParseTreeListener listener) { 430 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterTrigger_before_procedure_name(this); 431 } 432 @Override 433 public void exitRule(ParseTreeListener listener) { 434 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitTrigger_before_procedure_name(this); 435 } 436 @Override 437 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 438 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitTrigger_before_procedure_name(this); 439 else return visitor.visitChildren(this); 440 } 441 } 442 443 public final Trigger_before_procedure_nameContext trigger_before_procedure_name() throws RecognitionException { 444 Trigger_before_procedure_nameContext _localctx = new Trigger_before_procedure_nameContext(_ctx, getState()); 445 enterRule(_localctx, 8, RULE_trigger_before_procedure_name); 446 try { 447 enterOuterAlt(_localctx, 1); 448 { 449 setState(88); 450 match(IDENTIFIER); 451 } 452 } 453 catch (RecognitionException re) { 454 _localctx.exception = re; 455 _errHandler.reportError(this, re); 456 _errHandler.recover(this, re); 457 } 458 finally { 459 exitRule(); 460 } 461 return _localctx; 462 } 463 464 public static class Trigger_after_procedure_nameContext extends ParserRuleContext { 465 public TerminalNode IDENTIFIER() { return getToken(FbsqlParser.IDENTIFIER, 0); } 466 public Trigger_after_procedure_nameContext(ParserRuleContext parent, int invokingState) { 467 super(parent, invokingState); 468 } 469 @Override public int getRuleIndex() { return RULE_trigger_after_procedure_name; } 470 @Override 471 public void enterRule(ParseTreeListener listener) { 472 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterTrigger_after_procedure_name(this); 473 } 474 @Override 475 public void exitRule(ParseTreeListener listener) { 476 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitTrigger_after_procedure_name(this); 477 } 478 @Override 479 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 480 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitTrigger_after_procedure_name(this); 481 else return visitor.visitChildren(this); 482 } 483 } 484 485 public final Trigger_after_procedure_nameContext trigger_after_procedure_name() throws RecognitionException { 486 Trigger_after_procedure_nameContext _localctx = new Trigger_after_procedure_nameContext(_ctx, getState()); 487 enterRule(_localctx, 10, RULE_trigger_after_procedure_name); 488 try { 489 enterOuterAlt(_localctx, 1); 490 { 491 setState(90); 492 match(IDENTIFIER); 493 } 494 } 495 catch (RecognitionException re) { 496 _localctx.exception = re; 497 _errHandler.reportError(this, re); 498 _errHandler.recover(this, re); 499 } 500 finally { 501 exitRule(); 502 } 503 return _localctx; 504 } 505 506 public static class Compression_levelContext extends ParserRuleContext { 507 public TerminalNode NO() { return getToken(FbsqlParser.NO, 0); } 508 public TerminalNode COMPRESSION() { return getToken(FbsqlParser.COMPRESSION, 0); } 509 public TerminalNode BEST() { return getToken(FbsqlParser.BEST, 0); } 510 public TerminalNode SPEED() { return getToken(FbsqlParser.SPEED, 0); } 511 public Compression_levelContext(ParserRuleContext parent, int invokingState) { 512 super(parent, invokingState); 513 } 514 @Override public int getRuleIndex() { return RULE_compression_level; } 515 @Override 516 public void enterRule(ParseTreeListener listener) { 517 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterCompression_level(this); 518 } 519 @Override 520 public void exitRule(ParseTreeListener listener) { 521 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitCompression_level(this); 522 } 523 @Override 524 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 525 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitCompression_level(this); 526 else return visitor.visitChildren(this); 527 } 528 } 529 530 public final Compression_levelContext compression_level() throws RecognitionException { 531 Compression_levelContext _localctx = new Compression_levelContext(_ctx, getState()); 532 enterRule(_localctx, 12, RULE_compression_level); 533 try { 534 setState(98); 535 _errHandler.sync(this); 536 switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { 537 case 1: 538 enterOuterAlt(_localctx, 1); 539 { 540 setState(92); 541 match(NO); 542 setState(93); 543 match(COMPRESSION); 544 } 545 break; 546 case 2: 547 enterOuterAlt(_localctx, 2); 548 { 549 setState(94); 550 match(BEST); 551 setState(95); 552 match(COMPRESSION); 553 } 554 break; 555 case 3: 556 enterOuterAlt(_localctx, 3); 557 { 558 setState(96); 559 match(BEST); 560 setState(97); 561 match(SPEED); 562 } 563 break; 564 } 565 } 566 catch (RecognitionException re) { 567 _localctx.exception = re; 568 _errHandler.reportError(this, re); 569 _errHandler.recover(this, re); 570 } 571 finally { 572 exitRule(); 573 } 574 return _localctx; 575 } 576 577 public static class Connection_aliasContext extends ParserRuleContext { 578 public TerminalNode IDENTIFIER() { return getToken(FbsqlParser.IDENTIFIER, 0); } 579 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 580 public Connection_aliasContext(ParserRuleContext parent, int invokingState) { 581 super(parent, invokingState); 582 } 583 @Override public int getRuleIndex() { return RULE_connection_alias; } 584 @Override 585 public void enterRule(ParseTreeListener listener) { 586 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterConnection_alias(this); 587 } 588 @Override 589 public void exitRule(ParseTreeListener listener) { 590 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitConnection_alias(this); 591 } 592 @Override 593 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 594 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitConnection_alias(this); 595 else return visitor.visitChildren(this); 596 } 597 } 598 599 public final Connection_aliasContext connection_alias() throws RecognitionException { 600 Connection_aliasContext _localctx = new Connection_aliasContext(_ctx, getState()); 601 enterRule(_localctx, 14, RULE_connection_alias); 602 int _la; 603 try { 604 enterOuterAlt(_localctx, 1); 605 { 606 setState(100); 607 _la = _input.LA(1); 608 if ( !(_la==IDENTIFIER || _la==STRING_LITERAL) ) { 609 _errHandler.recoverInline(this); 610 } 611 else { 612 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 613 _errHandler.reportMatch(this); 614 consume(); 615 } 616 } 617 } 618 catch (RecognitionException re) { 619 _localctx.exception = re; 620 _errHandler.reportError(this, re); 621 _errHandler.recover(this, re); 622 } 623 finally { 624 exitRule(); 625 } 626 return _localctx; 627 } 628 629 public static class Statement_aliasContext extends ParserRuleContext { 630 public TerminalNode IDENTIFIER() { return getToken(FbsqlParser.IDENTIFIER, 0); } 631 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 632 public Statement_aliasContext(ParserRuleContext parent, int invokingState) { 633 super(parent, invokingState); 634 } 635 @Override public int getRuleIndex() { return RULE_statement_alias; } 636 @Override 637 public void enterRule(ParseTreeListener listener) { 638 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterStatement_alias(this); 639 } 640 @Override 641 public void exitRule(ParseTreeListener listener) { 642 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitStatement_alias(this); 643 } 644 @Override 645 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 646 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitStatement_alias(this); 647 else return visitor.visitChildren(this); 648 } 649 } 650 651 public final Statement_aliasContext statement_alias() throws RecognitionException { 652 Statement_aliasContext _localctx = new Statement_aliasContext(_ctx, getState()); 653 enterRule(_localctx, 16, RULE_statement_alias); 654 int _la; 655 try { 656 enterOuterAlt(_localctx, 1); 657 { 658 setState(102); 659 _la = _input.LA(1); 660 if ( !(_la==IDENTIFIER || _la==STRING_LITERAL) ) { 661 _errHandler.recoverInline(this); 662 } 663 else { 664 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 665 _errHandler.reportMatch(this); 666 consume(); 667 } 668 } 669 } 670 catch (RecognitionException re) { 671 _localctx.exception = re; 672 _errHandler.reportError(this, re); 673 _errHandler.recover(this, re); 674 } 675 finally { 676 exitRule(); 677 } 678 return _localctx; 679 } 680 681 public static class Procedure_nameContext extends ParserRuleContext { 682 public TerminalNode IDENTIFIER() { return getToken(FbsqlParser.IDENTIFIER, 0); } 683 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 684 public Procedure_nameContext(ParserRuleContext parent, int invokingState) { 685 super(parent, invokingState); 686 } 687 @Override public int getRuleIndex() { return RULE_procedure_name; } 688 @Override 689 public void enterRule(ParseTreeListener listener) { 690 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterProcedure_name(this); 691 } 692 @Override 693 public void exitRule(ParseTreeListener listener) { 694 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitProcedure_name(this); 695 } 696 @Override 697 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 698 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitProcedure_name(this); 699 else return visitor.visitChildren(this); 700 } 701 } 702 703 public final Procedure_nameContext procedure_name() throws RecognitionException { 704 Procedure_nameContext _localctx = new Procedure_nameContext(_ctx, getState()); 705 enterRule(_localctx, 18, RULE_procedure_name); 706 int _la; 707 try { 708 enterOuterAlt(_localctx, 1); 709 { 710 setState(104); 711 _la = _input.LA(1); 712 if ( !(_la==IDENTIFIER || _la==STRING_LITERAL) ) { 713 _errHandler.recoverInline(this); 714 } 715 else { 716 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 717 _errHandler.reportMatch(this); 718 consume(); 719 } 720 } 721 } 722 catch (RecognitionException re) { 723 _localctx.exception = re; 724 _errHandler.reportError(this, re); 725 _errHandler.recover(this, re); 726 } 727 finally { 728 exitRule(); 729 } 730 return _localctx; 731 } 732 733 public static class JsonContext extends ParserRuleContext { 734 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 735 public JsonContext(ParserRuleContext parent, int invokingState) { 736 super(parent, invokingState); 737 } 738 @Override public int getRuleIndex() { return RULE_json; } 739 @Override 740 public void enterRule(ParseTreeListener listener) { 741 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterJson(this); 742 } 743 @Override 744 public void exitRule(ParseTreeListener listener) { 745 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitJson(this); 746 } 747 @Override 748 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 749 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitJson(this); 750 else return visitor.visitChildren(this); 751 } 752 } 753 754 public final JsonContext json() throws RecognitionException { 755 JsonContext _localctx = new JsonContext(_ctx, getState()); 756 enterRule(_localctx, 20, RULE_json); 757 try { 758 enterOuterAlt(_localctx, 1); 759 { 760 setState(106); 761 match(STRING_LITERAL); 762 } 763 } 764 catch (RecognitionException re) { 765 _localctx.exception = re; 766 _errHandler.reportError(this, re); 767 _errHandler.recover(this, re); 768 } 769 finally { 770 exitRule(); 771 } 772 return _localctx; 773 } 774 775 public static class Jdbc_urlContext extends ParserRuleContext { 776 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 777 public Jdbc_urlContext(ParserRuleContext parent, int invokingState) { 778 super(parent, invokingState); 779 } 780 @Override public int getRuleIndex() { return RULE_jdbc_url; } 781 @Override 782 public void enterRule(ParseTreeListener listener) { 783 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterJdbc_url(this); 784 } 785 @Override 786 public void exitRule(ParseTreeListener listener) { 787 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitJdbc_url(this); 788 } 789 @Override 790 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 791 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitJdbc_url(this); 792 else return visitor.visitChildren(this); 793 } 794 } 795 796 public final Jdbc_urlContext jdbc_url() throws RecognitionException { 797 Jdbc_urlContext _localctx = new Jdbc_urlContext(_ctx, getState()); 798 enterRule(_localctx, 22, RULE_jdbc_url); 799 try { 800 enterOuterAlt(_localctx, 1); 801 { 802 setState(108); 803 match(STRING_LITERAL); 804 } 805 } 806 catch (RecognitionException re) { 807 _localctx.exception = re; 808 _errHandler.reportError(this, re); 809 _errHandler.recover(this, re); 810 } 811 finally { 812 exitRule(); 813 } 814 return _localctx; 815 } 816 817 public static class UserContext extends ParserRuleContext { 818 public TerminalNode IDENTIFIER() { return getToken(FbsqlParser.IDENTIFIER, 0); } 819 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 820 public UserContext(ParserRuleContext parent, int invokingState) { 821 super(parent, invokingState); 822 } 823 @Override public int getRuleIndex() { return RULE_user; } 824 @Override 825 public void enterRule(ParseTreeListener listener) { 826 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterUser(this); 827 } 828 @Override 829 public void exitRule(ParseTreeListener listener) { 830 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitUser(this); 831 } 832 @Override 833 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 834 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitUser(this); 835 else return visitor.visitChildren(this); 836 } 837 } 838 839 public final UserContext user() throws RecognitionException { 840 UserContext _localctx = new UserContext(_ctx, getState()); 841 enterRule(_localctx, 24, RULE_user); 842 int _la; 843 try { 844 enterOuterAlt(_localctx, 1); 845 { 846 setState(110); 847 _la = _input.LA(1); 848 if ( !(_la==IDENTIFIER || _la==STRING_LITERAL) ) { 849 _errHandler.recoverInline(this); 850 } 851 else { 852 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 853 _errHandler.reportMatch(this); 854 consume(); 855 } 856 } 857 } 858 catch (RecognitionException re) { 859 _localctx.exception = re; 860 _errHandler.reportError(this, re); 861 _errHandler.recover(this, re); 862 } 863 finally { 864 exitRule(); 865 } 866 return _localctx; 867 } 868 869 public static class PasswordContext extends ParserRuleContext { 870 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 871 public PasswordContext(ParserRuleContext parent, int invokingState) { 872 super(parent, invokingState); 873 } 874 @Override public int getRuleIndex() { return RULE_password; } 875 @Override 876 public void enterRule(ParseTreeListener listener) { 877 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterPassword(this); 878 } 879 @Override 880 public void exitRule(ParseTreeListener listener) { 881 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitPassword(this); 882 } 883 @Override 884 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 885 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitPassword(this); 886 else return visitor.visitChildren(this); 887 } 888 } 889 890 public final PasswordContext password() throws RecognitionException { 891 PasswordContext _localctx = new PasswordContext(_ctx, getState()); 892 enterRule(_localctx, 26, RULE_password); 893 try { 894 enterOuterAlt(_localctx, 1); 895 { 896 setState(112); 897 match(STRING_LITERAL); 898 } 899 } 900 catch (RecognitionException re) { 901 _localctx.exception = re; 902 _errHandler.reportError(this, re); 903 _errHandler.recover(this, re); 904 } 905 finally { 906 exitRule(); 907 } 908 return _localctx; 909 } 910 911 public static class Jdbc_connection_propertiesContext extends ParserRuleContext { 912 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 913 public Jdbc_connection_propertiesContext(ParserRuleContext parent, int invokingState) { 914 super(parent, invokingState); 915 } 916 @Override public int getRuleIndex() { return RULE_jdbc_connection_properties; } 917 @Override 918 public void enterRule(ParseTreeListener listener) { 919 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterJdbc_connection_properties(this); 920 } 921 @Override 922 public void exitRule(ParseTreeListener listener) { 923 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitJdbc_connection_properties(this); 924 } 925 @Override 926 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 927 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitJdbc_connection_properties(this); 928 else return visitor.visitChildren(this); 929 } 930 } 931 932 public final Jdbc_connection_propertiesContext jdbc_connection_properties() throws RecognitionException { 933 Jdbc_connection_propertiesContext _localctx = new Jdbc_connection_propertiesContext(_ctx, getState()); 934 enterRule(_localctx, 28, RULE_jdbc_connection_properties); 935 try { 936 enterOuterAlt(_localctx, 1); 937 { 938 setState(114); 939 match(STRING_LITERAL); 940 } 941 } 942 catch (RecognitionException re) { 943 _localctx.exception = re; 944 _errHandler.reportError(this, re); 945 _errHandler.recover(this, re); 946 } 947 finally { 948 exitRule(); 949 } 950 return _localctx; 951 } 952 953 public static class Jdbc_driver_class_nameContext extends ParserRuleContext { 954 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 955 public Jdbc_driver_class_nameContext(ParserRuleContext parent, int invokingState) { 956 super(parent, invokingState); 957 } 958 @Override public int getRuleIndex() { return RULE_jdbc_driver_class_name; } 959 @Override 960 public void enterRule(ParseTreeListener listener) { 961 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterJdbc_driver_class_name(this); 962 } 963 @Override 964 public void exitRule(ParseTreeListener listener) { 965 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitJdbc_driver_class_name(this); 966 } 967 @Override 968 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 969 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitJdbc_driver_class_name(this); 970 else return visitor.visitChildren(this); 971 } 972 } 973 974 public final Jdbc_driver_class_nameContext jdbc_driver_class_name() throws RecognitionException { 975 Jdbc_driver_class_nameContext _localctx = new Jdbc_driver_class_nameContext(_ctx, getState()); 976 enterRule(_localctx, 30, RULE_jdbc_driver_class_name); 977 try { 978 enterOuterAlt(_localctx, 1); 979 { 980 setState(116); 981 match(STRING_LITERAL); 982 } 983 } 984 catch (RecognitionException re) { 985 _localctx.exception = re; 986 _errHandler.reportError(this, re); 987 _errHandler.recover(this, re); 988 } 989 finally { 990 exitRule(); 991 } 992 return _localctx; 993 } 994 995 public static class Jar_fileContext extends ParserRuleContext { 996 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 997 public Jar_fileContext(ParserRuleContext parent, int invokingState) { 998 super(parent, invokingState); 999 } 1000 @Override public int getRuleIndex() { return RULE_jar_file; } 1001 @Override 1002 public void enterRule(ParseTreeListener listener) { 1003 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterJar_file(this); 1004 } 1005 @Override 1006 public void exitRule(ParseTreeListener listener) { 1007 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitJar_file(this); 1008 } 1009 @Override 1010 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1011 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitJar_file(this); 1012 else return visitor.visitChildren(this); 1013 } 1014 } 1015 1016 public final Jar_fileContext jar_file() throws RecognitionException { 1017 Jar_fileContext _localctx = new Jar_fileContext(_ctx, getState()); 1018 enterRule(_localctx, 32, RULE_jar_file); 1019 try { 1020 enterOuterAlt(_localctx, 1); 1021 { 1022 setState(118); 1023 match(STRING_LITERAL); 1024 } 1025 } 1026 catch (RecognitionException re) { 1027 _localctx.exception = re; 1028 _errHandler.reportError(this, re); 1029 _errHandler.recover(this, re); 1030 } 1031 finally { 1032 exitRule(); 1033 } 1034 return _localctx; 1035 } 1036 1037 public static class Connection_pool_size_minContext extends ParserRuleContext { 1038 public TerminalNode NUMERIC_LITERAL() { return getToken(FbsqlParser.NUMERIC_LITERAL, 0); } 1039 public Connection_pool_size_minContext(ParserRuleContext parent, int invokingState) { 1040 super(parent, invokingState); 1041 } 1042 @Override public int getRuleIndex() { return RULE_connection_pool_size_min; } 1043 @Override 1044 public void enterRule(ParseTreeListener listener) { 1045 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterConnection_pool_size_min(this); 1046 } 1047 @Override 1048 public void exitRule(ParseTreeListener listener) { 1049 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitConnection_pool_size_min(this); 1050 } 1051 @Override 1052 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1053 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitConnection_pool_size_min(this); 1054 else return visitor.visitChildren(this); 1055 } 1056 } 1057 1058 public final Connection_pool_size_minContext connection_pool_size_min() throws RecognitionException { 1059 Connection_pool_size_minContext _localctx = new Connection_pool_size_minContext(_ctx, getState()); 1060 enterRule(_localctx, 34, RULE_connection_pool_size_min); 1061 try { 1062 enterOuterAlt(_localctx, 1); 1063 { 1064 setState(120); 1065 match(NUMERIC_LITERAL); 1066 } 1067 } 1068 catch (RecognitionException re) { 1069 _localctx.exception = re; 1070 _errHandler.reportError(this, re); 1071 _errHandler.recover(this, re); 1072 } 1073 finally { 1074 exitRule(); 1075 } 1076 return _localctx; 1077 } 1078 1079 public static class Connection_pool_size_maxContext extends ParserRuleContext { 1080 public TerminalNode NUMERIC_LITERAL() { return getToken(FbsqlParser.NUMERIC_LITERAL, 0); } 1081 public Connection_pool_size_maxContext(ParserRuleContext parent, int invokingState) { 1082 super(parent, invokingState); 1083 } 1084 @Override public int getRuleIndex() { return RULE_connection_pool_size_max; } 1085 @Override 1086 public void enterRule(ParseTreeListener listener) { 1087 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterConnection_pool_size_max(this); 1088 } 1089 @Override 1090 public void exitRule(ParseTreeListener listener) { 1091 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitConnection_pool_size_max(this); 1092 } 1093 @Override 1094 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1095 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitConnection_pool_size_max(this); 1096 else return visitor.visitChildren(this); 1097 } 1098 } 1099 1100 public final Connection_pool_size_maxContext connection_pool_size_max() throws RecognitionException { 1101 Connection_pool_size_maxContext _localctx = new Connection_pool_size_maxContext(_ctx, getState()); 1102 enterRule(_localctx, 36, RULE_connection_pool_size_max); 1103 try { 1104 enterOuterAlt(_localctx, 1); 1105 { 1106 setState(122); 1107 match(NUMERIC_LITERAL); 1108 } 1109 } 1110 catch (RecognitionException re) { 1111 _localctx.exception = re; 1112 _errHandler.reportError(this, re); 1113 _errHandler.recover(this, re); 1114 } 1115 finally { 1116 exitRule(); 1117 } 1118 return _localctx; 1119 } 1120 1121 public static class Sql_script_fileContext extends ParserRuleContext { 1122 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 1123 public Sql_script_fileContext(ParserRuleContext parent, int invokingState) { 1124 super(parent, invokingState); 1125 } 1126 @Override public int getRuleIndex() { return RULE_sql_script_file; } 1127 @Override 1128 public void enterRule(ParseTreeListener listener) { 1129 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterSql_script_file(this); 1130 } 1131 @Override 1132 public void exitRule(ParseTreeListener listener) { 1133 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitSql_script_file(this); 1134 } 1135 @Override 1136 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1137 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitSql_script_file(this); 1138 else return visitor.visitChildren(this); 1139 } 1140 } 1141 1142 public final Sql_script_fileContext sql_script_file() throws RecognitionException { 1143 Sql_script_fileContext _localctx = new Sql_script_fileContext(_ctx, getState()); 1144 enterRule(_localctx, 38, RULE_sql_script_file); 1145 try { 1146 enterOuterAlt(_localctx, 1); 1147 { 1148 setState(124); 1149 match(STRING_LITERAL); 1150 } 1151 } 1152 catch (RecognitionException re) { 1153 _localctx.exception = re; 1154 _errHandler.reportError(this, re); 1155 _errHandler.recover(this, re); 1156 } 1157 finally { 1158 exitRule(); 1159 } 1160 return _localctx; 1161 } 1162 1163 public static class Json_fileContext extends ParserRuleContext { 1164 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 1165 public Json_fileContext(ParserRuleContext parent, int invokingState) { 1166 super(parent, invokingState); 1167 } 1168 @Override public int getRuleIndex() { return RULE_json_file; } 1169 @Override 1170 public void enterRule(ParseTreeListener listener) { 1171 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterJson_file(this); 1172 } 1173 @Override 1174 public void exitRule(ParseTreeListener listener) { 1175 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitJson_file(this); 1176 } 1177 @Override 1178 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1179 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitJson_file(this); 1180 else return visitor.visitChildren(this); 1181 } 1182 } 1183 1184 public final Json_fileContext json_file() throws RecognitionException { 1185 Json_fileContext _localctx = new Json_fileContext(_ctx, getState()); 1186 enterRule(_localctx, 40, RULE_json_file); 1187 try { 1188 enterOuterAlt(_localctx, 1); 1189 { 1190 setState(126); 1191 match(STRING_LITERAL); 1192 } 1193 } 1194 catch (RecognitionException re) { 1195 _localctx.exception = re; 1196 _errHandler.reportError(this, re); 1197 _errHandler.recover(this, re); 1198 } 1199 finally { 1200 exitRule(); 1201 } 1202 return _localctx; 1203 } 1204 1205 public static class Cron_expressionContext extends ParserRuleContext { 1206 public TerminalNode STRING_LITERAL() { return getToken(FbsqlParser.STRING_LITERAL, 0); } 1207 public Cron_expressionContext(ParserRuleContext parent, int invokingState) { 1208 super(parent, invokingState); 1209 } 1210 @Override public int getRuleIndex() { return RULE_cron_expression; } 1211 @Override 1212 public void enterRule(ParseTreeListener listener) { 1213 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterCron_expression(this); 1214 } 1215 @Override 1216 public void exitRule(ParseTreeListener listener) { 1217 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitCron_expression(this); 1218 } 1219 @Override 1220 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1221 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitCron_expression(this); 1222 else return visitor.visitChildren(this); 1223 } 1224 } 1225 1226 public final Cron_expressionContext cron_expression() throws RecognitionException { 1227 Cron_expressionContext _localctx = new Cron_expressionContext(_ctx, getState()); 1228 enterRule(_localctx, 42, RULE_cron_expression); 1229 try { 1230 enterOuterAlt(_localctx, 1); 1231 { 1232 setState(128); 1233 match(STRING_LITERAL); 1234 } 1235 } 1236 catch (RecognitionException re) { 1237 _localctx.exception = re; 1238 _errHandler.reportError(this, re); 1239 _errHandler.recover(this, re); 1240 } 1241 finally { 1242 exitRule(); 1243 } 1244 return _localctx; 1245 } 1246 1247 public static class Connect_to_stmtContext extends ParserRuleContext { 1248 public TerminalNode CONNECT() { return getToken(FbsqlParser.CONNECT, 0); } 1249 public TerminalNode TO() { return getToken(FbsqlParser.TO, 0); } 1250 public Jdbc_urlContext jdbc_url() { 1251 return getRuleContext(Jdbc_urlContext.class,0); 1252 } 1253 public List<TerminalNode> USER() { return getTokens(FbsqlParser.USER); } 1254 public TerminalNode USER(int i) { 1255 return getToken(FbsqlParser.USER, i); 1256 } 1257 public List<UserContext> user() { 1258 return getRuleContexts(UserContext.class); 1259 } 1260 public UserContext user(int i) { 1261 return getRuleContext(UserContext.class,i); 1262 } 1263 public List<TerminalNode> PASSWORD() { return getTokens(FbsqlParser.PASSWORD); } 1264 public TerminalNode PASSWORD(int i) { 1265 return getToken(FbsqlParser.PASSWORD, i); 1266 } 1267 public List<PasswordContext> password() { 1268 return getRuleContexts(PasswordContext.class); 1269 } 1270 public PasswordContext password(int i) { 1271 return getRuleContext(PasswordContext.class,i); 1272 } 1273 public List<TerminalNode> PROPERTIES() { return getTokens(FbsqlParser.PROPERTIES); } 1274 public TerminalNode PROPERTIES(int i) { 1275 return getToken(FbsqlParser.PROPERTIES, i); 1276 } 1277 public List<Jdbc_connection_propertiesContext> jdbc_connection_properties() { 1278 return getRuleContexts(Jdbc_connection_propertiesContext.class); 1279 } 1280 public Jdbc_connection_propertiesContext jdbc_connection_properties(int i) { 1281 return getRuleContext(Jdbc_connection_propertiesContext.class,i); 1282 } 1283 public List<TerminalNode> DRIVER() { return getTokens(FbsqlParser.DRIVER); } 1284 public TerminalNode DRIVER(int i) { 1285 return getToken(FbsqlParser.DRIVER, i); 1286 } 1287 public List<Jdbc_driver_class_nameContext> jdbc_driver_class_name() { 1288 return getRuleContexts(Jdbc_driver_class_nameContext.class); 1289 } 1290 public Jdbc_driver_class_nameContext jdbc_driver_class_name(int i) { 1291 return getRuleContext(Jdbc_driver_class_nameContext.class,i); 1292 } 1293 public List<TerminalNode> LIB() { return getTokens(FbsqlParser.LIB); } 1294 public TerminalNode LIB(int i) { 1295 return getToken(FbsqlParser.LIB, i); 1296 } 1297 public List<Jar_fileContext> jar_file() { 1298 return getRuleContexts(Jar_fileContext.class); 1299 } 1300 public Jar_fileContext jar_file(int i) { 1301 return getRuleContext(Jar_fileContext.class,i); 1302 } 1303 public List<TerminalNode> CONNECTION() { return getTokens(FbsqlParser.CONNECTION); } 1304 public TerminalNode CONNECTION(int i) { 1305 return getToken(FbsqlParser.CONNECTION, i); 1306 } 1307 public List<TerminalNode> POOL() { return getTokens(FbsqlParser.POOL); } 1308 public TerminalNode POOL(int i) { 1309 return getToken(FbsqlParser.POOL, i); 1310 } 1311 public List<TerminalNode> UNDECLARED() { return getTokens(FbsqlParser.UNDECLARED); } 1312 public TerminalNode UNDECLARED(int i) { 1313 return getToken(FbsqlParser.UNDECLARED, i); 1314 } 1315 public List<TerminalNode> STATEMENTS() { return getTokens(FbsqlParser.STATEMENTS); } 1316 public TerminalNode STATEMENTS(int i) { 1317 return getToken(FbsqlParser.STATEMENTS, i); 1318 } 1319 public List<TerminalNode> INCOMING() { return getTokens(FbsqlParser.INCOMING); } 1320 public TerminalNode INCOMING(int i) { 1321 return getToken(FbsqlParser.INCOMING, i); 1322 } 1323 public List<TerminalNode> CONNECTIONS() { return getTokens(FbsqlParser.CONNECTIONS); } 1324 public TerminalNode CONNECTIONS(int i) { 1325 return getToken(FbsqlParser.CONNECTIONS, i); 1326 } 1327 public List<Connection_aliasContext> connection_alias() { 1328 return getRuleContexts(Connection_aliasContext.class); 1329 } 1330 public Connection_aliasContext connection_alias(int i) { 1331 return getRuleContext(Connection_aliasContext.class,i); 1332 } 1333 public List<TerminalNode> IF() { return getTokens(FbsqlParser.IF); } 1334 public TerminalNode IF(int i) { 1335 return getToken(FbsqlParser.IF, i); 1336 } 1337 public List<TerminalNode> EXISTS() { return getTokens(FbsqlParser.EXISTS); } 1338 public TerminalNode EXISTS(int i) { 1339 return getToken(FbsqlParser.EXISTS, i); 1340 } 1341 public List<Native_sqlContext> native_sql() { 1342 return getRuleContexts(Native_sqlContext.class); 1343 } 1344 public Native_sqlContext native_sql(int i) { 1345 return getRuleContext(Native_sqlContext.class,i); 1346 } 1347 public List<TerminalNode> AS() { return getTokens(FbsqlParser.AS); } 1348 public TerminalNode AS(int i) { 1349 return getToken(FbsqlParser.AS, i); 1350 } 1351 public List<TerminalNode> ALLOW() { return getTokens(FbsqlParser.ALLOW); } 1352 public TerminalNode ALLOW(int i) { 1353 return getToken(FbsqlParser.ALLOW, i); 1354 } 1355 public List<TerminalNode> REJECT() { return getTokens(FbsqlParser.REJECT); } 1356 public TerminalNode REJECT(int i) { 1357 return getToken(FbsqlParser.REJECT, i); 1358 } 1359 public List<TerminalNode> MIN() { return getTokens(FbsqlParser.MIN); } 1360 public TerminalNode MIN(int i) { 1361 return getToken(FbsqlParser.MIN, i); 1362 } 1363 public List<Connection_pool_size_minContext> connection_pool_size_min() { 1364 return getRuleContexts(Connection_pool_size_minContext.class); 1365 } 1366 public Connection_pool_size_minContext connection_pool_size_min(int i) { 1367 return getRuleContext(Connection_pool_size_minContext.class,i); 1368 } 1369 public List<TerminalNode> MAX() { return getTokens(FbsqlParser.MAX); } 1370 public TerminalNode MAX(int i) { 1371 return getToken(FbsqlParser.MAX, i); 1372 } 1373 public List<Connection_pool_size_maxContext> connection_pool_size_max() { 1374 return getRuleContexts(Connection_pool_size_maxContext.class); 1375 } 1376 public Connection_pool_size_maxContext connection_pool_size_max(int i) { 1377 return getRuleContext(Connection_pool_size_maxContext.class,i); 1378 } 1379 public Connect_to_stmtContext(ParserRuleContext parent, int invokingState) { 1380 super(parent, invokingState); 1381 } 1382 @Override public int getRuleIndex() { return RULE_connect_to_stmt; } 1383 @Override 1384 public void enterRule(ParseTreeListener listener) { 1385 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterConnect_to_stmt(this); 1386 } 1387 @Override 1388 public void exitRule(ParseTreeListener listener) { 1389 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitConnect_to_stmt(this); 1390 } 1391 @Override 1392 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1393 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitConnect_to_stmt(this); 1394 else return visitor.visitChildren(this); 1395 } 1396 } 1397 1398 public final Connect_to_stmtContext connect_to_stmt() throws RecognitionException { 1399 Connect_to_stmtContext _localctx = new Connect_to_stmtContext(_ctx, getState()); 1400 enterRule(_localctx, 44, RULE_connect_to_stmt); 1401 int _la; 1402 try { 1403 enterOuterAlt(_localctx, 1); 1404 { 1405 setState(130); 1406 match(CONNECT); 1407 setState(131); 1408 match(TO); 1409 setState(132); 1410 jdbc_url(); 1411 setState(188); 1412 _errHandler.sync(this); 1413 _la = _input.LA(1); 1414 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AS) | (1L << USER) | (1L << PASSWORD) | (1L << PROPERTIES) | (1L << DRIVER) | (1L << LIB) | (1L << CONNECTION) | (1L << UNDECLARED) | (1L << INCOMING) | (1L << IDENTIFIER) | (1L << STRING_LITERAL))) != 0)) { 1415 { 1416 setState(186); 1417 _errHandler.sync(this); 1418 switch (_input.LA(1)) { 1419 case USER: 1420 { 1421 { 1422 setState(133); 1423 match(USER); 1424 setState(134); 1425 user(); 1426 } 1427 } 1428 break; 1429 case PASSWORD: 1430 { 1431 { 1432 setState(135); 1433 match(PASSWORD); 1434 setState(136); 1435 password(); 1436 } 1437 } 1438 break; 1439 case PROPERTIES: 1440 { 1441 { 1442 setState(137); 1443 match(PROPERTIES); 1444 setState(138); 1445 jdbc_connection_properties(); 1446 } 1447 } 1448 break; 1449 case DRIVER: 1450 { 1451 { 1452 setState(139); 1453 match(DRIVER); 1454 setState(140); 1455 jdbc_driver_class_name(); 1456 } 1457 } 1458 break; 1459 case LIB: 1460 { 1461 { 1462 setState(141); 1463 match(LIB); 1464 setState(142); 1465 jar_file(); 1466 setState(147); 1467 _errHandler.sync(this); 1468 _la = _input.LA(1); 1469 while (_la==T__2) { 1470 { 1471 { 1472 setState(143); 1473 match(T__2); 1474 setState(144); 1475 jar_file(); 1476 } 1477 } 1478 setState(149); 1479 _errHandler.sync(this); 1480 _la = _input.LA(1); 1481 } 1482 } 1483 } 1484 break; 1485 case CONNECTION: 1486 { 1487 { 1488 setState(150); 1489 match(CONNECTION); 1490 setState(151); 1491 match(POOL); 1492 setState(156); 1493 _errHandler.sync(this); 1494 _la = _input.LA(1); 1495 do { 1496 { 1497 setState(156); 1498 _errHandler.sync(this); 1499 switch (_input.LA(1)) { 1500 case MIN: 1501 { 1502 { 1503 setState(152); 1504 match(MIN); 1505 setState(153); 1506 connection_pool_size_min(); 1507 } 1508 } 1509 break; 1510 case MAX: 1511 { 1512 { 1513 setState(154); 1514 match(MAX); 1515 setState(155); 1516 connection_pool_size_max(); 1517 } 1518 } 1519 break; 1520 default: 1521 throw new NoViableAltException(this); 1522 } 1523 } 1524 setState(158); 1525 _errHandler.sync(this); 1526 _la = _input.LA(1); 1527 } while ( _la==MIN || _la==MAX ); 1528 } 1529 } 1530 break; 1531 case UNDECLARED: 1532 { 1533 { 1534 setState(160); 1535 match(UNDECLARED); 1536 setState(161); 1537 match(STATEMENTS); 1538 setState(163); 1539 _errHandler.sync(this); 1540 _la = _input.LA(1); 1541 do { 1542 { 1543 { 1544 setState(162); 1545 _la = _input.LA(1); 1546 if ( !(_la==ALLOW || _la==REJECT) ) { 1547 _errHandler.recoverInline(this); 1548 } 1549 else { 1550 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1551 _errHandler.reportMatch(this); 1552 consume(); 1553 } 1554 } 1555 } 1556 setState(165); 1557 _errHandler.sync(this); 1558 _la = _input.LA(1); 1559 } while ( _la==ALLOW || _la==REJECT ); 1560 } 1561 } 1562 break; 1563 case INCOMING: 1564 { 1565 { 1566 setState(167); 1567 match(INCOMING); 1568 setState(168); 1569 match(CONNECTIONS); 1570 setState(170); 1571 _errHandler.sync(this); 1572 _la = _input.LA(1); 1573 do { 1574 { 1575 { 1576 setState(169); 1577 _la = _input.LA(1); 1578 if ( !(_la==ALLOW || _la==REJECT) ) { 1579 _errHandler.recoverInline(this); 1580 } 1581 else { 1582 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1583 _errHandler.reportMatch(this); 1584 consume(); 1585 } 1586 } 1587 } 1588 setState(172); 1589 _errHandler.sync(this); 1590 _la = _input.LA(1); 1591 } while ( _la==ALLOW || _la==REJECT ); 1592 setState(180); 1593 _errHandler.sync(this); 1594 _la = _input.LA(1); 1595 if (_la==IF) { 1596 { 1597 setState(174); 1598 match(IF); 1599 setState(175); 1600 match(EXISTS); 1601 setState(176); 1602 match(T__1); 1603 setState(177); 1604 native_sql(); 1605 setState(178); 1606 match(T__3); 1607 } 1608 } 1609 1610 } 1611 } 1612 break; 1613 case AS: 1614 case IDENTIFIER: 1615 case STRING_LITERAL: 1616 { 1617 { 1618 setState(183); 1619 _errHandler.sync(this); 1620 _la = _input.LA(1); 1621 if (_la==AS) { 1622 { 1623 setState(182); 1624 match(AS); 1625 } 1626 } 1627 1628 setState(185); 1629 connection_alias(); 1630 } 1631 } 1632 break; 1633 default: 1634 throw new NoViableAltException(this); 1635 } 1636 } 1637 setState(190); 1638 _errHandler.sync(this); 1639 _la = _input.LA(1); 1640 } 1641 } 1642 } 1643 catch (RecognitionException re) { 1644 _localctx.exception = re; 1645 _errHandler.reportError(this, re); 1646 _errHandler.recover(this, re); 1647 } 1648 finally { 1649 exitRule(); 1650 } 1651 return _localctx; 1652 } 1653 1654 public static class Switch_to_stmtContext extends ParserRuleContext { 1655 public TerminalNode SWITCH() { return getToken(FbsqlParser.SWITCH, 0); } 1656 public TerminalNode TO() { return getToken(FbsqlParser.TO, 0); } 1657 public Connection_aliasContext connection_alias() { 1658 return getRuleContext(Connection_aliasContext.class,0); 1659 } 1660 public Switch_to_stmtContext(ParserRuleContext parent, int invokingState) { 1661 super(parent, invokingState); 1662 } 1663 @Override public int getRuleIndex() { return RULE_switch_to_stmt; } 1664 @Override 1665 public void enterRule(ParseTreeListener listener) { 1666 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterSwitch_to_stmt(this); 1667 } 1668 @Override 1669 public void exitRule(ParseTreeListener listener) { 1670 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitSwitch_to_stmt(this); 1671 } 1672 @Override 1673 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1674 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitSwitch_to_stmt(this); 1675 else return visitor.visitChildren(this); 1676 } 1677 } 1678 1679 public final Switch_to_stmtContext switch_to_stmt() throws RecognitionException { 1680 Switch_to_stmtContext _localctx = new Switch_to_stmtContext(_ctx, getState()); 1681 enterRule(_localctx, 46, RULE_switch_to_stmt); 1682 try { 1683 enterOuterAlt(_localctx, 1); 1684 { 1685 setState(191); 1686 match(SWITCH); 1687 setState(192); 1688 match(TO); 1689 setState(193); 1690 connection_alias(); 1691 } 1692 } 1693 catch (RecognitionException re) { 1694 _localctx.exception = re; 1695 _errHandler.reportError(this, re); 1696 _errHandler.recover(this, re); 1697 } 1698 finally { 1699 exitRule(); 1700 } 1701 return _localctx; 1702 } 1703 1704 public static class Declare_statement_stmtContext extends ParserRuleContext { 1705 public TerminalNode DECLARE() { return getToken(FbsqlParser.DECLARE, 0); } 1706 public TerminalNode STATEMENT() { return getToken(FbsqlParser.STATEMENT, 0); } 1707 public Native_sqlContext native_sql() { 1708 return getRuleContext(Native_sqlContext.class,0); 1709 } 1710 public List<TerminalNode> STATIC() { return getTokens(FbsqlParser.STATIC); } 1711 public TerminalNode STATIC(int i) { 1712 return getToken(FbsqlParser.STATIC, i); 1713 } 1714 public List<TerminalNode> COMPRESSION() { return getTokens(FbsqlParser.COMPRESSION); } 1715 public TerminalNode COMPRESSION(int i) { 1716 return getToken(FbsqlParser.COMPRESSION, i); 1717 } 1718 public List<Compression_levelContext> compression_level() { 1719 return getRuleContexts(Compression_levelContext.class); 1720 } 1721 public Compression_levelContext compression_level(int i) { 1722 return getRuleContext(Compression_levelContext.class,i); 1723 } 1724 public List<TerminalNode> ROLES() { return getTokens(FbsqlParser.ROLES); } 1725 public TerminalNode ROLES(int i) { 1726 return getToken(FbsqlParser.ROLES, i); 1727 } 1728 public List<Role_nameContext> role_name() { 1729 return getRuleContexts(Role_nameContext.class); 1730 } 1731 public Role_nameContext role_name(int i) { 1732 return getRuleContext(Role_nameContext.class,i); 1733 } 1734 public List<TerminalNode> TRIGGER() { return getTokens(FbsqlParser.TRIGGER); } 1735 public TerminalNode TRIGGER(int i) { 1736 return getToken(FbsqlParser.TRIGGER, i); 1737 } 1738 public List<TerminalNode> BEFORE() { return getTokens(FbsqlParser.BEFORE); } 1739 public TerminalNode BEFORE(int i) { 1740 return getToken(FbsqlParser.BEFORE, i); 1741 } 1742 public List<Trigger_before_procedure_nameContext> trigger_before_procedure_name() { 1743 return getRuleContexts(Trigger_before_procedure_nameContext.class); 1744 } 1745 public Trigger_before_procedure_nameContext trigger_before_procedure_name(int i) { 1746 return getRuleContext(Trigger_before_procedure_nameContext.class,i); 1747 } 1748 public List<TerminalNode> AFTER() { return getTokens(FbsqlParser.AFTER); } 1749 public TerminalNode AFTER(int i) { 1750 return getToken(FbsqlParser.AFTER, i); 1751 } 1752 public List<Trigger_after_procedure_nameContext> trigger_after_procedure_name() { 1753 return getRuleContexts(Trigger_after_procedure_nameContext.class); 1754 } 1755 public Trigger_after_procedure_nameContext trigger_after_procedure_name(int i) { 1756 return getRuleContext(Trigger_after_procedure_nameContext.class,i); 1757 } 1758 public List<Statement_aliasContext> statement_alias() { 1759 return getRuleContexts(Statement_aliasContext.class); 1760 } 1761 public Statement_aliasContext statement_alias(int i) { 1762 return getRuleContext(Statement_aliasContext.class,i); 1763 } 1764 public List<TerminalNode> AS() { return getTokens(FbsqlParser.AS); } 1765 public TerminalNode AS(int i) { 1766 return getToken(FbsqlParser.AS, i); 1767 } 1768 public Declare_statement_stmtContext(ParserRuleContext parent, int invokingState) { 1769 super(parent, invokingState); 1770 } 1771 @Override public int getRuleIndex() { return RULE_declare_statement_stmt; } 1772 @Override 1773 public void enterRule(ParseTreeListener listener) { 1774 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterDeclare_statement_stmt(this); 1775 } 1776 @Override 1777 public void exitRule(ParseTreeListener listener) { 1778 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitDeclare_statement_stmt(this); 1779 } 1780 @Override 1781 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1782 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitDeclare_statement_stmt(this); 1783 else return visitor.visitChildren(this); 1784 } 1785 } 1786 1787 public final Declare_statement_stmtContext declare_statement_stmt() throws RecognitionException { 1788 Declare_statement_stmtContext _localctx = new Declare_statement_stmtContext(_ctx, getState()); 1789 enterRule(_localctx, 48, RULE_declare_statement_stmt); 1790 int _la; 1791 try { 1792 enterOuterAlt(_localctx, 1); 1793 { 1794 setState(195); 1795 match(DECLARE); 1796 setState(196); 1797 match(STATEMENT); 1798 setState(197); 1799 match(T__1); 1800 setState(198); 1801 native_sql(); 1802 setState(199); 1803 match(T__3); 1804 setState(227); 1805 _errHandler.sync(this); 1806 _la = _input.LA(1); 1807 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STATIC) | (1L << ROLES) | (1L << TRIGGER) | (1L << AS) | (1L << COMPRESSION) | (1L << IDENTIFIER) | (1L << STRING_LITERAL))) != 0)) { 1808 { 1809 setState(225); 1810 _errHandler.sync(this); 1811 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { 1812 case 1: 1813 { 1814 setState(200); 1815 match(STATIC); 1816 } 1817 break; 1818 case 2: 1819 { 1820 { 1821 setState(201); 1822 match(COMPRESSION); 1823 setState(202); 1824 compression_level(); 1825 } 1826 } 1827 break; 1828 case 3: 1829 { 1830 { 1831 setState(203); 1832 match(ROLES); 1833 setState(204); 1834 match(T__1); 1835 setState(205); 1836 role_name(); 1837 setState(210); 1838 _errHandler.sync(this); 1839 _la = _input.LA(1); 1840 while (_la==T__2) { 1841 { 1842 { 1843 setState(206); 1844 match(T__2); 1845 setState(207); 1846 role_name(); 1847 } 1848 } 1849 setState(212); 1850 _errHandler.sync(this); 1851 _la = _input.LA(1); 1852 } 1853 setState(213); 1854 match(T__3); 1855 } 1856 } 1857 break; 1858 case 4: 1859 { 1860 { 1861 setState(215); 1862 match(TRIGGER); 1863 setState(216); 1864 match(BEFORE); 1865 setState(217); 1866 trigger_before_procedure_name(); 1867 } 1868 } 1869 break; 1870 case 5: 1871 { 1872 { 1873 setState(218); 1874 match(TRIGGER); 1875 setState(219); 1876 match(AFTER); 1877 setState(220); 1878 trigger_after_procedure_name(); 1879 } 1880 } 1881 break; 1882 case 6: 1883 { 1884 { 1885 setState(222); 1886 _errHandler.sync(this); 1887 _la = _input.LA(1); 1888 if (_la==AS) { 1889 { 1890 setState(221); 1891 match(AS); 1892 } 1893 } 1894 1895 setState(224); 1896 statement_alias(); 1897 } 1898 } 1899 break; 1900 } 1901 } 1902 setState(229); 1903 _errHandler.sync(this); 1904 _la = _input.LA(1); 1905 } 1906 } 1907 } 1908 catch (RecognitionException re) { 1909 _localctx.exception = re; 1910 _errHandler.reportError(this, re); 1911 _errHandler.recover(this, re); 1912 } 1913 finally { 1914 exitRule(); 1915 } 1916 return _localctx; 1917 } 1918 1919 public static class Declare_procedure_stmtContext extends ParserRuleContext { 1920 public TerminalNode DECLARE() { return getToken(FbsqlParser.DECLARE, 0); } 1921 public TerminalNode PROCEDURE() { return getToken(FbsqlParser.PROCEDURE, 0); } 1922 public Procedure_nameContext procedure_name() { 1923 return getRuleContext(Procedure_nameContext.class,0); 1924 } 1925 public TerminalNode TYPE() { return getToken(FbsqlParser.TYPE, 0); } 1926 public TerminalNode OPTIONS() { return getToken(FbsqlParser.OPTIONS, 0); } 1927 public JsonContext json() { 1928 return getRuleContext(JsonContext.class,0); 1929 } 1930 public TerminalNode FILE() { return getToken(FbsqlParser.FILE, 0); } 1931 public Json_fileContext json_file() { 1932 return getRuleContext(Json_fileContext.class,0); 1933 } 1934 public List<TerminalNode> JAVA() { return getTokens(FbsqlParser.JAVA); } 1935 public TerminalNode JAVA(int i) { 1936 return getToken(FbsqlParser.JAVA, i); 1937 } 1938 public List<TerminalNode> JS() { return getTokens(FbsqlParser.JS); } 1939 public TerminalNode JS(int i) { 1940 return getToken(FbsqlParser.JS, i); 1941 } 1942 public List<TerminalNode> EXEC() { return getTokens(FbsqlParser.EXEC); } 1943 public TerminalNode EXEC(int i) { 1944 return getToken(FbsqlParser.EXEC, i); 1945 } 1946 public List<TerminalNode> URL() { return getTokens(FbsqlParser.URL); } 1947 public TerminalNode URL(int i) { 1948 return getToken(FbsqlParser.URL, i); 1949 } 1950 public Declare_procedure_stmtContext(ParserRuleContext parent, int invokingState) { 1951 super(parent, invokingState); 1952 } 1953 @Override public int getRuleIndex() { return RULE_declare_procedure_stmt; } 1954 @Override 1955 public void enterRule(ParseTreeListener listener) { 1956 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterDeclare_procedure_stmt(this); 1957 } 1958 @Override 1959 public void exitRule(ParseTreeListener listener) { 1960 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitDeclare_procedure_stmt(this); 1961 } 1962 @Override 1963 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1964 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitDeclare_procedure_stmt(this); 1965 else return visitor.visitChildren(this); 1966 } 1967 } 1968 1969 public final Declare_procedure_stmtContext declare_procedure_stmt() throws RecognitionException { 1970 Declare_procedure_stmtContext _localctx = new Declare_procedure_stmtContext(_ctx, getState()); 1971 enterRule(_localctx, 50, RULE_declare_procedure_stmt); 1972 int _la; 1973 try { 1974 enterOuterAlt(_localctx, 1); 1975 { 1976 setState(230); 1977 match(DECLARE); 1978 setState(231); 1979 match(PROCEDURE); 1980 setState(232); 1981 procedure_name(); 1982 setState(233); 1983 match(TYPE); 1984 setState(237); 1985 _errHandler.sync(this); 1986 _la = _input.LA(1); 1987 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << JAVA) | (1L << JS) | (1L << EXEC) | (1L << URL))) != 0)) { 1988 { 1989 { 1990 setState(234); 1991 _la = _input.LA(1); 1992 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << JAVA) | (1L << JS) | (1L << EXEC) | (1L << URL))) != 0)) ) { 1993 _errHandler.recoverInline(this); 1994 } 1995 else { 1996 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1997 _errHandler.reportMatch(this); 1998 consume(); 1999 } 2000 } 2001 } 2002 setState(239); 2003 _errHandler.sync(this); 2004 _la = _input.LA(1); 2005 } 2006 setState(245); 2007 _errHandler.sync(this); 2008 switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) { 2009 case 1: 2010 { 2011 setState(240); 2012 match(OPTIONS); 2013 setState(241); 2014 json(); 2015 } 2016 break; 2017 case 2: 2018 { 2019 setState(242); 2020 match(OPTIONS); 2021 setState(243); 2022 match(FILE); 2023 setState(244); 2024 json_file(); 2025 } 2026 break; 2027 } 2028 } 2029 } 2030 catch (RecognitionException re) { 2031 _localctx.exception = re; 2032 _errHandler.reportError(this, re); 2033 _errHandler.recover(this, re); 2034 } 2035 finally { 2036 exitRule(); 2037 } 2038 return _localctx; 2039 } 2040 2041 public static class Include_script_file_stmtContext extends ParserRuleContext { 2042 public TerminalNode INCLUDE() { return getToken(FbsqlParser.INCLUDE, 0); } 2043 public List<Sql_script_fileContext> sql_script_file() { 2044 return getRuleContexts(Sql_script_fileContext.class); 2045 } 2046 public Sql_script_fileContext sql_script_file(int i) { 2047 return getRuleContext(Sql_script_fileContext.class,i); 2048 } 2049 public Include_script_file_stmtContext(ParserRuleContext parent, int invokingState) { 2050 super(parent, invokingState); 2051 } 2052 @Override public int getRuleIndex() { return RULE_include_script_file_stmt; } 2053 @Override 2054 public void enterRule(ParseTreeListener listener) { 2055 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterInclude_script_file_stmt(this); 2056 } 2057 @Override 2058 public void exitRule(ParseTreeListener listener) { 2059 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitInclude_script_file_stmt(this); 2060 } 2061 @Override 2062 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2063 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitInclude_script_file_stmt(this); 2064 else return visitor.visitChildren(this); 2065 } 2066 } 2067 2068 public final Include_script_file_stmtContext include_script_file_stmt() throws RecognitionException { 2069 Include_script_file_stmtContext _localctx = new Include_script_file_stmtContext(_ctx, getState()); 2070 enterRule(_localctx, 52, RULE_include_script_file_stmt); 2071 int _la; 2072 try { 2073 enterOuterAlt(_localctx, 1); 2074 { 2075 setState(247); 2076 match(INCLUDE); 2077 setState(248); 2078 sql_script_file(); 2079 setState(253); 2080 _errHandler.sync(this); 2081 _la = _input.LA(1); 2082 while (_la==T__2) { 2083 { 2084 { 2085 setState(249); 2086 match(T__2); 2087 setState(250); 2088 sql_script_file(); 2089 } 2090 } 2091 setState(255); 2092 _errHandler.sync(this); 2093 _la = _input.LA(1); 2094 } 2095 } 2096 } 2097 catch (RecognitionException re) { 2098 _localctx.exception = re; 2099 _errHandler.reportError(this, re); 2100 _errHandler.recover(this, re); 2101 } 2102 finally { 2103 exitRule(); 2104 } 2105 return _localctx; 2106 } 2107 2108 public static class Schedule_stmtContext extends ParserRuleContext { 2109 public TerminalNode SCHEDULE() { return getToken(FbsqlParser.SCHEDULE, 0); } 2110 public Procedure_nameContext procedure_name() { 2111 return getRuleContext(Procedure_nameContext.class,0); 2112 } 2113 public TerminalNode AT() { return getToken(FbsqlParser.AT, 0); } 2114 public Cron_expressionContext cron_expression() { 2115 return getRuleContext(Cron_expressionContext.class,0); 2116 } 2117 public Schedule_stmtContext(ParserRuleContext parent, int invokingState) { 2118 super(parent, invokingState); 2119 } 2120 @Override public int getRuleIndex() { return RULE_schedule_stmt; } 2121 @Override 2122 public void enterRule(ParseTreeListener listener) { 2123 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterSchedule_stmt(this); 2124 } 2125 @Override 2126 public void exitRule(ParseTreeListener listener) { 2127 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitSchedule_stmt(this); 2128 } 2129 @Override 2130 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2131 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitSchedule_stmt(this); 2132 else return visitor.visitChildren(this); 2133 } 2134 } 2135 2136 public final Schedule_stmtContext schedule_stmt() throws RecognitionException { 2137 Schedule_stmtContext _localctx = new Schedule_stmtContext(_ctx, getState()); 2138 enterRule(_localctx, 54, RULE_schedule_stmt); 2139 try { 2140 enterOuterAlt(_localctx, 1); 2141 { 2142 setState(256); 2143 match(SCHEDULE); 2144 setState(257); 2145 procedure_name(); 2146 setState(258); 2147 match(AT); 2148 setState(259); 2149 cron_expression(); 2150 } 2151 } 2152 catch (RecognitionException re) { 2153 _localctx.exception = re; 2154 _errHandler.reportError(this, re); 2155 _errHandler.recover(this, re); 2156 } 2157 finally { 2158 exitRule(); 2159 } 2160 return _localctx; 2161 } 2162 2163 public static class Native_stmtContext extends ParserRuleContext { 2164 public List<ProcedureContext> procedure() { 2165 return getRuleContexts(ProcedureContext.class); 2166 } 2167 public ProcedureContext procedure(int i) { 2168 return getRuleContext(ProcedureContext.class,i); 2169 } 2170 public Native_stmtContext(ParserRuleContext parent, int invokingState) { 2171 super(parent, invokingState); 2172 } 2173 @Override public int getRuleIndex() { return RULE_native_stmt; } 2174 @Override 2175 public void enterRule(ParseTreeListener listener) { 2176 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).enterNative_stmt(this); 2177 } 2178 @Override 2179 public void exitRule(ParseTreeListener listener) { 2180 if ( listener instanceof FbsqlListener ) ((FbsqlListener)listener).exitNative_stmt(this); 2181 } 2182 @Override 2183 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2184 if ( visitor instanceof FbsqlVisitor ) return ((FbsqlVisitor<? extends T>)visitor).visitNative_stmt(this); 2185 else return visitor.visitChildren(this); 2186 } 2187 } 2188 2189 public final Native_stmtContext native_stmt() throws RecognitionException { 2190 Native_stmtContext _localctx = new Native_stmtContext(_ctx, getState()); 2191 enterRule(_localctx, 56, RULE_native_stmt); 2192 int _la; 2193 try { 2194 int _alt; 2195 enterOuterAlt(_localctx, 1); 2196 { 2197 setState(276); 2198 _errHandler.sync(this); 2199 _la = _input.LA(1); 2200 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << STATIC) | (1L << ROLES) | (1L << TRIGGER) | (1L << BEFORE) | (1L << AFTER) | (1L << AS) | (1L << NO) | (1L << COMPRESSION) | (1L << BEST) | (1L << SPEED) | (1L << DECLARE) | (1L << PROCEDURE) | (1L << TYPE) | (1L << JAVA) | (1L << JS) | (1L << EXEC) | (1L << URL) | (1L << OPTIONS) | (1L << FILE) | (1L << STATEMENT) | (1L << CONNECT) | (1L << TO) | (1L << USER) | (1L << PASSWORD) | (1L << PROPERTIES) | (1L << DRIVER) | (1L << LIB) | (1L << CONNECTION) | (1L << POOL) | (1L << SIZE) | (1L << MIN) | (1L << MAX) | (1L << UNDECLARED) | (1L << STATEMENTS) | (1L << INCOMING) | (1L << CONNECTIONS) | (1L << ALLOW) | (1L << REJECT) | (1L << IF) | (1L << EXISTS) | (1L << SWITCH) | (1L << SCHEDULE) | (1L << AT) | (1L << INCLUDE) | (1L << NULL) | (1L << IDENTIFIER) | (1L << NUMERIC_LITERAL) | (1L << STRING_LITERAL) | (1L << SINGLE_LINE_COMMENT) | (1L << MULTILINE_COMMENT) | (1L << SPACES) | (1L << UNEXPECTED_CHAR))) != 0)) { 2201 { 2202 { 2203 setState(264); 2204 _errHandler.sync(this); 2205 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 2206 while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2207 if ( _alt==1+1 ) { 2208 { 2209 { 2210 setState(261); 2211 matchWildcard(); 2212 } 2213 } 2214 } 2215 setState(266); 2216 _errHandler.sync(this); 2217 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 2218 } 2219 setState(267); 2220 procedure(); 2221 setState(271); 2222 _errHandler.sync(this); 2223 _alt = getInterpreter().adaptivePredict(_input,22,_ctx); 2224 while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2225 if ( _alt==1+1 ) { 2226 { 2227 { 2228 setState(268); 2229 matchWildcard(); 2230 } 2231 } 2232 } 2233 setState(273); 2234 _errHandler.sync(this); 2235 _alt = getInterpreter().adaptivePredict(_input,22,_ctx); 2236 } 2237 } 2238 } 2239 setState(278); 2240 _errHandler.sync(this); 2241 _la = _input.LA(1); 2242 } 2243 } 2244 } 2245 catch (RecognitionException re) { 2246 _localctx.exception = re; 2247 _errHandler.reportError(this, re); 2248 _errHandler.recover(this, re); 2249 } 2250 finally { 2251 exitRule(); 2252 } 2253 return _localctx; 2254 } 2255 2256 public static final String _serializedATN = 2257 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3:\u011a\4\2\t\2\4"+ 2258 "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+ 2259 "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ 2260 "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ 2261 "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\3\2\7\2>\n\2\f\2\16"+ 2262 "\2A\13\2\3\3\3\3\3\3\3\3\3\3\3\3\5\3I\n\3\3\4\3\4\3\4\5\4N\n\4\3\4\3\4"+ 2263 "\7\4R\n\4\f\4\16\4U\13\4\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\b\3"+ 2264 "\b\3\b\3\b\5\be\n\b\3\t\3\t\3\n\3\n\3\13\3\13\3\f\3\f\3\r\3\r\3\16\3\16"+ 2265 "\3\17\3\17\3\20\3\20\3\21\3\21\3\22\3\22\3\23\3\23\3\24\3\24\3\25\3\25"+ 2266 "\3\26\3\26\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30"+ 2267 "\3\30\3\30\3\30\3\30\3\30\7\30\u0094\n\30\f\30\16\30\u0097\13\30\3\30"+ 2268 "\3\30\3\30\3\30\3\30\3\30\6\30\u009f\n\30\r\30\16\30\u00a0\3\30\3\30\3"+ 2269 "\30\6\30\u00a6\n\30\r\30\16\30\u00a7\3\30\3\30\3\30\6\30\u00ad\n\30\r"+ 2270 "\30\16\30\u00ae\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u00b7\n\30\3\30\5\30"+ 2271 "\u00ba\n\30\3\30\7\30\u00bd\n\30\f\30\16\30\u00c0\13\30\3\31\3\31\3\31"+ 2272 "\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32"+ 2273 "\7\32\u00d3\n\32\f\32\16\32\u00d6\13\32\3\32\3\32\3\32\3\32\3\32\3\32"+ 2274 "\3\32\3\32\3\32\5\32\u00e1\n\32\3\32\7\32\u00e4\n\32\f\32\16\32\u00e7"+ 2275 "\13\32\3\33\3\33\3\33\3\33\3\33\7\33\u00ee\n\33\f\33\16\33\u00f1\13\33"+ 2276 "\3\33\3\33\3\33\3\33\3\33\5\33\u00f8\n\33\3\34\3\34\3\34\3\34\7\34\u00fe"+ 2277 "\n\34\f\34\16\34\u0101\13\34\3\35\3\35\3\35\3\35\3\35\3\36\7\36\u0109"+ 2278 "\n\36\f\36\16\36\u010c\13\36\3\36\3\36\7\36\u0110\n\36\f\36\16\36\u0113"+ 2279 "\13\36\7\36\u0115\n\36\f\36\16\36\u0118\13\36\3\36\5?\u010a\u0111\2\37"+ 2280 "\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:\2\5\4\2"+ 2281 "\64\64\66\66\3\2+,\3\2\24\27\2\u0124\2?\3\2\2\2\4H\3\2\2\2\6J\3\2\2\2"+ 2282 "\bX\3\2\2\2\nZ\3\2\2\2\f\\\3\2\2\2\16d\3\2\2\2\20f\3\2\2\2\22h\3\2\2\2"+ 2283 "\24j\3\2\2\2\26l\3\2\2\2\30n\3\2\2\2\32p\3\2\2\2\34r\3\2\2\2\36t\3\2\2"+ 2284 "\2 v\3\2\2\2\"x\3\2\2\2$z\3\2\2\2&|\3\2\2\2(~\3\2\2\2*\u0080\3\2\2\2,"+ 2285 "\u0082\3\2\2\2.\u0084\3\2\2\2\60\u00c1\3\2\2\2\62\u00c5\3\2\2\2\64\u00e8"+ 2286 "\3\2\2\2\66\u00f9\3\2\2\28\u0102\3\2\2\2:\u0116\3\2\2\2<>\13\2\2\2=<\3"+ 2287 "\2\2\2>A\3\2\2\2?@\3\2\2\2?=\3\2\2\2@\3\3\2\2\2A?\3\2\2\2BC\7\3\2\2CI"+ 2288 "\7\64\2\2DI\7\65\2\2EI\7\66\2\2FI\7\63\2\2GI\5\6\4\2HB\3\2\2\2HD\3\2\2"+ 2289 "\2HE\3\2\2\2HF\3\2\2\2HG\3\2\2\2I\5\3\2\2\2JK\5\24\13\2KM\7\4\2\2LN\5"+ 2290 "\4\3\2ML\3\2\2\2MN\3\2\2\2NS\3\2\2\2OP\7\5\2\2PR\5\4\3\2QO\3\2\2\2RU\3"+ 2291 "\2\2\2SQ\3\2\2\2ST\3\2\2\2TV\3\2\2\2US\3\2\2\2VW\7\6\2\2W\7\3\2\2\2XY"+ 2292 "\t\2\2\2Y\t\3\2\2\2Z[\7\64\2\2[\13\3\2\2\2\\]\7\64\2\2]\r\3\2\2\2^_\7"+ 2293 "\r\2\2_e\7\16\2\2`a\7\17\2\2ae\7\16\2\2bc\7\17\2\2ce\7\20\2\2d^\3\2\2"+ 2294 "\2d`\3\2\2\2db\3\2\2\2e\17\3\2\2\2fg\t\2\2\2g\21\3\2\2\2hi\t\2\2\2i\23"+ 2295 "\3\2\2\2jk\t\2\2\2k\25\3\2\2\2lm\7\66\2\2m\27\3\2\2\2no\7\66\2\2o\31\3"+ 2296 "\2\2\2pq\t\2\2\2q\33\3\2\2\2rs\7\66\2\2s\35\3\2\2\2tu\7\66\2\2u\37\3\2"+ 2297 "\2\2vw\7\66\2\2w!\3\2\2\2xy\7\66\2\2y#\3\2\2\2z{\7\65\2\2{%\3\2\2\2|}"+ 2298 "\7\65\2\2}\'\3\2\2\2~\177\7\66\2\2\177)\3\2\2\2\u0080\u0081\7\66\2\2\u0081"+ 2299 "+\3\2\2\2\u0082\u0083\7\66\2\2\u0083-\3\2\2\2\u0084\u0085\7\33\2\2\u0085"+ 2300 "\u0086\7\34\2\2\u0086\u00be\5\30\r\2\u0087\u0088\7\35\2\2\u0088\u00bd"+ 2301 "\5\32\16\2\u0089\u008a\7\36\2\2\u008a\u00bd\5\34\17\2\u008b\u008c\7\37"+ 2302 "\2\2\u008c\u00bd\5\36\20\2\u008d\u008e\7 \2\2\u008e\u00bd\5 \21\2\u008f"+ 2303 "\u0090\7!\2\2\u0090\u0095\5\"\22\2\u0091\u0092\7\5\2\2\u0092\u0094\5\""+ 2304 "\22\2\u0093\u0091\3\2\2\2\u0094\u0097\3\2\2\2\u0095\u0093\3\2\2\2\u0095"+ 2305 "\u0096\3\2\2\2\u0096\u00bd\3\2\2\2\u0097\u0095\3\2\2\2\u0098\u0099\7\""+ 2306 "\2\2\u0099\u009e\7#\2\2\u009a\u009b\7%\2\2\u009b\u009f\5$\23\2\u009c\u009d"+ 2307 "\7&\2\2\u009d\u009f\5&\24\2\u009e\u009a\3\2\2\2\u009e\u009c\3\2\2\2\u009f"+ 2308 "\u00a0\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1\u00bd\3\2"+ 2309 "\2\2\u00a2\u00a3\7\'\2\2\u00a3\u00a5\7(\2\2\u00a4\u00a6\t\3\2\2\u00a5"+ 2310 "\u00a4\3\2\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00a5\3\2\2\2\u00a7\u00a8\3\2"+ 2311 "\2\2\u00a8\u00bd\3\2\2\2\u00a9\u00aa\7)\2\2\u00aa\u00ac\7*\2\2\u00ab\u00ad"+ 2312 "\t\3\2\2\u00ac\u00ab\3\2\2\2\u00ad\u00ae\3\2\2\2\u00ae\u00ac\3\2\2\2\u00ae"+ 2313 "\u00af\3\2\2\2\u00af\u00b6\3\2\2\2\u00b0\u00b1\7-\2\2\u00b1\u00b2\7.\2"+ 2314 "\2\u00b2\u00b3\7\4\2\2\u00b3\u00b4\5\2\2\2\u00b4\u00b5\7\6\2\2\u00b5\u00b7"+ 2315 "\3\2\2\2\u00b6\u00b0\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00bd\3\2\2\2\u00b8"+ 2316 "\u00ba\7\f\2\2\u00b9\u00b8\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bb\3\2"+ 2317 "\2\2\u00bb\u00bd\5\20\t\2\u00bc\u0087\3\2\2\2\u00bc\u0089\3\2\2\2\u00bc"+ 2318 "\u008b\3\2\2\2\u00bc\u008d\3\2\2\2\u00bc\u008f\3\2\2\2\u00bc\u0098\3\2"+ 2319 "\2\2\u00bc\u00a2\3\2\2\2\u00bc\u00a9\3\2\2\2\u00bc\u00b9\3\2\2\2\u00bd"+ 2320 "\u00c0\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf/\3\2\2\2"+ 2321 "\u00c0\u00be\3\2\2\2\u00c1\u00c2\7/\2\2\u00c2\u00c3\7\34\2\2\u00c3\u00c4"+ 2322 "\5\20\t\2\u00c4\61\3\2\2\2\u00c5\u00c6\7\21\2\2\u00c6\u00c7\7\32\2\2\u00c7"+ 2323 "\u00c8\7\4\2\2\u00c8\u00c9\5\2\2\2\u00c9\u00e5\7\6\2\2\u00ca\u00e4\7\7"+ 2324 "\2\2\u00cb\u00cc\7\16\2\2\u00cc\u00e4\5\16\b\2\u00cd\u00ce\7\b\2\2\u00ce"+ 2325 "\u00cf\7\4\2\2\u00cf\u00d4\5\b\5\2\u00d0\u00d1\7\5\2\2\u00d1\u00d3\5\b"+ 2326 "\5\2\u00d2\u00d0\3\2\2\2\u00d3\u00d6\3\2\2\2\u00d4\u00d2\3\2\2\2\u00d4"+ 2327 "\u00d5\3\2\2\2\u00d5\u00d7\3\2\2\2\u00d6\u00d4\3\2\2\2\u00d7\u00d8\7\6"+ 2328 "\2\2\u00d8\u00e4\3\2\2\2\u00d9\u00da\7\t\2\2\u00da\u00db\7\n\2\2\u00db"+ 2329 "\u00e4\5\n\6\2\u00dc\u00dd\7\t\2\2\u00dd\u00de\7\13\2\2\u00de\u00e4\5"+ 2330 "\f\7\2\u00df\u00e1\7\f\2\2\u00e0\u00df\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1"+ 2331 "\u00e2\3\2\2\2\u00e2\u00e4\5\22\n\2\u00e3\u00ca\3\2\2\2\u00e3\u00cb\3"+ 2332 "\2\2\2\u00e3\u00cd\3\2\2\2\u00e3\u00d9\3\2\2\2\u00e3\u00dc\3\2\2\2\u00e3"+ 2333 "\u00e0\3\2\2\2\u00e4\u00e7\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e6\3\2"+ 2334 "\2\2\u00e6\63\3\2\2\2\u00e7\u00e5\3\2\2\2\u00e8\u00e9\7\21\2\2\u00e9\u00ea"+ 2335 "\7\22\2\2\u00ea\u00eb\5\24\13\2\u00eb\u00ef\7\23\2\2\u00ec\u00ee\t\4\2"+ 2336 "\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0"+ 2337 "\3\2\2\2\u00f0\u00f7\3\2\2\2\u00f1\u00ef\3\2\2\2\u00f2\u00f3\7\30\2\2"+ 2338 "\u00f3\u00f8\5\26\f\2\u00f4\u00f5\7\30\2\2\u00f5\u00f6\7\31\2\2\u00f6"+ 2339 "\u00f8\5*\26\2\u00f7\u00f2\3\2\2\2\u00f7\u00f4\3\2\2\2\u00f7\u00f8\3\2"+ 2340 "\2\2\u00f8\65\3\2\2\2\u00f9\u00fa\7\62\2\2\u00fa\u00ff\5(\25\2\u00fb\u00fc"+ 2341 "\7\5\2\2\u00fc\u00fe\5(\25\2\u00fd\u00fb\3\2\2\2\u00fe\u0101\3\2\2\2\u00ff"+ 2342 "\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\67\3\2\2\2\u0101\u00ff\3\2\2"+ 2343 "\2\u0102\u0103\7\60\2\2\u0103\u0104\5\24\13\2\u0104\u0105\7\61\2\2\u0105"+ 2344 "\u0106\5,\27\2\u01069\3\2\2\2\u0107\u0109\13\2\2\2\u0108\u0107\3\2\2\2"+ 2345 "\u0109\u010c\3\2\2\2\u010a\u010b\3\2\2\2\u010a\u0108\3\2\2\2\u010b\u010d"+ 2346 "\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\5\6\4\2\u010e\u0110\13\2\2\2"+ 2347 "\u010f\u010e\3\2\2\2\u0110\u0113\3\2\2\2\u0111\u0112\3\2\2\2\u0111\u010f"+ 2348 "\3\2\2\2\u0112\u0115\3\2\2\2\u0113\u0111\3\2\2\2\u0114\u010a\3\2\2\2\u0115"+ 2349 "\u0118\3\2\2\2\u0116\u0114\3\2\2\2\u0116\u0117\3\2\2\2\u0117;\3\2\2\2"+ 2350 "\u0118\u0116\3\2\2\2\32?HMSd\u0095\u009e\u00a0\u00a7\u00ae\u00b6\u00b9"+ 2351 "\u00bc\u00be\u00d4\u00e0\u00e3\u00e5\u00ef\u00f7\u00ff\u010a\u0111\u0116"; 2352 public static final ATN _ATN = 2353 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 2354 static { 2355 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 2356 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 2357 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 2358 } 2359 } 2360}