| // A Bison parser, made by GNU Bison 3.7.2. |
| |
| // Skeleton implementation for Bison LALR(1) parsers in C++ |
| |
| // Copyright (C) 2002-2015, 2018-2020 Free Software Foundation, Inc. |
| |
| // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. |
| |
| // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. |
| |
| // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| |
| // As a special exception, you may create a larger work that contains |
| // part or all of the Bison parser skeleton and distribute that work |
| // under terms of your choice, so long as that work isn't itself a |
| // parser generator using the skeleton or a modified version thereof |
| // as a parser skeleton. Alternatively, if you modify or redistribute |
| // the parser skeleton itself, you may (at your option) remove this |
| // special exception, which will cause the skeleton and the resulting |
| // Bison output files to be licensed under the GNU General Public |
| // License without this special exception. |
| |
| // This special exception was added by the Free Software Foundation in |
| // version 2.2 of Bison. |
| |
| // DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, |
| // especially those whose name start with YY_ or yy_. They are |
| // private implementation details that can be changed or removed. |
| |
| |
| |
| |
| |
| #include "parser.hpp" |
| |
| |
| // Unqualified %code blocks. |
| |
| #include "pio_assembler.h" |
| #ifdef _MSC_VER |
| #pragma warning(disable : 4244) // possible loss of data (valid warning, but there is a software check / missing cast) |
| #endif |
| |
| |
| |
| #ifndef YY_ |
| # if defined YYENABLE_NLS && YYENABLE_NLS |
| # if ENABLE_NLS |
| # include <libintl.h> // FIXME: INFRINGES ON USER NAME SPACE. |
| # define YY_(msgid) dgettext ("bison-runtime", msgid) |
| # endif |
| # endif |
| # ifndef YY_ |
| # define YY_(msgid) msgid |
| # endif |
| #endif |
| |
| |
| // Whether we are compiled with exception support. |
| #ifndef YY_EXCEPTIONS |
| # if defined __GNUC__ && !defined __EXCEPTIONS |
| # define YY_EXCEPTIONS 0 |
| # else |
| # define YY_EXCEPTIONS 1 |
| # endif |
| #endif |
| |
| #define YYRHSLOC(Rhs, K) ((Rhs)[K].location) |
| /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. |
| If N is 0, then set CURRENT to the empty location which ends |
| the previous symbol: RHS[0] (always defined). */ |
| |
| # ifndef YYLLOC_DEFAULT |
| # define YYLLOC_DEFAULT(Current, Rhs, N) \ |
| do \ |
| if (N) \ |
| { \ |
| (Current).begin = YYRHSLOC (Rhs, 1).begin; \ |
| (Current).end = YYRHSLOC (Rhs, N).end; \ |
| } \ |
| else \ |
| { \ |
| (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ |
| } \ |
| while (false) |
| # endif |
| |
| |
| // Enable debugging if requested. |
| #if YYDEBUG |
| |
| // A pseudo ostream that takes yydebug_ into account. |
| # define YYCDEBUG if (yydebug_) (*yycdebug_) |
| |
| # define YY_SYMBOL_PRINT(Title, Symbol) \ |
| do { \ |
| if (yydebug_) \ |
| { \ |
| *yycdebug_ << Title << ' '; \ |
| yy_print_ (*yycdebug_, Symbol); \ |
| *yycdebug_ << '\n'; \ |
| } \ |
| } while (false) |
| |
| # define YY_REDUCE_PRINT(Rule) \ |
| do { \ |
| if (yydebug_) \ |
| yy_reduce_print_ (Rule); \ |
| } while (false) |
| |
| # define YY_STACK_PRINT() \ |
| do { \ |
| if (yydebug_) \ |
| yy_stack_print_ (); \ |
| } while (false) |
| |
| #else // !YYDEBUG |
| |
| # define YYCDEBUG if (false) std::cerr |
| # define YY_SYMBOL_PRINT(Title, Symbol) YYUSE (Symbol) |
| # define YY_REDUCE_PRINT(Rule) static_cast<void> (0) |
| # define YY_STACK_PRINT() static_cast<void> (0) |
| |
| #endif // !YYDEBUG |
| |
| #define yyerrok (yyerrstatus_ = 0) |
| #define yyclearin (yyla.clear ()) |
| |
| #define YYACCEPT goto yyacceptlab |
| #define YYABORT goto yyabortlab |
| #define YYERROR goto yyerrorlab |
| #define YYRECOVERING() (!!yyerrstatus_) |
| |
| namespace yy { |
| |
| /// Build a parser object. |
| parser::parser (pio_assembler& pioasm_yyarg) |
| #if YYDEBUG |
| : yydebug_ (false), |
| yycdebug_ (&std::cerr), |
| #else |
| : |
| #endif |
| yy_lac_established_ (false), |
| pioasm (pioasm_yyarg) |
| {} |
| |
| parser::~parser () |
| {} |
| |
| parser::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW |
| {} |
| |
| /*---------------. |
| | symbol kinds. | |
| `---------------*/ |
| |
| |
| |
| // by_state. |
| parser::by_state::by_state () YY_NOEXCEPT |
| : state (empty_state) |
| {} |
| |
| parser::by_state::by_state (const by_state& that) YY_NOEXCEPT |
| : state (that.state) |
| {} |
| |
| void |
| parser::by_state::clear () YY_NOEXCEPT |
| { |
| state = empty_state; |
| } |
| |
| void |
| parser::by_state::move (by_state& that) |
| { |
| state = that.state; |
| that.clear (); |
| } |
| |
| parser::by_state::by_state (state_type s) YY_NOEXCEPT |
| : state (s) |
| {} |
| |
| parser::symbol_kind_type |
| parser::by_state::kind () const YY_NOEXCEPT |
| { |
| if (state == empty_state) |
| return symbol_kind::S_YYEMPTY; |
| else |
| return YY_CAST (symbol_kind_type, yystos_[+state]); |
| } |
| |
| parser::stack_symbol_type::stack_symbol_type () |
| {} |
| |
| parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that) |
| : super_type (YY_MOVE (that.state), YY_MOVE (that.location)) |
| { |
| switch (that.kind ()) |
| { |
| case symbol_kind::S_if_full: // if_full |
| case symbol_kind::S_if_empty: // if_empty |
| case symbol_kind::S_blocking: // blocking |
| value.YY_MOVE_OR_COPY< bool > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_condition: // condition |
| value.YY_MOVE_OR_COPY< enum condition > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_in_source: // in_source |
| case symbol_kind::S_out_target: // out_target |
| case symbol_kind::S_set_target: // set_target |
| value.YY_MOVE_OR_COPY< enum in_out_set > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_irq_modifiers: // irq_modifiers |
| value.YY_MOVE_OR_COPY< enum irq > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_mov_target: // mov_target |
| case symbol_kind::S_mov_source: // mov_source |
| value.YY_MOVE_OR_COPY< enum mov > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_mov_op: // mov_op |
| value.YY_MOVE_OR_COPY< enum mov_op > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_INT: // "integer" |
| value.YY_MOVE_OR_COPY< int > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_instruction: // instruction |
| case symbol_kind::S_base_instruction: // base_instruction |
| value.YY_MOVE_OR_COPY< std::shared_ptr<instruction> > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_value: // value |
| case symbol_kind::S_expression: // expression |
| case symbol_kind::S_delay: // delay |
| case symbol_kind::S_sideset: // sideset |
| value.YY_MOVE_OR_COPY< std::shared_ptr<resolvable> > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_label_decl: // label_decl |
| case symbol_kind::S_symbol_def: // symbol_def |
| value.YY_MOVE_OR_COPY< std::shared_ptr<symbol> > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_wait_source: // wait_source |
| value.YY_MOVE_OR_COPY< std::shared_ptr<wait_source> > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_ID: // "identifier" |
| case symbol_kind::S_STRING: // "string" |
| case symbol_kind::S_NON_WS: // "text" |
| case symbol_kind::S_CODE_BLOCK_START: // "code block" |
| case symbol_kind::S_CODE_BLOCK_CONTENTS: // "%}" |
| case symbol_kind::S_UNKNOWN_DIRECTIVE: // UNKNOWN_DIRECTIVE |
| value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value)); |
| break; |
| |
| default: |
| break; |
| } |
| |
| #if 201103L <= YY_CPLUSPLUS |
| // that is emptied. |
| that.state = empty_state; |
| #endif |
| } |
| |
| parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that) |
| : super_type (s, YY_MOVE (that.location)) |
| { |
| switch (that.kind ()) |
| { |
| case symbol_kind::S_if_full: // if_full |
| case symbol_kind::S_if_empty: // if_empty |
| case symbol_kind::S_blocking: // blocking |
| value.move< bool > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_condition: // condition |
| value.move< enum condition > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_in_source: // in_source |
| case symbol_kind::S_out_target: // out_target |
| case symbol_kind::S_set_target: // set_target |
| value.move< enum in_out_set > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_irq_modifiers: // irq_modifiers |
| value.move< enum irq > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_mov_target: // mov_target |
| case symbol_kind::S_mov_source: // mov_source |
| value.move< enum mov > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_mov_op: // mov_op |
| value.move< enum mov_op > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_INT: // "integer" |
| value.move< int > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_instruction: // instruction |
| case symbol_kind::S_base_instruction: // base_instruction |
| value.move< std::shared_ptr<instruction> > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_value: // value |
| case symbol_kind::S_expression: // expression |
| case symbol_kind::S_delay: // delay |
| case symbol_kind::S_sideset: // sideset |
| value.move< std::shared_ptr<resolvable> > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_label_decl: // label_decl |
| case symbol_kind::S_symbol_def: // symbol_def |
| value.move< std::shared_ptr<symbol> > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_wait_source: // wait_source |
| value.move< std::shared_ptr<wait_source> > (YY_MOVE (that.value)); |
| break; |
| |
| case symbol_kind::S_ID: // "identifier" |
| case symbol_kind::S_STRING: // "string" |
| case symbol_kind::S_NON_WS: // "text" |
| case symbol_kind::S_CODE_BLOCK_START: // "code block" |
| case symbol_kind::S_CODE_BLOCK_CONTENTS: // "%}" |
| case symbol_kind::S_UNKNOWN_DIRECTIVE: // UNKNOWN_DIRECTIVE |
| value.move< std::string > (YY_MOVE (that.value)); |
| break; |
| |
| default: |
| break; |
| } |
| |
| // that is emptied. |
| that.kind_ = symbol_kind::S_YYEMPTY; |
| } |
| |
| #if YY_CPLUSPLUS < 201103L |
| parser::stack_symbol_type& |
| parser::stack_symbol_type::operator= (const stack_symbol_type& that) |
| { |
| state = that.state; |
| switch (that.kind ()) |
| { |
| case symbol_kind::S_if_full: // if_full |
| case symbol_kind::S_if_empty: // if_empty |
| case symbol_kind::S_blocking: // blocking |
| value.copy< bool > (that.value); |
| break; |
| |
| case symbol_kind::S_condition: // condition |
| value.copy< enum condition > (that.value); |
| break; |
| |
| case symbol_kind::S_in_source: // in_source |
| case symbol_kind::S_out_target: // out_target |
| case symbol_kind::S_set_target: // set_target |
| value.copy< enum in_out_set > (that.value); |
| break; |
| |
| case symbol_kind::S_irq_modifiers: // irq_modifiers |
| value.copy< enum irq > (that.value); |
| break; |
| |
| case symbol_kind::S_mov_target: // mov_target |
| case symbol_kind::S_mov_source: // mov_source |
| value.copy< enum mov > (that.value); |
| break; |
| |
| case symbol_kind::S_mov_op: // mov_op |
| value.copy< enum mov_op > (that.value); |
| break; |
| |
| case symbol_kind::S_INT: // "integer" |
| value.copy< int > (that.value); |
| break; |
| |
| case symbol_kind::S_instruction: // instruction |
| case symbol_kind::S_base_instruction: // base_instruction |
| value.copy< std::shared_ptr<instruction> > (that.value); |
| break; |
| |
| case symbol_kind::S_value: // value |
| case symbol_kind::S_expression: // expression |
| case symbol_kind::S_delay: // delay |
| case symbol_kind::S_sideset: // sideset |
| value.copy< std::shared_ptr<resolvable> > (that.value); |
| break; |
| |
| case symbol_kind::S_label_decl: // label_decl |
| case symbol_kind::S_symbol_def: // symbol_def |
| value.copy< std::shared_ptr<symbol> > (that.value); |
| break; |
| |
| case symbol_kind::S_wait_source: // wait_source |
| value.copy< std::shared_ptr<wait_source> > (that.value); |
| break; |
| |
| case symbol_kind::S_ID: // "identifier" |
| case symbol_kind::S_STRING: // "string" |
| case symbol_kind::S_NON_WS: // "text" |
| case symbol_kind::S_CODE_BLOCK_START: // "code block" |
| case symbol_kind::S_CODE_BLOCK_CONTENTS: // "%}" |
| case symbol_kind::S_UNKNOWN_DIRECTIVE: // UNKNOWN_DIRECTIVE |
| value.copy< std::string > (that.value); |
| break; |
| |
| default: |
| break; |
| } |
| |
| location = that.location; |
| return *this; |
| } |
| |
| parser::stack_symbol_type& |
| parser::stack_symbol_type::operator= (stack_symbol_type& that) |
| { |
| state = that.state; |
| switch (that.kind ()) |
| { |
| case symbol_kind::S_if_full: // if_full |
| case symbol_kind::S_if_empty: // if_empty |
| case symbol_kind::S_blocking: // blocking |
| value.move< bool > (that.value); |
| break; |
| |
| case symbol_kind::S_condition: // condition |
| value.move< enum condition > (that.value); |
| break; |
| |
| case symbol_kind::S_in_source: // in_source |
| case symbol_kind::S_out_target: // out_target |
| case symbol_kind::S_set_target: // set_target |
| value.move< enum in_out_set > (that.value); |
| break; |
| |
| case symbol_kind::S_irq_modifiers: // irq_modifiers |
| value.move< enum irq > (that.value); |
| break; |
| |
| case symbol_kind::S_mov_target: // mov_target |
| case symbol_kind::S_mov_source: // mov_source |
| value.move< enum mov > (that.value); |
| break; |
| |
| case symbol_kind::S_mov_op: // mov_op |
| value.move< enum mov_op > (that.value); |
| break; |
| |
| case symbol_kind::S_INT: // "integer" |
| value.move< int > (that.value); |
| break; |
| |
| case symbol_kind::S_instruction: // instruction |
| case symbol_kind::S_base_instruction: // base_instruction |
| value.move< std::shared_ptr<instruction> > (that.value); |
| break; |
| |
| case symbol_kind::S_value: // value |
| case symbol_kind::S_expression: // expression |
| case symbol_kind::S_delay: // delay |
| case symbol_kind::S_sideset: // sideset |
| value.move< std::shared_ptr<resolvable> > (that.value); |
| break; |
| |
| case symbol_kind::S_label_decl: // label_decl |
| case symbol_kind::S_symbol_def: // symbol_def |
| value.move< std::shared_ptr<symbol> > (that.value); |
| break; |
| |
| case symbol_kind::S_wait_source: // wait_source |
| value.move< std::shared_ptr<wait_source> > (that.value); |
| break; |
| |
| case symbol_kind::S_ID: // "identifier" |
| case symbol_kind::S_STRING: // "string" |
| case symbol_kind::S_NON_WS: // "text" |
| case symbol_kind::S_CODE_BLOCK_START: // "code block" |
| case symbol_kind::S_CODE_BLOCK_CONTENTS: // "%}" |
| case symbol_kind::S_UNKNOWN_DIRECTIVE: // UNKNOWN_DIRECTIVE |
| value.move< std::string > (that.value); |
| break; |
| |
| default: |
| break; |
| } |
| |
| location = that.location; |
| // that is emptied. |
| that.state = empty_state; |
| return *this; |
| } |
| #endif |
| |
| template <typename Base> |
| void |
| parser::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const |
| { |
| if (yymsg) |
| YY_SYMBOL_PRINT (yymsg, yysym); |
| } |
| |
| #if YYDEBUG |
| template <typename Base> |
| void |
| parser::yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const |
| { |
| std::ostream& yyoutput = yyo; |
| YYUSE (yyoutput); |
| if (yysym.empty ()) |
| yyo << "empty symbol"; |
| else |
| { |
| symbol_kind_type yykind = yysym.kind (); |
| yyo << (yykind < YYNTOKENS ? "token" : "nterm") |
| << ' ' << yysym.name () << " (" |
| << yysym.location << ": "; |
| switch (yykind) |
| { |
| case symbol_kind::S_ID: // "identifier" |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_STRING: // "string" |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_NON_WS: // "text" |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_CODE_BLOCK_START: // "code block" |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_CODE_BLOCK_CONTENTS: // "%}" |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_UNKNOWN_DIRECTIVE: // UNKNOWN_DIRECTIVE |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_INT: // "integer" |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_label_decl: // label_decl |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_value: // value |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_expression: // expression |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_instruction: // instruction |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_base_instruction: // base_instruction |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_delay: // delay |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_sideset: // sideset |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_condition: // condition |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_wait_source: // wait_source |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_in_source: // in_source |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_out_target: // out_target |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_mov_target: // mov_target |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_mov_source: // mov_source |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_mov_op: // mov_op |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_set_target: // set_target |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_if_full: // if_full |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_if_empty: // if_empty |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_blocking: // blocking |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_irq_modifiers: // irq_modifiers |
| { yyo << "..."; } |
| break; |
| |
| case symbol_kind::S_symbol_def: // symbol_def |
| { yyo << "..."; } |
| break; |
| |
| default: |
| break; |
| } |
| yyo << ')'; |
| } |
| } |
| #endif |
| |
| void |
| parser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym) |
| { |
| if (m) |
| YY_SYMBOL_PRINT (m, sym); |
| yystack_.push (YY_MOVE (sym)); |
| } |
| |
| void |
| parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym) |
| { |
| #if 201103L <= YY_CPLUSPLUS |
| yypush_ (m, stack_symbol_type (s, std::move (sym))); |
| #else |
| stack_symbol_type ss (s, sym); |
| yypush_ (m, ss); |
| #endif |
| } |
| |
| void |
| parser::yypop_ (int n) |
| { |
| yystack_.pop (n); |
| } |
| |
| #if YYDEBUG |
| std::ostream& |
| parser::debug_stream () const |
| { |
| return *yycdebug_; |
| } |
| |
| void |
| parser::set_debug_stream (std::ostream& o) |
| { |
| yycdebug_ = &o; |
| } |
| |
| |
| parser::debug_level_type |
| parser::debug_level () const |
| { |
| return yydebug_; |
| } |
| |
| void |
| parser::set_debug_level (debug_level_type l) |
| { |
| yydebug_ = l; |
| } |
| #endif // YYDEBUG |
| |
| parser::state_type |
| parser::yy_lr_goto_state_ (state_type yystate, int yysym) |
| { |
| int yyr = yypgoto_[yysym - YYNTOKENS] + yystate; |
| if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) |
| return yytable_[yyr]; |
| else |
| return yydefgoto_[yysym - YYNTOKENS]; |
| } |
| |
| bool |
| parser::yy_pact_value_is_default_ (int yyvalue) |
| { |
| return yyvalue == yypact_ninf_; |
| } |
| |
| bool |
| parser::yy_table_value_is_error_ (int yyvalue) |
| { |
| return yyvalue == yytable_ninf_; |
| } |
| |
| int |
| parser::operator() () |
| { |
| return parse (); |
| } |
| |
| int |
| parser::parse () |
| { |
| int yyn; |
| /// Length of the RHS of the rule being reduced. |
| int yylen = 0; |
| |
| // Error handling. |
| int yynerrs_ = 0; |
| int yyerrstatus_ = 0; |
| |
| /// The lookahead symbol. |
| symbol_type yyla; |
| |
| /// The locations where the error started and ended. |
| stack_symbol_type yyerror_range[3]; |
| |
| /// The return value of parse (). |
| int yyresult; |
| |
| /// Discard the LAC context in case there still is one left from a |
| /// previous invocation. |
| yy_lac_discard_ ("init"); |
| |
| #if YY_EXCEPTIONS |
| try |
| #endif // YY_EXCEPTIONS |
| { |
| YYCDEBUG << "Starting parse\n"; |
| |
| |
| /* Initialize the stack. The initial state will be set in |
| yynewstate, since the latter expects the semantical and the |
| location values to have been already stored, initialize these |
| stacks with a primary value. */ |
| yystack_.clear (); |
| yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla)); |
| |
| /*-----------------------------------------------. |
| | yynewstate -- push a new symbol on the stack. | |
| `-----------------------------------------------*/ |
| yynewstate: |
| YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n'; |
| YY_STACK_PRINT (); |
| |
| // Accept? |
| if (yystack_[0].state == yyfinal_) |
| YYACCEPT; |
| |
| goto yybackup; |
| |
| |
| /*-----------. |
| | yybackup. | |
| `-----------*/ |
| yybackup: |
| // Try to take a decision without lookahead. |
| yyn = yypact_[+yystack_[0].state]; |
| if (yy_pact_value_is_default_ (yyn)) |
| goto yydefault; |
| |
| // Read a lookahead token. |
| if (yyla.empty ()) |
| { |
| YYCDEBUG << "Reading a token\n"; |
| #if YY_EXCEPTIONS |
| try |
| #endif // YY_EXCEPTIONS |
| { |
| symbol_type yylookahead (yylex (pioasm)); |
| yyla.move (yylookahead); |
| } |
| #if YY_EXCEPTIONS |
| catch (const syntax_error& yyexc) |
| { |
| YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; |
| error (yyexc); |
| goto yyerrlab1; |
| } |
| #endif // YY_EXCEPTIONS |
| } |
| YY_SYMBOL_PRINT ("Next token is", yyla); |
| |
| if (yyla.kind () == symbol_kind::S_YYerror) |
| { |
| // The scanner already issued an error message, process directly |
| // to error recovery. But do not keep the error token as |
| // lookahead, it is too special and may lead us to an endless |
| // loop in error recovery. */ |
| yyla.kind_ = symbol_kind::S_YYUNDEF; |
| goto yyerrlab1; |
| } |
| |
| /* If the proper action on seeing token YYLA.TYPE is to reduce or |
| to detect an error, take that action. */ |
| yyn += yyla.kind (); |
| if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ()) |
| { |
| if (!yy_lac_establish_ (yyla.kind ())) |
| goto yyerrlab; |
| goto yydefault; |
| } |
| |
| // Reduce or error. |
| yyn = yytable_[yyn]; |
| if (yyn <= 0) |
| { |
| if (yy_table_value_is_error_ (yyn)) |
| goto yyerrlab; |
| if (!yy_lac_establish_ (yyla.kind ())) |
| goto yyerrlab; |
| |
| yyn = -yyn; |
| goto yyreduce; |
| } |
| |
| // Count tokens shifted since error; after three, turn off error status. |
| if (yyerrstatus_) |
| --yyerrstatus_; |
| |
| // Shift the lookahead token. |
| yypush_ ("Shifting", state_type (yyn), YY_MOVE (yyla)); |
| yy_lac_discard_ ("shift"); |
| goto yynewstate; |
| |
| |
| /*-----------------------------------------------------------. |
| | yydefault -- do the default action for the current state. | |
| `-----------------------------------------------------------*/ |
| yydefault: |
| yyn = yydefact_[+yystack_[0].state]; |
| if (yyn == 0) |
| goto yyerrlab; |
| goto yyreduce; |
| |
| |
| /*-----------------------------. |
| | yyreduce -- do a reduction. | |
| `-----------------------------*/ |
| yyreduce: |
| yylen = yyr2_[yyn]; |
| { |
| stack_symbol_type yylhs; |
| yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]); |
| /* Variants are always initialized to an empty instance of the |
| correct type. The default '$$ = $1' action is NOT applied |
| when using variants. */ |
| switch (yyr1_[yyn]) |
| { |
| case symbol_kind::S_if_full: // if_full |
| case symbol_kind::S_if_empty: // if_empty |
| case symbol_kind::S_blocking: // blocking |
| yylhs.value.emplace< bool > (); |
| break; |
| |
| case symbol_kind::S_condition: // condition |
| yylhs.value.emplace< enum condition > (); |
| break; |
| |
| case symbol_kind::S_in_source: // in_source |
| case symbol_kind::S_out_target: // out_target |
| case symbol_kind::S_set_target: // set_target |
| yylhs.value.emplace< enum in_out_set > (); |
| break; |
| |
| case symbol_kind::S_irq_modifiers: // irq_modifiers |
| yylhs.value.emplace< enum irq > (); |
| break; |
| |
| case symbol_kind::S_mov_target: // mov_target |
| case symbol_kind::S_mov_source: // mov_source |
| yylhs.value.emplace< enum mov > (); |
| break; |
| |
| case symbol_kind::S_mov_op: // mov_op |
| yylhs.value.emplace< enum mov_op > (); |
| break; |
| |
| case symbol_kind::S_INT: // "integer" |
| yylhs.value.emplace< int > (); |
| break; |
| |
| case symbol_kind::S_instruction: // instruction |
| case symbol_kind::S_base_instruction: // base_instruction |
| yylhs.value.emplace< std::shared_ptr<instruction> > (); |
| break; |
| |
| case symbol_kind::S_value: // value |
| case symbol_kind::S_expression: // expression |
| case symbol_kind::S_delay: // delay |
| case symbol_kind::S_sideset: // sideset |
| yylhs.value.emplace< std::shared_ptr<resolvable> > (); |
| break; |
| |
| case symbol_kind::S_label_decl: // label_decl |
| case symbol_kind::S_symbol_def: // symbol_def |
| yylhs.value.emplace< std::shared_ptr<symbol> > (); |
| break; |
| |
| case symbol_kind::S_wait_source: // wait_source |
| yylhs.value.emplace< std::shared_ptr<wait_source> > (); |
| break; |
| |
| case symbol_kind::S_ID: // "identifier" |
| case symbol_kind::S_STRING: // "string" |
| case symbol_kind::S_NON_WS: // "text" |
| case symbol_kind::S_CODE_BLOCK_START: // "code block" |
| case symbol_kind::S_CODE_BLOCK_CONTENTS: // "%}" |
| case symbol_kind::S_UNKNOWN_DIRECTIVE: // UNKNOWN_DIRECTIVE |
| yylhs.value.emplace< std::string > (); |
| break; |
| |
| default: |
| break; |
| } |
| |
| |
| // Default location. |
| { |
| stack_type::slice range (yystack_, yylen); |
| YYLLOC_DEFAULT (yylhs.location, range, yylen); |
| yyerror_range[1].location = yylhs.location; |
| } |
| |
| // Perform the reduction. |
| YY_REDUCE_PRINT (yyn); |
| #if YY_EXCEPTIONS |
| try |
| #endif // YY_EXCEPTIONS |
| { |
| switch (yyn) |
| { |
| case 2: // file: lines "end of file" |
| { if (pioasm.error_count || pioasm.write_output()) YYABORT; } |
| break; |
| |
| case 5: // line: ".program" "identifier" |
| { if (!pioasm.add_program(yylhs.location, yystack_[0].value.as < std::string > ())) { std::stringstream msg; msg << "program " << yystack_[0].value.as < std::string > () << " already exists"; error(yylhs.location, msg.str()); abort(); } } |
| break; |
| |
| case 7: // line: instruction |
| { pioasm.get_current_program(yystack_[0].location, "instruction").add_instruction(yystack_[0].value.as < std::shared_ptr<instruction> > ()); } |
| break; |
| |
| case 8: // line: label_decl instruction |
| { auto &p = pioasm.get_current_program(yystack_[0].location, "instruction"); p.add_label(yystack_[1].value.as < std::shared_ptr<symbol> > ()); p.add_instruction(yystack_[0].value.as < std::shared_ptr<instruction> > ()); } |
| break; |
| |
| case 9: // line: label_decl |
| { pioasm.get_current_program(yystack_[0].location, "label").add_label(yystack_[0].value.as < std::shared_ptr<symbol> > ()); } |
| break; |
| |
| case 12: // line: error |
| { if (pioasm.error_count > 6) { std::cerr << "\ntoo many errors; aborting.\n"; YYABORT; } } |
| break; |
| |
| case 13: // code_block: "code block" "%}" |
| { std::string of = yystack_[1].value.as < std::string > (); if (of.empty()) of = output_format::default_name; pioasm.get_current_program(yylhs.location, "code block", false, false).add_code_block( code_block(yylhs.location, of, yystack_[0].value.as < std::string > ())); } |
| break; |
| |
| case 14: // label_decl: symbol_def ":" |
| { yystack_[1].value.as < std::shared_ptr<symbol> > ()->is_label = true; yylhs.value.as < std::shared_ptr<symbol> > () = yystack_[1].value.as < std::shared_ptr<symbol> > (); } |
| break; |
| |
| case 15: // directive: ".define" symbol_def expression |
| { yystack_[1].value.as < std::shared_ptr<symbol> > ()->is_label = false; yystack_[1].value.as < std::shared_ptr<symbol> > ()->value = yystack_[0].value.as < std::shared_ptr<resolvable> > (); pioasm.get_current_program(yystack_[2].location, ".define", false, false).add_symbol(yystack_[1].value.as < std::shared_ptr<symbol> > ()); } |
| break; |
| |
| case 16: // directive: ".origin" value |
| { pioasm.get_current_program(yystack_[1].location, ".origin", true).set_origin(yylhs.location, yystack_[0].value.as < std::shared_ptr<resolvable> > ()); } |
| break; |
| |
| case 17: // directive: ".side_set" value "opt" "pindirs" |
| { pioasm.get_current_program(yystack_[3].location, ".side_set", true).set_sideset(yylhs.location, yystack_[2].value.as < std::shared_ptr<resolvable> > (), true, true); } |
| break; |
| |
| case 18: // directive: ".side_set" value "opt" |
| { pioasm.get_current_program(yystack_[2].location, ".side_set", true).set_sideset(yylhs.location, yystack_[1].value.as < std::shared_ptr<resolvable> > (), true, false); } |
| break; |
| |
| case 19: // directive: ".side_set" value "pindirs" |
| { pioasm.get_current_program(yystack_[2].location, ".side_set", true).set_sideset(yylhs.location, yystack_[1].value.as < std::shared_ptr<resolvable> > (), false, true); } |
| break; |
| |
| case 20: // directive: ".side_set" value |
| { pioasm.get_current_program(yystack_[1].location, ".side_set", true).set_sideset(yylhs.location, yystack_[0].value.as < std::shared_ptr<resolvable> > (), false, false); } |
| break; |
| |
| case 21: // directive: ".wrap_target" |
| { pioasm.get_current_program(yystack_[0].location, ".wrap_target").set_wrap_target(yylhs.location); } |
| break; |
| |
| case 22: // directive: ".wrap" |
| { pioasm.get_current_program(yystack_[0].location, ".wrap").set_wrap(yylhs.location); } |
| break; |
| |
| case 23: // directive: ".word" value |
| { pioasm.get_current_program(yystack_[1].location, "instruction").add_instruction(std::shared_ptr<instruction>(new instr_word(yylhs.location, yystack_[0].value.as < std::shared_ptr<resolvable> > ()))); } |
| break; |
| |
| case 24: // directive: ".lang_opt" "text" "text" "=" "integer" |
| { pioasm.get_current_program(yystack_[4].location, ".lang_opt").add_lang_opt(yystack_[3].value.as < std::string > (), yystack_[2].value.as < std::string > (), std::to_string(yystack_[0].value.as < int > ())); } |
| break; |
| |
| case 25: // directive: ".lang_opt" "text" "text" "=" "string" |
| { pioasm.get_current_program(yystack_[4].location, ".lang_opt").add_lang_opt(yystack_[3].value.as < std::string > (), yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } |
| break; |
| |
| case 26: // directive: ".lang_opt" "text" "text" "=" "text" |
| { pioasm.get_current_program(yystack_[4].location, ".lang_opt").add_lang_opt(yystack_[3].value.as < std::string > (), yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } |
| break; |
| |
| case 27: // directive: ".lang_opt" error |
| { error(yylhs.location, "expected format is .lang_opt language option_name = option_value"); } |
| break; |
| |
| case 28: // directive: UNKNOWN_DIRECTIVE |
| { std::stringstream msg; msg << "unknown directive " << yystack_[0].value.as < std::string > (); throw syntax_error(yylhs.location, msg.str()); } |
| break; |
| |
| case 29: // value: "integer" |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = resolvable_int(yylhs.location, yystack_[0].value.as < int > ()); } |
| break; |
| |
| case 30: // value: "identifier" |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = std::shared_ptr<resolvable>(new name_ref(yylhs.location, yystack_[0].value.as < std::string > ())); } |
| break; |
| |
| case 31: // value: "(" expression ")" |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = yystack_[1].value.as < std::shared_ptr<resolvable> > (); } |
| break; |
| |
| case 32: // expression: value |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = yystack_[0].value.as < std::shared_ptr<resolvable> > (); } |
| break; |
| |
| case 33: // expression: expression "+" expression |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = std::shared_ptr<binary_operation>(new binary_operation(yylhs.location, binary_operation::add, yystack_[2].value.as < std::shared_ptr<resolvable> > (), yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 34: // expression: expression "-" expression |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = std::shared_ptr<binary_operation>(new binary_operation(yylhs.location, binary_operation::subtract, yystack_[2].value.as < std::shared_ptr<resolvable> > (), yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 35: // expression: expression "*" expression |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = std::shared_ptr<binary_operation>(new binary_operation(yylhs.location, binary_operation::multiply, yystack_[2].value.as < std::shared_ptr<resolvable> > (), yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 36: // expression: expression "/" expression |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = std::shared_ptr<binary_operation>(new binary_operation(yylhs.location, binary_operation::divide, yystack_[2].value.as < std::shared_ptr<resolvable> > (), yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 37: // expression: expression "|" expression |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = std::shared_ptr<binary_operation>(new binary_operation(yylhs.location, binary_operation::or_, yystack_[2].value.as < std::shared_ptr<resolvable> > (), yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 38: // expression: expression "&" expression |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = std::shared_ptr<binary_operation>(new binary_operation(yylhs.location, binary_operation::and_, yystack_[2].value.as < std::shared_ptr<resolvable> > (), yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 39: // expression: expression "^" expression |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = std::shared_ptr<binary_operation>(new binary_operation(yylhs.location, binary_operation::xor_, yystack_[2].value.as < std::shared_ptr<resolvable> > (), yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 40: // expression: "-" expression |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = std::shared_ptr<unary_operation>(new unary_operation(yylhs.location, unary_operation::negate, yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 41: // expression: "::" expression |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = std::shared_ptr<unary_operation>(new unary_operation(yylhs.location, unary_operation::reverse, yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 42: // instruction: base_instruction sideset delay |
| { yylhs.value.as < std::shared_ptr<instruction> > () = yystack_[2].value.as < std::shared_ptr<instruction> > (); yylhs.value.as < std::shared_ptr<instruction> > ()->sideset = yystack_[1].value.as < std::shared_ptr<resolvable> > (); yylhs.value.as < std::shared_ptr<instruction> > ()->delay = yystack_[0].value.as < std::shared_ptr<resolvable> > (); } |
| break; |
| |
| case 43: // instruction: base_instruction delay sideset |
| { yylhs.value.as < std::shared_ptr<instruction> > () = yystack_[2].value.as < std::shared_ptr<instruction> > (); yylhs.value.as < std::shared_ptr<instruction> > ()->delay = yystack_[1].value.as < std::shared_ptr<resolvable> > (); yylhs.value.as < std::shared_ptr<instruction> > ()->sideset = yystack_[0].value.as < std::shared_ptr<resolvable> > (); } |
| break; |
| |
| case 44: // instruction: base_instruction sideset |
| { yylhs.value.as < std::shared_ptr<instruction> > () = yystack_[1].value.as < std::shared_ptr<instruction> > (); yylhs.value.as < std::shared_ptr<instruction> > ()->sideset = yystack_[0].value.as < std::shared_ptr<resolvable> > (); yylhs.value.as < std::shared_ptr<instruction> > ()->delay = resolvable_int(yylhs.location, 0); } |
| break; |
| |
| case 45: // instruction: base_instruction delay |
| { yylhs.value.as < std::shared_ptr<instruction> > () = yystack_[1].value.as < std::shared_ptr<instruction> > (); yylhs.value.as < std::shared_ptr<instruction> > ()->delay = yystack_[0].value.as < std::shared_ptr<resolvable> > (); } |
| break; |
| |
| case 46: // instruction: base_instruction |
| { yylhs.value.as < std::shared_ptr<instruction> > () = yystack_[0].value.as < std::shared_ptr<instruction> > (); yylhs.value.as < std::shared_ptr<instruction> > ()->delay = resolvable_int(yylhs.location, 0); } |
| break; |
| |
| case 47: // base_instruction: "nop" |
| { yylhs.value.as < std::shared_ptr<instruction> > () = std::shared_ptr<instruction>(new instr_nop(yylhs.location)); } |
| break; |
| |
| case 48: // base_instruction: "jmp" condition comma expression |
| { yylhs.value.as < std::shared_ptr<instruction> > () = std::shared_ptr<instruction>(new instr_jmp(yylhs.location, yystack_[2].value.as < enum condition > (), yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 49: // base_instruction: "wait" value wait_source |
| { yylhs.value.as < std::shared_ptr<instruction> > () = std::shared_ptr<instruction>(new instr_wait(yylhs.location, yystack_[1].value.as < std::shared_ptr<resolvable> > (), yystack_[0].value.as < std::shared_ptr<wait_source> > ())); } |
| break; |
| |
| case 50: // base_instruction: "wait" value "," value |
| { std::stringstream msg; location l; l.begin = yystack_[2].location.end; l.end = yystack_[1].location.end; msg << "expected irq, gpio or pin after the polarity value and before the \",\""; throw yy::parser::syntax_error(l, msg.str()); } |
| break; |
| |
| case 51: // base_instruction: "wait" wait_source |
| { yylhs.value.as < std::shared_ptr<instruction> > () = std::shared_ptr<instruction>(new instr_wait(yylhs.location, resolvable_int(yylhs.location, 1), yystack_[0].value.as < std::shared_ptr<wait_source> > ())); } |
| break; |
| |
| case 52: // base_instruction: "in" in_source comma value |
| { yylhs.value.as < std::shared_ptr<instruction> > () = std::shared_ptr<instruction>(new instr_in(yylhs.location, yystack_[2].value.as < enum in_out_set > (), yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 53: // base_instruction: "out" out_target comma value |
| { yylhs.value.as < std::shared_ptr<instruction> > () = std::shared_ptr<instruction>(new instr_out(yylhs.location, yystack_[2].value.as < enum in_out_set > (), yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 54: // base_instruction: "push" if_full blocking |
| { yylhs.value.as < std::shared_ptr<instruction> > () = std::shared_ptr<instruction>(new instr_push(yylhs.location, yystack_[1].value.as < bool > (), yystack_[0].value.as < bool > ())); } |
| break; |
| |
| case 55: // base_instruction: "pull" if_empty blocking |
| { yylhs.value.as < std::shared_ptr<instruction> > () = std::shared_ptr<instruction>(new instr_pull(yylhs.location, yystack_[1].value.as < bool > (), yystack_[0].value.as < bool > ())); } |
| break; |
| |
| case 56: // base_instruction: "mov" mov_target comma mov_op mov_source |
| { yylhs.value.as < std::shared_ptr<instruction> > () = std::shared_ptr<instruction>(new instr_mov(yylhs.location, yystack_[3].value.as < enum mov > (), yystack_[0].value.as < enum mov > (), yystack_[1].value.as < enum mov_op > ())); } |
| break; |
| |
| case 57: // base_instruction: "irq" irq_modifiers value "rel" |
| { yylhs.value.as < std::shared_ptr<instruction> > () = std::shared_ptr<instruction>(new instr_irq(yylhs.location, yystack_[2].value.as < enum irq > (), yystack_[1].value.as < std::shared_ptr<resolvable> > (), true)); } |
| break; |
| |
| case 58: // base_instruction: "irq" irq_modifiers value |
| { yylhs.value.as < std::shared_ptr<instruction> > () = std::shared_ptr<instruction>(new instr_irq(yylhs.location, yystack_[1].value.as < enum irq > (), yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 59: // base_instruction: "set" set_target comma value |
| { yylhs.value.as < std::shared_ptr<instruction> > () = std::shared_ptr<instruction>(new instr_set(yylhs.location, yystack_[2].value.as < enum in_out_set > (), yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 60: // delay: "[" expression "]" |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = yystack_[1].value.as < std::shared_ptr<resolvable> > (); } |
| break; |
| |
| case 61: // sideset: "side" value |
| { yylhs.value.as < std::shared_ptr<resolvable> > () = yystack_[0].value.as < std::shared_ptr<resolvable> > (); } |
| break; |
| |
| case 62: // condition: "!" "x" |
| { yylhs.value.as < enum condition > () = condition::xz; } |
| break; |
| |
| case 63: // condition: "x" "--" |
| { yylhs.value.as < enum condition > () = condition::xnz__; } |
| break; |
| |
| case 64: // condition: "!" "y" |
| { yylhs.value.as < enum condition > () = condition::yz; } |
| break; |
| |
| case 65: // condition: "y" "--" |
| { yylhs.value.as < enum condition > () = condition::ynz__; } |
| break; |
| |
| case 66: // condition: "x" "!=" "y" |
| { yylhs.value.as < enum condition > () = condition::xney; } |
| break; |
| |
| case 67: // condition: "pin" |
| { yylhs.value.as < enum condition > () = condition::pin; } |
| break; |
| |
| case 68: // condition: "!" "osre" |
| { yylhs.value.as < enum condition > () = condition::osrez; } |
| break; |
| |
| case 69: // condition: %empty |
| { yylhs.value.as < enum condition > () = condition::al; } |
| break; |
| |
| case 70: // wait_source: "irq" comma value "rel" |
| { yylhs.value.as < std::shared_ptr<wait_source> > () = std::shared_ptr<wait_source>(new wait_source(wait_source::irq, yystack_[1].value.as < std::shared_ptr<resolvable> > (), true)); } |
| break; |
| |
| case 71: // wait_source: "irq" comma value |
| { yylhs.value.as < std::shared_ptr<wait_source> > () = std::shared_ptr<wait_source>(new wait_source(wait_source::irq, yystack_[0].value.as < std::shared_ptr<resolvable> > (), false)); } |
| break; |
| |
| case 72: // wait_source: "gpio" comma value |
| { yylhs.value.as < std::shared_ptr<wait_source> > () = std::shared_ptr<wait_source>(new wait_source(wait_source::gpio, yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 73: // wait_source: "pin" comma value |
| { yylhs.value.as < std::shared_ptr<wait_source> > () = std::shared_ptr<wait_source>(new wait_source(wait_source::pin, yystack_[0].value.as < std::shared_ptr<resolvable> > ())); } |
| break; |
| |
| case 76: // in_source: "pins" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_set_pins; } |
| break; |
| |
| case 77: // in_source: "x" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_set_x; } |
| break; |
| |
| case 78: // in_source: "y" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_set_y; } |
| break; |
| |
| case 79: // in_source: "null" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_null; } |
| break; |
| |
| case 80: // in_source: "isr" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_isr; } |
| break; |
| |
| case 81: // in_source: "osr" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_osr; } |
| break; |
| |
| case 82: // in_source: "status" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_status; } |
| break; |
| |
| case 83: // out_target: "pins" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_set_pins; } |
| break; |
| |
| case 84: // out_target: "x" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_set_x; } |
| break; |
| |
| case 85: // out_target: "y" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_set_y; } |
| break; |
| |
| case 86: // out_target: "null" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_null; } |
| break; |
| |
| case 87: // out_target: "pindirs" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_set_pindirs; } |
| break; |
| |
| case 88: // out_target: "isr" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_isr; } |
| break; |
| |
| case 89: // out_target: "pc" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::out_set_pc; } |
| break; |
| |
| case 90: // out_target: "exec" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::out_exec; } |
| break; |
| |
| case 91: // mov_target: "pins" |
| { yylhs.value.as < enum mov > () = mov::pins; } |
| break; |
| |
| case 92: // mov_target: "x" |
| { yylhs.value.as < enum mov > () = mov::x; } |
| break; |
| |
| case 93: // mov_target: "y" |
| { yylhs.value.as < enum mov > () = mov::y; } |
| break; |
| |
| case 94: // mov_target: "exec" |
| { yylhs.value.as < enum mov > () = mov::exec; } |
| break; |
| |
| case 95: // mov_target: "pc" |
| { yylhs.value.as < enum mov > () = mov::pc; } |
| break; |
| |
| case 96: // mov_target: "isr" |
| { yylhs.value.as < enum mov > () = mov::isr; } |
| break; |
| |
| case 97: // mov_target: "osr" |
| { yylhs.value.as < enum mov > () = mov::osr; } |
| break; |
| |
| case 98: // mov_source: "pins" |
| { yylhs.value.as < enum mov > () = mov::pins; } |
| break; |
| |
| case 99: // mov_source: "x" |
| { yylhs.value.as < enum mov > () = mov::x; } |
| break; |
| |
| case 100: // mov_source: "y" |
| { yylhs.value.as < enum mov > () = mov::y; } |
| break; |
| |
| case 101: // mov_source: "null" |
| { yylhs.value.as < enum mov > () = mov::null; } |
| break; |
| |
| case 102: // mov_source: "status" |
| { yylhs.value.as < enum mov > () = mov::status; } |
| break; |
| |
| case 103: // mov_source: "isr" |
| { yylhs.value.as < enum mov > () = mov::isr; } |
| break; |
| |
| case 104: // mov_source: "osr" |
| { yylhs.value.as < enum mov > () = mov::osr; } |
| break; |
| |
| case 105: // mov_op: "!" |
| { yylhs.value.as < enum mov_op > () = mov_op::invert; } |
| break; |
| |
| case 106: // mov_op: "::" |
| { yylhs.value.as < enum mov_op > () = mov_op::bit_reverse; } |
| break; |
| |
| case 107: // mov_op: %empty |
| { yylhs.value.as < enum mov_op > () = mov_op::none; } |
| break; |
| |
| case 108: // set_target: "pins" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_set_pins; } |
| break; |
| |
| case 109: // set_target: "x" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_set_x; } |
| break; |
| |
| case 110: // set_target: "y" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_set_y; } |
| break; |
| |
| case 111: // set_target: "pindirs" |
| { yylhs.value.as < enum in_out_set > () = in_out_set::in_out_set_pindirs; } |
| break; |
| |
| case 112: // if_full: "iffull" |
| { yylhs.value.as < bool > () = true; } |
| break; |
| |
| case 113: // if_full: %empty |
| { yylhs.value.as < bool > () = false; } |
| break; |
| |
| case 114: // if_empty: "ifempty" |
| { yylhs.value.as < bool > () = true; } |
| break; |
| |
| case 115: // if_empty: %empty |
| { yylhs.value.as < bool > () = false; } |
| break; |
| |
| case 116: // blocking: "block" |
| { yylhs.value.as < bool > () = true; } |
| break; |
| |
| case 117: // blocking: "noblock" |
| { yylhs.value.as < bool > () = false; } |
| break; |
| |
| case 118: // blocking: %empty |
| { yylhs.value.as < bool > () = true; } |
| break; |
| |
| case 119: // irq_modifiers: "clear" |
| { yylhs.value.as < enum irq > () = irq::clear; } |
| break; |
| |
| case 120: // irq_modifiers: "wait" |
| { yylhs.value.as < enum irq > () = irq::set_wait; } |
| break; |
| |
| case 121: // irq_modifiers: "nowait" |
| { yylhs.value.as < enum irq > () = irq::set; } |
| break; |
| |
| case 122: // irq_modifiers: "set" |
| { yylhs.value.as < enum irq > () = irq::set; } |
| break; |
| |
| case 123: // irq_modifiers: %empty |
| { yylhs.value.as < enum irq > () = irq::set; } |
| break; |
| |
| case 124: // symbol_def: "identifier" |
| { yylhs.value.as < std::shared_ptr<symbol> > () = std::shared_ptr<symbol>(new symbol(yylhs.location, yystack_[0].value.as < std::string > ())); } |
| break; |
| |
| case 125: // symbol_def: "public" "identifier" |
| { yylhs.value.as < std::shared_ptr<symbol> > () = std::shared_ptr<symbol>(new symbol(yylhs.location, yystack_[0].value.as < std::string > (), true)); } |
| break; |
| |
| case 126: // symbol_def: "*" "identifier" |
| { yylhs.value.as < std::shared_ptr<symbol> > () = std::shared_ptr<symbol>(new symbol(yylhs.location, yystack_[0].value.as < std::string > (), true)); } |
| break; |
| |
| |
| |
| default: |
| break; |
| } |
| } |
| #if YY_EXCEPTIONS |
| catch (const syntax_error& yyexc) |
| { |
| YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; |
| error (yyexc); |
| YYERROR; |
| } |
| #endif // YY_EXCEPTIONS |
| YY_SYMBOL_PRINT ("-> $$ =", yylhs); |
| yypop_ (yylen); |
| yylen = 0; |
| |
| // Shift the result of the reduction. |
| yypush_ (YY_NULLPTR, YY_MOVE (yylhs)); |
| } |
| goto yynewstate; |
| |
| |
| /*--------------------------------------. |
| | yyerrlab -- here on detecting error. | |
| `--------------------------------------*/ |
| yyerrlab: |
| // If not already recovering from an error, report this error. |
| if (!yyerrstatus_) |
| { |
| ++yynerrs_; |
| context yyctx (*this, yyla); |
| std::string msg = yysyntax_error_ (yyctx); |
| error (yyla.location, YY_MOVE (msg)); |
| } |
| |
| |
| yyerror_range[1].location = yyla.location; |
| if (yyerrstatus_ == 3) |
| { |
| /* If just tried and failed to reuse lookahead token after an |
| error, discard it. */ |
| |
| // Return failure if at end of input. |
| if (yyla.kind () == symbol_kind::S_YYEOF) |
| YYABORT; |
| else if (!yyla.empty ()) |
| { |
| yy_destroy_ ("Error: discarding", yyla); |
| yyla.clear (); |
| } |
| } |
| |
| // Else will try to reuse lookahead token after shifting the error token. |
| goto yyerrlab1; |
| |
| |
| /*---------------------------------------------------. |
| | yyerrorlab -- error raised explicitly by YYERROR. | |
| `---------------------------------------------------*/ |
| yyerrorlab: |
| /* Pacify compilers when the user code never invokes YYERROR and |
| the label yyerrorlab therefore never appears in user code. */ |
| if (false) |
| YYERROR; |
| |
| /* Do not reclaim the symbols of the rule whose action triggered |
| this YYERROR. */ |
| yypop_ (yylen); |
| yylen = 0; |
| YY_STACK_PRINT (); |
| goto yyerrlab1; |
| |
| |
| /*-------------------------------------------------------------. |
| | yyerrlab1 -- common code for both syntax error and YYERROR. | |
| `-------------------------------------------------------------*/ |
| yyerrlab1: |
| yyerrstatus_ = 3; // Each real token shifted decrements this. |
| // Pop stack until we find a state that shifts the error token. |
| for (;;) |
| { |
| yyn = yypact_[+yystack_[0].state]; |
| if (!yy_pact_value_is_default_ (yyn)) |
| { |
| yyn += symbol_kind::S_YYerror; |
| if (0 <= yyn && yyn <= yylast_ |
| && yycheck_[yyn] == symbol_kind::S_YYerror) |
| { |
| yyn = yytable_[yyn]; |
| if (0 < yyn) |
| break; |
| } |
| } |
| |
| // Pop the current state because it cannot handle the error token. |
| if (yystack_.size () == 1) |
| YYABORT; |
| |
| yyerror_range[1].location = yystack_[0].location; |
| yy_destroy_ ("Error: popping", yystack_[0]); |
| yypop_ (); |
| YY_STACK_PRINT (); |
| } |
| { |
| stack_symbol_type error_token; |
| |
| yyerror_range[2].location = yyla.location; |
| YYLLOC_DEFAULT (error_token.location, yyerror_range, 2); |
| |
| // Shift the error token. |
| yy_lac_discard_ ("error recovery"); |
| error_token.state = state_type (yyn); |
| yypush_ ("Shifting", YY_MOVE (error_token)); |
| } |
| goto yynewstate; |
| |
| |
| /*-------------------------------------. |
| | yyacceptlab -- YYACCEPT comes here. | |
| `-------------------------------------*/ |
| yyacceptlab: |
| yyresult = 0; |
| goto yyreturn; |
| |
| |
| /*-----------------------------------. |
| | yyabortlab -- YYABORT comes here. | |
| `-----------------------------------*/ |
| yyabortlab: |
| yyresult = 1; |
| goto yyreturn; |
| |
| |
| /*-----------------------------------------------------. |
| | yyreturn -- parsing is finished, return the result. | |
| `-----------------------------------------------------*/ |
| yyreturn: |
| if (!yyla.empty ()) |
| yy_destroy_ ("Cleanup: discarding lookahead", yyla); |
| |
| /* Do not reclaim the symbols of the rule whose action triggered |
| this YYABORT or YYACCEPT. */ |
| yypop_ (yylen); |
| YY_STACK_PRINT (); |
| while (1 < yystack_.size ()) |
| { |
| yy_destroy_ ("Cleanup: popping", yystack_[0]); |
| yypop_ (); |
| } |
| |
| return yyresult; |
| } |
| #if YY_EXCEPTIONS |
| catch (...) |
| { |
| YYCDEBUG << "Exception caught: cleaning lookahead and stack\n"; |
| // Do not try to display the values of the reclaimed symbols, |
| // as their printers might throw an exception. |
| if (!yyla.empty ()) |
| yy_destroy_ (YY_NULLPTR, yyla); |
| |
| while (1 < yystack_.size ()) |
| { |
| yy_destroy_ (YY_NULLPTR, yystack_[0]); |
| yypop_ (); |
| } |
| throw; |
| } |
| #endif // YY_EXCEPTIONS |
| } |
| |
| void |
| parser::error (const syntax_error& yyexc) |
| { |
| error (yyexc.location, yyexc.what ()); |
| } |
| |
| /* Return YYSTR after stripping away unnecessary quotes and |
| backslashes, so that it's suitable for yyerror. The heuristic is |
| that double-quoting is unnecessary unless the string contains an |
| apostrophe, a comma, or backslash (other than backslash-backslash). |
| YYSTR is taken from yytname. */ |
| std::string |
| parser::yytnamerr_ (const char *yystr) |
| { |
| if (*yystr == '"') |
| { |
| std::string yyr; |
| char const *yyp = yystr; |
| |
| for (;;) |
| switch (*++yyp) |
| { |
| case '\'': |
| case ',': |
| goto do_not_strip_quotes; |
| |
| case '\\': |
| if (*++yyp != '\\') |
| goto do_not_strip_quotes; |
| else |
| goto append; |
| |
| append: |
| default: |
| yyr += *yyp; |
| break; |
| |
| case '"': |
| return yyr; |
| } |
| do_not_strip_quotes: ; |
| } |
| |
| return yystr; |
| } |
| |
| std::string |
| parser::symbol_name (symbol_kind_type yysymbol) |
| { |
| return yytnamerr_ (yytname_[yysymbol]); |
| } |
| |
| |
| |
| // parser::context. |
| parser::context::context (const parser& yyparser, const symbol_type& yyla) |
| : yyparser_ (yyparser) |
| , yyla_ (yyla) |
| {} |
| |
| int |
| parser::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const |
| { |
| // Actual number of expected tokens |
| int yycount = 0; |
| |
| #if YYDEBUG |
| // Execute LAC once. We don't care if it is successful, we |
| // only do it for the sake of debugging output. |
| if (!yyparser_.yy_lac_established_) |
| yyparser_.yy_lac_check_ (yyla_.kind ()); |
| #endif |
| |
| for (int yyx = 0; yyx < YYNTOKENS; ++yyx) |
| { |
| symbol_kind_type yysym = YY_CAST (symbol_kind_type, yyx); |
| if (yysym != symbol_kind::S_YYerror |
| && yysym != symbol_kind::S_YYUNDEF |
| && yyparser_.yy_lac_check_ (yysym)) |
| { |
| if (!yyarg) |
| ++yycount; |
| else if (yycount == yyargn) |
| return 0; |
| else |
| yyarg[yycount++] = yysym; |
| } |
| } |
| if (yyarg && yycount == 0 && 0 < yyargn) |
| yyarg[0] = symbol_kind::S_YYEMPTY; |
| return yycount; |
| } |
| |
| |
| bool |
| parser::yy_lac_check_ (symbol_kind_type yytoken) const |
| { |
| // Logically, the yylac_stack's lifetime is confined to this function. |
| // Clear it, to get rid of potential left-overs from previous call. |
| yylac_stack_.clear (); |
| // Reduce until we encounter a shift and thereby accept the token. |
| #if YYDEBUG |
| YYCDEBUG << "LAC: checking lookahead " << symbol_name (yytoken) << ':'; |
| #endif |
| std::ptrdiff_t lac_top = 0; |
| while (true) |
| { |
| state_type top_state = (yylac_stack_.empty () |
| ? yystack_[lac_top].state |
| : yylac_stack_.back ()); |
| int yyrule = yypact_[+top_state]; |
| if (yy_pact_value_is_default_ (yyrule) |
| || (yyrule += yytoken) < 0 || yylast_ < yyrule |
| || yycheck_[yyrule] != yytoken) |
| { |
| // Use the default action. |
| yyrule = yydefact_[+top_state]; |
| if (yyrule == 0) |
| { |
| YYCDEBUG << " Err\n"; |
| return false; |
| } |
| } |
| else |
| { |
| // Use the action from yytable. |
| yyrule = yytable_[yyrule]; |
| if (yy_table_value_is_error_ (yyrule)) |
| { |
| YYCDEBUG << " Err\n"; |
| return false; |
| } |
| if (0 < yyrule) |
| { |
| YYCDEBUG << " S" << yyrule << '\n'; |
| return true; |
| } |
| yyrule = -yyrule; |
| } |
| // By now we know we have to simulate a reduce. |
| YYCDEBUG << " R" << yyrule - 1; |
| // Pop the corresponding number of values from the stack. |
| { |
| std::ptrdiff_t yylen = yyr2_[yyrule]; |
| // First pop from the LAC stack as many tokens as possible. |
| std::ptrdiff_t lac_size = std::ptrdiff_t (yylac_stack_.size ()); |
| if (yylen < lac_size) |
| { |
| yylac_stack_.resize (std::size_t (lac_size - yylen)); |
| yylen = 0; |
| } |
| else if (lac_size) |
| { |
| yylac_stack_.clear (); |
| yylen -= lac_size; |
| } |
| // Only afterwards look at the main stack. |
| // We simulate popping elements by incrementing lac_top. |
| lac_top += yylen; |
| } |
| // Keep top_state in sync with the updated stack. |
| top_state = (yylac_stack_.empty () |
| ? yystack_[lac_top].state |
| : yylac_stack_.back ()); |
| // Push the resulting state of the reduction. |
| state_type state = yy_lr_goto_state_ (top_state, yyr1_[yyrule]); |
| YYCDEBUG << " G" << int (state); |
| yylac_stack_.push_back (state); |
| } |
| } |
| |
| // Establish the initial context if no initial context currently exists. |
| bool |
| parser::yy_lac_establish_ (symbol_kind_type yytoken) |
| { |
| /* Establish the initial context for the current lookahead if no initial |
| context is currently established. |
| |
| We define a context as a snapshot of the parser stacks. We define |
| the initial context for a lookahead as the context in which the |
| parser initially examines that lookahead in order to select a |
| syntactic action. Thus, if the lookahead eventually proves |
| syntactically unacceptable (possibly in a later context reached via a |
| series of reductions), the initial context can be used to determine |
| the exact set of tokens that would be syntactically acceptable in the |
| lookahead's place. Moreover, it is the context after which any |
| further semantic actions would be erroneous because they would be |
| determined by a syntactically unacceptable token. |
| |
| yy_lac_establish_ should be invoked when a reduction is about to be |
| performed in an inconsistent state (which, for the purposes of LAC, |
| includes consistent states that don't know they're consistent because |
| their default reductions have been disabled). |
| |
| For parse.lac=full, the implementation of yy_lac_establish_ is as |
| follows. If no initial context is currently established for the |
| current lookahead, then check if that lookahead can eventually be |
| shifted if syntactic actions continue from the current context. */ |
| if (!yy_lac_established_) |
| { |
| #if YYDEBUG |
| YYCDEBUG << "LAC: initial context established for " |
| << symbol_name (yytoken) << '\n'; |
| #endif |
| yy_lac_established_ = true; |
| return yy_lac_check_ (yytoken); |
| } |
| return true; |
| } |
| |
| // Discard any previous initial lookahead context. |
| void |
| parser::yy_lac_discard_ (const char* evt) |
| { |
| /* Discard any previous initial lookahead context because of Event, |
| which may be a lookahead change or an invalidation of the currently |
| established initial context for the current lookahead. |
| |
| The most common example of a lookahead change is a shift. An example |
| of both cases is syntax error recovery. That is, a syntax error |
| occurs when the lookahead is syntactically erroneous for the |
| currently established initial context, so error recovery manipulates |
| the parser stacks to try to find a new initial context in which the |
| current lookahead is syntactically acceptable. If it fails to find |
| such a context, it discards the lookahead. */ |
| if (yy_lac_established_) |
| { |
| YYCDEBUG << "LAC: initial context discarded due to " |
| << evt << '\n'; |
| yy_lac_established_ = false; |
| } |
| } |
| |
| int |
| parser::yy_syntax_error_arguments_ (const context& yyctx, |
| symbol_kind_type yyarg[], int yyargn) const |
| { |
| /* There are many possibilities here to consider: |
| - If this state is a consistent state with a default action, then |
| the only way this function was invoked is if the default action |
| is an error action. In that case, don't check for expected |
| tokens because there are none. |
| - The only way there can be no lookahead present (in yyla) is |
| if this state is a consistent state with a default action. |
| Thus, detecting the absence of a lookahead is sufficient to |
| determine that there is no unexpected or expected token to |
| report. In that case, just report a simple "syntax error". |
| - Don't assume there isn't a lookahead just because this state is |
| a consistent state with a default action. There might have |
| been a previous inconsistent state, consistent state with a |
| non-default action, or user semantic action that manipulated |
| yyla. (However, yyla is currently not documented for users.) |
| In the first two cases, it might appear that the current syntax |
| error should have been detected in the previous state when |
| yy_lac_check was invoked. However, at that time, there might |
| have been a different syntax error that discarded a different |
| initial context during error recovery, leaving behind the |
| current lookahead. |
| */ |
| |
| if (!yyctx.lookahead ().empty ()) |
| { |
| if (yyarg) |
| yyarg[0] = yyctx.token (); |
| int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1); |
| return yyn + 1; |
| } |
| return 0; |
| } |
| |
| // Generate an error message. |
| std::string |
| parser::yysyntax_error_ (const context& yyctx) const |
| { |
| // Its maximum. |
| enum { YYARGS_MAX = 5 }; |
| // Arguments of yyformat. |
| symbol_kind_type yyarg[YYARGS_MAX]; |
| int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX); |
| |
| char const* yyformat = YY_NULLPTR; |
| switch (yycount) |
| { |
| #define YYCASE_(N, S) \ |
| case N: \ |
| yyformat = S; \ |
| break |
| default: // Avoid compiler warnings. |
| YYCASE_ (0, YY_("syntax error")); |
| YYCASE_ (1, YY_("syntax error, unexpected %s")); |
| YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s")); |
| YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s")); |
| YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); |
| YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); |
| #undef YYCASE_ |
| } |
| |
| std::string yyres; |
| // Argument number. |
| std::ptrdiff_t yyi = 0; |
| for (char const* yyp = yyformat; *yyp; ++yyp) |
| if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) |
| { |
| yyres += symbol_name (yyarg[yyi++]); |
| ++yyp; |
| } |
| else |
| yyres += *yyp; |
| return yyres; |
| } |
| |
| |
| const signed char parser::yypact_ninf_ = -52; |
| |
| const signed char parser::yytable_ninf_ = -12; |
| |
| const short |
| parser::yypact_[] = |
| { |
| 3, -52, -41, -39, -52, -52, -3, 5, 5, 5, |
| 7, 44, 10, 0, 101, 18, 30, 94, 51, 50, |
| -52, 20, -52, 13, -52, 88, 17, -52, -52, 129, |
| -52, -52, 2, 85, -52, -52, 1, 1, -52, -52, |
| 40, -52, -52, -52, 42, 58, -52, 28, 96, 120, |
| 120, 120, 120, 15, -52, -52, -52, -52, -52, -52, |
| -52, -52, 120, -52, -52, -52, -52, -52, -52, -52, |
| -52, 120, -52, 63, -52, 63, -52, -52, -52, -52, |
| -52, -52, -52, 120, -52, -52, -52, -52, 5, -52, |
| -52, -52, -52, 120, -52, -52, -52, -52, 3, -52, |
| 1, 5, 45, 130, -52, 1, 1, -52, 177, 162, |
| -52, 97, 132, -52, -52, -52, -52, 87, -52, -52, |
| 1, 5, 5, 5, 5, -52, 5, 5, -52, -52, |
| -52, -52, 29, 118, 5, -52, 170, -52, -52, -52, |
| 107, 177, 1, 1, 1, 1, 1, 1, 1, -52, |
| -52, -51, -52, 177, 119, -52, -52, -52, -52, -52, |
| -52, -52, 82, -52, -52, -52, 107, 107, 184, 184, |
| -52, -52, -52, -52, -52, -52, -52, -52, -52, -52, |
| -52, -52, -52, -52, -52 |
| }; |
| |
| const signed char |
| parser::yydefact_[] = |
| { |
| 0, 12, 0, 0, 21, 22, 0, 0, 0, 0, |
| 0, 69, 0, 0, 0, 113, 115, 0, 123, 0, |
| 47, 0, 124, 0, 28, 0, 0, 3, 10, 9, |
| 6, 7, 46, 0, 126, 5, 0, 0, 30, 29, |
| 20, 23, 16, 27, 0, 0, 67, 0, 0, 75, |
| 75, 75, 75, 0, 51, 76, 79, 77, 78, 80, |
| 81, 82, 75, 83, 86, 87, 84, 85, 90, 89, |
| 88, 75, 112, 118, 114, 118, 91, 92, 93, 94, |
| 95, 96, 97, 75, 120, 122, 121, 119, 0, 108, |
| 111, 109, 110, 75, 125, 13, 1, 2, 0, 8, |
| 0, 0, 45, 44, 14, 0, 0, 32, 15, 0, |
| 19, 18, 0, 68, 62, 64, 63, 0, 65, 74, |
| 0, 0, 0, 0, 0, 49, 0, 0, 116, 117, |
| 54, 55, 107, 58, 0, 4, 0, 61, 43, 42, |
| 40, 41, 0, 0, 0, 0, 0, 0, 0, 31, |
| 17, 0, 66, 48, 71, 73, 72, 50, 52, 53, |
| 105, 106, 0, 57, 59, 60, 33, 34, 35, 36, |
| 37, 38, 39, 25, 26, 24, 70, 98, 101, 99, |
| 100, 103, 104, 102, 56 |
| }; |
| |
| const short |
| parser::yypgoto_[] = |
| { |
| -52, -52, -52, 98, -52, -52, -52, -7, -14, 168, |
| -52, 99, 102, -52, 148, 25, -52, -52, -52, -52, |
| -52, -52, -52, -52, 128, -52, 199 |
| }; |
| |
| const short |
| parser::yydefgoto_[] = |
| { |
| -1, 25, 26, 27, 28, 29, 30, 107, 108, 31, |
| 32, 102, 103, 49, 54, 120, 62, 71, 83, 184, |
| 162, 93, 73, 75, 130, 88, 33 |
| }; |
| |
| const short |
| parser::yytable_[] = |
| { |
| 40, 41, 42, -11, 1, 53, -11, 37, 43, 2, |
| 100, 37, 105, 173, 174, 2, 37, 97, 175, 124, |
| 98, 106, 34, 109, 35, 3, 4, 5, 6, 7, |
| 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, |
| 18, 19, 20, 55, 56, 116, 117, 50, 160, 161, |
| 51, 52, 50, 57, 58, 51, 52, 59, 60, 21, |
| 22, 61, 101, 45, 38, 21, 22, 72, 38, 23, |
| 39, 24, 44, 38, 39, 121, 122, 123, 74, 39, |
| 95, 133, 84, 94, 46, 110, 136, 126, 96, 85, |
| 104, 140, 141, 89, 137, 90, 127, 47, 48, 111, |
| 113, 86, 87, 91, 92, 101, 153, 112, 132, 128, |
| 129, 114, 115, 118, 154, 155, 156, 157, 134, 158, |
| 159, 146, 147, 148, 119, 177, 178, 164, 166, 167, |
| 168, 169, 170, 171, 172, 179, 180, 76, 100, 181, |
| 182, 152, 150, 183, 63, 64, 65, 77, 78, 79, |
| 80, 81, 82, 151, 66, 67, 68, 69, 70, 11, |
| 12, 13, 14, 15, 16, 17, 18, 19, 20, 149, |
| 163, 176, 142, 143, 144, 145, 146, 147, 148, 165, |
| 142, 143, 144, 145, 146, 147, 148, 142, 143, 144, |
| 145, 146, 147, 148, 142, 143, 135, 99, 146, 147, |
| 148, 125, 139, 131, 138, 36 |
| }; |
| |
| const unsigned char |
| parser::yycheck_[] = |
| { |
| 7, 8, 9, 0, 1, 12, 3, 6, 1, 12, |
| 8, 6, 11, 64, 65, 12, 6, 0, 69, 4, |
| 3, 20, 63, 37, 63, 22, 23, 24, 25, 26, |
| 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, |
| 37, 38, 39, 43, 44, 17, 18, 37, 19, 20, |
| 40, 41, 37, 53, 54, 40, 41, 57, 58, 62, |
| 63, 61, 60, 19, 63, 62, 63, 49, 63, 66, |
| 69, 68, 65, 63, 69, 50, 51, 52, 48, 69, |
| 67, 88, 31, 63, 40, 45, 100, 62, 0, 38, |
| 5, 105, 106, 43, 101, 45, 71, 53, 54, 59, |
| 42, 50, 51, 53, 54, 60, 120, 65, 83, 46, |
| 47, 53, 54, 17, 121, 122, 123, 124, 93, 126, |
| 127, 14, 15, 16, 4, 43, 44, 134, 142, 143, |
| 144, 145, 146, 147, 148, 53, 54, 43, 8, 57, |
| 58, 54, 45, 61, 43, 44, 45, 53, 54, 55, |
| 56, 57, 58, 21, 53, 54, 55, 56, 57, 30, |
| 31, 32, 33, 34, 35, 36, 37, 38, 39, 7, |
| 52, 52, 10, 11, 12, 13, 14, 15, 16, 9, |
| 10, 11, 12, 13, 14, 15, 16, 10, 11, 12, |
| 13, 14, 15, 16, 10, 11, 98, 29, 14, 15, |
| 16, 53, 103, 75, 102, 6 |
| }; |
| |
| const signed char |
| parser::yystos_[] = |
| { |
| 0, 1, 12, 22, 23, 24, 25, 26, 27, 28, |
| 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, |
| 39, 62, 63, 66, 68, 71, 72, 73, 74, 75, |
| 76, 79, 80, 96, 63, 63, 96, 6, 63, 69, |
| 77, 77, 77, 1, 65, 19, 40, 53, 54, 83, |
| 37, 40, 41, 77, 84, 43, 44, 53, 54, 57, |
| 58, 61, 86, 43, 44, 45, 53, 54, 55, 56, |
| 57, 87, 49, 92, 48, 93, 43, 53, 54, 55, |
| 56, 57, 58, 88, 31, 38, 50, 51, 95, 43, |
| 45, 53, 54, 91, 63, 67, 0, 0, 3, 79, |
| 8, 60, 81, 82, 5, 11, 20, 77, 78, 78, |
| 45, 59, 65, 42, 53, 54, 17, 18, 17, 4, |
| 85, 85, 85, 85, 4, 84, 85, 85, 46, 47, |
| 94, 94, 85, 77, 85, 73, 78, 77, 82, 81, |
| 78, 78, 10, 11, 12, 13, 14, 15, 16, 7, |
| 45, 21, 54, 78, 77, 77, 77, 77, 77, 77, |
| 19, 20, 90, 52, 77, 9, 78, 78, 78, 78, |
| 78, 78, 78, 64, 65, 69, 52, 43, 44, 53, |
| 54, 57, 58, 61, 89 |
| }; |
| |
| const signed char |
| parser::yyr1_[] = |
| { |
| 0, 70, 71, 72, 72, 73, 73, 73, 73, 73, |
| 73, 73, 73, 74, 75, 76, 76, 76, 76, 76, |
| 76, 76, 76, 76, 76, 76, 76, 76, 76, 77, |
| 77, 77, 78, 78, 78, 78, 78, 78, 78, 78, |
| 78, 78, 79, 79, 79, 79, 79, 80, 80, 80, |
| 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, |
| 81, 82, 83, 83, 83, 83, 83, 83, 83, 83, |
| 84, 84, 84, 84, 85, 85, 86, 86, 86, 86, |
| 86, 86, 86, 87, 87, 87, 87, 87, 87, 87, |
| 87, 88, 88, 88, 88, 88, 88, 88, 89, 89, |
| 89, 89, 89, 89, 89, 90, 90, 90, 91, 91, |
| 91, 91, 92, 92, 93, 93, 94, 94, 94, 95, |
| 95, 95, 95, 95, 96, 96, 96 |
| }; |
| |
| const signed char |
| parser::yyr2_[] = |
| { |
| 0, 2, 2, 1, 3, 2, 1, 1, 2, 1, |
| 1, 0, 1, 2, 2, 3, 2, 4, 3, 3, |
| 2, 1, 1, 2, 5, 5, 5, 2, 1, 1, |
| 1, 3, 1, 3, 3, 3, 3, 3, 3, 3, |
| 2, 2, 3, 3, 2, 2, 1, 1, 4, 3, |
| 4, 2, 4, 4, 3, 3, 5, 4, 3, 4, |
| 3, 2, 2, 2, 2, 2, 3, 1, 2, 0, |
| 4, 3, 3, 3, 1, 0, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, |
| 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, |
| 1, 1, 1, 0, 1, 2, 2 |
| }; |
| |
| |
| #if YYDEBUG || 1 |
| // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
| // First, the terminals, then, starting at \a YYNTOKENS, nonterminals. |
| const char* |
| const parser::yytname_[] = |
| { |
| "\"end of file\"", "error", "\"invalid token\"", "\"end of line\"", |
| "\",\"", "\":\"", "\"(\"", "\")\"", "\"[\"", "\"]\"", "\"+\"", "\"-\"", |
| "\"*\"", "\"/\"", "\"|\"", "\"&\"", "\"^\"", "\"--\"", "\"!=\"", "\"!\"", |
| "\"::\"", "\"=\"", "\".program\"", "\".wrap_target\"", "\".wrap\"", |
| "\".define\"", "\".side_set\"", "\".word\"", "\".origin\"", |
| "\".lang_opt\"", "\"jmp\"", "\"wait\"", "\"in\"", "\"out\"", "\"push\"", |
| "\"pull\"", "\"mov\"", "\"irq\"", "\"set\"", "\"nop\"", "\"pin\"", |
| "\"gpio\"", "\"osre\"", "\"pins\"", "\"null\"", "\"pindirs\"", |
| "\"block\"", "\"noblock\"", "\"ifempty\"", "\"iffull\"", "\"nowait\"", |
| "\"clear\"", "\"rel\"", "\"x\"", "\"y\"", "\"exec\"", "\"pc\"", |
| "\"isr\"", "\"osr\"", "\"opt\"", "\"side\"", "\"status\"", "\"public\"", |
| "\"identifier\"", "\"string\"", "\"text\"", "\"code block\"", "\"%}\"", |
| "UNKNOWN_DIRECTIVE", "\"integer\"", "$accept", "file", "lines", "line", |
| "code_block", "label_decl", "directive", "value", "expression", |
| "instruction", "base_instruction", "delay", "sideset", "condition", |
| "wait_source", "comma", "in_source", "out_target", "mov_target", |
| "mov_source", "mov_op", "set_target", "if_full", "if_empty", "blocking", |
| "irq_modifiers", "symbol_def", YY_NULLPTR |
| }; |
| #endif |
| |
| |
| #if YYDEBUG |
| const short |
| parser::yyrline_[] = |
| { |
| 0, 136, 136, 140, 141, 144, 145, 146, 147, 148, |
| 149, 150, 151, 155, 159, 162, 163, 164, 165, 166, |
| 167, 168, 169, 170, 171, 172, 173, 174, 175, 180, |
| 181, 182, 186, 187, 188, 189, 190, 191, 192, 193, |
| 194, 195, 199, 200, 201, 202, 203, 207, 208, 209, |
| 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, |
| 224, 228, 232, 233, 234, 235, 236, 237, 238, 239, |
| 243, 244, 245, 246, 248, 248, 251, 252, 253, 254, |
| 255, 256, 257, 260, 261, 262, 263, 264, 265, 266, |
| 267, 270, 271, 272, 273, 274, 275, 276, 279, 280, |
| 281, 282, 283, 284, 285, 289, 290, 291, 295, 296, |
| 297, 298, 302, 303, 307, 308, 312, 313, 314, 318, |
| 319, 320, 321, 322, 326, 327, 328 |
| }; |
| |
| void |
| parser::yy_stack_print_ () const |
| { |
| *yycdebug_ << "Stack now"; |
| for (stack_type::const_iterator |
| i = yystack_.begin (), |
| i_end = yystack_.end (); |
| i != i_end; ++i) |
| *yycdebug_ << ' ' << int (i->state); |
| *yycdebug_ << '\n'; |
| } |
| |
| void |
| parser::yy_reduce_print_ (int yyrule) const |
| { |
| int yylno = yyrline_[yyrule]; |
| int yynrhs = yyr2_[yyrule]; |
| // Print the symbols being reduced, and their result. |
| *yycdebug_ << "Reducing stack by rule " << yyrule - 1 |
| << " (line " << yylno << "):\n"; |
| // The symbols being reduced. |
| for (int yyi = 0; yyi < yynrhs; yyi++) |
| YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", |
| yystack_[(yynrhs) - (yyi + 1)]); |
| } |
| #endif // YYDEBUG |
| |
| |
| } // yy |
| |
| |
| void yy::parser::error(const location_type& l, const std::string& m) |
| { |
| if (l.begin.filename) { |
| std::cerr << l << ": " << m << '\n'; |
| pioasm.error_count++; |
| if (l.begin.line == l.end.line && *l.begin.filename == *l.end.filename) { |
| std::ifstream file(l.begin.filename->c_str()); |
| std::string line; |
| for(int i = 0; i < l.begin.line; ++i) { |
| std::getline(file, line); |
| } |
| fprintf(stderr, "%5d | %s\n", l.begin.line, line.c_str()); |
| fprintf(stderr, "%5s | %*s", "", l.begin.column, "^"); |
| for (int i = l.begin.column; i < l.end.column - 1; i++) { |
| putc ('~', stderr); |
| } |
| putc ('\n', stderr); |
| } |
| } else { |
| std::cerr << m << '\n'; |
| } |
| } |
| |
