| |
| // Generated from SV3_1aPpParser.g4 by ANTLR 4.7.2 |
| |
| |
| #include "SV3_1aPpParserListener.h" |
| |
| #include "SV3_1aPpParser.h" |
| |
| |
| using namespace antlrcpp; |
| using namespace antlr4; |
| |
| SV3_1aPpParser::SV3_1aPpParser(TokenStream *input) : Parser(input) { |
| _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache); |
| } |
| |
| SV3_1aPpParser::~SV3_1aPpParser() { |
| delete _interpreter; |
| } |
| |
| std::string SV3_1aPpParser::getGrammarFileName() const { |
| return "SV3_1aPpParser.g4"; |
| } |
| |
| const std::vector<std::string>& SV3_1aPpParser::getRuleNames() const { |
| return _ruleNames; |
| } |
| |
| dfa::Vocabulary& SV3_1aPpParser::getVocabulary() const { |
| return _vocabulary; |
| } |
| |
| |
| //----------------- Source_textContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Source_textContext::Source_textContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| std::vector<SV3_1aPpParser::DescriptionContext *> SV3_1aPpParser::Source_textContext::description() { |
| return getRuleContexts<SV3_1aPpParser::DescriptionContext>(); |
| } |
| |
| SV3_1aPpParser::DescriptionContext* SV3_1aPpParser::Source_textContext::description(size_t i) { |
| return getRuleContext<SV3_1aPpParser::DescriptionContext>(i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Source_textContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSource_text; |
| } |
| |
| void SV3_1aPpParser::Source_textContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSource_text(this); |
| } |
| |
| void SV3_1aPpParser::Source_textContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSource_text(this); |
| } |
| |
| SV3_1aPpParser::Source_textContext* SV3_1aPpParser::source_text() { |
| Source_textContext *_localctx = _tracker.createInstance<Source_textContext>(_ctx, getState()); |
| enterRule(_localctx, 0, SV3_1aPpParser::RuleSource_text); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(287); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while ((((_la & ~ 0x3fULL) == 0) && |
| ((1ULL << _la) & ((1ULL << SV3_1aPpParser::One_line_comment) |
| | (1ULL << SV3_1aPpParser::Block_comment) |
| | (1ULL << SV3_1aPpParser::TICK_VARIABLE) |
| | (1ULL << SV3_1aPpParser::TICK_DEFINE) |
| | (1ULL << SV3_1aPpParser::TICK_CELLDEFINE) |
| | (1ULL << SV3_1aPpParser::TICK_ENDCELLDEFINE) |
| | (1ULL << SV3_1aPpParser::TICK_DEFAULT_NETTYPE) |
| | (1ULL << SV3_1aPpParser::TICK_UNDEF) |
| | (1ULL << SV3_1aPpParser::TICK_IFDEF) |
| | (1ULL << SV3_1aPpParser::TICK_IFNDEF) |
| | (1ULL << SV3_1aPpParser::TICK_ELSE) |
| | (1ULL << SV3_1aPpParser::TICK_ELSIF) |
| | (1ULL << SV3_1aPpParser::TICK_ELSEIF) |
| | (1ULL << SV3_1aPpParser::TICK_ENDIF) |
| | (1ULL << SV3_1aPpParser::TICK_INCLUDE) |
| | (1ULL << SV3_1aPpParser::TICK_PRAGMA) |
| | (1ULL << SV3_1aPpParser::TICK_BEGIN_KEYWORDS) |
| | (1ULL << SV3_1aPpParser::TICK_END_KEYWORDS) |
| | (1ULL << SV3_1aPpParser::TICK_RESETALL) |
| | (1ULL << SV3_1aPpParser::TICK_TIMESCALE) |
| | (1ULL << SV3_1aPpParser::TICK_UNCONNECTED_DRIVE) |
| | (1ULL << SV3_1aPpParser::TICK_NOUNCONNECTED_DRIVE) |
| | (1ULL << SV3_1aPpParser::TICK_LINE) |
| | (1ULL << SV3_1aPpParser::TICK_DEFAULT_DECAY_TIME) |
| | (1ULL << SV3_1aPpParser::TICK_DEFAULT_TRIREG_STRENGTH) |
| | (1ULL << SV3_1aPpParser::TICK_DELAY_MODE_DISTRIBUTED) |
| | (1ULL << SV3_1aPpParser::TICK_DELAY_MODE_PATH) |
| | (1ULL << SV3_1aPpParser::TICK_DELAY_MODE_UNIT) |
| | (1ULL << SV3_1aPpParser::TICK_DELAY_MODE_ZERO) |
| | (1ULL << SV3_1aPpParser::TICK_UNDEFINEALL) |
| | (1ULL << SV3_1aPpParser::TICK_ACCELERATE) |
| | (1ULL << SV3_1aPpParser::TICK_NOACCELERATE) |
| | (1ULL << SV3_1aPpParser::TICK_PROTECT) |
| | (1ULL << SV3_1aPpParser::TICK_USELIB) |
| | (1ULL << SV3_1aPpParser::TICK_DISABLE_PORTFAULTS) |
| | (1ULL << SV3_1aPpParser::TICK_ENABLE_PORTFAULTS) |
| | (1ULL << SV3_1aPpParser::TICK_NOSUPPRESS_FAULTS) |
| | (1ULL << SV3_1aPpParser::TICK_SUPPRESS_FAULTS) |
| | (1ULL << SV3_1aPpParser::TICK_SIGNED) |
| | (1ULL << SV3_1aPpParser::TICK_UNSIGNED) |
| | (1ULL << SV3_1aPpParser::TICK_ENDPROTECT) |
| | (1ULL << SV3_1aPpParser::TICK_PROTECTED) |
| | (1ULL << SV3_1aPpParser::TICK_ENDPROTECTED) |
| | (1ULL << SV3_1aPpParser::TICK_EXPAND_VECTORNETS) |
| | (1ULL << SV3_1aPpParser::TICK_NOEXPAND_VECTORNETS) |
| | (1ULL << SV3_1aPpParser::TICK_AUTOEXPAND_VECTORNETS) |
| | (1ULL << SV3_1aPpParser::TICK_REMOVE_GATENAME) |
| | (1ULL << SV3_1aPpParser::TICK_NOREMOVE_GATENAMES) |
| | (1ULL << SV3_1aPpParser::TICK_REMOVE_NETNAME) |
| | (1ULL << SV3_1aPpParser::TICK_NOREMOVE_NETNAMES) |
| | (1ULL << SV3_1aPpParser::TICK_FILE__) |
| | (1ULL << SV3_1aPpParser::TICK_LINE__) |
| | (1ULL << SV3_1aPpParser::MODULE) |
| | (1ULL << SV3_1aPpParser::ENDMODULE) |
| | (1ULL << SV3_1aPpParser::INTERFACE) |
| | (1ULL << SV3_1aPpParser::ENDINTERFACE) |
| | (1ULL << SV3_1aPpParser::PROGRAM) |
| | (1ULL << SV3_1aPpParser::ENDPROGRAM) |
| | (1ULL << SV3_1aPpParser::PRIMITIVE) |
| | (1ULL << SV3_1aPpParser::ENDPRIMITIVE) |
| | (1ULL << SV3_1aPpParser::PACKAGE) |
| | (1ULL << SV3_1aPpParser::ENDPACKAGE) |
| | (1ULL << SV3_1aPpParser::CHECKER))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && |
| ((1ULL << (_la - 64)) & ((1ULL << (SV3_1aPpParser::ENDCHECKER - 64)) |
| | (1ULL << (SV3_1aPpParser::CONFIG - 64)) |
| | (1ULL << (SV3_1aPpParser::ENDCONFIG - 64)) |
| | (1ULL << (SV3_1aPpParser::Macro_identifier - 64)) |
| | (1ULL << (SV3_1aPpParser::Macro_Escaped_identifier - 64)) |
| | (1ULL << (SV3_1aPpParser::String - 64)) |
| | (1ULL << (SV3_1aPpParser::Simple_identifier - 64)) |
| | (1ULL << (SV3_1aPpParser::Spaces - 64)) |
| | (1ULL << (SV3_1aPpParser::Pound_delay - 64)) |
| | (1ULL << (SV3_1aPpParser::TIMESCALE - 64)) |
| | (1ULL << (SV3_1aPpParser::Number - 64)) |
| | (1ULL << (SV3_1aPpParser::Fixed_point_number - 64)) |
| | (1ULL << (SV3_1aPpParser::TEXT_CR - 64)) |
| | (1ULL << (SV3_1aPpParser::ESCAPED_CR - 64)) |
| | (1ULL << (SV3_1aPpParser::CR - 64)) |
| | (1ULL << (SV3_1aPpParser::TICK_QUOTE - 64)) |
| | (1ULL << (SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE - 64)) |
| | (1ULL << (SV3_1aPpParser::TICK_TICK - 64)) |
| | (1ULL << (SV3_1aPpParser::PARENS_OPEN - 64)) |
| | (1ULL << (SV3_1aPpParser::PARENS_CLOSE - 64)) |
| | (1ULL << (SV3_1aPpParser::COMMA - 64)) |
| | (1ULL << (SV3_1aPpParser::EQUAL_OP - 64)) |
| | (1ULL << (SV3_1aPpParser::DOUBLE_QUOTE - 64)) |
| | (1ULL << (SV3_1aPpParser::Escaped_identifier - 64)) |
| | (1ULL << (SV3_1aPpParser::CURLY_OPEN - 64)) |
| | (1ULL << (SV3_1aPpParser::CURLY_CLOSE - 64)) |
| | (1ULL << (SV3_1aPpParser::SQUARE_OPEN - 64)) |
| | (1ULL << (SV3_1aPpParser::SQUARE_CLOSE - 64)) |
| | (1ULL << (SV3_1aPpParser::Special - 64)) |
| | (1ULL << (SV3_1aPpParser::ANY - 64)))) != 0)) { |
| setState(284); |
| description(); |
| setState(289); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- DescriptionContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::DescriptionContext::DescriptionContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Unterminated_stringContext* SV3_1aPpParser::DescriptionContext::unterminated_string() { |
| return getRuleContext<SV3_1aPpParser::Unterminated_stringContext>(0); |
| } |
| |
| SV3_1aPpParser::StringContext* SV3_1aPpParser::DescriptionContext::string() { |
| return getRuleContext<SV3_1aPpParser::StringContext>(0); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::DescriptionContext::number() { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(0); |
| } |
| |
| SV3_1aPpParser::Macro_definitionContext* SV3_1aPpParser::DescriptionContext::macro_definition() { |
| return getRuleContext<SV3_1aPpParser::Macro_definitionContext>(0); |
| } |
| |
| SV3_1aPpParser::CommentsContext* SV3_1aPpParser::DescriptionContext::comments() { |
| return getRuleContext<SV3_1aPpParser::CommentsContext>(0); |
| } |
| |
| SV3_1aPpParser::Celldefine_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::celldefine_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Celldefine_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Endcelldefine_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::endcelldefine_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Endcelldefine_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Default_nettype_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::default_nettype_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Default_nettype_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Undef_directiveContext* SV3_1aPpParser::DescriptionContext::undef_directive() { |
| return getRuleContext<SV3_1aPpParser::Undef_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Ifdef_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::ifdef_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Ifdef_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Ifndef_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::ifndef_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Ifndef_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Else_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::else_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Else_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Elsif_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::elsif_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Elsif_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Elseif_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::elseif_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Elseif_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Endif_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::endif_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Endif_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Include_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::include_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Include_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Include_directiveContext* SV3_1aPpParser::DescriptionContext::include_directive() { |
| return getRuleContext<SV3_1aPpParser::Include_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Resetall_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::resetall_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Resetall_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Begin_keywords_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::begin_keywords_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Begin_keywords_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Begin_keywords_directiveContext* SV3_1aPpParser::DescriptionContext::begin_keywords_directive() { |
| return getRuleContext<SV3_1aPpParser::Begin_keywords_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::End_keywords_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::end_keywords_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::End_keywords_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Timescale_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::timescale_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Timescale_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Unconnected_drive_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::unconnected_drive_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Unconnected_drive_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Nounconnected_drive_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::nounconnected_drive_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Nounconnected_drive_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Line_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::line_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Line_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Default_decay_time_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::default_decay_time_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Default_decay_time_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Default_trireg_strenght_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::default_trireg_strenght_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Default_trireg_strenght_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Delay_mode_distributed_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::delay_mode_distributed_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Delay_mode_distributed_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Delay_mode_path_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::delay_mode_path_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Delay_mode_path_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Delay_mode_unit_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::delay_mode_unit_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Delay_mode_unit_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Delay_mode_zero_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::delay_mode_zero_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Delay_mode_zero_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Protect_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::protect_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Protect_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Endprotect_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::endprotect_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Endprotect_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Protected_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::protected_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Protected_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Endprotected_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::endprotected_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Endprotected_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Expand_vectornets_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::expand_vectornets_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Expand_vectornets_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Noexpand_vectornets_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::noexpand_vectornets_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Noexpand_vectornets_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Autoexpand_vectornets_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::autoexpand_vectornets_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Autoexpand_vectornets_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Remove_gatename_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::remove_gatename_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Remove_gatename_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Noremove_gatenames_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::noremove_gatenames_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Noremove_gatenames_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Remove_netname_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::remove_netname_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Remove_netname_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Noremove_netnames_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::noremove_netnames_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Noremove_netnames_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Accelerate_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::accelerate_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Accelerate_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Noaccelerate_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::noaccelerate_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Noaccelerate_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Undefineall_directiveContext* SV3_1aPpParser::DescriptionContext::undefineall_directive() { |
| return getRuleContext<SV3_1aPpParser::Undefineall_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Uselib_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::uselib_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Uselib_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Disable_portfaults_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::disable_portfaults_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Disable_portfaults_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Enable_portfaults_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::enable_portfaults_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Enable_portfaults_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Nosuppress_faults_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::nosuppress_faults_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Nosuppress_faults_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Suppress_faults_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::suppress_faults_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Suppress_faults_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Signed_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::signed_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Signed_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Unsigned_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::unsigned_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Unsigned_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Pragma_directive_one_lineContext* SV3_1aPpParser::DescriptionContext::pragma_directive_one_line() { |
| return getRuleContext<SV3_1aPpParser::Pragma_directive_one_lineContext>(0); |
| } |
| |
| SV3_1aPpParser::Sv_file_directiveContext* SV3_1aPpParser::DescriptionContext::sv_file_directive() { |
| return getRuleContext<SV3_1aPpParser::Sv_file_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Sv_line_directiveContext* SV3_1aPpParser::DescriptionContext::sv_line_directive() { |
| return getRuleContext<SV3_1aPpParser::Sv_line_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::DescriptionContext::macro_instance() { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(0); |
| } |
| |
| SV3_1aPpParser::ModuleContext* SV3_1aPpParser::DescriptionContext::module() { |
| return getRuleContext<SV3_1aPpParser::ModuleContext>(0); |
| } |
| |
| SV3_1aPpParser::EndmoduleContext* SV3_1aPpParser::DescriptionContext::endmodule() { |
| return getRuleContext<SV3_1aPpParser::EndmoduleContext>(0); |
| } |
| |
| SV3_1aPpParser::Sv_interfaceContext* SV3_1aPpParser::DescriptionContext::sv_interface() { |
| return getRuleContext<SV3_1aPpParser::Sv_interfaceContext>(0); |
| } |
| |
| SV3_1aPpParser::EndinterfaceContext* SV3_1aPpParser::DescriptionContext::endinterface() { |
| return getRuleContext<SV3_1aPpParser::EndinterfaceContext>(0); |
| } |
| |
| SV3_1aPpParser::ProgramContext* SV3_1aPpParser::DescriptionContext::program() { |
| return getRuleContext<SV3_1aPpParser::ProgramContext>(0); |
| } |
| |
| SV3_1aPpParser::EndprogramContext* SV3_1aPpParser::DescriptionContext::endprogram() { |
| return getRuleContext<SV3_1aPpParser::EndprogramContext>(0); |
| } |
| |
| SV3_1aPpParser::PrimitiveContext* SV3_1aPpParser::DescriptionContext::primitive() { |
| return getRuleContext<SV3_1aPpParser::PrimitiveContext>(0); |
| } |
| |
| SV3_1aPpParser::EndprimitiveContext* SV3_1aPpParser::DescriptionContext::endprimitive() { |
| return getRuleContext<SV3_1aPpParser::EndprimitiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Sv_packageContext* SV3_1aPpParser::DescriptionContext::sv_package() { |
| return getRuleContext<SV3_1aPpParser::Sv_packageContext>(0); |
| } |
| |
| SV3_1aPpParser::EndpackageContext* SV3_1aPpParser::DescriptionContext::endpackage() { |
| return getRuleContext<SV3_1aPpParser::EndpackageContext>(0); |
| } |
| |
| SV3_1aPpParser::CheckerContext* SV3_1aPpParser::DescriptionContext::checker() { |
| return getRuleContext<SV3_1aPpParser::CheckerContext>(0); |
| } |
| |
| SV3_1aPpParser::EndcheckerContext* SV3_1aPpParser::DescriptionContext::endchecker() { |
| return getRuleContext<SV3_1aPpParser::EndcheckerContext>(0); |
| } |
| |
| SV3_1aPpParser::ConfigContext* SV3_1aPpParser::DescriptionContext::config() { |
| return getRuleContext<SV3_1aPpParser::ConfigContext>(0); |
| } |
| |
| SV3_1aPpParser::EndconfigContext* SV3_1aPpParser::DescriptionContext::endconfig() { |
| return getRuleContext<SV3_1aPpParser::EndconfigContext>(0); |
| } |
| |
| SV3_1aPpParser::Text_blobContext* SV3_1aPpParser::DescriptionContext::text_blob() { |
| return getRuleContext<SV3_1aPpParser::Text_blobContext>(0); |
| } |
| |
| SV3_1aPpParser::Escaped_identifierContext* SV3_1aPpParser::DescriptionContext::escaped_identifier() { |
| return getRuleContext<SV3_1aPpParser::Escaped_identifierContext>(0); |
| } |
| |
| SV3_1aPpParser::Pound_delayContext* SV3_1aPpParser::DescriptionContext::pound_delay() { |
| return getRuleContext<SV3_1aPpParser::Pound_delayContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::DescriptionContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDescription; |
| } |
| |
| void SV3_1aPpParser::DescriptionContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDescription(this); |
| } |
| |
| void SV3_1aPpParser::DescriptionContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDescription(this); |
| } |
| |
| SV3_1aPpParser::DescriptionContext* SV3_1aPpParser::description() { |
| DescriptionContext *_localctx = _tracker.createInstance<DescriptionContext>(_ctx, getState()); |
| enterRule(_localctx, 2, SV3_1aPpParser::RuleDescription); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(363); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1, _ctx)) { |
| case 1: { |
| enterOuterAlt(_localctx, 1); |
| setState(290); |
| unterminated_string(); |
| break; |
| } |
| |
| case 2: { |
| enterOuterAlt(_localctx, 2); |
| setState(291); |
| string(); |
| break; |
| } |
| |
| case 3: { |
| enterOuterAlt(_localctx, 3); |
| setState(292); |
| number(); |
| break; |
| } |
| |
| case 4: { |
| enterOuterAlt(_localctx, 4); |
| setState(293); |
| macro_definition(); |
| break; |
| } |
| |
| case 5: { |
| enterOuterAlt(_localctx, 5); |
| setState(294); |
| comments(); |
| break; |
| } |
| |
| case 6: { |
| enterOuterAlt(_localctx, 6); |
| setState(295); |
| celldefine_directive_one_line(); |
| break; |
| } |
| |
| case 7: { |
| enterOuterAlt(_localctx, 7); |
| setState(296); |
| endcelldefine_directive_one_line(); |
| break; |
| } |
| |
| case 8: { |
| enterOuterAlt(_localctx, 8); |
| setState(297); |
| default_nettype_directive_one_line(); |
| break; |
| } |
| |
| case 9: { |
| enterOuterAlt(_localctx, 9); |
| setState(298); |
| undef_directive(); |
| break; |
| } |
| |
| case 10: { |
| enterOuterAlt(_localctx, 10); |
| setState(299); |
| ifdef_directive_one_line(); |
| break; |
| } |
| |
| case 11: { |
| enterOuterAlt(_localctx, 11); |
| setState(300); |
| ifndef_directive_one_line(); |
| break; |
| } |
| |
| case 12: { |
| enterOuterAlt(_localctx, 12); |
| setState(301); |
| else_directive_one_line(); |
| break; |
| } |
| |
| case 13: { |
| enterOuterAlt(_localctx, 13); |
| setState(302); |
| elsif_directive_one_line(); |
| break; |
| } |
| |
| case 14: { |
| enterOuterAlt(_localctx, 14); |
| setState(303); |
| elseif_directive_one_line(); |
| break; |
| } |
| |
| case 15: { |
| enterOuterAlt(_localctx, 15); |
| setState(304); |
| endif_directive_one_line(); |
| break; |
| } |
| |
| case 16: { |
| enterOuterAlt(_localctx, 16); |
| setState(305); |
| include_directive_one_line(); |
| break; |
| } |
| |
| case 17: { |
| enterOuterAlt(_localctx, 17); |
| setState(306); |
| include_directive(); |
| break; |
| } |
| |
| case 18: { |
| enterOuterAlt(_localctx, 18); |
| setState(307); |
| resetall_directive_one_line(); |
| break; |
| } |
| |
| case 19: { |
| enterOuterAlt(_localctx, 19); |
| setState(308); |
| begin_keywords_directive_one_line(); |
| break; |
| } |
| |
| case 20: { |
| enterOuterAlt(_localctx, 20); |
| setState(309); |
| begin_keywords_directive(); |
| break; |
| } |
| |
| case 21: { |
| enterOuterAlt(_localctx, 21); |
| setState(310); |
| end_keywords_directive_one_line(); |
| break; |
| } |
| |
| case 22: { |
| enterOuterAlt(_localctx, 22); |
| setState(311); |
| timescale_directive_one_line(); |
| break; |
| } |
| |
| case 23: { |
| enterOuterAlt(_localctx, 23); |
| setState(312); |
| unconnected_drive_directive_one_line(); |
| break; |
| } |
| |
| case 24: { |
| enterOuterAlt(_localctx, 24); |
| setState(313); |
| nounconnected_drive_directive_one_line(); |
| break; |
| } |
| |
| case 25: { |
| enterOuterAlt(_localctx, 25); |
| setState(314); |
| line_directive_one_line(); |
| break; |
| } |
| |
| case 26: { |
| enterOuterAlt(_localctx, 26); |
| setState(315); |
| default_decay_time_directive_one_line(); |
| break; |
| } |
| |
| case 27: { |
| enterOuterAlt(_localctx, 27); |
| setState(316); |
| default_trireg_strenght_directive_one_line(); |
| break; |
| } |
| |
| case 28: { |
| enterOuterAlt(_localctx, 28); |
| setState(317); |
| delay_mode_distributed_directive_one_line(); |
| break; |
| } |
| |
| case 29: { |
| enterOuterAlt(_localctx, 29); |
| setState(318); |
| delay_mode_path_directive_one_line(); |
| break; |
| } |
| |
| case 30: { |
| enterOuterAlt(_localctx, 30); |
| setState(319); |
| delay_mode_unit_directive_one_line(); |
| break; |
| } |
| |
| case 31: { |
| enterOuterAlt(_localctx, 31); |
| setState(320); |
| delay_mode_zero_directive_one_line(); |
| break; |
| } |
| |
| case 32: { |
| enterOuterAlt(_localctx, 32); |
| setState(321); |
| protect_directive_one_line(); |
| break; |
| } |
| |
| case 33: { |
| enterOuterAlt(_localctx, 33); |
| setState(322); |
| endprotect_directive_one_line(); |
| break; |
| } |
| |
| case 34: { |
| enterOuterAlt(_localctx, 34); |
| setState(323); |
| protected_directive_one_line(); |
| break; |
| } |
| |
| case 35: { |
| enterOuterAlt(_localctx, 35); |
| setState(324); |
| endprotected_directive_one_line(); |
| break; |
| } |
| |
| case 36: { |
| enterOuterAlt(_localctx, 36); |
| setState(325); |
| expand_vectornets_directive_one_line(); |
| break; |
| } |
| |
| case 37: { |
| enterOuterAlt(_localctx, 37); |
| setState(326); |
| noexpand_vectornets_directive_one_line(); |
| break; |
| } |
| |
| case 38: { |
| enterOuterAlt(_localctx, 38); |
| setState(327); |
| autoexpand_vectornets_directive_one_line(); |
| break; |
| } |
| |
| case 39: { |
| enterOuterAlt(_localctx, 39); |
| setState(328); |
| remove_gatename_directive_one_line(); |
| break; |
| } |
| |
| case 40: { |
| enterOuterAlt(_localctx, 40); |
| setState(329); |
| noremove_gatenames_directive_one_line(); |
| break; |
| } |
| |
| case 41: { |
| enterOuterAlt(_localctx, 41); |
| setState(330); |
| remove_netname_directive_one_line(); |
| break; |
| } |
| |
| case 42: { |
| enterOuterAlt(_localctx, 42); |
| setState(331); |
| noremove_netnames_directive_one_line(); |
| break; |
| } |
| |
| case 43: { |
| enterOuterAlt(_localctx, 43); |
| setState(332); |
| accelerate_directive_one_line(); |
| break; |
| } |
| |
| case 44: { |
| enterOuterAlt(_localctx, 44); |
| setState(333); |
| noaccelerate_directive_one_line(); |
| break; |
| } |
| |
| case 45: { |
| enterOuterAlt(_localctx, 45); |
| setState(334); |
| undefineall_directive(); |
| break; |
| } |
| |
| case 46: { |
| enterOuterAlt(_localctx, 46); |
| setState(335); |
| uselib_directive_one_line(); |
| break; |
| } |
| |
| case 47: { |
| enterOuterAlt(_localctx, 47); |
| setState(336); |
| disable_portfaults_directive_one_line(); |
| break; |
| } |
| |
| case 48: { |
| enterOuterAlt(_localctx, 48); |
| setState(337); |
| enable_portfaults_directive_one_line(); |
| break; |
| } |
| |
| case 49: { |
| enterOuterAlt(_localctx, 49); |
| setState(338); |
| nosuppress_faults_directive_one_line(); |
| break; |
| } |
| |
| case 50: { |
| enterOuterAlt(_localctx, 50); |
| setState(339); |
| suppress_faults_directive_one_line(); |
| break; |
| } |
| |
| case 51: { |
| enterOuterAlt(_localctx, 51); |
| setState(340); |
| signed_directive_one_line(); |
| break; |
| } |
| |
| case 52: { |
| enterOuterAlt(_localctx, 52); |
| setState(341); |
| unsigned_directive_one_line(); |
| break; |
| } |
| |
| case 53: { |
| enterOuterAlt(_localctx, 53); |
| setState(342); |
| pragma_directive_one_line(); |
| break; |
| } |
| |
| case 54: { |
| enterOuterAlt(_localctx, 54); |
| setState(343); |
| sv_file_directive(); |
| break; |
| } |
| |
| case 55: { |
| enterOuterAlt(_localctx, 55); |
| setState(344); |
| sv_line_directive(); |
| break; |
| } |
| |
| case 56: { |
| enterOuterAlt(_localctx, 56); |
| setState(345); |
| macro_instance(); |
| break; |
| } |
| |
| case 57: { |
| enterOuterAlt(_localctx, 57); |
| setState(346); |
| module(); |
| break; |
| } |
| |
| case 58: { |
| enterOuterAlt(_localctx, 58); |
| setState(347); |
| endmodule(); |
| break; |
| } |
| |
| case 59: { |
| enterOuterAlt(_localctx, 59); |
| setState(348); |
| sv_interface(); |
| break; |
| } |
| |
| case 60: { |
| enterOuterAlt(_localctx, 60); |
| setState(349); |
| endinterface(); |
| break; |
| } |
| |
| case 61: { |
| enterOuterAlt(_localctx, 61); |
| setState(350); |
| program(); |
| break; |
| } |
| |
| case 62: { |
| enterOuterAlt(_localctx, 62); |
| setState(351); |
| endprogram(); |
| break; |
| } |
| |
| case 63: { |
| enterOuterAlt(_localctx, 63); |
| setState(352); |
| primitive(); |
| break; |
| } |
| |
| case 64: { |
| enterOuterAlt(_localctx, 64); |
| setState(353); |
| endprimitive(); |
| break; |
| } |
| |
| case 65: { |
| enterOuterAlt(_localctx, 65); |
| setState(354); |
| sv_package(); |
| break; |
| } |
| |
| case 66: { |
| enterOuterAlt(_localctx, 66); |
| setState(355); |
| endpackage(); |
| break; |
| } |
| |
| case 67: { |
| enterOuterAlt(_localctx, 67); |
| setState(356); |
| checker(); |
| break; |
| } |
| |
| case 68: { |
| enterOuterAlt(_localctx, 68); |
| setState(357); |
| endchecker(); |
| break; |
| } |
| |
| case 69: { |
| enterOuterAlt(_localctx, 69); |
| setState(358); |
| config(); |
| break; |
| } |
| |
| case 70: { |
| enterOuterAlt(_localctx, 70); |
| setState(359); |
| endconfig(); |
| break; |
| } |
| |
| case 71: { |
| enterOuterAlt(_localctx, 71); |
| setState(360); |
| text_blob(); |
| break; |
| } |
| |
| case 72: { |
| enterOuterAlt(_localctx, 72); |
| setState(361); |
| escaped_identifier(); |
| break; |
| } |
| |
| case 73: { |
| enterOuterAlt(_localctx, 73); |
| setState(362); |
| pound_delay(); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Macro_instanceContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Macro_instanceContext::Macro_instanceContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| |
| size_t SV3_1aPpParser::Macro_instanceContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleMacro_instance; |
| } |
| |
| void SV3_1aPpParser::Macro_instanceContext::copyFrom(Macro_instanceContext *ctx) { |
| ParserRuleContext::copyFrom(ctx); |
| } |
| |
| //----------------- MacroInstanceWithArgsContext ------------------------------------------------------------------ |
| |
| tree::TerminalNode* SV3_1aPpParser::MacroInstanceWithArgsContext::PARENS_OPEN() { |
| return getToken(SV3_1aPpParser::PARENS_OPEN, 0); |
| } |
| |
| SV3_1aPpParser::Macro_actual_argsContext* SV3_1aPpParser::MacroInstanceWithArgsContext::macro_actual_args() { |
| return getRuleContext<SV3_1aPpParser::Macro_actual_argsContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::MacroInstanceWithArgsContext::PARENS_CLOSE() { |
| return getToken(SV3_1aPpParser::PARENS_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::MacroInstanceWithArgsContext::Macro_identifier() { |
| return getToken(SV3_1aPpParser::Macro_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::MacroInstanceWithArgsContext::Macro_Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Macro_Escaped_identifier, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::MacroInstanceWithArgsContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::MacroInstanceWithArgsContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| SV3_1aPpParser::MacroInstanceWithArgsContext::MacroInstanceWithArgsContext(Macro_instanceContext *ctx) { copyFrom(ctx); } |
| |
| void SV3_1aPpParser::MacroInstanceWithArgsContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterMacroInstanceWithArgs(this); |
| } |
| void SV3_1aPpParser::MacroInstanceWithArgsContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitMacroInstanceWithArgs(this); |
| } |
| //----------------- MacroInstanceNoArgsContext ------------------------------------------------------------------ |
| |
| tree::TerminalNode* SV3_1aPpParser::MacroInstanceNoArgsContext::Macro_identifier() { |
| return getToken(SV3_1aPpParser::Macro_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::MacroInstanceNoArgsContext::Macro_Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Macro_Escaped_identifier, 0); |
| } |
| |
| SV3_1aPpParser::MacroInstanceNoArgsContext::MacroInstanceNoArgsContext(Macro_instanceContext *ctx) { copyFrom(ctx); } |
| |
| void SV3_1aPpParser::MacroInstanceNoArgsContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterMacroInstanceNoArgs(this); |
| } |
| void SV3_1aPpParser::MacroInstanceNoArgsContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitMacroInstanceNoArgs(this); |
| } |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::macro_instance() { |
| Macro_instanceContext *_localctx = _tracker.createInstance<Macro_instanceContext>(_ctx, getState()); |
| enterRule(_localctx, 4, SV3_1aPpParser::RuleMacro_instance); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(377); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 3, _ctx)) { |
| case 1: { |
| _localctx = dynamic_cast<Macro_instanceContext *>(_tracker.createInstance<SV3_1aPpParser::MacroInstanceWithArgsContext>(_localctx)); |
| enterOuterAlt(_localctx, 1); |
| setState(365); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::Macro_identifier |
| |
| || _la == SV3_1aPpParser::Macro_Escaped_identifier)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| setState(369); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(366); |
| match(SV3_1aPpParser::Spaces); |
| setState(371); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(372); |
| match(SV3_1aPpParser::PARENS_OPEN); |
| setState(373); |
| macro_actual_args(); |
| setState(374); |
| match(SV3_1aPpParser::PARENS_CLOSE); |
| break; |
| } |
| |
| case 2: { |
| _localctx = dynamic_cast<Macro_instanceContext *>(_tracker.createInstance<SV3_1aPpParser::MacroInstanceNoArgsContext>(_localctx)); |
| enterOuterAlt(_localctx, 2); |
| setState(376); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::Macro_identifier |
| |
| || _la == SV3_1aPpParser::Macro_Escaped_identifier)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Unterminated_stringContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Unterminated_stringContext::Unterminated_stringContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Unterminated_stringContext::DOUBLE_QUOTE() { |
| return getToken(SV3_1aPpParser::DOUBLE_QUOTE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Unterminated_stringContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<SV3_1aPpParser::String_blobContext *> SV3_1aPpParser::Unterminated_stringContext::string_blob() { |
| return getRuleContexts<SV3_1aPpParser::String_blobContext>(); |
| } |
| |
| SV3_1aPpParser::String_blobContext* SV3_1aPpParser::Unterminated_stringContext::string_blob(size_t i) { |
| return getRuleContext<SV3_1aPpParser::String_blobContext>(i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Unterminated_stringContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleUnterminated_string; |
| } |
| |
| void SV3_1aPpParser::Unterminated_stringContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterUnterminated_string(this); |
| } |
| |
| void SV3_1aPpParser::Unterminated_stringContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitUnterminated_string(this); |
| } |
| |
| SV3_1aPpParser::Unterminated_stringContext* SV3_1aPpParser::unterminated_string() { |
| Unterminated_stringContext *_localctx = _tracker.createInstance<Unterminated_stringContext>(_ctx, getState()); |
| enterRule(_localctx, 6, SV3_1aPpParser::RuleUnterminated_string); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(379); |
| match(SV3_1aPpParser::DOUBLE_QUOTE); |
| setState(383); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (((((_la - 70) & ~ 0x3fULL) == 0) && |
| ((1ULL << (_la - 70)) & ((1ULL << (SV3_1aPpParser::Simple_identifier - 70)) |
| | (1ULL << (SV3_1aPpParser::Spaces - 70)) |
| | (1ULL << (SV3_1aPpParser::Pound_delay - 70)) |
| | (1ULL << (SV3_1aPpParser::TIMESCALE - 70)) |
| | (1ULL << (SV3_1aPpParser::Number - 70)) |
| | (1ULL << (SV3_1aPpParser::Fixed_point_number - 70)) |
| | (1ULL << (SV3_1aPpParser::TEXT_CR - 70)) |
| | (1ULL << (SV3_1aPpParser::ESCAPED_CR - 70)) |
| | (1ULL << (SV3_1aPpParser::PARENS_OPEN - 70)) |
| | (1ULL << (SV3_1aPpParser::PARENS_CLOSE - 70)) |
| | (1ULL << (SV3_1aPpParser::COMMA - 70)) |
| | (1ULL << (SV3_1aPpParser::EQUAL_OP - 70)) |
| | (1ULL << (SV3_1aPpParser::DOUBLE_QUOTE - 70)) |
| | (1ULL << (SV3_1aPpParser::Escaped_identifier - 70)) |
| | (1ULL << (SV3_1aPpParser::CURLY_OPEN - 70)) |
| | (1ULL << (SV3_1aPpParser::CURLY_CLOSE - 70)) |
| | (1ULL << (SV3_1aPpParser::SQUARE_OPEN - 70)) |
| | (1ULL << (SV3_1aPpParser::SQUARE_CLOSE - 70)) |
| | (1ULL << (SV3_1aPpParser::Special - 70)) |
| | (1ULL << (SV3_1aPpParser::ANY - 70)))) != 0)) { |
| setState(380); |
| string_blob(); |
| setState(385); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(386); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Macro_actual_argsContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Macro_actual_argsContext::Macro_actual_argsContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| std::vector<SV3_1aPpParser::Macro_argContext *> SV3_1aPpParser::Macro_actual_argsContext::macro_arg() { |
| return getRuleContexts<SV3_1aPpParser::Macro_argContext>(); |
| } |
| |
| SV3_1aPpParser::Macro_argContext* SV3_1aPpParser::Macro_actual_argsContext::macro_arg(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Macro_argContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Macro_actual_argsContext::COMMA() { |
| return getTokens(SV3_1aPpParser::COMMA); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_actual_argsContext::COMMA(size_t i) { |
| return getToken(SV3_1aPpParser::COMMA, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Macro_actual_argsContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleMacro_actual_args; |
| } |
| |
| void SV3_1aPpParser::Macro_actual_argsContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterMacro_actual_args(this); |
| } |
| |
| void SV3_1aPpParser::Macro_actual_argsContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitMacro_actual_args(this); |
| } |
| |
| SV3_1aPpParser::Macro_actual_argsContext* SV3_1aPpParser::macro_actual_args() { |
| Macro_actual_argsContext *_localctx = _tracker.createInstance<Macro_actual_argsContext>(_ctx, getState()); |
| enterRule(_localctx, 8, SV3_1aPpParser::RuleMacro_actual_args); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(391); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(388); |
| macro_arg(); |
| } |
| setState(393); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx); |
| } |
| setState(398); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::COMMA) { |
| setState(394); |
| match(SV3_1aPpParser::COMMA); |
| setState(395); |
| macro_arg(); |
| setState(400); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- CommentsContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::CommentsContext::CommentsContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::CommentsContext::One_line_comment() { |
| return getToken(SV3_1aPpParser::One_line_comment, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::CommentsContext::Block_comment() { |
| return getToken(SV3_1aPpParser::Block_comment, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::CommentsContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleComments; |
| } |
| |
| void SV3_1aPpParser::CommentsContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterComments(this); |
| } |
| |
| void SV3_1aPpParser::CommentsContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitComments(this); |
| } |
| |
| SV3_1aPpParser::CommentsContext* SV3_1aPpParser::comments() { |
| CommentsContext *_localctx = _tracker.createInstance<CommentsContext>(_ctx, getState()); |
| enterRule(_localctx, 10, SV3_1aPpParser::RuleComments); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(401); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::One_line_comment |
| |
| || _la == SV3_1aPpParser::Block_comment)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- NumberContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::NumberContext::NumberContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::NumberContext::Number() { |
| return getToken(SV3_1aPpParser::Number, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::NumberContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNumber; |
| } |
| |
| void SV3_1aPpParser::NumberContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNumber(this); |
| } |
| |
| void SV3_1aPpParser::NumberContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNumber(this); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::number() { |
| NumberContext *_localctx = _tracker.createInstance<NumberContext>(_ctx, getState()); |
| enterRule(_localctx, 12, SV3_1aPpParser::RuleNumber); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(403); |
| match(SV3_1aPpParser::Number); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Pound_delayContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Pound_delayContext::Pound_delayContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pound_delayContext::Pound_delay() { |
| return getToken(SV3_1aPpParser::Pound_delay, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Pound_delayContext::getRuleIndex() const { |
| return SV3_1aPpParser::RulePound_delay; |
| } |
| |
| void SV3_1aPpParser::Pound_delayContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterPound_delay(this); |
| } |
| |
| void SV3_1aPpParser::Pound_delayContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitPound_delay(this); |
| } |
| |
| SV3_1aPpParser::Pound_delayContext* SV3_1aPpParser::pound_delay() { |
| Pound_delayContext *_localctx = _tracker.createInstance<Pound_delayContext>(_ctx, getState()); |
| enterRule(_localctx, 14, SV3_1aPpParser::RulePound_delay); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(405); |
| match(SV3_1aPpParser::Pound_delay); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Macro_definitionContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Macro_definitionContext::Macro_definitionContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Define_directiveContext* SV3_1aPpParser::Macro_definitionContext::define_directive() { |
| return getRuleContext<SV3_1aPpParser::Define_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Multiline_args_macro_definitionContext* SV3_1aPpParser::Macro_definitionContext::multiline_args_macro_definition() { |
| return getRuleContext<SV3_1aPpParser::Multiline_args_macro_definitionContext>(0); |
| } |
| |
| SV3_1aPpParser::Simple_no_args_macro_definitionContext* SV3_1aPpParser::Macro_definitionContext::simple_no_args_macro_definition() { |
| return getRuleContext<SV3_1aPpParser::Simple_no_args_macro_definitionContext>(0); |
| } |
| |
| SV3_1aPpParser::Multiline_no_args_macro_definitionContext* SV3_1aPpParser::Macro_definitionContext::multiline_no_args_macro_definition() { |
| return getRuleContext<SV3_1aPpParser::Multiline_no_args_macro_definitionContext>(0); |
| } |
| |
| SV3_1aPpParser::Simple_args_macro_definitionContext* SV3_1aPpParser::Macro_definitionContext::simple_args_macro_definition() { |
| return getRuleContext<SV3_1aPpParser::Simple_args_macro_definitionContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Macro_definitionContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleMacro_definition; |
| } |
| |
| void SV3_1aPpParser::Macro_definitionContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterMacro_definition(this); |
| } |
| |
| void SV3_1aPpParser::Macro_definitionContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitMacro_definition(this); |
| } |
| |
| SV3_1aPpParser::Macro_definitionContext* SV3_1aPpParser::macro_definition() { |
| Macro_definitionContext *_localctx = _tracker.createInstance<Macro_definitionContext>(_ctx, getState()); |
| enterRule(_localctx, 16, SV3_1aPpParser::RuleMacro_definition); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(412); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) { |
| case 1: { |
| enterOuterAlt(_localctx, 1); |
| setState(407); |
| define_directive(); |
| break; |
| } |
| |
| case 2: { |
| enterOuterAlt(_localctx, 2); |
| setState(408); |
| multiline_args_macro_definition(); |
| break; |
| } |
| |
| case 3: { |
| enterOuterAlt(_localctx, 3); |
| setState(409); |
| simple_no_args_macro_definition(); |
| break; |
| } |
| |
| case 4: { |
| enterOuterAlt(_localctx, 4); |
| setState(410); |
| multiline_no_args_macro_definition(); |
| break; |
| } |
| |
| case 5: { |
| enterOuterAlt(_localctx, 5); |
| setState(411); |
| simple_args_macro_definition(); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Include_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Include_directive_one_lineContext::Include_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Include_directiveContext* SV3_1aPpParser::Include_directive_one_lineContext::include_directive() { |
| return getRuleContext<SV3_1aPpParser::Include_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Include_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Include_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Include_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Include_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleInclude_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Include_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterInclude_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Include_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitInclude_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Include_directive_one_lineContext* SV3_1aPpParser::include_directive_one_line() { |
| Include_directive_one_lineContext *_localctx = _tracker.createInstance<Include_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 18, SV3_1aPpParser::RuleInclude_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(414); |
| include_directive(); |
| setState(418); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(415); |
| match(SV3_1aPpParser::Spaces); |
| setState(420); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(421); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Include_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Include_directiveContext::Include_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Include_directiveContext::TICK_INCLUDE() { |
| return getToken(SV3_1aPpParser::TICK_INCLUDE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Include_directiveContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Include_directiveContext::String() { |
| return getToken(SV3_1aPpParser::String, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Include_directiveContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Include_directiveContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::Include_directiveContext::macro_instance() { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Include_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleInclude_directive; |
| } |
| |
| void SV3_1aPpParser::Include_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterInclude_directive(this); |
| } |
| |
| void SV3_1aPpParser::Include_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitInclude_directive(this); |
| } |
| |
| SV3_1aPpParser::Include_directiveContext* SV3_1aPpParser::include_directive() { |
| Include_directiveContext *_localctx = _tracker.createInstance<Include_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 20, SV3_1aPpParser::RuleInclude_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(423); |
| match(SV3_1aPpParser::TICK_INCLUDE); |
| setState(424); |
| match(SV3_1aPpParser::Spaces); |
| setState(429); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::String: { |
| setState(425); |
| match(SV3_1aPpParser::String); |
| break; |
| } |
| |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(426); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(427); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(428); |
| macro_instance(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Line_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Line_directive_one_lineContext::Line_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Line_directiveContext* SV3_1aPpParser::Line_directive_one_lineContext::line_directive() { |
| return getRuleContext<SV3_1aPpParser::Line_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Line_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Line_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Line_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Line_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleLine_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Line_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterLine_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Line_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitLine_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Line_directive_one_lineContext* SV3_1aPpParser::line_directive_one_line() { |
| Line_directive_one_lineContext *_localctx = _tracker.createInstance<Line_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 22, SV3_1aPpParser::RuleLine_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(431); |
| line_directive(); |
| setState(435); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(432); |
| match(SV3_1aPpParser::Spaces); |
| setState(437); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(438); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Line_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Line_directiveContext::Line_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Line_directiveContext::TICK_LINE() { |
| return getToken(SV3_1aPpParser::TICK_LINE, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Line_directiveContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Line_directiveContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| std::vector<SV3_1aPpParser::NumberContext *> SV3_1aPpParser::Line_directiveContext::number() { |
| return getRuleContexts<SV3_1aPpParser::NumberContext>(); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::Line_directiveContext::number(size_t i) { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(i); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Line_directiveContext::String() { |
| return getToken(SV3_1aPpParser::String, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Line_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleLine_directive; |
| } |
| |
| void SV3_1aPpParser::Line_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterLine_directive(this); |
| } |
| |
| void SV3_1aPpParser::Line_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitLine_directive(this); |
| } |
| |
| SV3_1aPpParser::Line_directiveContext* SV3_1aPpParser::line_directive() { |
| Line_directiveContext *_localctx = _tracker.createInstance<Line_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 24, SV3_1aPpParser::RuleLine_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(440); |
| match(SV3_1aPpParser::TICK_LINE); |
| setState(441); |
| match(SV3_1aPpParser::Spaces); |
| setState(442); |
| number(); |
| setState(443); |
| match(SV3_1aPpParser::String); |
| setState(444); |
| match(SV3_1aPpParser::Spaces); |
| setState(445); |
| number(); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Default_nettype_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Default_nettype_directive_one_lineContext::Default_nettype_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Default_nettype_directiveContext* SV3_1aPpParser::Default_nettype_directive_one_lineContext::default_nettype_directive() { |
| return getRuleContext<SV3_1aPpParser::Default_nettype_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_nettype_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Default_nettype_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_nettype_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Default_nettype_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDefault_nettype_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Default_nettype_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDefault_nettype_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Default_nettype_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDefault_nettype_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Default_nettype_directive_one_lineContext* SV3_1aPpParser::default_nettype_directive_one_line() { |
| Default_nettype_directive_one_lineContext *_localctx = _tracker.createInstance<Default_nettype_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 26, SV3_1aPpParser::RuleDefault_nettype_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(447); |
| default_nettype_directive(); |
| setState(451); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(448); |
| match(SV3_1aPpParser::Spaces); |
| setState(453); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(454); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Default_nettype_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Default_nettype_directiveContext::Default_nettype_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_nettype_directiveContext::TICK_DEFAULT_NETTYPE() { |
| return getToken(SV3_1aPpParser::TICK_DEFAULT_NETTYPE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_nettype_directiveContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_nettype_directiveContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Default_nettype_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDefault_nettype_directive; |
| } |
| |
| void SV3_1aPpParser::Default_nettype_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDefault_nettype_directive(this); |
| } |
| |
| void SV3_1aPpParser::Default_nettype_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDefault_nettype_directive(this); |
| } |
| |
| SV3_1aPpParser::Default_nettype_directiveContext* SV3_1aPpParser::default_nettype_directive() { |
| Default_nettype_directiveContext *_localctx = _tracker.createInstance<Default_nettype_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 28, SV3_1aPpParser::RuleDefault_nettype_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(456); |
| match(SV3_1aPpParser::TICK_DEFAULT_NETTYPE); |
| setState(457); |
| match(SV3_1aPpParser::Spaces); |
| setState(458); |
| match(SV3_1aPpParser::Simple_identifier); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Sv_file_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Sv_file_directiveContext::Sv_file_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Sv_file_directiveContext::TICK_FILE__() { |
| return getToken(SV3_1aPpParser::TICK_FILE__, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Sv_file_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSv_file_directive; |
| } |
| |
| void SV3_1aPpParser::Sv_file_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSv_file_directive(this); |
| } |
| |
| void SV3_1aPpParser::Sv_file_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSv_file_directive(this); |
| } |
| |
| SV3_1aPpParser::Sv_file_directiveContext* SV3_1aPpParser::sv_file_directive() { |
| Sv_file_directiveContext *_localctx = _tracker.createInstance<Sv_file_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 30, SV3_1aPpParser::RuleSv_file_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(460); |
| match(SV3_1aPpParser::TICK_FILE__); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Sv_line_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Sv_line_directiveContext::Sv_line_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Sv_line_directiveContext::TICK_LINE__() { |
| return getToken(SV3_1aPpParser::TICK_LINE__, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Sv_line_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSv_line_directive; |
| } |
| |
| void SV3_1aPpParser::Sv_line_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSv_line_directive(this); |
| } |
| |
| void SV3_1aPpParser::Sv_line_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSv_line_directive(this); |
| } |
| |
| SV3_1aPpParser::Sv_line_directiveContext* SV3_1aPpParser::sv_line_directive() { |
| Sv_line_directiveContext *_localctx = _tracker.createInstance<Sv_line_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 32, SV3_1aPpParser::RuleSv_line_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(462); |
| match(SV3_1aPpParser::TICK_LINE__); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Timescale_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Timescale_directive_one_lineContext::Timescale_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Timescale_directiveContext* SV3_1aPpParser::Timescale_directive_one_lineContext::timescale_directive() { |
| return getRuleContext<SV3_1aPpParser::Timescale_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Timescale_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Timescale_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Timescale_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Timescale_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleTimescale_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Timescale_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterTimescale_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Timescale_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitTimescale_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Timescale_directive_one_lineContext* SV3_1aPpParser::timescale_directive_one_line() { |
| Timescale_directive_one_lineContext *_localctx = _tracker.createInstance<Timescale_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 34, SV3_1aPpParser::RuleTimescale_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(464); |
| timescale_directive(); |
| setState(468); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(465); |
| match(SV3_1aPpParser::Spaces); |
| setState(470); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(471); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Timescale_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Timescale_directiveContext::Timescale_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Timescale_directiveContext::TICK_TIMESCALE() { |
| return getToken(SV3_1aPpParser::TICK_TIMESCALE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Timescale_directiveContext::TIMESCALE() { |
| return getToken(SV3_1aPpParser::TIMESCALE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Timescale_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleTimescale_directive; |
| } |
| |
| void SV3_1aPpParser::Timescale_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterTimescale_directive(this); |
| } |
| |
| void SV3_1aPpParser::Timescale_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitTimescale_directive(this); |
| } |
| |
| SV3_1aPpParser::Timescale_directiveContext* SV3_1aPpParser::timescale_directive() { |
| Timescale_directiveContext *_localctx = _tracker.createInstance<Timescale_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 36, SV3_1aPpParser::RuleTimescale_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(473); |
| match(SV3_1aPpParser::TICK_TIMESCALE); |
| setState(474); |
| match(SV3_1aPpParser::TIMESCALE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Undef_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Undef_directiveContext::Undef_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Undef_directiveContext::TICK_UNDEF() { |
| return getToken(SV3_1aPpParser::TICK_UNDEF, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Undef_directiveContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Undef_directiveContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Undef_directiveContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::Undef_directiveContext::macro_instance() { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Undef_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleUndef_directive; |
| } |
| |
| void SV3_1aPpParser::Undef_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterUndef_directive(this); |
| } |
| |
| void SV3_1aPpParser::Undef_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitUndef_directive(this); |
| } |
| |
| SV3_1aPpParser::Undef_directiveContext* SV3_1aPpParser::undef_directive() { |
| Undef_directiveContext *_localctx = _tracker.createInstance<Undef_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 38, SV3_1aPpParser::RuleUndef_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(476); |
| match(SV3_1aPpParser::TICK_UNDEF); |
| setState(477); |
| match(SV3_1aPpParser::Spaces); |
| setState(481); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(478); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(479); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(480); |
| macro_instance(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Ifdef_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Ifdef_directive_one_lineContext::Ifdef_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Ifdef_directiveContext* SV3_1aPpParser::Ifdef_directive_one_lineContext::ifdef_directive() { |
| return getRuleContext<SV3_1aPpParser::Ifdef_directiveContext>(0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Ifdef_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifdef_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifdef_directive_one_lineContext::One_line_comment() { |
| return getToken(SV3_1aPpParser::One_line_comment, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifdef_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| SV3_1aPpParser::Endif_directiveContext* SV3_1aPpParser::Ifdef_directive_one_lineContext::endif_directive() { |
| return getRuleContext<SV3_1aPpParser::Endif_directiveContext>(0); |
| } |
| |
| std::vector<SV3_1aPpParser::DescriptionContext *> SV3_1aPpParser::Ifdef_directive_one_lineContext::description() { |
| return getRuleContexts<SV3_1aPpParser::DescriptionContext>(); |
| } |
| |
| SV3_1aPpParser::DescriptionContext* SV3_1aPpParser::Ifdef_directive_one_lineContext::description(size_t i) { |
| return getRuleContext<SV3_1aPpParser::DescriptionContext>(i); |
| } |
| |
| std::vector<SV3_1aPpParser::Else_directiveContext *> SV3_1aPpParser::Ifdef_directive_one_lineContext::else_directive() { |
| return getRuleContexts<SV3_1aPpParser::Else_directiveContext>(); |
| } |
| |
| SV3_1aPpParser::Else_directiveContext* SV3_1aPpParser::Ifdef_directive_one_lineContext::else_directive(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Else_directiveContext>(i); |
| } |
| |
| std::vector<SV3_1aPpParser::Elseif_directiveContext *> SV3_1aPpParser::Ifdef_directive_one_lineContext::elseif_directive() { |
| return getRuleContexts<SV3_1aPpParser::Elseif_directiveContext>(); |
| } |
| |
| SV3_1aPpParser::Elseif_directiveContext* SV3_1aPpParser::Ifdef_directive_one_lineContext::elseif_directive(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Elseif_directiveContext>(i); |
| } |
| |
| std::vector<SV3_1aPpParser::Elsif_directiveContext *> SV3_1aPpParser::Ifdef_directive_one_lineContext::elsif_directive() { |
| return getRuleContexts<SV3_1aPpParser::Elsif_directiveContext>(); |
| } |
| |
| SV3_1aPpParser::Elsif_directiveContext* SV3_1aPpParser::Ifdef_directive_one_lineContext::elsif_directive(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Elsif_directiveContext>(i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Ifdef_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleIfdef_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Ifdef_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterIfdef_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Ifdef_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitIfdef_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Ifdef_directive_one_lineContext* SV3_1aPpParser::ifdef_directive_one_line() { |
| Ifdef_directive_one_lineContext *_localctx = _tracker.createInstance<Ifdef_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 40, SV3_1aPpParser::RuleIfdef_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(483); |
| ifdef_directive(); |
| setState(487); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 14, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(484); |
| match(SV3_1aPpParser::Spaces); |
| } |
| setState(489); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 14, _ctx); |
| } |
| setState(513); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 19, _ctx)) { |
| case 1: { |
| setState(490); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::One_line_comment || _la == SV3_1aPpParser::CR)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| break; |
| } |
| |
| case 2: { |
| setState(494); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 15, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(491); |
| description(); |
| } |
| setState(496); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 15, _ctx); |
| } |
| setState(509); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(500); |
| _errHandler->sync(this); |
| |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 16, _ctx)) { |
| case 1: { |
| setState(497); |
| else_directive(); |
| break; |
| } |
| |
| case 2: { |
| setState(498); |
| elseif_directive(); |
| break; |
| } |
| |
| case 3: { |
| setState(499); |
| elsif_directive(); |
| break; |
| } |
| |
| } |
| setState(503); |
| _errHandler->sync(this); |
| alt = 1; |
| do { |
| switch (alt) { |
| case 1: { |
| setState(502); |
| description(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| setState(505); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 17, _ctx); |
| } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); |
| } |
| setState(511); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx); |
| } |
| setState(512); |
| endif_directive(); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Ifdef_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Ifdef_directiveContext::Ifdef_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifdef_directiveContext::TICK_IFDEF() { |
| return getToken(SV3_1aPpParser::TICK_IFDEF, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifdef_directiveContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifdef_directiveContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifdef_directiveContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::Ifdef_directiveContext::macro_instance() { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Ifdef_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleIfdef_directive; |
| } |
| |
| void SV3_1aPpParser::Ifdef_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterIfdef_directive(this); |
| } |
| |
| void SV3_1aPpParser::Ifdef_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitIfdef_directive(this); |
| } |
| |
| SV3_1aPpParser::Ifdef_directiveContext* SV3_1aPpParser::ifdef_directive() { |
| Ifdef_directiveContext *_localctx = _tracker.createInstance<Ifdef_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 42, SV3_1aPpParser::RuleIfdef_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(515); |
| match(SV3_1aPpParser::TICK_IFDEF); |
| setState(516); |
| match(SV3_1aPpParser::Spaces); |
| setState(520); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(517); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(518); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(519); |
| macro_instance(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Ifdef_directive_in_macro_bodyContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Ifdef_directive_in_macro_bodyContext::Ifdef_directive_in_macro_bodyContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifdef_directive_in_macro_bodyContext::TICK_IFDEF() { |
| return getToken(SV3_1aPpParser::TICK_IFDEF, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifdef_directive_in_macro_bodyContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| SV3_1aPpParser::Identifier_in_macro_bodyContext* SV3_1aPpParser::Ifdef_directive_in_macro_bodyContext::identifier_in_macro_body() { |
| return getRuleContext<SV3_1aPpParser::Identifier_in_macro_bodyContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifdef_directive_in_macro_bodyContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::Ifdef_directive_in_macro_bodyContext::macro_instance() { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Ifdef_directive_in_macro_bodyContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleIfdef_directive_in_macro_body; |
| } |
| |
| void SV3_1aPpParser::Ifdef_directive_in_macro_bodyContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterIfdef_directive_in_macro_body(this); |
| } |
| |
| void SV3_1aPpParser::Ifdef_directive_in_macro_bodyContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitIfdef_directive_in_macro_body(this); |
| } |
| |
| SV3_1aPpParser::Ifdef_directive_in_macro_bodyContext* SV3_1aPpParser::ifdef_directive_in_macro_body() { |
| Ifdef_directive_in_macro_bodyContext *_localctx = _tracker.createInstance<Ifdef_directive_in_macro_bodyContext>(_ctx, getState()); |
| enterRule(_localctx, 44, SV3_1aPpParser::RuleIfdef_directive_in_macro_body); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(522); |
| match(SV3_1aPpParser::TICK_IFDEF); |
| setState(523); |
| match(SV3_1aPpParser::Spaces); |
| setState(527); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::EOF: |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(524); |
| identifier_in_macro_body(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(525); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(526); |
| macro_instance(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Ifndef_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Ifndef_directive_one_lineContext::Ifndef_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Ifndef_directiveContext* SV3_1aPpParser::Ifndef_directive_one_lineContext::ifndef_directive() { |
| return getRuleContext<SV3_1aPpParser::Ifndef_directiveContext>(0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Ifndef_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifndef_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifndef_directive_one_lineContext::One_line_comment() { |
| return getToken(SV3_1aPpParser::One_line_comment, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifndef_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| SV3_1aPpParser::Endif_directiveContext* SV3_1aPpParser::Ifndef_directive_one_lineContext::endif_directive() { |
| return getRuleContext<SV3_1aPpParser::Endif_directiveContext>(0); |
| } |
| |
| std::vector<SV3_1aPpParser::DescriptionContext *> SV3_1aPpParser::Ifndef_directive_one_lineContext::description() { |
| return getRuleContexts<SV3_1aPpParser::DescriptionContext>(); |
| } |
| |
| SV3_1aPpParser::DescriptionContext* SV3_1aPpParser::Ifndef_directive_one_lineContext::description(size_t i) { |
| return getRuleContext<SV3_1aPpParser::DescriptionContext>(i); |
| } |
| |
| std::vector<SV3_1aPpParser::Else_directiveContext *> SV3_1aPpParser::Ifndef_directive_one_lineContext::else_directive() { |
| return getRuleContexts<SV3_1aPpParser::Else_directiveContext>(); |
| } |
| |
| SV3_1aPpParser::Else_directiveContext* SV3_1aPpParser::Ifndef_directive_one_lineContext::else_directive(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Else_directiveContext>(i); |
| } |
| |
| std::vector<SV3_1aPpParser::Elseif_directiveContext *> SV3_1aPpParser::Ifndef_directive_one_lineContext::elseif_directive() { |
| return getRuleContexts<SV3_1aPpParser::Elseif_directiveContext>(); |
| } |
| |
| SV3_1aPpParser::Elseif_directiveContext* SV3_1aPpParser::Ifndef_directive_one_lineContext::elseif_directive(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Elseif_directiveContext>(i); |
| } |
| |
| std::vector<SV3_1aPpParser::Elsif_directiveContext *> SV3_1aPpParser::Ifndef_directive_one_lineContext::elsif_directive() { |
| return getRuleContexts<SV3_1aPpParser::Elsif_directiveContext>(); |
| } |
| |
| SV3_1aPpParser::Elsif_directiveContext* SV3_1aPpParser::Ifndef_directive_one_lineContext::elsif_directive(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Elsif_directiveContext>(i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Ifndef_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleIfndef_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Ifndef_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterIfndef_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Ifndef_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitIfndef_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Ifndef_directive_one_lineContext* SV3_1aPpParser::ifndef_directive_one_line() { |
| Ifndef_directive_one_lineContext *_localctx = _tracker.createInstance<Ifndef_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 46, SV3_1aPpParser::RuleIfndef_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(529); |
| ifndef_directive(); |
| setState(533); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(530); |
| match(SV3_1aPpParser::Spaces); |
| } |
| setState(535); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx); |
| } |
| setState(559); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx)) { |
| case 1: { |
| setState(536); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::One_line_comment || _la == SV3_1aPpParser::CR)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| break; |
| } |
| |
| case 2: { |
| setState(540); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 23, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(537); |
| description(); |
| } |
| setState(542); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 23, _ctx); |
| } |
| setState(555); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 26, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(546); |
| _errHandler->sync(this); |
| |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 24, _ctx)) { |
| case 1: { |
| setState(543); |
| else_directive(); |
| break; |
| } |
| |
| case 2: { |
| setState(544); |
| elseif_directive(); |
| break; |
| } |
| |
| case 3: { |
| setState(545); |
| elsif_directive(); |
| break; |
| } |
| |
| } |
| setState(549); |
| _errHandler->sync(this); |
| alt = 1; |
| do { |
| switch (alt) { |
| case 1: { |
| setState(548); |
| description(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| setState(551); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 25, _ctx); |
| } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); |
| } |
| setState(557); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 26, _ctx); |
| } |
| setState(558); |
| endif_directive(); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Ifndef_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Ifndef_directiveContext::Ifndef_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifndef_directiveContext::TICK_IFNDEF() { |
| return getToken(SV3_1aPpParser::TICK_IFNDEF, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifndef_directiveContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifndef_directiveContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifndef_directiveContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::Ifndef_directiveContext::macro_instance() { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Ifndef_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleIfndef_directive; |
| } |
| |
| void SV3_1aPpParser::Ifndef_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterIfndef_directive(this); |
| } |
| |
| void SV3_1aPpParser::Ifndef_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitIfndef_directive(this); |
| } |
| |
| SV3_1aPpParser::Ifndef_directiveContext* SV3_1aPpParser::ifndef_directive() { |
| Ifndef_directiveContext *_localctx = _tracker.createInstance<Ifndef_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 48, SV3_1aPpParser::RuleIfndef_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(561); |
| match(SV3_1aPpParser::TICK_IFNDEF); |
| setState(562); |
| match(SV3_1aPpParser::Spaces); |
| setState(566); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(563); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(564); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(565); |
| macro_instance(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Ifndef_directive_in_macro_bodyContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Ifndef_directive_in_macro_bodyContext::Ifndef_directive_in_macro_bodyContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifndef_directive_in_macro_bodyContext::TICK_IFNDEF() { |
| return getToken(SV3_1aPpParser::TICK_IFNDEF, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifndef_directive_in_macro_bodyContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| SV3_1aPpParser::Identifier_in_macro_bodyContext* SV3_1aPpParser::Ifndef_directive_in_macro_bodyContext::identifier_in_macro_body() { |
| return getRuleContext<SV3_1aPpParser::Identifier_in_macro_bodyContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Ifndef_directive_in_macro_bodyContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::Ifndef_directive_in_macro_bodyContext::macro_instance() { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Ifndef_directive_in_macro_bodyContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleIfndef_directive_in_macro_body; |
| } |
| |
| void SV3_1aPpParser::Ifndef_directive_in_macro_bodyContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterIfndef_directive_in_macro_body(this); |
| } |
| |
| void SV3_1aPpParser::Ifndef_directive_in_macro_bodyContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitIfndef_directive_in_macro_body(this); |
| } |
| |
| SV3_1aPpParser::Ifndef_directive_in_macro_bodyContext* SV3_1aPpParser::ifndef_directive_in_macro_body() { |
| Ifndef_directive_in_macro_bodyContext *_localctx = _tracker.createInstance<Ifndef_directive_in_macro_bodyContext>(_ctx, getState()); |
| enterRule(_localctx, 50, SV3_1aPpParser::RuleIfndef_directive_in_macro_body); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(568); |
| match(SV3_1aPpParser::TICK_IFNDEF); |
| setState(569); |
| match(SV3_1aPpParser::Spaces); |
| setState(573); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::EOF: |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(570); |
| identifier_in_macro_body(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(571); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(572); |
| macro_instance(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Elsif_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Elsif_directive_one_lineContext::Elsif_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Elsif_directiveContext* SV3_1aPpParser::Elsif_directive_one_lineContext::elsif_directive() { |
| return getRuleContext<SV3_1aPpParser::Elsif_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elsif_directive_one_lineContext::One_line_comment() { |
| return getToken(SV3_1aPpParser::One_line_comment, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elsif_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Elsif_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elsif_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Elsif_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleElsif_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Elsif_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterElsif_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Elsif_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitElsif_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Elsif_directive_one_lineContext* SV3_1aPpParser::elsif_directive_one_line() { |
| Elsif_directive_one_lineContext *_localctx = _tracker.createInstance<Elsif_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 52, SV3_1aPpParser::RuleElsif_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(575); |
| elsif_directive(); |
| setState(579); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(576); |
| match(SV3_1aPpParser::Spaces); |
| setState(581); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(582); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::One_line_comment || _la == SV3_1aPpParser::CR)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Elsif_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Elsif_directiveContext::Elsif_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elsif_directiveContext::TICK_ELSIF() { |
| return getToken(SV3_1aPpParser::TICK_ELSIF, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elsif_directiveContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elsif_directiveContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elsif_directiveContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::Elsif_directiveContext::macro_instance() { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Elsif_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleElsif_directive; |
| } |
| |
| void SV3_1aPpParser::Elsif_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterElsif_directive(this); |
| } |
| |
| void SV3_1aPpParser::Elsif_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitElsif_directive(this); |
| } |
| |
| SV3_1aPpParser::Elsif_directiveContext* SV3_1aPpParser::elsif_directive() { |
| Elsif_directiveContext *_localctx = _tracker.createInstance<Elsif_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 54, SV3_1aPpParser::RuleElsif_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(584); |
| match(SV3_1aPpParser::TICK_ELSIF); |
| setState(585); |
| match(SV3_1aPpParser::Spaces); |
| setState(589); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(586); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(587); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(588); |
| macro_instance(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Elsif_directive_in_macro_bodyContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Elsif_directive_in_macro_bodyContext::Elsif_directive_in_macro_bodyContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elsif_directive_in_macro_bodyContext::TICK_ELSIF() { |
| return getToken(SV3_1aPpParser::TICK_ELSIF, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elsif_directive_in_macro_bodyContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| SV3_1aPpParser::Identifier_in_macro_bodyContext* SV3_1aPpParser::Elsif_directive_in_macro_bodyContext::identifier_in_macro_body() { |
| return getRuleContext<SV3_1aPpParser::Identifier_in_macro_bodyContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elsif_directive_in_macro_bodyContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::Elsif_directive_in_macro_bodyContext::macro_instance() { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Elsif_directive_in_macro_bodyContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleElsif_directive_in_macro_body; |
| } |
| |
| void SV3_1aPpParser::Elsif_directive_in_macro_bodyContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterElsif_directive_in_macro_body(this); |
| } |
| |
| void SV3_1aPpParser::Elsif_directive_in_macro_bodyContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitElsif_directive_in_macro_body(this); |
| } |
| |
| SV3_1aPpParser::Elsif_directive_in_macro_bodyContext* SV3_1aPpParser::elsif_directive_in_macro_body() { |
| Elsif_directive_in_macro_bodyContext *_localctx = _tracker.createInstance<Elsif_directive_in_macro_bodyContext>(_ctx, getState()); |
| enterRule(_localctx, 56, SV3_1aPpParser::RuleElsif_directive_in_macro_body); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(591); |
| match(SV3_1aPpParser::TICK_ELSIF); |
| setState(592); |
| match(SV3_1aPpParser::Spaces); |
| setState(596); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::EOF: |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(593); |
| identifier_in_macro_body(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(594); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(595); |
| macro_instance(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Elseif_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Elseif_directive_one_lineContext::Elseif_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Elseif_directiveContext* SV3_1aPpParser::Elseif_directive_one_lineContext::elseif_directive() { |
| return getRuleContext<SV3_1aPpParser::Elseif_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elseif_directive_one_lineContext::One_line_comment() { |
| return getToken(SV3_1aPpParser::One_line_comment, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elseif_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Elseif_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elseif_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Elseif_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleElseif_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Elseif_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterElseif_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Elseif_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitElseif_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Elseif_directive_one_lineContext* SV3_1aPpParser::elseif_directive_one_line() { |
| Elseif_directive_one_lineContext *_localctx = _tracker.createInstance<Elseif_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 58, SV3_1aPpParser::RuleElseif_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(598); |
| elseif_directive(); |
| setState(602); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(599); |
| match(SV3_1aPpParser::Spaces); |
| setState(604); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(605); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::One_line_comment || _la == SV3_1aPpParser::CR)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Elseif_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Elseif_directiveContext::Elseif_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elseif_directiveContext::TICK_ELSEIF() { |
| return getToken(SV3_1aPpParser::TICK_ELSEIF, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elseif_directiveContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elseif_directiveContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elseif_directiveContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::Elseif_directiveContext::macro_instance() { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Elseif_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleElseif_directive; |
| } |
| |
| void SV3_1aPpParser::Elseif_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterElseif_directive(this); |
| } |
| |
| void SV3_1aPpParser::Elseif_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitElseif_directive(this); |
| } |
| |
| SV3_1aPpParser::Elseif_directiveContext* SV3_1aPpParser::elseif_directive() { |
| Elseif_directiveContext *_localctx = _tracker.createInstance<Elseif_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 60, SV3_1aPpParser::RuleElseif_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(607); |
| match(SV3_1aPpParser::TICK_ELSEIF); |
| setState(608); |
| match(SV3_1aPpParser::Spaces); |
| setState(612); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(609); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(610); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(611); |
| macro_instance(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Elseif_directive_in_macro_bodyContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Elseif_directive_in_macro_bodyContext::Elseif_directive_in_macro_bodyContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elseif_directive_in_macro_bodyContext::TICK_ELSEIF() { |
| return getToken(SV3_1aPpParser::TICK_ELSEIF, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elseif_directive_in_macro_bodyContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| SV3_1aPpParser::Identifier_in_macro_bodyContext* SV3_1aPpParser::Elseif_directive_in_macro_bodyContext::identifier_in_macro_body() { |
| return getRuleContext<SV3_1aPpParser::Identifier_in_macro_bodyContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Elseif_directive_in_macro_bodyContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::Elseif_directive_in_macro_bodyContext::macro_instance() { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Elseif_directive_in_macro_bodyContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleElseif_directive_in_macro_body; |
| } |
| |
| void SV3_1aPpParser::Elseif_directive_in_macro_bodyContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterElseif_directive_in_macro_body(this); |
| } |
| |
| void SV3_1aPpParser::Elseif_directive_in_macro_bodyContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitElseif_directive_in_macro_body(this); |
| } |
| |
| SV3_1aPpParser::Elseif_directive_in_macro_bodyContext* SV3_1aPpParser::elseif_directive_in_macro_body() { |
| Elseif_directive_in_macro_bodyContext *_localctx = _tracker.createInstance<Elseif_directive_in_macro_bodyContext>(_ctx, getState()); |
| enterRule(_localctx, 62, SV3_1aPpParser::RuleElseif_directive_in_macro_body); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(614); |
| match(SV3_1aPpParser::TICK_ELSEIF); |
| setState(615); |
| match(SV3_1aPpParser::Spaces); |
| setState(619); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::EOF: |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(616); |
| identifier_in_macro_body(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(617); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(618); |
| macro_instance(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Else_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Else_directive_one_lineContext::Else_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Else_directiveContext* SV3_1aPpParser::Else_directive_one_lineContext::else_directive() { |
| return getRuleContext<SV3_1aPpParser::Else_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Else_directive_one_lineContext::One_line_comment() { |
| return getToken(SV3_1aPpParser::One_line_comment, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Else_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Else_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Else_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Else_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleElse_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Else_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterElse_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Else_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitElse_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Else_directive_one_lineContext* SV3_1aPpParser::else_directive_one_line() { |
| Else_directive_one_lineContext *_localctx = _tracker.createInstance<Else_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 64, SV3_1aPpParser::RuleElse_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(621); |
| else_directive(); |
| setState(625); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(622); |
| match(SV3_1aPpParser::Spaces); |
| setState(627); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(628); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::One_line_comment || _la == SV3_1aPpParser::CR)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Else_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Else_directiveContext::Else_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Else_directiveContext::TICK_ELSE() { |
| return getToken(SV3_1aPpParser::TICK_ELSE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Else_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleElse_directive; |
| } |
| |
| void SV3_1aPpParser::Else_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterElse_directive(this); |
| } |
| |
| void SV3_1aPpParser::Else_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitElse_directive(this); |
| } |
| |
| SV3_1aPpParser::Else_directiveContext* SV3_1aPpParser::else_directive() { |
| Else_directiveContext *_localctx = _tracker.createInstance<Else_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 66, SV3_1aPpParser::RuleElse_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(630); |
| match(SV3_1aPpParser::TICK_ELSE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Endif_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Endif_directive_one_lineContext::Endif_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endif_directive_one_lineContext::TICK_ENDIF() { |
| return getToken(SV3_1aPpParser::TICK_ENDIF, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endif_directive_one_lineContext::One_line_comment() { |
| return getToken(SV3_1aPpParser::One_line_comment, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Endif_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endif_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endif_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endif_directive_one_lineContext::EOF() { |
| return getToken(SV3_1aPpParser::EOF, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Endif_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndif_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Endif_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndif_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Endif_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndif_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Endif_directive_one_lineContext* SV3_1aPpParser::endif_directive_one_line() { |
| Endif_directive_one_lineContext *_localctx = _tracker.createInstance<Endif_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 68, SV3_1aPpParser::RuleEndif_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(650); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx)) { |
| case 1: { |
| enterOuterAlt(_localctx, 1); |
| setState(632); |
| match(SV3_1aPpParser::TICK_ENDIF); |
| setState(636); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(633); |
| match(SV3_1aPpParser::Spaces); |
| setState(638); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(639); |
| match(SV3_1aPpParser::One_line_comment); |
| break; |
| } |
| |
| case 2: { |
| enterOuterAlt(_localctx, 2); |
| setState(640); |
| match(SV3_1aPpParser::TICK_ENDIF); |
| setState(644); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(641); |
| match(SV3_1aPpParser::Spaces); |
| setState(646); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(647); |
| match(SV3_1aPpParser::CR); |
| break; |
| } |
| |
| case 3: { |
| enterOuterAlt(_localctx, 3); |
| setState(648); |
| match(SV3_1aPpParser::TICK_ENDIF); |
| setState(649); |
| match(SV3_1aPpParser::EOF); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Endif_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Endif_directiveContext::Endif_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endif_directiveContext::TICK_ENDIF() { |
| return getToken(SV3_1aPpParser::TICK_ENDIF, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endif_directiveContext::One_line_comment() { |
| return getToken(SV3_1aPpParser::One_line_comment, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Endif_directiveContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endif_directiveContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Endif_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndif_directive; |
| } |
| |
| void SV3_1aPpParser::Endif_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndif_directive(this); |
| } |
| |
| void SV3_1aPpParser::Endif_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndif_directive(this); |
| } |
| |
| SV3_1aPpParser::Endif_directiveContext* SV3_1aPpParser::endif_directive() { |
| Endif_directiveContext *_localctx = _tracker.createInstance<Endif_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 70, SV3_1aPpParser::RuleEndif_directive); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(661); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 41, _ctx)) { |
| case 1: { |
| enterOuterAlt(_localctx, 1); |
| setState(652); |
| match(SV3_1aPpParser::TICK_ENDIF); |
| setState(656); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(653); |
| match(SV3_1aPpParser::Spaces); |
| setState(658); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(659); |
| match(SV3_1aPpParser::One_line_comment); |
| break; |
| } |
| |
| case 2: { |
| enterOuterAlt(_localctx, 2); |
| setState(660); |
| match(SV3_1aPpParser::TICK_ENDIF); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Resetall_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Resetall_directive_one_lineContext::Resetall_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Resetall_directiveContext* SV3_1aPpParser::Resetall_directive_one_lineContext::resetall_directive() { |
| return getRuleContext<SV3_1aPpParser::Resetall_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Resetall_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Resetall_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Resetall_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Resetall_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleResetall_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Resetall_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterResetall_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Resetall_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitResetall_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Resetall_directive_one_lineContext* SV3_1aPpParser::resetall_directive_one_line() { |
| Resetall_directive_one_lineContext *_localctx = _tracker.createInstance<Resetall_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 72, SV3_1aPpParser::RuleResetall_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(663); |
| resetall_directive(); |
| setState(667); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(664); |
| match(SV3_1aPpParser::Spaces); |
| setState(669); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(670); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Resetall_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Resetall_directiveContext::Resetall_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Resetall_directiveContext::TICK_RESETALL() { |
| return getToken(SV3_1aPpParser::TICK_RESETALL, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Resetall_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleResetall_directive; |
| } |
| |
| void SV3_1aPpParser::Resetall_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterResetall_directive(this); |
| } |
| |
| void SV3_1aPpParser::Resetall_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitResetall_directive(this); |
| } |
| |
| SV3_1aPpParser::Resetall_directiveContext* SV3_1aPpParser::resetall_directive() { |
| Resetall_directiveContext *_localctx = _tracker.createInstance<Resetall_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 74, SV3_1aPpParser::RuleResetall_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(672); |
| match(SV3_1aPpParser::TICK_RESETALL); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Begin_keywords_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Begin_keywords_directive_one_lineContext::Begin_keywords_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Begin_keywords_directiveContext* SV3_1aPpParser::Begin_keywords_directive_one_lineContext::begin_keywords_directive() { |
| return getRuleContext<SV3_1aPpParser::Begin_keywords_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Begin_keywords_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Begin_keywords_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Begin_keywords_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Begin_keywords_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleBegin_keywords_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Begin_keywords_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterBegin_keywords_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Begin_keywords_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitBegin_keywords_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Begin_keywords_directive_one_lineContext* SV3_1aPpParser::begin_keywords_directive_one_line() { |
| Begin_keywords_directive_one_lineContext *_localctx = _tracker.createInstance<Begin_keywords_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 76, SV3_1aPpParser::RuleBegin_keywords_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(674); |
| begin_keywords_directive(); |
| setState(678); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(675); |
| match(SV3_1aPpParser::Spaces); |
| setState(680); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(681); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Begin_keywords_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Begin_keywords_directiveContext::Begin_keywords_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Begin_keywords_directiveContext::TICK_BEGIN_KEYWORDS() { |
| return getToken(SV3_1aPpParser::TICK_BEGIN_KEYWORDS, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Begin_keywords_directiveContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Begin_keywords_directiveContext::String() { |
| return getToken(SV3_1aPpParser::String, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Begin_keywords_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleBegin_keywords_directive; |
| } |
| |
| void SV3_1aPpParser::Begin_keywords_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterBegin_keywords_directive(this); |
| } |
| |
| void SV3_1aPpParser::Begin_keywords_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitBegin_keywords_directive(this); |
| } |
| |
| SV3_1aPpParser::Begin_keywords_directiveContext* SV3_1aPpParser::begin_keywords_directive() { |
| Begin_keywords_directiveContext *_localctx = _tracker.createInstance<Begin_keywords_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 78, SV3_1aPpParser::RuleBegin_keywords_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(683); |
| match(SV3_1aPpParser::TICK_BEGIN_KEYWORDS); |
| setState(684); |
| match(SV3_1aPpParser::Spaces); |
| setState(685); |
| match(SV3_1aPpParser::String); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- End_keywords_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::End_keywords_directive_one_lineContext::End_keywords_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::End_keywords_directiveContext* SV3_1aPpParser::End_keywords_directive_one_lineContext::end_keywords_directive() { |
| return getRuleContext<SV3_1aPpParser::End_keywords_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::End_keywords_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::End_keywords_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::End_keywords_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::End_keywords_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEnd_keywords_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::End_keywords_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEnd_keywords_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::End_keywords_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEnd_keywords_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::End_keywords_directive_one_lineContext* SV3_1aPpParser::end_keywords_directive_one_line() { |
| End_keywords_directive_one_lineContext *_localctx = _tracker.createInstance<End_keywords_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 80, SV3_1aPpParser::RuleEnd_keywords_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(687); |
| end_keywords_directive(); |
| setState(691); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(688); |
| match(SV3_1aPpParser::Spaces); |
| setState(693); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(694); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- End_keywords_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::End_keywords_directiveContext::End_keywords_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::End_keywords_directiveContext::TICK_END_KEYWORDS() { |
| return getToken(SV3_1aPpParser::TICK_END_KEYWORDS, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::End_keywords_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEnd_keywords_directive; |
| } |
| |
| void SV3_1aPpParser::End_keywords_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEnd_keywords_directive(this); |
| } |
| |
| void SV3_1aPpParser::End_keywords_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEnd_keywords_directive(this); |
| } |
| |
| SV3_1aPpParser::End_keywords_directiveContext* SV3_1aPpParser::end_keywords_directive() { |
| End_keywords_directiveContext *_localctx = _tracker.createInstance<End_keywords_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 82, SV3_1aPpParser::RuleEnd_keywords_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(696); |
| match(SV3_1aPpParser::TICK_END_KEYWORDS); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Pragma_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Pragma_directive_one_lineContext::Pragma_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Pragma_directiveContext* SV3_1aPpParser::Pragma_directive_one_lineContext::pragma_directive() { |
| return getRuleContext<SV3_1aPpParser::Pragma_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Pragma_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Pragma_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RulePragma_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Pragma_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterPragma_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Pragma_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitPragma_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Pragma_directive_one_lineContext* SV3_1aPpParser::pragma_directive_one_line() { |
| Pragma_directive_one_lineContext *_localctx = _tracker.createInstance<Pragma_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 84, SV3_1aPpParser::RulePragma_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(698); |
| pragma_directive(); |
| setState(702); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(699); |
| match(SV3_1aPpParser::Spaces); |
| setState(704); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(705); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Pragma_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Pragma_directiveContext::Pragma_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_directiveContext::TICK_PRAGMA() { |
| return getToken(SV3_1aPpParser::TICK_PRAGMA, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_directiveContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_directiveContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| std::vector<SV3_1aPpParser::Pragma_expressionContext *> SV3_1aPpParser::Pragma_directiveContext::pragma_expression() { |
| return getRuleContexts<SV3_1aPpParser::Pragma_expressionContext>(); |
| } |
| |
| SV3_1aPpParser::Pragma_expressionContext* SV3_1aPpParser::Pragma_directiveContext::pragma_expression(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Pragma_expressionContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Pragma_directiveContext::Special() { |
| return getTokens(SV3_1aPpParser::Special); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_directiveContext::Special(size_t i) { |
| return getToken(SV3_1aPpParser::Special, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Pragma_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RulePragma_directive; |
| } |
| |
| void SV3_1aPpParser::Pragma_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterPragma_directive(this); |
| } |
| |
| void SV3_1aPpParser::Pragma_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitPragma_directive(this); |
| } |
| |
| SV3_1aPpParser::Pragma_directiveContext* SV3_1aPpParser::pragma_directive() { |
| Pragma_directiveContext *_localctx = _tracker.createInstance<Pragma_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 86, SV3_1aPpParser::RulePragma_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(707); |
| match(SV3_1aPpParser::TICK_PRAGMA); |
| setState(708); |
| match(SV3_1aPpParser::Spaces); |
| setState(709); |
| match(SV3_1aPpParser::Simple_identifier); |
| setState(720); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(710); |
| pragma_expression(); |
| setState(715); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 46, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(711); |
| match(SV3_1aPpParser::Special); |
| setState(712); |
| pragma_expression(); |
| } |
| setState(717); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 46, _ctx); |
| } |
| } |
| setState(722); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Celldefine_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Celldefine_directive_one_lineContext::Celldefine_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Celldefine_directiveContext* SV3_1aPpParser::Celldefine_directive_one_lineContext::celldefine_directive() { |
| return getRuleContext<SV3_1aPpParser::Celldefine_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Celldefine_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Celldefine_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Celldefine_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Celldefine_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleCelldefine_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Celldefine_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterCelldefine_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Celldefine_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitCelldefine_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Celldefine_directive_one_lineContext* SV3_1aPpParser::celldefine_directive_one_line() { |
| Celldefine_directive_one_lineContext *_localctx = _tracker.createInstance<Celldefine_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 88, SV3_1aPpParser::RuleCelldefine_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(723); |
| celldefine_directive(); |
| setState(727); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(724); |
| match(SV3_1aPpParser::Spaces); |
| setState(729); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(730); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Celldefine_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Celldefine_directiveContext::Celldefine_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Celldefine_directiveContext::TICK_CELLDEFINE() { |
| return getToken(SV3_1aPpParser::TICK_CELLDEFINE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Celldefine_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleCelldefine_directive; |
| } |
| |
| void SV3_1aPpParser::Celldefine_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterCelldefine_directive(this); |
| } |
| |
| void SV3_1aPpParser::Celldefine_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitCelldefine_directive(this); |
| } |
| |
| SV3_1aPpParser::Celldefine_directiveContext* SV3_1aPpParser::celldefine_directive() { |
| Celldefine_directiveContext *_localctx = _tracker.createInstance<Celldefine_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 90, SV3_1aPpParser::RuleCelldefine_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(732); |
| match(SV3_1aPpParser::TICK_CELLDEFINE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Endcelldefine_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Endcelldefine_directive_one_lineContext::Endcelldefine_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Endcelldefine_directiveContext* SV3_1aPpParser::Endcelldefine_directive_one_lineContext::endcelldefine_directive() { |
| return getRuleContext<SV3_1aPpParser::Endcelldefine_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endcelldefine_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Endcelldefine_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endcelldefine_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Endcelldefine_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndcelldefine_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Endcelldefine_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndcelldefine_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Endcelldefine_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndcelldefine_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Endcelldefine_directive_one_lineContext* SV3_1aPpParser::endcelldefine_directive_one_line() { |
| Endcelldefine_directive_one_lineContext *_localctx = _tracker.createInstance<Endcelldefine_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 92, SV3_1aPpParser::RuleEndcelldefine_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(734); |
| endcelldefine_directive(); |
| setState(738); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(735); |
| match(SV3_1aPpParser::Spaces); |
| setState(740); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(741); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Endcelldefine_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Endcelldefine_directiveContext::Endcelldefine_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endcelldefine_directiveContext::TICK_ENDCELLDEFINE() { |
| return getToken(SV3_1aPpParser::TICK_ENDCELLDEFINE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Endcelldefine_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndcelldefine_directive; |
| } |
| |
| void SV3_1aPpParser::Endcelldefine_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndcelldefine_directive(this); |
| } |
| |
| void SV3_1aPpParser::Endcelldefine_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndcelldefine_directive(this); |
| } |
| |
| SV3_1aPpParser::Endcelldefine_directiveContext* SV3_1aPpParser::endcelldefine_directive() { |
| Endcelldefine_directiveContext *_localctx = _tracker.createInstance<Endcelldefine_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 94, SV3_1aPpParser::RuleEndcelldefine_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(743); |
| match(SV3_1aPpParser::TICK_ENDCELLDEFINE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Protect_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Protect_directive_one_lineContext::Protect_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Protect_directiveContext* SV3_1aPpParser::Protect_directive_one_lineContext::protect_directive() { |
| return getRuleContext<SV3_1aPpParser::Protect_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Protect_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Protect_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Protect_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Protect_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleProtect_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Protect_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterProtect_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Protect_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitProtect_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Protect_directive_one_lineContext* SV3_1aPpParser::protect_directive_one_line() { |
| Protect_directive_one_lineContext *_localctx = _tracker.createInstance<Protect_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 96, SV3_1aPpParser::RuleProtect_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(745); |
| protect_directive(); |
| setState(749); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(746); |
| match(SV3_1aPpParser::Spaces); |
| setState(751); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(752); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Protect_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Protect_directiveContext::Protect_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Protect_directiveContext::TICK_PROTECT() { |
| return getToken(SV3_1aPpParser::TICK_PROTECT, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Protect_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleProtect_directive; |
| } |
| |
| void SV3_1aPpParser::Protect_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterProtect_directive(this); |
| } |
| |
| void SV3_1aPpParser::Protect_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitProtect_directive(this); |
| } |
| |
| SV3_1aPpParser::Protect_directiveContext* SV3_1aPpParser::protect_directive() { |
| Protect_directiveContext *_localctx = _tracker.createInstance<Protect_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 98, SV3_1aPpParser::RuleProtect_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(754); |
| match(SV3_1aPpParser::TICK_PROTECT); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Endprotect_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Endprotect_directive_one_lineContext::Endprotect_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Endprotect_directiveContext* SV3_1aPpParser::Endprotect_directive_one_lineContext::endprotect_directive() { |
| return getRuleContext<SV3_1aPpParser::Endprotect_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endprotect_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Endprotect_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endprotect_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Endprotect_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndprotect_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Endprotect_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndprotect_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Endprotect_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndprotect_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Endprotect_directive_one_lineContext* SV3_1aPpParser::endprotect_directive_one_line() { |
| Endprotect_directive_one_lineContext *_localctx = _tracker.createInstance<Endprotect_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 100, SV3_1aPpParser::RuleEndprotect_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(756); |
| endprotect_directive(); |
| setState(760); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(757); |
| match(SV3_1aPpParser::Spaces); |
| setState(762); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(763); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Endprotect_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Endprotect_directiveContext::Endprotect_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endprotect_directiveContext::TICK_ENDPROTECT() { |
| return getToken(SV3_1aPpParser::TICK_ENDPROTECT, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Endprotect_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndprotect_directive; |
| } |
| |
| void SV3_1aPpParser::Endprotect_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndprotect_directive(this); |
| } |
| |
| void SV3_1aPpParser::Endprotect_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndprotect_directive(this); |
| } |
| |
| SV3_1aPpParser::Endprotect_directiveContext* SV3_1aPpParser::endprotect_directive() { |
| Endprotect_directiveContext *_localctx = _tracker.createInstance<Endprotect_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 102, SV3_1aPpParser::RuleEndprotect_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(765); |
| match(SV3_1aPpParser::TICK_ENDPROTECT); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Protected_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Protected_directive_one_lineContext::Protected_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Protected_directiveContext* SV3_1aPpParser::Protected_directive_one_lineContext::protected_directive() { |
| return getRuleContext<SV3_1aPpParser::Protected_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Protected_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Protected_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Protected_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Protected_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleProtected_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Protected_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterProtected_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Protected_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitProtected_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Protected_directive_one_lineContext* SV3_1aPpParser::protected_directive_one_line() { |
| Protected_directive_one_lineContext *_localctx = _tracker.createInstance<Protected_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 104, SV3_1aPpParser::RuleProtected_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(767); |
| protected_directive(); |
| setState(771); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(768); |
| match(SV3_1aPpParser::Spaces); |
| setState(773); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(774); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Protected_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Protected_directiveContext::Protected_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Protected_directiveContext::TICK_PROTECTED() { |
| return getToken(SV3_1aPpParser::TICK_PROTECTED, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Protected_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleProtected_directive; |
| } |
| |
| void SV3_1aPpParser::Protected_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterProtected_directive(this); |
| } |
| |
| void SV3_1aPpParser::Protected_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitProtected_directive(this); |
| } |
| |
| SV3_1aPpParser::Protected_directiveContext* SV3_1aPpParser::protected_directive() { |
| Protected_directiveContext *_localctx = _tracker.createInstance<Protected_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 106, SV3_1aPpParser::RuleProtected_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(776); |
| match(SV3_1aPpParser::TICK_PROTECTED); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Endprotected_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Endprotected_directive_one_lineContext::Endprotected_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Endprotected_directiveContext* SV3_1aPpParser::Endprotected_directive_one_lineContext::endprotected_directive() { |
| return getRuleContext<SV3_1aPpParser::Endprotected_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endprotected_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Endprotected_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endprotected_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Endprotected_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndprotected_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Endprotected_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndprotected_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Endprotected_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndprotected_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Endprotected_directive_one_lineContext* SV3_1aPpParser::endprotected_directive_one_line() { |
| Endprotected_directive_one_lineContext *_localctx = _tracker.createInstance<Endprotected_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 108, SV3_1aPpParser::RuleEndprotected_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(778); |
| endprotected_directive(); |
| setState(782); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(779); |
| match(SV3_1aPpParser::Spaces); |
| setState(784); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(785); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Endprotected_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Endprotected_directiveContext::Endprotected_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Endprotected_directiveContext::TICK_ENDPROTECTED() { |
| return getToken(SV3_1aPpParser::TICK_ENDPROTECTED, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Endprotected_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndprotected_directive; |
| } |
| |
| void SV3_1aPpParser::Endprotected_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndprotected_directive(this); |
| } |
| |
| void SV3_1aPpParser::Endprotected_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndprotected_directive(this); |
| } |
| |
| SV3_1aPpParser::Endprotected_directiveContext* SV3_1aPpParser::endprotected_directive() { |
| Endprotected_directiveContext *_localctx = _tracker.createInstance<Endprotected_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 110, SV3_1aPpParser::RuleEndprotected_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(787); |
| match(SV3_1aPpParser::TICK_ENDPROTECTED); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Expand_vectornets_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Expand_vectornets_directive_one_lineContext::Expand_vectornets_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Expand_vectornets_directiveContext* SV3_1aPpParser::Expand_vectornets_directive_one_lineContext::expand_vectornets_directive() { |
| return getRuleContext<SV3_1aPpParser::Expand_vectornets_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Expand_vectornets_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Expand_vectornets_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Expand_vectornets_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Expand_vectornets_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleExpand_vectornets_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Expand_vectornets_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterExpand_vectornets_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Expand_vectornets_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitExpand_vectornets_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Expand_vectornets_directive_one_lineContext* SV3_1aPpParser::expand_vectornets_directive_one_line() { |
| Expand_vectornets_directive_one_lineContext *_localctx = _tracker.createInstance<Expand_vectornets_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 112, SV3_1aPpParser::RuleExpand_vectornets_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(789); |
| expand_vectornets_directive(); |
| setState(793); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(790); |
| match(SV3_1aPpParser::Spaces); |
| setState(795); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(796); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Expand_vectornets_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Expand_vectornets_directiveContext::Expand_vectornets_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Expand_vectornets_directiveContext::TICK_EXPAND_VECTORNETS() { |
| return getToken(SV3_1aPpParser::TICK_EXPAND_VECTORNETS, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Expand_vectornets_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleExpand_vectornets_directive; |
| } |
| |
| void SV3_1aPpParser::Expand_vectornets_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterExpand_vectornets_directive(this); |
| } |
| |
| void SV3_1aPpParser::Expand_vectornets_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitExpand_vectornets_directive(this); |
| } |
| |
| SV3_1aPpParser::Expand_vectornets_directiveContext* SV3_1aPpParser::expand_vectornets_directive() { |
| Expand_vectornets_directiveContext *_localctx = _tracker.createInstance<Expand_vectornets_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 114, SV3_1aPpParser::RuleExpand_vectornets_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(798); |
| match(SV3_1aPpParser::TICK_EXPAND_VECTORNETS); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Noexpand_vectornets_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Noexpand_vectornets_directive_one_lineContext::Noexpand_vectornets_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Noexpand_vectornets_directiveContext* SV3_1aPpParser::Noexpand_vectornets_directive_one_lineContext::noexpand_vectornets_directive() { |
| return getRuleContext<SV3_1aPpParser::Noexpand_vectornets_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Noexpand_vectornets_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Noexpand_vectornets_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Noexpand_vectornets_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Noexpand_vectornets_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNoexpand_vectornets_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Noexpand_vectornets_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNoexpand_vectornets_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Noexpand_vectornets_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNoexpand_vectornets_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Noexpand_vectornets_directive_one_lineContext* SV3_1aPpParser::noexpand_vectornets_directive_one_line() { |
| Noexpand_vectornets_directive_one_lineContext *_localctx = _tracker.createInstance<Noexpand_vectornets_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 116, SV3_1aPpParser::RuleNoexpand_vectornets_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(800); |
| noexpand_vectornets_directive(); |
| setState(804); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(801); |
| match(SV3_1aPpParser::Spaces); |
| setState(806); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(807); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Noexpand_vectornets_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Noexpand_vectornets_directiveContext::Noexpand_vectornets_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Noexpand_vectornets_directiveContext::TICK_NOEXPAND_VECTORNETS() { |
| return getToken(SV3_1aPpParser::TICK_NOEXPAND_VECTORNETS, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Noexpand_vectornets_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNoexpand_vectornets_directive; |
| } |
| |
| void SV3_1aPpParser::Noexpand_vectornets_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNoexpand_vectornets_directive(this); |
| } |
| |
| void SV3_1aPpParser::Noexpand_vectornets_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNoexpand_vectornets_directive(this); |
| } |
| |
| SV3_1aPpParser::Noexpand_vectornets_directiveContext* SV3_1aPpParser::noexpand_vectornets_directive() { |
| Noexpand_vectornets_directiveContext *_localctx = _tracker.createInstance<Noexpand_vectornets_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 118, SV3_1aPpParser::RuleNoexpand_vectornets_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(809); |
| match(SV3_1aPpParser::TICK_NOEXPAND_VECTORNETS); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Autoexpand_vectornets_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Autoexpand_vectornets_directive_one_lineContext::Autoexpand_vectornets_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Autoexpand_vectornets_directiveContext* SV3_1aPpParser::Autoexpand_vectornets_directive_one_lineContext::autoexpand_vectornets_directive() { |
| return getRuleContext<SV3_1aPpParser::Autoexpand_vectornets_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Autoexpand_vectornets_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Autoexpand_vectornets_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Autoexpand_vectornets_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Autoexpand_vectornets_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleAutoexpand_vectornets_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Autoexpand_vectornets_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterAutoexpand_vectornets_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Autoexpand_vectornets_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitAutoexpand_vectornets_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Autoexpand_vectornets_directive_one_lineContext* SV3_1aPpParser::autoexpand_vectornets_directive_one_line() { |
| Autoexpand_vectornets_directive_one_lineContext *_localctx = _tracker.createInstance<Autoexpand_vectornets_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 120, SV3_1aPpParser::RuleAutoexpand_vectornets_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(811); |
| autoexpand_vectornets_directive(); |
| setState(815); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(812); |
| match(SV3_1aPpParser::Spaces); |
| setState(817); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(818); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Autoexpand_vectornets_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Autoexpand_vectornets_directiveContext::Autoexpand_vectornets_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Autoexpand_vectornets_directiveContext::TICK_AUTOEXPAND_VECTORNETS() { |
| return getToken(SV3_1aPpParser::TICK_AUTOEXPAND_VECTORNETS, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Autoexpand_vectornets_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleAutoexpand_vectornets_directive; |
| } |
| |
| void SV3_1aPpParser::Autoexpand_vectornets_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterAutoexpand_vectornets_directive(this); |
| } |
| |
| void SV3_1aPpParser::Autoexpand_vectornets_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitAutoexpand_vectornets_directive(this); |
| } |
| |
| SV3_1aPpParser::Autoexpand_vectornets_directiveContext* SV3_1aPpParser::autoexpand_vectornets_directive() { |
| Autoexpand_vectornets_directiveContext *_localctx = _tracker.createInstance<Autoexpand_vectornets_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 122, SV3_1aPpParser::RuleAutoexpand_vectornets_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(820); |
| match(SV3_1aPpParser::TICK_AUTOEXPAND_VECTORNETS); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Uselib_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Uselib_directive_one_lineContext::Uselib_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Uselib_directiveContext* SV3_1aPpParser::Uselib_directive_one_lineContext::uselib_directive() { |
| return getRuleContext<SV3_1aPpParser::Uselib_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Uselib_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Uselib_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleUselib_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Uselib_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterUselib_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Uselib_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitUselib_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Uselib_directive_one_lineContext* SV3_1aPpParser::uselib_directive_one_line() { |
| Uselib_directive_one_lineContext *_localctx = _tracker.createInstance<Uselib_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 124, SV3_1aPpParser::RuleUselib_directive_one_line); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(822); |
| uselib_directive(); |
| setState(823); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Uselib_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Uselib_directiveContext::Uselib_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Uselib_directiveContext::TICK_USELIB() { |
| return getToken(SV3_1aPpParser::TICK_USELIB, 0); |
| } |
| |
| std::vector<SV3_1aPpParser::Text_blobContext *> SV3_1aPpParser::Uselib_directiveContext::text_blob() { |
| return getRuleContexts<SV3_1aPpParser::Text_blobContext>(); |
| } |
| |
| SV3_1aPpParser::Text_blobContext* SV3_1aPpParser::Uselib_directiveContext::text_blob(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Text_blobContext>(i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Uselib_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleUselib_directive; |
| } |
| |
| void SV3_1aPpParser::Uselib_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterUselib_directive(this); |
| } |
| |
| void SV3_1aPpParser::Uselib_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitUselib_directive(this); |
| } |
| |
| SV3_1aPpParser::Uselib_directiveContext* SV3_1aPpParser::uselib_directive() { |
| Uselib_directiveContext *_localctx = _tracker.createInstance<Uselib_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 126, SV3_1aPpParser::RuleUselib_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(825); |
| match(SV3_1aPpParser::TICK_USELIB); |
| setState(827); |
| _errHandler->sync(this); |
| alt = 1; |
| do { |
| switch (alt) { |
| case 1: { |
| setState(826); |
| text_blob(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| setState(829); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 57, _ctx); |
| } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Disable_portfaults_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Disable_portfaults_directive_one_lineContext::Disable_portfaults_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Disable_portfaults_directiveContext* SV3_1aPpParser::Disable_portfaults_directive_one_lineContext::disable_portfaults_directive() { |
| return getRuleContext<SV3_1aPpParser::Disable_portfaults_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Disable_portfaults_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Disable_portfaults_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Disable_portfaults_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Disable_portfaults_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDisable_portfaults_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Disable_portfaults_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDisable_portfaults_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Disable_portfaults_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDisable_portfaults_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Disable_portfaults_directive_one_lineContext* SV3_1aPpParser::disable_portfaults_directive_one_line() { |
| Disable_portfaults_directive_one_lineContext *_localctx = _tracker.createInstance<Disable_portfaults_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 128, SV3_1aPpParser::RuleDisable_portfaults_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(831); |
| disable_portfaults_directive(); |
| setState(835); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(832); |
| match(SV3_1aPpParser::Spaces); |
| setState(837); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(838); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Disable_portfaults_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Disable_portfaults_directiveContext::Disable_portfaults_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Disable_portfaults_directiveContext::TICK_DISABLE_PORTFAULTS() { |
| return getToken(SV3_1aPpParser::TICK_DISABLE_PORTFAULTS, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Disable_portfaults_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDisable_portfaults_directive; |
| } |
| |
| void SV3_1aPpParser::Disable_portfaults_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDisable_portfaults_directive(this); |
| } |
| |
| void SV3_1aPpParser::Disable_portfaults_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDisable_portfaults_directive(this); |
| } |
| |
| SV3_1aPpParser::Disable_portfaults_directiveContext* SV3_1aPpParser::disable_portfaults_directive() { |
| Disable_portfaults_directiveContext *_localctx = _tracker.createInstance<Disable_portfaults_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 130, SV3_1aPpParser::RuleDisable_portfaults_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(840); |
| match(SV3_1aPpParser::TICK_DISABLE_PORTFAULTS); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Enable_portfaults_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Enable_portfaults_directive_one_lineContext::Enable_portfaults_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Enable_portfaults_directiveContext* SV3_1aPpParser::Enable_portfaults_directive_one_lineContext::enable_portfaults_directive() { |
| return getRuleContext<SV3_1aPpParser::Enable_portfaults_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Enable_portfaults_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Enable_portfaults_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Enable_portfaults_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Enable_portfaults_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEnable_portfaults_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Enable_portfaults_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEnable_portfaults_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Enable_portfaults_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEnable_portfaults_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Enable_portfaults_directive_one_lineContext* SV3_1aPpParser::enable_portfaults_directive_one_line() { |
| Enable_portfaults_directive_one_lineContext *_localctx = _tracker.createInstance<Enable_portfaults_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 132, SV3_1aPpParser::RuleEnable_portfaults_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(842); |
| enable_portfaults_directive(); |
| setState(846); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(843); |
| match(SV3_1aPpParser::Spaces); |
| setState(848); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(849); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Enable_portfaults_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Enable_portfaults_directiveContext::Enable_portfaults_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Enable_portfaults_directiveContext::TICK_ENABLE_PORTFAULTS() { |
| return getToken(SV3_1aPpParser::TICK_ENABLE_PORTFAULTS, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Enable_portfaults_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEnable_portfaults_directive; |
| } |
| |
| void SV3_1aPpParser::Enable_portfaults_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEnable_portfaults_directive(this); |
| } |
| |
| void SV3_1aPpParser::Enable_portfaults_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEnable_portfaults_directive(this); |
| } |
| |
| SV3_1aPpParser::Enable_portfaults_directiveContext* SV3_1aPpParser::enable_portfaults_directive() { |
| Enable_portfaults_directiveContext *_localctx = _tracker.createInstance<Enable_portfaults_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 134, SV3_1aPpParser::RuleEnable_portfaults_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(851); |
| match(SV3_1aPpParser::TICK_ENABLE_PORTFAULTS); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Nosuppress_faults_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Nosuppress_faults_directive_one_lineContext::Nosuppress_faults_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Nosuppress_faults_directiveContext* SV3_1aPpParser::Nosuppress_faults_directive_one_lineContext::nosuppress_faults_directive() { |
| return getRuleContext<SV3_1aPpParser::Nosuppress_faults_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Nosuppress_faults_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Nosuppress_faults_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Nosuppress_faults_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Nosuppress_faults_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNosuppress_faults_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Nosuppress_faults_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNosuppress_faults_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Nosuppress_faults_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNosuppress_faults_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Nosuppress_faults_directive_one_lineContext* SV3_1aPpParser::nosuppress_faults_directive_one_line() { |
| Nosuppress_faults_directive_one_lineContext *_localctx = _tracker.createInstance<Nosuppress_faults_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 136, SV3_1aPpParser::RuleNosuppress_faults_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(853); |
| nosuppress_faults_directive(); |
| setState(857); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(854); |
| match(SV3_1aPpParser::Spaces); |
| setState(859); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(860); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Nosuppress_faults_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Nosuppress_faults_directiveContext::Nosuppress_faults_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Nosuppress_faults_directiveContext::TICK_NOSUPPRESS_FAULTS() { |
| return getToken(SV3_1aPpParser::TICK_NOSUPPRESS_FAULTS, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Nosuppress_faults_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNosuppress_faults_directive; |
| } |
| |
| void SV3_1aPpParser::Nosuppress_faults_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNosuppress_faults_directive(this); |
| } |
| |
| void SV3_1aPpParser::Nosuppress_faults_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNosuppress_faults_directive(this); |
| } |
| |
| SV3_1aPpParser::Nosuppress_faults_directiveContext* SV3_1aPpParser::nosuppress_faults_directive() { |
| Nosuppress_faults_directiveContext *_localctx = _tracker.createInstance<Nosuppress_faults_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 138, SV3_1aPpParser::RuleNosuppress_faults_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(862); |
| match(SV3_1aPpParser::TICK_NOSUPPRESS_FAULTS); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Suppress_faults_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Suppress_faults_directive_one_lineContext::Suppress_faults_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Suppress_faults_directiveContext* SV3_1aPpParser::Suppress_faults_directive_one_lineContext::suppress_faults_directive() { |
| return getRuleContext<SV3_1aPpParser::Suppress_faults_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Suppress_faults_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Suppress_faults_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Suppress_faults_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Suppress_faults_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSuppress_faults_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Suppress_faults_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSuppress_faults_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Suppress_faults_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSuppress_faults_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Suppress_faults_directive_one_lineContext* SV3_1aPpParser::suppress_faults_directive_one_line() { |
| Suppress_faults_directive_one_lineContext *_localctx = _tracker.createInstance<Suppress_faults_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 140, SV3_1aPpParser::RuleSuppress_faults_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(864); |
| suppress_faults_directive(); |
| setState(868); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(865); |
| match(SV3_1aPpParser::Spaces); |
| setState(870); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(871); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Suppress_faults_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Suppress_faults_directiveContext::Suppress_faults_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Suppress_faults_directiveContext::TICK_SUPPRESS_FAULTS() { |
| return getToken(SV3_1aPpParser::TICK_SUPPRESS_FAULTS, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Suppress_faults_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSuppress_faults_directive; |
| } |
| |
| void SV3_1aPpParser::Suppress_faults_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSuppress_faults_directive(this); |
| } |
| |
| void SV3_1aPpParser::Suppress_faults_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSuppress_faults_directive(this); |
| } |
| |
| SV3_1aPpParser::Suppress_faults_directiveContext* SV3_1aPpParser::suppress_faults_directive() { |
| Suppress_faults_directiveContext *_localctx = _tracker.createInstance<Suppress_faults_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 142, SV3_1aPpParser::RuleSuppress_faults_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(873); |
| match(SV3_1aPpParser::TICK_SUPPRESS_FAULTS); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Signed_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Signed_directive_one_lineContext::Signed_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Signed_directiveContext* SV3_1aPpParser::Signed_directive_one_lineContext::signed_directive() { |
| return getRuleContext<SV3_1aPpParser::Signed_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Signed_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Signed_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Signed_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Signed_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSigned_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Signed_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSigned_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Signed_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSigned_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Signed_directive_one_lineContext* SV3_1aPpParser::signed_directive_one_line() { |
| Signed_directive_one_lineContext *_localctx = _tracker.createInstance<Signed_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 144, SV3_1aPpParser::RuleSigned_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(875); |
| signed_directive(); |
| setState(879); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(876); |
| match(SV3_1aPpParser::Spaces); |
| setState(881); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(882); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Signed_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Signed_directiveContext::Signed_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Signed_directiveContext::TICK_SIGNED() { |
| return getToken(SV3_1aPpParser::TICK_SIGNED, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Signed_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSigned_directive; |
| } |
| |
| void SV3_1aPpParser::Signed_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSigned_directive(this); |
| } |
| |
| void SV3_1aPpParser::Signed_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSigned_directive(this); |
| } |
| |
| SV3_1aPpParser::Signed_directiveContext* SV3_1aPpParser::signed_directive() { |
| Signed_directiveContext *_localctx = _tracker.createInstance<Signed_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 146, SV3_1aPpParser::RuleSigned_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(884); |
| match(SV3_1aPpParser::TICK_SIGNED); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Unsigned_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Unsigned_directive_one_lineContext::Unsigned_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Unsigned_directiveContext* SV3_1aPpParser::Unsigned_directive_one_lineContext::unsigned_directive() { |
| return getRuleContext<SV3_1aPpParser::Unsigned_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Unsigned_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Unsigned_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Unsigned_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Unsigned_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleUnsigned_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Unsigned_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterUnsigned_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Unsigned_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitUnsigned_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Unsigned_directive_one_lineContext* SV3_1aPpParser::unsigned_directive_one_line() { |
| Unsigned_directive_one_lineContext *_localctx = _tracker.createInstance<Unsigned_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 148, SV3_1aPpParser::RuleUnsigned_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(886); |
| unsigned_directive(); |
| setState(890); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(887); |
| match(SV3_1aPpParser::Spaces); |
| setState(892); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(893); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Unsigned_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Unsigned_directiveContext::Unsigned_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Unsigned_directiveContext::TICK_UNSIGNED() { |
| return getToken(SV3_1aPpParser::TICK_UNSIGNED, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Unsigned_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleUnsigned_directive; |
| } |
| |
| void SV3_1aPpParser::Unsigned_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterUnsigned_directive(this); |
| } |
| |
| void SV3_1aPpParser::Unsigned_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitUnsigned_directive(this); |
| } |
| |
| SV3_1aPpParser::Unsigned_directiveContext* SV3_1aPpParser::unsigned_directive() { |
| Unsigned_directiveContext *_localctx = _tracker.createInstance<Unsigned_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 150, SV3_1aPpParser::RuleUnsigned_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(895); |
| match(SV3_1aPpParser::TICK_UNSIGNED); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Remove_gatename_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Remove_gatename_directive_one_lineContext::Remove_gatename_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Remove_gatename_directiveContext* SV3_1aPpParser::Remove_gatename_directive_one_lineContext::remove_gatename_directive() { |
| return getRuleContext<SV3_1aPpParser::Remove_gatename_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Remove_gatename_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Remove_gatename_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Remove_gatename_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Remove_gatename_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleRemove_gatename_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Remove_gatename_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterRemove_gatename_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Remove_gatename_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitRemove_gatename_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Remove_gatename_directive_one_lineContext* SV3_1aPpParser::remove_gatename_directive_one_line() { |
| Remove_gatename_directive_one_lineContext *_localctx = _tracker.createInstance<Remove_gatename_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 152, SV3_1aPpParser::RuleRemove_gatename_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(897); |
| remove_gatename_directive(); |
| setState(901); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(898); |
| match(SV3_1aPpParser::Spaces); |
| setState(903); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(904); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Remove_gatename_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Remove_gatename_directiveContext::Remove_gatename_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Remove_gatename_directiveContext::TICK_REMOVE_GATENAME() { |
| return getToken(SV3_1aPpParser::TICK_REMOVE_GATENAME, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Remove_gatename_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleRemove_gatename_directive; |
| } |
| |
| void SV3_1aPpParser::Remove_gatename_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterRemove_gatename_directive(this); |
| } |
| |
| void SV3_1aPpParser::Remove_gatename_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitRemove_gatename_directive(this); |
| } |
| |
| SV3_1aPpParser::Remove_gatename_directiveContext* SV3_1aPpParser::remove_gatename_directive() { |
| Remove_gatename_directiveContext *_localctx = _tracker.createInstance<Remove_gatename_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 154, SV3_1aPpParser::RuleRemove_gatename_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(906); |
| match(SV3_1aPpParser::TICK_REMOVE_GATENAME); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Noremove_gatenames_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Noremove_gatenames_directive_one_lineContext::Noremove_gatenames_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Noremove_gatenames_directiveContext* SV3_1aPpParser::Noremove_gatenames_directive_one_lineContext::noremove_gatenames_directive() { |
| return getRuleContext<SV3_1aPpParser::Noremove_gatenames_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Noremove_gatenames_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Noremove_gatenames_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Noremove_gatenames_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Noremove_gatenames_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNoremove_gatenames_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Noremove_gatenames_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNoremove_gatenames_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Noremove_gatenames_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNoremove_gatenames_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Noremove_gatenames_directive_one_lineContext* SV3_1aPpParser::noremove_gatenames_directive_one_line() { |
| Noremove_gatenames_directive_one_lineContext *_localctx = _tracker.createInstance<Noremove_gatenames_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 156, SV3_1aPpParser::RuleNoremove_gatenames_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(908); |
| noremove_gatenames_directive(); |
| setState(912); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(909); |
| match(SV3_1aPpParser::Spaces); |
| setState(914); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(915); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Noremove_gatenames_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Noremove_gatenames_directiveContext::Noremove_gatenames_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Noremove_gatenames_directiveContext::TICK_NOREMOVE_GATENAMES() { |
| return getToken(SV3_1aPpParser::TICK_NOREMOVE_GATENAMES, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Noremove_gatenames_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNoremove_gatenames_directive; |
| } |
| |
| void SV3_1aPpParser::Noremove_gatenames_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNoremove_gatenames_directive(this); |
| } |
| |
| void SV3_1aPpParser::Noremove_gatenames_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNoremove_gatenames_directive(this); |
| } |
| |
| SV3_1aPpParser::Noremove_gatenames_directiveContext* SV3_1aPpParser::noremove_gatenames_directive() { |
| Noremove_gatenames_directiveContext *_localctx = _tracker.createInstance<Noremove_gatenames_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 158, SV3_1aPpParser::RuleNoremove_gatenames_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(917); |
| match(SV3_1aPpParser::TICK_NOREMOVE_GATENAMES); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Remove_netname_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Remove_netname_directive_one_lineContext::Remove_netname_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Remove_netname_directiveContext* SV3_1aPpParser::Remove_netname_directive_one_lineContext::remove_netname_directive() { |
| return getRuleContext<SV3_1aPpParser::Remove_netname_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Remove_netname_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Remove_netname_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Remove_netname_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Remove_netname_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleRemove_netname_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Remove_netname_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterRemove_netname_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Remove_netname_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitRemove_netname_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Remove_netname_directive_one_lineContext* SV3_1aPpParser::remove_netname_directive_one_line() { |
| Remove_netname_directive_one_lineContext *_localctx = _tracker.createInstance<Remove_netname_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 160, SV3_1aPpParser::RuleRemove_netname_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(919); |
| remove_netname_directive(); |
| setState(923); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(920); |
| match(SV3_1aPpParser::Spaces); |
| setState(925); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(926); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Remove_netname_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Remove_netname_directiveContext::Remove_netname_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Remove_netname_directiveContext::TICK_REMOVE_NETNAME() { |
| return getToken(SV3_1aPpParser::TICK_REMOVE_NETNAME, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Remove_netname_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleRemove_netname_directive; |
| } |
| |
| void SV3_1aPpParser::Remove_netname_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterRemove_netname_directive(this); |
| } |
| |
| void SV3_1aPpParser::Remove_netname_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitRemove_netname_directive(this); |
| } |
| |
| SV3_1aPpParser::Remove_netname_directiveContext* SV3_1aPpParser::remove_netname_directive() { |
| Remove_netname_directiveContext *_localctx = _tracker.createInstance<Remove_netname_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 162, SV3_1aPpParser::RuleRemove_netname_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(928); |
| match(SV3_1aPpParser::TICK_REMOVE_NETNAME); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Noremove_netnames_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Noremove_netnames_directive_one_lineContext::Noremove_netnames_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Noremove_netnames_directiveContext* SV3_1aPpParser::Noremove_netnames_directive_one_lineContext::noremove_netnames_directive() { |
| return getRuleContext<SV3_1aPpParser::Noremove_netnames_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Noremove_netnames_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Noremove_netnames_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Noremove_netnames_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Noremove_netnames_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNoremove_netnames_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Noremove_netnames_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNoremove_netnames_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Noremove_netnames_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNoremove_netnames_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Noremove_netnames_directive_one_lineContext* SV3_1aPpParser::noremove_netnames_directive_one_line() { |
| Noremove_netnames_directive_one_lineContext *_localctx = _tracker.createInstance<Noremove_netnames_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 164, SV3_1aPpParser::RuleNoremove_netnames_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(930); |
| noremove_netnames_directive(); |
| setState(934); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(931); |
| match(SV3_1aPpParser::Spaces); |
| setState(936); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(937); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Noremove_netnames_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Noremove_netnames_directiveContext::Noremove_netnames_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Noremove_netnames_directiveContext::TICK_NOREMOVE_NETNAMES() { |
| return getToken(SV3_1aPpParser::TICK_NOREMOVE_NETNAMES, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Noremove_netnames_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNoremove_netnames_directive; |
| } |
| |
| void SV3_1aPpParser::Noremove_netnames_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNoremove_netnames_directive(this); |
| } |
| |
| void SV3_1aPpParser::Noremove_netnames_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNoremove_netnames_directive(this); |
| } |
| |
| SV3_1aPpParser::Noremove_netnames_directiveContext* SV3_1aPpParser::noremove_netnames_directive() { |
| Noremove_netnames_directiveContext *_localctx = _tracker.createInstance<Noremove_netnames_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 166, SV3_1aPpParser::RuleNoremove_netnames_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(939); |
| match(SV3_1aPpParser::TICK_NOREMOVE_NETNAMES); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Accelerate_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Accelerate_directive_one_lineContext::Accelerate_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Accelerate_directiveContext* SV3_1aPpParser::Accelerate_directive_one_lineContext::accelerate_directive() { |
| return getRuleContext<SV3_1aPpParser::Accelerate_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Accelerate_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Accelerate_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Accelerate_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Accelerate_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleAccelerate_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Accelerate_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterAccelerate_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Accelerate_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitAccelerate_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Accelerate_directive_one_lineContext* SV3_1aPpParser::accelerate_directive_one_line() { |
| Accelerate_directive_one_lineContext *_localctx = _tracker.createInstance<Accelerate_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 168, SV3_1aPpParser::RuleAccelerate_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(941); |
| accelerate_directive(); |
| setState(945); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(942); |
| match(SV3_1aPpParser::Spaces); |
| setState(947); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(948); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Accelerate_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Accelerate_directiveContext::Accelerate_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Accelerate_directiveContext::TICK_ACCELERATE() { |
| return getToken(SV3_1aPpParser::TICK_ACCELERATE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Accelerate_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleAccelerate_directive; |
| } |
| |
| void SV3_1aPpParser::Accelerate_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterAccelerate_directive(this); |
| } |
| |
| void SV3_1aPpParser::Accelerate_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitAccelerate_directive(this); |
| } |
| |
| SV3_1aPpParser::Accelerate_directiveContext* SV3_1aPpParser::accelerate_directive() { |
| Accelerate_directiveContext *_localctx = _tracker.createInstance<Accelerate_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 170, SV3_1aPpParser::RuleAccelerate_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(950); |
| match(SV3_1aPpParser::TICK_ACCELERATE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Noaccelerate_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Noaccelerate_directive_one_lineContext::Noaccelerate_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Noaccelerate_directiveContext* SV3_1aPpParser::Noaccelerate_directive_one_lineContext::noaccelerate_directive() { |
| return getRuleContext<SV3_1aPpParser::Noaccelerate_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Noaccelerate_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Noaccelerate_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Noaccelerate_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Noaccelerate_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNoaccelerate_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Noaccelerate_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNoaccelerate_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Noaccelerate_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNoaccelerate_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Noaccelerate_directive_one_lineContext* SV3_1aPpParser::noaccelerate_directive_one_line() { |
| Noaccelerate_directive_one_lineContext *_localctx = _tracker.createInstance<Noaccelerate_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 172, SV3_1aPpParser::RuleNoaccelerate_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(952); |
| noaccelerate_directive(); |
| setState(956); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(953); |
| match(SV3_1aPpParser::Spaces); |
| setState(958); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(959); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Noaccelerate_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Noaccelerate_directiveContext::Noaccelerate_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Noaccelerate_directiveContext::TICK_NOACCELERATE() { |
| return getToken(SV3_1aPpParser::TICK_NOACCELERATE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Noaccelerate_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNoaccelerate_directive; |
| } |
| |
| void SV3_1aPpParser::Noaccelerate_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNoaccelerate_directive(this); |
| } |
| |
| void SV3_1aPpParser::Noaccelerate_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNoaccelerate_directive(this); |
| } |
| |
| SV3_1aPpParser::Noaccelerate_directiveContext* SV3_1aPpParser::noaccelerate_directive() { |
| Noaccelerate_directiveContext *_localctx = _tracker.createInstance<Noaccelerate_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 174, SV3_1aPpParser::RuleNoaccelerate_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(961); |
| match(SV3_1aPpParser::TICK_NOACCELERATE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Default_trireg_strenght_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Default_trireg_strenght_directive_one_lineContext::Default_trireg_strenght_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Default_trireg_strenght_directiveContext* SV3_1aPpParser::Default_trireg_strenght_directive_one_lineContext::default_trireg_strenght_directive() { |
| return getRuleContext<SV3_1aPpParser::Default_trireg_strenght_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_trireg_strenght_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Default_trireg_strenght_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_trireg_strenght_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Default_trireg_strenght_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDefault_trireg_strenght_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Default_trireg_strenght_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDefault_trireg_strenght_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Default_trireg_strenght_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDefault_trireg_strenght_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Default_trireg_strenght_directive_one_lineContext* SV3_1aPpParser::default_trireg_strenght_directive_one_line() { |
| Default_trireg_strenght_directive_one_lineContext *_localctx = _tracker.createInstance<Default_trireg_strenght_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 176, SV3_1aPpParser::RuleDefault_trireg_strenght_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(963); |
| default_trireg_strenght_directive(); |
| setState(967); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(964); |
| match(SV3_1aPpParser::Spaces); |
| setState(969); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(970); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Default_trireg_strenght_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Default_trireg_strenght_directiveContext::Default_trireg_strenght_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_trireg_strenght_directiveContext::TICK_DEFAULT_TRIREG_STRENGTH() { |
| return getToken(SV3_1aPpParser::TICK_DEFAULT_TRIREG_STRENGTH, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_trireg_strenght_directiveContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::Default_trireg_strenght_directiveContext::number() { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Default_trireg_strenght_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDefault_trireg_strenght_directive; |
| } |
| |
| void SV3_1aPpParser::Default_trireg_strenght_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDefault_trireg_strenght_directive(this); |
| } |
| |
| void SV3_1aPpParser::Default_trireg_strenght_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDefault_trireg_strenght_directive(this); |
| } |
| |
| SV3_1aPpParser::Default_trireg_strenght_directiveContext* SV3_1aPpParser::default_trireg_strenght_directive() { |
| Default_trireg_strenght_directiveContext *_localctx = _tracker.createInstance<Default_trireg_strenght_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 178, SV3_1aPpParser::RuleDefault_trireg_strenght_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(972); |
| match(SV3_1aPpParser::TICK_DEFAULT_TRIREG_STRENGTH); |
| setState(973); |
| match(SV3_1aPpParser::Spaces); |
| setState(974); |
| number(); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Default_decay_time_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Default_decay_time_directive_one_lineContext::Default_decay_time_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Default_decay_time_directiveContext* SV3_1aPpParser::Default_decay_time_directive_one_lineContext::default_decay_time_directive() { |
| return getRuleContext<SV3_1aPpParser::Default_decay_time_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_decay_time_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Default_decay_time_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_decay_time_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Default_decay_time_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDefault_decay_time_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Default_decay_time_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDefault_decay_time_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Default_decay_time_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDefault_decay_time_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Default_decay_time_directive_one_lineContext* SV3_1aPpParser::default_decay_time_directive_one_line() { |
| Default_decay_time_directive_one_lineContext *_localctx = _tracker.createInstance<Default_decay_time_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 180, SV3_1aPpParser::RuleDefault_decay_time_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(976); |
| default_decay_time_directive(); |
| setState(980); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(977); |
| match(SV3_1aPpParser::Spaces); |
| setState(982); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(983); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Default_decay_time_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Default_decay_time_directiveContext::Default_decay_time_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_decay_time_directiveContext::TICK_DEFAULT_DECAY_TIME() { |
| return getToken(SV3_1aPpParser::TICK_DEFAULT_DECAY_TIME, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_decay_time_directiveContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::Default_decay_time_directiveContext::number() { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_decay_time_directiveContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_decay_time_directiveContext::Fixed_point_number() { |
| return getToken(SV3_1aPpParser::Fixed_point_number, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Default_decay_time_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDefault_decay_time_directive; |
| } |
| |
| void SV3_1aPpParser::Default_decay_time_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDefault_decay_time_directive(this); |
| } |
| |
| void SV3_1aPpParser::Default_decay_time_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDefault_decay_time_directive(this); |
| } |
| |
| SV3_1aPpParser::Default_decay_time_directiveContext* SV3_1aPpParser::default_decay_time_directive() { |
| Default_decay_time_directiveContext *_localctx = _tracker.createInstance<Default_decay_time_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 182, SV3_1aPpParser::RuleDefault_decay_time_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(985); |
| match(SV3_1aPpParser::TICK_DEFAULT_DECAY_TIME); |
| setState(986); |
| match(SV3_1aPpParser::Spaces); |
| setState(990); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Number: { |
| setState(987); |
| number(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(988); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Fixed_point_number: { |
| setState(989); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Unconnected_drive_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Unconnected_drive_directive_one_lineContext::Unconnected_drive_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Unconnected_drive_directiveContext* SV3_1aPpParser::Unconnected_drive_directive_one_lineContext::unconnected_drive_directive() { |
| return getRuleContext<SV3_1aPpParser::Unconnected_drive_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Unconnected_drive_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Unconnected_drive_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Unconnected_drive_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Unconnected_drive_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleUnconnected_drive_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Unconnected_drive_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterUnconnected_drive_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Unconnected_drive_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitUnconnected_drive_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Unconnected_drive_directive_one_lineContext* SV3_1aPpParser::unconnected_drive_directive_one_line() { |
| Unconnected_drive_directive_one_lineContext *_localctx = _tracker.createInstance<Unconnected_drive_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 184, SV3_1aPpParser::RuleUnconnected_drive_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(992); |
| unconnected_drive_directive(); |
| setState(996); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(993); |
| match(SV3_1aPpParser::Spaces); |
| setState(998); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(999); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Unconnected_drive_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Unconnected_drive_directiveContext::Unconnected_drive_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Unconnected_drive_directiveContext::TICK_UNCONNECTED_DRIVE() { |
| return getToken(SV3_1aPpParser::TICK_UNCONNECTED_DRIVE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Unconnected_drive_directiveContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Unconnected_drive_directiveContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Unconnected_drive_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleUnconnected_drive_directive; |
| } |
| |
| void SV3_1aPpParser::Unconnected_drive_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterUnconnected_drive_directive(this); |
| } |
| |
| void SV3_1aPpParser::Unconnected_drive_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitUnconnected_drive_directive(this); |
| } |
| |
| SV3_1aPpParser::Unconnected_drive_directiveContext* SV3_1aPpParser::unconnected_drive_directive() { |
| Unconnected_drive_directiveContext *_localctx = _tracker.createInstance<Unconnected_drive_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 186, SV3_1aPpParser::RuleUnconnected_drive_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1001); |
| match(SV3_1aPpParser::TICK_UNCONNECTED_DRIVE); |
| setState(1002); |
| match(SV3_1aPpParser::Spaces); |
| setState(1003); |
| match(SV3_1aPpParser::Simple_identifier); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Nounconnected_drive_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Nounconnected_drive_directive_one_lineContext::Nounconnected_drive_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Nounconnected_drive_directiveContext* SV3_1aPpParser::Nounconnected_drive_directive_one_lineContext::nounconnected_drive_directive() { |
| return getRuleContext<SV3_1aPpParser::Nounconnected_drive_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Nounconnected_drive_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Nounconnected_drive_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Nounconnected_drive_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Nounconnected_drive_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNounconnected_drive_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Nounconnected_drive_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNounconnected_drive_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Nounconnected_drive_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNounconnected_drive_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Nounconnected_drive_directive_one_lineContext* SV3_1aPpParser::nounconnected_drive_directive_one_line() { |
| Nounconnected_drive_directive_one_lineContext *_localctx = _tracker.createInstance<Nounconnected_drive_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 188, SV3_1aPpParser::RuleNounconnected_drive_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1005); |
| nounconnected_drive_directive(); |
| setState(1009); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(1006); |
| match(SV3_1aPpParser::Spaces); |
| setState(1011); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1012); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Nounconnected_drive_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Nounconnected_drive_directiveContext::Nounconnected_drive_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Nounconnected_drive_directiveContext::TICK_NOUNCONNECTED_DRIVE() { |
| return getToken(SV3_1aPpParser::TICK_NOUNCONNECTED_DRIVE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Nounconnected_drive_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleNounconnected_drive_directive; |
| } |
| |
| void SV3_1aPpParser::Nounconnected_drive_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterNounconnected_drive_directive(this); |
| } |
| |
| void SV3_1aPpParser::Nounconnected_drive_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitNounconnected_drive_directive(this); |
| } |
| |
| SV3_1aPpParser::Nounconnected_drive_directiveContext* SV3_1aPpParser::nounconnected_drive_directive() { |
| Nounconnected_drive_directiveContext *_localctx = _tracker.createInstance<Nounconnected_drive_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 190, SV3_1aPpParser::RuleNounconnected_drive_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1014); |
| match(SV3_1aPpParser::TICK_NOUNCONNECTED_DRIVE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Delay_mode_distributed_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Delay_mode_distributed_directive_one_lineContext::Delay_mode_distributed_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Delay_mode_distributed_directiveContext* SV3_1aPpParser::Delay_mode_distributed_directive_one_lineContext::delay_mode_distributed_directive() { |
| return getRuleContext<SV3_1aPpParser::Delay_mode_distributed_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Delay_mode_distributed_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Delay_mode_distributed_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Delay_mode_distributed_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Delay_mode_distributed_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDelay_mode_distributed_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Delay_mode_distributed_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDelay_mode_distributed_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Delay_mode_distributed_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDelay_mode_distributed_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Delay_mode_distributed_directive_one_lineContext* SV3_1aPpParser::delay_mode_distributed_directive_one_line() { |
| Delay_mode_distributed_directive_one_lineContext *_localctx = _tracker.createInstance<Delay_mode_distributed_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 192, SV3_1aPpParser::RuleDelay_mode_distributed_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1016); |
| delay_mode_distributed_directive(); |
| setState(1020); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(1017); |
| match(SV3_1aPpParser::Spaces); |
| setState(1022); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1023); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Delay_mode_distributed_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Delay_mode_distributed_directiveContext::Delay_mode_distributed_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Delay_mode_distributed_directiveContext::TICK_DELAY_MODE_DISTRIBUTED() { |
| return getToken(SV3_1aPpParser::TICK_DELAY_MODE_DISTRIBUTED, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Delay_mode_distributed_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDelay_mode_distributed_directive; |
| } |
| |
| void SV3_1aPpParser::Delay_mode_distributed_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDelay_mode_distributed_directive(this); |
| } |
| |
| void SV3_1aPpParser::Delay_mode_distributed_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDelay_mode_distributed_directive(this); |
| } |
| |
| SV3_1aPpParser::Delay_mode_distributed_directiveContext* SV3_1aPpParser::delay_mode_distributed_directive() { |
| Delay_mode_distributed_directiveContext *_localctx = _tracker.createInstance<Delay_mode_distributed_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 194, SV3_1aPpParser::RuleDelay_mode_distributed_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1025); |
| match(SV3_1aPpParser::TICK_DELAY_MODE_DISTRIBUTED); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Delay_mode_path_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Delay_mode_path_directive_one_lineContext::Delay_mode_path_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Delay_mode_path_directiveContext* SV3_1aPpParser::Delay_mode_path_directive_one_lineContext::delay_mode_path_directive() { |
| return getRuleContext<SV3_1aPpParser::Delay_mode_path_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Delay_mode_path_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Delay_mode_path_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Delay_mode_path_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Delay_mode_path_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDelay_mode_path_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Delay_mode_path_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDelay_mode_path_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Delay_mode_path_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDelay_mode_path_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Delay_mode_path_directive_one_lineContext* SV3_1aPpParser::delay_mode_path_directive_one_line() { |
| Delay_mode_path_directive_one_lineContext *_localctx = _tracker.createInstance<Delay_mode_path_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 196, SV3_1aPpParser::RuleDelay_mode_path_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1027); |
| delay_mode_path_directive(); |
| setState(1031); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(1028); |
| match(SV3_1aPpParser::Spaces); |
| setState(1033); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1034); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Delay_mode_path_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Delay_mode_path_directiveContext::Delay_mode_path_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Delay_mode_path_directiveContext::TICK_DELAY_MODE_PATH() { |
| return getToken(SV3_1aPpParser::TICK_DELAY_MODE_PATH, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Delay_mode_path_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDelay_mode_path_directive; |
| } |
| |
| void SV3_1aPpParser::Delay_mode_path_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDelay_mode_path_directive(this); |
| } |
| |
| void SV3_1aPpParser::Delay_mode_path_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDelay_mode_path_directive(this); |
| } |
| |
| SV3_1aPpParser::Delay_mode_path_directiveContext* SV3_1aPpParser::delay_mode_path_directive() { |
| Delay_mode_path_directiveContext *_localctx = _tracker.createInstance<Delay_mode_path_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 198, SV3_1aPpParser::RuleDelay_mode_path_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1036); |
| match(SV3_1aPpParser::TICK_DELAY_MODE_PATH); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Delay_mode_unit_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Delay_mode_unit_directive_one_lineContext::Delay_mode_unit_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Delay_mode_unit_directiveContext* SV3_1aPpParser::Delay_mode_unit_directive_one_lineContext::delay_mode_unit_directive() { |
| return getRuleContext<SV3_1aPpParser::Delay_mode_unit_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Delay_mode_unit_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Delay_mode_unit_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Delay_mode_unit_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Delay_mode_unit_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDelay_mode_unit_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Delay_mode_unit_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDelay_mode_unit_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Delay_mode_unit_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDelay_mode_unit_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Delay_mode_unit_directive_one_lineContext* SV3_1aPpParser::delay_mode_unit_directive_one_line() { |
| Delay_mode_unit_directive_one_lineContext *_localctx = _tracker.createInstance<Delay_mode_unit_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 200, SV3_1aPpParser::RuleDelay_mode_unit_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1038); |
| delay_mode_unit_directive(); |
| setState(1042); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(1039); |
| match(SV3_1aPpParser::Spaces); |
| setState(1044); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1045); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Delay_mode_unit_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Delay_mode_unit_directiveContext::Delay_mode_unit_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Delay_mode_unit_directiveContext::TICK_DELAY_MODE_UNIT() { |
| return getToken(SV3_1aPpParser::TICK_DELAY_MODE_UNIT, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Delay_mode_unit_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDelay_mode_unit_directive; |
| } |
| |
| void SV3_1aPpParser::Delay_mode_unit_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDelay_mode_unit_directive(this); |
| } |
| |
| void SV3_1aPpParser::Delay_mode_unit_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDelay_mode_unit_directive(this); |
| } |
| |
| SV3_1aPpParser::Delay_mode_unit_directiveContext* SV3_1aPpParser::delay_mode_unit_directive() { |
| Delay_mode_unit_directiveContext *_localctx = _tracker.createInstance<Delay_mode_unit_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 202, SV3_1aPpParser::RuleDelay_mode_unit_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1047); |
| match(SV3_1aPpParser::TICK_DELAY_MODE_UNIT); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Delay_mode_zero_directive_one_lineContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Delay_mode_zero_directive_one_lineContext::Delay_mode_zero_directive_one_lineContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Delay_mode_zero_directiveContext* SV3_1aPpParser::Delay_mode_zero_directive_one_lineContext::delay_mode_zero_directive() { |
| return getRuleContext<SV3_1aPpParser::Delay_mode_zero_directiveContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Delay_mode_zero_directive_one_lineContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Delay_mode_zero_directive_one_lineContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Delay_mode_zero_directive_one_lineContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Delay_mode_zero_directive_one_lineContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDelay_mode_zero_directive_one_line; |
| } |
| |
| void SV3_1aPpParser::Delay_mode_zero_directive_one_lineContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDelay_mode_zero_directive_one_line(this); |
| } |
| |
| void SV3_1aPpParser::Delay_mode_zero_directive_one_lineContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDelay_mode_zero_directive_one_line(this); |
| } |
| |
| SV3_1aPpParser::Delay_mode_zero_directive_one_lineContext* SV3_1aPpParser::delay_mode_zero_directive_one_line() { |
| Delay_mode_zero_directive_one_lineContext *_localctx = _tracker.createInstance<Delay_mode_zero_directive_one_lineContext>(_ctx, getState()); |
| enterRule(_localctx, 204, SV3_1aPpParser::RuleDelay_mode_zero_directive_one_line); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1049); |
| delay_mode_zero_directive(); |
| setState(1053); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(1050); |
| match(SV3_1aPpParser::Spaces); |
| setState(1055); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1056); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Delay_mode_zero_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Delay_mode_zero_directiveContext::Delay_mode_zero_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Delay_mode_zero_directiveContext::TICK_DELAY_MODE_ZERO() { |
| return getToken(SV3_1aPpParser::TICK_DELAY_MODE_ZERO, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Delay_mode_zero_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDelay_mode_zero_directive; |
| } |
| |
| void SV3_1aPpParser::Delay_mode_zero_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDelay_mode_zero_directive(this); |
| } |
| |
| void SV3_1aPpParser::Delay_mode_zero_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDelay_mode_zero_directive(this); |
| } |
| |
| SV3_1aPpParser::Delay_mode_zero_directiveContext* SV3_1aPpParser::delay_mode_zero_directive() { |
| Delay_mode_zero_directiveContext *_localctx = _tracker.createInstance<Delay_mode_zero_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 206, SV3_1aPpParser::RuleDelay_mode_zero_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1058); |
| match(SV3_1aPpParser::TICK_DELAY_MODE_ZERO); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Undefineall_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Undefineall_directiveContext::Undefineall_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Undefineall_directiveContext::TICK_UNDEFINEALL() { |
| return getToken(SV3_1aPpParser::TICK_UNDEFINEALL, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Undefineall_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleUndefineall_directive; |
| } |
| |
| void SV3_1aPpParser::Undefineall_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterUndefineall_directive(this); |
| } |
| |
| void SV3_1aPpParser::Undefineall_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitUndefineall_directive(this); |
| } |
| |
| SV3_1aPpParser::Undefineall_directiveContext* SV3_1aPpParser::undefineall_directive() { |
| Undefineall_directiveContext *_localctx = _tracker.createInstance<Undefineall_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 208, SV3_1aPpParser::RuleUndefineall_directive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1060); |
| match(SV3_1aPpParser::TICK_UNDEFINEALL); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- ModuleContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::ModuleContext::ModuleContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::ModuleContext::MODULE() { |
| return getToken(SV3_1aPpParser::MODULE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::ModuleContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleModule; |
| } |
| |
| void SV3_1aPpParser::ModuleContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterModule(this); |
| } |
| |
| void SV3_1aPpParser::ModuleContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitModule(this); |
| } |
| |
| SV3_1aPpParser::ModuleContext* SV3_1aPpParser::module() { |
| ModuleContext *_localctx = _tracker.createInstance<ModuleContext>(_ctx, getState()); |
| enterRule(_localctx, 210, SV3_1aPpParser::RuleModule); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1062); |
| match(SV3_1aPpParser::MODULE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- EndmoduleContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::EndmoduleContext::EndmoduleContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::EndmoduleContext::ENDMODULE() { |
| return getToken(SV3_1aPpParser::ENDMODULE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::EndmoduleContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndmodule; |
| } |
| |
| void SV3_1aPpParser::EndmoduleContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndmodule(this); |
| } |
| |
| void SV3_1aPpParser::EndmoduleContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndmodule(this); |
| } |
| |
| SV3_1aPpParser::EndmoduleContext* SV3_1aPpParser::endmodule() { |
| EndmoduleContext *_localctx = _tracker.createInstance<EndmoduleContext>(_ctx, getState()); |
| enterRule(_localctx, 212, SV3_1aPpParser::RuleEndmodule); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1064); |
| match(SV3_1aPpParser::ENDMODULE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Sv_interfaceContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Sv_interfaceContext::Sv_interfaceContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Sv_interfaceContext::INTERFACE() { |
| return getToken(SV3_1aPpParser::INTERFACE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Sv_interfaceContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSv_interface; |
| } |
| |
| void SV3_1aPpParser::Sv_interfaceContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSv_interface(this); |
| } |
| |
| void SV3_1aPpParser::Sv_interfaceContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSv_interface(this); |
| } |
| |
| SV3_1aPpParser::Sv_interfaceContext* SV3_1aPpParser::sv_interface() { |
| Sv_interfaceContext *_localctx = _tracker.createInstance<Sv_interfaceContext>(_ctx, getState()); |
| enterRule(_localctx, 214, SV3_1aPpParser::RuleSv_interface); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1066); |
| match(SV3_1aPpParser::INTERFACE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- EndinterfaceContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::EndinterfaceContext::EndinterfaceContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::EndinterfaceContext::ENDINTERFACE() { |
| return getToken(SV3_1aPpParser::ENDINTERFACE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::EndinterfaceContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndinterface; |
| } |
| |
| void SV3_1aPpParser::EndinterfaceContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndinterface(this); |
| } |
| |
| void SV3_1aPpParser::EndinterfaceContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndinterface(this); |
| } |
| |
| SV3_1aPpParser::EndinterfaceContext* SV3_1aPpParser::endinterface() { |
| EndinterfaceContext *_localctx = _tracker.createInstance<EndinterfaceContext>(_ctx, getState()); |
| enterRule(_localctx, 216, SV3_1aPpParser::RuleEndinterface); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1068); |
| match(SV3_1aPpParser::ENDINTERFACE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- ProgramContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::ProgramContext::ProgramContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::ProgramContext::PROGRAM() { |
| return getToken(SV3_1aPpParser::PROGRAM, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::ProgramContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleProgram; |
| } |
| |
| void SV3_1aPpParser::ProgramContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterProgram(this); |
| } |
| |
| void SV3_1aPpParser::ProgramContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitProgram(this); |
| } |
| |
| SV3_1aPpParser::ProgramContext* SV3_1aPpParser::program() { |
| ProgramContext *_localctx = _tracker.createInstance<ProgramContext>(_ctx, getState()); |
| enterRule(_localctx, 218, SV3_1aPpParser::RuleProgram); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1070); |
| match(SV3_1aPpParser::PROGRAM); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- EndprogramContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::EndprogramContext::EndprogramContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::EndprogramContext::ENDPROGRAM() { |
| return getToken(SV3_1aPpParser::ENDPROGRAM, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::EndprogramContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndprogram; |
| } |
| |
| void SV3_1aPpParser::EndprogramContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndprogram(this); |
| } |
| |
| void SV3_1aPpParser::EndprogramContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndprogram(this); |
| } |
| |
| SV3_1aPpParser::EndprogramContext* SV3_1aPpParser::endprogram() { |
| EndprogramContext *_localctx = _tracker.createInstance<EndprogramContext>(_ctx, getState()); |
| enterRule(_localctx, 220, SV3_1aPpParser::RuleEndprogram); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1072); |
| match(SV3_1aPpParser::ENDPROGRAM); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- PrimitiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::PrimitiveContext::PrimitiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::PrimitiveContext::PRIMITIVE() { |
| return getToken(SV3_1aPpParser::PRIMITIVE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::PrimitiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RulePrimitive; |
| } |
| |
| void SV3_1aPpParser::PrimitiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterPrimitive(this); |
| } |
| |
| void SV3_1aPpParser::PrimitiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitPrimitive(this); |
| } |
| |
| SV3_1aPpParser::PrimitiveContext* SV3_1aPpParser::primitive() { |
| PrimitiveContext *_localctx = _tracker.createInstance<PrimitiveContext>(_ctx, getState()); |
| enterRule(_localctx, 222, SV3_1aPpParser::RulePrimitive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1074); |
| match(SV3_1aPpParser::PRIMITIVE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- EndprimitiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::EndprimitiveContext::EndprimitiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::EndprimitiveContext::ENDPRIMITIVE() { |
| return getToken(SV3_1aPpParser::ENDPRIMITIVE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::EndprimitiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndprimitive; |
| } |
| |
| void SV3_1aPpParser::EndprimitiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndprimitive(this); |
| } |
| |
| void SV3_1aPpParser::EndprimitiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndprimitive(this); |
| } |
| |
| SV3_1aPpParser::EndprimitiveContext* SV3_1aPpParser::endprimitive() { |
| EndprimitiveContext *_localctx = _tracker.createInstance<EndprimitiveContext>(_ctx, getState()); |
| enterRule(_localctx, 224, SV3_1aPpParser::RuleEndprimitive); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1076); |
| match(SV3_1aPpParser::ENDPRIMITIVE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Sv_packageContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Sv_packageContext::Sv_packageContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Sv_packageContext::PACKAGE() { |
| return getToken(SV3_1aPpParser::PACKAGE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Sv_packageContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSv_package; |
| } |
| |
| void SV3_1aPpParser::Sv_packageContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSv_package(this); |
| } |
| |
| void SV3_1aPpParser::Sv_packageContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSv_package(this); |
| } |
| |
| SV3_1aPpParser::Sv_packageContext* SV3_1aPpParser::sv_package() { |
| Sv_packageContext *_localctx = _tracker.createInstance<Sv_packageContext>(_ctx, getState()); |
| enterRule(_localctx, 226, SV3_1aPpParser::RuleSv_package); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1078); |
| match(SV3_1aPpParser::PACKAGE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- EndpackageContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::EndpackageContext::EndpackageContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::EndpackageContext::ENDPACKAGE() { |
| return getToken(SV3_1aPpParser::ENDPACKAGE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::EndpackageContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndpackage; |
| } |
| |
| void SV3_1aPpParser::EndpackageContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndpackage(this); |
| } |
| |
| void SV3_1aPpParser::EndpackageContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndpackage(this); |
| } |
| |
| SV3_1aPpParser::EndpackageContext* SV3_1aPpParser::endpackage() { |
| EndpackageContext *_localctx = _tracker.createInstance<EndpackageContext>(_ctx, getState()); |
| enterRule(_localctx, 228, SV3_1aPpParser::RuleEndpackage); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1080); |
| match(SV3_1aPpParser::ENDPACKAGE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- CheckerContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::CheckerContext::CheckerContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::CheckerContext::CHECKER() { |
| return getToken(SV3_1aPpParser::CHECKER, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::CheckerContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleChecker; |
| } |
| |
| void SV3_1aPpParser::CheckerContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterChecker(this); |
| } |
| |
| void SV3_1aPpParser::CheckerContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitChecker(this); |
| } |
| |
| SV3_1aPpParser::CheckerContext* SV3_1aPpParser::checker() { |
| CheckerContext *_localctx = _tracker.createInstance<CheckerContext>(_ctx, getState()); |
| enterRule(_localctx, 230, SV3_1aPpParser::RuleChecker); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1082); |
| match(SV3_1aPpParser::CHECKER); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- EndcheckerContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::EndcheckerContext::EndcheckerContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::EndcheckerContext::ENDCHECKER() { |
| return getToken(SV3_1aPpParser::ENDCHECKER, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::EndcheckerContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndchecker; |
| } |
| |
| void SV3_1aPpParser::EndcheckerContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndchecker(this); |
| } |
| |
| void SV3_1aPpParser::EndcheckerContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndchecker(this); |
| } |
| |
| SV3_1aPpParser::EndcheckerContext* SV3_1aPpParser::endchecker() { |
| EndcheckerContext *_localctx = _tracker.createInstance<EndcheckerContext>(_ctx, getState()); |
| enterRule(_localctx, 232, SV3_1aPpParser::RuleEndchecker); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1084); |
| match(SV3_1aPpParser::ENDCHECKER); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- ConfigContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::ConfigContext::ConfigContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::ConfigContext::CONFIG() { |
| return getToken(SV3_1aPpParser::CONFIG, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::ConfigContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleConfig; |
| } |
| |
| void SV3_1aPpParser::ConfigContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterConfig(this); |
| } |
| |
| void SV3_1aPpParser::ConfigContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitConfig(this); |
| } |
| |
| SV3_1aPpParser::ConfigContext* SV3_1aPpParser::config() { |
| ConfigContext *_localctx = _tracker.createInstance<ConfigContext>(_ctx, getState()); |
| enterRule(_localctx, 234, SV3_1aPpParser::RuleConfig); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1086); |
| match(SV3_1aPpParser::CONFIG); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- EndconfigContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::EndconfigContext::EndconfigContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::EndconfigContext::ENDCONFIG() { |
| return getToken(SV3_1aPpParser::ENDCONFIG, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::EndconfigContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEndconfig; |
| } |
| |
| void SV3_1aPpParser::EndconfigContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEndconfig(this); |
| } |
| |
| void SV3_1aPpParser::EndconfigContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEndconfig(this); |
| } |
| |
| SV3_1aPpParser::EndconfigContext* SV3_1aPpParser::endconfig() { |
| EndconfigContext *_localctx = _tracker.createInstance<EndconfigContext>(_ctx, getState()); |
| enterRule(_localctx, 236, SV3_1aPpParser::RuleEndconfig); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1088); |
| match(SV3_1aPpParser::ENDCONFIG); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Define_directiveContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Define_directiveContext::Define_directiveContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Define_directiveContext::TICK_DEFINE() { |
| return getToken(SV3_1aPpParser::TICK_DEFINE, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Define_directiveContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Define_directiveContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Define_directiveContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Define_directiveContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Define_directiveContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Define_directiveContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDefine_directive; |
| } |
| |
| void SV3_1aPpParser::Define_directiveContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDefine_directive(this); |
| } |
| |
| void SV3_1aPpParser::Define_directiveContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDefine_directive(this); |
| } |
| |
| SV3_1aPpParser::Define_directiveContext* SV3_1aPpParser::define_directive() { |
| Define_directiveContext *_localctx = _tracker.createInstance<Define_directiveContext>(_ctx, getState()); |
| enterRule(_localctx, 238, SV3_1aPpParser::RuleDefine_directive); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1090); |
| match(SV3_1aPpParser::TICK_DEFINE); |
| setState(1091); |
| match(SV3_1aPpParser::Spaces); |
| setState(1092); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::Simple_identifier |
| |
| || _la == SV3_1aPpParser::Escaped_identifier)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| setState(1096); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(1093); |
| match(SV3_1aPpParser::Spaces); |
| setState(1098); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1099); |
| match(SV3_1aPpParser::CR); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Multiline_no_args_macro_definitionContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Multiline_no_args_macro_definitionContext::Multiline_no_args_macro_definitionContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Multiline_no_args_macro_definitionContext::TICK_DEFINE() { |
| return getToken(SV3_1aPpParser::TICK_DEFINE, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Multiline_no_args_macro_definitionContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Multiline_no_args_macro_definitionContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| SV3_1aPpParser::Escaped_macro_definition_bodyContext* SV3_1aPpParser::Multiline_no_args_macro_definitionContext::escaped_macro_definition_body() { |
| return getRuleContext<SV3_1aPpParser::Escaped_macro_definition_bodyContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Multiline_no_args_macro_definitionContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Multiline_no_args_macro_definitionContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Multiline_no_args_macro_definitionContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleMultiline_no_args_macro_definition; |
| } |
| |
| void SV3_1aPpParser::Multiline_no_args_macro_definitionContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterMultiline_no_args_macro_definition(this); |
| } |
| |
| void SV3_1aPpParser::Multiline_no_args_macro_definitionContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitMultiline_no_args_macro_definition(this); |
| } |
| |
| SV3_1aPpParser::Multiline_no_args_macro_definitionContext* SV3_1aPpParser::multiline_no_args_macro_definition() { |
| Multiline_no_args_macro_definitionContext *_localctx = _tracker.createInstance<Multiline_no_args_macro_definitionContext>(_ctx, getState()); |
| enterRule(_localctx, 240, SV3_1aPpParser::RuleMultiline_no_args_macro_definition); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(1101); |
| match(SV3_1aPpParser::TICK_DEFINE); |
| setState(1102); |
| match(SV3_1aPpParser::Spaces); |
| setState(1103); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::Simple_identifier |
| |
| || _la == SV3_1aPpParser::Escaped_identifier)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| setState(1107); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 80, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(1104); |
| match(SV3_1aPpParser::Spaces); |
| } |
| setState(1109); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 80, _ctx); |
| } |
| setState(1110); |
| escaped_macro_definition_body(); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Multiline_args_macro_definitionContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Multiline_args_macro_definitionContext::Multiline_args_macro_definitionContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Multiline_args_macro_definitionContext::TICK_DEFINE() { |
| return getToken(SV3_1aPpParser::TICK_DEFINE, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Multiline_args_macro_definitionContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Multiline_args_macro_definitionContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| SV3_1aPpParser::Macro_argumentsContext* SV3_1aPpParser::Multiline_args_macro_definitionContext::macro_arguments() { |
| return getRuleContext<SV3_1aPpParser::Macro_argumentsContext>(0); |
| } |
| |
| SV3_1aPpParser::Escaped_macro_definition_bodyContext* SV3_1aPpParser::Multiline_args_macro_definitionContext::escaped_macro_definition_body() { |
| return getRuleContext<SV3_1aPpParser::Escaped_macro_definition_bodyContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Multiline_args_macro_definitionContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Multiline_args_macro_definitionContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Multiline_args_macro_definitionContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleMultiline_args_macro_definition; |
| } |
| |
| void SV3_1aPpParser::Multiline_args_macro_definitionContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterMultiline_args_macro_definition(this); |
| } |
| |
| void SV3_1aPpParser::Multiline_args_macro_definitionContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitMultiline_args_macro_definition(this); |
| } |
| |
| SV3_1aPpParser::Multiline_args_macro_definitionContext* SV3_1aPpParser::multiline_args_macro_definition() { |
| Multiline_args_macro_definitionContext *_localctx = _tracker.createInstance<Multiline_args_macro_definitionContext>(_ctx, getState()); |
| enterRule(_localctx, 242, SV3_1aPpParser::RuleMultiline_args_macro_definition); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(1112); |
| match(SV3_1aPpParser::TICK_DEFINE); |
| setState(1113); |
| match(SV3_1aPpParser::Spaces); |
| setState(1114); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::Simple_identifier |
| |
| || _la == SV3_1aPpParser::Escaped_identifier)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| setState(1115); |
| macro_arguments(); |
| setState(1119); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 81, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(1116); |
| match(SV3_1aPpParser::Spaces); |
| } |
| setState(1121); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 81, _ctx); |
| } |
| setState(1122); |
| escaped_macro_definition_body(); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Simple_no_args_macro_definitionContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Simple_no_args_macro_definitionContext::Simple_no_args_macro_definitionContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_no_args_macro_definitionContext::TICK_DEFINE() { |
| return getToken(SV3_1aPpParser::TICK_DEFINE, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_no_args_macro_definitionContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_no_args_macro_definitionContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| SV3_1aPpParser::Simple_macro_definition_bodyContext* SV3_1aPpParser::Simple_no_args_macro_definitionContext::simple_macro_definition_body() { |
| return getRuleContext<SV3_1aPpParser::Simple_macro_definition_bodyContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_no_args_macro_definitionContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_no_args_macro_definitionContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_no_args_macro_definitionContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_no_args_macro_definitionContext::One_line_comment() { |
| return getToken(SV3_1aPpParser::One_line_comment, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Simple_no_args_macro_definitionContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSimple_no_args_macro_definition; |
| } |
| |
| void SV3_1aPpParser::Simple_no_args_macro_definitionContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSimple_no_args_macro_definition(this); |
| } |
| |
| void SV3_1aPpParser::Simple_no_args_macro_definitionContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSimple_no_args_macro_definition(this); |
| } |
| |
| SV3_1aPpParser::Simple_no_args_macro_definitionContext* SV3_1aPpParser::simple_no_args_macro_definition() { |
| Simple_no_args_macro_definitionContext *_localctx = _tracker.createInstance<Simple_no_args_macro_definitionContext>(_ctx, getState()); |
| enterRule(_localctx, 244, SV3_1aPpParser::RuleSimple_no_args_macro_definition); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(1141); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 83, _ctx)) { |
| case 1: { |
| enterOuterAlt(_localctx, 1); |
| setState(1124); |
| match(SV3_1aPpParser::TICK_DEFINE); |
| setState(1125); |
| match(SV3_1aPpParser::Spaces); |
| setState(1126); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::Simple_identifier |
| |
| || _la == SV3_1aPpParser::Escaped_identifier)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| setState(1127); |
| match(SV3_1aPpParser::Spaces); |
| setState(1128); |
| simple_macro_definition_body(); |
| setState(1129); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::One_line_comment || _la == SV3_1aPpParser::CR)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| break; |
| } |
| |
| case 2: { |
| enterOuterAlt(_localctx, 2); |
| setState(1131); |
| match(SV3_1aPpParser::TICK_DEFINE); |
| setState(1132); |
| match(SV3_1aPpParser::Spaces); |
| setState(1133); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::Simple_identifier |
| |
| || _la == SV3_1aPpParser::Escaped_identifier)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| setState(1137); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(1134); |
| match(SV3_1aPpParser::Spaces); |
| setState(1139); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1140); |
| match(SV3_1aPpParser::CR); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Simple_args_macro_definitionContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Simple_args_macro_definitionContext::Simple_args_macro_definitionContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_args_macro_definitionContext::TICK_DEFINE() { |
| return getToken(SV3_1aPpParser::TICK_DEFINE, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_args_macro_definitionContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_args_macro_definitionContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| SV3_1aPpParser::Macro_argumentsContext* SV3_1aPpParser::Simple_args_macro_definitionContext::macro_arguments() { |
| return getRuleContext<SV3_1aPpParser::Macro_argumentsContext>(0); |
| } |
| |
| SV3_1aPpParser::Simple_macro_definition_bodyContext* SV3_1aPpParser::Simple_args_macro_definitionContext::simple_macro_definition_body() { |
| return getRuleContext<SV3_1aPpParser::Simple_macro_definition_bodyContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_args_macro_definitionContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_args_macro_definitionContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_args_macro_definitionContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_args_macro_definitionContext::One_line_comment() { |
| return getToken(SV3_1aPpParser::One_line_comment, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Simple_args_macro_definitionContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSimple_args_macro_definition; |
| } |
| |
| void SV3_1aPpParser::Simple_args_macro_definitionContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSimple_args_macro_definition(this); |
| } |
| |
| void SV3_1aPpParser::Simple_args_macro_definitionContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSimple_args_macro_definition(this); |
| } |
| |
| SV3_1aPpParser::Simple_args_macro_definitionContext* SV3_1aPpParser::simple_args_macro_definition() { |
| Simple_args_macro_definitionContext *_localctx = _tracker.createInstance<Simple_args_macro_definitionContext>(_ctx, getState()); |
| enterRule(_localctx, 246, SV3_1aPpParser::RuleSimple_args_macro_definition); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(1163); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx)) { |
| case 1: { |
| enterOuterAlt(_localctx, 1); |
| setState(1143); |
| match(SV3_1aPpParser::TICK_DEFINE); |
| setState(1144); |
| match(SV3_1aPpParser::Spaces); |
| setState(1145); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::Simple_identifier |
| |
| || _la == SV3_1aPpParser::Escaped_identifier)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| setState(1146); |
| macro_arguments(); |
| setState(1147); |
| match(SV3_1aPpParser::Spaces); |
| setState(1148); |
| simple_macro_definition_body(); |
| setState(1149); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::One_line_comment || _la == SV3_1aPpParser::CR)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| break; |
| } |
| |
| case 2: { |
| enterOuterAlt(_localctx, 2); |
| setState(1151); |
| match(SV3_1aPpParser::TICK_DEFINE); |
| setState(1152); |
| match(SV3_1aPpParser::Spaces); |
| setState(1153); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::Simple_identifier |
| |
| || _la == SV3_1aPpParser::Escaped_identifier)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| setState(1154); |
| macro_arguments(); |
| setState(1158); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(1155); |
| match(SV3_1aPpParser::Spaces); |
| setState(1160); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1161); |
| match(SV3_1aPpParser::CR); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Identifier_in_macro_bodyContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Identifier_in_macro_bodyContext::Identifier_in_macro_bodyContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Identifier_in_macro_bodyContext::Simple_identifier() { |
| return getTokens(SV3_1aPpParser::Simple_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Identifier_in_macro_bodyContext::Simple_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Simple_identifier, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Identifier_in_macro_bodyContext::TICK_TICK() { |
| return getTokens(SV3_1aPpParser::TICK_TICK); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Identifier_in_macro_bodyContext::TICK_TICK(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_TICK, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Identifier_in_macro_bodyContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleIdentifier_in_macro_body; |
| } |
| |
| void SV3_1aPpParser::Identifier_in_macro_bodyContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterIdentifier_in_macro_body(this); |
| } |
| |
| void SV3_1aPpParser::Identifier_in_macro_bodyContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitIdentifier_in_macro_body(this); |
| } |
| |
| SV3_1aPpParser::Identifier_in_macro_bodyContext* SV3_1aPpParser::identifier_in_macro_body() { |
| Identifier_in_macro_bodyContext *_localctx = _tracker.createInstance<Identifier_in_macro_bodyContext>(_ctx, getState()); |
| enterRule(_localctx, 248, SV3_1aPpParser::RuleIdentifier_in_macro_body); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(1171); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 87, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(1165); |
| match(SV3_1aPpParser::Simple_identifier); |
| setState(1167); |
| _errHandler->sync(this); |
| |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 86, _ctx)) { |
| case 1: { |
| setState(1166); |
| match(SV3_1aPpParser::TICK_TICK); |
| break; |
| } |
| |
| } |
| } |
| setState(1173); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 87, _ctx); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Simple_no_args_macro_definition_in_macro_bodyContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext::Simple_no_args_macro_definition_in_macro_bodyContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext::TICK_DEFINE() { |
| return getToken(SV3_1aPpParser::TICK_DEFINE, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext* SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext::simple_macro_definition_body_in_macro_body() { |
| return getRuleContext<SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext>(0); |
| } |
| |
| SV3_1aPpParser::Identifier_in_macro_bodyContext* SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext::identifier_in_macro_body() { |
| return getRuleContext<SV3_1aPpParser::Identifier_in_macro_bodyContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext::TICK_VARIABLE() { |
| return getToken(SV3_1aPpParser::TICK_VARIABLE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSimple_no_args_macro_definition_in_macro_body; |
| } |
| |
| void SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSimple_no_args_macro_definition_in_macro_body(this); |
| } |
| |
| void SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSimple_no_args_macro_definition_in_macro_body(this); |
| } |
| |
| SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext* SV3_1aPpParser::simple_no_args_macro_definition_in_macro_body() { |
| Simple_no_args_macro_definition_in_macro_bodyContext *_localctx = _tracker.createInstance<Simple_no_args_macro_definition_in_macro_bodyContext>(_ctx, getState()); |
| enterRule(_localctx, 250, SV3_1aPpParser::RuleSimple_no_args_macro_definition_in_macro_body); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| setState(1202); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 92, _ctx)) { |
| case 1: { |
| enterOuterAlt(_localctx, 1); |
| setState(1174); |
| match(SV3_1aPpParser::TICK_DEFINE); |
| setState(1175); |
| match(SV3_1aPpParser::Spaces); |
| setState(1178); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: |
| case SV3_1aPpParser::Spaces: { |
| setState(1176); |
| identifier_in_macro_body(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(1177); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| setState(1180); |
| match(SV3_1aPpParser::Spaces); |
| setState(1181); |
| simple_macro_definition_body_in_macro_body(); |
| break; |
| } |
| |
| case 2: { |
| enterOuterAlt(_localctx, 2); |
| setState(1182); |
| match(SV3_1aPpParser::TICK_DEFINE); |
| setState(1183); |
| match(SV3_1aPpParser::Spaces); |
| setState(1186); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 89, _ctx)) { |
| case 1: { |
| setState(1184); |
| identifier_in_macro_body(); |
| break; |
| } |
| |
| case 2: { |
| setState(1185); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| } |
| setState(1191); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(1188); |
| match(SV3_1aPpParser::Spaces); |
| } |
| setState(1193); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx); |
| } |
| break; |
| } |
| |
| case 3: { |
| enterOuterAlt(_localctx, 3); |
| setState(1194); |
| match(SV3_1aPpParser::TICK_DEFINE); |
| setState(1195); |
| match(SV3_1aPpParser::Spaces); |
| setState(1198); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::TICK_VARIABLE: |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(1196); |
| identifier_in_macro_body(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(1197); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| setState(1200); |
| match(SV3_1aPpParser::TICK_VARIABLE); |
| setState(1201); |
| simple_macro_definition_body_in_macro_body(); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Simple_args_macro_definition_in_macro_bodyContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext::Simple_args_macro_definition_in_macro_bodyContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext::TICK_DEFINE() { |
| return getToken(SV3_1aPpParser::TICK_DEFINE, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| SV3_1aPpParser::Macro_argumentsContext* SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext::macro_arguments() { |
| return getRuleContext<SV3_1aPpParser::Macro_argumentsContext>(0); |
| } |
| |
| SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext* SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext::simple_macro_definition_body_in_macro_body() { |
| return getRuleContext<SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext>(0); |
| } |
| |
| SV3_1aPpParser::Identifier_in_macro_bodyContext* SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext::identifier_in_macro_body() { |
| return getRuleContext<SV3_1aPpParser::Identifier_in_macro_bodyContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSimple_args_macro_definition_in_macro_body; |
| } |
| |
| void SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSimple_args_macro_definition_in_macro_body(this); |
| } |
| |
| void SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSimple_args_macro_definition_in_macro_body(this); |
| } |
| |
| SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext* SV3_1aPpParser::simple_args_macro_definition_in_macro_body() { |
| Simple_args_macro_definition_in_macro_bodyContext *_localctx = _tracker.createInstance<Simple_args_macro_definition_in_macro_bodyContext>(_ctx, getState()); |
| enterRule(_localctx, 252, SV3_1aPpParser::RuleSimple_args_macro_definition_in_macro_body); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(1221); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 95, _ctx)) { |
| case 1: { |
| enterOuterAlt(_localctx, 1); |
| setState(1204); |
| match(SV3_1aPpParser::TICK_DEFINE); |
| setState(1205); |
| match(SV3_1aPpParser::Spaces); |
| setState(1208); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: |
| case SV3_1aPpParser::PARENS_OPEN: { |
| setState(1206); |
| identifier_in_macro_body(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(1207); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| setState(1210); |
| macro_arguments(); |
| setState(1211); |
| match(SV3_1aPpParser::Spaces); |
| setState(1212); |
| simple_macro_definition_body_in_macro_body(); |
| break; |
| } |
| |
| case 2: { |
| enterOuterAlt(_localctx, 2); |
| setState(1214); |
| match(SV3_1aPpParser::TICK_DEFINE); |
| setState(1215); |
| match(SV3_1aPpParser::Spaces); |
| setState(1218); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: |
| case SV3_1aPpParser::PARENS_OPEN: { |
| setState(1216); |
| identifier_in_macro_body(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(1217); |
| match(SV3_1aPpParser::Escaped_identifier); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| setState(1220); |
| macro_arguments(); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Directive_in_macroContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Directive_in_macroContext::Directive_in_macroContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Celldefine_directiveContext* SV3_1aPpParser::Directive_in_macroContext::celldefine_directive() { |
| return getRuleContext<SV3_1aPpParser::Celldefine_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Endcelldefine_directiveContext* SV3_1aPpParser::Directive_in_macroContext::endcelldefine_directive() { |
| return getRuleContext<SV3_1aPpParser::Endcelldefine_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Default_nettype_directiveContext* SV3_1aPpParser::Directive_in_macroContext::default_nettype_directive() { |
| return getRuleContext<SV3_1aPpParser::Default_nettype_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Undef_directiveContext* SV3_1aPpParser::Directive_in_macroContext::undef_directive() { |
| return getRuleContext<SV3_1aPpParser::Undef_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Ifdef_directiveContext* SV3_1aPpParser::Directive_in_macroContext::ifdef_directive() { |
| return getRuleContext<SV3_1aPpParser::Ifdef_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Ifndef_directiveContext* SV3_1aPpParser::Directive_in_macroContext::ifndef_directive() { |
| return getRuleContext<SV3_1aPpParser::Ifndef_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Else_directiveContext* SV3_1aPpParser::Directive_in_macroContext::else_directive() { |
| return getRuleContext<SV3_1aPpParser::Else_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Elsif_directiveContext* SV3_1aPpParser::Directive_in_macroContext::elsif_directive() { |
| return getRuleContext<SV3_1aPpParser::Elsif_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Elseif_directiveContext* SV3_1aPpParser::Directive_in_macroContext::elseif_directive() { |
| return getRuleContext<SV3_1aPpParser::Elseif_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Endif_directiveContext* SV3_1aPpParser::Directive_in_macroContext::endif_directive() { |
| return getRuleContext<SV3_1aPpParser::Endif_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Include_directiveContext* SV3_1aPpParser::Directive_in_macroContext::include_directive() { |
| return getRuleContext<SV3_1aPpParser::Include_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Resetall_directiveContext* SV3_1aPpParser::Directive_in_macroContext::resetall_directive() { |
| return getRuleContext<SV3_1aPpParser::Resetall_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Timescale_directiveContext* SV3_1aPpParser::Directive_in_macroContext::timescale_directive() { |
| return getRuleContext<SV3_1aPpParser::Timescale_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Unconnected_drive_directiveContext* SV3_1aPpParser::Directive_in_macroContext::unconnected_drive_directive() { |
| return getRuleContext<SV3_1aPpParser::Unconnected_drive_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Nounconnected_drive_directiveContext* SV3_1aPpParser::Directive_in_macroContext::nounconnected_drive_directive() { |
| return getRuleContext<SV3_1aPpParser::Nounconnected_drive_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Line_directiveContext* SV3_1aPpParser::Directive_in_macroContext::line_directive() { |
| return getRuleContext<SV3_1aPpParser::Line_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Default_decay_time_directiveContext* SV3_1aPpParser::Directive_in_macroContext::default_decay_time_directive() { |
| return getRuleContext<SV3_1aPpParser::Default_decay_time_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Default_trireg_strenght_directiveContext* SV3_1aPpParser::Directive_in_macroContext::default_trireg_strenght_directive() { |
| return getRuleContext<SV3_1aPpParser::Default_trireg_strenght_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Delay_mode_distributed_directiveContext* SV3_1aPpParser::Directive_in_macroContext::delay_mode_distributed_directive() { |
| return getRuleContext<SV3_1aPpParser::Delay_mode_distributed_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Delay_mode_path_directiveContext* SV3_1aPpParser::Directive_in_macroContext::delay_mode_path_directive() { |
| return getRuleContext<SV3_1aPpParser::Delay_mode_path_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Delay_mode_unit_directiveContext* SV3_1aPpParser::Directive_in_macroContext::delay_mode_unit_directive() { |
| return getRuleContext<SV3_1aPpParser::Delay_mode_unit_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Delay_mode_zero_directiveContext* SV3_1aPpParser::Directive_in_macroContext::delay_mode_zero_directive() { |
| return getRuleContext<SV3_1aPpParser::Delay_mode_zero_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Protect_directiveContext* SV3_1aPpParser::Directive_in_macroContext::protect_directive() { |
| return getRuleContext<SV3_1aPpParser::Protect_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Endprotect_directiveContext* SV3_1aPpParser::Directive_in_macroContext::endprotect_directive() { |
| return getRuleContext<SV3_1aPpParser::Endprotect_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Protected_directiveContext* SV3_1aPpParser::Directive_in_macroContext::protected_directive() { |
| return getRuleContext<SV3_1aPpParser::Protected_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Endprotected_directiveContext* SV3_1aPpParser::Directive_in_macroContext::endprotected_directive() { |
| return getRuleContext<SV3_1aPpParser::Endprotected_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Expand_vectornets_directiveContext* SV3_1aPpParser::Directive_in_macroContext::expand_vectornets_directive() { |
| return getRuleContext<SV3_1aPpParser::Expand_vectornets_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Noexpand_vectornets_directiveContext* SV3_1aPpParser::Directive_in_macroContext::noexpand_vectornets_directive() { |
| return getRuleContext<SV3_1aPpParser::Noexpand_vectornets_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Autoexpand_vectornets_directiveContext* SV3_1aPpParser::Directive_in_macroContext::autoexpand_vectornets_directive() { |
| return getRuleContext<SV3_1aPpParser::Autoexpand_vectornets_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Remove_gatename_directiveContext* SV3_1aPpParser::Directive_in_macroContext::remove_gatename_directive() { |
| return getRuleContext<SV3_1aPpParser::Remove_gatename_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Noremove_gatenames_directiveContext* SV3_1aPpParser::Directive_in_macroContext::noremove_gatenames_directive() { |
| return getRuleContext<SV3_1aPpParser::Noremove_gatenames_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Remove_netname_directiveContext* SV3_1aPpParser::Directive_in_macroContext::remove_netname_directive() { |
| return getRuleContext<SV3_1aPpParser::Remove_netname_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Noremove_netnames_directiveContext* SV3_1aPpParser::Directive_in_macroContext::noremove_netnames_directive() { |
| return getRuleContext<SV3_1aPpParser::Noremove_netnames_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Accelerate_directiveContext* SV3_1aPpParser::Directive_in_macroContext::accelerate_directive() { |
| return getRuleContext<SV3_1aPpParser::Accelerate_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Noaccelerate_directiveContext* SV3_1aPpParser::Directive_in_macroContext::noaccelerate_directive() { |
| return getRuleContext<SV3_1aPpParser::Noaccelerate_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Undefineall_directiveContext* SV3_1aPpParser::Directive_in_macroContext::undefineall_directive() { |
| return getRuleContext<SV3_1aPpParser::Undefineall_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Uselib_directiveContext* SV3_1aPpParser::Directive_in_macroContext::uselib_directive() { |
| return getRuleContext<SV3_1aPpParser::Uselib_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Disable_portfaults_directiveContext* SV3_1aPpParser::Directive_in_macroContext::disable_portfaults_directive() { |
| return getRuleContext<SV3_1aPpParser::Disable_portfaults_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Enable_portfaults_directiveContext* SV3_1aPpParser::Directive_in_macroContext::enable_portfaults_directive() { |
| return getRuleContext<SV3_1aPpParser::Enable_portfaults_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Nosuppress_faults_directiveContext* SV3_1aPpParser::Directive_in_macroContext::nosuppress_faults_directive() { |
| return getRuleContext<SV3_1aPpParser::Nosuppress_faults_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Suppress_faults_directiveContext* SV3_1aPpParser::Directive_in_macroContext::suppress_faults_directive() { |
| return getRuleContext<SV3_1aPpParser::Suppress_faults_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Signed_directiveContext* SV3_1aPpParser::Directive_in_macroContext::signed_directive() { |
| return getRuleContext<SV3_1aPpParser::Signed_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Unsigned_directiveContext* SV3_1aPpParser::Directive_in_macroContext::unsigned_directive() { |
| return getRuleContext<SV3_1aPpParser::Unsigned_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Sv_file_directiveContext* SV3_1aPpParser::Directive_in_macroContext::sv_file_directive() { |
| return getRuleContext<SV3_1aPpParser::Sv_file_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Sv_line_directiveContext* SV3_1aPpParser::Directive_in_macroContext::sv_line_directive() { |
| return getRuleContext<SV3_1aPpParser::Sv_line_directiveContext>(0); |
| } |
| |
| SV3_1aPpParser::Sv_packageContext* SV3_1aPpParser::Directive_in_macroContext::sv_package() { |
| return getRuleContext<SV3_1aPpParser::Sv_packageContext>(0); |
| } |
| |
| SV3_1aPpParser::EndpackageContext* SV3_1aPpParser::Directive_in_macroContext::endpackage() { |
| return getRuleContext<SV3_1aPpParser::EndpackageContext>(0); |
| } |
| |
| SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext* SV3_1aPpParser::Directive_in_macroContext::simple_args_macro_definition_in_macro_body() { |
| return getRuleContext<SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext>(0); |
| } |
| |
| SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext* SV3_1aPpParser::Directive_in_macroContext::simple_no_args_macro_definition_in_macro_body() { |
| return getRuleContext<SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext>(0); |
| } |
| |
| SV3_1aPpParser::Pound_delayContext* SV3_1aPpParser::Directive_in_macroContext::pound_delay() { |
| return getRuleContext<SV3_1aPpParser::Pound_delayContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Directive_in_macroContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDirective_in_macro; |
| } |
| |
| void SV3_1aPpParser::Directive_in_macroContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDirective_in_macro(this); |
| } |
| |
| void SV3_1aPpParser::Directive_in_macroContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDirective_in_macro(this); |
| } |
| |
| SV3_1aPpParser::Directive_in_macroContext* SV3_1aPpParser::directive_in_macro() { |
| Directive_in_macroContext *_localctx = _tracker.createInstance<Directive_in_macroContext>(_ctx, getState()); |
| enterRule(_localctx, 254, SV3_1aPpParser::RuleDirective_in_macro); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(1273); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 96, _ctx)) { |
| case 1: { |
| enterOuterAlt(_localctx, 1); |
| setState(1223); |
| celldefine_directive(); |
| break; |
| } |
| |
| case 2: { |
| enterOuterAlt(_localctx, 2); |
| setState(1224); |
| endcelldefine_directive(); |
| break; |
| } |
| |
| case 3: { |
| enterOuterAlt(_localctx, 3); |
| setState(1225); |
| default_nettype_directive(); |
| break; |
| } |
| |
| case 4: { |
| enterOuterAlt(_localctx, 4); |
| setState(1226); |
| undef_directive(); |
| break; |
| } |
| |
| case 5: { |
| enterOuterAlt(_localctx, 5); |
| setState(1227); |
| ifdef_directive(); |
| break; |
| } |
| |
| case 6: { |
| enterOuterAlt(_localctx, 6); |
| setState(1228); |
| ifndef_directive(); |
| break; |
| } |
| |
| case 7: { |
| enterOuterAlt(_localctx, 7); |
| setState(1229); |
| else_directive(); |
| break; |
| } |
| |
| case 8: { |
| enterOuterAlt(_localctx, 8); |
| setState(1230); |
| elsif_directive(); |
| break; |
| } |
| |
| case 9: { |
| enterOuterAlt(_localctx, 9); |
| setState(1231); |
| elseif_directive(); |
| break; |
| } |
| |
| case 10: { |
| enterOuterAlt(_localctx, 10); |
| setState(1232); |
| endif_directive(); |
| break; |
| } |
| |
| case 11: { |
| enterOuterAlt(_localctx, 11); |
| setState(1233); |
| include_directive(); |
| break; |
| } |
| |
| case 12: { |
| enterOuterAlt(_localctx, 12); |
| setState(1234); |
| resetall_directive(); |
| break; |
| } |
| |
| case 13: { |
| enterOuterAlt(_localctx, 13); |
| setState(1235); |
| timescale_directive(); |
| break; |
| } |
| |
| case 14: { |
| enterOuterAlt(_localctx, 14); |
| setState(1236); |
| unconnected_drive_directive(); |
| break; |
| } |
| |
| case 15: { |
| enterOuterAlt(_localctx, 15); |
| setState(1237); |
| nounconnected_drive_directive(); |
| break; |
| } |
| |
| case 16: { |
| enterOuterAlt(_localctx, 16); |
| setState(1238); |
| line_directive(); |
| break; |
| } |
| |
| case 17: { |
| enterOuterAlt(_localctx, 17); |
| setState(1239); |
| default_decay_time_directive(); |
| break; |
| } |
| |
| case 18: { |
| enterOuterAlt(_localctx, 18); |
| setState(1240); |
| default_trireg_strenght_directive(); |
| break; |
| } |
| |
| case 19: { |
| enterOuterAlt(_localctx, 19); |
| setState(1241); |
| delay_mode_distributed_directive(); |
| break; |
| } |
| |
| case 20: { |
| enterOuterAlt(_localctx, 20); |
| setState(1242); |
| delay_mode_path_directive(); |
| break; |
| } |
| |
| case 21: { |
| enterOuterAlt(_localctx, 21); |
| setState(1243); |
| delay_mode_unit_directive(); |
| break; |
| } |
| |
| case 22: { |
| enterOuterAlt(_localctx, 22); |
| setState(1244); |
| delay_mode_zero_directive(); |
| break; |
| } |
| |
| case 23: { |
| enterOuterAlt(_localctx, 23); |
| setState(1245); |
| protect_directive(); |
| break; |
| } |
| |
| case 24: { |
| enterOuterAlt(_localctx, 24); |
| setState(1246); |
| endprotect_directive(); |
| break; |
| } |
| |
| case 25: { |
| enterOuterAlt(_localctx, 25); |
| setState(1247); |
| protected_directive(); |
| break; |
| } |
| |
| case 26: { |
| enterOuterAlt(_localctx, 26); |
| setState(1248); |
| endprotected_directive(); |
| break; |
| } |
| |
| case 27: { |
| enterOuterAlt(_localctx, 27); |
| setState(1249); |
| expand_vectornets_directive(); |
| break; |
| } |
| |
| case 28: { |
| enterOuterAlt(_localctx, 28); |
| setState(1250); |
| noexpand_vectornets_directive(); |
| break; |
| } |
| |
| case 29: { |
| enterOuterAlt(_localctx, 29); |
| setState(1251); |
| autoexpand_vectornets_directive(); |
| break; |
| } |
| |
| case 30: { |
| enterOuterAlt(_localctx, 30); |
| setState(1252); |
| remove_gatename_directive(); |
| break; |
| } |
| |
| case 31: { |
| enterOuterAlt(_localctx, 31); |
| setState(1253); |
| noremove_gatenames_directive(); |
| break; |
| } |
| |
| case 32: { |
| enterOuterAlt(_localctx, 32); |
| setState(1254); |
| remove_netname_directive(); |
| break; |
| } |
| |
| case 33: { |
| enterOuterAlt(_localctx, 33); |
| setState(1255); |
| noremove_netnames_directive(); |
| break; |
| } |
| |
| case 34: { |
| enterOuterAlt(_localctx, 34); |
| setState(1256); |
| accelerate_directive(); |
| break; |
| } |
| |
| case 35: { |
| enterOuterAlt(_localctx, 35); |
| setState(1257); |
| noaccelerate_directive(); |
| break; |
| } |
| |
| case 36: { |
| enterOuterAlt(_localctx, 36); |
| setState(1258); |
| undefineall_directive(); |
| break; |
| } |
| |
| case 37: { |
| enterOuterAlt(_localctx, 37); |
| setState(1259); |
| uselib_directive(); |
| break; |
| } |
| |
| case 38: { |
| enterOuterAlt(_localctx, 38); |
| setState(1260); |
| disable_portfaults_directive(); |
| break; |
| } |
| |
| case 39: { |
| enterOuterAlt(_localctx, 39); |
| setState(1261); |
| enable_portfaults_directive(); |
| break; |
| } |
| |
| case 40: { |
| enterOuterAlt(_localctx, 40); |
| setState(1262); |
| nosuppress_faults_directive(); |
| break; |
| } |
| |
| case 41: { |
| enterOuterAlt(_localctx, 41); |
| setState(1263); |
| suppress_faults_directive(); |
| break; |
| } |
| |
| case 42: { |
| enterOuterAlt(_localctx, 42); |
| setState(1264); |
| signed_directive(); |
| break; |
| } |
| |
| case 43: { |
| enterOuterAlt(_localctx, 43); |
| setState(1265); |
| unsigned_directive(); |
| break; |
| } |
| |
| case 44: { |
| enterOuterAlt(_localctx, 44); |
| setState(1266); |
| sv_file_directive(); |
| break; |
| } |
| |
| case 45: { |
| enterOuterAlt(_localctx, 45); |
| setState(1267); |
| sv_line_directive(); |
| break; |
| } |
| |
| case 46: { |
| enterOuterAlt(_localctx, 46); |
| setState(1268); |
| sv_package(); |
| break; |
| } |
| |
| case 47: { |
| enterOuterAlt(_localctx, 47); |
| setState(1269); |
| endpackage(); |
| break; |
| } |
| |
| case 48: { |
| enterOuterAlt(_localctx, 48); |
| setState(1270); |
| simple_args_macro_definition_in_macro_body(); |
| break; |
| } |
| |
| case 49: { |
| enterOuterAlt(_localctx, 49); |
| setState(1271); |
| simple_no_args_macro_definition_in_macro_body(); |
| break; |
| } |
| |
| case 50: { |
| enterOuterAlt(_localctx, 50); |
| setState(1272); |
| pound_delay(); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Macro_argumentsContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Macro_argumentsContext::Macro_argumentsContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argumentsContext::PARENS_OPEN() { |
| return getToken(SV3_1aPpParser::PARENS_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argumentsContext::PARENS_CLOSE() { |
| return getToken(SV3_1aPpParser::PARENS_CLOSE, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Macro_argumentsContext::Simple_identifier() { |
| return getTokens(SV3_1aPpParser::Simple_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argumentsContext::Simple_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Simple_identifier, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Macro_argumentsContext::COMMA() { |
| return getTokens(SV3_1aPpParser::COMMA); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argumentsContext::COMMA(size_t i) { |
| return getToken(SV3_1aPpParser::COMMA, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Macro_argumentsContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argumentsContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Macro_argumentsContext::EQUAL_OP() { |
| return getTokens(SV3_1aPpParser::EQUAL_OP); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argumentsContext::EQUAL_OP(size_t i) { |
| return getToken(SV3_1aPpParser::EQUAL_OP, i); |
| } |
| |
| std::vector<SV3_1aPpParser::Default_valueContext *> SV3_1aPpParser::Macro_argumentsContext::default_value() { |
| return getRuleContexts<SV3_1aPpParser::Default_valueContext>(); |
| } |
| |
| SV3_1aPpParser::Default_valueContext* SV3_1aPpParser::Macro_argumentsContext::default_value(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Default_valueContext>(i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Macro_argumentsContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleMacro_arguments; |
| } |
| |
| void SV3_1aPpParser::Macro_argumentsContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterMacro_arguments(this); |
| } |
| |
| void SV3_1aPpParser::Macro_argumentsContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitMacro_arguments(this); |
| } |
| |
| SV3_1aPpParser::Macro_argumentsContext* SV3_1aPpParser::macro_arguments() { |
| Macro_argumentsContext *_localctx = _tracker.createInstance<Macro_argumentsContext>(_ctx, getState()); |
| enterRule(_localctx, 256, SV3_1aPpParser::RuleMacro_arguments); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(1275); |
| match(SV3_1aPpParser::PARENS_OPEN); |
| setState(1328); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Simple_identifier) { |
| setState(1276); |
| match(SV3_1aPpParser::Simple_identifier); |
| setState(1280); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(1277); |
| match(SV3_1aPpParser::Spaces); |
| setState(1282); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1292); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::EQUAL_OP) { |
| setState(1283); |
| match(SV3_1aPpParser::EQUAL_OP); |
| setState(1287); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 98, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(1284); |
| default_value(); |
| } |
| setState(1289); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 98, _ctx); |
| } |
| setState(1294); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1323); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::COMMA) { |
| setState(1295); |
| match(SV3_1aPpParser::COMMA); |
| setState(1299); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(1296); |
| match(SV3_1aPpParser::Spaces); |
| setState(1301); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| |
| setState(1302); |
| match(SV3_1aPpParser::Simple_identifier); |
| setState(1306); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(1303); |
| match(SV3_1aPpParser::Spaces); |
| setState(1308); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1318); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::EQUAL_OP) { |
| setState(1309); |
| match(SV3_1aPpParser::EQUAL_OP); |
| setState(1313); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 102, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(1310); |
| default_value(); |
| } |
| setState(1315); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 102, _ctx); |
| } |
| setState(1320); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1325); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1330); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1331); |
| match(SV3_1aPpParser::PARENS_CLOSE); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Escaped_macro_definition_bodyContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Escaped_macro_definition_bodyContext::Escaped_macro_definition_bodyContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| SV3_1aPpParser::Escaped_macro_definition_body_alt1Context* SV3_1aPpParser::Escaped_macro_definition_bodyContext::escaped_macro_definition_body_alt1() { |
| return getRuleContext<SV3_1aPpParser::Escaped_macro_definition_body_alt1Context>(0); |
| } |
| |
| SV3_1aPpParser::Escaped_macro_definition_body_alt2Context* SV3_1aPpParser::Escaped_macro_definition_bodyContext::escaped_macro_definition_body_alt2() { |
| return getRuleContext<SV3_1aPpParser::Escaped_macro_definition_body_alt2Context>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Escaped_macro_definition_bodyContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEscaped_macro_definition_body; |
| } |
| |
| void SV3_1aPpParser::Escaped_macro_definition_bodyContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEscaped_macro_definition_body(this); |
| } |
| |
| void SV3_1aPpParser::Escaped_macro_definition_bodyContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEscaped_macro_definition_body(this); |
| } |
| |
| SV3_1aPpParser::Escaped_macro_definition_bodyContext* SV3_1aPpParser::escaped_macro_definition_body() { |
| Escaped_macro_definition_bodyContext *_localctx = _tracker.createInstance<Escaped_macro_definition_bodyContext>(_ctx, getState()); |
| enterRule(_localctx, 258, SV3_1aPpParser::RuleEscaped_macro_definition_body); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(1335); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _ctx)) { |
| case 1: { |
| enterOuterAlt(_localctx, 1); |
| setState(1333); |
| escaped_macro_definition_body_alt1(); |
| break; |
| } |
| |
| case 2: { |
| enterOuterAlt(_localctx, 2); |
| setState(1334); |
| escaped_macro_definition_body_alt2(); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Escaped_macro_definition_body_alt1Context ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Escaped_macro_definition_body_alt1Context(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::ESCAPED_CR() { |
| return getTokens(SV3_1aPpParser::ESCAPED_CR); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::ESCAPED_CR(size_t i) { |
| return getToken(SV3_1aPpParser::ESCAPED_CR, i); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::EOF() { |
| return getToken(SV3_1aPpParser::EOF, 0); |
| } |
| |
| std::vector<SV3_1aPpParser::Unterminated_stringContext *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::unterminated_string() { |
| return getRuleContexts<SV3_1aPpParser::Unterminated_stringContext>(); |
| } |
| |
| SV3_1aPpParser::Unterminated_stringContext* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::unterminated_string(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Unterminated_stringContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Macro_identifier() { |
| return getTokens(SV3_1aPpParser::Macro_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Macro_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Macro_identifier, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Macro_Escaped_identifier() { |
| return getTokens(SV3_1aPpParser::Macro_Escaped_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Macro_Escaped_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Macro_Escaped_identifier, i); |
| } |
| |
| std::vector<SV3_1aPpParser::Escaped_identifierContext *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::escaped_identifier() { |
| return getRuleContexts<SV3_1aPpParser::Escaped_identifierContext>(); |
| } |
| |
| SV3_1aPpParser::Escaped_identifierContext* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::escaped_identifier(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Escaped_identifierContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Simple_identifier() { |
| return getTokens(SV3_1aPpParser::Simple_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Simple_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Simple_identifier, i); |
| } |
| |
| std::vector<SV3_1aPpParser::NumberContext *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::number() { |
| return getRuleContexts<SV3_1aPpParser::NumberContext>(); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::number(size_t i) { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::TEXT_CR() { |
| return getTokens(SV3_1aPpParser::TEXT_CR); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::TEXT_CR(size_t i) { |
| return getToken(SV3_1aPpParser::TEXT_CR, i); |
| } |
| |
| std::vector<SV3_1aPpParser::Pound_delayContext *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::pound_delay() { |
| return getRuleContexts<SV3_1aPpParser::Pound_delayContext>(); |
| } |
| |
| SV3_1aPpParser::Pound_delayContext* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::pound_delay(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Pound_delayContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::PARENS_OPEN() { |
| return getTokens(SV3_1aPpParser::PARENS_OPEN); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::PARENS_OPEN(size_t i) { |
| return getToken(SV3_1aPpParser::PARENS_OPEN, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::PARENS_CLOSE() { |
| return getTokens(SV3_1aPpParser::PARENS_CLOSE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::PARENS_CLOSE(size_t i) { |
| return getToken(SV3_1aPpParser::PARENS_CLOSE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::COMMA() { |
| return getTokens(SV3_1aPpParser::COMMA); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::COMMA(size_t i) { |
| return getToken(SV3_1aPpParser::COMMA, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::EQUAL_OP() { |
| return getTokens(SV3_1aPpParser::EQUAL_OP); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::EQUAL_OP(size_t i) { |
| return getToken(SV3_1aPpParser::EQUAL_OP, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::DOUBLE_QUOTE() { |
| return getTokens(SV3_1aPpParser::DOUBLE_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::DOUBLE_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::DOUBLE_QUOTE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::TICK_VARIABLE() { |
| return getTokens(SV3_1aPpParser::TICK_VARIABLE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::TICK_VARIABLE(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_VARIABLE, i); |
| } |
| |
| std::vector<SV3_1aPpParser::Directive_in_macroContext *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::directive_in_macro() { |
| return getRuleContexts<SV3_1aPpParser::Directive_in_macroContext>(); |
| } |
| |
| SV3_1aPpParser::Directive_in_macroContext* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::directive_in_macro(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Directive_in_macroContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Fixed_point_number() { |
| return getTokens(SV3_1aPpParser::Fixed_point_number); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Fixed_point_number(size_t i) { |
| return getToken(SV3_1aPpParser::Fixed_point_number, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::String() { |
| return getTokens(SV3_1aPpParser::String); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::String(size_t i) { |
| return getToken(SV3_1aPpParser::String, i); |
| } |
| |
| std::vector<SV3_1aPpParser::CommentsContext *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::comments() { |
| return getRuleContexts<SV3_1aPpParser::CommentsContext>(); |
| } |
| |
| SV3_1aPpParser::CommentsContext* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::comments(size_t i) { |
| return getRuleContext<SV3_1aPpParser::CommentsContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::TICK_QUOTE() { |
| return getTokens(SV3_1aPpParser::TICK_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::TICK_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_QUOTE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::TICK_BACKSLASH_TICK_QUOTE() { |
| return getTokens(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::TICK_BACKSLASH_TICK_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::TICK_TICK() { |
| return getTokens(SV3_1aPpParser::TICK_TICK); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::TICK_TICK(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_TICK, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Special() { |
| return getTokens(SV3_1aPpParser::Special); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::Special(size_t i) { |
| return getToken(SV3_1aPpParser::Special, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::CURLY_OPEN() { |
| return getTokens(SV3_1aPpParser::CURLY_OPEN); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::CURLY_OPEN(size_t i) { |
| return getToken(SV3_1aPpParser::CURLY_OPEN, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::CURLY_CLOSE() { |
| return getTokens(SV3_1aPpParser::CURLY_CLOSE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::CURLY_CLOSE(size_t i) { |
| return getToken(SV3_1aPpParser::CURLY_CLOSE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::SQUARE_OPEN() { |
| return getTokens(SV3_1aPpParser::SQUARE_OPEN); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::SQUARE_OPEN(size_t i) { |
| return getToken(SV3_1aPpParser::SQUARE_OPEN, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::SQUARE_CLOSE() { |
| return getTokens(SV3_1aPpParser::SQUARE_CLOSE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::SQUARE_CLOSE(size_t i) { |
| return getToken(SV3_1aPpParser::SQUARE_CLOSE, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEscaped_macro_definition_body_alt1; |
| } |
| |
| void SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEscaped_macro_definition_body_alt1(this); |
| } |
| |
| void SV3_1aPpParser::Escaped_macro_definition_body_alt1Context::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEscaped_macro_definition_body_alt1(this); |
| } |
| |
| SV3_1aPpParser::Escaped_macro_definition_body_alt1Context* SV3_1aPpParser::escaped_macro_definition_body_alt1() { |
| Escaped_macro_definition_body_alt1Context *_localctx = _tracker.createInstance<Escaped_macro_definition_body_alt1Context>(_ctx, getState()); |
| enterRule(_localctx, 260, SV3_1aPpParser::RuleEscaped_macro_definition_body_alt1); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(1367); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 108, _ctx); |
| while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1 + 1) { |
| setState(1365); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 107, _ctx)) { |
| case 1: { |
| setState(1337); |
| unterminated_string(); |
| break; |
| } |
| |
| case 2: { |
| setState(1338); |
| match(SV3_1aPpParser::Macro_identifier); |
| break; |
| } |
| |
| case 3: { |
| setState(1339); |
| match(SV3_1aPpParser::Macro_Escaped_identifier); |
| break; |
| } |
| |
| case 4: { |
| setState(1340); |
| escaped_identifier(); |
| break; |
| } |
| |
| case 5: { |
| setState(1341); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case 6: { |
| setState(1342); |
| number(); |
| break; |
| } |
| |
| case 7: { |
| setState(1343); |
| match(SV3_1aPpParser::TEXT_CR); |
| break; |
| } |
| |
| case 8: { |
| setState(1344); |
| pound_delay(); |
| break; |
| } |
| |
| case 9: { |
| setState(1345); |
| match(SV3_1aPpParser::ESCAPED_CR); |
| break; |
| } |
| |
| case 10: { |
| setState(1346); |
| match(SV3_1aPpParser::PARENS_OPEN); |
| break; |
| } |
| |
| case 11: { |
| setState(1347); |
| match(SV3_1aPpParser::PARENS_CLOSE); |
| break; |
| } |
| |
| case 12: { |
| setState(1348); |
| match(SV3_1aPpParser::COMMA); |
| break; |
| } |
| |
| case 13: { |
| setState(1349); |
| match(SV3_1aPpParser::EQUAL_OP); |
| break; |
| } |
| |
| case 14: { |
| setState(1350); |
| match(SV3_1aPpParser::DOUBLE_QUOTE); |
| break; |
| } |
| |
| case 15: { |
| setState(1351); |
| match(SV3_1aPpParser::TICK_VARIABLE); |
| break; |
| } |
| |
| case 16: { |
| setState(1352); |
| directive_in_macro(); |
| break; |
| } |
| |
| case 17: { |
| setState(1353); |
| match(SV3_1aPpParser::Spaces); |
| break; |
| } |
| |
| case 18: { |
| setState(1354); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| case 19: { |
| setState(1355); |
| match(SV3_1aPpParser::String); |
| break; |
| } |
| |
| case 20: { |
| setState(1356); |
| comments(); |
| break; |
| } |
| |
| case 21: { |
| setState(1357); |
| match(SV3_1aPpParser::TICK_QUOTE); |
| break; |
| } |
| |
| case 22: { |
| setState(1358); |
| match(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE); |
| break; |
| } |
| |
| case 23: { |
| setState(1359); |
| match(SV3_1aPpParser::TICK_TICK); |
| break; |
| } |
| |
| case 24: { |
| setState(1360); |
| match(SV3_1aPpParser::Special); |
| break; |
| } |
| |
| case 25: { |
| setState(1361); |
| match(SV3_1aPpParser::CURLY_OPEN); |
| break; |
| } |
| |
| case 26: { |
| setState(1362); |
| match(SV3_1aPpParser::CURLY_CLOSE); |
| break; |
| } |
| |
| case 27: { |
| setState(1363); |
| match(SV3_1aPpParser::SQUARE_OPEN); |
| break; |
| } |
| |
| case 28: { |
| setState(1364); |
| match(SV3_1aPpParser::SQUARE_CLOSE); |
| break; |
| } |
| |
| } |
| } |
| setState(1369); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 108, _ctx); |
| } |
| setState(1370); |
| match(SV3_1aPpParser::ESCAPED_CR); |
| setState(1374); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (_la == SV3_1aPpParser::Spaces) { |
| setState(1371); |
| match(SV3_1aPpParser::Spaces); |
| setState(1376); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1377); |
| _la = _input->LA(1); |
| if (!(_la == SV3_1aPpParser::EOF || _la == SV3_1aPpParser::CR)) { |
| _errHandler->recoverInline(this); |
| } |
| else { |
| _errHandler->reportMatch(this); |
| consume(); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Escaped_macro_definition_body_alt2Context ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Escaped_macro_definition_body_alt2Context(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::EOF() { |
| return getToken(SV3_1aPpParser::EOF, 0); |
| } |
| |
| std::vector<SV3_1aPpParser::Unterminated_stringContext *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::unterminated_string() { |
| return getRuleContexts<SV3_1aPpParser::Unterminated_stringContext>(); |
| } |
| |
| SV3_1aPpParser::Unterminated_stringContext* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::unterminated_string(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Unterminated_stringContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Macro_identifier() { |
| return getTokens(SV3_1aPpParser::Macro_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Macro_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Macro_identifier, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Macro_Escaped_identifier() { |
| return getTokens(SV3_1aPpParser::Macro_Escaped_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Macro_Escaped_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Macro_Escaped_identifier, i); |
| } |
| |
| std::vector<SV3_1aPpParser::Escaped_identifierContext *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::escaped_identifier() { |
| return getRuleContexts<SV3_1aPpParser::Escaped_identifierContext>(); |
| } |
| |
| SV3_1aPpParser::Escaped_identifierContext* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::escaped_identifier(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Escaped_identifierContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Simple_identifier() { |
| return getTokens(SV3_1aPpParser::Simple_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Simple_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Simple_identifier, i); |
| } |
| |
| std::vector<SV3_1aPpParser::NumberContext *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::number() { |
| return getRuleContexts<SV3_1aPpParser::NumberContext>(); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::number(size_t i) { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::TEXT_CR() { |
| return getTokens(SV3_1aPpParser::TEXT_CR); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::TEXT_CR(size_t i) { |
| return getToken(SV3_1aPpParser::TEXT_CR, i); |
| } |
| |
| std::vector<SV3_1aPpParser::Pound_delayContext *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::pound_delay() { |
| return getRuleContexts<SV3_1aPpParser::Pound_delayContext>(); |
| } |
| |
| SV3_1aPpParser::Pound_delayContext* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::pound_delay(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Pound_delayContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::ESCAPED_CR() { |
| return getTokens(SV3_1aPpParser::ESCAPED_CR); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::ESCAPED_CR(size_t i) { |
| return getToken(SV3_1aPpParser::ESCAPED_CR, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::PARENS_OPEN() { |
| return getTokens(SV3_1aPpParser::PARENS_OPEN); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::PARENS_OPEN(size_t i) { |
| return getToken(SV3_1aPpParser::PARENS_OPEN, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::PARENS_CLOSE() { |
| return getTokens(SV3_1aPpParser::PARENS_CLOSE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::PARENS_CLOSE(size_t i) { |
| return getToken(SV3_1aPpParser::PARENS_CLOSE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::COMMA() { |
| return getTokens(SV3_1aPpParser::COMMA); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::COMMA(size_t i) { |
| return getToken(SV3_1aPpParser::COMMA, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::EQUAL_OP() { |
| return getTokens(SV3_1aPpParser::EQUAL_OP); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::EQUAL_OP(size_t i) { |
| return getToken(SV3_1aPpParser::EQUAL_OP, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::DOUBLE_QUOTE() { |
| return getTokens(SV3_1aPpParser::DOUBLE_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::DOUBLE_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::DOUBLE_QUOTE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::TICK_VARIABLE() { |
| return getTokens(SV3_1aPpParser::TICK_VARIABLE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::TICK_VARIABLE(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_VARIABLE, i); |
| } |
| |
| std::vector<SV3_1aPpParser::Directive_in_macroContext *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::directive_in_macro() { |
| return getRuleContexts<SV3_1aPpParser::Directive_in_macroContext>(); |
| } |
| |
| SV3_1aPpParser::Directive_in_macroContext* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::directive_in_macro(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Directive_in_macroContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Fixed_point_number() { |
| return getTokens(SV3_1aPpParser::Fixed_point_number); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Fixed_point_number(size_t i) { |
| return getToken(SV3_1aPpParser::Fixed_point_number, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::String() { |
| return getTokens(SV3_1aPpParser::String); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::String(size_t i) { |
| return getToken(SV3_1aPpParser::String, i); |
| } |
| |
| std::vector<SV3_1aPpParser::CommentsContext *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::comments() { |
| return getRuleContexts<SV3_1aPpParser::CommentsContext>(); |
| } |
| |
| SV3_1aPpParser::CommentsContext* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::comments(size_t i) { |
| return getRuleContext<SV3_1aPpParser::CommentsContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::TICK_QUOTE() { |
| return getTokens(SV3_1aPpParser::TICK_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::TICK_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_QUOTE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::TICK_BACKSLASH_TICK_QUOTE() { |
| return getTokens(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::TICK_BACKSLASH_TICK_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::TICK_TICK() { |
| return getTokens(SV3_1aPpParser::TICK_TICK); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::TICK_TICK(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_TICK, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Special() { |
| return getTokens(SV3_1aPpParser::Special); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::Special(size_t i) { |
| return getToken(SV3_1aPpParser::Special, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::CURLY_OPEN() { |
| return getTokens(SV3_1aPpParser::CURLY_OPEN); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::CURLY_OPEN(size_t i) { |
| return getToken(SV3_1aPpParser::CURLY_OPEN, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::CURLY_CLOSE() { |
| return getTokens(SV3_1aPpParser::CURLY_CLOSE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::CURLY_CLOSE(size_t i) { |
| return getToken(SV3_1aPpParser::CURLY_CLOSE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::SQUARE_OPEN() { |
| return getTokens(SV3_1aPpParser::SQUARE_OPEN); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::SQUARE_OPEN(size_t i) { |
| return getToken(SV3_1aPpParser::SQUARE_OPEN, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::SQUARE_CLOSE() { |
| return getTokens(SV3_1aPpParser::SQUARE_CLOSE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::SQUARE_CLOSE(size_t i) { |
| return getToken(SV3_1aPpParser::SQUARE_CLOSE, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEscaped_macro_definition_body_alt2; |
| } |
| |
| void SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEscaped_macro_definition_body_alt2(this); |
| } |
| |
| void SV3_1aPpParser::Escaped_macro_definition_body_alt2Context::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEscaped_macro_definition_body_alt2(this); |
| } |
| |
| SV3_1aPpParser::Escaped_macro_definition_body_alt2Context* SV3_1aPpParser::escaped_macro_definition_body_alt2() { |
| Escaped_macro_definition_body_alt2Context *_localctx = _tracker.createInstance<Escaped_macro_definition_body_alt2Context>(_ctx, getState()); |
| enterRule(_localctx, 262, SV3_1aPpParser::RuleEscaped_macro_definition_body_alt2); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(1409); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx); |
| while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1 + 1) { |
| setState(1407); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx)) { |
| case 1: { |
| setState(1379); |
| unterminated_string(); |
| break; |
| } |
| |
| case 2: { |
| setState(1380); |
| match(SV3_1aPpParser::Macro_identifier); |
| break; |
| } |
| |
| case 3: { |
| setState(1381); |
| match(SV3_1aPpParser::Macro_Escaped_identifier); |
| break; |
| } |
| |
| case 4: { |
| setState(1382); |
| escaped_identifier(); |
| break; |
| } |
| |
| case 5: { |
| setState(1383); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case 6: { |
| setState(1384); |
| number(); |
| break; |
| } |
| |
| case 7: { |
| setState(1385); |
| match(SV3_1aPpParser::TEXT_CR); |
| break; |
| } |
| |
| case 8: { |
| setState(1386); |
| pound_delay(); |
| break; |
| } |
| |
| case 9: { |
| setState(1387); |
| match(SV3_1aPpParser::ESCAPED_CR); |
| break; |
| } |
| |
| case 10: { |
| setState(1388); |
| match(SV3_1aPpParser::PARENS_OPEN); |
| break; |
| } |
| |
| case 11: { |
| setState(1389); |
| match(SV3_1aPpParser::PARENS_CLOSE); |
| break; |
| } |
| |
| case 12: { |
| setState(1390); |
| match(SV3_1aPpParser::COMMA); |
| break; |
| } |
| |
| case 13: { |
| setState(1391); |
| match(SV3_1aPpParser::EQUAL_OP); |
| break; |
| } |
| |
| case 14: { |
| setState(1392); |
| match(SV3_1aPpParser::DOUBLE_QUOTE); |
| break; |
| } |
| |
| case 15: { |
| setState(1393); |
| match(SV3_1aPpParser::TICK_VARIABLE); |
| break; |
| } |
| |
| case 16: { |
| setState(1394); |
| directive_in_macro(); |
| break; |
| } |
| |
| case 17: { |
| setState(1395); |
| match(SV3_1aPpParser::Spaces); |
| break; |
| } |
| |
| case 18: { |
| setState(1396); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| case 19: { |
| setState(1397); |
| match(SV3_1aPpParser::String); |
| break; |
| } |
| |
| case 20: { |
| setState(1398); |
| comments(); |
| break; |
| } |
| |
| case 21: { |
| setState(1399); |
| match(SV3_1aPpParser::TICK_QUOTE); |
| break; |
| } |
| |
| case 22: { |
| setState(1400); |
| match(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE); |
| break; |
| } |
| |
| case 23: { |
| setState(1401); |
| match(SV3_1aPpParser::TICK_TICK); |
| break; |
| } |
| |
| case 24: { |
| setState(1402); |
| match(SV3_1aPpParser::Special); |
| break; |
| } |
| |
| case 25: { |
| setState(1403); |
| match(SV3_1aPpParser::CURLY_OPEN); |
| break; |
| } |
| |
| case 26: { |
| setState(1404); |
| match(SV3_1aPpParser::CURLY_CLOSE); |
| break; |
| } |
| |
| case 27: { |
| setState(1405); |
| match(SV3_1aPpParser::SQUARE_OPEN); |
| break; |
| } |
| |
| case 28: { |
| setState(1406); |
| match(SV3_1aPpParser::SQUARE_CLOSE); |
| break; |
| } |
| |
| } |
| } |
| setState(1411); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx); |
| } |
| setState(1420); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::CR: { |
| setState(1412); |
| match(SV3_1aPpParser::CR); |
| setState(1416); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 112, _ctx); |
| while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1) { |
| setState(1413); |
| match(SV3_1aPpParser::Spaces); |
| } |
| setState(1418); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 112, _ctx); |
| } |
| break; |
| } |
| |
| case SV3_1aPpParser::EOF: { |
| setState(1419); |
| match(SV3_1aPpParser::EOF); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Simple_macro_definition_bodyContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Simple_macro_definition_bodyContext::Simple_macro_definition_bodyContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| std::vector<SV3_1aPpParser::Unterminated_stringContext *> SV3_1aPpParser::Simple_macro_definition_bodyContext::unterminated_string() { |
| return getRuleContexts<SV3_1aPpParser::Unterminated_stringContext>(); |
| } |
| |
| SV3_1aPpParser::Unterminated_stringContext* SV3_1aPpParser::Simple_macro_definition_bodyContext::unterminated_string(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Unterminated_stringContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::Macro_identifier() { |
| return getTokens(SV3_1aPpParser::Macro_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::Macro_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Macro_identifier, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::Macro_Escaped_identifier() { |
| return getTokens(SV3_1aPpParser::Macro_Escaped_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::Macro_Escaped_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Macro_Escaped_identifier, i); |
| } |
| |
| std::vector<SV3_1aPpParser::Escaped_identifierContext *> SV3_1aPpParser::Simple_macro_definition_bodyContext::escaped_identifier() { |
| return getRuleContexts<SV3_1aPpParser::Escaped_identifierContext>(); |
| } |
| |
| SV3_1aPpParser::Escaped_identifierContext* SV3_1aPpParser::Simple_macro_definition_bodyContext::escaped_identifier(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Escaped_identifierContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::Simple_identifier() { |
| return getTokens(SV3_1aPpParser::Simple_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::Simple_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Simple_identifier, i); |
| } |
| |
| std::vector<SV3_1aPpParser::NumberContext *> SV3_1aPpParser::Simple_macro_definition_bodyContext::number() { |
| return getRuleContexts<SV3_1aPpParser::NumberContext>(); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::Simple_macro_definition_bodyContext::number(size_t i) { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(i); |
| } |
| |
| std::vector<SV3_1aPpParser::Pound_delayContext *> SV3_1aPpParser::Simple_macro_definition_bodyContext::pound_delay() { |
| return getRuleContexts<SV3_1aPpParser::Pound_delayContext>(); |
| } |
| |
| SV3_1aPpParser::Pound_delayContext* SV3_1aPpParser::Simple_macro_definition_bodyContext::pound_delay(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Pound_delayContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::TEXT_CR() { |
| return getTokens(SV3_1aPpParser::TEXT_CR); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::TEXT_CR(size_t i) { |
| return getToken(SV3_1aPpParser::TEXT_CR, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::PARENS_OPEN() { |
| return getTokens(SV3_1aPpParser::PARENS_OPEN); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::PARENS_OPEN(size_t i) { |
| return getToken(SV3_1aPpParser::PARENS_OPEN, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::PARENS_CLOSE() { |
| return getTokens(SV3_1aPpParser::PARENS_CLOSE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::PARENS_CLOSE(size_t i) { |
| return getToken(SV3_1aPpParser::PARENS_CLOSE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::COMMA() { |
| return getTokens(SV3_1aPpParser::COMMA); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::COMMA(size_t i) { |
| return getToken(SV3_1aPpParser::COMMA, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::EQUAL_OP() { |
| return getTokens(SV3_1aPpParser::EQUAL_OP); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::EQUAL_OP(size_t i) { |
| return getToken(SV3_1aPpParser::EQUAL_OP, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::DOUBLE_QUOTE() { |
| return getTokens(SV3_1aPpParser::DOUBLE_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::DOUBLE_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::DOUBLE_QUOTE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::TICK_VARIABLE() { |
| return getTokens(SV3_1aPpParser::TICK_VARIABLE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::TICK_VARIABLE(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_VARIABLE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::Fixed_point_number() { |
| return getTokens(SV3_1aPpParser::Fixed_point_number); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::Fixed_point_number(size_t i) { |
| return getToken(SV3_1aPpParser::Fixed_point_number, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::String() { |
| return getTokens(SV3_1aPpParser::String); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::String(size_t i) { |
| return getToken(SV3_1aPpParser::String, i); |
| } |
| |
| std::vector<SV3_1aPpParser::CommentsContext *> SV3_1aPpParser::Simple_macro_definition_bodyContext::comments() { |
| return getRuleContexts<SV3_1aPpParser::CommentsContext>(); |
| } |
| |
| SV3_1aPpParser::CommentsContext* SV3_1aPpParser::Simple_macro_definition_bodyContext::comments(size_t i) { |
| return getRuleContext<SV3_1aPpParser::CommentsContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::TICK_QUOTE() { |
| return getTokens(SV3_1aPpParser::TICK_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::TICK_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_QUOTE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::TICK_BACKSLASH_TICK_QUOTE() { |
| return getTokens(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::TICK_BACKSLASH_TICK_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::TICK_TICK() { |
| return getTokens(SV3_1aPpParser::TICK_TICK); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::TICK_TICK(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_TICK, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::Special() { |
| return getTokens(SV3_1aPpParser::Special); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::Special(size_t i) { |
| return getToken(SV3_1aPpParser::Special, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::CURLY_OPEN() { |
| return getTokens(SV3_1aPpParser::CURLY_OPEN); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::CURLY_OPEN(size_t i) { |
| return getToken(SV3_1aPpParser::CURLY_OPEN, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::CURLY_CLOSE() { |
| return getTokens(SV3_1aPpParser::CURLY_CLOSE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::CURLY_CLOSE(size_t i) { |
| return getToken(SV3_1aPpParser::CURLY_CLOSE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::SQUARE_OPEN() { |
| return getTokens(SV3_1aPpParser::SQUARE_OPEN); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::SQUARE_OPEN(size_t i) { |
| return getToken(SV3_1aPpParser::SQUARE_OPEN, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_bodyContext::SQUARE_CLOSE() { |
| return getTokens(SV3_1aPpParser::SQUARE_CLOSE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_bodyContext::SQUARE_CLOSE(size_t i) { |
| return getToken(SV3_1aPpParser::SQUARE_CLOSE, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Simple_macro_definition_bodyContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSimple_macro_definition_body; |
| } |
| |
| void SV3_1aPpParser::Simple_macro_definition_bodyContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSimple_macro_definition_body(this); |
| } |
| |
| void SV3_1aPpParser::Simple_macro_definition_bodyContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSimple_macro_definition_body(this); |
| } |
| |
| SV3_1aPpParser::Simple_macro_definition_bodyContext* SV3_1aPpParser::simple_macro_definition_body() { |
| Simple_macro_definition_bodyContext *_localctx = _tracker.createInstance<Simple_macro_definition_bodyContext>(_ctx, getState()); |
| enterRule(_localctx, 264, SV3_1aPpParser::RuleSimple_macro_definition_body); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(1450); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 115, _ctx); |
| while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1 + 1) { |
| setState(1448); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _ctx)) { |
| case 1: { |
| setState(1422); |
| unterminated_string(); |
| break; |
| } |
| |
| case 2: { |
| setState(1423); |
| match(SV3_1aPpParser::Macro_identifier); |
| break; |
| } |
| |
| case 3: { |
| setState(1424); |
| match(SV3_1aPpParser::Macro_Escaped_identifier); |
| break; |
| } |
| |
| case 4: { |
| setState(1425); |
| escaped_identifier(); |
| break; |
| } |
| |
| case 5: { |
| setState(1426); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case 6: { |
| setState(1427); |
| number(); |
| break; |
| } |
| |
| case 7: { |
| setState(1428); |
| pound_delay(); |
| break; |
| } |
| |
| case 8: { |
| setState(1429); |
| match(SV3_1aPpParser::TEXT_CR); |
| break; |
| } |
| |
| case 9: { |
| setState(1430); |
| match(SV3_1aPpParser::PARENS_OPEN); |
| break; |
| } |
| |
| case 10: { |
| setState(1431); |
| match(SV3_1aPpParser::PARENS_CLOSE); |
| break; |
| } |
| |
| case 11: { |
| setState(1432); |
| match(SV3_1aPpParser::COMMA); |
| break; |
| } |
| |
| case 12: { |
| setState(1433); |
| match(SV3_1aPpParser::EQUAL_OP); |
| break; |
| } |
| |
| case 13: { |
| setState(1434); |
| match(SV3_1aPpParser::DOUBLE_QUOTE); |
| break; |
| } |
| |
| case 14: { |
| setState(1435); |
| match(SV3_1aPpParser::TICK_VARIABLE); |
| break; |
| } |
| |
| case 15: { |
| setState(1436); |
| match(SV3_1aPpParser::Spaces); |
| break; |
| } |
| |
| case 16: { |
| setState(1437); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| case 17: { |
| setState(1438); |
| match(SV3_1aPpParser::String); |
| break; |
| } |
| |
| case 18: { |
| setState(1439); |
| comments(); |
| break; |
| } |
| |
| case 19: { |
| setState(1440); |
| match(SV3_1aPpParser::TICK_QUOTE); |
| break; |
| } |
| |
| case 20: { |
| setState(1441); |
| match(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE); |
| break; |
| } |
| |
| case 21: { |
| setState(1442); |
| match(SV3_1aPpParser::TICK_TICK); |
| break; |
| } |
| |
| case 22: { |
| setState(1443); |
| match(SV3_1aPpParser::Special); |
| break; |
| } |
| |
| case 23: { |
| setState(1444); |
| match(SV3_1aPpParser::CURLY_OPEN); |
| break; |
| } |
| |
| case 24: { |
| setState(1445); |
| match(SV3_1aPpParser::CURLY_CLOSE); |
| break; |
| } |
| |
| case 25: { |
| setState(1446); |
| match(SV3_1aPpParser::SQUARE_OPEN); |
| break; |
| } |
| |
| case 26: { |
| setState(1447); |
| match(SV3_1aPpParser::SQUARE_CLOSE); |
| break; |
| } |
| |
| } |
| } |
| setState(1452); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 115, _ctx); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Simple_macro_definition_body_in_macro_bodyContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Simple_macro_definition_body_in_macro_bodyContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| std::vector<SV3_1aPpParser::Unterminated_stringContext *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::unterminated_string() { |
| return getRuleContexts<SV3_1aPpParser::Unterminated_stringContext>(); |
| } |
| |
| SV3_1aPpParser::Unterminated_stringContext* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::unterminated_string(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Unterminated_stringContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Macro_identifier() { |
| return getTokens(SV3_1aPpParser::Macro_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Macro_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Macro_identifier, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Macro_Escaped_identifier() { |
| return getTokens(SV3_1aPpParser::Macro_Escaped_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Macro_Escaped_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Macro_Escaped_identifier, i); |
| } |
| |
| std::vector<SV3_1aPpParser::Escaped_identifierContext *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::escaped_identifier() { |
| return getRuleContexts<SV3_1aPpParser::Escaped_identifierContext>(); |
| } |
| |
| SV3_1aPpParser::Escaped_identifierContext* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::escaped_identifier(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Escaped_identifierContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Simple_identifier() { |
| return getTokens(SV3_1aPpParser::Simple_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Simple_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Simple_identifier, i); |
| } |
| |
| std::vector<SV3_1aPpParser::NumberContext *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::number() { |
| return getRuleContexts<SV3_1aPpParser::NumberContext>(); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::number(size_t i) { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(i); |
| } |
| |
| std::vector<SV3_1aPpParser::Pound_delayContext *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::pound_delay() { |
| return getRuleContexts<SV3_1aPpParser::Pound_delayContext>(); |
| } |
| |
| SV3_1aPpParser::Pound_delayContext* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::pound_delay(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Pound_delayContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::TEXT_CR() { |
| return getTokens(SV3_1aPpParser::TEXT_CR); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::TEXT_CR(size_t i) { |
| return getToken(SV3_1aPpParser::TEXT_CR, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::PARENS_OPEN() { |
| return getTokens(SV3_1aPpParser::PARENS_OPEN); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::PARENS_OPEN(size_t i) { |
| return getToken(SV3_1aPpParser::PARENS_OPEN, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::PARENS_CLOSE() { |
| return getTokens(SV3_1aPpParser::PARENS_CLOSE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::PARENS_CLOSE(size_t i) { |
| return getToken(SV3_1aPpParser::PARENS_CLOSE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::COMMA() { |
| return getTokens(SV3_1aPpParser::COMMA); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::COMMA(size_t i) { |
| return getToken(SV3_1aPpParser::COMMA, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::EQUAL_OP() { |
| return getTokens(SV3_1aPpParser::EQUAL_OP); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::EQUAL_OP(size_t i) { |
| return getToken(SV3_1aPpParser::EQUAL_OP, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::DOUBLE_QUOTE() { |
| return getTokens(SV3_1aPpParser::DOUBLE_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::DOUBLE_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::DOUBLE_QUOTE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::TICK_VARIABLE() { |
| return getTokens(SV3_1aPpParser::TICK_VARIABLE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::TICK_VARIABLE(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_VARIABLE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Fixed_point_number() { |
| return getTokens(SV3_1aPpParser::Fixed_point_number); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Fixed_point_number(size_t i) { |
| return getToken(SV3_1aPpParser::Fixed_point_number, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::String() { |
| return getTokens(SV3_1aPpParser::String); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::String(size_t i) { |
| return getToken(SV3_1aPpParser::String, i); |
| } |
| |
| std::vector<SV3_1aPpParser::CommentsContext *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::comments() { |
| return getRuleContexts<SV3_1aPpParser::CommentsContext>(); |
| } |
| |
| SV3_1aPpParser::CommentsContext* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::comments(size_t i) { |
| return getRuleContext<SV3_1aPpParser::CommentsContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::TICK_QUOTE() { |
| return getTokens(SV3_1aPpParser::TICK_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::TICK_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_QUOTE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::TICK_BACKSLASH_TICK_QUOTE() { |
| return getTokens(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::TICK_BACKSLASH_TICK_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::TICK_TICK() { |
| return getTokens(SV3_1aPpParser::TICK_TICK); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::TICK_TICK(size_t i) { |
| return getToken(SV3_1aPpParser::TICK_TICK, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Special() { |
| return getTokens(SV3_1aPpParser::Special); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::Special(size_t i) { |
| return getToken(SV3_1aPpParser::Special, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::CURLY_OPEN() { |
| return getTokens(SV3_1aPpParser::CURLY_OPEN); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::CURLY_OPEN(size_t i) { |
| return getToken(SV3_1aPpParser::CURLY_OPEN, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::CURLY_CLOSE() { |
| return getTokens(SV3_1aPpParser::CURLY_CLOSE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::CURLY_CLOSE(size_t i) { |
| return getToken(SV3_1aPpParser::CURLY_CLOSE, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::SQUARE_OPEN() { |
| return getTokens(SV3_1aPpParser::SQUARE_OPEN); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::SQUARE_OPEN(size_t i) { |
| return getToken(SV3_1aPpParser::SQUARE_OPEN, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::SQUARE_CLOSE() { |
| return getTokens(SV3_1aPpParser::SQUARE_CLOSE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::SQUARE_CLOSE(size_t i) { |
| return getToken(SV3_1aPpParser::SQUARE_CLOSE, i); |
| } |
| |
| |
| size_t SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleSimple_macro_definition_body_in_macro_body; |
| } |
| |
| void SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterSimple_macro_definition_body_in_macro_body(this); |
| } |
| |
| void SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitSimple_macro_definition_body_in_macro_body(this); |
| } |
| |
| SV3_1aPpParser::Simple_macro_definition_body_in_macro_bodyContext* SV3_1aPpParser::simple_macro_definition_body_in_macro_body() { |
| Simple_macro_definition_body_in_macro_bodyContext *_localctx = _tracker.createInstance<Simple_macro_definition_body_in_macro_bodyContext>(_ctx, getState()); |
| enterRule(_localctx, 266, SV3_1aPpParser::RuleSimple_macro_definition_body_in_macro_body); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| size_t alt; |
| enterOuterAlt(_localctx, 1); |
| setState(1481); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 117, _ctx); |
| while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) { |
| if (alt == 1 + 1) { |
| setState(1479); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 116, _ctx)) { |
| case 1: { |
| setState(1453); |
| unterminated_string(); |
| break; |
| } |
| |
| case 2: { |
| setState(1454); |
| match(SV3_1aPpParser::Macro_identifier); |
| break; |
| } |
| |
| case 3: { |
| setState(1455); |
| match(SV3_1aPpParser::Macro_Escaped_identifier); |
| break; |
| } |
| |
| case 4: { |
| setState(1456); |
| escaped_identifier(); |
| break; |
| } |
| |
| case 5: { |
| setState(1457); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case 6: { |
| setState(1458); |
| number(); |
| break; |
| } |
| |
| case 7: { |
| setState(1459); |
| pound_delay(); |
| break; |
| } |
| |
| case 8: { |
| setState(1460); |
| match(SV3_1aPpParser::TEXT_CR); |
| break; |
| } |
| |
| case 9: { |
| setState(1461); |
| match(SV3_1aPpParser::PARENS_OPEN); |
| break; |
| } |
| |
| case 10: { |
| setState(1462); |
| match(SV3_1aPpParser::PARENS_CLOSE); |
| break; |
| } |
| |
| case 11: { |
| setState(1463); |
| match(SV3_1aPpParser::COMMA); |
| break; |
| } |
| |
| case 12: { |
| setState(1464); |
| match(SV3_1aPpParser::EQUAL_OP); |
| break; |
| } |
| |
| case 13: { |
| setState(1465); |
| match(SV3_1aPpParser::DOUBLE_QUOTE); |
| break; |
| } |
| |
| case 14: { |
| setState(1466); |
| match(SV3_1aPpParser::TICK_VARIABLE); |
| break; |
| } |
| |
| case 15: { |
| setState(1467); |
| match(SV3_1aPpParser::Spaces); |
| break; |
| } |
| |
| case 16: { |
| setState(1468); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| case 17: { |
| setState(1469); |
| match(SV3_1aPpParser::String); |
| break; |
| } |
| |
| case 18: { |
| setState(1470); |
| comments(); |
| break; |
| } |
| |
| case 19: { |
| setState(1471); |
| match(SV3_1aPpParser::TICK_QUOTE); |
| break; |
| } |
| |
| case 20: { |
| setState(1472); |
| match(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE); |
| break; |
| } |
| |
| case 21: { |
| setState(1473); |
| match(SV3_1aPpParser::TICK_TICK); |
| break; |
| } |
| |
| case 22: { |
| setState(1474); |
| match(SV3_1aPpParser::Special); |
| break; |
| } |
| |
| case 23: { |
| setState(1475); |
| match(SV3_1aPpParser::CURLY_OPEN); |
| break; |
| } |
| |
| case 24: { |
| setState(1476); |
| match(SV3_1aPpParser::CURLY_CLOSE); |
| break; |
| } |
| |
| case 25: { |
| setState(1477); |
| match(SV3_1aPpParser::SQUARE_OPEN); |
| break; |
| } |
| |
| case 26: { |
| setState(1478); |
| match(SV3_1aPpParser::SQUARE_CLOSE); |
| break; |
| } |
| |
| } |
| } |
| setState(1483); |
| _errHandler->sync(this); |
| alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 117, _ctx); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Pragma_expressionContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Pragma_expressionContext::Pragma_expressionContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::Pragma_expressionContext::number() { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::Fixed_point_number() { |
| return getToken(SV3_1aPpParser::Fixed_point_number, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::String() { |
| return getToken(SV3_1aPpParser::String, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::Special() { |
| return getToken(SV3_1aPpParser::Special, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::CURLY_OPEN() { |
| return getToken(SV3_1aPpParser::CURLY_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::CURLY_CLOSE() { |
| return getToken(SV3_1aPpParser::CURLY_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::SQUARE_OPEN() { |
| return getToken(SV3_1aPpParser::SQUARE_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::SQUARE_CLOSE() { |
| return getToken(SV3_1aPpParser::SQUARE_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::PARENS_OPEN() { |
| return getToken(SV3_1aPpParser::PARENS_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::PARENS_CLOSE() { |
| return getToken(SV3_1aPpParser::PARENS_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::COMMA() { |
| return getToken(SV3_1aPpParser::COMMA, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::EQUAL_OP() { |
| return getToken(SV3_1aPpParser::EQUAL_OP, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::DOUBLE_QUOTE() { |
| return getToken(SV3_1aPpParser::DOUBLE_QUOTE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Pragma_expressionContext::ANY() { |
| return getToken(SV3_1aPpParser::ANY, 0); |
| } |
| |
| SV3_1aPpParser::Escaped_identifierContext* SV3_1aPpParser::Pragma_expressionContext::escaped_identifier() { |
| return getRuleContext<SV3_1aPpParser::Escaped_identifierContext>(0); |
| } |
| |
| SV3_1aPpParser::Pound_delayContext* SV3_1aPpParser::Pragma_expressionContext::pound_delay() { |
| return getRuleContext<SV3_1aPpParser::Pound_delayContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Pragma_expressionContext::getRuleIndex() const { |
| return SV3_1aPpParser::RulePragma_expression; |
| } |
| |
| void SV3_1aPpParser::Pragma_expressionContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterPragma_expression(this); |
| } |
| |
| void SV3_1aPpParser::Pragma_expressionContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitPragma_expression(this); |
| } |
| |
| SV3_1aPpParser::Pragma_expressionContext* SV3_1aPpParser::pragma_expression() { |
| Pragma_expressionContext *_localctx = _tracker.createInstance<Pragma_expressionContext>(_ctx, getState()); |
| enterRule(_localctx, 268, SV3_1aPpParser::RulePragma_expression); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(1502); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: { |
| enterOuterAlt(_localctx, 1); |
| setState(1484); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Number: { |
| enterOuterAlt(_localctx, 2); |
| setState(1485); |
| number(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Spaces: { |
| enterOuterAlt(_localctx, 3); |
| setState(1486); |
| match(SV3_1aPpParser::Spaces); |
| break; |
| } |
| |
| case SV3_1aPpParser::Fixed_point_number: { |
| enterOuterAlt(_localctx, 4); |
| setState(1487); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| case SV3_1aPpParser::String: { |
| enterOuterAlt(_localctx, 5); |
| setState(1488); |
| match(SV3_1aPpParser::String); |
| break; |
| } |
| |
| case SV3_1aPpParser::Special: { |
| enterOuterAlt(_localctx, 6); |
| setState(1489); |
| match(SV3_1aPpParser::Special); |
| break; |
| } |
| |
| case SV3_1aPpParser::CURLY_OPEN: { |
| enterOuterAlt(_localctx, 7); |
| setState(1490); |
| match(SV3_1aPpParser::CURLY_OPEN); |
| break; |
| } |
| |
| case SV3_1aPpParser::CURLY_CLOSE: { |
| enterOuterAlt(_localctx, 8); |
| setState(1491); |
| match(SV3_1aPpParser::CURLY_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::SQUARE_OPEN: { |
| enterOuterAlt(_localctx, 9); |
| setState(1492); |
| match(SV3_1aPpParser::SQUARE_OPEN); |
| break; |
| } |
| |
| case SV3_1aPpParser::SQUARE_CLOSE: { |
| enterOuterAlt(_localctx, 10); |
| setState(1493); |
| match(SV3_1aPpParser::SQUARE_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::PARENS_OPEN: { |
| enterOuterAlt(_localctx, 11); |
| setState(1494); |
| match(SV3_1aPpParser::PARENS_OPEN); |
| break; |
| } |
| |
| case SV3_1aPpParser::PARENS_CLOSE: { |
| enterOuterAlt(_localctx, 12); |
| setState(1495); |
| match(SV3_1aPpParser::PARENS_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::COMMA: { |
| enterOuterAlt(_localctx, 13); |
| setState(1496); |
| match(SV3_1aPpParser::COMMA); |
| break; |
| } |
| |
| case SV3_1aPpParser::EQUAL_OP: { |
| enterOuterAlt(_localctx, 14); |
| setState(1497); |
| match(SV3_1aPpParser::EQUAL_OP); |
| break; |
| } |
| |
| case SV3_1aPpParser::DOUBLE_QUOTE: { |
| enterOuterAlt(_localctx, 15); |
| setState(1498); |
| match(SV3_1aPpParser::DOUBLE_QUOTE); |
| break; |
| } |
| |
| case SV3_1aPpParser::ANY: { |
| enterOuterAlt(_localctx, 16); |
| setState(1499); |
| match(SV3_1aPpParser::ANY); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| enterOuterAlt(_localctx, 17); |
| setState(1500); |
| escaped_identifier(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Pound_delay: { |
| enterOuterAlt(_localctx, 18); |
| setState(1501); |
| pound_delay(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Macro_argContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Macro_argContext::Macro_argContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::Macro_argContext::number() { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argContext::Fixed_point_number() { |
| return getToken(SV3_1aPpParser::Fixed_point_number, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argContext::String() { |
| return getToken(SV3_1aPpParser::String, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argContext::Special() { |
| return getToken(SV3_1aPpParser::Special, 0); |
| } |
| |
| SV3_1aPpParser::Paired_parensContext* SV3_1aPpParser::Macro_argContext::paired_parens() { |
| return getRuleContext<SV3_1aPpParser::Paired_parensContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argContext::COMMA() { |
| return getToken(SV3_1aPpParser::COMMA, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argContext::EQUAL_OP() { |
| return getToken(SV3_1aPpParser::EQUAL_OP, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argContext::DOUBLE_QUOTE() { |
| return getToken(SV3_1aPpParser::DOUBLE_QUOTE, 0); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::Macro_argContext::macro_instance() { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argContext::TEXT_CR() { |
| return getToken(SV3_1aPpParser::TEXT_CR, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Macro_argContext::ANY() { |
| return getToken(SV3_1aPpParser::ANY, 0); |
| } |
| |
| SV3_1aPpParser::Escaped_identifierContext* SV3_1aPpParser::Macro_argContext::escaped_identifier() { |
| return getRuleContext<SV3_1aPpParser::Escaped_identifierContext>(0); |
| } |
| |
| SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext* SV3_1aPpParser::Macro_argContext::simple_args_macro_definition_in_macro_body() { |
| return getRuleContext<SV3_1aPpParser::Simple_args_macro_definition_in_macro_bodyContext>(0); |
| } |
| |
| SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext* SV3_1aPpParser::Macro_argContext::simple_no_args_macro_definition_in_macro_body() { |
| return getRuleContext<SV3_1aPpParser::Simple_no_args_macro_definition_in_macro_bodyContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Macro_argContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleMacro_arg; |
| } |
| |
| void SV3_1aPpParser::Macro_argContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterMacro_arg(this); |
| } |
| |
| void SV3_1aPpParser::Macro_argContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitMacro_arg(this); |
| } |
| |
| SV3_1aPpParser::Macro_argContext* SV3_1aPpParser::macro_arg() { |
| Macro_argContext *_localctx = _tracker.createInstance<Macro_argContext>(_ctx, getState()); |
| enterRule(_localctx, 270, SV3_1aPpParser::RuleMacro_arg); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(1521); |
| _errHandler->sync(this); |
| switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 119, _ctx)) { |
| case 1: { |
| enterOuterAlt(_localctx, 1); |
| setState(1504); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case 2: { |
| enterOuterAlt(_localctx, 2); |
| setState(1505); |
| number(); |
| break; |
| } |
| |
| case 3: { |
| enterOuterAlt(_localctx, 3); |
| setState(1506); |
| match(SV3_1aPpParser::Spaces); |
| break; |
| } |
| |
| case 4: { |
| enterOuterAlt(_localctx, 4); |
| setState(1507); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| case 5: { |
| enterOuterAlt(_localctx, 5); |
| setState(1508); |
| match(SV3_1aPpParser::String); |
| break; |
| } |
| |
| case 6: { |
| enterOuterAlt(_localctx, 6); |
| setState(1509); |
| match(SV3_1aPpParser::Special); |
| break; |
| } |
| |
| case 7: { |
| enterOuterAlt(_localctx, 7); |
| setState(1510); |
| paired_parens(); |
| break; |
| } |
| |
| case 8: { |
| enterOuterAlt(_localctx, 8); |
| setState(1511); |
| match(SV3_1aPpParser::COMMA); |
| break; |
| } |
| |
| case 9: { |
| enterOuterAlt(_localctx, 9); |
| setState(1512); |
| match(SV3_1aPpParser::EQUAL_OP); |
| break; |
| } |
| |
| case 10: { |
| enterOuterAlt(_localctx, 10); |
| setState(1513); |
| match(SV3_1aPpParser::DOUBLE_QUOTE); |
| break; |
| } |
| |
| case 11: { |
| enterOuterAlt(_localctx, 11); |
| setState(1514); |
| macro_instance(); |
| break; |
| } |
| |
| case 12: { |
| enterOuterAlt(_localctx, 12); |
| setState(1515); |
| match(SV3_1aPpParser::CR); |
| break; |
| } |
| |
| case 13: { |
| enterOuterAlt(_localctx, 13); |
| setState(1516); |
| match(SV3_1aPpParser::TEXT_CR); |
| break; |
| } |
| |
| case 14: { |
| enterOuterAlt(_localctx, 14); |
| setState(1517); |
| match(SV3_1aPpParser::ANY); |
| break; |
| } |
| |
| case 15: { |
| enterOuterAlt(_localctx, 15); |
| setState(1518); |
| escaped_identifier(); |
| break; |
| } |
| |
| case 16: { |
| enterOuterAlt(_localctx, 16); |
| setState(1519); |
| simple_args_macro_definition_in_macro_body(); |
| break; |
| } |
| |
| case 17: { |
| enterOuterAlt(_localctx, 17); |
| setState(1520); |
| simple_no_args_macro_definition_in_macro_body(); |
| break; |
| } |
| |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Paired_parensContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Paired_parensContext::Paired_parensContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::PARENS_OPEN() { |
| return getToken(SV3_1aPpParser::PARENS_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::PARENS_CLOSE() { |
| return getToken(SV3_1aPpParser::PARENS_CLOSE, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Paired_parensContext::Simple_identifier() { |
| return getTokens(SV3_1aPpParser::Simple_identifier); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::Simple_identifier(size_t i) { |
| return getToken(SV3_1aPpParser::Simple_identifier, i); |
| } |
| |
| std::vector<SV3_1aPpParser::NumberContext *> SV3_1aPpParser::Paired_parensContext::number() { |
| return getRuleContexts<SV3_1aPpParser::NumberContext>(); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::Paired_parensContext::number(size_t i) { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Paired_parensContext::Spaces() { |
| return getTokens(SV3_1aPpParser::Spaces); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::Spaces(size_t i) { |
| return getToken(SV3_1aPpParser::Spaces, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Paired_parensContext::Fixed_point_number() { |
| return getTokens(SV3_1aPpParser::Fixed_point_number); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::Fixed_point_number(size_t i) { |
| return getToken(SV3_1aPpParser::Fixed_point_number, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Paired_parensContext::String() { |
| return getTokens(SV3_1aPpParser::String); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::String(size_t i) { |
| return getToken(SV3_1aPpParser::String, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Paired_parensContext::Special() { |
| return getTokens(SV3_1aPpParser::Special); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::Special(size_t i) { |
| return getToken(SV3_1aPpParser::Special, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Paired_parensContext::COMMA() { |
| return getTokens(SV3_1aPpParser::COMMA); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::COMMA(size_t i) { |
| return getToken(SV3_1aPpParser::COMMA, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Paired_parensContext::EQUAL_OP() { |
| return getTokens(SV3_1aPpParser::EQUAL_OP); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::EQUAL_OP(size_t i) { |
| return getToken(SV3_1aPpParser::EQUAL_OP, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Paired_parensContext::DOUBLE_QUOTE() { |
| return getTokens(SV3_1aPpParser::DOUBLE_QUOTE); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::DOUBLE_QUOTE(size_t i) { |
| return getToken(SV3_1aPpParser::DOUBLE_QUOTE, i); |
| } |
| |
| std::vector<SV3_1aPpParser::Macro_instanceContext *> SV3_1aPpParser::Paired_parensContext::macro_instance() { |
| return getRuleContexts<SV3_1aPpParser::Macro_instanceContext>(); |
| } |
| |
| SV3_1aPpParser::Macro_instanceContext* SV3_1aPpParser::Paired_parensContext::macro_instance(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Macro_instanceContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Paired_parensContext::TEXT_CR() { |
| return getTokens(SV3_1aPpParser::TEXT_CR); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::TEXT_CR(size_t i) { |
| return getToken(SV3_1aPpParser::TEXT_CR, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Paired_parensContext::CR() { |
| return getTokens(SV3_1aPpParser::CR); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::CR(size_t i) { |
| return getToken(SV3_1aPpParser::CR, i); |
| } |
| |
| std::vector<tree::TerminalNode *> SV3_1aPpParser::Paired_parensContext::ANY() { |
| return getTokens(SV3_1aPpParser::ANY); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::ANY(size_t i) { |
| return getToken(SV3_1aPpParser::ANY, i); |
| } |
| |
| std::vector<SV3_1aPpParser::Paired_parensContext *> SV3_1aPpParser::Paired_parensContext::paired_parens() { |
| return getRuleContexts<SV3_1aPpParser::Paired_parensContext>(); |
| } |
| |
| SV3_1aPpParser::Paired_parensContext* SV3_1aPpParser::Paired_parensContext::paired_parens(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Paired_parensContext>(i); |
| } |
| |
| std::vector<SV3_1aPpParser::Escaped_identifierContext *> SV3_1aPpParser::Paired_parensContext::escaped_identifier() { |
| return getRuleContexts<SV3_1aPpParser::Escaped_identifierContext>(); |
| } |
| |
| SV3_1aPpParser::Escaped_identifierContext* SV3_1aPpParser::Paired_parensContext::escaped_identifier(size_t i) { |
| return getRuleContext<SV3_1aPpParser::Escaped_identifierContext>(i); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::CURLY_OPEN() { |
| return getToken(SV3_1aPpParser::CURLY_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::CURLY_CLOSE() { |
| return getToken(SV3_1aPpParser::CURLY_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::SQUARE_OPEN() { |
| return getToken(SV3_1aPpParser::SQUARE_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Paired_parensContext::SQUARE_CLOSE() { |
| return getToken(SV3_1aPpParser::SQUARE_CLOSE, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Paired_parensContext::getRuleIndex() const { |
| return SV3_1aPpParser::RulePaired_parens; |
| } |
| |
| void SV3_1aPpParser::Paired_parensContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterPaired_parens(this); |
| } |
| |
| void SV3_1aPpParser::Paired_parensContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitPaired_parens(this); |
| } |
| |
| SV3_1aPpParser::Paired_parensContext* SV3_1aPpParser::paired_parens() { |
| Paired_parensContext *_localctx = _tracker.createInstance<Paired_parensContext>(_ctx, getState()); |
| enterRule(_localctx, 272, SV3_1aPpParser::RulePaired_parens); |
| size_t _la = 0; |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(1587); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::PARENS_OPEN: { |
| enterOuterAlt(_localctx, 1); |
| setState(1523); |
| match(SV3_1aPpParser::PARENS_OPEN); |
| setState(1541); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (((((_la - 67) & ~ 0x3fULL) == 0) && |
| ((1ULL << (_la - 67)) & ((1ULL << (SV3_1aPpParser::Macro_identifier - 67)) |
| | (1ULL << (SV3_1aPpParser::Macro_Escaped_identifier - 67)) |
| | (1ULL << (SV3_1aPpParser::String - 67)) |
| | (1ULL << (SV3_1aPpParser::Simple_identifier - 67)) |
| | (1ULL << (SV3_1aPpParser::Spaces - 67)) |
| | (1ULL << (SV3_1aPpParser::Number - 67)) |
| | (1ULL << (SV3_1aPpParser::Fixed_point_number - 67)) |
| | (1ULL << (SV3_1aPpParser::TEXT_CR - 67)) |
| | (1ULL << (SV3_1aPpParser::CR - 67)) |
| | (1ULL << (SV3_1aPpParser::PARENS_OPEN - 67)) |
| | (1ULL << (SV3_1aPpParser::COMMA - 67)) |
| | (1ULL << (SV3_1aPpParser::EQUAL_OP - 67)) |
| | (1ULL << (SV3_1aPpParser::DOUBLE_QUOTE - 67)) |
| | (1ULL << (SV3_1aPpParser::Escaped_identifier - 67)) |
| | (1ULL << (SV3_1aPpParser::CURLY_OPEN - 67)) |
| | (1ULL << (SV3_1aPpParser::SQUARE_OPEN - 67)) |
| | (1ULL << (SV3_1aPpParser::Special - 67)) |
| | (1ULL << (SV3_1aPpParser::ANY - 67)))) != 0)) { |
| setState(1539); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(1524); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Number: { |
| setState(1525); |
| number(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Spaces: { |
| setState(1526); |
| match(SV3_1aPpParser::Spaces); |
| break; |
| } |
| |
| case SV3_1aPpParser::Fixed_point_number: { |
| setState(1527); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| case SV3_1aPpParser::String: { |
| setState(1528); |
| match(SV3_1aPpParser::String); |
| break; |
| } |
| |
| case SV3_1aPpParser::Special: { |
| setState(1529); |
| match(SV3_1aPpParser::Special); |
| break; |
| } |
| |
| case SV3_1aPpParser::COMMA: { |
| setState(1530); |
| match(SV3_1aPpParser::COMMA); |
| break; |
| } |
| |
| case SV3_1aPpParser::EQUAL_OP: { |
| setState(1531); |
| match(SV3_1aPpParser::EQUAL_OP); |
| break; |
| } |
| |
| case SV3_1aPpParser::DOUBLE_QUOTE: { |
| setState(1532); |
| match(SV3_1aPpParser::DOUBLE_QUOTE); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(1533); |
| macro_instance(); |
| break; |
| } |
| |
| case SV3_1aPpParser::TEXT_CR: { |
| setState(1534); |
| match(SV3_1aPpParser::TEXT_CR); |
| break; |
| } |
| |
| case SV3_1aPpParser::CR: { |
| setState(1535); |
| match(SV3_1aPpParser::CR); |
| break; |
| } |
| |
| case SV3_1aPpParser::ANY: { |
| setState(1536); |
| match(SV3_1aPpParser::ANY); |
| break; |
| } |
| |
| case SV3_1aPpParser::PARENS_OPEN: |
| case SV3_1aPpParser::CURLY_OPEN: |
| case SV3_1aPpParser::SQUARE_OPEN: { |
| setState(1537); |
| paired_parens(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(1538); |
| escaped_identifier(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| setState(1543); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1544); |
| match(SV3_1aPpParser::PARENS_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::CURLY_OPEN: { |
| enterOuterAlt(_localctx, 2); |
| setState(1545); |
| match(SV3_1aPpParser::CURLY_OPEN); |
| setState(1562); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (((((_la - 67) & ~ 0x3fULL) == 0) && |
| ((1ULL << (_la - 67)) & ((1ULL << (SV3_1aPpParser::Macro_identifier - 67)) |
| | (1ULL << (SV3_1aPpParser::Macro_Escaped_identifier - 67)) |
| | (1ULL << (SV3_1aPpParser::String - 67)) |
| | (1ULL << (SV3_1aPpParser::Simple_identifier - 67)) |
| | (1ULL << (SV3_1aPpParser::Spaces - 67)) |
| | (1ULL << (SV3_1aPpParser::Number - 67)) |
| | (1ULL << (SV3_1aPpParser::Fixed_point_number - 67)) |
| | (1ULL << (SV3_1aPpParser::CR - 67)) |
| | (1ULL << (SV3_1aPpParser::PARENS_OPEN - 67)) |
| | (1ULL << (SV3_1aPpParser::COMMA - 67)) |
| | (1ULL << (SV3_1aPpParser::EQUAL_OP - 67)) |
| | (1ULL << (SV3_1aPpParser::DOUBLE_QUOTE - 67)) |
| | (1ULL << (SV3_1aPpParser::Escaped_identifier - 67)) |
| | (1ULL << (SV3_1aPpParser::CURLY_OPEN - 67)) |
| | (1ULL << (SV3_1aPpParser::SQUARE_OPEN - 67)) |
| | (1ULL << (SV3_1aPpParser::Special - 67)) |
| | (1ULL << (SV3_1aPpParser::ANY - 67)))) != 0)) { |
| setState(1560); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(1546); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Number: { |
| setState(1547); |
| number(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Spaces: { |
| setState(1548); |
| match(SV3_1aPpParser::Spaces); |
| break; |
| } |
| |
| case SV3_1aPpParser::Fixed_point_number: { |
| setState(1549); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| case SV3_1aPpParser::String: { |
| setState(1550); |
| match(SV3_1aPpParser::String); |
| break; |
| } |
| |
| case SV3_1aPpParser::Special: { |
| setState(1551); |
| match(SV3_1aPpParser::Special); |
| break; |
| } |
| |
| case SV3_1aPpParser::COMMA: { |
| setState(1552); |
| match(SV3_1aPpParser::COMMA); |
| break; |
| } |
| |
| case SV3_1aPpParser::EQUAL_OP: { |
| setState(1553); |
| match(SV3_1aPpParser::EQUAL_OP); |
| break; |
| } |
| |
| case SV3_1aPpParser::DOUBLE_QUOTE: { |
| setState(1554); |
| match(SV3_1aPpParser::DOUBLE_QUOTE); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(1555); |
| macro_instance(); |
| break; |
| } |
| |
| case SV3_1aPpParser::CR: { |
| setState(1556); |
| match(SV3_1aPpParser::CR); |
| break; |
| } |
| |
| case SV3_1aPpParser::ANY: { |
| setState(1557); |
| match(SV3_1aPpParser::ANY); |
| break; |
| } |
| |
| case SV3_1aPpParser::PARENS_OPEN: |
| case SV3_1aPpParser::CURLY_OPEN: |
| case SV3_1aPpParser::SQUARE_OPEN: { |
| setState(1558); |
| paired_parens(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(1559); |
| escaped_identifier(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| setState(1564); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1565); |
| match(SV3_1aPpParser::CURLY_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::SQUARE_OPEN: { |
| enterOuterAlt(_localctx, 3); |
| setState(1566); |
| match(SV3_1aPpParser::SQUARE_OPEN); |
| setState(1583); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| while (((((_la - 67) & ~ 0x3fULL) == 0) && |
| ((1ULL << (_la - 67)) & ((1ULL << (SV3_1aPpParser::Macro_identifier - 67)) |
| | (1ULL << (SV3_1aPpParser::Macro_Escaped_identifier - 67)) |
| | (1ULL << (SV3_1aPpParser::String - 67)) |
| | (1ULL << (SV3_1aPpParser::Simple_identifier - 67)) |
| | (1ULL << (SV3_1aPpParser::Spaces - 67)) |
| | (1ULL << (SV3_1aPpParser::Number - 67)) |
| | (1ULL << (SV3_1aPpParser::Fixed_point_number - 67)) |
| | (1ULL << (SV3_1aPpParser::CR - 67)) |
| | (1ULL << (SV3_1aPpParser::PARENS_OPEN - 67)) |
| | (1ULL << (SV3_1aPpParser::COMMA - 67)) |
| | (1ULL << (SV3_1aPpParser::EQUAL_OP - 67)) |
| | (1ULL << (SV3_1aPpParser::DOUBLE_QUOTE - 67)) |
| | (1ULL << (SV3_1aPpParser::Escaped_identifier - 67)) |
| | (1ULL << (SV3_1aPpParser::CURLY_OPEN - 67)) |
| | (1ULL << (SV3_1aPpParser::SQUARE_OPEN - 67)) |
| | (1ULL << (SV3_1aPpParser::Special - 67)) |
| | (1ULL << (SV3_1aPpParser::ANY - 67)))) != 0)) { |
| setState(1581); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: { |
| setState(1567); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Number: { |
| setState(1568); |
| number(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Spaces: { |
| setState(1569); |
| match(SV3_1aPpParser::Spaces); |
| break; |
| } |
| |
| case SV3_1aPpParser::Fixed_point_number: { |
| setState(1570); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| case SV3_1aPpParser::String: { |
| setState(1571); |
| match(SV3_1aPpParser::String); |
| break; |
| } |
| |
| case SV3_1aPpParser::Special: { |
| setState(1572); |
| match(SV3_1aPpParser::Special); |
| break; |
| } |
| |
| case SV3_1aPpParser::COMMA: { |
| setState(1573); |
| match(SV3_1aPpParser::COMMA); |
| break; |
| } |
| |
| case SV3_1aPpParser::EQUAL_OP: { |
| setState(1574); |
| match(SV3_1aPpParser::EQUAL_OP); |
| break; |
| } |
| |
| case SV3_1aPpParser::DOUBLE_QUOTE: { |
| setState(1575); |
| match(SV3_1aPpParser::DOUBLE_QUOTE); |
| break; |
| } |
| |
| case SV3_1aPpParser::Macro_identifier: |
| case SV3_1aPpParser::Macro_Escaped_identifier: { |
| setState(1576); |
| macro_instance(); |
| break; |
| } |
| |
| case SV3_1aPpParser::CR: { |
| setState(1577); |
| match(SV3_1aPpParser::CR); |
| break; |
| } |
| |
| case SV3_1aPpParser::ANY: { |
| setState(1578); |
| match(SV3_1aPpParser::ANY); |
| break; |
| } |
| |
| case SV3_1aPpParser::PARENS_OPEN: |
| case SV3_1aPpParser::CURLY_OPEN: |
| case SV3_1aPpParser::SQUARE_OPEN: { |
| setState(1579); |
| paired_parens(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| setState(1580); |
| escaped_identifier(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| setState(1585); |
| _errHandler->sync(this); |
| _la = _input->LA(1); |
| } |
| setState(1586); |
| match(SV3_1aPpParser::SQUARE_CLOSE); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Text_blobContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Text_blobContext::Text_blobContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::Text_blobContext::number() { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::CR() { |
| return getToken(SV3_1aPpParser::CR, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::Fixed_point_number() { |
| return getToken(SV3_1aPpParser::Fixed_point_number, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::ESCAPED_CR() { |
| return getToken(SV3_1aPpParser::ESCAPED_CR, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::String() { |
| return getToken(SV3_1aPpParser::String, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::PARENS_OPEN() { |
| return getToken(SV3_1aPpParser::PARENS_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::PARENS_CLOSE() { |
| return getToken(SV3_1aPpParser::PARENS_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::COMMA() { |
| return getToken(SV3_1aPpParser::COMMA, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::EQUAL_OP() { |
| return getToken(SV3_1aPpParser::EQUAL_OP, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::DOUBLE_QUOTE() { |
| return getToken(SV3_1aPpParser::DOUBLE_QUOTE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::Special() { |
| return getToken(SV3_1aPpParser::Special, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::CURLY_OPEN() { |
| return getToken(SV3_1aPpParser::CURLY_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::CURLY_CLOSE() { |
| return getToken(SV3_1aPpParser::CURLY_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::SQUARE_OPEN() { |
| return getToken(SV3_1aPpParser::SQUARE_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::SQUARE_CLOSE() { |
| return getToken(SV3_1aPpParser::SQUARE_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::TICK_TICK() { |
| return getToken(SV3_1aPpParser::TICK_TICK, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::TICK_VARIABLE() { |
| return getToken(SV3_1aPpParser::TICK_VARIABLE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::TIMESCALE() { |
| return getToken(SV3_1aPpParser::TIMESCALE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::ANY() { |
| return getToken(SV3_1aPpParser::ANY, 0); |
| } |
| |
| SV3_1aPpParser::Pound_delayContext* SV3_1aPpParser::Text_blobContext::pound_delay() { |
| return getRuleContext<SV3_1aPpParser::Pound_delayContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::TICK_QUOTE() { |
| return getToken(SV3_1aPpParser::TICK_QUOTE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::TICK_BACKSLASH_TICK_QUOTE() { |
| return getToken(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Text_blobContext::TEXT_CR() { |
| return getToken(SV3_1aPpParser::TEXT_CR, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Text_blobContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleText_blob; |
| } |
| |
| void SV3_1aPpParser::Text_blobContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterText_blob(this); |
| } |
| |
| void SV3_1aPpParser::Text_blobContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitText_blob(this); |
| } |
| |
| SV3_1aPpParser::Text_blobContext* SV3_1aPpParser::text_blob() { |
| Text_blobContext *_localctx = _tracker.createInstance<Text_blobContext>(_ctx, getState()); |
| enterRule(_localctx, 274, SV3_1aPpParser::RuleText_blob); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(1614); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: { |
| enterOuterAlt(_localctx, 1); |
| setState(1589); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Number: { |
| enterOuterAlt(_localctx, 2); |
| setState(1590); |
| number(); |
| break; |
| } |
| |
| case SV3_1aPpParser::CR: { |
| enterOuterAlt(_localctx, 3); |
| setState(1591); |
| match(SV3_1aPpParser::CR); |
| break; |
| } |
| |
| case SV3_1aPpParser::Spaces: { |
| enterOuterAlt(_localctx, 4); |
| setState(1592); |
| match(SV3_1aPpParser::Spaces); |
| break; |
| } |
| |
| case SV3_1aPpParser::Fixed_point_number: { |
| enterOuterAlt(_localctx, 5); |
| setState(1593); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| case SV3_1aPpParser::ESCAPED_CR: { |
| enterOuterAlt(_localctx, 6); |
| setState(1594); |
| match(SV3_1aPpParser::ESCAPED_CR); |
| break; |
| } |
| |
| case SV3_1aPpParser::String: { |
| enterOuterAlt(_localctx, 7); |
| setState(1595); |
| match(SV3_1aPpParser::String); |
| break; |
| } |
| |
| case SV3_1aPpParser::PARENS_OPEN: { |
| enterOuterAlt(_localctx, 8); |
| setState(1596); |
| match(SV3_1aPpParser::PARENS_OPEN); |
| break; |
| } |
| |
| case SV3_1aPpParser::PARENS_CLOSE: { |
| enterOuterAlt(_localctx, 9); |
| setState(1597); |
| match(SV3_1aPpParser::PARENS_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::COMMA: { |
| enterOuterAlt(_localctx, 10); |
| setState(1598); |
| match(SV3_1aPpParser::COMMA); |
| break; |
| } |
| |
| case SV3_1aPpParser::EQUAL_OP: { |
| enterOuterAlt(_localctx, 11); |
| setState(1599); |
| match(SV3_1aPpParser::EQUAL_OP); |
| break; |
| } |
| |
| case SV3_1aPpParser::DOUBLE_QUOTE: { |
| enterOuterAlt(_localctx, 12); |
| setState(1600); |
| match(SV3_1aPpParser::DOUBLE_QUOTE); |
| break; |
| } |
| |
| case SV3_1aPpParser::Special: { |
| enterOuterAlt(_localctx, 13); |
| setState(1601); |
| match(SV3_1aPpParser::Special); |
| break; |
| } |
| |
| case SV3_1aPpParser::CURLY_OPEN: { |
| enterOuterAlt(_localctx, 14); |
| setState(1602); |
| match(SV3_1aPpParser::CURLY_OPEN); |
| break; |
| } |
| |
| case SV3_1aPpParser::CURLY_CLOSE: { |
| enterOuterAlt(_localctx, 15); |
| setState(1603); |
| match(SV3_1aPpParser::CURLY_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::SQUARE_OPEN: { |
| enterOuterAlt(_localctx, 16); |
| setState(1604); |
| match(SV3_1aPpParser::SQUARE_OPEN); |
| break; |
| } |
| |
| case SV3_1aPpParser::SQUARE_CLOSE: { |
| enterOuterAlt(_localctx, 17); |
| setState(1605); |
| match(SV3_1aPpParser::SQUARE_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::TICK_TICK: { |
| enterOuterAlt(_localctx, 18); |
| setState(1606); |
| match(SV3_1aPpParser::TICK_TICK); |
| break; |
| } |
| |
| case SV3_1aPpParser::TICK_VARIABLE: { |
| enterOuterAlt(_localctx, 19); |
| setState(1607); |
| match(SV3_1aPpParser::TICK_VARIABLE); |
| break; |
| } |
| |
| case SV3_1aPpParser::TIMESCALE: { |
| enterOuterAlt(_localctx, 20); |
| setState(1608); |
| match(SV3_1aPpParser::TIMESCALE); |
| break; |
| } |
| |
| case SV3_1aPpParser::ANY: { |
| enterOuterAlt(_localctx, 21); |
| setState(1609); |
| match(SV3_1aPpParser::ANY); |
| break; |
| } |
| |
| case SV3_1aPpParser::Pound_delay: { |
| enterOuterAlt(_localctx, 22); |
| setState(1610); |
| pound_delay(); |
| break; |
| } |
| |
| case SV3_1aPpParser::TICK_QUOTE: { |
| enterOuterAlt(_localctx, 23); |
| setState(1611); |
| match(SV3_1aPpParser::TICK_QUOTE); |
| break; |
| } |
| |
| case SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE: { |
| enterOuterAlt(_localctx, 24); |
| setState(1612); |
| match(SV3_1aPpParser::TICK_BACKSLASH_TICK_QUOTE); |
| break; |
| } |
| |
| case SV3_1aPpParser::TEXT_CR: { |
| enterOuterAlt(_localctx, 25); |
| setState(1613); |
| match(SV3_1aPpParser::TEXT_CR); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- StringContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::StringContext::StringContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::StringContext::String() { |
| return getToken(SV3_1aPpParser::String, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::StringContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleString; |
| } |
| |
| void SV3_1aPpParser::StringContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterString(this); |
| } |
| |
| void SV3_1aPpParser::StringContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitString(this); |
| } |
| |
| SV3_1aPpParser::StringContext* SV3_1aPpParser::string() { |
| StringContext *_localctx = _tracker.createInstance<StringContext>(_ctx, getState()); |
| enterRule(_localctx, 276, SV3_1aPpParser::RuleString); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1616); |
| match(SV3_1aPpParser::String); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Escaped_identifierContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Escaped_identifierContext::Escaped_identifierContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Escaped_identifierContext::Escaped_identifier() { |
| return getToken(SV3_1aPpParser::Escaped_identifier, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Escaped_identifierContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleEscaped_identifier; |
| } |
| |
| void SV3_1aPpParser::Escaped_identifierContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterEscaped_identifier(this); |
| } |
| |
| void SV3_1aPpParser::Escaped_identifierContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitEscaped_identifier(this); |
| } |
| |
| SV3_1aPpParser::Escaped_identifierContext* SV3_1aPpParser::escaped_identifier() { |
| Escaped_identifierContext *_localctx = _tracker.createInstance<Escaped_identifierContext>(_ctx, getState()); |
| enterRule(_localctx, 278, SV3_1aPpParser::RuleEscaped_identifier); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| enterOuterAlt(_localctx, 1); |
| setState(1618); |
| match(SV3_1aPpParser::Escaped_identifier); |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- Default_valueContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::Default_valueContext::Default_valueContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_valueContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::Default_valueContext::number() { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_valueContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_valueContext::Fixed_point_number() { |
| return getToken(SV3_1aPpParser::Fixed_point_number, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_valueContext::String() { |
| return getToken(SV3_1aPpParser::String, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_valueContext::Special() { |
| return getToken(SV3_1aPpParser::Special, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_valueContext::CURLY_OPEN() { |
| return getToken(SV3_1aPpParser::CURLY_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_valueContext::CURLY_CLOSE() { |
| return getToken(SV3_1aPpParser::CURLY_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_valueContext::SQUARE_OPEN() { |
| return getToken(SV3_1aPpParser::SQUARE_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_valueContext::SQUARE_CLOSE() { |
| return getToken(SV3_1aPpParser::SQUARE_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::Default_valueContext::ANY() { |
| return getToken(SV3_1aPpParser::ANY, 0); |
| } |
| |
| SV3_1aPpParser::Escaped_identifierContext* SV3_1aPpParser::Default_valueContext::escaped_identifier() { |
| return getRuleContext<SV3_1aPpParser::Escaped_identifierContext>(0); |
| } |
| |
| |
| size_t SV3_1aPpParser::Default_valueContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleDefault_value; |
| } |
| |
| void SV3_1aPpParser::Default_valueContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterDefault_value(this); |
| } |
| |
| void SV3_1aPpParser::Default_valueContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitDefault_value(this); |
| } |
| |
| SV3_1aPpParser::Default_valueContext* SV3_1aPpParser::default_value() { |
| Default_valueContext *_localctx = _tracker.createInstance<Default_valueContext>(_ctx, getState()); |
| enterRule(_localctx, 280, SV3_1aPpParser::RuleDefault_value); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(1632); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: { |
| enterOuterAlt(_localctx, 1); |
| setState(1620); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Number: { |
| enterOuterAlt(_localctx, 2); |
| setState(1621); |
| number(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Spaces: { |
| enterOuterAlt(_localctx, 3); |
| setState(1622); |
| match(SV3_1aPpParser::Spaces); |
| break; |
| } |
| |
| case SV3_1aPpParser::Fixed_point_number: { |
| enterOuterAlt(_localctx, 4); |
| setState(1623); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| case SV3_1aPpParser::String: { |
| enterOuterAlt(_localctx, 5); |
| setState(1624); |
| match(SV3_1aPpParser::String); |
| break; |
| } |
| |
| case SV3_1aPpParser::Special: { |
| enterOuterAlt(_localctx, 6); |
| setState(1625); |
| match(SV3_1aPpParser::Special); |
| break; |
| } |
| |
| case SV3_1aPpParser::CURLY_OPEN: { |
| enterOuterAlt(_localctx, 7); |
| setState(1626); |
| match(SV3_1aPpParser::CURLY_OPEN); |
| break; |
| } |
| |
| case SV3_1aPpParser::CURLY_CLOSE: { |
| enterOuterAlt(_localctx, 8); |
| setState(1627); |
| match(SV3_1aPpParser::CURLY_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::SQUARE_OPEN: { |
| enterOuterAlt(_localctx, 9); |
| setState(1628); |
| match(SV3_1aPpParser::SQUARE_OPEN); |
| break; |
| } |
| |
| case SV3_1aPpParser::SQUARE_CLOSE: { |
| enterOuterAlt(_localctx, 10); |
| setState(1629); |
| match(SV3_1aPpParser::SQUARE_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::ANY: { |
| enterOuterAlt(_localctx, 11); |
| setState(1630); |
| match(SV3_1aPpParser::ANY); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| enterOuterAlt(_localctx, 12); |
| setState(1631); |
| escaped_identifier(); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| //----------------- String_blobContext ------------------------------------------------------------------ |
| |
| SV3_1aPpParser::String_blobContext::String_blobContext(ParserRuleContext *parent, size_t invokingState) |
| : ParserRuleContext(parent, invokingState) { |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::Simple_identifier() { |
| return getToken(SV3_1aPpParser::Simple_identifier, 0); |
| } |
| |
| SV3_1aPpParser::NumberContext* SV3_1aPpParser::String_blobContext::number() { |
| return getRuleContext<SV3_1aPpParser::NumberContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::Spaces() { |
| return getToken(SV3_1aPpParser::Spaces, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::Fixed_point_number() { |
| return getToken(SV3_1aPpParser::Fixed_point_number, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::ESCAPED_CR() { |
| return getToken(SV3_1aPpParser::ESCAPED_CR, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::PARENS_OPEN() { |
| return getToken(SV3_1aPpParser::PARENS_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::PARENS_CLOSE() { |
| return getToken(SV3_1aPpParser::PARENS_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::COMMA() { |
| return getToken(SV3_1aPpParser::COMMA, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::EQUAL_OP() { |
| return getToken(SV3_1aPpParser::EQUAL_OP, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::DOUBLE_QUOTE() { |
| return getToken(SV3_1aPpParser::DOUBLE_QUOTE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::Special() { |
| return getToken(SV3_1aPpParser::Special, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::CURLY_OPEN() { |
| return getToken(SV3_1aPpParser::CURLY_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::CURLY_CLOSE() { |
| return getToken(SV3_1aPpParser::CURLY_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::SQUARE_OPEN() { |
| return getToken(SV3_1aPpParser::SQUARE_OPEN, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::SQUARE_CLOSE() { |
| return getToken(SV3_1aPpParser::SQUARE_CLOSE, 0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::ANY() { |
| return getToken(SV3_1aPpParser::ANY, 0); |
| } |
| |
| SV3_1aPpParser::Escaped_identifierContext* SV3_1aPpParser::String_blobContext::escaped_identifier() { |
| return getRuleContext<SV3_1aPpParser::Escaped_identifierContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::TIMESCALE() { |
| return getToken(SV3_1aPpParser::TIMESCALE, 0); |
| } |
| |
| SV3_1aPpParser::Pound_delayContext* SV3_1aPpParser::String_blobContext::pound_delay() { |
| return getRuleContext<SV3_1aPpParser::Pound_delayContext>(0); |
| } |
| |
| tree::TerminalNode* SV3_1aPpParser::String_blobContext::TEXT_CR() { |
| return getToken(SV3_1aPpParser::TEXT_CR, 0); |
| } |
| |
| |
| size_t SV3_1aPpParser::String_blobContext::getRuleIndex() const { |
| return SV3_1aPpParser::RuleString_blob; |
| } |
| |
| void SV3_1aPpParser::String_blobContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->enterString_blob(this); |
| } |
| |
| void SV3_1aPpParser::String_blobContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<SV3_1aPpParserListener *>(listener); |
| if (parserListener != nullptr) |
| parserListener->exitString_blob(this); |
| } |
| |
| SV3_1aPpParser::String_blobContext* SV3_1aPpParser::string_blob() { |
| String_blobContext *_localctx = _tracker.createInstance<String_blobContext>(_ctx, getState()); |
| enterRule(_localctx, 282, SV3_1aPpParser::RuleString_blob); |
| |
| auto onExit = finally([=] { |
| exitRule(); |
| }); |
| try { |
| setState(1654); |
| _errHandler->sync(this); |
| switch (_input->LA(1)) { |
| case SV3_1aPpParser::Simple_identifier: { |
| enterOuterAlt(_localctx, 1); |
| setState(1634); |
| match(SV3_1aPpParser::Simple_identifier); |
| break; |
| } |
| |
| case SV3_1aPpParser::Number: { |
| enterOuterAlt(_localctx, 2); |
| setState(1635); |
| number(); |
| break; |
| } |
| |
| case SV3_1aPpParser::Spaces: { |
| enterOuterAlt(_localctx, 3); |
| setState(1636); |
| match(SV3_1aPpParser::Spaces); |
| break; |
| } |
| |
| case SV3_1aPpParser::Fixed_point_number: { |
| enterOuterAlt(_localctx, 4); |
| setState(1637); |
| match(SV3_1aPpParser::Fixed_point_number); |
| break; |
| } |
| |
| case SV3_1aPpParser::ESCAPED_CR: { |
| enterOuterAlt(_localctx, 5); |
| setState(1638); |
| match(SV3_1aPpParser::ESCAPED_CR); |
| break; |
| } |
| |
| case SV3_1aPpParser::PARENS_OPEN: { |
| enterOuterAlt(_localctx, 6); |
| setState(1639); |
| match(SV3_1aPpParser::PARENS_OPEN); |
| break; |
| } |
| |
| case SV3_1aPpParser::PARENS_CLOSE: { |
| enterOuterAlt(_localctx, 7); |
| setState(1640); |
| match(SV3_1aPpParser::PARENS_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::COMMA: { |
| enterOuterAlt(_localctx, 8); |
| setState(1641); |
| match(SV3_1aPpParser::COMMA); |
| break; |
| } |
| |
| case SV3_1aPpParser::EQUAL_OP: { |
| enterOuterAlt(_localctx, 9); |
| setState(1642); |
| match(SV3_1aPpParser::EQUAL_OP); |
| break; |
| } |
| |
| case SV3_1aPpParser::DOUBLE_QUOTE: { |
| enterOuterAlt(_localctx, 10); |
| setState(1643); |
| match(SV3_1aPpParser::DOUBLE_QUOTE); |
| break; |
| } |
| |
| case SV3_1aPpParser::Special: { |
| enterOuterAlt(_localctx, 11); |
| setState(1644); |
| match(SV3_1aPpParser::Special); |
| break; |
| } |
| |
| case SV3_1aPpParser::CURLY_OPEN: { |
| enterOuterAlt(_localctx, 12); |
| setState(1645); |
| match(SV3_1aPpParser::CURLY_OPEN); |
| break; |
| } |
| |
| case SV3_1aPpParser::CURLY_CLOSE: { |
| enterOuterAlt(_localctx, 13); |
| setState(1646); |
| match(SV3_1aPpParser::CURLY_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::SQUARE_OPEN: { |
| enterOuterAlt(_localctx, 14); |
| setState(1647); |
| match(SV3_1aPpParser::SQUARE_OPEN); |
| break; |
| } |
| |
| case SV3_1aPpParser::SQUARE_CLOSE: { |
| enterOuterAlt(_localctx, 15); |
| setState(1648); |
| match(SV3_1aPpParser::SQUARE_CLOSE); |
| break; |
| } |
| |
| case SV3_1aPpParser::ANY: { |
| enterOuterAlt(_localctx, 16); |
| setState(1649); |
| match(SV3_1aPpParser::ANY); |
| break; |
| } |
| |
| case SV3_1aPpParser::Escaped_identifier: { |
| enterOuterAlt(_localctx, 17); |
| setState(1650); |
| escaped_identifier(); |
| break; |
| } |
| |
| case SV3_1aPpParser::TIMESCALE: { |
| enterOuterAlt(_localctx, 18); |
| setState(1651); |
| match(SV3_1aPpParser::TIMESCALE); |
| break; |
| } |
| |
| case SV3_1aPpParser::Pound_delay: { |
| enterOuterAlt(_localctx, 19); |
| setState(1652); |
| pound_delay(); |
| break; |
| } |
| |
| case SV3_1aPpParser::TEXT_CR: { |
| enterOuterAlt(_localctx, 20); |
| setState(1653); |
| match(SV3_1aPpParser::TEXT_CR); |
| break; |
| } |
| |
| default: |
| throw NoViableAltException(this); |
| } |
| |
| } |
| catch (RecognitionException &e) { |
| _errHandler->reportError(this, e); |
| _localctx->exception = std::current_exception(); |
| _errHandler->recover(this, _localctx->exception); |
| } |
| |
| return _localctx; |
| } |
| |
| // Static vars and initialization. |
| std::vector<dfa::DFA> SV3_1aPpParser::_decisionToDFA; |
| atn::PredictionContextCache SV3_1aPpParser::_sharedContextCache; |
| |
| // We own the ATN which in turn owns the ATN states. |
| atn::ATN SV3_1aPpParser::_atn; |
| std::vector<uint16_t> SV3_1aPpParser::_serializedATN; |
| |
| std::vector<std::string> SV3_1aPpParser::_ruleNames = { |
| "source_text", "description", "macro_instance", "unterminated_string", |
| "macro_actual_args", "comments", "number", "pound_delay", "macro_definition", |
| "include_directive_one_line", "include_directive", "line_directive_one_line", |
| "line_directive", "default_nettype_directive_one_line", "default_nettype_directive", |
| "sv_file_directive", "sv_line_directive", "timescale_directive_one_line", |
| "timescale_directive", "undef_directive", "ifdef_directive_one_line", |
| "ifdef_directive", "ifdef_directive_in_macro_body", "ifndef_directive_one_line", |
| "ifndef_directive", "ifndef_directive_in_macro_body", "elsif_directive_one_line", |
| "elsif_directive", "elsif_directive_in_macro_body", "elseif_directive_one_line", |
| "elseif_directive", "elseif_directive_in_macro_body", "else_directive_one_line", |
| "else_directive", "endif_directive_one_line", "endif_directive", "resetall_directive_one_line", |
| "resetall_directive", "begin_keywords_directive_one_line", "begin_keywords_directive", |
| "end_keywords_directive_one_line", "end_keywords_directive", "pragma_directive_one_line", |
| "pragma_directive", "celldefine_directive_one_line", "celldefine_directive", |
| "endcelldefine_directive_one_line", "endcelldefine_directive", "protect_directive_one_line", |
| "protect_directive", "endprotect_directive_one_line", "endprotect_directive", |
| "protected_directive_one_line", "protected_directive", "endprotected_directive_one_line", |
| "endprotected_directive", "expand_vectornets_directive_one_line", "expand_vectornets_directive", |
| "noexpand_vectornets_directive_one_line", "noexpand_vectornets_directive", |
| "autoexpand_vectornets_directive_one_line", "autoexpand_vectornets_directive", |
| "uselib_directive_one_line", "uselib_directive", "disable_portfaults_directive_one_line", |
| "disable_portfaults_directive", "enable_portfaults_directive_one_line", |
| "enable_portfaults_directive", "nosuppress_faults_directive_one_line", |
| "nosuppress_faults_directive", "suppress_faults_directive_one_line", "suppress_faults_directive", |
| "signed_directive_one_line", "signed_directive", "unsigned_directive_one_line", |
| "unsigned_directive", "remove_gatename_directive_one_line", "remove_gatename_directive", |
| "noremove_gatenames_directive_one_line", "noremove_gatenames_directive", |
| "remove_netname_directive_one_line", "remove_netname_directive", "noremove_netnames_directive_one_line", |
| "noremove_netnames_directive", "accelerate_directive_one_line", "accelerate_directive", |
| "noaccelerate_directive_one_line", "noaccelerate_directive", "default_trireg_strenght_directive_one_line", |
| "default_trireg_strenght_directive", "default_decay_time_directive_one_line", |
| "default_decay_time_directive", "unconnected_drive_directive_one_line", |
| "unconnected_drive_directive", "nounconnected_drive_directive_one_line", |
| "nounconnected_drive_directive", "delay_mode_distributed_directive_one_line", |
| "delay_mode_distributed_directive", "delay_mode_path_directive_one_line", |
| "delay_mode_path_directive", "delay_mode_unit_directive_one_line", "delay_mode_unit_directive", |
| "delay_mode_zero_directive_one_line", "delay_mode_zero_directive", "undefineall_directive", |
| "module", "endmodule", "sv_interface", "endinterface", "program", "endprogram", |
| "primitive", "endprimitive", "sv_package", "endpackage", "checker", "endchecker", |
| "config", "endconfig", "define_directive", "multiline_no_args_macro_definition", |
| "multiline_args_macro_definition", "simple_no_args_macro_definition", |
| "simple_args_macro_definition", "identifier_in_macro_body", "simple_no_args_macro_definition_in_macro_body", |
| "simple_args_macro_definition_in_macro_body", "directive_in_macro", "macro_arguments", |
| "escaped_macro_definition_body", "escaped_macro_definition_body_alt1", |
| "escaped_macro_definition_body_alt2", "simple_macro_definition_body", |
| "simple_macro_definition_body_in_macro_body", "pragma_expression", "macro_arg", |
| "paired_parens", "text_blob", "string", "escaped_identifier", "default_value", |
| "string_blob" |
| }; |
| |
| std::vector<std::string> SV3_1aPpParser::_literalNames = { |
| "", "", "", "", "'`define'", "'`celldefine'", "'`endcelldefine'", "'`default_nettype'", |
| "'`undef'", "'`ifdef'", "'`ifndef'", "'`else'", "'`elsif'", "'`elseif'", |
| "'`endif'", "'`include'", "'`pragma'", "'`begin_keywords'", "'`end_keywords'", |
| "'`resetall'", "'`timescale'", "'`unconnected_drive'", "'`nounconnected_drive'", |
| "'`line'", "'`default_decay_time'", "'`default_trireg_strength'", "'`delay_mode_distributed'", |
| "'`delay_mode_path'", "'`delay_mode_unit'", "'`delay_mode_zero'", "'`undefineall'", |
| "'`accelerate'", "'`noaccelerate'", "'`protect'", "'`uselib'", "'`disable_portfaults'", |
| "'`enable_portfaults'", "'`nosuppress_faults'", "'`suppress_faults'", |
| "'`signed'", "'`unsigned'", "'`endprotect'", "'`protected'", "'`endprotected'", |
| "'`expand_vectornets'", "'`noexpand_vectornets'", "'`autoexpand_vectornets'", |
| "'`remove_gatename'", "'`noremove_gatenames'", "'`remove_netname'", "'`noremove_netnames'", |
| "'`__FILE__'", "'`__LINE__'", "'module'", "'endmodule'", "'interface'", |
| "'endinterface'", "'program'", "'endprogram'", "'primivite'", "'endprimitive'", |
| "'package'", "'endpackage'", "'checker'", "'endchecker'", "'config'", |
| "'endconfig'", "", "", "", "", "", "", "", "", "", "", "", "", "'`\"'", |
| "'`\\`\"'", "'``'", "'('", "')'", "','", "'='", "'\"'", "", "'{'", "'}'", |
| "'['", "']'" |
| }; |
| |
| std::vector<std::string> SV3_1aPpParser::_symbolicNames = { |
| "", "One_line_comment", "Block_comment", "TICK_VARIABLE", "TICK_DEFINE", |
| "TICK_CELLDEFINE", "TICK_ENDCELLDEFINE", "TICK_DEFAULT_NETTYPE", "TICK_UNDEF", |
| "TICK_IFDEF", "TICK_IFNDEF", "TICK_ELSE", "TICK_ELSIF", "TICK_ELSEIF", |
| "TICK_ENDIF", "TICK_INCLUDE", "TICK_PRAGMA", "TICK_BEGIN_KEYWORDS", "TICK_END_KEYWORDS", |
| "TICK_RESETALL", "TICK_TIMESCALE", "TICK_UNCONNECTED_DRIVE", "TICK_NOUNCONNECTED_DRIVE", |
| "TICK_LINE", "TICK_DEFAULT_DECAY_TIME", "TICK_DEFAULT_TRIREG_STRENGTH", |
| "TICK_DELAY_MODE_DISTRIBUTED", "TICK_DELAY_MODE_PATH", "TICK_DELAY_MODE_UNIT", |
| "TICK_DELAY_MODE_ZERO", "TICK_UNDEFINEALL", "TICK_ACCELERATE", "TICK_NOACCELERATE", |
| "TICK_PROTECT", "TICK_USELIB", "TICK_DISABLE_PORTFAULTS", "TICK_ENABLE_PORTFAULTS", |
| "TICK_NOSUPPRESS_FAULTS", "TICK_SUPPRESS_FAULTS", "TICK_SIGNED", "TICK_UNSIGNED", |
| "TICK_ENDPROTECT", "TICK_PROTECTED", "TICK_ENDPROTECTED", "TICK_EXPAND_VECTORNETS", |
| "TICK_NOEXPAND_VECTORNETS", "TICK_AUTOEXPAND_VECTORNETS", "TICK_REMOVE_GATENAME", |
| "TICK_NOREMOVE_GATENAMES", "TICK_REMOVE_NETNAME", "TICK_NOREMOVE_NETNAMES", |
| "TICK_FILE__", "TICK_LINE__", "MODULE", "ENDMODULE", "INTERFACE", "ENDINTERFACE", |
| "PROGRAM", "ENDPROGRAM", "PRIMITIVE", "ENDPRIMITIVE", "PACKAGE", "ENDPACKAGE", |
| "CHECKER", "ENDCHECKER", "CONFIG", "ENDCONFIG", "Macro_identifier", "Macro_Escaped_identifier", |
| "String", "Simple_identifier", "Spaces", "Pound_delay", "TIMESCALE", "Number", |
| "Fixed_point_number", "TEXT_CR", "ESCAPED_CR", "CR", "TICK_QUOTE", "TICK_BACKSLASH_TICK_QUOTE", |
| "TICK_TICK", "PARENS_OPEN", "PARENS_CLOSE", "COMMA", "EQUAL_OP", "DOUBLE_QUOTE", |
| "Escaped_identifier", "CURLY_OPEN", "CURLY_CLOSE", "SQUARE_OPEN", "SQUARE_CLOSE", |
| "Special", "ANY" |
| }; |
| |
| dfa::Vocabulary SV3_1aPpParser::_vocabulary(_literalNames, _symbolicNames); |
| |
| std::vector<std::string> SV3_1aPpParser::_tokenNames; |
| |
| SV3_1aPpParser::Initializer::Initializer() { |
| for (size_t i = 0; i < _symbolicNames.size(); ++i) { |
| std::string name = _vocabulary.getLiteralName(i); |
| if (name.empty()) { |
| name = _vocabulary.getSymbolicName(i); |
| } |
| |
| if (name.empty()) { |
| _tokenNames.push_back("<INVALID>"); |
| } else { |
| _tokenNames.push_back(name); |
| } |
| } |
| |
| _serializedATN = { |
| 0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, |
| 0x3, 0x5f, 0x67b, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, |
| 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7, |
| 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb, |
| 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe, |
| 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4, |
| 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15, |
| 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 0x18, 0x9, |
| 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, |
| 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, |
| 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, |
| 0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, |
| 0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, |
| 0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4, |
| 0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f, |
| 0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, 0x9, |
| 0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, 0x4, 0x35, 0x9, 0x35, |
| 0x4, 0x36, 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9, 0x38, 0x4, |
| 0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9, 0x3b, 0x4, 0x3c, |
| 0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, 0x9, |
| 0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42, 0x9, 0x42, |
| 0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, 0x9, 0x45, 0x4, |
| 0x46, 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48, 0x4, 0x49, |
| 0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a, 0x4, 0x4b, 0x9, 0x4b, 0x4, 0x4c, 0x9, |
| 0x4c, 0x4, 0x4d, 0x9, 0x4d, 0x4, 0x4e, 0x9, 0x4e, 0x4, 0x4f, 0x9, 0x4f, |
| 0x4, 0x50, 0x9, 0x50, 0x4, 0x51, 0x9, 0x51, 0x4, 0x52, 0x9, 0x52, 0x4, |
| 0x53, 0x9, 0x53, 0x4, 0x54, 0x9, 0x54, 0x4, 0x55, 0x9, 0x55, 0x4, 0x56, |
| 0x9, 0x56, 0x4, 0x57, 0x9, 0x57, 0x4, 0x58, 0x9, 0x58, 0x4, 0x59, 0x9, |
| 0x59, 0x4, 0x5a, 0x9, 0x5a, 0x4, 0x5b, 0x9, 0x5b, 0x4, 0x5c, 0x9, 0x5c, |
| 0x4, 0x5d, 0x9, 0x5d, 0x4, 0x5e, 0x9, 0x5e, 0x4, 0x5f, 0x9, 0x5f, 0x4, |
| 0x60, 0x9, 0x60, 0x4, 0x61, 0x9, 0x61, 0x4, 0x62, 0x9, 0x62, 0x4, 0x63, |
| 0x9, 0x63, 0x4, 0x64, 0x9, 0x64, 0x4, 0x65, 0x9, 0x65, 0x4, 0x66, 0x9, |
| 0x66, 0x4, 0x67, 0x9, 0x67, 0x4, 0x68, 0x9, 0x68, 0x4, 0x69, 0x9, 0x69, |
| 0x4, 0x6a, 0x9, 0x6a, 0x4, 0x6b, 0x9, 0x6b, 0x4, 0x6c, 0x9, 0x6c, 0x4, |
| 0x6d, 0x9, 0x6d, 0x4, 0x6e, 0x9, 0x6e, 0x4, 0x6f, 0x9, 0x6f, 0x4, 0x70, |
| 0x9, 0x70, 0x4, 0x71, 0x9, 0x71, 0x4, 0x72, 0x9, 0x72, 0x4, 0x73, 0x9, |
| 0x73, 0x4, 0x74, 0x9, 0x74, 0x4, 0x75, 0x9, 0x75, 0x4, 0x76, 0x9, 0x76, |
| 0x4, 0x77, 0x9, 0x77, 0x4, 0x78, 0x9, 0x78, 0x4, 0x79, 0x9, 0x79, 0x4, |
| 0x7a, 0x9, 0x7a, 0x4, 0x7b, 0x9, 0x7b, 0x4, 0x7c, 0x9, 0x7c, 0x4, 0x7d, |
| 0x9, 0x7d, 0x4, 0x7e, 0x9, 0x7e, 0x4, 0x7f, 0x9, 0x7f, 0x4, 0x80, 0x9, |
| 0x80, 0x4, 0x81, 0x9, 0x81, 0x4, 0x82, 0x9, 0x82, 0x4, 0x83, 0x9, 0x83, |
| 0x4, 0x84, 0x9, 0x84, 0x4, 0x85, 0x9, 0x85, 0x4, 0x86, 0x9, 0x86, 0x4, |
| 0x87, 0x9, 0x87, 0x4, 0x88, 0x9, 0x88, 0x4, 0x89, 0x9, 0x89, 0x4, 0x8a, |
| 0x9, 0x8a, 0x4, 0x8b, 0x9, 0x8b, 0x4, 0x8c, 0x9, 0x8c, 0x4, 0x8d, 0x9, |
| 0x8d, 0x4, 0x8e, 0x9, 0x8e, 0x4, 0x8f, 0x9, 0x8f, 0x3, 0x2, 0x7, 0x2, |
| 0x120, 0xa, 0x2, 0xc, 0x2, 0xe, 0x2, 0x123, 0xb, 0x2, 0x3, 0x3, 0x3, |
| 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, |
| 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, |
| 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, |
| 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, |
| 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, |
| 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, |
| 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, |
| 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, |
| 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, |
| 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, |
| 0x3, 0x3, 0x3, 0x5, 0x3, 0x16e, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x7, 0x4, |
| 0x172, 0xa, 0x4, 0xc, 0x4, 0xe, 0x4, 0x175, 0xb, 0x4, 0x3, 0x4, 0x3, |
| 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x5, 0x4, 0x17c, 0xa, 0x4, 0x3, 0x5, |
| 0x3, 0x5, 0x7, 0x5, 0x180, 0xa, 0x5, 0xc, 0x5, 0xe, 0x5, 0x183, 0xb, |
| 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, 0x7, 0x6, 0x188, 0xa, 0x6, 0xc, 0x6, |
| 0xe, 0x6, 0x18b, 0xb, 0x6, 0x3, 0x6, 0x3, 0x6, 0x7, 0x6, 0x18f, 0xa, |
| 0x6, 0xc, 0x6, 0xe, 0x6, 0x192, 0xb, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, |
| 0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, |
| 0x3, 0xa, 0x5, 0xa, 0x19f, 0xa, 0xa, 0x3, 0xb, 0x3, 0xb, 0x7, 0xb, 0x1a3, |
| 0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0x1a6, 0xb, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, |
| 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x5, 0xc, 0x1b0, |
| 0xa, 0xc, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0x1b4, 0xa, 0xd, 0xc, 0xd, 0xe, |
| 0xd, 0x1b7, 0xb, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, |
| 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xf, 0x3, 0xf, 0x7, 0xf, |
| 0x1c4, 0xa, 0xf, 0xc, 0xf, 0xe, 0xf, 0x1c7, 0xb, 0xf, 0x3, 0xf, 0x3, |
| 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11, 0x3, 0x11, |
| 0x3, 0x12, 0x3, 0x12, 0x3, 0x13, 0x3, 0x13, 0x7, 0x13, 0x1d5, 0xa, 0x13, |
| 0xc, 0x13, 0xe, 0x13, 0x1d8, 0xb, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, |
| 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, |
| 0x15, 0x5, 0x15, 0x1e4, 0xa, 0x15, 0x3, 0x16, 0x3, 0x16, 0x7, 0x16, |
| 0x1e8, 0xa, 0x16, 0xc, 0x16, 0xe, 0x16, 0x1eb, 0xb, 0x16, 0x3, 0x16, |
| 0x3, 0x16, 0x7, 0x16, 0x1ef, 0xa, 0x16, 0xc, 0x16, 0xe, 0x16, 0x1f2, |
| 0xb, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, 0x16, 0x1f7, 0xa, 0x16, |
| 0x3, 0x16, 0x6, 0x16, 0x1fa, 0xa, 0x16, 0xd, 0x16, 0xe, 0x16, 0x1fb, |
| 0x7, 0x16, 0x1fe, 0xa, 0x16, 0xc, 0x16, 0xe, 0x16, 0x201, 0xb, 0x16, |
| 0x3, 0x16, 0x5, 0x16, 0x204, 0xa, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, |
| 0x3, 0x17, 0x3, 0x17, 0x5, 0x17, 0x20b, 0xa, 0x17, 0x3, 0x18, 0x3, 0x18, |
| 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5, 0x18, 0x212, 0xa, 0x18, 0x3, 0x19, |
| 0x3, 0x19, 0x7, 0x19, 0x216, 0xa, 0x19, 0xc, 0x19, 0xe, 0x19, 0x219, |
| 0xb, 0x19, 0x3, 0x19, 0x3, 0x19, 0x7, 0x19, 0x21d, 0xa, 0x19, 0xc, 0x19, |
| 0xe, 0x19, 0x220, 0xb, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, |
| 0x225, 0xa, 0x19, 0x3, 0x19, 0x6, 0x19, 0x228, 0xa, 0x19, 0xd, 0x19, |
| 0xe, 0x19, 0x229, 0x7, 0x19, 0x22c, 0xa, 0x19, 0xc, 0x19, 0xe, 0x19, |
| 0x22f, 0xb, 0x19, 0x3, 0x19, 0x5, 0x19, 0x232, 0xa, 0x19, 0x3, 0x1a, |
| 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x5, 0x1a, 0x239, 0xa, 0x1a, |
| 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x5, 0x1b, 0x240, |
| 0xa, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x7, 0x1c, 0x244, 0xa, 0x1c, 0xc, 0x1c, |
| 0xe, 0x1c, 0x247, 0xb, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d, |
| 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x5, 0x1d, 0x250, 0xa, 0x1d, 0x3, 0x1e, |
| 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x5, 0x1e, 0x257, 0xa, 0x1e, |
| 0x3, 0x1f, 0x3, 0x1f, 0x7, 0x1f, 0x25b, 0xa, 0x1f, 0xc, 0x1f, 0xe, 0x1f, |
| 0x25e, 0xb, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, |
| 0x3, 0x20, 0x3, 0x20, 0x5, 0x20, 0x267, 0xa, 0x20, 0x3, 0x21, 0x3, 0x21, |
| 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x5, 0x21, 0x26e, 0xa, 0x21, 0x3, 0x22, |
| 0x3, 0x22, 0x7, 0x22, 0x272, 0xa, 0x22, 0xc, 0x22, 0xe, 0x22, 0x275, |
| 0xb, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, 0x3, |
| 0x24, 0x7, 0x24, 0x27d, 0xa, 0x24, 0xc, 0x24, 0xe, 0x24, 0x280, 0xb, |
| 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x7, 0x24, 0x285, 0xa, 0x24, |
| 0xc, 0x24, 0xe, 0x24, 0x288, 0xb, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, |
| 0x5, 0x24, 0x28d, 0xa, 0x24, 0x3, 0x25, 0x3, 0x25, 0x7, 0x25, 0x291, |
| 0xa, 0x25, 0xc, 0x25, 0xe, 0x25, 0x294, 0xb, 0x25, 0x3, 0x25, 0x3, 0x25, |
| 0x5, 0x25, 0x298, 0xa, 0x25, 0x3, 0x26, 0x3, 0x26, 0x7, 0x26, 0x29c, |
| 0xa, 0x26, 0xc, 0x26, 0xe, 0x26, 0x29f, 0xb, 0x26, 0x3, 0x26, 0x3, 0x26, |
| 0x3, 0x27, 0x3, 0x27, 0x3, 0x28, 0x3, 0x28, 0x7, 0x28, 0x2a7, 0xa, 0x28, |
| 0xc, 0x28, 0xe, 0x28, 0x2aa, 0xb, 0x28, 0x3, 0x28, 0x3, 0x28, 0x3, 0x29, |
| 0x3, 0x29, 0x3, 0x29, 0x3, 0x29, 0x3, 0x2a, 0x3, 0x2a, 0x7, 0x2a, 0x2b4, |
| 0xa, 0x2a, 0xc, 0x2a, 0xe, 0x2a, 0x2b7, 0xb, 0x2a, 0x3, 0x2a, 0x3, 0x2a, |
| 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2c, 0x3, 0x2c, 0x7, 0x2c, 0x2bf, 0xa, 0x2c, |
| 0xc, 0x2c, 0xe, 0x2c, 0x2c2, 0xb, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2d, |
| 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x7, 0x2d, 0x2cc, |
| 0xa, 0x2d, 0xc, 0x2d, 0xe, 0x2d, 0x2cf, 0xb, 0x2d, 0x7, 0x2d, 0x2d1, |
| 0xa, 0x2d, 0xc, 0x2d, 0xe, 0x2d, 0x2d4, 0xb, 0x2d, 0x3, 0x2e, 0x3, 0x2e, |
| 0x7, 0x2e, 0x2d8, 0xa, 0x2e, 0xc, 0x2e, 0xe, 0x2e, 0x2db, 0xb, 0x2e, |
| 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x30, 0x3, 0x30, 0x7, |
| 0x30, 0x2e3, 0xa, 0x30, 0xc, 0x30, 0xe, 0x30, 0x2e6, 0xb, 0x30, 0x3, |
| 0x30, 0x3, 0x30, 0x3, 0x31, 0x3, 0x31, 0x3, 0x32, 0x3, 0x32, 0x7, 0x32, |
| 0x2ee, 0xa, 0x32, 0xc, 0x32, 0xe, 0x32, 0x2f1, 0xb, 0x32, 0x3, 0x32, |
| 0x3, 0x32, 0x3, 0x33, 0x3, 0x33, 0x3, 0x34, 0x3, 0x34, 0x7, 0x34, 0x2f9, |
| 0xa, 0x34, 0xc, 0x34, 0xe, 0x34, 0x2fc, 0xb, 0x34, 0x3, 0x34, 0x3, 0x34, |
| 0x3, 0x35, 0x3, 0x35, 0x3, 0x36, 0x3, 0x36, 0x7, 0x36, 0x304, 0xa, 0x36, |
| 0xc, 0x36, 0xe, 0x36, 0x307, 0xb, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x37, |
| 0x3, 0x37, 0x3, 0x38, 0x3, 0x38, 0x7, 0x38, 0x30f, 0xa, 0x38, 0xc, 0x38, |
| 0xe, 0x38, 0x312, 0xb, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x39, 0x3, 0x39, |
| 0x3, 0x3a, 0x3, 0x3a, 0x7, 0x3a, 0x31a, 0xa, 0x3a, 0xc, 0x3a, 0xe, 0x3a, |
| 0x31d, 0xb, 0x3a, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3c, |
| 0x3, 0x3c, 0x7, 0x3c, 0x325, 0xa, 0x3c, 0xc, 0x3c, 0xe, 0x3c, 0x328, |
| 0xb, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3e, 0x3, |
| 0x3e, 0x7, 0x3e, 0x330, 0xa, 0x3e, 0xc, 0x3e, 0xe, 0x3e, 0x333, 0xb, |
| 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x40, 0x3, 0x40, |
| 0x3, 0x40, 0x3, 0x41, 0x3, 0x41, 0x6, 0x41, 0x33e, 0xa, 0x41, 0xd, 0x41, |
| 0xe, 0x41, 0x33f, 0x3, 0x42, 0x3, 0x42, 0x7, 0x42, 0x344, 0xa, 0x42, |
| 0xc, 0x42, 0xe, 0x42, 0x347, 0xb, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x43, |
| 0x3, 0x43, 0x3, 0x44, 0x3, 0x44, 0x7, 0x44, 0x34f, 0xa, 0x44, 0xc, 0x44, |
| 0xe, 0x44, 0x352, 0xb, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x45, 0x3, 0x45, |
| 0x3, 0x46, 0x3, 0x46, 0x7, 0x46, 0x35a, 0xa, 0x46, 0xc, 0x46, 0xe, 0x46, |
| 0x35d, 0xb, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x47, 0x3, 0x47, 0x3, 0x48, |
| 0x3, 0x48, 0x7, 0x48, 0x365, 0xa, 0x48, 0xc, 0x48, 0xe, 0x48, 0x368, |
| 0xb, 0x48, 0x3, 0x48, 0x3, 0x48, 0x3, 0x49, 0x3, 0x49, 0x3, 0x4a, 0x3, |
| 0x4a, 0x7, 0x4a, 0x370, 0xa, 0x4a, 0xc, 0x4a, 0xe, 0x4a, 0x373, 0xb, |
| 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4c, 0x3, 0x4c, |
| 0x7, 0x4c, 0x37b, 0xa, 0x4c, 0xc, 0x4c, 0xe, 0x4c, 0x37e, 0xb, 0x4c, |
| 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4e, 0x3, 0x4e, 0x7, |
| 0x4e, 0x386, 0xa, 0x4e, 0xc, 0x4e, 0xe, 0x4e, 0x389, 0xb, 0x4e, 0x3, |
| 0x4e, 0x3, 0x4e, 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x50, 0x3, 0x50, 0x7, 0x50, |
| 0x391, 0xa, 0x50, 0xc, 0x50, 0xe, 0x50, 0x394, 0xb, 0x50, 0x3, 0x50, |
| 0x3, 0x50, 0x3, 0x51, 0x3, 0x51, 0x3, 0x52, 0x3, 0x52, 0x7, 0x52, 0x39c, |
| 0xa, 0x52, 0xc, 0x52, 0xe, 0x52, 0x39f, 0xb, 0x52, 0x3, 0x52, 0x3, 0x52, |
| 0x3, 0x53, 0x3, 0x53, 0x3, 0x54, 0x3, 0x54, 0x7, 0x54, 0x3a7, 0xa, 0x54, |
| 0xc, 0x54, 0xe, 0x54, 0x3aa, 0xb, 0x54, 0x3, 0x54, 0x3, 0x54, 0x3, 0x55, |
| 0x3, 0x55, 0x3, 0x56, 0x3, 0x56, 0x7, 0x56, 0x3b2, 0xa, 0x56, 0xc, 0x56, |
| 0xe, 0x56, 0x3b5, 0xb, 0x56, 0x3, 0x56, 0x3, 0x56, 0x3, 0x57, 0x3, 0x57, |
| 0x3, 0x58, 0x3, 0x58, 0x7, 0x58, 0x3bd, 0xa, 0x58, 0xc, 0x58, 0xe, 0x58, |
| 0x3c0, 0xb, 0x58, 0x3, 0x58, 0x3, 0x58, 0x3, 0x59, 0x3, 0x59, 0x3, 0x5a, |
| 0x3, 0x5a, 0x7, 0x5a, 0x3c8, 0xa, 0x5a, 0xc, 0x5a, 0xe, 0x5a, 0x3cb, |
| 0xb, 0x5a, 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, |
| 0x5b, 0x3, 0x5c, 0x3, 0x5c, 0x7, 0x5c, 0x3d5, 0xa, 0x5c, 0xc, 0x5c, |
| 0xe, 0x5c, 0x3d8, 0xb, 0x5c, 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5d, 0x3, 0x5d, |
| 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5d, 0x5, 0x5d, 0x3e1, 0xa, 0x5d, 0x3, 0x5e, |
| 0x3, 0x5e, 0x7, 0x5e, 0x3e5, 0xa, 0x5e, 0xc, 0x5e, 0xe, 0x5e, 0x3e8, |
| 0xb, 0x5e, 0x3, 0x5e, 0x3, 0x5e, 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x5f, 0x3, |
| 0x5f, 0x3, 0x60, 0x3, 0x60, 0x7, 0x60, 0x3f2, 0xa, 0x60, 0xc, 0x60, |
| 0xe, 0x60, 0x3f5, 0xb, 0x60, 0x3, 0x60, 0x3, 0x60, 0x3, 0x61, 0x3, 0x61, |
| 0x3, 0x62, 0x3, 0x62, 0x7, 0x62, 0x3fd, 0xa, 0x62, 0xc, 0x62, 0xe, 0x62, |
| 0x400, 0xb, 0x62, 0x3, 0x62, 0x3, 0x62, 0x3, 0x63, 0x3, 0x63, 0x3, 0x64, |
| 0x3, 0x64, 0x7, 0x64, 0x408, 0xa, 0x64, 0xc, 0x64, 0xe, 0x64, 0x40b, |
| 0xb, 0x64, 0x3, 0x64, 0x3, 0x64, 0x3, 0x65, 0x3, 0x65, 0x3, 0x66, 0x3, |
| 0x66, 0x7, 0x66, 0x413, 0xa, 0x66, 0xc, 0x66, 0xe, 0x66, 0x416, 0xb, |
| 0x66, 0x3, 0x66, 0x3, 0x66, 0x3, 0x67, 0x3, 0x67, 0x3, 0x68, 0x3, 0x68, |
| 0x7, 0x68, 0x41e, 0xa, 0x68, 0xc, 0x68, 0xe, 0x68, 0x421, 0xb, 0x68, |
| 0x3, 0x68, 0x3, 0x68, 0x3, 0x69, 0x3, 0x69, 0x3, 0x6a, 0x3, 0x6a, 0x3, |
| 0x6b, 0x3, 0x6b, 0x3, 0x6c, 0x3, 0x6c, 0x3, 0x6d, 0x3, 0x6d, 0x3, 0x6e, |
| 0x3, 0x6e, 0x3, 0x6f, 0x3, 0x6f, 0x3, 0x70, 0x3, 0x70, 0x3, 0x71, 0x3, |
| 0x71, 0x3, 0x72, 0x3, 0x72, 0x3, 0x73, 0x3, 0x73, 0x3, 0x74, 0x3, 0x74, |
| 0x3, 0x75, 0x3, 0x75, 0x3, 0x76, 0x3, 0x76, 0x3, 0x77, 0x3, 0x77, 0x3, |
| 0x78, 0x3, 0x78, 0x3, 0x79, 0x3, 0x79, 0x3, 0x79, 0x3, 0x79, 0x7, 0x79, |
| 0x449, 0xa, 0x79, 0xc, 0x79, 0xe, 0x79, 0x44c, 0xb, 0x79, 0x3, 0x79, |
| 0x3, 0x79, 0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x7, 0x7a, 0x454, |
| 0xa, 0x7a, 0xc, 0x7a, 0xe, 0x7a, 0x457, 0xb, 0x7a, 0x3, 0x7a, 0x3, 0x7a, |
| 0x3, 0x7b, 0x3, 0x7b, 0x3, 0x7b, 0x3, 0x7b, 0x3, 0x7b, 0x7, 0x7b, 0x460, |
| 0xa, 0x7b, 0xc, 0x7b, 0xe, 0x7b, 0x463, 0xb, 0x7b, 0x3, 0x7b, 0x3, 0x7b, |
| 0x3, 0x7c, 0x3, 0x7c, 0x3, 0x7c, 0x3, 0x7c, 0x3, 0x7c, 0x3, 0x7c, 0x3, |
| 0x7c, 0x3, 0x7c, 0x3, 0x7c, 0x3, 0x7c, 0x3, 0x7c, 0x7, 0x7c, 0x472, |
| 0xa, 0x7c, 0xc, 0x7c, 0xe, 0x7c, 0x475, 0xb, 0x7c, 0x3, 0x7c, 0x5, 0x7c, |
| 0x478, 0xa, 0x7c, 0x3, 0x7d, 0x3, 0x7d, 0x3, 0x7d, 0x3, 0x7d, 0x3, 0x7d, |
| 0x3, 0x7d, 0x3, 0x7d, 0x3, 0x7d, 0x3, 0x7d, 0x3, 0x7d, 0x3, 0x7d, 0x3, |
| 0x7d, 0x3, 0x7d, 0x7, 0x7d, 0x487, 0xa, 0x7d, 0xc, 0x7d, 0xe, 0x7d, |
| 0x48a, 0xb, 0x7d, 0x3, 0x7d, 0x3, 0x7d, 0x5, 0x7d, 0x48e, 0xa, 0x7d, |
| 0x3, 0x7e, 0x3, 0x7e, 0x5, 0x7e, 0x492, 0xa, 0x7e, 0x7, 0x7e, 0x494, |
| 0xa, 0x7e, 0xc, 0x7e, 0xe, 0x7e, 0x497, 0xb, 0x7e, 0x3, 0x7f, 0x3, 0x7f, |
| 0x3, 0x7f, 0x3, 0x7f, 0x5, 0x7f, 0x49d, 0xa, 0x7f, 0x3, 0x7f, 0x3, 0x7f, |
| 0x3, 0x7f, 0x3, 0x7f, 0x3, 0x7f, 0x3, 0x7f, 0x5, 0x7f, 0x4a5, 0xa, 0x7f, |
| 0x3, 0x7f, 0x7, 0x7f, 0x4a8, 0xa, 0x7f, 0xc, 0x7f, 0xe, 0x7f, 0x4ab, |
| 0xb, 0x7f, 0x3, 0x7f, 0x3, 0x7f, 0x3, 0x7f, 0x3, 0x7f, 0x5, 0x7f, 0x4b1, |
| 0xa, 0x7f, 0x3, 0x7f, 0x3, 0x7f, 0x5, 0x7f, 0x4b5, 0xa, 0x7f, 0x3, 0x80, |
| 0x3, 0x80, 0x3, 0x80, 0x3, 0x80, 0x5, 0x80, 0x4bb, 0xa, 0x80, 0x3, 0x80, |
| 0x3, 0x80, 0x3, 0x80, 0x3, 0x80, 0x3, 0x80, 0x3, 0x80, 0x3, 0x80, 0x3, |
| 0x80, 0x5, 0x80, 0x4c5, 0xa, 0x80, 0x3, 0x80, 0x5, 0x80, 0x4c8, 0xa, |
| 0x80, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, |
| 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, |
| 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, |
| 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, |
| 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, |
| 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, |
| 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, |
| 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x3, 0x81, 0x5, 0x81, 0x4fc, |
| 0xa, 0x81, 0x3, 0x82, 0x3, 0x82, 0x3, 0x82, 0x7, 0x82, 0x501, 0xa, 0x82, |
| 0xc, 0x82, 0xe, 0x82, 0x504, 0xb, 0x82, 0x3, 0x82, 0x3, 0x82, 0x7, 0x82, |
| 0x508, 0xa, 0x82, 0xc, 0x82, 0xe, 0x82, 0x50b, 0xb, 0x82, 0x7, 0x82, |
| 0x50d, 0xa, 0x82, 0xc, 0x82, 0xe, 0x82, 0x510, 0xb, 0x82, 0x3, 0x82, |
| 0x3, 0x82, 0x7, 0x82, 0x514, 0xa, 0x82, 0xc, 0x82, 0xe, 0x82, 0x517, |
| 0xb, 0x82, 0x3, 0x82, 0x3, 0x82, 0x7, 0x82, 0x51b, 0xa, 0x82, 0xc, 0x82, |
| 0xe, 0x82, 0x51e, 0xb, 0x82, 0x3, 0x82, 0x3, 0x82, 0x7, 0x82, 0x522, |
| 0xa, 0x82, 0xc, 0x82, 0xe, 0x82, 0x525, 0xb, 0x82, 0x7, 0x82, 0x527, |
| 0xa, 0x82, 0xc, 0x82, 0xe, 0x82, 0x52a, 0xb, 0x82, 0x7, 0x82, 0x52c, |
| 0xa, 0x82, 0xc, 0x82, 0xe, 0x82, 0x52f, 0xb, 0x82, 0x7, 0x82, 0x531, |
| 0xa, 0x82, 0xc, 0x82, 0xe, 0x82, 0x534, 0xb, 0x82, 0x3, 0x82, 0x3, 0x82, |
| 0x3, 0x83, 0x3, 0x83, 0x5, 0x83, 0x53a, 0xa, 0x83, 0x3, 0x84, 0x3, 0x84, |
| 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, |
| 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, |
| 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, |
| 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x84, |
| 0x7, 0x84, 0x558, 0xa, 0x84, 0xc, 0x84, 0xe, 0x84, 0x55b, 0xb, 0x84, |
| 0x3, 0x84, 0x3, 0x84, 0x7, 0x84, 0x55f, 0xa, 0x84, 0xc, 0x84, 0xe, 0x84, |
| 0x562, 0xb, 0x84, 0x3, 0x84, 0x3, 0x84, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, |
| 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, |
| 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, |
| 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, |
| 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x3, 0x85, 0x7, 0x85, |
| 0x582, 0xa, 0x85, 0xc, 0x85, 0xe, 0x85, 0x585, 0xb, 0x85, 0x3, 0x85, |
| 0x3, 0x85, 0x7, 0x85, 0x589, 0xa, 0x85, 0xc, 0x85, 0xe, 0x85, 0x58c, |
| 0xb, 0x85, 0x3, 0x85, 0x5, 0x85, 0x58f, 0xa, 0x85, 0x3, 0x86, 0x3, 0x86, |
| 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, |
| 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, |
| 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, |
| 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x3, 0x86, 0x7, 0x86, 0x5ab, |
| 0xa, 0x86, 0xc, 0x86, 0xe, 0x86, 0x5ae, 0xb, 0x86, 0x3, 0x87, 0x3, 0x87, |
| 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, |
| 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, |
| 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, |
| 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x3, 0x87, 0x7, 0x87, 0x5ca, |
| 0xa, 0x87, 0xc, 0x87, 0xe, 0x87, 0x5cd, 0xb, 0x87, 0x3, 0x88, 0x3, 0x88, |
| 0x3, 0x88, 0x3, 0x88, 0x3, 0x88, 0x3, 0x88, 0x3, 0x88, 0x3, 0x88, 0x3, |
| 0x88, 0x3, 0x88, 0x3, 0x88, 0x3, 0x88, 0x3, 0x88, 0x3, 0x88, 0x3, 0x88, |
| 0x3, 0x88, 0x3, 0x88, 0x3, 0x88, 0x5, 0x88, 0x5e1, 0xa, 0x88, 0x3, 0x89, |
| 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, 0x3, |
| 0x89, 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, |
| 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, 0x5, 0x89, 0x5f4, 0xa, 0x89, 0x3, 0x8a, |
| 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, |
| 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, |
| 0x3, 0x8a, 0x3, 0x8a, 0x7, 0x8a, 0x606, 0xa, 0x8a, 0xc, 0x8a, 0xe, 0x8a, |
| 0x609, 0xb, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, |
| 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, |
| 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x7, 0x8a, 0x61b, |
| 0xa, 0x8a, 0xc, 0x8a, 0xe, 0x8a, 0x61e, 0xb, 0x8a, 0x3, 0x8a, 0x3, 0x8a, |
| 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, |
| 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, |
| 0x3, 0x8a, 0x7, 0x8a, 0x630, 0xa, 0x8a, 0xc, 0x8a, 0xe, 0x8a, 0x633, |
| 0xb, 0x8a, 0x3, 0x8a, 0x5, 0x8a, 0x636, 0xa, 0x8a, 0x3, 0x8b, 0x3, 0x8b, |
| 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, |
| 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, |
| 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, |
| 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x5, 0x8b, 0x651, 0xa, 0x8b, |
| 0x3, 0x8c, 0x3, 0x8c, 0x3, 0x8d, 0x3, 0x8d, 0x3, 0x8e, 0x3, 0x8e, 0x3, |
| 0x8e, 0x3, 0x8e, 0x3, 0x8e, 0x3, 0x8e, 0x3, 0x8e, 0x3, 0x8e, 0x3, 0x8e, |
| 0x3, 0x8e, 0x3, 0x8e, 0x3, 0x8e, 0x5, 0x8e, 0x663, 0xa, 0x8e, 0x3, 0x8f, |
| 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x3, |
| 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, |
| 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x5, |
| 0x8f, 0x679, 0xa, 0x8f, 0x3, 0x8f, 0x6, 0x559, 0x583, 0x5ac, 0x5cb, |
| 0x2, 0x90, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, |
| 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, |
| 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, |
| 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, |
| 0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, |
| 0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, |
| 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa4, 0xa6, |
| 0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe, |
| 0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, |
| 0xd8, 0xda, 0xdc, 0xde, 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, |
| 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x100, 0x102, 0x104, |
| 0x106, 0x108, 0x10a, 0x10c, 0x10e, 0x110, 0x112, 0x114, 0x116, 0x118, |
| 0x11a, 0x11c, 0x2, 0x7, 0x3, 0x2, 0x45, 0x46, 0x3, 0x2, 0x3, 0x4, 0x4, |
| 0x2, 0x3, 0x3, 0x50, 0x50, 0x4, 0x2, 0x48, 0x48, 0x59, 0x59, 0x3, 0x3, |
| 0x50, 0x50, 0x2, 0x7d6, 0x2, 0x121, 0x3, 0x2, 0x2, 0x2, 0x4, 0x16d, |
| 0x3, 0x2, 0x2, 0x2, 0x6, 0x17b, 0x3, 0x2, 0x2, 0x2, 0x8, 0x17d, 0x3, |
| 0x2, 0x2, 0x2, 0xa, 0x189, 0x3, 0x2, 0x2, 0x2, 0xc, 0x193, 0x3, 0x2, |
| 0x2, 0x2, 0xe, 0x195, 0x3, 0x2, 0x2, 0x2, 0x10, 0x197, 0x3, 0x2, 0x2, |
| 0x2, 0x12, 0x19e, 0x3, 0x2, 0x2, 0x2, 0x14, 0x1a0, 0x3, 0x2, 0x2, 0x2, |
| 0x16, 0x1a9, 0x3, 0x2, 0x2, 0x2, 0x18, 0x1b1, 0x3, 0x2, 0x2, 0x2, 0x1a, |
| 0x1ba, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x1c1, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x1ca, |
| 0x3, 0x2, 0x2, 0x2, 0x20, 0x1ce, 0x3, 0x2, 0x2, 0x2, 0x22, 0x1d0, 0x3, |
| 0x2, 0x2, 0x2, 0x24, 0x1d2, 0x3, 0x2, 0x2, 0x2, 0x26, 0x1db, 0x3, 0x2, |
| 0x2, 0x2, 0x28, 0x1de, 0x3, 0x2, 0x2, 0x2, 0x2a, 0x1e5, 0x3, 0x2, 0x2, |
| 0x2, 0x2c, 0x205, 0x3, 0x2, 0x2, 0x2, 0x2e, 0x20c, 0x3, 0x2, 0x2, 0x2, |
| 0x30, 0x213, 0x3, 0x2, 0x2, 0x2, 0x32, 0x233, 0x3, 0x2, 0x2, 0x2, 0x34, |
| 0x23a, 0x3, 0x2, 0x2, 0x2, 0x36, 0x241, 0x3, 0x2, 0x2, 0x2, 0x38, 0x24a, |
| 0x3, 0x2, 0x2, 0x2, 0x3a, 0x251, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x258, 0x3, |
| 0x2, 0x2, 0x2, 0x3e, 0x261, 0x3, 0x2, 0x2, 0x2, 0x40, 0x268, 0x3, 0x2, |
| 0x2, 0x2, 0x42, 0x26f, 0x3, 0x2, 0x2, 0x2, 0x44, 0x278, 0x3, 0x2, 0x2, |
| 0x2, 0x46, 0x28c, 0x3, 0x2, 0x2, 0x2, 0x48, 0x297, 0x3, 0x2, 0x2, 0x2, |
| 0x4a, 0x299, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x2a2, 0x3, 0x2, 0x2, 0x2, 0x4e, |
| 0x2a4, 0x3, 0x2, 0x2, 0x2, 0x50, 0x2ad, 0x3, 0x2, 0x2, 0x2, 0x52, 0x2b1, |
| 0x3, 0x2, 0x2, 0x2, 0x54, 0x2ba, 0x3, 0x2, 0x2, 0x2, 0x56, 0x2bc, 0x3, |
| 0x2, 0x2, 0x2, 0x58, 0x2c5, 0x3, 0x2, 0x2, 0x2, 0x5a, 0x2d5, 0x3, 0x2, |
| 0x2, 0x2, 0x5c, 0x2de, 0x3, 0x2, 0x2, 0x2, 0x5e, 0x2e0, 0x3, 0x2, 0x2, |
| 0x2, 0x60, 0x2e9, 0x3, 0x2, 0x2, 0x2, 0x62, 0x2eb, 0x3, 0x2, 0x2, 0x2, |
| 0x64, 0x2f4, 0x3, 0x2, 0x2, 0x2, 0x66, 0x2f6, 0x3, 0x2, 0x2, 0x2, 0x68, |
| 0x2ff, 0x3, 0x2, 0x2, 0x2, 0x6a, 0x301, 0x3, 0x2, 0x2, 0x2, 0x6c, 0x30a, |
| 0x3, 0x2, 0x2, 0x2, 0x6e, 0x30c, 0x3, 0x2, 0x2, 0x2, 0x70, 0x315, 0x3, |
| 0x2, 0x2, 0x2, 0x72, 0x317, 0x3, 0x2, 0x2, 0x2, 0x74, 0x320, 0x3, 0x2, |
| 0x2, 0x2, 0x76, 0x322, 0x3, 0x2, 0x2, 0x2, 0x78, 0x32b, 0x3, 0x2, 0x2, |
| 0x2, 0x7a, 0x32d, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x336, 0x3, 0x2, 0x2, 0x2, |
| 0x7e, 0x338, 0x3, 0x2, 0x2, 0x2, 0x80, 0x33b, 0x3, 0x2, 0x2, 0x2, 0x82, |
| 0x341, 0x3, 0x2, 0x2, 0x2, 0x84, 0x34a, 0x3, 0x2, 0x2, 0x2, 0x86, 0x34c, |
| 0x3, 0x2, 0x2, 0x2, 0x88, 0x355, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x357, 0x3, |
| 0x2, 0x2, 0x2, 0x8c, 0x360, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x362, 0x3, 0x2, |
| 0x2, 0x2, 0x90, 0x36b, 0x3, 0x2, 0x2, 0x2, 0x92, 0x36d, 0x3, 0x2, 0x2, |
| 0x2, 0x94, 0x376, 0x3, 0x2, 0x2, 0x2, 0x96, 0x378, 0x3, 0x2, 0x2, 0x2, |
| 0x98, 0x381, 0x3, 0x2, 0x2, 0x2, 0x9a, 0x383, 0x3, 0x2, 0x2, 0x2, 0x9c, |
| 0x38c, 0x3, 0x2, 0x2, 0x2, 0x9e, 0x38e, 0x3, 0x2, 0x2, 0x2, 0xa0, 0x397, |
| 0x3, 0x2, 0x2, 0x2, 0xa2, 0x399, 0x3, 0x2, 0x2, 0x2, 0xa4, 0x3a2, 0x3, |
| 0x2, 0x2, 0x2, 0xa6, 0x3a4, 0x3, 0x2, 0x2, 0x2, 0xa8, 0x3ad, 0x3, 0x2, |
| 0x2, 0x2, 0xaa, 0x3af, 0x3, 0x2, 0x2, 0x2, 0xac, 0x3b8, 0x3, 0x2, 0x2, |
| 0x2, 0xae, 0x3ba, 0x3, 0x2, 0x2, 0x2, 0xb0, 0x3c3, 0x3, 0x2, 0x2, 0x2, |
| 0xb2, 0x3c5, 0x3, 0x2, 0x2, 0x2, 0xb4, 0x3ce, 0x3, 0x2, 0x2, 0x2, 0xb6, |
| 0x3d2, 0x3, 0x2, 0x2, 0x2, 0xb8, 0x3db, 0x3, 0x2, 0x2, 0x2, 0xba, 0x3e2, |
| 0x3, 0x2, 0x2, 0x2, 0xbc, 0x3eb, 0x3, 0x2, 0x2, 0x2, 0xbe, 0x3ef, 0x3, |
| 0x2, 0x2, 0x2, 0xc0, 0x3f8, 0x3, 0x2, 0x2, 0x2, 0xc2, 0x3fa, 0x3, 0x2, |
| 0x2, 0x2, 0xc4, 0x403, 0x3, 0x2, 0x2, 0x2, 0xc6, 0x405, 0x3, 0x2, 0x2, |
| 0x2, 0xc8, 0x40e, 0x3, 0x2, 0x2, 0x2, 0xca, 0x410, 0x3, 0x2, 0x2, 0x2, |
| 0xcc, 0x419, 0x3, 0x2, 0x2, 0x2, 0xce, 0x41b, 0x3, 0x2, 0x2, 0x2, 0xd0, |
| 0x424, 0x3, 0x2, 0x2, 0x2, 0xd2, 0x426, 0x3, 0x2, 0x2, 0x2, 0xd4, 0x428, |
| 0x3, 0x2, 0x2, 0x2, 0xd6, 0x42a, 0x3, 0x2, 0x2, 0x2, 0xd8, 0x42c, 0x3, |
| 0x2, 0x2, 0x2, 0xda, 0x42e, 0x3, 0x2, 0x2, 0x2, 0xdc, 0x430, 0x3, 0x2, |
| 0x2, 0x2, 0xde, 0x432, 0x3, 0x2, 0x2, 0x2, 0xe0, 0x434, 0x3, 0x2, 0x2, |
| 0x2, 0xe2, 0x436, 0x3, 0x2, 0x2, 0x2, 0xe4, 0x438, 0x3, 0x2, 0x2, 0x2, |
| 0xe6, 0x43a, 0x3, 0x2, 0x2, 0x2, 0xe8, 0x43c, 0x3, 0x2, 0x2, 0x2, 0xea, |
| 0x43e, 0x3, 0x2, 0x2, 0x2, 0xec, 0x440, 0x3, 0x2, 0x2, 0x2, 0xee, 0x442, |
| 0x3, 0x2, 0x2, 0x2, 0xf0, 0x444, 0x3, 0x2, 0x2, 0x2, 0xf2, 0x44f, 0x3, |
| 0x2, 0x2, 0x2, 0xf4, 0x45a, 0x3, 0x2, 0x2, 0x2, 0xf6, 0x477, 0x3, 0x2, |
| 0x2, 0x2, 0xf8, 0x48d, 0x3, 0x2, 0x2, 0x2, 0xfa, 0x495, 0x3, 0x2, 0x2, |
| 0x2, 0xfc, 0x4b4, 0x3, 0x2, 0x2, 0x2, 0xfe, 0x4c7, 0x3, 0x2, 0x2, 0x2, |
| 0x100, 0x4fb, 0x3, 0x2, 0x2, 0x2, 0x102, 0x4fd, 0x3, 0x2, 0x2, 0x2, |
| 0x104, 0x539, 0x3, 0x2, 0x2, 0x2, 0x106, 0x559, 0x3, 0x2, 0x2, 0x2, |
| 0x108, 0x583, 0x3, 0x2, 0x2, 0x2, 0x10a, 0x5ac, 0x3, 0x2, 0x2, 0x2, |
| 0x10c, 0x5cb, 0x3, 0x2, 0x2, 0x2, 0x10e, 0x5e0, 0x3, 0x2, 0x2, 0x2, |
| 0x110, 0x5f3, 0x3, 0x2, 0x2, 0x2, 0x112, 0x635, 0x3, 0x2, 0x2, 0x2, |
| 0x114, 0x650, 0x3, 0x2, 0x2, 0x2, 0x116, 0x652, 0x3, 0x2, 0x2, 0x2, |
| 0x118, 0x654, 0x3, 0x2, 0x2, 0x2, 0x11a, 0x662, 0x3, 0x2, 0x2, 0x2, |
| 0x11c, 0x678, 0x3, 0x2, 0x2, 0x2, 0x11e, 0x120, 0x5, 0x4, 0x3, 0x2, |
| 0x11f, 0x11e, 0x3, 0x2, 0x2, 0x2, 0x120, 0x123, 0x3, 0x2, 0x2, 0x2, |
| 0x121, 0x11f, 0x3, 0x2, 0x2, 0x2, 0x121, 0x122, 0x3, 0x2, 0x2, 0x2, |
| 0x122, 0x3, 0x3, 0x2, 0x2, 0x2, 0x123, 0x121, 0x3, 0x2, 0x2, 0x2, 0x124, |
| 0x16e, 0x5, 0x8, 0x5, 0x2, 0x125, 0x16e, 0x5, 0x116, 0x8c, 0x2, 0x126, |
| 0x16e, 0x5, 0xe, 0x8, 0x2, 0x127, 0x16e, 0x5, 0x12, 0xa, 0x2, 0x128, |
| 0x16e, 0x5, 0xc, 0x7, 0x2, 0x129, 0x16e, 0x5, 0x5a, 0x2e, 0x2, 0x12a, |
| 0x16e, 0x5, 0x5e, 0x30, 0x2, 0x12b, 0x16e, 0x5, 0x1c, 0xf, 0x2, 0x12c, |
| 0x16e, 0x5, 0x28, 0x15, 0x2, 0x12d, 0x16e, 0x5, 0x2a, 0x16, 0x2, 0x12e, |
| 0x16e, 0x5, 0x30, 0x19, 0x2, 0x12f, 0x16e, 0x5, 0x42, 0x22, 0x2, 0x130, |
| 0x16e, 0x5, 0x36, 0x1c, 0x2, 0x131, 0x16e, 0x5, 0x3c, 0x1f, 0x2, 0x132, |
| 0x16e, 0x5, 0x46, 0x24, 0x2, 0x133, 0x16e, 0x5, 0x14, 0xb, 0x2, 0x134, |
| 0x16e, 0x5, 0x16, 0xc, 0x2, 0x135, 0x16e, 0x5, 0x4a, 0x26, 0x2, 0x136, |
| 0x16e, 0x5, 0x4e, 0x28, 0x2, 0x137, 0x16e, 0x5, 0x50, 0x29, 0x2, 0x138, |
| 0x16e, 0x5, 0x52, 0x2a, 0x2, 0x139, 0x16e, 0x5, 0x24, 0x13, 0x2, 0x13a, |
| 0x16e, 0x5, 0xba, 0x5e, 0x2, 0x13b, 0x16e, 0x5, 0xbe, 0x60, 0x2, 0x13c, |
| 0x16e, 0x5, 0x18, 0xd, 0x2, 0x13d, 0x16e, 0x5, 0xb6, 0x5c, 0x2, 0x13e, |
| 0x16e, 0x5, 0xb2, 0x5a, 0x2, 0x13f, 0x16e, 0x5, 0xc2, 0x62, 0x2, 0x140, |
| 0x16e, 0x5, 0xc6, 0x64, 0x2, 0x141, 0x16e, 0x5, 0xca, 0x66, 0x2, 0x142, |
| 0x16e, 0x5, 0xce, 0x68, 0x2, 0x143, 0x16e, 0x5, 0x62, 0x32, 0x2, 0x144, |
| 0x16e, 0x5, 0x66, 0x34, 0x2, 0x145, 0x16e, 0x5, 0x6a, 0x36, 0x2, 0x146, |
| 0x16e, 0x5, 0x6e, 0x38, 0x2, 0x147, 0x16e, 0x5, 0x72, 0x3a, 0x2, 0x148, |
| 0x16e, 0x5, 0x76, 0x3c, 0x2, 0x149, 0x16e, 0x5, 0x7a, 0x3e, 0x2, 0x14a, |
| 0x16e, 0x5, 0x9a, 0x4e, 0x2, 0x14b, 0x16e, 0x5, 0x9e, 0x50, 0x2, 0x14c, |
| 0x16e, 0x5, 0xa2, 0x52, 0x2, 0x14d, 0x16e, 0x5, 0xa6, 0x54, 0x2, 0x14e, |
| 0x16e, 0x5, 0xaa, 0x56, 0x2, 0x14f, 0x16e, 0x5, 0xae, 0x58, 0x2, 0x150, |
| 0x16e, 0x5, 0xd2, 0x6a, 0x2, 0x151, 0x16e, 0x5, 0x7e, 0x40, 0x2, 0x152, |
| 0x16e, 0x5, 0x82, 0x42, 0x2, 0x153, 0x16e, 0x5, 0x86, 0x44, 0x2, 0x154, |
| 0x16e, 0x5, 0x8a, 0x46, 0x2, 0x155, 0x16e, 0x5, 0x8e, 0x48, 0x2, 0x156, |
| 0x16e, 0x5, 0x92, 0x4a, 0x2, 0x157, 0x16e, 0x5, 0x96, 0x4c, 0x2, 0x158, |
| 0x16e, 0x5, 0x56, 0x2c, 0x2, 0x159, 0x16e, 0x5, 0x20, 0x11, 0x2, 0x15a, |
| 0x16e, 0x5, 0x22, 0x12, 0x2, 0x15b, 0x16e, 0x5, 0x6, 0x4, 0x2, 0x15c, |
| 0x16e, 0x5, 0xd4, 0x6b, 0x2, 0x15d, 0x16e, 0x5, 0xd6, 0x6c, 0x2, 0x15e, |
| 0x16e, 0x5, 0xd8, 0x6d, 0x2, 0x15f, 0x16e, 0x5, 0xda, 0x6e, 0x2, 0x160, |
| 0x16e, 0x5, 0xdc, 0x6f, 0x2, 0x161, 0x16e, 0x5, 0xde, 0x70, 0x2, 0x162, |
| 0x16e, 0x5, 0xe0, 0x71, 0x2, 0x163, 0x16e, 0x5, 0xe2, 0x72, 0x2, 0x164, |
| 0x16e, 0x5, 0xe4, 0x73, 0x2, 0x165, 0x16e, 0x5, 0xe6, 0x74, 0x2, 0x166, |
| 0x16e, 0x5, 0xe8, 0x75, 0x2, 0x167, 0x16e, 0x5, 0xea, 0x76, 0x2, 0x168, |
| 0x16e, 0x5, 0xec, 0x77, 0x2, 0x169, 0x16e, 0x5, 0xee, 0x78, 0x2, 0x16a, |
| 0x16e, 0x5, 0x114, 0x8b, 0x2, 0x16b, 0x16e, 0x5, 0x118, 0x8d, 0x2, 0x16c, |
| 0x16e, 0x5, 0x10, 0x9, 0x2, 0x16d, 0x124, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x125, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x126, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x127, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x128, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x129, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x12a, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x12b, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x12c, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x12d, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x12f, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x130, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x131, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x132, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x133, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x134, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x135, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x136, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x137, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x138, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x139, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x13a, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x13b, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x13c, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x13d, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x13e, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x13f, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x140, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x141, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x142, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x143, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x144, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x145, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x146, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x147, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x148, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x149, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x14a, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x14b, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x14c, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x14d, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x14e, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x14f, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x150, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x151, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x152, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x153, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x154, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x155, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x156, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x157, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x158, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x159, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x15a, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x15b, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x15c, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x15d, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x15e, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x15f, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x160, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x161, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x162, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x163, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x164, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x165, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x166, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x167, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x168, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x169, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x16a, 0x3, 0x2, 0x2, 0x2, 0x16d, |
| 0x16b, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x16c, 0x3, 0x2, 0x2, 0x2, 0x16e, |
| 0x5, 0x3, 0x2, 0x2, 0x2, 0x16f, 0x173, 0x9, 0x2, 0x2, 0x2, 0x170, 0x172, |
| 0x7, 0x49, 0x2, 0x2, 0x171, 0x170, 0x3, 0x2, 0x2, 0x2, 0x172, 0x175, |
| 0x3, 0x2, 0x2, 0x2, 0x173, 0x171, 0x3, 0x2, 0x2, 0x2, 0x173, 0x174, |
| 0x3, 0x2, 0x2, 0x2, 0x174, 0x176, 0x3, 0x2, 0x2, 0x2, 0x175, 0x173, |
| 0x3, 0x2, 0x2, 0x2, 0x176, 0x177, 0x7, 0x54, 0x2, 0x2, 0x177, 0x178, |
| 0x5, 0xa, 0x6, 0x2, 0x178, 0x179, 0x7, 0x55, 0x2, 0x2, 0x179, 0x17c, |
| 0x3, 0x2, 0x2, 0x2, 0x17a, 0x17c, 0x9, 0x2, 0x2, 0x2, 0x17b, 0x16f, |
| 0x3, 0x2, 0x2, 0x2, 0x17b, 0x17a, 0x3, 0x2, 0x2, 0x2, 0x17c, 0x7, 0x3, |
| 0x2, 0x2, 0x2, 0x17d, 0x181, 0x7, 0x58, 0x2, 0x2, 0x17e, 0x180, 0x5, |
| 0x11c, 0x8f, 0x2, 0x17f, 0x17e, 0x3, 0x2, 0x2, 0x2, 0x180, 0x183, 0x3, |
| 0x2, 0x2, 0x2, 0x181, 0x17f, 0x3, 0x2, 0x2, 0x2, 0x181, 0x182, 0x3, |
| 0x2, 0x2, 0x2, 0x182, 0x184, 0x3, 0x2, 0x2, 0x2, 0x183, 0x181, 0x3, |
| 0x2, 0x2, 0x2, 0x184, 0x185, 0x7, 0x50, 0x2, 0x2, 0x185, 0x9, 0x3, 0x2, |
| 0x2, 0x2, 0x186, 0x188, 0x5, 0x110, 0x89, 0x2, 0x187, 0x186, 0x3, 0x2, |
| 0x2, 0x2, 0x188, 0x18b, 0x3, 0x2, 0x2, 0x2, 0x189, 0x187, 0x3, 0x2, |
| 0x2, 0x2, 0x189, 0x18a, 0x3, 0x2, 0x2, 0x2, 0x18a, 0x190, 0x3, 0x2, |
| 0x2, 0x2, 0x18b, 0x189, 0x3, 0x2, 0x2, 0x2, 0x18c, 0x18d, 0x7, 0x56, |
| 0x2, 0x2, 0x18d, 0x18f, 0x5, 0x110, 0x89, 0x2, 0x18e, 0x18c, 0x3, 0x2, |
| 0x2, 0x2, 0x18f, 0x192, 0x3, 0x2, 0x2, 0x2, 0x190, 0x18e, 0x3, 0x2, |
| 0x2, 0x2, 0x190, 0x191, 0x3, 0x2, 0x2, 0x2, 0x191, 0xb, 0x3, 0x2, 0x2, |
| 0x2, 0x192, 0x190, 0x3, 0x2, 0x2, 0x2, 0x193, 0x194, 0x9, 0x3, 0x2, |
| 0x2, 0x194, 0xd, 0x3, 0x2, 0x2, 0x2, 0x195, 0x196, 0x7, 0x4c, 0x2, 0x2, |
| 0x196, 0xf, 0x3, 0x2, 0x2, 0x2, 0x197, 0x198, 0x7, 0x4a, 0x2, 0x2, 0x198, |
| 0x11, 0x3, 0x2, 0x2, 0x2, 0x199, 0x19f, 0x5, 0xf0, 0x79, 0x2, 0x19a, |
| 0x19f, 0x5, 0xf4, 0x7b, 0x2, 0x19b, 0x19f, 0x5, 0xf6, 0x7c, 0x2, 0x19c, |
| 0x19f, 0x5, 0xf2, 0x7a, 0x2, 0x19d, 0x19f, 0x5, 0xf8, 0x7d, 0x2, 0x19e, |
| 0x199, 0x3, 0x2, 0x2, 0x2, 0x19e, 0x19a, 0x3, 0x2, 0x2, 0x2, 0x19e, |
| 0x19b, 0x3, 0x2, 0x2, 0x2, 0x19e, 0x19c, 0x3, 0x2, 0x2, 0x2, 0x19e, |
| 0x19d, 0x3, 0x2, 0x2, 0x2, 0x19f, 0x13, 0x3, 0x2, 0x2, 0x2, 0x1a0, 0x1a4, |
| 0x5, 0x16, 0xc, 0x2, 0x1a1, 0x1a3, 0x7, 0x49, 0x2, 0x2, 0x1a2, 0x1a1, |
| 0x3, 0x2, 0x2, 0x2, 0x1a3, 0x1a6, 0x3, 0x2, 0x2, 0x2, 0x1a4, 0x1a2, |
| 0x3, 0x2, 0x2, 0x2, 0x1a4, 0x1a5, 0x3, 0x2, 0x2, 0x2, 0x1a5, 0x1a7, |
| 0x3, 0x2, 0x2, 0x2, 0x1a6, 0x1a4, 0x3, 0x2, 0x2, 0x2, 0x1a7, 0x1a8, |
| 0x7, 0x50, 0x2, 0x2, 0x1a8, 0x15, 0x3, 0x2, 0x2, 0x2, 0x1a9, 0x1aa, |
| 0x7, 0x11, 0x2, 0x2, 0x1aa, 0x1af, 0x7, 0x49, 0x2, 0x2, 0x1ab, 0x1b0, |
| 0x7, 0x47, 0x2, 0x2, 0x1ac, 0x1b0, 0x7, 0x48, 0x2, 0x2, 0x1ad, 0x1b0, |
| 0x7, 0x59, 0x2, 0x2, 0x1ae, 0x1b0, 0x5, 0x6, 0x4, 0x2, 0x1af, 0x1ab, |
| 0x3, 0x2, 0x2, 0x2, 0x1af, 0x1ac, 0x3, 0x2, 0x2, 0x2, 0x1af, 0x1ad, |
| 0x3, 0x2, 0x2, 0x2, 0x1af, 0x1ae, 0x3, 0x2, 0x2, 0x2, 0x1b0, 0x17, 0x3, |
| 0x2, 0x2, 0x2, 0x1b1, 0x1b5, 0x5, 0x1a, 0xe, 0x2, 0x1b2, 0x1b4, 0x7, |
| 0x49, 0x2, 0x2, 0x1b3, 0x1b2, 0x3, 0x2, 0x2, 0x2, 0x1b4, 0x1b7, 0x3, |
| 0x2, 0x2, 0x2, 0x1b5, 0x1b3, 0x3, 0x2, 0x2, 0x2, 0x1b5, 0x1b6, 0x3, |
| 0x2, 0x2, 0x2, 0x1b6, 0x1b8, 0x3, 0x2, 0x2, 0x2, 0x1b7, 0x1b5, 0x3, |
| 0x2, 0x2, 0x2, 0x1b8, 0x1b9, 0x7, 0x50, 0x2, 0x2, 0x1b9, 0x19, 0x3, |
| 0x2, 0x2, 0x2, 0x1ba, 0x1bb, 0x7, 0x19, 0x2, 0x2, 0x1bb, 0x1bc, 0x7, |
| 0x49, 0x2, 0x2, 0x1bc, 0x1bd, 0x5, 0xe, 0x8, 0x2, 0x1bd, 0x1be, 0x7, |
| 0x47, 0x2, 0x2, 0x1be, 0x1bf, 0x7, 0x49, 0x2, 0x2, 0x1bf, 0x1c0, 0x5, |
| 0xe, 0x8, 0x2, 0x1c0, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x1c1, 0x1c5, 0x5, 0x1e, |
| 0x10, 0x2, 0x1c2, 0x1c4, 0x7, 0x49, 0x2, 0x2, 0x1c3, 0x1c2, 0x3, 0x2, |
| 0x2, 0x2, 0x1c4, 0x1c7, 0x3, 0x2, 0x2, 0x2, 0x1c5, 0x1c3, 0x3, 0x2, |
| 0x2, 0x2, 0x1c5, 0x1c6, 0x3, 0x2, 0x2, 0x2, 0x1c6, 0x1c8, 0x3, 0x2, |
| 0x2, 0x2, 0x1c7, 0x1c5, 0x3, 0x2, 0x2, 0x2, 0x1c8, 0x1c9, 0x7, 0x50, |
| 0x2, 0x2, 0x1c9, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x1ca, 0x1cb, 0x7, 0x9, 0x2, |
| 0x2, 0x1cb, 0x1cc, 0x7, 0x49, 0x2, 0x2, 0x1cc, 0x1cd, 0x7, 0x48, 0x2, |
| 0x2, 0x1cd, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x1ce, 0x1cf, 0x7, 0x35, 0x2, |
| 0x2, 0x1cf, 0x21, 0x3, 0x2, 0x2, 0x2, 0x1d0, 0x1d1, 0x7, 0x36, 0x2, |
| 0x2, 0x1d1, 0x23, 0x3, 0x2, 0x2, 0x2, 0x1d2, 0x1d6, 0x5, 0x26, 0x14, |
| 0x2, 0x1d3, 0x1d5, 0x7, 0x49, 0x2, 0x2, 0x1d4, 0x1d3, 0x3, 0x2, 0x2, |
| 0x2, 0x1d5, 0x1d8, 0x3, 0x2, 0x2, 0x2, 0x1d6, 0x1d4, 0x3, 0x2, 0x2, |
| 0x2, 0x1d6, 0x1d7, 0x3, 0x2, 0x2, 0x2, 0x1d7, 0x1d9, 0x3, 0x2, 0x2, |
| 0x2, 0x1d8, 0x1d6, 0x3, 0x2, 0x2, 0x2, 0x1d9, 0x1da, 0x7, 0x50, 0x2, |
| 0x2, 0x1da, 0x25, 0x3, 0x2, 0x2, 0x2, 0x1db, 0x1dc, 0x7, 0x16, 0x2, |
| 0x2, 0x1dc, 0x1dd, 0x7, 0x4b, 0x2, 0x2, 0x1dd, 0x27, 0x3, 0x2, 0x2, |
| 0x2, 0x1de, 0x1df, 0x7, 0xa, 0x2, 0x2, 0x1df, 0x1e3, 0x7, 0x49, 0x2, |
| 0x2, 0x1e0, 0x1e4, 0x7, 0x48, 0x2, 0x2, 0x1e1, 0x1e4, 0x7, 0x59, 0x2, |
| 0x2, 0x1e2, 0x1e4, 0x5, 0x6, 0x4, 0x2, 0x1e3, 0x1e0, 0x3, 0x2, 0x2, |
| 0x2, 0x1e3, 0x1e1, 0x3, 0x2, 0x2, 0x2, 0x1e3, 0x1e2, 0x3, 0x2, 0x2, |
| 0x2, 0x1e4, 0x29, 0x3, 0x2, 0x2, 0x2, 0x1e5, 0x1e9, 0x5, 0x2c, 0x17, |
| 0x2, 0x1e6, 0x1e8, 0x7, 0x49, 0x2, 0x2, 0x1e7, 0x1e6, 0x3, 0x2, 0x2, |
| 0x2, 0x1e8, 0x1eb, 0x3, 0x2, 0x2, 0x2, 0x1e9, 0x1e7, 0x3, 0x2, 0x2, |
| 0x2, 0x1e9, 0x1ea, 0x3, 0x2, 0x2, 0x2, 0x1ea, 0x203, 0x3, 0x2, 0x2, |
| 0x2, 0x1eb, 0x1e9, 0x3, 0x2, 0x2, 0x2, 0x1ec, 0x204, 0x9, 0x4, 0x2, |
| 0x2, 0x1ed, 0x1ef, 0x5, 0x4, 0x3, 0x2, 0x1ee, 0x1ed, 0x3, 0x2, 0x2, |
| 0x2, 0x1ef, 0x1f2, 0x3, 0x2, 0x2, 0x2, 0x1f0, 0x1ee, 0x3, 0x2, 0x2, |
| 0x2, 0x1f0, 0x1f1, 0x3, 0x2, 0x2, 0x2, 0x1f1, 0x1ff, 0x3, 0x2, 0x2, |
| 0x2, 0x1f2, 0x1f0, 0x3, 0x2, 0x2, 0x2, 0x1f3, 0x1f7, 0x5, 0x44, 0x23, |
| 0x2, 0x1f4, 0x1f7, 0x5, 0x3e, 0x20, 0x2, 0x1f5, 0x1f7, 0x5, 0x38, 0x1d, |
| 0x2, 0x1f6, 0x1f3, 0x3, 0x2, 0x2, 0x2, 0x1f6, 0x1f4, 0x3, 0x2, 0x2, |
| 0x2, 0x1f6, 0x1f5, 0x3, 0x2, 0x2, 0x2, 0x1f6, 0x1f7, 0x3, 0x2, 0x2, |
| 0x2, 0x1f7, 0x1f9, 0x3, 0x2, 0x2, 0x2, 0x1f8, 0x1fa, 0x5, 0x4, 0x3, |
| 0x2, 0x1f9, 0x1f8, 0x3, 0x2, 0x2, 0x2, 0x1fa, 0x1fb, 0x3, 0x2, 0x2, |
| 0x2, 0x1fb, 0x1f9, 0x3, 0x2, 0x2, 0x2, 0x1fb, 0x1fc, 0x3, 0x2, 0x2, |
| 0x2, 0x1fc, 0x1fe, 0x3, 0x2, 0x2, 0x2, 0x1fd, 0x1f6, 0x3, 0x2, 0x2, |
| 0x2, 0x1fe, 0x201, 0x3, 0x2, 0x2, 0x2, 0x1ff, 0x1fd, 0x3, 0x2, 0x2, |
| 0x2, 0x1ff, 0x200, 0x3, 0x2, 0x2, 0x2, 0x200, 0x202, 0x3, 0x2, 0x2, |
| 0x2, 0x201, 0x1ff, 0x3, 0x2, 0x2, 0x2, 0x202, 0x204, 0x5, 0x48, 0x25, |
| 0x2, 0x203, 0x1ec, 0x3, 0x2, 0x2, 0x2, 0x203, 0x1f0, 0x3, 0x2, 0x2, |
| 0x2, 0x204, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x205, 0x206, 0x7, 0xb, 0x2, 0x2, |
| 0x206, 0x20a, 0x7, 0x49, 0x2, 0x2, 0x207, 0x20b, 0x7, 0x48, 0x2, 0x2, |
| 0x208, 0x20b, 0x7, 0x59, 0x2, 0x2, 0x209, 0x20b, 0x5, 0x6, 0x4, 0x2, |
| 0x20a, 0x207, 0x3, 0x2, 0x2, 0x2, 0x20a, 0x208, 0x3, 0x2, 0x2, 0x2, |
| 0x20a, 0x209, 0x3, 0x2, 0x2, 0x2, 0x20b, 0x2d, 0x3, 0x2, 0x2, 0x2, 0x20c, |
| 0x20d, 0x7, 0xb, 0x2, 0x2, 0x20d, 0x211, 0x7, 0x49, 0x2, 0x2, 0x20e, |
| 0x212, 0x5, 0xfa, 0x7e, 0x2, 0x20f, 0x212, 0x7, 0x59, 0x2, 0x2, 0x210, |
| 0x212, 0x5, 0x6, 0x4, 0x2, 0x211, 0x20e, 0x3, 0x2, 0x2, 0x2, 0x211, |
| 0x20f, 0x3, 0x2, 0x2, 0x2, 0x211, 0x210, 0x3, 0x2, 0x2, 0x2, 0x212, |
| 0x2f, 0x3, 0x2, 0x2, 0x2, 0x213, 0x217, 0x5, 0x32, 0x1a, 0x2, 0x214, |
| 0x216, 0x7, 0x49, 0x2, 0x2, 0x215, 0x214, 0x3, 0x2, 0x2, 0x2, 0x216, |
| 0x219, 0x3, 0x2, 0x2, 0x2, 0x217, 0x215, 0x3, 0x2, 0x2, 0x2, 0x217, |
| 0x218, 0x3, 0x2, 0x2, 0x2, 0x218, 0x231, 0x3, 0x2, 0x2, 0x2, 0x219, |
| 0x217, 0x3, 0x2, 0x2, 0x2, 0x21a, 0x232, 0x9, 0x4, 0x2, 0x2, 0x21b, |
| 0x21d, 0x5, 0x4, 0x3, 0x2, 0x21c, 0x21b, 0x3, 0x2, 0x2, 0x2, 0x21d, |
| 0x220, 0x3, 0x2, 0x2, 0x2, 0x21e, 0x21c, 0x3, 0x2, 0x2, 0x2, 0x21e, |
| 0x21f, 0x3, 0x2, 0x2, 0x2, 0x21f, 0x22d, 0x3, 0x2, 0x2, 0x2, 0x220, |
| 0x21e, 0x3, 0x2, 0x2, 0x2, 0x221, 0x225, 0x5, 0x44, 0x23, 0x2, 0x222, |
| 0x225, 0x5, 0x3e, 0x20, 0x2, 0x223, 0x225, 0x5, 0x38, 0x1d, 0x2, 0x224, |
| 0x221, 0x3, 0x2, 0x2, 0x2, 0x224, 0x222, 0x3, 0x2, 0x2, 0x2, 0x224, |
| 0x223, 0x3, 0x2, 0x2, 0x2, 0x224, 0x225, 0x3, 0x2, 0x2, 0x2, 0x225, |
| 0x227, 0x3, 0x2, 0x2, 0x2, 0x226, 0x228, 0x5, 0x4, 0x3, 0x2, 0x227, |
| 0x226, 0x3, 0x2, 0x2, 0x2, 0x228, 0x229, 0x3, 0x2, 0x2, 0x2, 0x229, |
| 0x227, 0x3, 0x2, 0x2, 0x2, 0x229, 0x22a, 0x3, 0x2, 0x2, 0x2, 0x22a, |
| 0x22c, 0x3, 0x2, 0x2, 0x2, 0x22b, 0x224, 0x3, 0x2, 0x2, 0x2, 0x22c, |
| 0x22f, 0x3, 0x2, 0x2, 0x2, 0x22d, 0x22b, 0x3, 0x2, 0x2, 0x2, 0x22d, |
| 0x22e, 0x3, 0x2, 0x2, 0x2, 0x22e, 0x230, 0x3, 0x2, 0x2, 0x2, 0x22f, |
| 0x22d, 0x3, 0x2, 0x2, 0x2, 0x230, 0x232, 0x5, 0x48, 0x25, 0x2, 0x231, |
| 0x21a, 0x3, 0x2, 0x2, 0x2, 0x231, 0x21e, 0x3, 0x2, 0x2, 0x2, 0x232, |
| 0x31, 0x3, 0x2, 0x2, 0x2, 0x233, 0x234, 0x7, 0xc, 0x2, 0x2, 0x234, 0x238, |
| 0x7, 0x49, 0x2, 0x2, 0x235, 0x239, 0x7, 0x48, 0x2, 0x2, 0x236, 0x239, |
| 0x7, 0x59, 0x2, 0x2, 0x237, 0x239, 0x5, 0x6, 0x4, 0x2, 0x238, 0x235, |
| 0x3, 0x2, 0x2, 0x2, 0x238, 0x236, 0x3, 0x2, 0x2, 0x2, 0x238, 0x237, |
| 0x3, 0x2, 0x2, 0x2, 0x239, 0x33, 0x3, 0x2, 0x2, 0x2, 0x23a, 0x23b, 0x7, |
| 0xc, 0x2, 0x2, 0x23b, 0x23f, 0x7, 0x49, 0x2, 0x2, 0x23c, 0x240, 0x5, |
| 0xfa, 0x7e, 0x2, 0x23d, 0x240, 0x7, 0x59, 0x2, 0x2, 0x23e, 0x240, 0x5, |
| 0x6, 0x4, 0x2, 0x23f, 0x23c, 0x3, 0x2, 0x2, 0x2, 0x23f, 0x23d, 0x3, |
| 0x2, 0x2, 0x2, 0x23f, 0x23e, 0x3, 0x2, 0x2, 0x2, 0x240, 0x35, 0x3, 0x2, |
| 0x2, 0x2, 0x241, 0x245, 0x5, 0x38, 0x1d, 0x2, 0x242, 0x244, 0x7, 0x49, |
| 0x2, 0x2, 0x243, 0x242, 0x3, 0x2, 0x2, 0x2, 0x244, 0x247, 0x3, 0x2, |
| 0x2, 0x2, 0x245, 0x243, 0x3, 0x2, 0x2, 0x2, 0x245, 0x246, 0x3, 0x2, |
| 0x2, 0x2, 0x246, 0x248, 0x3, 0x2, 0x2, 0x2, 0x247, 0x245, 0x3, 0x2, |
| 0x2, 0x2, 0x248, 0x249, 0x9, 0x4, 0x2, 0x2, 0x249, 0x37, 0x3, 0x2, 0x2, |
| 0x2, 0x24a, 0x24b, 0x7, 0xe, 0x2, 0x2, 0x24b, 0x24f, 0x7, 0x49, 0x2, |
| 0x2, 0x24c, 0x250, 0x7, 0x48, 0x2, 0x2, 0x24d, 0x250, 0x7, 0x59, 0x2, |
| 0x2, 0x24e, 0x250, 0x5, 0x6, 0x4, 0x2, 0x24f, 0x24c, 0x3, 0x2, 0x2, |
| 0x2, 0x24f, 0x24d, 0x3, 0x2, 0x2, 0x2, 0x24f, 0x24e, 0x3, 0x2, 0x2, |
| 0x2, 0x250, 0x39, 0x3, 0x2, 0x2, 0x2, 0x251, 0x252, 0x7, 0xe, 0x2, 0x2, |
| 0x252, 0x256, 0x7, 0x49, 0x2, 0x2, 0x253, 0x257, 0x5, 0xfa, 0x7e, 0x2, |
| 0x254, 0x257, 0x7, 0x59, 0x2, 0x2, 0x255, 0x257, 0x5, 0x6, 0x4, 0x2, |
| 0x256, 0x253, 0x3, 0x2, 0x2, 0x2, 0x256, 0x254, 0x3, 0x2, 0x2, 0x2, |
| 0x256, 0x255, 0x3, 0x2, 0x2, 0x2, 0x257, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x258, |
| 0x25c, 0x5, 0x3e, 0x20, 0x2, 0x259, 0x25b, 0x7, 0x49, 0x2, 0x2, 0x25a, |
| 0x259, 0x3, 0x2, 0x2, 0x2, 0x25b, 0x25e, 0x3, 0x2, 0x2, 0x2, 0x25c, |
| 0x25a, 0x3, 0x2, 0x2, 0x2, 0x25c, 0x25d, 0x3, 0x2, 0x2, 0x2, 0x25d, |
| 0x25f, 0x3, 0x2, 0x2, 0x2, 0x25e, 0x25c, 0x3, 0x2, 0x2, 0x2, 0x25f, |
| 0x260, 0x9, 0x4, 0x2, 0x2, 0x260, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x261, 0x262, |
| 0x7, 0xf, 0x2, 0x2, 0x262, 0x266, 0x7, 0x49, 0x2, 0x2, 0x263, 0x267, |
| 0x7, 0x48, 0x2, 0x2, 0x264, 0x267, 0x7, 0x59, 0x2, 0x2, 0x265, 0x267, |
| 0x5, 0x6, 0x4, 0x2, 0x266, 0x263, 0x3, 0x2, 0x2, 0x2, 0x266, 0x264, |
| 0x3, 0x2, 0x2, 0x2, 0x266, 0x265, 0x3, 0x2, 0x2, 0x2, 0x267, 0x3f, 0x3, |
| 0x2, 0x2, 0x2, 0x268, 0x269, 0x7, 0xf, 0x2, 0x2, 0x269, 0x26d, 0x7, |
| 0x49, 0x2, 0x2, 0x26a, 0x26e, 0x5, 0xfa, 0x7e, 0x2, 0x26b, 0x26e, 0x7, |
| 0x59, 0x2, 0x2, 0x26c, 0x26e, 0x5, 0x6, 0x4, 0x2, 0x26d, 0x26a, 0x3, |
| 0x2, 0x2, 0x2, 0x26d, 0x26b, 0x3, 0x2, 0x2, 0x2, 0x26d, 0x26c, 0x3, |
| 0x2, 0x2, 0x2, 0x26e, 0x41, 0x3, 0x2, 0x2, 0x2, 0x26f, 0x273, 0x5, 0x44, |
| 0x23, 0x2, 0x270, 0x272, 0x7, 0x49, 0x2, 0x2, 0x271, 0x270, 0x3, 0x2, |
| 0x2, 0x2, 0x272, 0x275, 0x3, 0x2, 0x2, 0x2, 0x273, 0x271, 0x3, 0x2, |
| 0x2, 0x2, 0x273, 0x274, 0x3, 0x2, 0x2, 0x2, 0x274, 0x276, 0x3, 0x2, |
| 0x2, 0x2, 0x275, 0x273, 0x3, 0x2, 0x2, 0x2, 0x276, 0x277, 0x9, 0x4, |
| 0x2, 0x2, 0x277, 0x43, 0x3, 0x2, 0x2, 0x2, 0x278, 0x279, 0x7, 0xd, 0x2, |
| 0x2, 0x279, 0x45, 0x3, 0x2, 0x2, 0x2, 0x27a, 0x27e, 0x7, 0x10, 0x2, |
| 0x2, 0x27b, 0x27d, 0x7, 0x49, 0x2, 0x2, 0x27c, 0x27b, 0x3, 0x2, 0x2, |
| 0x2, 0x27d, 0x280, 0x3, 0x2, 0x2, 0x2, 0x27e, 0x27c, 0x3, 0x2, 0x2, |
| 0x2, 0x27e, 0x27f, 0x3, 0x2, 0x2, 0x2, 0x27f, 0x281, 0x3, 0x2, 0x2, |
| 0x2, 0x280, 0x27e, 0x3, 0x2, 0x2, 0x2, 0x281, 0x28d, 0x7, 0x3, 0x2, |
| 0x2, 0x282, 0x286, 0x7, 0x10, 0x2, 0x2, 0x283, 0x285, 0x7, 0x49, 0x2, |
| 0x2, 0x284, 0x283, 0x3, 0x2, 0x2, 0x2, 0x285, 0x288, 0x3, 0x2, 0x2, |
| 0x2, 0x286, 0x284, 0x3, 0x2, 0x2, 0x2, 0x286, 0x287, 0x3, 0x2, 0x2, |
| 0x2, 0x287, 0x289, 0x3, 0x2, 0x2, 0x2, 0x288, 0x286, 0x3, 0x2, 0x2, |
| 0x2, 0x289, 0x28d, 0x7, 0x50, 0x2, 0x2, 0x28a, 0x28b, 0x7, 0x10, 0x2, |
| 0x2, 0x28b, 0x28d, 0x7, 0x2, 0x2, 0x3, 0x28c, 0x27a, 0x3, 0x2, 0x2, |
| 0x2, 0x28c, 0x282, 0x3, 0x2, 0x2, 0x2, 0x28c, 0x28a, 0x3, 0x2, 0x2, |
| 0x2, 0x28d, 0x47, 0x3, 0x2, 0x2, 0x2, 0x28e, 0x292, 0x7, 0x10, 0x2, |
| 0x2, 0x28f, 0x291, 0x7, 0x49, 0x2, 0x2, 0x290, 0x28f, 0x3, 0x2, 0x2, |
| 0x2, 0x291, 0x294, 0x3, 0x2, 0x2, 0x2, 0x292, 0x290, 0x3, 0x2, 0x2, |
| 0x2, 0x292, 0x293, 0x3, 0x2, 0x2, 0x2, 0x293, 0x295, 0x3, 0x2, 0x2, |
| 0x2, 0x294, 0x292, 0x3, 0x2, 0x2, 0x2, 0x295, 0x298, 0x7, 0x3, 0x2, |
| 0x2, 0x296, 0x298, 0x7, 0x10, 0x2, 0x2, 0x297, 0x28e, 0x3, 0x2, 0x2, |
| 0x2, 0x297, 0x296, 0x3, 0x2, 0x2, 0x2, 0x298, 0x49, 0x3, 0x2, 0x2, 0x2, |
| 0x299, 0x29d, 0x5, 0x4c, 0x27, 0x2, 0x29a, 0x29c, 0x7, 0x49, 0x2, 0x2, |
| 0x29b, 0x29a, 0x3, 0x2, 0x2, 0x2, 0x29c, 0x29f, 0x3, 0x2, 0x2, 0x2, |
| 0x29d, 0x29b, 0x3, 0x2, 0x2, 0x2, 0x29d, 0x29e, 0x3, 0x2, 0x2, 0x2, |
| 0x29e, 0x2a0, 0x3, 0x2, 0x2, 0x2, 0x29f, 0x29d, 0x3, 0x2, 0x2, 0x2, |
| 0x2a0, 0x2a1, 0x7, 0x50, 0x2, 0x2, 0x2a1, 0x4b, 0x3, 0x2, 0x2, 0x2, |
| 0x2a2, 0x2a3, 0x7, 0x15, 0x2, 0x2, 0x2a3, 0x4d, 0x3, 0x2, 0x2, 0x2, |
| 0x2a4, 0x2a8, 0x5, 0x50, 0x29, 0x2, 0x2a5, 0x2a7, 0x7, 0x49, 0x2, 0x2, |
| 0x2a6, 0x2a5, 0x3, 0x2, 0x2, 0x2, 0x2a7, 0x2aa, 0x3, 0x2, 0x2, 0x2, |
| 0x2a8, 0x2a6, 0x3, 0x2, 0x2, 0x2, 0x2a8, 0x2a9, 0x3, 0x2, 0x2, 0x2, |
| 0x2a9, 0x2ab, 0x3, 0x2, 0x2, 0x2, 0x2aa, 0x2a8, 0x3, 0x2, 0x2, 0x2, |
| 0x2ab, 0x2ac, 0x7, 0x50, 0x2, 0x2, 0x2ac, 0x4f, 0x3, 0x2, 0x2, 0x2, |
| 0x2ad, 0x2ae, 0x7, 0x13, 0x2, 0x2, 0x2ae, 0x2af, 0x7, 0x49, 0x2, 0x2, |
| 0x2af, 0x2b0, 0x7, 0x47, 0x2, 0x2, 0x2b0, 0x51, 0x3, 0x2, 0x2, 0x2, |
| 0x2b1, 0x2b5, 0x5, 0x54, 0x2b, 0x2, 0x2b2, 0x2b4, 0x7, 0x49, 0x2, 0x2, |
| 0x2b3, 0x2b2, 0x3, 0x2, 0x2, 0x2, 0x2b4, 0x2b7, 0x3, 0x2, 0x2, 0x2, |
| 0x2b5, 0x2b3, 0x3, 0x2, 0x2, 0x2, 0x2b5, 0x2b6, 0x3, 0x2, 0x2, 0x2, |
| 0x2b6, 0x2b8, 0x3, 0x2, 0x2, 0x2, 0x2b7, 0x2b5, 0x3, 0x2, 0x2, 0x2, |
| 0x2b8, 0x2b9, 0x7, 0x50, 0x2, 0x2, 0x2b9, 0x53, 0x3, 0x2, 0x2, 0x2, |
| 0x2ba, 0x2bb, 0x7, 0x14, 0x2, 0x2, 0x2bb, 0x55, 0x3, 0x2, 0x2, 0x2, |
| 0x2bc, 0x2c0, 0x5, 0x58, 0x2d, 0x2, 0x2bd, 0x2bf, 0x7, 0x49, 0x2, 0x2, |
| 0x2be, 0x2bd, 0x3, 0x2, 0x2, 0x2, 0x2bf, 0x2c2, 0x3, 0x2, 0x2, 0x2, |
| 0x2c0, 0x2be, 0x3, 0x2, 0x2, 0x2, 0x2c0, 0x2c1, 0x3, 0x2, 0x2, 0x2, |
| 0x2c1, 0x2c3, 0x3, 0x2, 0x2, 0x2, 0x2c2, 0x2c0, 0x3, 0x2, 0x2, 0x2, |
| 0x2c3, 0x2c4, 0x7, 0x50, 0x2, 0x2, 0x2c4, 0x57, 0x3, 0x2, 0x2, 0x2, |
| 0x2c5, 0x2c6, 0x7, 0x12, 0x2, 0x2, 0x2c6, 0x2c7, 0x7, 0x49, 0x2, 0x2, |
| 0x2c7, 0x2d2, 0x7, 0x48, 0x2, 0x2, 0x2c8, 0x2cd, 0x5, 0x10e, 0x88, 0x2, |
| 0x2c9, 0x2ca, 0x7, 0x5e, 0x2, 0x2, 0x2ca, 0x2cc, 0x5, 0x10e, 0x88, 0x2, |
| 0x2cb, 0x2c9, 0x3, 0x2, 0x2, 0x2, 0x2cc, 0x2cf, 0x3, 0x2, 0x2, 0x2, |
| 0x2cd, 0x2cb, 0x3, 0x2, 0x2, 0x2, 0x2cd, 0x2ce, 0x3, 0x2, 0x2, 0x2, |
| 0x2ce, 0x2d1, 0x3, 0x2, 0x2, 0x2, 0x2cf, 0x2cd, 0x3, 0x2, 0x2, 0x2, |
| 0x2d0, 0x2c8, 0x3, 0x2, 0x2, 0x2, 0x2d1, 0x2d4, 0x3, 0x2, 0x2, 0x2, |
| 0x2d2, 0x2d0, 0x3, 0x2, 0x2, 0x2, 0x2d2, 0x2d3, 0x3, 0x2, 0x2, 0x2, |
| 0x2d3, 0x59, 0x3, 0x2, 0x2, 0x2, 0x2d4, 0x2d2, 0x3, 0x2, 0x2, 0x2, 0x2d5, |
| 0x2d9, 0x5, 0x5c, 0x2f, 0x2, 0x2d6, 0x2d8, 0x7, 0x49, 0x2, 0x2, 0x2d7, |
| 0x2d6, 0x3, 0x2, 0x2, 0x2, 0x2d8, 0x2db, 0x3, 0x2, 0x2, 0x2, 0x2d9, |
| 0x2d7, 0x3, 0x2, 0x2, 0x2, 0x2d9, 0x2da, 0x3, 0x2, 0x2, 0x2, 0x2da, |
| 0x2dc, 0x3, 0x2, 0x2, 0x2, 0x2db, 0x2d9, 0x3, 0x2, 0x2, 0x2, 0x2dc, |
| 0x2dd, 0x7, 0x50, 0x2, 0x2, 0x2dd, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x2de, |
| 0x2df, 0x7, 0x7, 0x2, 0x2, 0x2df, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x2e0, 0x2e4, |
| 0x5, 0x60, 0x31, 0x2, 0x2e1, 0x2e3, 0x7, 0x49, 0x2, 0x2, 0x2e2, 0x2e1, |
| 0x3, 0x2, 0x2, 0x2, 0x2e3, 0x2e6, 0x3, 0x2, 0x2, 0x2, 0x2e4, 0x2e2, |
| 0x3, 0x2, 0x2, 0x2, 0x2e4, 0x2e5, 0x3, 0x2, 0x2, 0x2, 0x2e5, 0x2e7, |
| 0x3, 0x2, 0x2, 0x2, 0x2e6, 0x2e4, 0x3, 0x2, 0x2, 0x2, 0x2e7, 0x2e8, |
| 0x7, 0x50, 0x2, 0x2, 0x2e8, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x2e9, 0x2ea, |
| 0x7, 0x8, 0x2, 0x2, 0x2ea, 0x61, 0x3, 0x2, 0x2, 0x2, 0x2eb, 0x2ef, 0x5, |
| 0x64, 0x33, 0x2, 0x2ec, 0x2ee, 0x7, 0x49, 0x2, 0x2, 0x2ed, 0x2ec, 0x3, |
| 0x2, 0x2, 0x2, 0x2ee, 0x2f1, 0x3, 0x2, 0x2, 0x2, 0x2ef, 0x2ed, 0x3, |
| 0x2, 0x2, 0x2, 0x2ef, 0x2f0, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2f2, 0x3, |
| 0x2, 0x2, 0x2, 0x2f1, 0x2ef, 0x3, 0x2, 0x2, 0x2, 0x2f2, 0x2f3, 0x7, |
| 0x50, 0x2, 0x2, 0x2f3, 0x63, 0x3, 0x2, 0x2, 0x2, 0x2f4, 0x2f5, 0x7, |
| 0x23, 0x2, 0x2, 0x2f5, 0x65, 0x3, 0x2, 0x2, 0x2, 0x2f6, 0x2fa, 0x5, |
| 0x68, 0x35, 0x2, 0x2f7, 0x2f9, 0x7, 0x49, 0x2, 0x2, 0x2f8, 0x2f7, 0x3, |
| 0x2, 0x2, 0x2, 0x2f9, 0x2fc, 0x3, 0x2, 0x2, 0x2, 0x2fa, 0x2f8, 0x3, |
| 0x2, 0x2, 0x2, 0x2fa, 0x2fb, 0x3, 0x2, 0x2, 0x2, 0x2fb, 0x2fd, 0x3, |
| 0x2, 0x2, 0x2, 0x2fc, 0x2fa, 0x3, 0x2, 0x2, 0x2, 0x2fd, 0x2fe, 0x7, |
| 0x50, 0x2, 0x2, 0x2fe, 0x67, 0x3, 0x2, 0x2, 0x2, 0x2ff, 0x300, 0x7, |
| 0x2b, 0x2, 0x2, 0x300, 0x69, 0x3, 0x2, 0x2, 0x2, 0x301, 0x305, 0x5, |
| 0x6c, 0x37, 0x2, 0x302, 0x304, 0x7, 0x49, 0x2, 0x2, 0x303, 0x302, 0x3, |
| 0x2, 0x2, 0x2, 0x304, 0x307, 0x3, 0x2, 0x2, 0x2, 0x305, 0x303, 0x3, |
| 0x2, 0x2, 0x2, 0x305, 0x306, 0x3, 0x2, 0x2, 0x2, 0x306, 0x308, 0x3, |
| 0x2, 0x2, 0x2, 0x307, 0x305, 0x3, 0x2, 0x2, 0x2, 0x308, 0x309, 0x7, |
| 0x50, 0x2, 0x2, 0x309, 0x6b, 0x3, 0x2, 0x2, 0x2, 0x30a, 0x30b, 0x7, |
| 0x2c, 0x2, 0x2, 0x30b, 0x6d, 0x3, 0x2, 0x2, 0x2, 0x30c, 0x310, 0x5, |
| 0x70, 0x39, 0x2, 0x30d, 0x30f, 0x7, 0x49, 0x2, 0x2, 0x30e, 0x30d, 0x3, |
| 0x2, 0x2, 0x2, 0x30f, 0x312, 0x3, 0x2, 0x2, 0x2, 0x310, 0x30e, 0x3, |
| 0x2, 0x2, 0x2, 0x310, 0x311, 0x3, 0x2, 0x2, 0x2, 0x311, 0x313, 0x3, |
| 0x2, 0x2, 0x2, 0x312, 0x310, 0x3, 0x2, 0x2, 0x2, 0x313, 0x314, 0x7, |
| 0x50, 0x2, 0x2, 0x314, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x315, 0x316, 0x7, |
| 0x2d, 0x2, 0x2, 0x316, 0x71, 0x3, 0x2, 0x2, 0x2, 0x317, 0x31b, 0x5, |
| 0x74, 0x3b, 0x2, 0x318, 0x31a, 0x7, 0x49, 0x2, 0x2, 0x319, 0x318, 0x3, |
| 0x2, 0x2, 0x2, 0x31a, 0x31d, 0x3, 0x2, 0x2, 0x2, 0x31b, 0x319, 0x3, |
| 0x2, 0x2, 0x2, 0x31b, 0x31c, 0x3, 0x2, 0x2, 0x2, 0x31c, 0x31e, 0x3, |
| 0x2, 0x2, 0x2, 0x31d, 0x31b, 0x3, 0x2, 0x2, 0x2, 0x31e, 0x31f, 0x7, |
| 0x50, 0x2, 0x2, 0x31f, 0x73, 0x3, 0x2, 0x2, 0x2, 0x320, 0x321, 0x7, |
| 0x2e, 0x2, 0x2, 0x321, 0x75, 0x3, 0x2, 0x2, 0x2, 0x322, 0x326, 0x5, |
| 0x78, 0x3d, 0x2, 0x323, 0x325, 0x7, 0x49, 0x2, 0x2, 0x324, 0x323, 0x3, |
| 0x2, 0x2, 0x2, 0x325, 0x328, 0x3, 0x2, 0x2, 0x2, 0x326, 0x324, 0x3, |
| 0x2, 0x2, 0x2, 0x326, 0x327, 0x3, 0x2, 0x2, 0x2, 0x327, 0x329, 0x3, |
| 0x2, 0x2, 0x2, 0x328, 0x326, 0x3, 0x2, 0x2, 0x2, 0x329, 0x32a, 0x7, |
| 0x50, 0x2, 0x2, 0x32a, 0x77, 0x3, 0x2, 0x2, 0x2, 0x32b, 0x32c, 0x7, |
| 0x2f, 0x2, 0x2, 0x32c, 0x79, 0x3, 0x2, 0x2, 0x2, 0x32d, 0x331, 0x5, |
| 0x7c, 0x3f, 0x2, 0x32e, 0x330, 0x7, 0x49, 0x2, 0x2, 0x32f, 0x32e, 0x3, |
| 0x2, 0x2, 0x2, 0x330, 0x333, 0x3, 0x2, 0x2, 0x2, 0x331, 0x32f, 0x3, |
| 0x2, 0x2, 0x2, 0x331, 0x332, 0x3, 0x2, 0x2, 0x2, 0x332, 0x334, 0x3, |
| 0x2, 0x2, 0x2, 0x333, 0x331, 0x3, 0x2, 0x2, 0x2, 0x334, 0x335, 0x7, |
| 0x50, 0x2, 0x2, 0x335, 0x7b, 0x3, 0x2, 0x2, 0x2, 0x336, 0x337, 0x7, |
| 0x30, 0x2, 0x2, 0x337, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x338, 0x339, 0x5, |
| 0x80, 0x41, 0x2, 0x339, 0x33a, 0x7, 0x50, 0x2, 0x2, 0x33a, 0x7f, 0x3, |
| 0x2, 0x2, 0x2, 0x33b, 0x33d, 0x7, 0x24, 0x2, 0x2, 0x33c, 0x33e, 0x5, |
| 0x114, 0x8b, 0x2, 0x33d, 0x33c, 0x3, 0x2, 0x2, 0x2, 0x33e, 0x33f, 0x3, |
| 0x2, 0x2, 0x2, 0x33f, 0x33d, 0x3, 0x2, 0x2, 0x2, 0x33f, 0x340, 0x3, |
| 0x2, 0x2, 0x2, 0x340, 0x81, 0x3, 0x2, 0x2, 0x2, 0x341, 0x345, 0x5, 0x84, |
| 0x43, 0x2, 0x342, 0x344, 0x7, 0x49, 0x2, 0x2, 0x343, 0x342, 0x3, 0x2, |
| 0x2, 0x2, 0x344, 0x347, 0x3, 0x2, 0x2, 0x2, 0x345, 0x343, 0x3, 0x2, |
| 0x2, 0x2, 0x345, 0x346, 0x3, 0x2, 0x2, 0x2, 0x346, 0x348, 0x3, 0x2, |
| 0x2, 0x2, 0x347, 0x345, 0x3, 0x2, 0x2, 0x2, 0x348, 0x349, 0x7, 0x50, |
| 0x2, 0x2, 0x349, 0x83, 0x3, 0x2, 0x2, 0x2, 0x34a, 0x34b, 0x7, 0x25, |
| 0x2, 0x2, 0x34b, 0x85, 0x3, 0x2, 0x2, 0x2, 0x34c, 0x350, 0x5, 0x88, |
| 0x45, 0x2, 0x34d, 0x34f, 0x7, 0x49, 0x2, 0x2, 0x34e, 0x34d, 0x3, 0x2, |
| 0x2, 0x2, 0x34f, 0x352, 0x3, 0x2, 0x2, 0x2, 0x350, 0x34e, 0x3, 0x2, |
| 0x2, 0x2, 0x350, 0x351, 0x3, 0x2, 0x2, 0x2, 0x351, 0x353, 0x3, 0x2, |
| 0x2, 0x2, 0x352, 0x350, 0x3, 0x2, 0x2, 0x2, 0x353, 0x354, 0x7, 0x50, |
| 0x2, 0x2, 0x354, 0x87, 0x3, 0x2, 0x2, 0x2, 0x355, 0x356, 0x7, 0x26, |
| 0x2, 0x2, 0x356, 0x89, 0x3, 0x2, 0x2, 0x2, 0x357, 0x35b, 0x5, 0x8c, |
| 0x47, 0x2, 0x358, 0x35a, 0x7, 0x49, 0x2, 0x2, 0x359, 0x358, 0x3, 0x2, |
| 0x2, 0x2, 0x35a, 0x35d, 0x3, 0x2, 0x2, 0x2, 0x35b, 0x359, 0x3, 0x2, |
| 0x2, 0x2, 0x35b, 0x35c, 0x3, 0x2, 0x2, 0x2, 0x35c, 0x35e, 0x3, 0x2, |
| 0x2, 0x2, 0x35d, 0x35b, 0x3, 0x2, 0x2, 0x2, 0x35e, 0x35f, 0x7, 0x50, |
| 0x2, 0x2, 0x35f, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x360, 0x361, 0x7, 0x27, |
| 0x2, 0x2, 0x361, 0x8d, 0x3, 0x2, 0x2, 0x2, 0x362, 0x366, 0x5, 0x90, |
| 0x49, 0x2, 0x363, 0x365, 0x7, 0x49, 0x2, 0x2, 0x364, 0x363, 0x3, 0x2, |
| 0x2, 0x2, 0x365, 0x368, 0x3, 0x2, 0x2, 0x2, 0x366, 0x364, 0x3, 0x2, |
| 0x2, 0x2, 0x366, 0x367, 0x3, 0x2, 0x2, 0x2, 0x367, 0x369, 0x3, 0x2, |
| 0x2, 0x2, 0x368, 0x366, 0x3, 0x2, 0x2, 0x2, 0x369, 0x36a, 0x7, 0x50, |
| 0x2, 0x2, 0x36a, 0x8f, 0x3, 0x2, 0x2, 0x2, 0x36b, 0x36c, 0x7, 0x28, |
| 0x2, 0x2, 0x36c, 0x91, 0x3, 0x2, 0x2, 0x2, 0x36d, 0x371, 0x5, 0x94, |
| 0x4b, 0x2, 0x36e, 0x370, 0x7, 0x49, 0x2, 0x2, 0x36f, 0x36e, 0x3, 0x2, |
| 0x2, 0x2, 0x370, 0x373, 0x3, 0x2, 0x2, 0x2, 0x371, 0x36f, 0x3, 0x2, |
| 0x2, 0x2, 0x371, 0x372, 0x3, 0x2, 0x2, 0x2, 0x372, 0x374, 0x3, 0x2, |
| 0x2, 0x2, 0x373, 0x371, 0x3, 0x2, 0x2, 0x2, 0x374, 0x375, 0x7, 0x50, |
| 0x2, 0x2, 0x375, 0x93, 0x3, 0x2, 0x2, 0x2, 0x376, 0x377, 0x7, 0x29, |
| 0x2, 0x2, 0x377, 0x95, 0x3, 0x2, 0x2, 0x2, 0x378, 0x37c, 0x5, 0x98, |
| 0x4d, 0x2, 0x379, 0x37b, 0x7, 0x49, 0x2, 0x2, 0x37a, 0x379, 0x3, 0x2, |
| 0x2, 0x2, 0x37b, 0x37e, 0x3, 0x2, 0x2, 0x2, 0x37c, 0x37a, 0x3, 0x2, |
| 0x2, 0x2, 0x37c, 0x37d, 0x3, 0x2, 0x2, 0x2, 0x37d, 0x37f, 0x3, 0x2, |
| 0x2, 0x2, 0x37e, 0x37c, 0x3, 0x2, 0x2, 0x2, 0x37f, 0x380, 0x7, 0x50, |
| 0x2, 0x2, 0x380, 0x97, 0x3, 0x2, 0x2, 0x2, 0x381, 0x382, 0x7, 0x2a, |
| 0x2, 0x2, 0x382, 0x99, 0x3, 0x2, 0x2, 0x2, 0x383, 0x387, 0x5, 0x9c, |
| 0x4f, 0x2, 0x384, 0x386, 0x7, 0x49, 0x2, 0x2, 0x385, 0x384, 0x3, 0x2, |
| 0x2, 0x2, 0x386, 0x389, 0x3, 0x2, 0x2, 0x2, 0x387, 0x385, 0x3, 0x2, |
| 0x2, 0x2, 0x387, 0x388, 0x3, 0x2, 0x2, 0x2, 0x388, 0x38a, 0x3, 0x2, |
| 0x2, 0x2, 0x389, 0x387, 0x3, 0x2, 0x2, 0x2, 0x38a, 0x38b, 0x7, 0x50, |
| 0x2, 0x2, 0x38b, 0x9b, 0x3, 0x2, 0x2, 0x2, 0x38c, 0x38d, 0x7, 0x31, |
| 0x2, 0x2, 0x38d, 0x9d, 0x3, 0x2, 0x2, 0x2, 0x38e, 0x392, 0x5, 0xa0, |
| 0x51, 0x2, 0x38f, 0x391, 0x7, 0x49, 0x2, 0x2, 0x390, 0x38f, 0x3, 0x2, |
| 0x2, 0x2, 0x391, 0x394, 0x3, 0x2, 0x2, 0x2, 0x392, 0x390, 0x3, 0x2, |
| 0x2, 0x2, 0x392, 0x393, 0x3, 0x2, 0x2, 0x2, 0x393, 0x395, 0x3, 0x2, |
| 0x2, 0x2, 0x394, 0x392, 0x3, 0x2, 0x2, 0x2, 0x395, 0x396, 0x7, 0x50, |
| 0x2, 0x2, 0x396, 0x9f, 0x3, 0x2, 0x2, 0x2, 0x397, 0x398, 0x7, 0x32, |
| 0x2, 0x2, 0x398, 0xa1, 0x3, 0x2, 0x2, 0x2, 0x399, 0x39d, 0x5, 0xa4, |
| 0x53, 0x2, 0x39a, 0x39c, 0x7, 0x49, 0x2, 0x2, 0x39b, 0x39a, 0x3, 0x2, |
| 0x2, 0x2, 0x39c, 0x39f, 0x3, 0x2, 0x2, 0x2, 0x39d, 0x39b, 0x3, 0x2, |
| 0x2, 0x2, 0x39d, 0x39e, 0x3, 0x2, 0x2, 0x2, 0x39e, 0x3a0, 0x3, 0x2, |
| 0x2, 0x2, 0x39f, 0x39d, 0x3, 0x2, 0x2, 0x2, 0x3a0, 0x3a1, 0x7, 0x50, |
| 0x2, 0x2, 0x3a1, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x3a2, 0x3a3, 0x7, 0x33, |
| 0x2, 0x2, 0x3a3, 0xa5, 0x3, 0x2, 0x2, 0x2, 0x3a4, 0x3a8, 0x5, 0xa8, |
| 0x55, 0x2, 0x3a5, 0x3a7, 0x7, 0x49, 0x2, 0x2, 0x3a6, 0x3a5, 0x3, 0x2, |
| 0x2, 0x2, 0x3a7, 0x3aa, 0x3, 0x2, 0x2, 0x2, 0x3a8, 0x3a6, 0x3, 0x2, |
| 0x2, 0x2, 0x3a8, 0x3a9, 0x3, 0x2, 0x2, 0x2, 0x3a9, 0x3ab, 0x3, 0x2, |
| 0x2, 0x2, 0x3aa, 0x3a8, 0x3, 0x2, 0x2, 0x2, 0x3ab, 0x3ac, 0x7, 0x50, |
| 0x2, 0x2, 0x3ac, 0xa7, 0x3, 0x2, 0x2, 0x2, 0x3ad, 0x3ae, 0x7, 0x34, |
| 0x2, 0x2, 0x3ae, 0xa9, 0x3, 0x2, 0x2, 0x2, 0x3af, 0x3b3, 0x5, 0xac, |
| 0x57, 0x2, 0x3b0, 0x3b2, 0x7, 0x49, 0x2, 0x2, 0x3b1, 0x3b0, 0x3, 0x2, |
| 0x2, 0x2, 0x3b2, 0x3b5, 0x3, 0x2, 0x2, 0x2, 0x3b3, 0x3b1, 0x3, 0x2, |
| 0x2, 0x2, 0x3b3, 0x3b4, 0x3, 0x2, 0x2, 0x2, 0x3b4, 0x3b6, 0x3, 0x2, |
| 0x2, 0x2, 0x3b5, 0x3b3, 0x3, 0x2, 0x2, 0x2, 0x3b6, 0x3b7, 0x7, 0x50, |
| 0x2, 0x2, 0x3b7, 0xab, 0x3, 0x2, 0x2, 0x2, 0x3b8, 0x3b9, 0x7, 0x21, |
| 0x2, 0x2, 0x3b9, 0xad, 0x3, 0x2, 0x2, 0x2, 0x3ba, 0x3be, 0x5, 0xb0, |
| 0x59, 0x2, 0x3bb, 0x3bd, 0x7, 0x49, 0x2, 0x2, 0x3bc, 0x3bb, 0x3, 0x2, |
| 0x2, 0x2, 0x3bd, 0x3c0, 0x3, 0x2, 0x2, 0x2, 0x3be, 0x3bc, 0x3, 0x2, |
| 0x2, 0x2, 0x3be, 0x3bf, 0x3, 0x2, 0x2, 0x2, 0x3bf, 0x3c1, 0x3, 0x2, |
| 0x2, 0x2, 0x3c0, 0x3be, 0x3, 0x2, 0x2, 0x2, 0x3c1, 0x3c2, 0x7, 0x50, |
| 0x2, 0x2, 0x3c2, 0xaf, 0x3, 0x2, 0x2, 0x2, 0x3c3, 0x3c4, 0x7, 0x22, |
| 0x2, 0x2, 0x3c4, 0xb1, 0x3, 0x2, 0x2, 0x2, 0x3c5, 0x3c9, 0x5, 0xb4, |
| 0x5b, 0x2, 0x3c6, 0x3c8, 0x7, 0x49, 0x2, 0x2, 0x3c7, 0x3c6, 0x3, 0x2, |
| 0x2, 0x2, 0x3c8, 0x3cb, 0x3, 0x2, 0x2, 0x2, 0x3c9, 0x3c7, 0x3, 0x2, |
| 0x2, 0x2, 0x3c9, 0x3ca, 0x3, 0x2, 0x2, 0x2, 0x3ca, 0x3cc, 0x3, 0x2, |
| 0x2, 0x2, 0x3cb, 0x3c9, 0x3, 0x2, 0x2, 0x2, 0x3cc, 0x3cd, 0x7, 0x50, |
| 0x2, 0x2, 0x3cd, 0xb3, 0x3, 0x2, 0x2, 0x2, 0x3ce, 0x3cf, 0x7, 0x1b, |
| 0x2, 0x2, 0x3cf, 0x3d0, 0x7, 0x49, 0x2, 0x2, 0x3d0, 0x3d1, 0x5, 0xe, |
| 0x8, 0x2, 0x3d1, 0xb5, 0x3, 0x2, 0x2, 0x2, 0x3d2, 0x3d6, 0x5, 0xb8, |
| 0x5d, 0x2, 0x3d3, 0x3d5, 0x7, 0x49, 0x2, 0x2, 0x3d4, 0x3d3, 0x3, 0x2, |
| 0x2, 0x2, 0x3d5, 0x3d8, 0x3, 0x2, 0x2, 0x2, 0x3d6, 0x3d4, 0x3, 0x2, |
| 0x2, 0x2, 0x3d6, 0x3d7, 0x3, 0x2, 0x2, 0x2, 0x3d7, 0x3d9, 0x3, 0x2, |
| 0x2, 0x2, 0x3d8, 0x3d6, 0x3, 0x2, 0x2, 0x2, 0x3d9, 0x3da, 0x7, 0x50, |
| 0x2, 0x2, 0x3da, 0xb7, 0x3, 0x2, 0x2, 0x2, 0x3db, 0x3dc, 0x7, 0x1a, |
| 0x2, 0x2, 0x3dc, 0x3e0, 0x7, 0x49, 0x2, 0x2, 0x3dd, 0x3e1, 0x5, 0xe, |
| 0x8, 0x2, 0x3de, 0x3e1, 0x7, 0x48, 0x2, 0x2, 0x3df, 0x3e1, 0x7, 0x4d, |
| 0x2, 0x2, 0x3e0, 0x3dd, 0x3, 0x2, 0x2, 0x2, 0x3e0, 0x3de, 0x3, 0x2, |
| 0x2, 0x2, 0x3e0, 0x3df, 0x3, 0x2, 0x2, 0x2, 0x3e1, 0xb9, 0x3, 0x2, 0x2, |
| 0x2, 0x3e2, 0x3e6, 0x5, 0xbc, 0x5f, 0x2, 0x3e3, 0x3e5, 0x7, 0x49, 0x2, |
| 0x2, 0x3e4, 0x3e3, 0x3, 0x2, 0x2, 0x2, 0x3e5, 0x3e8, 0x3, 0x2, 0x2, |
| 0x2, 0x3e6, 0x3e4, 0x3, 0x2, 0x2, 0x2, 0x3e6, 0x3e7, 0x3, 0x2, 0x2, |
| 0x2, 0x3e7, 0x3e9, 0x3, 0x2, 0x2, 0x2, 0x3e8, 0x3e6, 0x3, 0x2, 0x2, |
| 0x2, 0x3e9, 0x3ea, 0x7, 0x50, 0x2, 0x2, 0x3ea, 0xbb, 0x3, 0x2, 0x2, |
| 0x2, 0x3eb, 0x3ec, 0x7, 0x17, 0x2, 0x2, 0x3ec, 0x3ed, 0x7, 0x49, 0x2, |
| 0x2, 0x3ed, 0x3ee, 0x7, 0x48, 0x2, 0x2, 0x3ee, 0xbd, 0x3, 0x2, 0x2, |
| 0x2, 0x3ef, 0x3f3, 0x5, 0xc0, 0x61, 0x2, 0x3f0, 0x3f2, 0x7, 0x49, 0x2, |
| 0x2, 0x3f1, 0x3f0, 0x3, 0x2, 0x2, 0x2, 0x3f2, 0x3f5, 0x3, 0x2, 0x2, |
| 0x2, 0x3f3, 0x3f1, 0x3, 0x2, 0x2, 0x2, 0x3f3, 0x3f4, 0x3, 0x2, 0x2, |
| 0x2, 0x3f4, 0x3f6, 0x3, 0x2, 0x2, 0x2, 0x3f5, 0x3f3, 0x3, 0x2, 0x2, |
| 0x2, 0x3f6, 0x3f7, 0x7, 0x50, 0x2, 0x2, 0x3f7, 0xbf, 0x3, 0x2, 0x2, |
| 0x2, 0x3f8, 0x3f9, 0x7, 0x18, 0x2, 0x2, 0x3f9, 0xc1, 0x3, 0x2, 0x2, |
| 0x2, 0x3fa, 0x3fe, 0x5, 0xc4, 0x63, 0x2, 0x3fb, 0x3fd, 0x7, 0x49, 0x2, |
| 0x2, 0x3fc, 0x3fb, 0x3, 0x2, 0x2, 0x2, 0x3fd, 0x400, 0x3, 0x2, 0x2, |
| 0x2, 0x3fe, 0x3fc, 0x3, 0x2, 0x2, 0x2, 0x3fe, 0x3ff, 0x3, 0x2, 0x2, |
| 0x2, 0x3ff, 0x401, 0x3, 0x2, 0x2, 0x2, 0x400, 0x3fe, 0x3, 0x2, 0x2, |
| 0x2, 0x401, 0x402, 0x7, 0x50, 0x2, 0x2, 0x402, 0xc3, 0x3, 0x2, 0x2, |
| 0x2, 0x403, 0x404, 0x7, 0x1c, 0x2, 0x2, 0x404, 0xc5, 0x3, 0x2, 0x2, |
| 0x2, 0x405, 0x409, 0x5, 0xc8, 0x65, 0x2, 0x406, 0x408, 0x7, 0x49, 0x2, |
| 0x2, 0x407, 0x406, 0x3, 0x2, 0x2, 0x2, 0x408, 0x40b, 0x3, 0x2, 0x2, |
| 0x2, 0x409, 0x407, 0x3, 0x2, 0x2, 0x2, 0x409, 0x40a, 0x3, 0x2, 0x2, |
| 0x2, 0x40a, 0x40c, 0x3, 0x2, 0x2, 0x2, 0x40b, 0x409, 0x3, 0x2, 0x2, |
| 0x2, 0x40c, 0x40d, 0x7, 0x50, 0x2, 0x2, 0x40d, 0xc7, 0x3, 0x2, 0x2, |
| 0x2, 0x40e, 0x40f, 0x7, 0x1d, 0x2, 0x2, 0x40f, 0xc9, 0x3, 0x2, 0x2, |
| 0x2, 0x410, 0x414, 0x5, 0xcc, 0x67, 0x2, 0x411, 0x413, 0x7, 0x49, 0x2, |
| 0x2, 0x412, 0x411, 0x3, 0x2, 0x2, 0x2, 0x413, 0x416, 0x3, 0x2, 0x2, |
| 0x2, 0x414, 0x412, 0x3, 0x2, 0x2, 0x2, 0x414, 0x415, 0x3, 0x2, 0x2, |
| 0x2, 0x415, 0x417, 0x3, 0x2, 0x2, 0x2, 0x416, 0x414, 0x3, 0x2, 0x2, |
| 0x2, 0x417, 0x418, 0x7, 0x50, 0x2, 0x2, 0x418, 0xcb, 0x3, 0x2, 0x2, |
| 0x2, 0x419, 0x41a, 0x7, 0x1e, 0x2, 0x2, 0x41a, 0xcd, 0x3, 0x2, 0x2, |
| 0x2, 0x41b, 0x41f, 0x5, 0xd0, 0x69, 0x2, 0x41c, 0x41e, 0x7, 0x49, 0x2, |
| 0x2, 0x41d, 0x41c, 0x3, 0x2, 0x2, 0x2, 0x41e, 0x421, 0x3, 0x2, 0x2, |
| 0x2, 0x41f, 0x41d, 0x3, 0x2, 0x2, 0x2, 0x41f, 0x420, 0x3, 0x2, 0x2, |
| 0x2, 0x420, 0x422, 0x3, 0x2, 0x2, 0x2, 0x421, 0x41f, 0x3, 0x2, 0x2, |
| 0x2, 0x422, 0x423, 0x7, 0x50, 0x2, 0x2, 0x423, 0xcf, 0x3, 0x2, 0x2, |
| 0x2, 0x424, 0x425, 0x7, 0x1f, 0x2, 0x2, 0x425, 0xd1, 0x3, 0x2, 0x2, |
| 0x2, 0x426, 0x427, 0x7, 0x20, 0x2, 0x2, 0x427, 0xd3, 0x3, 0x2, 0x2, |
| 0x2, 0x428, 0x429, 0x7, 0x37, 0x2, 0x2, 0x429, 0xd5, 0x3, 0x2, 0x2, |
| 0x2, 0x42a, 0x42b, 0x7, 0x38, 0x2, 0x2, 0x42b, 0xd7, 0x3, 0x2, 0x2, |
| 0x2, 0x42c, 0x42d, 0x7, 0x39, 0x2, 0x2, 0x42d, 0xd9, 0x3, 0x2, 0x2, |
| 0x2, 0x42e, 0x42f, 0x7, 0x3a, 0x2, 0x2, 0x42f, 0xdb, 0x3, 0x2, 0x2, |
| 0x2, 0x430, 0x431, 0x7, 0x3b, 0x2, 0x2, 0x431, 0xdd, 0x3, 0x2, 0x2, |
| 0x2, 0x432, 0x433, 0x7, 0x3c, 0x2, 0x2, 0x433, 0xdf, 0x3, 0x2, 0x2, |
| 0x2, 0x434, 0x435, 0x7, 0x3d, 0x2, 0x2, 0x435, 0xe1, 0x3, 0x2, 0x2, |
| 0x2, 0x436, 0x437, 0x7, 0x3e, 0x2, 0x2, 0x437, 0xe3, 0x3, 0x2, 0x2, |
| 0x2, 0x438, 0x439, 0x7, 0x3f, 0x2, 0x2, 0x439, 0xe5, 0x3, 0x2, 0x2, |
| 0x2, 0x43a, 0x43b, 0x7, 0x40, 0x2, 0x2, 0x43b, 0xe7, 0x3, 0x2, 0x2, |
| 0x2, 0x43c, 0x43d, 0x7, 0x41, 0x2, 0x2, 0x43d, 0xe9, 0x3, 0x2, 0x2, |
| 0x2, 0x43e, 0x43f, 0x7, 0x42, 0x2, 0x2, 0x43f, 0xeb, 0x3, 0x2, 0x2, |
| 0x2, 0x440, 0x441, 0x7, 0x43, 0x2, 0x2, 0x441, 0xed, 0x3, 0x2, 0x2, |
| 0x2, 0x442, 0x443, 0x7, 0x44, 0x2, 0x2, 0x443, 0xef, 0x3, 0x2, 0x2, |
| 0x2, 0x444, 0x445, 0x7, 0x6, 0x2, 0x2, 0x445, 0x446, 0x7, 0x49, 0x2, |
| 0x2, 0x446, 0x44a, 0x9, 0x5, 0x2, 0x2, 0x447, 0x449, 0x7, 0x49, 0x2, |
| 0x2, 0x448, 0x447, 0x3, 0x2, 0x2, 0x2, 0x449, 0x44c, 0x3, 0x2, 0x2, |
| 0x2, 0x44a, 0x448, 0x3, 0x2, 0x2, 0x2, 0x44a, 0x44b, 0x3, 0x2, 0x2, |
| 0x2, 0x44b, 0x44d, 0x3, 0x2, 0x2, 0x2, 0x44c, 0x44a, 0x3, 0x2, 0x2, |
| 0x2, 0x44d, 0x44e, 0x7, 0x50, 0x2, 0x2, 0x44e, 0xf1, 0x3, 0x2, 0x2, |
| 0x2, 0x44f, 0x450, 0x7, 0x6, 0x2, 0x2, 0x450, 0x451, 0x7, 0x49, 0x2, |
| 0x2, 0x451, 0x455, 0x9, 0x5, 0x2, 0x2, 0x452, 0x454, 0x7, 0x49, 0x2, |
| 0x2, 0x453, 0x452, 0x3, 0x2, 0x2, 0x2, 0x454, 0x457, 0x3, 0x2, 0x2, |
| 0x2, 0x455, 0x453, 0x3, 0x2, 0x2, 0x2, 0x455, 0x456, 0x3, 0x2, 0x2, |
| 0x2, 0x456, 0x458, 0x3, 0x2, 0x2, 0x2, 0x457, 0x455, 0x3, 0x2, 0x2, |
| 0x2, 0x458, 0x459, 0x5, 0x104, 0x83, 0x2, 0x459, 0xf3, 0x3, 0x2, 0x2, |
| 0x2, 0x45a, 0x45b, 0x7, 0x6, 0x2, 0x2, 0x45b, 0x45c, 0x7, 0x49, 0x2, |
| 0x2, 0x45c, 0x45d, 0x9, 0x5, 0x2, 0x2, 0x45d, 0x461, 0x5, 0x102, 0x82, |
| 0x2, 0x45e, 0x460, 0x7, 0x49, 0x2, 0x2, 0x45f, 0x45e, 0x3, 0x2, 0x2, |
| 0x2, 0x460, 0x463, 0x3, 0x2, 0x2, 0x2, 0x461, 0x45f, 0x3, 0x2, 0x2, |
| 0x2, 0x461, 0x462, 0x3, 0x2, 0x2, 0x2, 0x462, 0x464, 0x3, 0x2, 0x2, |
| 0x2, 0x463, 0x461, 0x3, 0x2, 0x2, 0x2, 0x464, 0x465, 0x5, 0x104, 0x83, |
| 0x2, 0x465, 0xf5, 0x3, 0x2, 0x2, 0x2, 0x466, 0x467, 0x7, 0x6, 0x2, 0x2, |
| 0x467, 0x468, 0x7, 0x49, 0x2, 0x2, 0x468, 0x469, 0x9, 0x5, 0x2, 0x2, |
| 0x469, 0x46a, 0x7, 0x49, 0x2, 0x2, 0x46a, 0x46b, 0x5, 0x10a, 0x86, 0x2, |
| 0x46b, 0x46c, 0x9, 0x4, 0x2, 0x2, 0x46c, 0x478, 0x3, 0x2, 0x2, 0x2, |
| 0x46d, 0x46e, 0x7, 0x6, 0x2, 0x2, 0x46e, 0x46f, 0x7, 0x49, 0x2, 0x2, |
| 0x46f, 0x473, 0x9, 0x5, 0x2, 0x2, 0x470, 0x472, 0x7, 0x49, 0x2, 0x2, |
| 0x471, 0x470, 0x3, 0x2, 0x2, 0x2, 0x472, 0x475, 0x3, 0x2, 0x2, 0x2, |
| 0x473, 0x471, 0x3, 0x2, 0x2, 0x2, 0x473, 0x474, 0x3, 0x2, 0x2, 0x2, |
| 0x474, 0x476, 0x3, 0x2, 0x2, 0x2, 0x475, 0x473, 0x3, 0x2, 0x2, 0x2, |
| 0x476, 0x478, 0x7, 0x50, 0x2, 0x2, 0x477, 0x466, 0x3, 0x2, 0x2, 0x2, |
| 0x477, 0x46d, 0x3, 0x2, 0x2, 0x2, 0x478, 0xf7, 0x3, 0x2, 0x2, 0x2, 0x479, |
| 0x47a, 0x7, 0x6, 0x2, 0x2, 0x47a, 0x47b, 0x7, 0x49, 0x2, 0x2, 0x47b, |
| 0x47c, 0x9, 0x5, 0x2, 0x2, 0x47c, 0x47d, 0x5, 0x102, 0x82, 0x2, 0x47d, |
| 0x47e, 0x7, 0x49, 0x2, 0x2, 0x47e, 0x47f, 0x5, 0x10a, 0x86, 0x2, 0x47f, |
| 0x480, 0x9, 0x4, 0x2, 0x2, 0x480, 0x48e, 0x3, 0x2, 0x2, 0x2, 0x481, |
| 0x482, 0x7, 0x6, 0x2, 0x2, 0x482, 0x483, 0x7, 0x49, 0x2, 0x2, 0x483, |
| 0x484, 0x9, 0x5, 0x2, 0x2, 0x484, 0x488, 0x5, 0x102, 0x82, 0x2, 0x485, |
| 0x487, 0x7, 0x49, 0x2, 0x2, 0x486, 0x485, 0x3, 0x2, 0x2, 0x2, 0x487, |
| 0x48a, 0x3, 0x2, 0x2, 0x2, 0x488, 0x486, 0x3, 0x2, 0x2, 0x2, 0x488, |
| 0x489, 0x3, 0x2, 0x2, 0x2, 0x489, 0x48b, 0x3, 0x2, 0x2, 0x2, 0x48a, |
| 0x488, 0x3, 0x2, 0x2, 0x2, 0x48b, 0x48c, 0x7, 0x50, 0x2, 0x2, 0x48c, |
| 0x48e, 0x3, 0x2, 0x2, 0x2, 0x48d, 0x479, 0x3, 0x2, 0x2, 0x2, 0x48d, |
| 0x481, 0x3, 0x2, 0x2, 0x2, 0x48e, 0xf9, 0x3, 0x2, 0x2, 0x2, 0x48f, 0x491, |
| 0x7, 0x48, 0x2, 0x2, 0x490, 0x492, 0x7, 0x53, 0x2, 0x2, 0x491, 0x490, |
| 0x3, 0x2, 0x2, 0x2, 0x491, 0x492, 0x3, 0x2, 0x2, 0x2, 0x492, 0x494, |
| 0x3, 0x2, 0x2, 0x2, 0x493, 0x48f, 0x3, 0x2, 0x2, 0x2, 0x494, 0x497, |
| 0x3, 0x2, 0x2, 0x2, 0x495, 0x493, 0x3, 0x2, 0x2, 0x2, 0x495, 0x496, |
| 0x3, 0x2, 0x2, 0x2, 0x496, 0xfb, 0x3, 0x2, 0x2, 0x2, 0x497, 0x495, 0x3, |
| 0x2, 0x2, 0x2, 0x498, 0x499, 0x7, 0x6, 0x2, 0x2, 0x499, 0x49c, 0x7, |
| 0x49, 0x2, 0x2, 0x49a, 0x49d, 0x5, 0xfa, 0x7e, 0x2, 0x49b, 0x49d, 0x7, |
| 0x59, 0x2, 0x2, 0x49c, 0x49a, 0x3, 0x2, 0x2, 0x2, 0x49c, 0x49b, 0x3, |
| 0x2, 0x2, 0x2, 0x49d, 0x49e, 0x3, 0x2, 0x2, 0x2, 0x49e, 0x49f, 0x7, |
| 0x49, 0x2, 0x2, 0x49f, 0x4b5, 0x5, 0x10c, 0x87, 0x2, 0x4a0, 0x4a1, 0x7, |
| 0x6, 0x2, 0x2, 0x4a1, 0x4a4, 0x7, 0x49, 0x2, 0x2, 0x4a2, 0x4a5, 0x5, |
| 0xfa, 0x7e, 0x2, 0x4a3, 0x4a5, 0x7, 0x59, 0x2, 0x2, 0x4a4, 0x4a2, 0x3, |
| 0x2, 0x2, 0x2, 0x4a4, 0x4a3, 0x3, 0x2, 0x2, 0x2, 0x4a5, 0x4a9, 0x3, |
| 0x2, 0x2, 0x2, 0x4a6, 0x4a8, 0x7, 0x49, 0x2, 0x2, 0x4a7, 0x4a6, 0x3, |
| 0x2, 0x2, 0x2, 0x4a8, 0x4ab, 0x3, 0x2, 0x2, 0x2, 0x4a9, 0x4a7, 0x3, |
| 0x2, 0x2, 0x2, 0x4a9, 0x4aa, 0x3, 0x2, 0x2, 0x2, 0x4aa, 0x4b5, 0x3, |
| 0x2, 0x2, 0x2, 0x4ab, 0x4a9, 0x3, 0x2, 0x2, 0x2, 0x4ac, 0x4ad, 0x7, |
| 0x6, 0x2, 0x2, 0x4ad, 0x4b0, 0x7, 0x49, 0x2, 0x2, 0x4ae, 0x4b1, 0x5, |
| 0xfa, 0x7e, 0x2, 0x4af, 0x4b1, 0x7, 0x59, 0x2, 0x2, 0x4b0, 0x4ae, 0x3, |
| 0x2, 0x2, 0x2, 0x4b0, 0x4af, 0x3, 0x2, 0x2, 0x2, 0x4b1, 0x4b2, 0x3, |
| 0x2, 0x2, 0x2, 0x4b2, 0x4b3, 0x7, 0x5, 0x2, 0x2, 0x4b3, 0x4b5, 0x5, |
| 0x10c, 0x87, 0x2, 0x4b4, 0x498, 0x3, 0x2, 0x2, 0x2, 0x4b4, 0x4a0, 0x3, |
| 0x2, 0x2, 0x2, 0x4b4, 0x4ac, 0x3, 0x2, 0x2, 0x2, 0x4b5, 0xfd, 0x3, 0x2, |
| 0x2, 0x2, 0x4b6, 0x4b7, 0x7, 0x6, 0x2, 0x2, 0x4b7, 0x4ba, 0x7, 0x49, |
| 0x2, 0x2, 0x4b8, 0x4bb, 0x5, 0xfa, 0x7e, 0x2, 0x4b9, 0x4bb, 0x7, 0x59, |
| 0x2, 0x2, 0x4ba, 0x4b8, 0x3, 0x2, 0x2, 0x2, 0x4ba, 0x4b9, 0x3, 0x2, |
| 0x2, 0x2, 0x4bb, 0x4bc, 0x3, 0x2, 0x2, 0x2, 0x4bc, 0x4bd, 0x5, 0x102, |
| 0x82, 0x2, 0x4bd, 0x4be, 0x7, 0x49, 0x2, 0x2, 0x4be, 0x4bf, 0x5, 0x10c, |
| 0x87, 0x2, 0x4bf, 0x4c8, 0x3, 0x2, 0x2, 0x2, 0x4c0, 0x4c1, 0x7, 0x6, |
| 0x2, 0x2, 0x4c1, 0x4c4, 0x7, 0x49, 0x2, 0x2, 0x4c2, 0x4c5, 0x5, 0xfa, |
| 0x7e, 0x2, 0x4c3, 0x4c5, 0x7, 0x59, 0x2, 0x2, 0x4c4, 0x4c2, 0x3, 0x2, |
| 0x2, 0x2, 0x4c4, 0x4c3, 0x3, 0x2, 0x2, 0x2, 0x4c5, 0x4c6, 0x3, 0x2, |
| 0x2, 0x2, 0x4c6, 0x4c8, 0x5, 0x102, 0x82, 0x2, 0x4c7, 0x4b6, 0x3, 0x2, |
| 0x2, 0x2, 0x4c7, 0x4c0, 0x3, 0x2, 0x2, 0x2, 0x4c8, 0xff, 0x3, 0x2, 0x2, |
| 0x2, 0x4c9, 0x4fc, 0x5, 0x5c, 0x2f, 0x2, 0x4ca, 0x4fc, 0x5, 0x60, 0x31, |
| 0x2, 0x4cb, 0x4fc, 0x5, 0x1e, 0x10, 0x2, 0x4cc, 0x4fc, 0x5, 0x28, 0x15, |
| 0x2, 0x4cd, 0x4fc, 0x5, 0x2c, 0x17, 0x2, 0x4ce, 0x4fc, 0x5, 0x32, 0x1a, |
| 0x2, 0x4cf, 0x4fc, 0x5, 0x44, 0x23, 0x2, 0x4d0, 0x4fc, 0x5, 0x38, 0x1d, |
| 0x2, 0x4d1, 0x4fc, 0x5, 0x3e, 0x20, 0x2, 0x4d2, 0x4fc, 0x5, 0x48, 0x25, |
| 0x2, 0x4d3, 0x4fc, 0x5, 0x16, 0xc, 0x2, 0x4d4, 0x4fc, 0x5, 0x4c, 0x27, |
| 0x2, 0x4d5, 0x4fc, 0x5, 0x26, 0x14, 0x2, 0x4d6, 0x4fc, 0x5, 0xbc, 0x5f, |
| 0x2, 0x4d7, 0x4fc, 0x5, 0xc0, 0x61, 0x2, 0x4d8, 0x4fc, 0x5, 0x1a, 0xe, |
| 0x2, 0x4d9, 0x4fc, 0x5, 0xb8, 0x5d, 0x2, 0x4da, 0x4fc, 0x5, 0xb4, 0x5b, |
| 0x2, 0x4db, 0x4fc, 0x5, 0xc4, 0x63, 0x2, 0x4dc, 0x4fc, 0x5, 0xc8, 0x65, |
| 0x2, 0x4dd, 0x4fc, 0x5, 0xcc, 0x67, 0x2, 0x4de, 0x4fc, 0x5, 0xd0, 0x69, |
| 0x2, 0x4df, 0x4fc, 0x5, 0x64, 0x33, 0x2, 0x4e0, 0x4fc, 0x5, 0x68, 0x35, |
| 0x2, 0x4e1, 0x4fc, 0x5, 0x6c, 0x37, 0x2, 0x4e2, 0x4fc, 0x5, 0x70, 0x39, |
| 0x2, 0x4e3, 0x4fc, 0x5, 0x74, 0x3b, 0x2, 0x4e4, 0x4fc, 0x5, 0x78, 0x3d, |
| 0x2, 0x4e5, 0x4fc, 0x5, 0x7c, 0x3f, 0x2, 0x4e6, 0x4fc, 0x5, 0x9c, 0x4f, |
| 0x2, 0x4e7, 0x4fc, 0x5, 0xa0, 0x51, 0x2, 0x4e8, 0x4fc, 0x5, 0xa4, 0x53, |
| 0x2, 0x4e9, 0x4fc, 0x5, 0xa8, 0x55, 0x2, 0x4ea, 0x4fc, 0x5, 0xac, 0x57, |
| 0x2, 0x4eb, 0x4fc, 0x5, 0xb0, 0x59, 0x2, 0x4ec, 0x4fc, 0x5, 0xd2, 0x6a, |
| 0x2, 0x4ed, 0x4fc, 0x5, 0x80, 0x41, 0x2, 0x4ee, 0x4fc, 0x5, 0x84, 0x43, |
| 0x2, 0x4ef, 0x4fc, 0x5, 0x88, 0x45, 0x2, 0x4f0, 0x4fc, 0x5, 0x8c, 0x47, |
| 0x2, 0x4f1, 0x4fc, 0x5, 0x90, 0x49, 0x2, 0x4f2, 0x4fc, 0x5, 0x94, 0x4b, |
| 0x2, 0x4f3, 0x4fc, 0x5, 0x98, 0x4d, 0x2, 0x4f4, 0x4fc, 0x5, 0x20, 0x11, |
| 0x2, 0x4f5, 0x4fc, 0x5, 0x22, 0x12, 0x2, 0x4f6, 0x4fc, 0x5, 0xe4, 0x73, |
| 0x2, 0x4f7, 0x4fc, 0x5, 0xe6, 0x74, 0x2, 0x4f8, 0x4fc, 0x5, 0xfe, 0x80, |
| 0x2, 0x4f9, 0x4fc, 0x5, 0xfc, 0x7f, 0x2, 0x4fa, 0x4fc, 0x5, 0x10, 0x9, |
| 0x2, 0x4fb, 0x4c9, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4ca, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4cb, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4cc, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4cd, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4ce, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4cf, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4d0, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4d1, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4d2, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4d3, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4d4, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4d5, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4d6, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4d7, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4d8, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4d9, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4da, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4db, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4dc, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4dd, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4de, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4df, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4e0, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4e1, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4e2, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4e3, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4e4, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4e5, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4e6, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4e7, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4e8, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4e9, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4ea, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4eb, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4ec, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4ed, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4ee, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4ef, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4f0, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4f1, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4f2, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4f3, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4f4, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4f5, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4f6, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4f7, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4f8, 0x3, 0x2, 0x2, |
| 0x2, 0x4fb, 0x4f9, 0x3, 0x2, 0x2, 0x2, 0x4fb, 0x4fa, 0x3, 0x2, 0x2, |
| 0x2, 0x4fc, 0x101, 0x3, 0x2, 0x2, 0x2, 0x4fd, 0x532, 0x7, 0x54, 0x2, |
| 0x2, 0x4fe, 0x502, 0x7, 0x48, 0x2, 0x2, 0x4ff, 0x501, 0x7, 0x49, 0x2, |
| 0x2, 0x500, 0x4ff, 0x3, 0x2, 0x2, 0x2, 0x501, 0x504, 0x3, 0x2, 0x2, |
| 0x2, 0x502, 0x500, 0x3, 0x2, 0x2, 0x2, 0x502, 0x503, 0x3, 0x2, 0x2, |
| 0x2, 0x503, 0x50e, 0x3, 0x2, 0x2, 0x2, 0x504, 0x502, 0x3, 0x2, 0x2, |
| 0x2, 0x505, 0x509, 0x7, 0x57, 0x2, 0x2, 0x506, 0x508, 0x5, 0x11a, 0x8e, |
| 0x2, 0x507, 0x506, 0x3, 0x2, 0x2, 0x2, 0x508, 0x50b, 0x3, 0x2, 0x2, |
| 0x2, 0x509, 0x507, 0x3, 0x2, 0x2, 0x2, 0x509, 0x50a, 0x3, 0x2, 0x2, |
| 0x2, 0x50a, 0x50d, 0x3, 0x2, 0x2, 0x2, 0x50b, 0x509, 0x3, 0x2, 0x2, |
| 0x2, 0x50c, 0x505, 0x3, 0x2, 0x2, 0x2, 0x50d, 0x510, 0x3, 0x2, 0x2, |
| 0x2, 0x50e, 0x50c, 0x3, 0x2, 0x2, 0x2, 0x50e, 0x50f, 0x3, 0x2, 0x2, |
| 0x2, 0x50f, 0x52d, 0x3, 0x2, 0x2, 0x2, 0x510, 0x50e, 0x3, 0x2, 0x2, |
| 0x2, 0x511, 0x515, 0x7, 0x56, 0x2, 0x2, 0x512, 0x514, 0x7, 0x49, 0x2, |
| 0x2, 0x513, 0x512, 0x3, 0x2, 0x2, 0x2, 0x514, 0x517, 0x3, 0x2, 0x2, |
| 0x2, 0x515, 0x513, 0x3, 0x2, 0x2, 0x2, 0x515, 0x516, 0x3, 0x2, 0x2, |
| 0x2, 0x516, 0x518, 0x3, 0x2, 0x2, 0x2, 0x517, 0x515, 0x3, 0x2, 0x2, |
| 0x2, 0x518, 0x51c, 0x7, 0x48, 0x2, 0x2, 0x519, 0x51b, 0x7, 0x49, 0x2, |
| 0x2, 0x51a, 0x519, 0x3, 0x2, 0x2, 0x2, 0x51b, 0x51e, 0x3, 0x2, 0x2, |
| 0x2, 0x51c, 0x51a, 0x3, 0x2, 0x2, 0x2, 0x51c, 0x51d, 0x3, 0x2, 0x2, |
| 0x2, 0x51d, 0x528, 0x3, 0x2, 0x2, 0x2, 0x51e, 0x51c, 0x3, 0x2, 0x2, |
| 0x2, 0x51f, 0x523, 0x7, 0x57, 0x2, 0x2, 0x520, 0x522, 0x5, 0x11a, 0x8e, |
| 0x2, 0x521, 0x520, 0x3, 0x2, 0x2, 0x2, 0x522, 0x525, 0x3, 0x2, 0x2, |
| 0x2, 0x523, 0x521, 0x3, 0x2, 0x2, 0x2, 0x523, 0x524, 0x3, 0x2, 0x2, |
| 0x2, 0x524, 0x527, 0x3, 0x2, 0x2, 0x2, 0x525, 0x523, 0x3, 0x2, 0x2, |
| 0x2, 0x526, 0x51f, 0x3, 0x2, 0x2, 0x2, 0x527, 0x52a, 0x3, 0x2, 0x2, |
| 0x2, 0x528, 0x526, 0x3, 0x2, 0x2, 0x2, 0x528, 0x529, 0x3, 0x2, 0x2, |
| 0x2, 0x529, 0x52c, 0x3, 0x2, 0x2, 0x2, 0x52a, 0x528, 0x3, 0x2, 0x2, |
| 0x2, 0x52b, 0x511, 0x3, 0x2, 0x2, 0x2, 0x52c, 0x52f, 0x3, 0x2, 0x2, |
| 0x2, 0x52d, 0x52b, 0x3, 0x2, 0x2, 0x2, 0x52d, 0x52e, 0x3, 0x2, 0x2, |
| 0x2, 0x52e, 0x531, 0x3, 0x2, 0x2, 0x2, 0x52f, 0x52d, 0x3, 0x2, 0x2, |
| 0x2, 0x530, 0x4fe, 0x3, 0x2, 0x2, 0x2, 0x531, 0x534, 0x3, 0x2, 0x2, |
| 0x2, 0x532, 0x530, 0x3, 0x2, 0x2, 0x2, 0x532, 0x533, 0x3, 0x2, 0x2, |
| 0x2, 0x533, 0x535, 0x3, 0x2, 0x2, 0x2, 0x534, 0x532, 0x3, 0x2, 0x2, |
| 0x2, 0x535, 0x536, 0x7, 0x55, 0x2, 0x2, 0x536, 0x103, 0x3, 0x2, 0x2, |
| 0x2, 0x537, 0x53a, 0x5, 0x106, 0x84, 0x2, 0x538, 0x53a, 0x5, 0x108, |
| 0x85, 0x2, 0x539, 0x537, 0x3, 0x2, 0x2, 0x2, 0x539, 0x538, 0x3, 0x2, |
| 0x2, 0x2, 0x53a, 0x105, 0x3, 0x2, 0x2, 0x2, 0x53b, 0x558, 0x5, 0x8, |
| 0x5, 0x2, 0x53c, 0x558, 0x7, 0x45, 0x2, 0x2, 0x53d, 0x558, 0x7, 0x46, |
| 0x2, 0x2, 0x53e, 0x558, 0x5, 0x118, 0x8d, 0x2, 0x53f, 0x558, 0x7, 0x48, |
| 0x2, 0x2, 0x540, 0x558, 0x5, 0xe, 0x8, 0x2, 0x541, 0x558, 0x7, 0x4e, |
| 0x2, 0x2, 0x542, 0x558, 0x5, 0x10, 0x9, 0x2, 0x543, 0x558, 0x7, 0x4f, |
| 0x2, 0x2, 0x544, 0x558, 0x7, 0x54, 0x2, 0x2, 0x545, 0x558, 0x7, 0x55, |
| 0x2, 0x2, 0x546, 0x558, 0x7, 0x56, 0x2, 0x2, 0x547, 0x558, 0x7, 0x57, |
| 0x2, 0x2, 0x548, 0x558, 0x7, 0x58, 0x2, 0x2, 0x549, 0x558, 0x7, 0x5, |
| 0x2, 0x2, 0x54a, 0x558, 0x5, 0x100, 0x81, 0x2, 0x54b, 0x558, 0x7, 0x49, |
| 0x2, 0x2, 0x54c, 0x558, 0x7, 0x4d, 0x2, 0x2, 0x54d, 0x558, 0x7, 0x47, |
| 0x2, 0x2, 0x54e, 0x558, 0x5, 0xc, 0x7, 0x2, 0x54f, 0x558, 0x7, 0x51, |
| 0x2, 0x2, 0x550, 0x558, 0x7, 0x52, 0x2, 0x2, 0x551, 0x558, 0x7, 0x53, |
| 0x2, 0x2, 0x552, 0x558, 0x7, 0x5e, 0x2, 0x2, 0x553, 0x558, 0x7, 0x5a, |
| 0x2, 0x2, 0x554, 0x558, 0x7, 0x5b, 0x2, 0x2, 0x555, 0x558, 0x7, 0x5c, |
| 0x2, 0x2, 0x556, 0x558, 0x7, 0x5d, 0x2, 0x2, 0x557, 0x53b, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x53c, 0x3, 0x2, 0x2, 0x2, 0x557, 0x53d, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x53e, 0x3, 0x2, 0x2, 0x2, 0x557, 0x53f, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x540, 0x3, 0x2, 0x2, 0x2, 0x557, 0x541, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x542, 0x3, 0x2, 0x2, 0x2, 0x557, 0x543, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x544, 0x3, 0x2, 0x2, 0x2, 0x557, 0x545, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x546, 0x3, 0x2, 0x2, 0x2, 0x557, 0x547, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x548, 0x3, 0x2, 0x2, 0x2, 0x557, 0x549, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x54a, 0x3, 0x2, 0x2, 0x2, 0x557, 0x54b, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x54c, 0x3, 0x2, 0x2, 0x2, 0x557, 0x54d, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x54e, 0x3, 0x2, 0x2, 0x2, 0x557, 0x54f, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x550, 0x3, 0x2, 0x2, 0x2, 0x557, 0x551, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x552, 0x3, 0x2, 0x2, 0x2, 0x557, 0x553, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x554, 0x3, 0x2, 0x2, 0x2, 0x557, 0x555, 0x3, 0x2, |
| 0x2, 0x2, 0x557, 0x556, 0x3, 0x2, 0x2, 0x2, 0x558, 0x55b, 0x3, 0x2, |
| 0x2, 0x2, 0x559, 0x55a, 0x3, 0x2, 0x2, 0x2, 0x559, 0x557, 0x3, 0x2, |
| 0x2, 0x2, 0x55a, 0x55c, 0x3, 0x2, 0x2, 0x2, 0x55b, 0x559, 0x3, 0x2, |
| 0x2, 0x2, 0x55c, 0x560, 0x7, 0x4f, 0x2, 0x2, 0x55d, 0x55f, 0x7, 0x49, |
| 0x2, 0x2, 0x55e, 0x55d, 0x3, 0x2, 0x2, 0x2, 0x55f, 0x562, 0x3, 0x2, |
| 0x2, 0x2, 0x560, 0x55e, 0x3, 0x2, 0x2, 0x2, 0x560, 0x561, 0x3, 0x2, |
| 0x2, 0x2, 0x561, 0x563, 0x3, 0x2, 0x2, 0x2, 0x562, 0x560, 0x3, 0x2, |
| 0x2, 0x2, 0x563, 0x564, 0x9, 0x6, 0x2, 0x2, 0x564, 0x107, 0x3, 0x2, |
| 0x2, 0x2, 0x565, 0x582, 0x5, 0x8, 0x5, 0x2, 0x566, 0x582, 0x7, 0x45, |
| 0x2, 0x2, 0x567, 0x582, 0x7, 0x46, 0x2, 0x2, 0x568, 0x582, 0x5, 0x118, |
| 0x8d, 0x2, 0x569, 0x582, 0x7, 0x48, 0x2, 0x2, 0x56a, 0x582, 0x5, 0xe, |
| 0x8, 0x2, 0x56b, 0x582, 0x7, 0x4e, 0x2, 0x2, 0x56c, 0x582, 0x5, 0x10, |
| 0x9, 0x2, 0x56d, 0x582, 0x7, 0x4f, 0x2, 0x2, 0x56e, 0x582, 0x7, 0x54, |
| 0x2, 0x2, 0x56f, 0x582, 0x7, 0x55, 0x2, 0x2, 0x570, 0x582, 0x7, 0x56, |
| 0x2, 0x2, 0x571, 0x582, 0x7, 0x57, 0x2, 0x2, 0x572, 0x582, 0x7, 0x58, |
| 0x2, 0x2, 0x573, 0x582, 0x7, 0x5, 0x2, 0x2, 0x574, 0x582, 0x5, 0x100, |
| 0x81, 0x2, 0x575, 0x582, 0x7, 0x49, 0x2, 0x2, 0x576, 0x582, 0x7, 0x4d, |
| 0x2, 0x2, 0x577, 0x582, 0x7, 0x47, 0x2, 0x2, 0x578, 0x582, 0x5, 0xc, |
| 0x7, 0x2, 0x579, 0x582, 0x7, 0x51, 0x2, 0x2, 0x57a, 0x582, 0x7, 0x52, |
| 0x2, 0x2, 0x57b, 0x582, 0x7, 0x53, 0x2, 0x2, 0x57c, 0x582, 0x7, 0x5e, |
| 0x2, 0x2, 0x57d, 0x582, 0x7, 0x5a, 0x2, 0x2, 0x57e, 0x582, 0x7, 0x5b, |
| 0x2, 0x2, 0x57f, 0x582, 0x7, 0x5c, 0x2, 0x2, 0x580, 0x582, 0x7, 0x5d, |
| 0x2, 0x2, 0x581, 0x565, 0x3, 0x2, 0x2, 0x2, 0x581, 0x566, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x567, 0x3, 0x2, 0x2, 0x2, 0x581, 0x568, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x569, 0x3, 0x2, 0x2, 0x2, 0x581, 0x56a, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x56b, 0x3, 0x2, 0x2, 0x2, 0x581, 0x56c, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x56d, 0x3, 0x2, 0x2, 0x2, 0x581, 0x56e, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x56f, 0x3, 0x2, 0x2, 0x2, 0x581, 0x570, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x571, 0x3, 0x2, 0x2, 0x2, 0x581, 0x572, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x573, 0x3, 0x2, 0x2, 0x2, 0x581, 0x574, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x575, 0x3, 0x2, 0x2, 0x2, 0x581, 0x576, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x577, 0x3, 0x2, 0x2, 0x2, 0x581, 0x578, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x579, 0x3, 0x2, 0x2, 0x2, 0x581, 0x57a, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x57b, 0x3, 0x2, 0x2, 0x2, 0x581, 0x57c, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x57d, 0x3, 0x2, 0x2, 0x2, 0x581, 0x57e, 0x3, 0x2, |
| 0x2, 0x2, 0x581, 0x57f, 0x3, 0x2, 0x2, 0x2, 0x581, 0x580, 0x3, 0x2, |
| 0x2, 0x2, 0x582, 0x585, 0x3, 0x2, 0x2, 0x2, 0x583, 0x584, 0x3, 0x2, |
| 0x2, 0x2, 0x583, 0x581, 0x3, 0x2, 0x2, 0x2, 0x584, 0x58e, 0x3, 0x2, |
| 0x2, 0x2, 0x585, 0x583, 0x3, 0x2, 0x2, 0x2, 0x586, 0x58a, 0x7, 0x50, |
| 0x2, 0x2, 0x587, 0x589, 0x7, 0x49, 0x2, 0x2, 0x588, 0x587, 0x3, 0x2, |
| 0x2, 0x2, 0x589, 0x58c, 0x3, 0x2, 0x2, 0x2, 0x58a, 0x588, 0x3, 0x2, |
| 0x2, 0x2, 0x58a, 0x58b, 0x3, 0x2, 0x2, 0x2, 0x58b, 0x58f, 0x3, 0x2, |
| 0x2, 0x2, 0x58c, 0x58a, 0x3, 0x2, 0x2, 0x2, 0x58d, 0x58f, 0x7, 0x2, |
| 0x2, 0x3, 0x58e, 0x586, 0x3, 0x2, 0x2, 0x2, 0x58e, 0x58d, 0x3, 0x2, |
| 0x2, 0x2, 0x58f, 0x109, 0x3, 0x2, 0x2, 0x2, 0x590, 0x5ab, 0x5, 0x8, |
| 0x5, 0x2, 0x591, 0x5ab, 0x7, 0x45, 0x2, 0x2, 0x592, 0x5ab, 0x7, 0x46, |
| 0x2, 0x2, 0x593, 0x5ab, 0x5, 0x118, 0x8d, 0x2, 0x594, 0x5ab, 0x7, 0x48, |
| 0x2, 0x2, 0x595, 0x5ab, 0x5, 0xe, 0x8, 0x2, 0x596, 0x5ab, 0x5, 0x10, |
| 0x9, 0x2, 0x597, 0x5ab, 0x7, 0x4e, 0x2, 0x2, 0x598, 0x5ab, 0x7, 0x54, |
| 0x2, 0x2, 0x599, 0x5ab, 0x7, 0x55, 0x2, 0x2, 0x59a, 0x5ab, 0x7, 0x56, |
| 0x2, 0x2, 0x59b, 0x5ab, 0x7, 0x57, 0x2, 0x2, 0x59c, 0x5ab, 0x7, 0x58, |
| 0x2, 0x2, 0x59d, 0x5ab, 0x7, 0x5, 0x2, 0x2, 0x59e, 0x5ab, 0x7, 0x49, |
| 0x2, 0x2, 0x59f, 0x5ab, 0x7, 0x4d, 0x2, 0x2, 0x5a0, 0x5ab, 0x7, 0x47, |
| 0x2, 0x2, 0x5a1, 0x5ab, 0x5, 0xc, 0x7, 0x2, 0x5a2, 0x5ab, 0x7, 0x51, |
| 0x2, 0x2, 0x5a3, 0x5ab, 0x7, 0x52, 0x2, 0x2, 0x5a4, 0x5ab, 0x7, 0x53, |
| 0x2, 0x2, 0x5a5, 0x5ab, 0x7, 0x5e, 0x2, 0x2, 0x5a6, 0x5ab, 0x7, 0x5a, |
| 0x2, 0x2, 0x5a7, 0x5ab, 0x7, 0x5b, 0x2, 0x2, 0x5a8, 0x5ab, 0x7, 0x5c, |
| 0x2, 0x2, 0x5a9, 0x5ab, 0x7, 0x5d, 0x2, 0x2, 0x5aa, 0x590, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x591, 0x3, 0x2, 0x2, 0x2, 0x5aa, 0x592, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x593, 0x3, 0x2, 0x2, 0x2, 0x5aa, 0x594, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x595, 0x3, 0x2, 0x2, 0x2, 0x5aa, 0x596, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x597, 0x3, 0x2, 0x2, 0x2, 0x5aa, 0x598, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x599, 0x3, 0x2, 0x2, 0x2, 0x5aa, 0x59a, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x59b, 0x3, 0x2, 0x2, 0x2, 0x5aa, 0x59c, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x59d, 0x3, 0x2, 0x2, 0x2, 0x5aa, 0x59e, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x59f, 0x3, 0x2, 0x2, 0x2, 0x5aa, 0x5a0, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x5a1, 0x3, 0x2, 0x2, 0x2, 0x5aa, 0x5a2, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x5a3, 0x3, 0x2, 0x2, 0x2, 0x5aa, 0x5a4, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x5a5, 0x3, 0x2, 0x2, 0x2, 0x5aa, 0x5a6, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x5a7, 0x3, 0x2, 0x2, 0x2, 0x5aa, 0x5a8, 0x3, 0x2, |
| 0x2, 0x2, 0x5aa, 0x5a9, 0x3, 0x2, 0x2, 0x2, 0x5ab, 0x5ae, 0x3, 0x2, |
| 0x2, 0x2, 0x5ac, 0x5ad, 0x3, 0x2, 0x2, 0x2, 0x5ac, 0x5aa, 0x3, 0x2, |
| 0x2, 0x2, 0x5ad, 0x10b, 0x3, 0x2, 0x2, 0x2, 0x5ae, 0x5ac, 0x3, 0x2, |
| 0x2, 0x2, 0x5af, 0x5ca, 0x5, 0x8, 0x5, 0x2, 0x5b0, 0x5ca, 0x7, 0x45, |
| 0x2, 0x2, 0x5b1, 0x5ca, 0x7, 0x46, 0x2, 0x2, 0x5b2, 0x5ca, 0x5, 0x118, |
| 0x8d, 0x2, 0x5b3, 0x5ca, 0x7, 0x48, 0x2, 0x2, 0x5b4, 0x5ca, 0x5, 0xe, |
| 0x8, 0x2, 0x5b5, 0x5ca, 0x5, 0x10, 0x9, 0x2, 0x5b6, 0x5ca, 0x7, 0x4e, |
| 0x2, 0x2, 0x5b7, 0x5ca, 0x7, 0x54, 0x2, 0x2, 0x5b8, 0x5ca, 0x7, 0x55, |
| 0x2, 0x2, 0x5b9, 0x5ca, 0x7, 0x56, 0x2, 0x2, 0x5ba, 0x5ca, 0x7, 0x57, |
| 0x2, 0x2, 0x5bb, 0x5ca, 0x7, 0x58, 0x2, 0x2, 0x5bc, 0x5ca, 0x7, 0x5, |
| 0x2, 0x2, 0x5bd, 0x5ca, 0x7, 0x49, 0x2, 0x2, 0x5be, 0x5ca, 0x7, 0x4d, |
| 0x2, 0x2, 0x5bf, 0x5ca, 0x7, 0x47, 0x2, 0x2, 0x5c0, 0x5ca, 0x5, 0xc, |
| 0x7, 0x2, 0x5c1, 0x5ca, 0x7, 0x51, 0x2, 0x2, 0x5c2, 0x5ca, 0x7, 0x52, |
| 0x2, 0x2, 0x5c3, 0x5ca, 0x7, 0x53, 0x2, 0x2, 0x5c4, 0x5ca, 0x7, 0x5e, |
| 0x2, 0x2, 0x5c5, 0x5ca, 0x7, 0x5a, 0x2, 0x2, 0x5c6, 0x5ca, 0x7, 0x5b, |
| 0x2, 0x2, 0x5c7, 0x5ca, 0x7, 0x5c, 0x2, 0x2, 0x5c8, 0x5ca, 0x7, 0x5d, |
| 0x2, 0x2, 0x5c9, 0x5af, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5b0, 0x3, 0x2, |
| 0x2, 0x2, 0x5c9, 0x5b1, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5b2, 0x3, 0x2, |
| 0x2, 0x2, 0x5c9, 0x5b3, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5b4, 0x3, 0x2, |
| 0x2, 0x2, 0x5c9, 0x5b5, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5b6, 0x3, 0x2, |
| 0x2, 0x2, 0x5c9, 0x5b7, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5b8, 0x3, 0x2, |
| 0x2, 0x2, 0x5c9, 0x5b9, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5ba, 0x3, 0x2, |
| 0x2, 0x2, 0x5c9, 0x5bb, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5bc, 0x3, 0x2, |
| 0x2, 0x2, 0x5c9, 0x5bd, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5be, 0x3, 0x2, |
| 0x2, 0x2, 0x5c9, 0x5bf, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5c0, 0x3, 0x2, |
| 0x2, 0x2, 0x5c9, 0x5c1, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5c2, 0x3, 0x2, |
| 0x2, 0x2, 0x5c9, 0x5c3, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5c4, 0x3, 0x2, |
| 0x2, 0x2, 0x5c9, 0x5c5, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5c6, 0x3, 0x2, |
| 0x2, 0x2, 0x5c9, 0x5c7, 0x3, 0x2, 0x2, 0x2, 0x5c9, 0x5c8, 0x3, 0x2, |
| 0x2, 0x2, 0x5ca, 0x5cd, 0x3, 0x2, 0x2, 0x2, 0x5cb, 0x5cc, 0x3, 0x2, |
| 0x2, 0x2, 0x5cb, 0x5c9, 0x3, 0x2, 0x2, 0x2, 0x5cc, 0x10d, 0x3, 0x2, |
| 0x2, 0x2, 0x5cd, 0x5cb, 0x3, 0x2, 0x2, 0x2, 0x5ce, 0x5e1, 0x7, 0x48, |
| 0x2, 0x2, 0x5cf, 0x5e1, 0x5, 0xe, 0x8, 0x2, 0x5d0, 0x5e1, 0x7, 0x49, |
| 0x2, 0x2, 0x5d1, 0x5e1, 0x7, 0x4d, 0x2, 0x2, 0x5d2, 0x5e1, 0x7, 0x47, |
| 0x2, 0x2, 0x5d3, 0x5e1, 0x7, 0x5e, 0x2, 0x2, 0x5d4, 0x5e1, 0x7, 0x5a, |
| 0x2, 0x2, 0x5d5, 0x5e1, 0x7, 0x5b, 0x2, 0x2, 0x5d6, 0x5e1, 0x7, 0x5c, |
| 0x2, 0x2, 0x5d7, 0x5e1, 0x7, 0x5d, 0x2, 0x2, 0x5d8, 0x5e1, 0x7, 0x54, |
| 0x2, 0x2, 0x5d9, 0x5e1, 0x7, 0x55, 0x2, 0x2, 0x5da, 0x5e1, 0x7, 0x56, |
| 0x2, 0x2, 0x5db, 0x5e1, 0x7, 0x57, 0x2, 0x2, 0x5dc, 0x5e1, 0x7, 0x58, |
| 0x2, 0x2, 0x5dd, 0x5e1, 0x7, 0x5f, 0x2, 0x2, 0x5de, 0x5e1, 0x5, 0x118, |
| 0x8d, 0x2, 0x5df, 0x5e1, 0x5, 0x10, 0x9, 0x2, 0x5e0, 0x5ce, 0x3, 0x2, |
| 0x2, 0x2, 0x5e0, 0x5cf, 0x3, 0x2, 0x2, 0x2, 0x5e0, 0x5d0, 0x3, 0x2, |
| 0x2, 0x2, 0x5e0, 0x5d1, 0x3, 0x2, 0x2, 0x2, 0x5e0, 0x5d2, 0x3, 0x2, |
| 0x2, 0x2, 0x5e0, 0x5d3, 0x3, 0x2, 0x2, 0x2, 0x5e0, 0x5d4, 0x3, 0x2, |
| 0x2, 0x2, 0x5e0, 0x5d5, 0x3, 0x2, 0x2, 0x2, 0x5e0, 0x5d6, 0x3, 0x2, |
| 0x2, 0x2, 0x5e0, 0x5d7, 0x3, 0x2, 0x2, 0x2, 0x5e0, 0x5d8, 0x3, 0x2, |
| 0x2, 0x2, 0x5e0, 0x5d9, 0x3, 0x2, 0x2, 0x2, 0x5e0, 0x5da, 0x3, 0x2, |
| 0x2, 0x2, 0x5e0, 0x5db, 0x3, 0x2, 0x2, 0x2, 0x5e0, 0x5dc, 0x3, 0x2, |
| 0x2, 0x2, 0x5e0, 0x5dd, 0x3, 0x2, 0x2, 0x2, 0x5e0, 0x5de, 0x3, 0x2, |
| 0x2, 0x2, 0x5e0, 0x5df, 0x3, 0x2, 0x2, 0x2, 0x5e1, 0x10f, 0x3, 0x2, |
| 0x2, 0x2, 0x5e2, 0x5f4, 0x7, 0x48, 0x2, 0x2, 0x5e3, 0x5f4, 0x5, 0xe, |
| 0x8, 0x2, 0x5e4, 0x5f4, 0x7, 0x49, 0x2, 0x2, 0x5e5, 0x5f4, 0x7, 0x4d, |
| 0x2, 0x2, 0x5e6, 0x5f4, 0x7, 0x47, 0x2, 0x2, 0x5e7, 0x5f4, 0x7, 0x5e, |
| 0x2, 0x2, 0x5e8, 0x5f4, 0x5, 0x112, 0x8a, 0x2, 0x5e9, 0x5f4, 0x7, 0x56, |
| 0x2, 0x2, 0x5ea, 0x5f4, 0x7, 0x57, 0x2, 0x2, 0x5eb, 0x5f4, 0x7, 0x58, |
| 0x2, 0x2, 0x5ec, 0x5f4, 0x5, 0x6, 0x4, 0x2, 0x5ed, 0x5f4, 0x7, 0x50, |
| 0x2, 0x2, 0x5ee, 0x5f4, 0x7, 0x4e, 0x2, 0x2, 0x5ef, 0x5f4, 0x7, 0x5f, |
| 0x2, 0x2, 0x5f0, 0x5f4, 0x5, 0x118, 0x8d, 0x2, 0x5f1, 0x5f4, 0x5, 0xfe, |
| 0x80, 0x2, 0x5f2, 0x5f4, 0x5, 0xfc, 0x7f, 0x2, 0x5f3, 0x5e2, 0x3, 0x2, |
| 0x2, 0x2, 0x5f3, 0x5e3, 0x3, 0x2, 0x2, 0x2, 0x5f3, 0x5e4, 0x3, 0x2, |
| 0x2, 0x2, 0x5f3, 0x5e5, 0x3, 0x2, 0x2, 0x2, 0x5f3, 0x5e6, 0x3, 0x2, |
| 0x2, 0x2, 0x5f3, 0x5e7, 0x3, 0x2, 0x2, 0x2, 0x5f3, 0x5e8, 0x3, 0x2, |
| 0x2, 0x2, 0x5f3, 0x5e9, 0x3, 0x2, 0x2, 0x2, 0x5f3, 0x5ea, 0x3, 0x2, |
| 0x2, 0x2, 0x5f3, 0x5eb, 0x3, 0x2, 0x2, 0x2, 0x5f3, 0x5ec, 0x3, 0x2, |
| 0x2, 0x2, 0x5f3, 0x5ed, 0x3, 0x2, 0x2, 0x2, 0x5f3, 0x5ee, 0x3, 0x2, |
| 0x2, 0x2, 0x5f3, 0x5ef, 0x3, 0x2, 0x2, 0x2, 0x5f3, 0x5f0, 0x3, 0x2, |
| 0x2, 0x2, 0x5f3, 0x5f1, 0x3, 0x2, 0x2, 0x2, 0x5f3, 0x5f2, 0x3, 0x2, |
| 0x2, 0x2, 0x5f4, 0x111, 0x3, 0x2, 0x2, 0x2, 0x5f5, 0x607, 0x7, 0x54, |
| 0x2, 0x2, 0x5f6, 0x606, 0x7, 0x48, 0x2, 0x2, 0x5f7, 0x606, 0x5, 0xe, |
| 0x8, 0x2, 0x5f8, 0x606, 0x7, 0x49, 0x2, 0x2, 0x5f9, 0x606, 0x7, 0x4d, |
| 0x2, 0x2, 0x5fa, 0x606, 0x7, 0x47, 0x2, 0x2, 0x5fb, 0x606, 0x7, 0x5e, |
| 0x2, 0x2, 0x5fc, 0x606, 0x7, 0x56, 0x2, 0x2, 0x5fd, 0x606, 0x7, 0x57, |
| 0x2, 0x2, 0x5fe, 0x606, 0x7, 0x58, 0x2, 0x2, 0x5ff, 0x606, 0x5, 0x6, |
| 0x4, 0x2, 0x600, 0x606, 0x7, 0x4e, 0x2, 0x2, 0x601, 0x606, 0x7, 0x50, |
| 0x2, 0x2, 0x602, 0x606, 0x7, 0x5f, 0x2, 0x2, 0x603, 0x606, 0x5, 0x112, |
| 0x8a, 0x2, 0x604, 0x606, 0x5, 0x118, 0x8d, 0x2, 0x605, 0x5f6, 0x3, 0x2, |
| 0x2, 0x2, 0x605, 0x5f7, 0x3, 0x2, 0x2, 0x2, 0x605, 0x5f8, 0x3, 0x2, |
| 0x2, 0x2, 0x605, 0x5f9, 0x3, 0x2, 0x2, 0x2, 0x605, 0x5fa, 0x3, 0x2, |
| 0x2, 0x2, 0x605, 0x5fb, 0x3, 0x2, 0x2, 0x2, 0x605, 0x5fc, 0x3, 0x2, |
| 0x2, 0x2, 0x605, 0x5fd, 0x3, 0x2, 0x2, 0x2, 0x605, 0x5fe, 0x3, 0x2, |
| 0x2, 0x2, 0x605, 0x5ff, 0x3, 0x2, 0x2, 0x2, 0x605, 0x600, 0x3, 0x2, |
| 0x2, 0x2, 0x605, 0x601, 0x3, 0x2, 0x2, 0x2, 0x605, 0x602, 0x3, 0x2, |
| 0x2, 0x2, 0x605, 0x603, 0x3, 0x2, 0x2, 0x2, 0x605, 0x604, 0x3, 0x2, |
| 0x2, 0x2, 0x606, 0x609, 0x3, 0x2, 0x2, 0x2, 0x607, 0x605, 0x3, 0x2, |
| 0x2, 0x2, 0x607, 0x608, 0x3, 0x2, 0x2, 0x2, 0x608, 0x60a, 0x3, 0x2, |
| 0x2, 0x2, 0x609, 0x607, 0x3, 0x2, 0x2, 0x2, 0x60a, 0x636, 0x7, 0x55, |
| 0x2, 0x2, 0x60b, 0x61c, 0x7, 0x5a, 0x2, 0x2, 0x60c, 0x61b, 0x7, 0x48, |
| 0x2, 0x2, 0x60d, 0x61b, 0x5, 0xe, 0x8, 0x2, 0x60e, 0x61b, 0x7, 0x49, |
| 0x2, 0x2, 0x60f, 0x61b, 0x7, 0x4d, 0x2, 0x2, 0x610, 0x61b, 0x7, 0x47, |
| 0x2, 0x2, 0x611, 0x61b, 0x7, 0x5e, 0x2, 0x2, 0x612, 0x61b, 0x7, 0x56, |
| 0x2, 0x2, 0x613, 0x61b, 0x7, 0x57, 0x2, 0x2, 0x614, 0x61b, 0x7, 0x58, |
| 0x2, 0x2, 0x615, 0x61b, 0x5, 0x6, 0x4, 0x2, 0x616, 0x61b, 0x7, 0x50, |
| 0x2, 0x2, 0x617, 0x61b, 0x7, 0x5f, 0x2, 0x2, 0x618, 0x61b, 0x5, 0x112, |
| 0x8a, 0x2, 0x619, 0x61b, 0x5, 0x118, 0x8d, 0x2, 0x61a, 0x60c, 0x3, 0x2, |
| 0x2, 0x2, 0x61a, 0x60d, 0x3, 0x2, 0x2, 0x2, 0x61a, 0x60e, 0x3, 0x2, |
| 0x2, 0x2, 0x61a, 0x60f, 0x3, 0x2, 0x2, 0x2, 0x61a, 0x610, 0x3, 0x2, |
| 0x2, 0x2, 0x61a, 0x611, 0x3, 0x2, 0x2, 0x2, 0x61a, 0x612, 0x3, 0x2, |
| 0x2, 0x2, 0x61a, 0x613, 0x3, 0x2, 0x2, 0x2, 0x61a, 0x614, 0x3, 0x2, |
| 0x2, 0x2, 0x61a, 0x615, 0x3, 0x2, 0x2, 0x2, 0x61a, 0x616, 0x3, 0x2, |
| 0x2, 0x2, 0x61a, 0x617, 0x3, 0x2, 0x2, 0x2, 0x61a, 0x618, 0x3, 0x2, |
| 0x2, 0x2, 0x61a, 0x619, 0x3, 0x2, 0x2, 0x2, 0x61b, 0x61e, 0x3, 0x2, |
| 0x2, 0x2, 0x61c, 0x61a, 0x3, 0x2, 0x2, 0x2, 0x61c, 0x61d, 0x3, 0x2, |
| 0x2, 0x2, 0x61d, 0x61f, 0x3, 0x2, 0x2, 0x2, 0x61e, 0x61c, 0x3, 0x2, |
| 0x2, 0x2, 0x61f, 0x636, 0x7, 0x5b, 0x2, 0x2, 0x620, 0x631, 0x7, 0x5c, |
| 0x2, 0x2, 0x621, 0x630, 0x7, 0x48, 0x2, 0x2, 0x622, 0x630, 0x5, 0xe, |
| 0x8, 0x2, 0x623, 0x630, 0x7, 0x49, 0x2, 0x2, 0x624, 0x630, 0x7, 0x4d, |
| 0x2, 0x2, 0x625, 0x630, 0x7, 0x47, 0x2, 0x2, 0x626, 0x630, 0x7, 0x5e, |
| 0x2, 0x2, 0x627, 0x630, 0x7, 0x56, 0x2, 0x2, 0x628, 0x630, 0x7, 0x57, |
| 0x2, 0x2, 0x629, 0x630, 0x7, 0x58, 0x2, 0x2, 0x62a, 0x630, 0x5, 0x6, |
| 0x4, 0x2, 0x62b, 0x630, 0x7, 0x50, 0x2, 0x2, 0x62c, 0x630, 0x7, 0x5f, |
| 0x2, 0x2, 0x62d, 0x630, 0x5, 0x112, 0x8a, 0x2, 0x62e, 0x630, 0x5, 0x118, |
| 0x8d, 0x2, 0x62f, 0x621, 0x3, 0x2, 0x2, 0x2, 0x62f, 0x622, 0x3, 0x2, |
| 0x2, 0x2, 0x62f, 0x623, 0x3, 0x2, 0x2, 0x2, 0x62f, 0x624, 0x3, 0x2, |
| 0x2, 0x2, 0x62f, 0x625, 0x3, 0x2, 0x2, 0x2, 0x62f, 0x626, 0x3, 0x2, |
| 0x2, 0x2, 0x62f, 0x627, 0x3, 0x2, 0x2, 0x2, 0x62f, 0x628, 0x3, 0x2, |
| 0x2, 0x2, 0x62f, 0x629, 0x3, 0x2, 0x2, 0x2, 0x62f, 0x62a, 0x3, 0x2, |
| 0x2, 0x2, 0x62f, 0x62b, 0x3, 0x2, 0x2, 0x2, 0x62f, 0x62c, 0x3, 0x2, |
| 0x2, 0x2, 0x62f, 0x62d, 0x3, 0x2, 0x2, 0x2, 0x62f, 0x62e, 0x3, 0x2, |
| 0x2, 0x2, 0x630, 0x633, 0x3, 0x2, 0x2, 0x2, 0x631, 0x62f, 0x3, 0x2, |
| 0x2, 0x2, 0x631, 0x632, 0x3, 0x2, 0x2, 0x2, 0x632, 0x634, 0x3, 0x2, |
| 0x2, 0x2, 0x633, 0x631, 0x3, 0x2, 0x2, 0x2, 0x634, 0x636, 0x7, 0x5d, |
| 0x2, 0x2, 0x635, 0x5f5, 0x3, 0x2, 0x2, 0x2, 0x635, 0x60b, 0x3, 0x2, |
| 0x2, 0x2, 0x635, 0x620, 0x3, 0x2, 0x2, 0x2, 0x636, 0x113, 0x3, 0x2, |
| 0x2, 0x2, 0x637, 0x651, 0x7, 0x48, 0x2, 0x2, 0x638, 0x651, 0x5, 0xe, |
| 0x8, 0x2, 0x639, 0x651, 0x7, 0x50, 0x2, 0x2, 0x63a, 0x651, 0x7, 0x49, |
| 0x2, 0x2, 0x63b, 0x651, 0x7, 0x4d, 0x2, 0x2, 0x63c, 0x651, 0x7, 0x4f, |
| 0x2, 0x2, 0x63d, 0x651, 0x7, 0x47, 0x2, 0x2, 0x63e, 0x651, 0x7, 0x54, |
| 0x2, 0x2, 0x63f, 0x651, 0x7, 0x55, 0x2, 0x2, 0x640, 0x651, 0x7, 0x56, |
| 0x2, 0x2, 0x641, 0x651, 0x7, 0x57, 0x2, 0x2, 0x642, 0x651, 0x7, 0x58, |
| 0x2, 0x2, 0x643, 0x651, 0x7, 0x5e, 0x2, 0x2, 0x644, 0x651, 0x7, 0x5a, |
| 0x2, 0x2, 0x645, 0x651, 0x7, 0x5b, 0x2, 0x2, 0x646, 0x651, 0x7, 0x5c, |
| 0x2, 0x2, 0x647, 0x651, 0x7, 0x5d, 0x2, 0x2, 0x648, 0x651, 0x7, 0x53, |
| 0x2, 0x2, 0x649, 0x651, 0x7, 0x5, 0x2, 0x2, 0x64a, 0x651, 0x7, 0x4b, |
| 0x2, 0x2, 0x64b, 0x651, 0x7, 0x5f, 0x2, 0x2, 0x64c, 0x651, 0x5, 0x10, |
| 0x9, 0x2, 0x64d, 0x651, 0x7, 0x51, 0x2, 0x2, 0x64e, 0x651, 0x7, 0x52, |
| 0x2, 0x2, 0x64f, 0x651, 0x7, 0x4e, 0x2, 0x2, 0x650, 0x637, 0x3, 0x2, |
| 0x2, 0x2, 0x650, 0x638, 0x3, 0x2, 0x2, 0x2, 0x650, 0x639, 0x3, 0x2, |
| 0x2, 0x2, 0x650, 0x63a, 0x3, 0x2, 0x2, 0x2, 0x650, 0x63b, 0x3, 0x2, |
| 0x2, 0x2, 0x650, 0x63c, 0x3, 0x2, 0x2, 0x2, 0x650, 0x63d, 0x3, 0x2, |
| 0x2, 0x2, 0x650, 0x63e, 0x3, 0x2, 0x2, 0x2, 0x650, 0x63f, 0x3, 0x2, |
| 0x2, 0x2, 0x650, 0x640, 0x3, 0x2, 0x2, 0x2, 0x650, 0x641, 0x3, 0x2, |
| 0x2, 0x2, 0x650, 0x642, 0x3, 0x2, 0x2, 0x2, 0x650, 0x643, 0x3, 0x2, |
| 0x2, 0x2, 0x650, 0x644, 0x3, 0x2, 0x2, 0x2, 0x650, 0x645, 0x3, 0x2, |
| 0x2, 0x2, 0x650, 0x646, 0x3, 0x2, 0x2, 0x2, 0x650, 0x647, 0x3, 0x2, |
| 0x2, 0x2, 0x650, 0x648, 0x3, 0x2, 0x2, 0x2, 0x650, 0x649, 0x3, 0x2, |
| 0x2, 0x2, 0x650, 0x64a, 0x3, 0x2, 0x2, 0x2, 0x650, 0x64b, 0x3, 0x2, |
| 0x2, 0x2, 0x650, 0x64c, 0x3, 0x2, 0x2, 0x2, 0x650, 0x64d, 0x3, 0x2, |
| 0x2, 0x2, 0x650, 0x64e, 0x3, 0x2, 0x2, 0x2, 0x650, 0x64f, 0x3, 0x2, |
| 0x2, 0x2, 0x651, 0x115, 0x3, 0x2, 0x2, 0x2, 0x652, 0x653, 0x7, 0x47, |
| 0x2, 0x2, 0x653, 0x117, 0x3, 0x2, 0x2, 0x2, 0x654, 0x655, 0x7, 0x59, |
| 0x2, 0x2, 0x655, 0x119, 0x3, 0x2, 0x2, 0x2, 0x656, 0x663, 0x7, 0x48, |
| 0x2, 0x2, 0x657, 0x663, 0x5, 0xe, 0x8, 0x2, 0x658, 0x663, 0x7, 0x49, |
| 0x2, 0x2, 0x659, 0x663, 0x7, 0x4d, 0x2, 0x2, 0x65a, 0x663, 0x7, 0x47, |
| 0x2, 0x2, 0x65b, 0x663, 0x7, 0x5e, 0x2, 0x2, 0x65c, 0x663, 0x7, 0x5a, |
| 0x2, 0x2, 0x65d, 0x663, 0x7, 0x5b, 0x2, 0x2, 0x65e, 0x663, 0x7, 0x5c, |
| 0x2, 0x2, 0x65f, 0x663, 0x7, 0x5d, 0x2, 0x2, 0x660, 0x663, 0x7, 0x5f, |
| 0x2, 0x2, 0x661, 0x663, 0x5, 0x118, 0x8d, 0x2, 0x662, 0x656, 0x3, 0x2, |
| 0x2, 0x2, 0x662, 0x657, 0x3, 0x2, 0x2, 0x2, 0x662, 0x658, 0x3, 0x2, |
| 0x2, 0x2, 0x662, 0x659, 0x3, 0x2, 0x2, 0x2, 0x662, 0x65a, 0x3, 0x2, |
| 0x2, 0x2, 0x662, 0x65b, 0x3, 0x2, 0x2, 0x2, 0x662, 0x65c, 0x3, 0x2, |
| 0x2, 0x2, 0x662, 0x65d, 0x3, 0x2, 0x2, 0x2, 0x662, 0x65e, 0x3, 0x2, |
| 0x2, 0x2, 0x662, 0x65f, 0x3, 0x2, 0x2, 0x2, 0x662, 0x660, 0x3, 0x2, |
| 0x2, 0x2, 0x662, 0x661, 0x3, 0x2, 0x2, 0x2, 0x663, 0x11b, 0x3, 0x2, |
| 0x2, 0x2, 0x664, 0x679, 0x7, 0x48, 0x2, 0x2, 0x665, 0x679, 0x5, 0xe, |
| 0x8, 0x2, 0x666, 0x679, 0x7, 0x49, 0x2, 0x2, 0x667, 0x679, 0x7, 0x4d, |
| 0x2, 0x2, 0x668, 0x679, 0x7, 0x4f, 0x2, 0x2, 0x669, 0x679, 0x7, 0x54, |
| 0x2, 0x2, 0x66a, 0x679, 0x7, 0x55, 0x2, 0x2, 0x66b, 0x679, 0x7, 0x56, |
| 0x2, 0x2, 0x66c, 0x679, 0x7, 0x57, 0x2, 0x2, 0x66d, 0x679, 0x7, 0x58, |
| 0x2, 0x2, 0x66e, 0x679, 0x7, 0x5e, 0x2, 0x2, 0x66f, 0x679, 0x7, 0x5a, |
| 0x2, 0x2, 0x670, 0x679, 0x7, 0x5b, 0x2, 0x2, 0x671, 0x679, 0x7, 0x5c, |
| 0x2, 0x2, 0x672, 0x679, 0x7, 0x5d, 0x2, 0x2, 0x673, 0x679, 0x7, 0x5f, |
| 0x2, 0x2, 0x674, 0x679, 0x5, 0x118, 0x8d, 0x2, 0x675, 0x679, 0x7, 0x4b, |
| 0x2, 0x2, 0x676, 0x679, 0x5, 0x10, 0x9, 0x2, 0x677, 0x679, 0x7, 0x4e, |
| 0x2, 0x2, 0x678, 0x664, 0x3, 0x2, 0x2, 0x2, 0x678, 0x665, 0x3, 0x2, |
| 0x2, 0x2, 0x678, 0x666, 0x3, 0x2, 0x2, 0x2, 0x678, 0x667, 0x3, 0x2, |
| 0x2, 0x2, 0x678, 0x668, 0x3, 0x2, 0x2, 0x2, 0x678, 0x669, 0x3, 0x2, |
| 0x2, 0x2, 0x678, 0x66a, 0x3, 0x2, 0x2, 0x2, 0x678, 0x66b, 0x3, 0x2, |
| 0x2, 0x2, 0x678, 0x66c, 0x3, 0x2, 0x2, 0x2, 0x678, 0x66d, 0x3, 0x2, |
| 0x2, 0x2, 0x678, 0x66e, 0x3, 0x2, 0x2, 0x2, 0x678, 0x66f, 0x3, 0x2, |
| 0x2, 0x2, 0x678, 0x670, 0x3, 0x2, 0x2, 0x2, 0x678, 0x671, 0x3, 0x2, |
| 0x2, 0x2, 0x678, 0x672, 0x3, 0x2, 0x2, 0x2, 0x678, 0x673, 0x3, 0x2, |
| 0x2, 0x2, 0x678, 0x674, 0x3, 0x2, 0x2, 0x2, 0x678, 0x675, 0x3, 0x2, |
| 0x2, 0x2, 0x678, 0x676, 0x3, 0x2, 0x2, 0x2, 0x678, 0x677, 0x3, 0x2, |
| 0x2, 0x2, 0x679, 0x11d, 0x3, 0x2, 0x2, 0x2, 0x84, 0x121, 0x16d, 0x173, |
| 0x17b, 0x181, 0x189, 0x190, 0x19e, 0x1a4, 0x1af, 0x1b5, 0x1c5, 0x1d6, |
| 0x1e3, 0x1e9, 0x1f0, 0x1f6, 0x1fb, 0x1ff, 0x203, 0x20a, 0x211, 0x217, |
| 0x21e, 0x224, 0x229, 0x22d, 0x231, 0x238, 0x23f, 0x245, 0x24f, 0x256, |
| 0x25c, 0x266, 0x26d, 0x273, 0x27e, 0x286, 0x28c, 0x292, 0x297, 0x29d, |
| 0x2a8, 0x2b5, 0x2c0, 0x2cd, 0x2d2, 0x2d9, 0x2e4, 0x2ef, 0x2fa, 0x305, |
| 0x310, 0x31b, 0x326, 0x331, 0x33f, 0x345, 0x350, 0x35b, 0x366, 0x371, |
| 0x37c, 0x387, 0x392, 0x39d, 0x3a8, 0x3b3, 0x3be, 0x3c9, 0x3d6, 0x3e0, |
| 0x3e6, 0x3f3, 0x3fe, 0x409, 0x414, 0x41f, 0x44a, 0x455, 0x461, 0x473, |
| 0x477, 0x488, 0x48d, 0x491, 0x495, 0x49c, 0x4a4, 0x4a9, 0x4b0, 0x4b4, |
| 0x4ba, 0x4c4, 0x4c7, 0x4fb, 0x502, 0x509, 0x50e, 0x515, 0x51c, 0x523, |
| 0x528, 0x52d, 0x532, 0x539, 0x557, 0x559, 0x560, 0x581, 0x583, 0x58a, |
| 0x58e, 0x5aa, 0x5ac, 0x5c9, 0x5cb, 0x5e0, 0x5f3, 0x605, 0x607, 0x61a, |
| 0x61c, 0x62f, 0x631, 0x635, 0x650, 0x662, 0x678, |
| }; |
| |
| atn::ATNDeserializer deserializer; |
| _atn = deserializer.deserialize(_serializedATN); |
| |
| size_t count = _atn.getNumberOfDecisions(); |
| _decisionToDFA.reserve(count); |
| for (size_t i = 0; i < count; i++) { |
| _decisionToDFA.emplace_back(_atn.getDecisionState(i), i); |
| } |
| } |
| |
| SV3_1aPpParser::Initializer SV3_1aPpParser::_init; |
