diff options
Diffstat (limited to 'circuitpython/ports/raspberrypi/sdk/tools/pioasm/gen/parser.cpp')
| -rw-r--r-- | circuitpython/ports/raspberrypi/sdk/tools/pioasm/gen/parser.cpp | 2208 |
1 files changed, 2208 insertions, 0 deletions
diff --git a/circuitpython/ports/raspberrypi/sdk/tools/pioasm/gen/parser.cpp b/circuitpython/ports/raspberrypi/sdk/tools/pioasm/gen/parser.cpp new file mode 100644 index 0000000..c9bd036 --- /dev/null +++ b/circuitpython/ports/raspberrypi/sdk/tools/pioasm/gen/parser.cpp @@ -0,0 +1,2208 @@ +// 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, + 182, 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, 182, 182, 107, 107, + -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, 102, -52, -52, -52, -7, -14, 172, + -52, 99, 103, -52, 146, 25, -52, -52, -52, -52, + -52, -52, -52, -52, 128, -52, 198 + }; + + 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, 144, 145, 146, 147, 148, 125, + 135, 99, 139, 131, 36, 138 + }; + + 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, 12, 13, 14, 15, 16, 53, + 98, 29, 103, 75, 6, 102 + }; + + 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'; + } +} + |