| // 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; |