From 4730a70874b860ae7fbeba0e22e8c420c5701711 Mon Sep 17 00:00:00 2001 From: Kelvin Sherlock Date: Sun, 30 May 2021 23:29:34 -0400 Subject: [PATCH] include generated lemon code so lemon isn't needed. --- bin/CMakeLists.txt | 37 +- bin/parser.cpp | 1868 +++++++++++++++++++++++++++++++++++++++ bin/parser.h | 51 ++ bin/template_parser.cpp | 1291 +++++++++++++++++++++++++++ bin/template_parser.h | 20 + 5 files changed, 3251 insertions(+), 16 deletions(-) create mode 100644 bin/parser.cpp create mode 100644 bin/parser.h create mode 100644 bin/template_parser.cpp create mode 100644 bin/template_parser.h diff --git a/bin/CMakeLists.txt b/bin/CMakeLists.txt index 8e4969a..388510a 100644 --- a/bin/CMakeLists.txt +++ b/bin/CMakeLists.txt @@ -13,25 +13,30 @@ add_custom_command( MAIN_DEPENDENCY lexer.rl ) -add_custom_command( - OUTPUT parser.cpp parser.h - COMMAND cp -f "${CMAKE_CURRENT_SOURCE_DIR}/parser.lemon" "parser.lemon" - COMMAND lemon parser.lemon - COMMAND mv -f parser.c parser.cpp - MAIN_DEPENDENCY parser.lemon - DEPENDS debugger.h -) +find_program(LEMON NAMES lemon) +if (LEMON) -add_custom_command( - OUTPUT template_parser.cpp template_parser.h - COMMAND cp -f "${CMAKE_CURRENT_SOURCE_DIR}/template_parser.lemon" "template_parser.lemon" - COMMAND lemon template_parser.lemon - COMMAND mv -f template_parser.c template_parser.cpp - MAIN_DEPENDENCY template_parser.lemon - DEPENDS debugger.h -) + add_custom_command( + OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/parser.cpp ${CMAKE_CURRENT_SOURCE_DIR}/parser.h + # COMMAND cp -f "${CMAKE_CURRENT_SOURCE_DIR}/parser.lemon" "parser.lemon" + COMMAND lemon parser.lemon + COMMAND mv -f parser.c parser.cpp + MAIN_DEPENDENCY parser.lemon + DEPENDS debugger.h + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + ) + add_custom_command( + OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/template_parser.cpp ${CMAKE_CURRENT_SOURCE_DIR}/template_parser.h + # COMMAND cp -f "${CMAKE_CURRENT_SOURCE_DIR}/template_parser.lemon" "template_parser.lemon" + COMMAND lemon template_parser.lemon + COMMAND mv -f template_parser.c template_parser.cpp + MAIN_DEPENDENCY template_parser.lemon + DEPENDS debugger.h + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + ) +endif() add_custom_command( diff --git a/bin/parser.cpp b/bin/parser.cpp new file mode 100644 index 0000000..b4e0305 --- /dev/null +++ b/bin/parser.cpp @@ -0,0 +1,1868 @@ +/* +** 2000-05-29 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Driver template for the LEMON parser generator. +** +** The "lemon" program processes an LALR(1) input grammar file, then uses +** this template to construct a parser. The "lemon" program inserts text +** at each "%%" line. Also, any "P-a-r-s-e" identifer prefix (without the +** interstitial "-" characters) contained in this template is changed into +** the value of the %name directive from the grammar. Otherwise, the content +** of this template is copied straight through into the generate parser +** source file. +** +** The following is the concatenation of all %include directives from the +** input grammar file: +*/ +#include +#include +/************ Begin %include sections from the grammar ************************/ +#line 6 "parser.lemon" + +#include +#include +#include +#include +#include +#include "debugger.h" + +#include + +using Debug::Token; + +#ifdef __cplusplus +extern "C" { +#endif + +uint32_t cpuGetSR(); +uint32_t cpuGetPC(); +uint32_t cpuGetAReg(unsigned); +uint32_t cpuGetDReg(unsigned); + +#ifdef __cplusplus +} +#endif + + +#undef NDEBUG + +#line 58 "parser.c" +/**************** End of %include directives **********************************/ +/* These constants specify the various numeric values for terminal symbols +** in a format understandable to "makeheaders". This section is blank unless +** "lemon" is run with the "-m" command-line option. +***************** Begin makeheaders token definitions *************************/ +/**************** End makeheaders token definitions ***************************/ + +/* The next sections is a series of control #defines. +** various aspects of the generated parser. +** YYCODETYPE is the data type used to store the integer codes +** that represent terminal and non-terminal symbols. +** "unsigned char" is used if there are fewer than +** 256 symbols. Larger types otherwise. +** YYNOCODE is a number of type YYCODETYPE that is not used for +** any terminal or nonterminal symbol. +** YYFALLBACK If defined, this indicates that one or more tokens +** (also known as: "terminal symbols") have fall-back +** values which should be used if the original symbol +** would not parse. This permits keywords to sometimes +** be used as identifiers, for example. +** YYACTIONTYPE is the data type used for "action codes" - numbers +** that indicate what to do in response to the next +** token. +** ParseTOKENTYPE is the data type used for minor type for terminal +** symbols. Background: A "minor type" is a semantic +** value associated with a terminal or non-terminal +** symbols. For example, for an "ID" terminal symbol, +** the minor type might be the name of the identifier. +** Each non-terminal can have a different minor type. +** Terminal symbols all have the same minor type, though. +** This macros defines the minor type for terminal +** symbols. +** YYMINORTYPE is the data type used for all minor types. +** This is typically a union of many types, one of +** which is ParseTOKENTYPE. The entry in the union +** for terminal symbols is called "yy0". +** YYSTACKDEPTH is the maximum depth of the parser's stack. If +** zero the stack is dynamically sized using realloc() +** ParseARG_SDECL A static variable declaration for the %extra_argument +** ParseARG_PDECL A parameter declaration for the %extra_argument +** ParseARG_STORE Code to store %extra_argument into yypParser +** ParseARG_FETCH Code to extract %extra_argument from yypParser +** YYERRORSYMBOL is the code number of the error symbol. If not +** defined, then do no error processing. +** YYNSTATE the combined number of states. +** YYNRULE the number of rules in the grammar +** YY_MAX_SHIFT Maximum value for shift actions +** YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions +** YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions +** YY_MIN_REDUCE Maximum value for reduce actions +** YY_ERROR_ACTION The yy_action[] code for syntax error +** YY_ACCEPT_ACTION The yy_action[] code for accept +** YY_NO_ACTION The yy_action[] code for no-op +*/ +#ifndef INTERFACE +# define INTERFACE 1 +#endif +/************* Begin control #defines *****************************************/ +#define YYCODETYPE unsigned char +#define YYNOCODE 59 +#define YYACTIONTYPE unsigned short int +#define ParseTOKENTYPE Token +typedef union { + int yyinit; + ParseTOKENTYPE yy0; + int yy117; +} YYMINORTYPE; +#ifndef YYSTACKDEPTH +#define YYSTACKDEPTH 100 +#endif +#define ParseARG_SDECL Debug::Command *command ; +#define ParseARG_PDECL , Debug::Command *command +#define ParseARG_FETCH Debug::Command *command = yypParser->command +#define ParseARG_STORE yypParser->command = command +#define YYERRORSYMBOL 52 +#define YYERRSYMDT yy117 +#define YYNSTATE 140 +#define YYNRULE 70 +#define YY_MAX_SHIFT 139 +#define YY_MIN_SHIFTREDUCE 157 +#define YY_MAX_SHIFTREDUCE 226 +#define YY_MIN_REDUCE 227 +#define YY_MAX_REDUCE 296 +#define YY_ERROR_ACTION 297 +#define YY_ACCEPT_ACTION 298 +#define YY_NO_ACTION 299 +/************* End control #defines *******************************************/ + +/* Define the yytestcase() macro to be a no-op if is not already defined +** otherwise. +** +** Applications can choose to define yytestcase() in the %include section +** to a macro that can assist in verifying code coverage. For production +** code the yytestcase() macro should be turned off. But it is useful +** for testing. +*/ +#ifndef yytestcase +# define yytestcase(X) +#endif + + +/* Next are the tables used to determine what action to take based on the +** current state and lookahead token. These tables are used to implement +** functions that take a state number and lookahead value and return an +** action integer. +** +** Suppose the action integer is N. Then the action is determined as +** follows +** +** 0 <= N <= YY_MAX_SHIFT Shift N. That is, push the lookahead +** token onto the stack and goto state N. +** +** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then +** and YY_MAX_SHIFTREDUCE reduce by rule N-YY_MIN_SHIFTREDUCE. +** +** N between YY_MIN_REDUCE Reduce by rule N-YY_MIN_REDUCE +** and YY_MAX_REDUCE +** +** N == YY_ERROR_ACTION A syntax error has occurred. +** +** N == YY_ACCEPT_ACTION The parser accepts its input. +** +** N == YY_NO_ACTION No such action. Denotes unused +** slots in the yy_action[] table. +** +** The action table is constructed as a single large table named yy_action[]. +** Given state S and lookahead X, the action is computed as either: +** +** (A) N = yy_action[ yy_shift_ofst[S] + X ] +** (B) N = yy_default[S] +** +** The (A) formula is preferred. The B formula is used instead if: +** (1) The yy_shift_ofst[S]+X value is out of range, or +** (2) yy_lookahead[yy_shift_ofst[S]+X] is not equal to X, or +** (3) yy_shift_ofst[S] equal YY_SHIFT_USE_DFLT. +** (Implementation note: YY_SHIFT_USE_DFLT is chosen so that +** YY_SHIFT_USE_DFLT+X will be out of range for all possible lookaheads X. +** Hence only tests (1) and (2) need to be evaluated.) +** +** The formulas above are for computing the action when the lookahead is +** a terminal symbol. If the lookahead is a non-terminal (as occurs after +** a reduce action) then the yy_reduce_ofst[] array is used in place of +** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of +** YY_SHIFT_USE_DFLT. +** +** The following are the tables generated in this section: +** +** yy_action[] A single table containing all actions. +** yy_lookahead[] A table containing the lookahead for each entry in +** yy_action. Used to detect hash collisions. +** yy_shift_ofst[] For each state, the offset into yy_action for +** shifting terminals. +** yy_reduce_ofst[] For each state, the offset into yy_action for +** shifting non-terminals after a reduce. +** yy_default[] Default action for each state. +** +*********** Begin parsing tables **********************************************/ +#define YY_ACTTAB_COUNT (849) +static const YYACTIONTYPE yy_action[] = { + /* 0 */ 42, 41, 37, 119, 128, 39, 40, 126, 15, 5, + /* 10 */ 110, 108, 4, 3, 2, 14, 1, 13, 263, 6, + /* 20 */ 10, 93, 30, 29, 35, 34, 33, 32, 31, 83, + /* 30 */ 91, 262, 89, 87, 85, 17, 118, 221, 116, 18, + /* 40 */ 19, 20, 21, 22, 24, 23, 28, 27, 26, 25, + /* 50 */ 30, 29, 35, 34, 33, 32, 31, 261, 84, 139, + /* 60 */ 138, 136, 134, 132, 130, 44, 54, 120, 292, 284, + /* 70 */ 36, 16, 7, 124, 75, 122, 18, 19, 20, 21, + /* 80 */ 22, 24, 23, 28, 27, 26, 25, 30, 29, 35, + /* 90 */ 34, 33, 32, 31, 260, 8, 97, 298, 45, 120, + /* 100 */ 292, 284, 35, 34, 33, 32, 31, 12, 11, 18, + /* 110 */ 19, 20, 21, 22, 24, 23, 28, 27, 26, 25, + /* 120 */ 30, 29, 35, 34, 33, 32, 31, 259, 9, 82, + /* 130 */ 92, 18, 19, 20, 21, 22, 24, 23, 28, 27, + /* 140 */ 26, 25, 30, 29, 35, 34, 33, 32, 31, 247, + /* 150 */ 246, 86, 107, 18, 19, 20, 21, 22, 24, 23, + /* 160 */ 28, 27, 26, 25, 30, 29, 35, 34, 33, 32, + /* 170 */ 31, 245, 244, 88, 109, 18, 19, 20, 21, 22, + /* 180 */ 24, 23, 28, 27, 26, 25, 30, 29, 35, 34, + /* 190 */ 33, 32, 31, 243, 242, 90, 115, 18, 19, 20, + /* 200 */ 21, 22, 24, 23, 28, 27, 26, 25, 30, 29, + /* 210 */ 35, 34, 33, 32, 31, 241, 240, 94, 117, 18, + /* 220 */ 19, 20, 21, 22, 24, 23, 28, 27, 26, 25, + /* 230 */ 30, 29, 35, 34, 33, 32, 31, 239, 238, 95, + /* 240 */ 213, 18, 19, 20, 21, 22, 24, 23, 28, 27, + /* 250 */ 26, 25, 30, 29, 35, 34, 33, 32, 31, 237, + /* 260 */ 236, 96, 43, 18, 19, 20, 21, 22, 24, 23, + /* 270 */ 28, 27, 26, 25, 30, 29, 35, 34, 33, 32, + /* 280 */ 31, 235, 234, 98, 121, 18, 19, 20, 21, 22, + /* 290 */ 24, 23, 28, 27, 26, 25, 30, 29, 35, 34, + /* 300 */ 33, 32, 31, 233, 232, 100, 123, 18, 19, 20, + /* 310 */ 21, 22, 24, 23, 28, 27, 26, 25, 30, 29, + /* 320 */ 35, 34, 33, 32, 31, 231, 230, 101, 125, 18, + /* 330 */ 19, 20, 21, 22, 24, 23, 28, 27, 26, 25, + /* 340 */ 30, 29, 35, 34, 33, 32, 31, 229, 228, 103, + /* 350 */ 127, 18, 19, 20, 21, 22, 24, 23, 28, 27, + /* 360 */ 26, 25, 30, 29, 35, 34, 33, 32, 31, 253, + /* 370 */ 250, 105, 129, 18, 19, 20, 21, 22, 24, 23, + /* 380 */ 28, 27, 26, 25, 30, 29, 35, 34, 33, 32, + /* 390 */ 31, 254, 249, 111, 131, 18, 19, 20, 21, 22, + /* 400 */ 24, 23, 28, 27, 26, 25, 30, 29, 35, 34, + /* 410 */ 33, 32, 31, 258, 257, 113, 133, 18, 19, 20, + /* 420 */ 21, 22, 24, 23, 28, 27, 26, 25, 30, 29, + /* 430 */ 35, 34, 33, 32, 31, 19, 20, 21, 22, 24, + /* 440 */ 23, 28, 27, 26, 25, 30, 29, 35, 34, 33, + /* 450 */ 32, 31, 80, 135, 18, 19, 20, 21, 22, 24, + /* 460 */ 23, 28, 27, 26, 25, 30, 29, 35, 34, 33, + /* 470 */ 32, 31, 18, 19, 20, 21, 22, 24, 23, 28, + /* 480 */ 27, 26, 25, 30, 29, 35, 34, 33, 32, 31, + /* 490 */ 24, 23, 28, 27, 26, 25, 30, 29, 35, 34, + /* 500 */ 33, 32, 31, 220, 289, 292, 284, 81, 33, 32, + /* 510 */ 31, 20, 21, 22, 24, 23, 28, 27, 26, 25, + /* 520 */ 30, 29, 35, 34, 33, 32, 31, 21, 22, 24, + /* 530 */ 23, 28, 27, 26, 25, 30, 29, 35, 34, 33, + /* 540 */ 32, 31, 22, 24, 23, 28, 27, 26, 25, 30, + /* 550 */ 29, 35, 34, 33, 32, 31, 42, 41, 38, 256, + /* 560 */ 255, 39, 40, 99, 252, 42, 41, 38, 251, 248, + /* 570 */ 39, 40, 102, 288, 292, 284, 42, 41, 38, 137, + /* 580 */ 227, 39, 40, 104, 229, 223, 224, 229, 225, 226, + /* 590 */ 229, 17, 229, 221, 223, 224, 229, 225, 226, 229, + /* 600 */ 17, 224, 221, 225, 226, 223, 224, 229, 225, 226, + /* 610 */ 229, 17, 229, 221, 229, 42, 41, 38, 229, 229, + /* 620 */ 39, 40, 106, 229, 42, 41, 38, 229, 229, 39, + /* 630 */ 40, 112, 287, 292, 284, 42, 41, 38, 229, 229, + /* 640 */ 39, 40, 114, 229, 223, 224, 229, 225, 226, 229, + /* 650 */ 17, 229, 221, 223, 224, 229, 225, 226, 229, 17, + /* 660 */ 229, 221, 229, 229, 223, 224, 229, 225, 226, 229, + /* 670 */ 17, 229, 221, 229, 42, 41, 38, 229, 229, 39, + /* 680 */ 40, 28, 27, 26, 25, 30, 29, 35, 34, 33, + /* 690 */ 32, 31, 56, 120, 292, 284, 57, 120, 292, 284, + /* 700 */ 286, 292, 284, 223, 224, 229, 225, 226, 229, 17, + /* 710 */ 229, 221, 58, 120, 292, 284, 59, 120, 292, 284, + /* 720 */ 47, 120, 292, 284, 229, 48, 120, 292, 284, 49, + /* 730 */ 120, 292, 284, 229, 50, 120, 292, 284, 51, 120, + /* 740 */ 292, 284, 52, 120, 292, 284, 53, 120, 292, 284, + /* 750 */ 46, 120, 292, 284, 55, 120, 292, 284, 60, 120, + /* 760 */ 292, 284, 61, 120, 292, 284, 62, 120, 292, 284, + /* 770 */ 64, 120, 292, 284, 65, 120, 292, 284, 66, 120, + /* 780 */ 292, 284, 67, 120, 292, 284, 68, 120, 292, 284, + /* 790 */ 69, 120, 292, 284, 70, 120, 292, 284, 71, 120, + /* 800 */ 292, 284, 72, 120, 292, 284, 73, 120, 292, 284, + /* 810 */ 74, 120, 292, 284, 76, 120, 292, 284, 77, 120, + /* 820 */ 292, 284, 269, 120, 292, 284, 268, 120, 292, 284, + /* 830 */ 267, 120, 292, 284, 78, 120, 292, 284, 79, 120, + /* 840 */ 292, 284, 63, 120, 292, 284, 285, 292, 284, +}; +static const YYCODETYPE yy_lookahead[] = { + /* 0 */ 14, 15, 16, 56, 43, 19, 20, 52, 22, 23, + /* 10 */ 24, 25, 26, 27, 28, 29, 30, 31, 0, 45, + /* 20 */ 34, 35, 12, 13, 14, 15, 16, 17, 18, 43, + /* 30 */ 44, 0, 46, 47, 48, 49, 37, 51, 39, 1, + /* 40 */ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + /* 50 */ 12, 13, 14, 15, 16, 17, 18, 0, 21, 21, + /* 60 */ 37, 38, 39, 40, 41, 42, 54, 55, 56, 57, + /* 70 */ 32, 33, 45, 37, 36, 39, 1, 2, 3, 4, + /* 80 */ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + /* 90 */ 15, 16, 17, 18, 0, 45, 21, 53, 54, 55, + /* 100 */ 56, 57, 14, 15, 16, 17, 18, 32, 33, 1, + /* 110 */ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + /* 120 */ 12, 13, 14, 15, 16, 17, 18, 0, 45, 21, + /* 130 */ 21, 1, 2, 3, 4, 5, 6, 7, 8, 9, + /* 140 */ 10, 11, 12, 13, 14, 15, 16, 17, 18, 0, + /* 150 */ 0, 21, 21, 1, 2, 3, 4, 5, 6, 7, + /* 160 */ 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + /* 170 */ 18, 0, 0, 21, 21, 1, 2, 3, 4, 5, + /* 180 */ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + /* 190 */ 16, 17, 18, 0, 0, 21, 21, 1, 2, 3, + /* 200 */ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + /* 210 */ 14, 15, 16, 17, 18, 0, 0, 21, 21, 1, + /* 220 */ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + /* 230 */ 12, 13, 14, 15, 16, 17, 18, 0, 0, 21, + /* 240 */ 50, 1, 2, 3, 4, 5, 6, 7, 8, 9, + /* 250 */ 10, 11, 12, 13, 14, 15, 16, 17, 18, 0, + /* 260 */ 0, 21, 49, 1, 2, 3, 4, 5, 6, 7, + /* 270 */ 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + /* 280 */ 18, 0, 0, 21, 21, 1, 2, 3, 4, 5, + /* 290 */ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + /* 300 */ 16, 17, 18, 0, 0, 21, 21, 1, 2, 3, + /* 310 */ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + /* 320 */ 14, 15, 16, 17, 18, 0, 0, 21, 21, 1, + /* 330 */ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + /* 340 */ 12, 13, 14, 15, 16, 17, 18, 0, 0, 21, + /* 350 */ 21, 1, 2, 3, 4, 5, 6, 7, 8, 9, + /* 360 */ 10, 11, 12, 13, 14, 15, 16, 17, 18, 0, + /* 370 */ 0, 21, 21, 1, 2, 3, 4, 5, 6, 7, + /* 380 */ 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + /* 390 */ 18, 0, 0, 21, 21, 1, 2, 3, 4, 5, + /* 400 */ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + /* 410 */ 16, 17, 18, 0, 0, 21, 21, 1, 2, 3, + /* 420 */ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + /* 430 */ 14, 15, 16, 17, 18, 2, 3, 4, 5, 6, + /* 440 */ 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + /* 450 */ 17, 18, 36, 21, 1, 2, 3, 4, 5, 6, + /* 460 */ 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + /* 470 */ 17, 18, 1, 2, 3, 4, 5, 6, 7, 8, + /* 480 */ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + /* 490 */ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + /* 500 */ 16, 17, 18, 50, 55, 56, 57, 36, 16, 17, + /* 510 */ 18, 3, 4, 5, 6, 7, 8, 9, 10, 11, + /* 520 */ 12, 13, 14, 15, 16, 17, 18, 4, 5, 6, + /* 530 */ 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + /* 540 */ 17, 18, 5, 6, 7, 8, 9, 10, 11, 12, + /* 550 */ 13, 14, 15, 16, 17, 18, 14, 15, 16, 0, + /* 560 */ 0, 19, 20, 21, 0, 14, 15, 16, 0, 0, + /* 570 */ 19, 20, 21, 55, 56, 57, 14, 15, 16, 21, + /* 580 */ 0, 19, 20, 21, 58, 43, 44, 58, 46, 47, + /* 590 */ 58, 49, 58, 51, 43, 44, 58, 46, 47, 58, + /* 600 */ 49, 44, 51, 46, 47, 43, 44, 58, 46, 47, + /* 610 */ 58, 49, 58, 51, 58, 14, 15, 16, 58, 58, + /* 620 */ 19, 20, 21, 58, 14, 15, 16, 58, 58, 19, + /* 630 */ 20, 21, 55, 56, 57, 14, 15, 16, 58, 58, + /* 640 */ 19, 20, 21, 58, 43, 44, 58, 46, 47, 58, + /* 650 */ 49, 58, 51, 43, 44, 58, 46, 47, 58, 49, + /* 660 */ 58, 51, 58, 58, 43, 44, 58, 46, 47, 58, + /* 670 */ 49, 58, 51, 58, 14, 15, 16, 58, 58, 19, + /* 680 */ 20, 8, 9, 10, 11, 12, 13, 14, 15, 16, + /* 690 */ 17, 18, 54, 55, 56, 57, 54, 55, 56, 57, + /* 700 */ 55, 56, 57, 43, 44, 58, 46, 47, 58, 49, + /* 710 */ 58, 51, 54, 55, 56, 57, 54, 55, 56, 57, + /* 720 */ 54, 55, 56, 57, 58, 54, 55, 56, 57, 54, + /* 730 */ 55, 56, 57, 58, 54, 55, 56, 57, 54, 55, + /* 740 */ 56, 57, 54, 55, 56, 57, 54, 55, 56, 57, + /* 750 */ 54, 55, 56, 57, 54, 55, 56, 57, 54, 55, + /* 760 */ 56, 57, 54, 55, 56, 57, 54, 55, 56, 57, + /* 770 */ 54, 55, 56, 57, 54, 55, 56, 57, 54, 55, + /* 780 */ 56, 57, 54, 55, 56, 57, 54, 55, 56, 57, + /* 790 */ 54, 55, 56, 57, 54, 55, 56, 57, 54, 55, + /* 800 */ 56, 57, 54, 55, 56, 57, 54, 55, 56, 57, + /* 810 */ 54, 55, 56, 57, 54, 55, 56, 57, 54, 55, + /* 820 */ 56, 57, 54, 55, 56, 57, 54, 55, 56, 57, + /* 830 */ 54, 55, 56, 57, 54, 55, 56, 57, 54, 55, + /* 840 */ 56, 57, 54, 55, 56, 57, 55, 56, 57, +}; +#define YY_SHIFT_USE_DFLT (849) +#define YY_SHIFT_COUNT (139) +#define YY_SHIFT_MIN (-39) +#define YY_SHIFT_MAX (673) +static const short yy_shift_ofst[] = { + /* 0 */ -14, 542, 551, 562, 601, 610, 660, 660, 660, 660, + /* 10 */ 660, 660, 660, 660, 660, 660, 660, 660, 660, 660, + /* 20 */ 660, 660, 660, 660, 660, 660, 660, 660, 660, 660, + /* 30 */ 660, 660, 660, 660, 660, 660, 660, 621, 660, 660, + /* 40 */ 660, 660, 660, 557, -39, 38, 75, 108, 130, 152, + /* 50 */ 174, 196, 218, 240, 262, 284, 306, 328, 350, 372, + /* 60 */ 394, 416, 453, 471, 433, 508, 523, 537, 484, 673, + /* 70 */ 673, 10, 10, 10, 10, 23, 88, 88, 492, 492, + /* 80 */ -1, 36, 18, -26, 31, 37, 57, 27, 94, 50, + /* 90 */ 127, 83, 149, 109, 150, 171, 172, 193, 194, 215, + /* 100 */ 216, 237, 238, 259, 260, 281, 282, 303, 131, 304, + /* 110 */ 153, 325, 326, 347, 348, 369, 175, 370, 197, 190, + /* 120 */ 213, 391, 263, 392, 285, 413, 307, 414, 329, 559, + /* 130 */ 351, 560, 373, 564, 395, 568, 432, 569, 558, 580, +}; +#define YY_REDUCE_USE_DFLT (-54) +#define YY_REDUCE_COUNT (44) +#define YY_REDUCE_MIN (-53) +#define YY_REDUCE_MAX (791) +static const short yy_reduce_ofst[] = { + /* 0 */ 44, 12, 638, 642, 658, 662, 666, 671, 675, 680, + /* 10 */ 684, 688, 692, 696, 700, 704, 708, 712, 716, 720, + /* 20 */ 724, 728, 732, 736, 740, 744, 748, 752, 756, 760, + /* 30 */ 764, 768, 772, 776, 780, 784, 788, 449, 449, 518, + /* 40 */ 577, 645, 791, -53, -45, +}; +static const YYACTIONTYPE yy_default[] = { + /* 0 */ 297, 297, 297, 297, 297, 297, 297, 297, 297, 297, + /* 10 */ 297, 297, 297, 297, 297, 297, 297, 297, 297, 297, + /* 20 */ 297, 297, 297, 297, 297, 297, 297, 297, 297, 297, + /* 30 */ 297, 297, 297, 297, 297, 297, 297, 297, 297, 297, + /* 40 */ 297, 297, 297, 297, 297, 297, 297, 297, 297, 297, + /* 50 */ 297, 297, 297, 297, 297, 297, 297, 297, 297, 297, + /* 60 */ 297, 297, 297, 297, 282, 281, 280, 279, 278, 277, + /* 70 */ 276, 275, 274, 273, 272, 297, 271, 270, 266, 265, + /* 80 */ 297, 297, 297, 293, 297, 297, 297, 296, 297, 295, + /* 90 */ 297, 294, 297, 297, 297, 297, 297, 297, 297, 297, + /* 100 */ 297, 297, 297, 297, 297, 297, 297, 297, 297, 297, + /* 110 */ 297, 297, 297, 297, 297, 297, 297, 297, 297, 297, + /* 120 */ 264, 297, 297, 297, 297, 297, 297, 297, 297, 297, + /* 130 */ 297, 297, 297, 297, 297, 297, 297, 297, 297, 297, +}; +/********** End of lemon-generated parsing tables *****************************/ + +/* The next table maps tokens (terminal symbols) into fallback tokens. +** If a construct like the following: +** +** %fallback ID X Y Z. +** +** appears in the grammar, then ID becomes a fallback token for X, Y, +** and Z. Whenever one of the tokens X, Y, or Z is input to the parser +** but it does not parse, the type of the token is changed to ID and +** the parse is retried before an error is thrown. +** +** This feature can be used, for example, to cause some keywords in a language +** to revert to identifiers if they keyword does not apply in the context where +** it appears. +*/ +#ifdef YYFALLBACK +static const YYCODETYPE yyFallback[] = { +}; +#endif /* YYFALLBACK */ + +/* The following structure represents a single element of the +** parser's stack. Information stored includes: +** +** + The state number for the parser at this level of the stack. +** +** + The value of the token stored at this level of the stack. +** (In other words, the "major" token.) +** +** + The semantic value stored at this level of the stack. This is +** the information used by the action routines in the grammar. +** It is sometimes called the "minor" token. +** +** After the "shift" half of a SHIFTREDUCE action, the stateno field +** actually contains the reduce action for the second half of the +** SHIFTREDUCE. +*/ +struct yyStackEntry { + YYACTIONTYPE stateno; /* The state-number, or reduce action in SHIFTREDUCE */ + YYCODETYPE major; /* The major token value. This is the code + ** number for the token at this stack level */ + YYMINORTYPE minor; /* The user-supplied minor token value. This + ** is the value of the token */ +}; +typedef struct yyStackEntry yyStackEntry; + +/* The state of the parser is completely contained in an instance of +** the following structure */ +struct yyParser { + yyStackEntry *yytos; /* Pointer to top element of the stack */ +#ifdef YYTRACKMAXSTACKDEPTH + int yyhwm; /* High-water mark of the stack */ +#endif +#ifndef YYNOERRORRECOVERY + int yyerrcnt; /* Shifts left before out of the error */ +#endif + ParseARG_SDECL /* A place to hold %extra_argument */ +#if YYSTACKDEPTH<=0 + int yystksz; /* Current side of the stack */ + yyStackEntry *yystack; /* The parser's stack */ + yyStackEntry yystk0; /* First stack entry */ +#else + yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ + yyStackEntry *yystackEnd; /* Last entry in the stack */ +#endif +}; +typedef struct yyParser yyParser; + +#ifndef NDEBUG +#include +static FILE *yyTraceFILE = 0; +static char *yyTracePrompt = 0; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Turn parser tracing on by giving a stream to which to write the trace +** and a prompt to preface each trace message. Tracing is turned off +** by making either argument NULL +** +** Inputs: +**
    +**
  • A FILE* to which trace output should be written. +** If NULL, then tracing is turned off. +**
  • A prefix string written at the beginning of every +** line of trace output. If NULL, then tracing is +** turned off. +**
+** +** Outputs: +** None. +*/ +void ParseTrace(FILE *TraceFILE, char *zTracePrompt){ + yyTraceFILE = TraceFILE; + yyTracePrompt = zTracePrompt; + if( yyTraceFILE==0 ) yyTracePrompt = 0; + else if( yyTracePrompt==0 ) yyTraceFILE = 0; +} +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing shifts, the names of all terminals and nonterminals +** are required. The following table supplies these names */ +static const char *const yyTokenName[] = { + "$", "PIPEPIPE", "AMPAMP", "PIPE", + "CARET", "AMP", "EQEQ", "BANGEQ", + "LT", "LTEQ", "GT", "GTEQ", + "LTLT", "GTGT", "PLUS", "MINUS", + "STAR", "SLASH", "PERCENT", "BANG", + "TILDE", "EOL", "PRINT", "BREAK", + "BACKTRACE", "CONTINUE", "TBREAK", "RBREAK", + "WBREAK", "RWBREAK", "NEXT", "DUMP", + "COLON", "AT", "LIST", "STACKCRAWL", + "SEMI", "SEMIH", "SEMII", "SEMIL", + "SEMIDATE", "SEMIERROR", "SEMIT", "IDENTIFIER", + "DREGISTER", "EQ", "AREGISTER", "XREGISTER", + "HELP", "LPAREN", "RPAREN", "INTEGER", + "error", "stmt", "expr", "unary", + "register", "term", +}; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing reduce actions, the names of all rules are required. +*/ +static const char *const yyRuleName[] = { + /* 0 */ "stmt ::= expr EOL", + /* 1 */ "stmt ::= STAR EOL", + /* 2 */ "stmt ::= PRINT expr EOL", + /* 3 */ "stmt ::= BREAK EOL", + /* 4 */ "stmt ::= BREAK expr EOL", + /* 5 */ "stmt ::= BACKTRACE EOL", + /* 6 */ "stmt ::= CONTINUE EOL", + /* 7 */ "stmt ::= TBREAK EOL", + /* 8 */ "stmt ::= TBREAK expr EOL", + /* 9 */ "stmt ::= RBREAK EOL", + /* 10 */ "stmt ::= RBREAK expr EOL", + /* 11 */ "stmt ::= WBREAK EOL", + /* 12 */ "stmt ::= WBREAK expr EOL", + /* 13 */ "stmt ::= RWBREAK expr EOL", + /* 14 */ "stmt ::= NEXT EOL", + /* 15 */ "stmt ::= NEXT expr EOL", + /* 16 */ "stmt ::= DUMP expr EOL", + /* 17 */ "stmt ::= DUMP expr COLON expr EOL", + /* 18 */ "stmt ::= DUMP expr AT expr EOL", + /* 19 */ "stmt ::= LIST expr EOL", + /* 20 */ "stmt ::= STACKCRAWL EOL", + /* 21 */ "stmt ::= expr SEMI SEMIH EOL", + /* 22 */ "stmt ::= expr COLON expr SEMI SEMIH EOL", + /* 23 */ "stmt ::= expr AT expr SEMI SEMIH EOL", + /* 24 */ "stmt ::= expr SEMI SEMII EOL", + /* 25 */ "stmt ::= expr SEMI SEMIL EOL", + /* 26 */ "stmt ::= expr AT expr SEMI SEMIL EOL", + /* 27 */ "stmt ::= expr COLON expr SEMI SEMIL EOL", + /* 28 */ "stmt ::= expr SEMI SEMIDATE EOL", + /* 29 */ "stmt ::= expr SEMI SEMIERROR EOL", + /* 30 */ "stmt ::= expr SEMI SEMIT IDENTIFIER EOL", + /* 31 */ "stmt ::= expr SEMI SEMIT error EOL", + /* 32 */ "stmt ::= DREGISTER EQ expr EOL", + /* 33 */ "stmt ::= AREGISTER EQ expr EOL", + /* 34 */ "stmt ::= XREGISTER EQ expr EOL", + /* 35 */ "stmt ::= HELP EOL", + /* 36 */ "stmt ::= IDENTIFIER EQ expr EOL", + /* 37 */ "expr ::= unary", + /* 38 */ "expr ::= expr PLUS expr", + /* 39 */ "expr ::= expr MINUS expr", + /* 40 */ "expr ::= expr STAR expr", + /* 41 */ "expr ::= expr SLASH expr", + /* 42 */ "expr ::= expr PERCENT expr", + /* 43 */ "expr ::= expr LTLT expr", + /* 44 */ "expr ::= expr GTGT expr", + /* 45 */ "expr ::= expr LT expr", + /* 46 */ "expr ::= expr LTEQ expr", + /* 47 */ "expr ::= expr GT expr", + /* 48 */ "expr ::= expr GTEQ expr", + /* 49 */ "expr ::= expr EQEQ expr", + /* 50 */ "expr ::= expr BANGEQ expr", + /* 51 */ "expr ::= expr AMP expr", + /* 52 */ "expr ::= expr CARET expr", + /* 53 */ "expr ::= expr PIPE expr", + /* 54 */ "expr ::= expr AMPAMP expr", + /* 55 */ "expr ::= expr PIPEPIPE expr", + /* 56 */ "expr ::= unary LPAREN register RPAREN", + /* 57 */ "unary ::= term", + /* 58 */ "unary ::= PLUS unary", + /* 59 */ "unary ::= MINUS unary", + /* 60 */ "unary ::= TILDE unary", + /* 61 */ "unary ::= BANG unary", + /* 62 */ "unary ::= STAR unary", + /* 63 */ "term ::= LPAREN expr RPAREN", + /* 64 */ "term ::= INTEGER", + /* 65 */ "term ::= register", + /* 66 */ "term ::= IDENTIFIER", + /* 67 */ "register ::= DREGISTER", + /* 68 */ "register ::= AREGISTER", + /* 69 */ "register ::= XREGISTER", +}; +#endif /* NDEBUG */ + + +#if YYSTACKDEPTH<=0 +/* +** Try to increase the size of the parser stack. Return the number +** of errors. Return 0 on success. +*/ +static int yyGrowStack(yyParser *p){ + int newSize; + int idx; + yyStackEntry *pNew; + + newSize = p->yystksz*2 + 100; + idx = p->yytos ? (int)(p->yytos - p->yystack) : 0; + if( p->yystack==&p->yystk0 ){ + pNew = malloc(newSize*sizeof(pNew[0])); + if( pNew ) pNew[0] = p->yystk0; + }else{ + pNew = realloc(p->yystack, newSize*sizeof(pNew[0])); + } + if( pNew ){ + p->yystack = pNew; + p->yytos = &p->yystack[idx]; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n", + yyTracePrompt, p->yystksz, newSize); + } +#endif + p->yystksz = newSize; + } + return pNew==0; +} +#endif + +/* Datatype of the argument to the memory allocated passed as the +** second argument to ParseAlloc() below. This can be changed by +** putting an appropriate #define in the %include section of the input +** grammar. +*/ +#ifndef YYMALLOCARGTYPE +# define YYMALLOCARGTYPE size_t +#endif + +/* Initialize a new parser that has already been allocated. +*/ +void ParseInit(void *yypParser){ + yyParser *pParser = (yyParser*)yypParser; +#ifdef YYTRACKMAXSTACKDEPTH + pParser->yyhwm = 0; +#endif +#if YYSTACKDEPTH<=0 + pParser->yytos = NULL; + pParser->yystack = NULL; + pParser->yystksz = 0; + if( yyGrowStack(pParser) ){ + pParser->yystack = &pParser->yystk0; + pParser->yystksz = 1; + } +#endif +#ifndef YYNOERRORRECOVERY + pParser->yyerrcnt = -1; +#endif + pParser->yytos = pParser->yystack; + pParser->yystack[0].stateno = 0; + pParser->yystack[0].major = 0; +#if YYSTACKDEPTH>0 + pParser->yystackEnd = &pParser->yystack[YYSTACKDEPTH-1]; +#endif +} + +#ifndef Parse_ENGINEALWAYSONSTACK +/* +** This function allocates a new parser. +** The only argument is a pointer to a function which works like +** malloc. +** +** Inputs: +** A pointer to the function used to allocate memory. +** +** Outputs: +** A pointer to a parser. This pointer is used in subsequent calls +** to Parse and ParseFree. +*/ +void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE)){ + yyParser *pParser; + pParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) ); + if( pParser ) ParseInit(pParser); + return pParser; +} +#endif /* Parse_ENGINEALWAYSONSTACK */ + + +/* The following function deletes the "minor type" or semantic value +** associated with a symbol. The symbol can be either a terminal +** or nonterminal. "yymajor" is the symbol code, and "yypminor" is +** a pointer to the value to be deleted. The code used to do the +** deletions is derived from the %destructor and/or %token_destructor +** directives of the input grammar. +*/ +static void yy_destructor( + yyParser *yypParser, /* The parser */ + YYCODETYPE yymajor, /* Type code for object to destroy */ + YYMINORTYPE *yypminor /* The object to be destroyed */ +){ + ParseARG_FETCH; + switch( yymajor ){ + /* Here is inserted the actions which take place when a + ** terminal or non-terminal is destroyed. This can happen + ** when the symbol is popped from the stack during a + ** reduce or during error processing or when a parser is + ** being destroyed before it is finished parsing. + ** + ** Note: during a reduce, the only symbols destroyed are those + ** which appear on the RHS of the rule, but which are *not* used + ** inside the C code. + */ +/********* Begin destructor definitions ***************************************/ +/********* End destructor definitions *****************************************/ + default: break; /* If no destructor action specified: do nothing */ + } +} + +/* +** Pop the parser's stack once. +** +** If there is a destructor routine associated with the token which +** is popped from the stack, then call it. +*/ +static void yy_pop_parser_stack(yyParser *pParser){ + yyStackEntry *yytos; + assert( pParser->yytos!=0 ); + assert( pParser->yytos > pParser->yystack ); + yytos = pParser->yytos--; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sPopping %s\n", + yyTracePrompt, + yyTokenName[yytos->major]); + } +#endif + yy_destructor(pParser, yytos->major, &yytos->minor); +} + +/* +** Clear all secondary memory allocations from the parser +*/ +void ParseFinalize(void *p){ + yyParser *pParser = (yyParser*)p; + while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser); +#if YYSTACKDEPTH<=0 + if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack); +#endif +} + +#ifndef Parse_ENGINEALWAYSONSTACK +/* +** Deallocate and destroy a parser. Destructors are called for +** all stack elements before shutting the parser down. +** +** If the YYPARSEFREENEVERNULL macro exists (for example because it +** is defined in a %include section of the input grammar) then it is +** assumed that the input pointer is never NULL. +*/ +void ParseFree( + void *p, /* The parser to be deleted */ + void (*freeProc)(void*) /* Function used to reclaim memory */ +){ +#ifndef YYPARSEFREENEVERNULL + if( p==0 ) return; +#endif + ParseFinalize(p); + (*freeProc)(p); +} +#endif /* Parse_ENGINEALWAYSONSTACK */ + +/* +** Return the peak depth of the stack for a parser. +*/ +#ifdef YYTRACKMAXSTACKDEPTH +int ParseStackPeak(void *p){ + yyParser *pParser = (yyParser*)p; + return pParser->yyhwm; +} +#endif + +/* +** Find the appropriate action for a parser given the terminal +** look-ahead token iLookAhead. +*/ +static unsigned int yy_find_shift_action( + yyParser *pParser, /* The parser */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; + int stateno = pParser->yytos->stateno; + + if( stateno>=YY_MIN_REDUCE ) return stateno; + assert( stateno <= YY_SHIFT_COUNT ); + do{ + i = yy_shift_ofst[stateno]; + assert( iLookAhead!=YYNOCODE ); + i += iLookAhead; + if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ +#ifdef YYFALLBACK + YYCODETYPE iFallback; /* Fallback token */ + if( iLookAhead %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); + } +#endif + assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */ + iLookAhead = iFallback; + continue; + } +#endif +#ifdef YYWILDCARD + { + int j = i - iLookAhead + YYWILDCARD; + if( +#if YY_SHIFT_MIN+YYWILDCARD<0 + j>=0 && +#endif +#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT + j0 + ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n", + yyTracePrompt, yyTokenName[iLookAhead], + yyTokenName[YYWILDCARD]); + } +#endif /* NDEBUG */ + return yy_action[j]; + } + } +#endif /* YYWILDCARD */ + return yy_default[stateno]; + }else{ + return yy_action[i]; + } + }while(1); +} + +/* +** Find the appropriate action for a parser given the non-terminal +** look-ahead token iLookAhead. +*/ +static int yy_find_reduce_action( + int stateno, /* Current state number */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; +#ifdef YYERRORSYMBOL + if( stateno>YY_REDUCE_COUNT ){ + return yy_default[stateno]; + } +#else + assert( stateno<=YY_REDUCE_COUNT ); +#endif + i = yy_reduce_ofst[stateno]; + assert( i!=YY_REDUCE_USE_DFLT ); + assert( iLookAhead!=YYNOCODE ); + i += iLookAhead; +#ifdef YYERRORSYMBOL + if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ + return yy_default[stateno]; + } +#else + assert( i>=0 && iyytos>yypParser->yystack ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will execute if the parser + ** stack every overflows */ +/******** Begin %stack_overflow code ******************************************/ +/******** End %stack_overflow code ********************************************/ + ParseARG_STORE; /* Suppress warning about unused %extra_argument var */ +} + +/* +** Print tracing information for a SHIFT action +*/ +#ifndef NDEBUG +static void yyTraceShift(yyParser *yypParser, int yyNewState){ + if( yyTraceFILE ){ + if( yyNewStateyytos->major], + yyNewState); + }else{ + fprintf(yyTraceFILE,"%sShift '%s'\n", + yyTracePrompt,yyTokenName[yypParser->yytos->major]); + } + } +} +#else +# define yyTraceShift(X,Y) +#endif + +/* +** Perform a shift action. +*/ +static void yy_shift( + yyParser *yypParser, /* The parser to be shifted */ + int yyNewState, /* The new state to shift in */ + int yyMajor, /* The major token to shift in */ + ParseTOKENTYPE yyMinor /* The minor token to shift in */ +){ + yyStackEntry *yytos; + yypParser->yytos++; +#ifdef YYTRACKMAXSTACKDEPTH + if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){ + yypParser->yyhwm++; + assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) ); + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yytos>yypParser->yystackEnd ){ + yypParser->yytos--; + yyStackOverflow(yypParser); + return; + } +#else + if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){ + if( yyGrowStack(yypParser) ){ + yypParser->yytos--; + yyStackOverflow(yypParser); + return; + } + } +#endif + if( yyNewState > YY_MAX_SHIFT ){ + yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE; + } + yytos = yypParser->yytos; + yytos->stateno = (YYACTIONTYPE)yyNewState; + yytos->major = (YYCODETYPE)yyMajor; + yytos->minor.yy0 = yyMinor; + yyTraceShift(yypParser, yyNewState); +} + +/* The following table contains information about every rule that +** is used during the reduce. +*/ +static const struct { + YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ + signed char nrhs; /* Negative of the number of RHS symbols in the rule */ +} yyRuleInfo[] = { + { 53, -2 }, + { 53, -2 }, + { 53, -3 }, + { 53, -2 }, + { 53, -3 }, + { 53, -2 }, + { 53, -2 }, + { 53, -2 }, + { 53, -3 }, + { 53, -2 }, + { 53, -3 }, + { 53, -2 }, + { 53, -3 }, + { 53, -3 }, + { 53, -2 }, + { 53, -3 }, + { 53, -3 }, + { 53, -5 }, + { 53, -5 }, + { 53, -3 }, + { 53, -2 }, + { 53, -4 }, + { 53, -6 }, + { 53, -6 }, + { 53, -4 }, + { 53, -4 }, + { 53, -6 }, + { 53, -6 }, + { 53, -4 }, + { 53, -4 }, + { 53, -5 }, + { 53, -5 }, + { 53, -4 }, + { 53, -4 }, + { 53, -4 }, + { 53, -2 }, + { 53, -4 }, + { 54, -1 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -3 }, + { 54, -4 }, + { 55, -1 }, + { 55, -2 }, + { 55, -2 }, + { 55, -2 }, + { 55, -2 }, + { 55, -2 }, + { 57, -3 }, + { 57, -1 }, + { 57, -1 }, + { 57, -1 }, + { 56, -1 }, + { 56, -1 }, + { 56, -1 }, +}; + +static void yy_accept(yyParser*); /* Forward Declaration */ + +/* +** Perform a reduce action and the shift that must immediately +** follow the reduce. +*/ +static void yy_reduce( + yyParser *yypParser, /* The parser */ + unsigned int yyruleno /* Number of the rule by which to reduce */ +){ + int yygoto; /* The next state */ + int yyact; /* The next action */ + yyStackEntry *yymsp; /* The top of the parser's stack */ + int yysize; /* Amount to pop the stack */ + ParseARG_FETCH; + yymsp = yypParser->yytos; +#ifndef NDEBUG + if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ + yysize = yyRuleInfo[yyruleno].nrhs; + fprintf(yyTraceFILE, "%sReduce [%s], go to state %d.\n", yyTracePrompt, + yyRuleName[yyruleno], yymsp[yysize].stateno); + } +#endif /* NDEBUG */ + + /* Check that the stack is large enough to grow by a single entry + ** if the RHS of the rule is empty. This ensures that there is room + ** enough on the stack to push the LHS value */ + if( yyRuleInfo[yyruleno].nrhs==0 ){ +#ifdef YYTRACKMAXSTACKDEPTH + if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){ + yypParser->yyhwm++; + assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack)); + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yytos>=yypParser->yystackEnd ){ + yyStackOverflow(yypParser); + return; + } +#else + if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ + if( yyGrowStack(yypParser) ){ + yyStackOverflow(yypParser); + return; + } + yymsp = yypParser->yytos; + } +#endif + } + + switch( yyruleno ){ + /* Beginning here are the reduction cases. A typical example + ** follows: + ** case 0: + ** #line + ** { ... } // User supplied code + ** #line + ** break; + */ +/********** Begin reduce actions **********************************************/ + YYMINORTYPE yylhsminor; + case 0: /* stmt ::= expr EOL */ + case 2: /* stmt ::= PRINT expr EOL */ yytestcase(yyruleno==2); +#line 61 "parser.lemon" +{ + Debug::Print(yymsp[-1].minor.yy0.intValue); +} +#line 1142 "parser.c" + break; + case 1: /* stmt ::= STAR EOL */ +#line 66 "parser.lemon" +{ + Debug::PrintRegisters(); +} +#line 1149 "parser.c" + break; + case 3: /* stmt ::= BREAK EOL */ +#line 76 "parser.lemon" +{ + Debug::Break(); +} +#line 1156 "parser.c" + break; + case 4: /* stmt ::= BREAK expr EOL */ +#line 81 "parser.lemon" +{ + Debug::Break(yymsp[-1].minor.yy0.intValue); +} +#line 1163 "parser.c" + break; + case 5: /* stmt ::= BACKTRACE EOL */ +#line 86 "parser.lemon" +{ + Debug::PrintBackTrace(); +} +#line 1170 "parser.c" + break; + case 6: /* stmt ::= CONTINUE EOL */ +#line 91 "parser.lemon" +{ + command->action = Debug::cmdContinue; + command->argc = 0; +} +#line 1178 "parser.c" + break; + case 7: /* stmt ::= TBREAK EOL */ +#line 97 "parser.lemon" +{ + Debug::ToolBreak(); +} +#line 1185 "parser.c" + break; + case 8: /* stmt ::= TBREAK expr EOL */ +#line 102 "parser.lemon" +{ + Debug::ToolBreak(yymsp[-1].minor.yy0.intValue); +} +#line 1192 "parser.c" + break; + case 9: /* stmt ::= RBREAK EOL */ +#line 107 "parser.lemon" +{ + Debug::ReadBreak(); +} +#line 1199 "parser.c" + break; + case 10: /* stmt ::= RBREAK expr EOL */ +#line 112 "parser.lemon" +{ + Debug::ReadBreak(yymsp[-1].minor.yy0.intValue); +} +#line 1206 "parser.c" + break; + case 11: /* stmt ::= WBREAK EOL */ +#line 117 "parser.lemon" +{ + Debug::WriteBreak(); +} +#line 1213 "parser.c" + break; + case 12: /* stmt ::= WBREAK expr EOL */ +#line 122 "parser.lemon" +{ + Debug::WriteBreak(yymsp[-1].minor.yy0.intValue); +} +#line 1220 "parser.c" + break; + case 13: /* stmt ::= RWBREAK expr EOL */ +#line 128 "parser.lemon" +{ + Debug::ReadWriteBreak(yymsp[-1].minor.yy0.intValue); +} +#line 1227 "parser.c" + break; + case 14: /* stmt ::= NEXT EOL */ +#line 134 "parser.lemon" +{ + command->action = Debug::cmdStep; + command->argc = 0; +} +#line 1235 "parser.c" + break; + case 15: /* stmt ::= NEXT expr EOL */ +#line 140 "parser.lemon" +{ + command->action = Debug::cmdStep; + command->argc = 1; + command->argv[0] = yymsp[-1].minor.yy0.intValue; +} +#line 1244 "parser.c" + break; + case 16: /* stmt ::= DUMP expr EOL */ +#line 147 "parser.lemon" +{ + Debug::Dump(yymsp[-1].minor.yy0.intValue); +} +#line 1251 "parser.c" + break; + case 17: /* stmt ::= DUMP expr COLON expr EOL */ +#line 152 "parser.lemon" +{ + Debug::Dump(yymsp[-3].minor.yy0.intValue, yymsp[-1].minor.yy0.intValue - yymsp[-3].minor.yy0.intValue); +} +#line 1258 "parser.c" + break; + case 18: /* stmt ::= DUMP expr AT expr EOL */ +#line 157 "parser.lemon" +{ + Debug::Dump(yymsp[-3].minor.yy0.intValue, yymsp[-1].minor.yy0.intValue); +} +#line 1265 "parser.c" + break; + case 19: /* stmt ::= LIST expr EOL */ +#line 162 "parser.lemon" +{ + Debug::List(yymsp[-1].minor.yy0.intValue); +} +#line 1272 "parser.c" + break; + case 20: /* stmt ::= STACKCRAWL EOL */ +#line 167 "parser.lemon" +{ + Debug::StackCrawl(); +} +#line 1279 "parser.c" + break; + case 21: /* stmt ::= expr SEMI SEMIH EOL */ +#line 172 "parser.lemon" +{ + Debug::Dump(yymsp[-3].minor.yy0.intValue); +} +#line 1286 "parser.c" + break; + case 22: /* stmt ::= expr COLON expr SEMI SEMIH EOL */ +#line 177 "parser.lemon" +{ + Debug::Dump(yymsp[-5].minor.yy0.intValue, yymsp[-3].minor.yy0.intValue - yymsp[-5].minor.yy0.intValue); +} +#line 1293 "parser.c" + break; + case 23: /* stmt ::= expr AT expr SEMI SEMIH EOL */ +#line 182 "parser.lemon" +{ + Debug::Dump(yymsp[-5].minor.yy0.intValue, yymsp[-3].minor.yy0.intValue); +} +#line 1300 "parser.c" + break; + case 24: /* stmt ::= expr SEMI SEMII EOL */ +#line 188 "parser.lemon" +{ + Debug::Info(yymsp[-3].minor.yy0.intValue); +} +#line 1307 "parser.c" + break; + case 25: /* stmt ::= expr SEMI SEMIL EOL */ +#line 194 "parser.lemon" +{ + Debug::List(yymsp[-3].minor.yy0.intValue); +} +#line 1314 "parser.c" + break; + case 26: /* stmt ::= expr AT expr SEMI SEMIL EOL */ +#line 199 "parser.lemon" +{ + Debug::List(yymsp[-5].minor.yy0.intValue, (int)yymsp[-3].minor.yy0.intValue); +} +#line 1321 "parser.c" + break; + case 27: /* stmt ::= expr COLON expr SEMI SEMIL EOL */ +#line 204 "parser.lemon" +{ + Debug::List(yymsp[-5].minor.yy0.intValue, yymsp[-3].minor.yy0.intValue); +} +#line 1328 "parser.c" + break; + case 28: /* stmt ::= expr SEMI SEMIDATE EOL */ +#line 209 "parser.lemon" +{ + Debug::PrintDate(yymsp[-3].minor.yy0.intValue); +} +#line 1335 "parser.c" + break; + case 29: /* stmt ::= expr SEMI SEMIERROR EOL */ +#line 214 "parser.lemon" +{ + Debug::PrintError(yymsp[-3].minor.yy0.intValue); +} +#line 1342 "parser.c" + break; + case 30: /* stmt ::= expr SEMI SEMIT IDENTIFIER EOL */ +#line 221 "parser.lemon" +{ + Debug::ApplyTemplate(yymsp[-4].minor.yy0.intValue, *yymsp[-1].minor.yy0.stringValue); +} +#line 1349 "parser.c" + break; + case 31: /* stmt ::= expr SEMI SEMIT error EOL */ +#line 227 "parser.lemon" +{ + fprintf(stderr, "usage: expression ; t TemplateName\n"); +} +#line 1356 "parser.c" + break; + case 32: /* stmt ::= DREGISTER EQ expr EOL */ +#line 233 "parser.lemon" +{ + Debug::SetDRegister(yymsp[-3].minor.yy0.intValue, yymsp[-1].minor.yy0.intValue); +} +#line 1363 "parser.c" + break; + case 33: /* stmt ::= AREGISTER EQ expr EOL */ +#line 238 "parser.lemon" +{ + Debug::SetARegister(yymsp[-3].minor.yy0.intValue, yymsp[-1].minor.yy0.intValue); +} +#line 1370 "parser.c" + break; + case 34: /* stmt ::= XREGISTER EQ expr EOL */ +#line 243 "parser.lemon" +{ + Debug::SetXRegister(yymsp[-3].minor.yy0.intValue, yymsp[-1].minor.yy0.intValue); +} +#line 1377 "parser.c" + break; + case 35: /* stmt ::= HELP EOL */ +#line 248 "parser.lemon" +{ + Debug::Help(); +} +#line 1384 "parser.c" + break; + case 36: /* stmt ::= IDENTIFIER EQ expr EOL */ +#line 253 "parser.lemon" +{ + Debug::VariableSet(*yymsp[-3].minor.yy0.stringValue, yymsp[-1].minor.yy0.intValue); +} +#line 1391 "parser.c" + break; + case 37: /* expr ::= unary */ + case 57: /* unary ::= term */ yytestcase(yyruleno==57); + case 64: /* term ::= INTEGER */ yytestcase(yyruleno==64); + case 65: /* term ::= register */ yytestcase(yyruleno==65); +#line 257 "parser.lemon" +{ yylhsminor.yy0 = yymsp[0].minor.yy0; } +#line 1399 "parser.c" + yymsp[0].minor.yy0 = yylhsminor.yy0; + break; + case 38: /* expr ::= expr PLUS expr */ +#line 258 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue + yymsp[0].minor.yy0.intValue); } +#line 1405 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 39: /* expr ::= expr MINUS expr */ +#line 259 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue - yymsp[0].minor.yy0.intValue); } +#line 1411 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 40: /* expr ::= expr STAR expr */ +#line 260 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue * yymsp[0].minor.yy0.intValue); } +#line 1417 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 41: /* expr ::= expr SLASH expr */ +#line 261 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue / yymsp[0].minor.yy0.intValue); } +#line 1423 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 42: /* expr ::= expr PERCENT expr */ +#line 262 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue % yymsp[0].minor.yy0.intValue); } +#line 1429 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 43: /* expr ::= expr LTLT expr */ +#line 263 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue << yymsp[0].minor.yy0.intValue); } +#line 1435 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 44: /* expr ::= expr GTGT expr */ +#line 264 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue >> yymsp[0].minor.yy0.intValue); } +#line 1441 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 45: /* expr ::= expr LT expr */ +#line 265 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue < yymsp[0].minor.yy0.intValue); } +#line 1447 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 46: /* expr ::= expr LTEQ expr */ +#line 266 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue <= yymsp[0].minor.yy0.intValue); } +#line 1453 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 47: /* expr ::= expr GT expr */ +#line 267 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue > yymsp[0].minor.yy0.intValue); } +#line 1459 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 48: /* expr ::= expr GTEQ expr */ +#line 268 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue >= yymsp[0].minor.yy0.intValue); } +#line 1465 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 49: /* expr ::= expr EQEQ expr */ +#line 269 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue == yymsp[0].minor.yy0.intValue); } +#line 1471 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 50: /* expr ::= expr BANGEQ expr */ +#line 270 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue != yymsp[0].minor.yy0.intValue); } +#line 1477 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 51: /* expr ::= expr AMP expr */ +#line 271 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue & yymsp[0].minor.yy0.intValue); } +#line 1483 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 52: /* expr ::= expr CARET expr */ +#line 272 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue ^ yymsp[0].minor.yy0.intValue); } +#line 1489 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 53: /* expr ::= expr PIPE expr */ +#line 273 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue | yymsp[0].minor.yy0.intValue); } +#line 1495 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 54: /* expr ::= expr AMPAMP expr */ +#line 274 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue && yymsp[0].minor.yy0.intValue); } +#line 1501 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 55: /* expr ::= expr PIPEPIPE expr */ +#line 275 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(yymsp[-2].minor.yy0.intValue || yymsp[0].minor.yy0.intValue); } +#line 1507 "parser.c" + yymsp[-2].minor.yy0 = yylhsminor.yy0; + break; + case 56: /* expr ::= unary LPAREN register RPAREN */ +#line 281 "parser.lemon" +{ + uint32_t offset = yymsp[-3].minor.yy0.intValue; + uint32_t value = yymsp[-1].minor.yy0.intValue; + + // offset is 16-bits. + if (offset <= 0xffff) + { + if (offset & 0x8000) + offset |= 0xffff0000; + } + + yylhsminor.yy0 = Token::Make(value + offset); +} +#line 1525 "parser.c" + yymsp[-3].minor.yy0 = yylhsminor.yy0; + break; + case 58: /* unary ::= PLUS unary */ +#line 297 "parser.lemon" +{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; } +#line 1531 "parser.c" + break; + case 59: /* unary ::= MINUS unary */ +#line 298 "parser.lemon" +{ yymsp[-1].minor.yy0 = Token::Make(-yymsp[0].minor.yy0.intValue); } +#line 1536 "parser.c" + break; + case 60: /* unary ::= TILDE unary */ +#line 299 "parser.lemon" +{ yymsp[-1].minor.yy0 = Token::Make(~yymsp[0].minor.yy0.intValue); } +#line 1541 "parser.c" + break; + case 61: /* unary ::= BANG unary */ +#line 300 "parser.lemon" +{ yymsp[-1].minor.yy0 = Token::Make(!yymsp[0].minor.yy0.intValue); } +#line 1546 "parser.c" + break; + case 62: /* unary ::= STAR unary */ +#line 301 "parser.lemon" +{ yymsp[-1].minor.yy0 = Token::Make(Debug::ReadLong(yymsp[0].minor.yy0)); } +#line 1551 "parser.c" + break; + case 63: /* term ::= LPAREN expr RPAREN */ +#line 303 "parser.lemon" +{ yymsp[-2].minor.yy0 = yymsp[-1].minor.yy0; } +#line 1556 "parser.c" + break; + case 66: /* term ::= IDENTIFIER */ +#line 309 "parser.lemon" +{ + // should throw/barf if undefined? + yylhsminor.yy0 = Token::Make(Debug::VariableGet(*yymsp[0].minor.yy0.stringValue)); +} +#line 1564 "parser.c" + yymsp[0].minor.yy0 = yylhsminor.yy0; + break; + case 67: /* register ::= DREGISTER */ +#line 315 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(cpuGetDReg(yymsp[0].minor.yy0)); } +#line 1570 "parser.c" + yymsp[0].minor.yy0 = yylhsminor.yy0; + break; + case 68: /* register ::= AREGISTER */ +#line 316 "parser.lemon" +{ yylhsminor.yy0 = Token::Make(cpuGetAReg(yymsp[0].minor.yy0)); } +#line 1576 "parser.c" + yymsp[0].minor.yy0 = yylhsminor.yy0; + break; + case 69: /* register ::= XREGISTER */ +#line 318 "parser.lemon" +{ + switch(yymsp[0].minor.yy0) + { + case 0: + yylhsminor.yy0 = Token::Make(cpuGetPC()); + break; + case 1: + yylhsminor.yy0 = Token::Make(cpuGetSR()); + break; + default: + yylhsminor.yy0 = Token::Make(0); + } +} +#line 1594 "parser.c" + yymsp[0].minor.yy0 = yylhsminor.yy0; + break; + default: + break; +/********** End reduce actions ************************************************/ + }; + assert( yyrulenoYY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) ); + + /* It is not possible for a REDUCE to be followed by an error */ + assert( yyact!=YY_ERROR_ACTION ); + + if( yyact==YY_ACCEPT_ACTION ){ + yypParser->yytos += yysize; + yy_accept(yypParser); + }else{ + yymsp += yysize+1; + yypParser->yytos = yymsp; + yymsp->stateno = (YYACTIONTYPE)yyact; + yymsp->major = (YYCODETYPE)yygoto; + yyTraceShift(yypParser, yyact); + } +} + +/* +** The following code executes when the parse fails +*/ +#ifndef YYNOERRORRECOVERY +static void yy_parse_failed( + yyParser *yypParser /* The parser */ +){ + ParseARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); + } +#endif + while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser fails */ +/************ Begin %parse_failure code ***************************************/ +#line 36 "parser.lemon" + + //fprintf(stderr,"I don't understand.\n"); + command->valid = false; +#line 1646 "parser.c" +/************ End %parse_failure code *****************************************/ + ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} +#endif /* YYNOERRORRECOVERY */ + +/* +** The following code executes when a syntax error first occurs. +*/ +static void yy_syntax_error( + yyParser *yypParser, /* The parser */ + int yymajor, /* The major type of the error token */ + ParseTOKENTYPE yyminor /* The minor type of the error token */ +){ + ParseARG_FETCH; +#define TOKEN yyminor +/************ Begin %syntax_error code ****************************************/ +/************ End %syntax_error code ******************************************/ + ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following is executed when the parser accepts +*/ +static void yy_accept( + yyParser *yypParser /* The parser */ +){ + ParseARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); + } +#endif +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + assert( yypParser->yytos==yypParser->yystack ); + /* Here code is inserted which will be executed whenever the + ** parser accepts */ +/*********** Begin %parse_accept code *****************************************/ +#line 41 "parser.lemon" + + command->valid = true; +#line 1689 "parser.c" +/*********** End %parse_accept code *******************************************/ + ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* The main parser program. +** The first argument is a pointer to a structure obtained from +** "ParseAlloc" which describes the current state of the parser. +** The second argument is the major token number. The third is +** the minor token. The fourth optional argument is whatever the +** user wants (and specified in the grammar) and is available for +** use by the action routines. +** +** Inputs: +**
    +**
  • A pointer to the parser (an opaque structure.) +**
  • The major token number. +**
  • The minor token number. +**
  • An option argument of a grammar-specified type. +**
+** +** Outputs: +** None. +*/ +void Parse( + void *yyp, /* The parser */ + int yymajor, /* The major token code number */ + ParseTOKENTYPE yyminor /* The value for the token */ + ParseARG_PDECL /* Optional %extra_argument parameter */ +){ + YYMINORTYPE yyminorunion; + unsigned int yyact; /* The parser action. */ +#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) + int yyendofinput; /* True if we are at the end of input */ +#endif +#ifdef YYERRORSYMBOL + int yyerrorhit = 0; /* True if yymajor has invoked an error */ +#endif + yyParser *yypParser; /* The parser */ + + yypParser = (yyParser*)yyp; + assert( yypParser->yytos!=0 ); +#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) + yyendofinput = (yymajor==0); +#endif + ParseARG_STORE; + +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sInput '%s'\n",yyTracePrompt,yyTokenName[yymajor]); + } +#endif + + do{ + yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor); + if( yyact <= YY_MAX_SHIFTREDUCE ){ + yy_shift(yypParser,yyact,yymajor,yyminor); +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt--; +#endif + yymajor = YYNOCODE; + }else if( yyact <= YY_MAX_REDUCE ){ + yy_reduce(yypParser,yyact-YY_MIN_REDUCE); + }else{ + assert( yyact == YY_ERROR_ACTION ); + yyminorunion.yy0 = yyminor; +#ifdef YYERRORSYMBOL + int yymx; +#endif +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); + } +#endif +#ifdef YYERRORSYMBOL + /* A syntax error has occurred. + ** The response to an error depends upon whether or not the + ** grammar defines an error token "ERROR". + ** + ** This is what we do if the grammar does define ERROR: + ** + ** * Call the %syntax_error function. + ** + ** * Begin popping the stack until we enter a state where + ** it is legal to shift the error symbol, then shift + ** the error symbol. + ** + ** * Set the error count to three. + ** + ** * Begin accepting and shifting new tokens. No new error + ** processing will occur until three tokens have been + ** shifted successfully. + ** + */ + if( yypParser->yyerrcnt<0 ){ + yy_syntax_error(yypParser,yymajor,yyminor); + } + yymx = yypParser->yytos->major; + if( yymx==YYERRORSYMBOL || yyerrorhit ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sDiscard input token %s\n", + yyTracePrompt,yyTokenName[yymajor]); + } +#endif + yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion); + yymajor = YYNOCODE; + }else{ + while( yypParser->yytos >= yypParser->yystack + && yymx != YYERRORSYMBOL + && (yyact = yy_find_reduce_action( + yypParser->yytos->stateno, + YYERRORSYMBOL)) >= YY_MIN_REDUCE + ){ + yy_pop_parser_stack(yypParser); + } + if( yypParser->yytos < yypParser->yystack || yymajor==0 ){ + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + yy_parse_failed(yypParser); +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + yymajor = YYNOCODE; + }else if( yymx!=YYERRORSYMBOL ){ + yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor); + } + } + yypParser->yyerrcnt = 3; + yyerrorhit = 1; +#elif defined(YYNOERRORRECOVERY) + /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to + ** do any kind of error recovery. Instead, simply invoke the syntax + ** error routine and continue going as if nothing had happened. + ** + ** Applications can set this macro (for example inside %include) if + ** they intend to abandon the parse upon the first syntax error seen. + */ + yy_syntax_error(yypParser,yymajor, yyminor); + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + yymajor = YYNOCODE; + +#else /* YYERRORSYMBOL is not defined */ + /* This is what we do if the grammar does not define ERROR: + ** + ** * Report an error message, and throw away the input token. + ** + ** * If the input token is $, then fail the parse. + ** + ** As before, subsequent error messages are suppressed until + ** three input tokens have been successfully shifted. + */ + if( yypParser->yyerrcnt<=0 ){ + yy_syntax_error(yypParser,yymajor, yyminor); + } + yypParser->yyerrcnt = 3; + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + if( yyendofinput ){ + yy_parse_failed(yypParser); +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + } + yymajor = YYNOCODE; +#endif + } + }while( yymajor!=YYNOCODE && yypParser->yytos>yypParser->yystack ); +#ifndef NDEBUG + if( yyTraceFILE ){ + yyStackEntry *i; + char cDiv = '['; + fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt); + for(i=&yypParser->yystack[1]; i<=yypParser->yytos; i++){ + fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]); + cDiv = ' '; + } + if (cDiv == '[') fprintf(yyTraceFILE,"["); + fprintf(yyTraceFILE,"]\n"); + } +#endif + return; +} diff --git a/bin/parser.h b/bin/parser.h new file mode 100644 index 0000000..0ef37f7 --- /dev/null +++ b/bin/parser.h @@ -0,0 +1,51 @@ +#define tkPIPEPIPE 1 +#define tkAMPAMP 2 +#define tkPIPE 3 +#define tkCARET 4 +#define tkAMP 5 +#define tkEQEQ 6 +#define tkBANGEQ 7 +#define tkLT 8 +#define tkLTEQ 9 +#define tkGT 10 +#define tkGTEQ 11 +#define tkLTLT 12 +#define tkGTGT 13 +#define tkPLUS 14 +#define tkMINUS 15 +#define tkSTAR 16 +#define tkSLASH 17 +#define tkPERCENT 18 +#define tkBANG 19 +#define tkTILDE 20 +#define tkEOL 21 +#define tkPRINT 22 +#define tkBREAK 23 +#define tkBACKTRACE 24 +#define tkCONTINUE 25 +#define tkTBREAK 26 +#define tkRBREAK 27 +#define tkWBREAK 28 +#define tkRWBREAK 29 +#define tkNEXT 30 +#define tkDUMP 31 +#define tkCOLON 32 +#define tkAT 33 +#define tkLIST 34 +#define tkSTACKCRAWL 35 +#define tkSEMI 36 +#define tkSEMIH 37 +#define tkSEMII 38 +#define tkSEMIL 39 +#define tkSEMIDATE 40 +#define tkSEMIERROR 41 +#define tkSEMIT 42 +#define tkIDENTIFIER 43 +#define tkDREGISTER 44 +#define tkEQ 45 +#define tkAREGISTER 46 +#define tkXREGISTER 47 +#define tkHELP 48 +#define tkLPAREN 49 +#define tkRPAREN 50 +#define tkINTEGER 51 diff --git a/bin/template_parser.cpp b/bin/template_parser.cpp new file mode 100644 index 0000000..660b166 --- /dev/null +++ b/bin/template_parser.cpp @@ -0,0 +1,1291 @@ +/* +** 2000-05-29 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Driver template for the LEMON parser generator. +** +** The "lemon" program processes an LALR(1) input grammar file, then uses +** this template to construct a parser. The "lemon" program inserts text +** at each "%%" line. Also, any "P-a-r-s-e" identifer prefix (without the +** interstitial "-" characters) contained in this template is changed into +** the value of the %name directive from the grammar. Otherwise, the content +** of this template is copied straight through into the generate parser +** source file. +** +** The following is the concatenation of all %include directives from the +** input grammar file: +*/ +#include +#include +/************ Begin %include sections from the grammar ************************/ +#line 6 "template_parser.lemon" + + + #include + #include + #include + #include + + #include "template.h" + + using namespace Debug; +#line 40 "template_parser.c" +/**************** End of %include directives **********************************/ +/* These constants specify the various numeric values for terminal symbols +** in a format understandable to "makeheaders". This section is blank unless +** "lemon" is run with the "-m" command-line option. +***************** Begin makeheaders token definitions *************************/ +/**************** End makeheaders token definitions ***************************/ + +/* The next sections is a series of control #defines. +** various aspects of the generated parser. +** YYCODETYPE is the data type used to store the integer codes +** that represent terminal and non-terminal symbols. +** "unsigned char" is used if there are fewer than +** 256 symbols. Larger types otherwise. +** YYNOCODE is a number of type YYCODETYPE that is not used for +** any terminal or nonterminal symbol. +** YYFALLBACK If defined, this indicates that one or more tokens +** (also known as: "terminal symbols") have fall-back +** values which should be used if the original symbol +** would not parse. This permits keywords to sometimes +** be used as identifiers, for example. +** YYACTIONTYPE is the data type used for "action codes" - numbers +** that indicate what to do in response to the next +** token. +** TemplateParseTOKENTYPE is the data type used for minor type for terminal +** symbols. Background: A "minor type" is a semantic +** value associated with a terminal or non-terminal +** symbols. For example, for an "ID" terminal symbol, +** the minor type might be the name of the identifier. +** Each non-terminal can have a different minor type. +** Terminal symbols all have the same minor type, though. +** This macros defines the minor type for terminal +** symbols. +** YYMINORTYPE is the data type used for all minor types. +** This is typically a union of many types, one of +** which is TemplateParseTOKENTYPE. The entry in the union +** for terminal symbols is called "yy0". +** YYSTACKDEPTH is the maximum depth of the parser's stack. If +** zero the stack is dynamically sized using realloc() +** TemplateParseARG_SDECL A static variable declaration for the %extra_argument +** TemplateParseARG_PDECL A parameter declaration for the %extra_argument +** TemplateParseARG_STORE Code to store %extra_argument into yypParser +** TemplateParseARG_FETCH Code to extract %extra_argument from yypParser +** YYERRORSYMBOL is the code number of the error symbol. If not +** defined, then do no error processing. +** YYNSTATE the combined number of states. +** YYNRULE the number of rules in the grammar +** YY_MAX_SHIFT Maximum value for shift actions +** YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions +** YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions +** YY_MIN_REDUCE Maximum value for reduce actions +** YY_ERROR_ACTION The yy_action[] code for syntax error +** YY_ACCEPT_ACTION The yy_action[] code for accept +** YY_NO_ACTION The yy_action[] code for no-op +*/ +#ifndef INTERFACE +# define INTERFACE 1 +#endif +/************* Begin control #defines *****************************************/ +#define YYCODETYPE unsigned char +#define YYNOCODE 36 +#define YYACTIONTYPE unsigned char +#define TemplateParseTOKENTYPE void* +typedef union { + int yyinit; + TemplateParseTOKENTYPE yy0; + int yy32; + FieldEntry * yy51; +} YYMINORTYPE; +#ifndef YYSTACKDEPTH +#define YYSTACKDEPTH 100 +#endif +#define TemplateParseARG_SDECL Debug::TemplateParseInfo *info ; +#define TemplateParseARG_PDECL , Debug::TemplateParseInfo *info +#define TemplateParseARG_FETCH Debug::TemplateParseInfo *info = yypParser->info +#define TemplateParseARG_STORE yypParser->info = info +#define YYNSTATE 26 +#define YYNRULE 34 +#define YY_MAX_SHIFT 25 +#define YY_MIN_SHIFTREDUCE 50 +#define YY_MAX_SHIFTREDUCE 83 +#define YY_MIN_REDUCE 84 +#define YY_MAX_REDUCE 117 +#define YY_ERROR_ACTION 118 +#define YY_ACCEPT_ACTION 119 +#define YY_NO_ACTION 120 +/************* End control #defines *******************************************/ + +/* Define the yytestcase() macro to be a no-op if is not already defined +** otherwise. +** +** Applications can choose to define yytestcase() in the %include section +** to a macro that can assist in verifying code coverage. For production +** code the yytestcase() macro should be turned off. But it is useful +** for testing. +*/ +#ifndef yytestcase +# define yytestcase(X) +#endif + + +/* Next are the tables used to determine what action to take based on the +** current state and lookahead token. These tables are used to implement +** functions that take a state number and lookahead value and return an +** action integer. +** +** Suppose the action integer is N. Then the action is determined as +** follows +** +** 0 <= N <= YY_MAX_SHIFT Shift N. That is, push the lookahead +** token onto the stack and goto state N. +** +** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then +** and YY_MAX_SHIFTREDUCE reduce by rule N-YY_MIN_SHIFTREDUCE. +** +** N between YY_MIN_REDUCE Reduce by rule N-YY_MIN_REDUCE +** and YY_MAX_REDUCE +** +** N == YY_ERROR_ACTION A syntax error has occurred. +** +** N == YY_ACCEPT_ACTION The parser accepts its input. +** +** N == YY_NO_ACTION No such action. Denotes unused +** slots in the yy_action[] table. +** +** The action table is constructed as a single large table named yy_action[]. +** Given state S and lookahead X, the action is computed as either: +** +** (A) N = yy_action[ yy_shift_ofst[S] + X ] +** (B) N = yy_default[S] +** +** The (A) formula is preferred. The B formula is used instead if: +** (1) The yy_shift_ofst[S]+X value is out of range, or +** (2) yy_lookahead[yy_shift_ofst[S]+X] is not equal to X, or +** (3) yy_shift_ofst[S] equal YY_SHIFT_USE_DFLT. +** (Implementation note: YY_SHIFT_USE_DFLT is chosen so that +** YY_SHIFT_USE_DFLT+X will be out of range for all possible lookaheads X. +** Hence only tests (1) and (2) need to be evaluated.) +** +** The formulas above are for computing the action when the lookahead is +** a terminal symbol. If the lookahead is a non-terminal (as occurs after +** a reduce action) then the yy_reduce_ofst[] array is used in place of +** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of +** YY_SHIFT_USE_DFLT. +** +** The following are the tables generated in this section: +** +** yy_action[] A single table containing all actions. +** yy_lookahead[] A table containing the lookahead for each entry in +** yy_action. Used to detect hash collisions. +** yy_shift_ofst[] For each state, the offset into yy_action for +** shifting terminals. +** yy_reduce_ofst[] For each state, the offset into yy_action for +** shifting non-terminals after a reduce. +** yy_default[] Default action for each state. +** +*********** Begin parsing tables **********************************************/ +#define YY_ACTTAB_COUNT (61) +static const YYACTIONTYPE yy_action[] = { + /* 0 */ 59, 86, 59, 119, 5, 10, 19, 79, 3, 100, + /* 10 */ 24, 13, 24, 13, 101, 70, 23, 70, 23, 2, + /* 20 */ 87, 108, 6, 17, 22, 19, 73, 3, 62, 64, + /* 30 */ 7, 63, 65, 8, 20, 92, 12, 109, 110, 14, + /* 40 */ 79, 25, 68, 4, 69, 55, 83, 15, 83, 18, + /* 50 */ 9, 57, 16, 54, 11, 51, 21, 1, 94, 71, + /* 60 */ 50, +}; +static const YYCODETYPE yy_lookahead[] = { + /* 0 */ 2, 23, 2, 24, 25, 7, 28, 11, 30, 34, + /* 10 */ 12, 13, 12, 13, 34, 17, 18, 17, 18, 22, + /* 20 */ 23, 0, 1, 8, 3, 28, 19, 30, 14, 15, + /* 30 */ 16, 14, 15, 16, 5, 32, 33, 26, 27, 29, + /* 40 */ 11, 28, 16, 30, 16, 6, 20, 31, 20, 29, + /* 50 */ 2, 10, 9, 6, 2, 6, 2, 4, 2, 19, + /* 60 */ 2, +}; +#define YY_SHIFT_USE_DFLT (61) +#define YY_SHIFT_COUNT (25) +#define YY_SHIFT_MIN (-4) +#define YY_SHIFT_MAX (58) +static const signed char yy_shift_ofst[] = { + /* 0 */ 61, -4, 29, -2, 0, 21, -4, 26, 28, 15, + /* 10 */ 7, 15, 14, 17, 39, 48, 41, 43, 47, 52, + /* 20 */ 49, 53, 54, 40, 56, 58, +}; +#define YY_REDUCE_USE_DFLT (-26) +#define YY_REDUCE_COUNT (11) +#define YY_REDUCE_MIN (-25) +#define YY_REDUCE_MAX (20) +static const signed char yy_reduce_ofst[] = { + /* 0 */ -21, -3, -22, 3, 3, 11, 13, -25, -20, 10, + /* 10 */ 16, 20, +}; +static const YYACTIONTYPE yy_default[] = { + /* 0 */ 111, 112, 112, 114, 114, 118, 112, 116, 116, 90, + /* 10 */ 106, 90, 118, 95, 118, 118, 118, 118, 118, 118, + /* 20 */ 118, 118, 118, 118, 115, 118, +}; +/********** End of lemon-generated parsing tables *****************************/ + +/* The next table maps tokens (terminal symbols) into fallback tokens. +** If a construct like the following: +** +** %fallback ID X Y Z. +** +** appears in the grammar, then ID becomes a fallback token for X, Y, +** and Z. Whenever one of the tokens X, Y, or Z is input to the parser +** but it does not parse, the type of the token is changed to ID and +** the parse is retried before an error is thrown. +** +** This feature can be used, for example, to cause some keywords in a language +** to revert to identifiers if they keyword does not apply in the context where +** it appears. +*/ +#ifdef YYFALLBACK +static const YYCODETYPE yyFallback[] = { +}; +#endif /* YYFALLBACK */ + +/* The following structure represents a single element of the +** parser's stack. Information stored includes: +** +** + The state number for the parser at this level of the stack. +** +** + The value of the token stored at this level of the stack. +** (In other words, the "major" token.) +** +** + The semantic value stored at this level of the stack. This is +** the information used by the action routines in the grammar. +** It is sometimes called the "minor" token. +** +** After the "shift" half of a SHIFTREDUCE action, the stateno field +** actually contains the reduce action for the second half of the +** SHIFTREDUCE. +*/ +struct yyStackEntry { + YYACTIONTYPE stateno; /* The state-number, or reduce action in SHIFTREDUCE */ + YYCODETYPE major; /* The major token value. This is the code + ** number for the token at this stack level */ + YYMINORTYPE minor; /* The user-supplied minor token value. This + ** is the value of the token */ +}; +typedef struct yyStackEntry yyStackEntry; + +/* The state of the parser is completely contained in an instance of +** the following structure */ +struct yyParser { + yyStackEntry *yytos; /* Pointer to top element of the stack */ +#ifdef YYTRACKMAXSTACKDEPTH + int yyhwm; /* High-water mark of the stack */ +#endif +#ifndef YYNOERRORRECOVERY + int yyerrcnt; /* Shifts left before out of the error */ +#endif + TemplateParseARG_SDECL /* A place to hold %extra_argument */ +#if YYSTACKDEPTH<=0 + int yystksz; /* Current side of the stack */ + yyStackEntry *yystack; /* The parser's stack */ + yyStackEntry yystk0; /* First stack entry */ +#else + yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ + yyStackEntry *yystackEnd; /* Last entry in the stack */ +#endif +}; +typedef struct yyParser yyParser; + +#ifndef NDEBUG +#include +static FILE *yyTraceFILE = 0; +static char *yyTracePrompt = 0; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Turn parser tracing on by giving a stream to which to write the trace +** and a prompt to preface each trace message. Tracing is turned off +** by making either argument NULL +** +** Inputs: +**
    +**
  • A FILE* to which trace output should be written. +** If NULL, then tracing is turned off. +**
  • A prefix string written at the beginning of every +** line of trace output. If NULL, then tracing is +** turned off. +**
+** +** Outputs: +** None. +*/ +void TemplateParseTrace(FILE *TraceFILE, char *zTracePrompt){ + yyTraceFILE = TraceFILE; + yyTracePrompt = zTracePrompt; + if( yyTraceFILE==0 ) yyTracePrompt = 0; + else if( yyTracePrompt==0 ) yyTraceFILE = 0; +} +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing shifts, the names of all terminals and nonterminals +** are required. The following table supplies these names */ +static const char *const yyTokenName[] = { + "$", "TYPEDEF", "IDENTIFIER", "STRUCT", + "LBRACE", "RBRACE", "SEMI", "TEMPLATE", + "LBRACKET", "INTEGER", "RBRACKET", "VOLATILE", + "SIGNED", "UNSIGNED", "CHAR", "SHORT", + "LONG", "TYPECODE", "VOID", "STAR", + "INT", "error", "struct_fields", "struct_field", + "start", "templates", "struct", "typedef", + "type", "array_count", "opt_volatile", "opt_star", + "typecode", "opt_signed", "opt_int", +}; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing reduce actions, the names of all rules are required. +*/ +static const char *const yyRuleName[] = { + /* 0 */ "typedef ::= TYPEDEF type IDENTIFIER", + /* 1 */ "struct ::= STRUCT IDENTIFIER LBRACE struct_fields RBRACE SEMI", + /* 2 */ "struct_fields ::= struct_fields struct_field", + /* 3 */ "struct_fields ::= struct_field", + /* 4 */ "struct_field ::= type IDENTIFIER array_count SEMI", + /* 5 */ "struct_field ::= opt_volatile TEMPLATE opt_star IDENTIFIER array_count SEMI", + /* 6 */ "array_count ::=", + /* 7 */ "array_count ::= LBRACKET INTEGER RBRACKET", + /* 8 */ "type ::= opt_volatile typecode", + /* 9 */ "type ::= opt_volatile IDENTIFIER", + /* 10 */ "typecode ::= SIGNED", + /* 11 */ "typecode ::= UNSIGNED", + /* 12 */ "typecode ::= opt_signed CHAR", + /* 13 */ "typecode ::= UNSIGNED CHAR", + /* 14 */ "typecode ::= opt_signed SHORT", + /* 15 */ "typecode ::= UNSIGNED SHORT", + /* 16 */ "typecode ::= opt_signed LONG opt_int", + /* 17 */ "typecode ::= UNSIGNED LONG opt_int", + /* 18 */ "typecode ::= opt_signed LONG LONG", + /* 19 */ "typecode ::= UNSIGNED LONG LONG", + /* 20 */ "typecode ::= TYPECODE", + /* 21 */ "typecode ::= VOID STAR", + /* 22 */ "opt_star ::=", + /* 23 */ "opt_star ::= STAR", + /* 24 */ "start ::= templates", + /* 25 */ "templates ::= templates struct", + /* 26 */ "templates ::= templates typedef", + /* 27 */ "templates ::=", + /* 28 */ "opt_volatile ::=", + /* 29 */ "opt_volatile ::= VOLATILE", + /* 30 */ "opt_signed ::=", + /* 31 */ "opt_signed ::= SIGNED", + /* 32 */ "opt_int ::=", + /* 33 */ "opt_int ::= INT", +}; +#endif /* NDEBUG */ + + +#if YYSTACKDEPTH<=0 +/* +** Try to increase the size of the parser stack. Return the number +** of errors. Return 0 on success. +*/ +static int yyGrowStack(yyParser *p){ + int newSize; + int idx; + yyStackEntry *pNew; + + newSize = p->yystksz*2 + 100; + idx = p->yytos ? (int)(p->yytos - p->yystack) : 0; + if( p->yystack==&p->yystk0 ){ + pNew = malloc(newSize*sizeof(pNew[0])); + if( pNew ) pNew[0] = p->yystk0; + }else{ + pNew = realloc(p->yystack, newSize*sizeof(pNew[0])); + } + if( pNew ){ + p->yystack = pNew; + p->yytos = &p->yystack[idx]; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n", + yyTracePrompt, p->yystksz, newSize); + } +#endif + p->yystksz = newSize; + } + return pNew==0; +} +#endif + +/* Datatype of the argument to the memory allocated passed as the +** second argument to TemplateParseAlloc() below. This can be changed by +** putting an appropriate #define in the %include section of the input +** grammar. +*/ +#ifndef YYMALLOCARGTYPE +# define YYMALLOCARGTYPE size_t +#endif + +/* Initialize a new parser that has already been allocated. +*/ +void TemplateParseInit(void *yypParser){ + yyParser *pParser = (yyParser*)yypParser; +#ifdef YYTRACKMAXSTACKDEPTH + pParser->yyhwm = 0; +#endif +#if YYSTACKDEPTH<=0 + pParser->yytos = NULL; + pParser->yystack = NULL; + pParser->yystksz = 0; + if( yyGrowStack(pParser) ){ + pParser->yystack = &pParser->yystk0; + pParser->yystksz = 1; + } +#endif +#ifndef YYNOERRORRECOVERY + pParser->yyerrcnt = -1; +#endif + pParser->yytos = pParser->yystack; + pParser->yystack[0].stateno = 0; + pParser->yystack[0].major = 0; +#if YYSTACKDEPTH>0 + pParser->yystackEnd = &pParser->yystack[YYSTACKDEPTH-1]; +#endif +} + +#ifndef TemplateParse_ENGINEALWAYSONSTACK +/* +** This function allocates a new parser. +** The only argument is a pointer to a function which works like +** malloc. +** +** Inputs: +** A pointer to the function used to allocate memory. +** +** Outputs: +** A pointer to a parser. This pointer is used in subsequent calls +** to TemplateParse and TemplateParseFree. +*/ +void *TemplateParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE)){ + yyParser *pParser; + pParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) ); + if( pParser ) TemplateParseInit(pParser); + return pParser; +} +#endif /* TemplateParse_ENGINEALWAYSONSTACK */ + + +/* The following function deletes the "minor type" or semantic value +** associated with a symbol. The symbol can be either a terminal +** or nonterminal. "yymajor" is the symbol code, and "yypminor" is +** a pointer to the value to be deleted. The code used to do the +** deletions is derived from the %destructor and/or %token_destructor +** directives of the input grammar. +*/ +static void yy_destructor( + yyParser *yypParser, /* The parser */ + YYCODETYPE yymajor, /* Type code for object to destroy */ + YYMINORTYPE *yypminor /* The object to be destroyed */ +){ + TemplateParseARG_FETCH; + switch( yymajor ){ + /* Here is inserted the actions which take place when a + ** terminal or non-terminal is destroyed. This can happen + ** when the symbol is popped from the stack during a + ** reduce or during error processing or when a parser is + ** being destroyed before it is finished parsing. + ** + ** Note: during a reduce, the only symbols destroyed are those + ** which appear on the RHS of the rule, but which are *not* used + ** inside the C code. + */ +/********* Begin destructor definitions ***************************************/ +/********* End destructor definitions *****************************************/ + default: break; /* If no destructor action specified: do nothing */ + } +} + +/* +** Pop the parser's stack once. +** +** If there is a destructor routine associated with the token which +** is popped from the stack, then call it. +*/ +static void yy_pop_parser_stack(yyParser *pParser){ + yyStackEntry *yytos; + assert( pParser->yytos!=0 ); + assert( pParser->yytos > pParser->yystack ); + yytos = pParser->yytos--; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sPopping %s\n", + yyTracePrompt, + yyTokenName[yytos->major]); + } +#endif + yy_destructor(pParser, yytos->major, &yytos->minor); +} + +/* +** Clear all secondary memory allocations from the parser +*/ +void TemplateParseFinalize(void *p){ + yyParser *pParser = (yyParser*)p; + while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser); +#if YYSTACKDEPTH<=0 + if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack); +#endif +} + +#ifndef TemplateParse_ENGINEALWAYSONSTACK +/* +** Deallocate and destroy a parser. Destructors are called for +** all stack elements before shutting the parser down. +** +** If the YYPARSEFREENEVERNULL macro exists (for example because it +** is defined in a %include section of the input grammar) then it is +** assumed that the input pointer is never NULL. +*/ +void TemplateParseFree( + void *p, /* The parser to be deleted */ + void (*freeProc)(void*) /* Function used to reclaim memory */ +){ +#ifndef YYPARSEFREENEVERNULL + if( p==0 ) return; +#endif + TemplateParseFinalize(p); + (*freeProc)(p); +} +#endif /* TemplateParse_ENGINEALWAYSONSTACK */ + +/* +** Return the peak depth of the stack for a parser. +*/ +#ifdef YYTRACKMAXSTACKDEPTH +int TemplateParseStackPeak(void *p){ + yyParser *pParser = (yyParser*)p; + return pParser->yyhwm; +} +#endif + +/* +** Find the appropriate action for a parser given the terminal +** look-ahead token iLookAhead. +*/ +static unsigned int yy_find_shift_action( + yyParser *pParser, /* The parser */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; + int stateno = pParser->yytos->stateno; + + if( stateno>=YY_MIN_REDUCE ) return stateno; + assert( stateno <= YY_SHIFT_COUNT ); + do{ + i = yy_shift_ofst[stateno]; + assert( iLookAhead!=YYNOCODE ); + i += iLookAhead; + if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ +#ifdef YYFALLBACK + YYCODETYPE iFallback; /* Fallback token */ + if( iLookAhead %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); + } +#endif + assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */ + iLookAhead = iFallback; + continue; + } +#endif +#ifdef YYWILDCARD + { + int j = i - iLookAhead + YYWILDCARD; + if( +#if YY_SHIFT_MIN+YYWILDCARD<0 + j>=0 && +#endif +#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT + j0 + ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n", + yyTracePrompt, yyTokenName[iLookAhead], + yyTokenName[YYWILDCARD]); + } +#endif /* NDEBUG */ + return yy_action[j]; + } + } +#endif /* YYWILDCARD */ + return yy_default[stateno]; + }else{ + return yy_action[i]; + } + }while(1); +} + +/* +** Find the appropriate action for a parser given the non-terminal +** look-ahead token iLookAhead. +*/ +static int yy_find_reduce_action( + int stateno, /* Current state number */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; +#ifdef YYERRORSYMBOL + if( stateno>YY_REDUCE_COUNT ){ + return yy_default[stateno]; + } +#else + assert( stateno<=YY_REDUCE_COUNT ); +#endif + i = yy_reduce_ofst[stateno]; + assert( i!=YY_REDUCE_USE_DFLT ); + assert( iLookAhead!=YYNOCODE ); + i += iLookAhead; +#ifdef YYERRORSYMBOL + if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ + return yy_default[stateno]; + } +#else + assert( i>=0 && iyytos>yypParser->yystack ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will execute if the parser + ** stack every overflows */ +/******** Begin %stack_overflow code ******************************************/ +/******** End %stack_overflow code ********************************************/ + TemplateParseARG_STORE; /* Suppress warning about unused %extra_argument var */ +} + +/* +** Print tracing information for a SHIFT action +*/ +#ifndef NDEBUG +static void yyTraceShift(yyParser *yypParser, int yyNewState){ + if( yyTraceFILE ){ + if( yyNewStateyytos->major], + yyNewState); + }else{ + fprintf(yyTraceFILE,"%sShift '%s'\n", + yyTracePrompt,yyTokenName[yypParser->yytos->major]); + } + } +} +#else +# define yyTraceShift(X,Y) +#endif + +/* +** Perform a shift action. +*/ +static void yy_shift( + yyParser *yypParser, /* The parser to be shifted */ + int yyNewState, /* The new state to shift in */ + int yyMajor, /* The major token to shift in */ + TemplateParseTOKENTYPE yyMinor /* The minor token to shift in */ +){ + yyStackEntry *yytos; + yypParser->yytos++; +#ifdef YYTRACKMAXSTACKDEPTH + if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){ + yypParser->yyhwm++; + assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) ); + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yytos>yypParser->yystackEnd ){ + yypParser->yytos--; + yyStackOverflow(yypParser); + return; + } +#else + if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){ + if( yyGrowStack(yypParser) ){ + yypParser->yytos--; + yyStackOverflow(yypParser); + return; + } + } +#endif + if( yyNewState > YY_MAX_SHIFT ){ + yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE; + } + yytos = yypParser->yytos; + yytos->stateno = (YYACTIONTYPE)yyNewState; + yytos->major = (YYCODETYPE)yyMajor; + yytos->minor.yy0 = yyMinor; + yyTraceShift(yypParser, yyNewState); +} + +/* The following table contains information about every rule that +** is used during the reduce. +*/ +static const struct { + YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ + signed char nrhs; /* Negative of the number of RHS symbols in the rule */ +} yyRuleInfo[] = { + { 27, -3 }, + { 26, -6 }, + { 22, -2 }, + { 22, -1 }, + { 23, -4 }, + { 23, -6 }, + { 29, 0 }, + { 29, -3 }, + { 28, -2 }, + { 28, -2 }, + { 32, -1 }, + { 32, -1 }, + { 32, -2 }, + { 32, -2 }, + { 32, -2 }, + { 32, -2 }, + { 32, -3 }, + { 32, -3 }, + { 32, -3 }, + { 32, -3 }, + { 32, -1 }, + { 32, -2 }, + { 31, 0 }, + { 31, -1 }, + { 24, -1 }, + { 25, -2 }, + { 25, -2 }, + { 25, 0 }, + { 30, 0 }, + { 30, -1 }, + { 33, 0 }, + { 33, -1 }, + { 34, 0 }, + { 34, -1 }, +}; + +static void yy_accept(yyParser*); /* Forward Declaration */ + +/* +** Perform a reduce action and the shift that must immediately +** follow the reduce. +*/ +static void yy_reduce( + yyParser *yypParser, /* The parser */ + unsigned int yyruleno /* Number of the rule by which to reduce */ +){ + int yygoto; /* The next state */ + int yyact; /* The next action */ + yyStackEntry *yymsp; /* The top of the parser's stack */ + int yysize; /* Amount to pop the stack */ + TemplateParseARG_FETCH; + yymsp = yypParser->yytos; +#ifndef NDEBUG + if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ + yysize = yyRuleInfo[yyruleno].nrhs; + fprintf(yyTraceFILE, "%sReduce [%s], go to state %d.\n", yyTracePrompt, + yyRuleName[yyruleno], yymsp[yysize].stateno); + } +#endif /* NDEBUG */ + + /* Check that the stack is large enough to grow by a single entry + ** if the RHS of the rule is empty. This ensures that there is room + ** enough on the stack to push the LHS value */ + if( yyRuleInfo[yyruleno].nrhs==0 ){ +#ifdef YYTRACKMAXSTACKDEPTH + if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){ + yypParser->yyhwm++; + assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack)); + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yytos>=yypParser->yystackEnd ){ + yyStackOverflow(yypParser); + return; + } +#else + if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ + if( yyGrowStack(yypParser) ){ + yyStackOverflow(yypParser); + return; + } + yymsp = yypParser->yytos; + } +#endif + } + + switch( yyruleno ){ + /* Beginning here are the reduction cases. A typical example + ** follows: + ** case 0: + ** #line + ** { ... } // User supplied code + ** #line + ** break; + */ +/********** Begin reduce actions **********************************************/ + YYMINORTYPE yylhsminor; + case 0: /* typedef ::= TYPEDEF type IDENTIFIER */ +#line 29 "template_parser.lemon" +{ + CreateTypedef((std::string *)yymsp[0].minor.yy0, yymsp[-1].minor.yy32, info); +} +#line 863 "template_parser.c" + break; + case 1: /* struct ::= STRUCT IDENTIFIER LBRACE struct_fields RBRACE SEMI */ +#line 34 "template_parser.lemon" +{ + CreateTemplate((std::string *)yymsp[-4].minor.yy0, yymsp[-2].minor.yy51, info); +} +#line 870 "template_parser.c" + break; + case 2: /* struct_fields ::= struct_fields struct_field */ +#line 38 "template_parser.lemon" +{ + // reverse order? + yymsp[0].minor.yy51->next = yymsp[-1].minor.yy51; + yylhsminor.yy51 = yymsp[0].minor.yy51; +} +#line 879 "template_parser.c" + yymsp[-1].minor.yy51 = yylhsminor.yy51; + break; + case 3: /* struct_fields ::= struct_field */ +#line 44 "template_parser.lemon" +{ + yylhsminor.yy51 = yymsp[0].minor.yy51; +} +#line 887 "template_parser.c" + yymsp[0].minor.yy51 = yylhsminor.yy51; + break; + case 4: /* struct_field ::= type IDENTIFIER array_count SEMI */ +#line 49 "template_parser.lemon" +{ + FieldEntry *e = (FieldEntry *)calloc(sizeof(FieldEntry), 1); + + e->name = (std::string *)yymsp[-2].minor.yy0; + e->type = yymsp[-3].minor.yy32; + e->count = yymsp[-1].minor.yy32; + yylhsminor.yy51 = e; +} +#line 900 "template_parser.c" + yymsp[-3].minor.yy51 = yylhsminor.yy51; + break; + case 5: /* struct_field ::= opt_volatile TEMPLATE opt_star IDENTIFIER array_count SEMI */ +#line 58 "template_parser.lemon" +{ + FieldEntry *e = (FieldEntry *)calloc(sizeof(FieldEntry), 1); + + e->name = (std::string *)yymsp[-2].minor.yy0; + e->type = yymsp[-3].minor.yy32 ? kStructPtr : kStruct; + e->tmpl = (Template)yymsp[-4].minor.yy0; + e->count = yymsp[-1].minor.yy32; + + yymsp[-5].minor.yy51 = e; +} +#line 915 "template_parser.c" + break; + case 6: /* array_count ::= */ + case 22: /* opt_star ::= */ yytestcase(yyruleno==22); +#line 70 "template_parser.lemon" +{ yymsp[1].minor.yy32 = 0; } +#line 921 "template_parser.c" + break; + case 7: /* array_count ::= LBRACKET INTEGER RBRACKET */ +#line 71 "template_parser.lemon" +{ + int i = (int)(ptrdiff_t)yymsp[-1].minor.yy0; + if (i == 0) { + fprintf(stderr, "Template error: line %u: 0-sized arrays are not allowed.\n", + info->LineNumber); + i = 1; + } + yymsp[-2].minor.yy32 = i; +} +#line 934 "template_parser.c" + break; + case 8: /* type ::= opt_volatile typecode */ +#line 82 "template_parser.lemon" +{ yymsp[-1].minor.yy32 = yymsp[0].minor.yy32; } +#line 939 "template_parser.c" + break; + case 9: /* type ::= opt_volatile IDENTIFIER */ +#line 85 "template_parser.lemon" +{ + + // ugh, Lemon will blindly replace text within a string. + fprintf(stderr, "Template error: line %u: %s is not a known type.\n", + info->LineNumber, ((std::string *)yymsp[0].minor.yy0)->c_str()); + + yymsp[-1].minor.yy32 = 'i'; +} +#line 951 "template_parser.c" + break; + case 10: /* typecode ::= SIGNED */ +#line 100 "template_parser.lemon" +{ yymsp[0].minor.yy32 = kSInt32; } +#line 956 "template_parser.c" + break; + case 11: /* typecode ::= UNSIGNED */ +#line 101 "template_parser.lemon" +{yymsp[0].minor.yy32 = kUInt32; } +#line 961 "template_parser.c" + break; + case 12: /* typecode ::= opt_signed CHAR */ +#line 103 "template_parser.lemon" +{ yymsp[-1].minor.yy32 = kSInt8; } +#line 966 "template_parser.c" + break; + case 13: /* typecode ::= UNSIGNED CHAR */ +#line 104 "template_parser.lemon" +{ yymsp[-1].minor.yy32 = kUInt8; } +#line 971 "template_parser.c" + break; + case 14: /* typecode ::= opt_signed SHORT */ +#line 106 "template_parser.lemon" +{ yymsp[-1].minor.yy32 = kSInt16; } +#line 976 "template_parser.c" + break; + case 15: /* typecode ::= UNSIGNED SHORT */ +#line 107 "template_parser.lemon" +{ yymsp[-1].minor.yy32 = kUInt16; } +#line 981 "template_parser.c" + break; + case 16: /* typecode ::= opt_signed LONG opt_int */ +#line 109 "template_parser.lemon" +{ yymsp[-2].minor.yy32 = kSInt32; } +#line 986 "template_parser.c" + break; + case 17: /* typecode ::= UNSIGNED LONG opt_int */ +#line 110 "template_parser.lemon" +{ yymsp[-2].minor.yy32 = kUInt32; } +#line 991 "template_parser.c" + break; + case 18: /* typecode ::= opt_signed LONG LONG */ +#line 112 "template_parser.lemon" +{ yymsp[-2].minor.yy32 = kSInt64; } +#line 996 "template_parser.c" + break; + case 19: /* typecode ::= UNSIGNED LONG LONG */ +#line 113 "template_parser.lemon" +{ yymsp[-2].minor.yy32 = kUInt64; } +#line 1001 "template_parser.c" + break; + case 20: /* typecode ::= TYPECODE */ +#line 115 "template_parser.lemon" +{ yylhsminor.yy32 = (int)(ptrdiff_t)yymsp[0].minor.yy0; } +#line 1006 "template_parser.c" + yymsp[0].minor.yy32 = yylhsminor.yy32; + break; + case 21: /* typecode ::= VOID STAR */ +#line 118 "template_parser.lemon" +{ yymsp[-1].minor.yy32 = kVoidPtr; } +#line 1012 "template_parser.c" + break; + case 23: /* opt_star ::= STAR */ +#line 128 "template_parser.lemon" +{ yymsp[0].minor.yy32 = 1; } +#line 1017 "template_parser.c" + break; + default: + /* (24) start ::= templates */ yytestcase(yyruleno==24); + /* (25) templates ::= templates struct */ yytestcase(yyruleno==25); + /* (26) templates ::= templates typedef */ yytestcase(yyruleno==26); + /* (27) templates ::= */ yytestcase(yyruleno==27); + /* (28) opt_volatile ::= */ yytestcase(yyruleno==28); + /* (29) opt_volatile ::= VOLATILE */ yytestcase(yyruleno==29); + /* (30) opt_signed ::= */ yytestcase(yyruleno==30); + /* (31) opt_signed ::= SIGNED */ yytestcase(yyruleno==31); + /* (32) opt_int ::= */ yytestcase(yyruleno==32); + /* (33) opt_int ::= INT */ yytestcase(yyruleno==33); + break; +/********** End reduce actions ************************************************/ + }; + assert( yyrulenoYY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) ); + + /* It is not possible for a REDUCE to be followed by an error */ + assert( yyact!=YY_ERROR_ACTION ); + + if( yyact==YY_ACCEPT_ACTION ){ + yypParser->yytos += yysize; + yy_accept(yypParser); + }else{ + yymsp += yysize+1; + yypParser->yytos = yymsp; + yymsp->stateno = (YYACTIONTYPE)yyact; + yymsp->major = (YYCODETYPE)yygoto; + yyTraceShift(yypParser, yyact); + } +} + +/* +** The following code executes when the parse fails +*/ +#ifndef YYNOERRORRECOVERY +static void yy_parse_failed( + yyParser *yypParser /* The parser */ +){ + TemplateParseARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); + } +#endif + while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser fails */ +/************ Begin %parse_failure code ***************************************/ +/************ End %parse_failure code *****************************************/ + TemplateParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} +#endif /* YYNOERRORRECOVERY */ + +/* +** The following code executes when a syntax error first occurs. +*/ +static void yy_syntax_error( + yyParser *yypParser, /* The parser */ + int yymajor, /* The major type of the error token */ + TemplateParseTOKENTYPE yyminor /* The minor type of the error token */ +){ + TemplateParseARG_FETCH; +#define TOKEN yyminor +/************ Begin %syntax_error code ****************************************/ +/************ End %syntax_error code ******************************************/ + TemplateParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following is executed when the parser accepts +*/ +static void yy_accept( + yyParser *yypParser /* The parser */ +){ + TemplateParseARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); + } +#endif +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + assert( yypParser->yytos==yypParser->yystack ); + /* Here code is inserted which will be executed whenever the + ** parser accepts */ +/*********** Begin %parse_accept code *****************************************/ +/*********** End %parse_accept code *******************************************/ + TemplateParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* The main parser program. +** The first argument is a pointer to a structure obtained from +** "TemplateParseAlloc" which describes the current state of the parser. +** The second argument is the major token number. The third is +** the minor token. The fourth optional argument is whatever the +** user wants (and specified in the grammar) and is available for +** use by the action routines. +** +** Inputs: +**
    +**
  • A pointer to the parser (an opaque structure.) +**
  • The major token number. +**
  • The minor token number. +**
  • An option argument of a grammar-specified type. +**
+** +** Outputs: +** None. +*/ +void TemplateParse( + void *yyp, /* The parser */ + int yymajor, /* The major token code number */ + TemplateParseTOKENTYPE yyminor /* The value for the token */ + TemplateParseARG_PDECL /* Optional %extra_argument parameter */ +){ + YYMINORTYPE yyminorunion; + unsigned int yyact; /* The parser action. */ +#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) + int yyendofinput; /* True if we are at the end of input */ +#endif +#ifdef YYERRORSYMBOL + int yyerrorhit = 0; /* True if yymajor has invoked an error */ +#endif + yyParser *yypParser; /* The parser */ + + yypParser = (yyParser*)yyp; + assert( yypParser->yytos!=0 ); +#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) + yyendofinput = (yymajor==0); +#endif + TemplateParseARG_STORE; + +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sInput '%s'\n",yyTracePrompt,yyTokenName[yymajor]); + } +#endif + + do{ + yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor); + if( yyact <= YY_MAX_SHIFTREDUCE ){ + yy_shift(yypParser,yyact,yymajor,yyminor); +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt--; +#endif + yymajor = YYNOCODE; + }else if( yyact <= YY_MAX_REDUCE ){ + yy_reduce(yypParser,yyact-YY_MIN_REDUCE); + }else{ + assert( yyact == YY_ERROR_ACTION ); + yyminorunion.yy0 = yyminor; +#ifdef YYERRORSYMBOL + int yymx; +#endif +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); + } +#endif +#ifdef YYERRORSYMBOL + /* A syntax error has occurred. + ** The response to an error depends upon whether or not the + ** grammar defines an error token "ERROR". + ** + ** This is what we do if the grammar does define ERROR: + ** + ** * Call the %syntax_error function. + ** + ** * Begin popping the stack until we enter a state where + ** it is legal to shift the error symbol, then shift + ** the error symbol. + ** + ** * Set the error count to three. + ** + ** * Begin accepting and shifting new tokens. No new error + ** processing will occur until three tokens have been + ** shifted successfully. + ** + */ + if( yypParser->yyerrcnt<0 ){ + yy_syntax_error(yypParser,yymajor,yyminor); + } + yymx = yypParser->yytos->major; + if( yymx==YYERRORSYMBOL || yyerrorhit ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sDiscard input token %s\n", + yyTracePrompt,yyTokenName[yymajor]); + } +#endif + yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion); + yymajor = YYNOCODE; + }else{ + while( yypParser->yytos >= yypParser->yystack + && yymx != YYERRORSYMBOL + && (yyact = yy_find_reduce_action( + yypParser->yytos->stateno, + YYERRORSYMBOL)) >= YY_MIN_REDUCE + ){ + yy_pop_parser_stack(yypParser); + } + if( yypParser->yytos < yypParser->yystack || yymajor==0 ){ + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + yy_parse_failed(yypParser); +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + yymajor = YYNOCODE; + }else if( yymx!=YYERRORSYMBOL ){ + yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor); + } + } + yypParser->yyerrcnt = 3; + yyerrorhit = 1; +#elif defined(YYNOERRORRECOVERY) + /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to + ** do any kind of error recovery. Instead, simply invoke the syntax + ** error routine and continue going as if nothing had happened. + ** + ** Applications can set this macro (for example inside %include) if + ** they intend to abandon the parse upon the first syntax error seen. + */ + yy_syntax_error(yypParser,yymajor, yyminor); + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + yymajor = YYNOCODE; + +#else /* YYERRORSYMBOL is not defined */ + /* This is what we do if the grammar does not define ERROR: + ** + ** * Report an error message, and throw away the input token. + ** + ** * If the input token is $, then fail the parse. + ** + ** As before, subsequent error messages are suppressed until + ** three input tokens have been successfully shifted. + */ + if( yypParser->yyerrcnt<=0 ){ + yy_syntax_error(yypParser,yymajor, yyminor); + } + yypParser->yyerrcnt = 3; + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + if( yyendofinput ){ + yy_parse_failed(yypParser); +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + } + yymajor = YYNOCODE; +#endif + } + }while( yymajor!=YYNOCODE && yypParser->yytos>yypParser->yystack ); +#ifndef NDEBUG + if( yyTraceFILE ){ + yyStackEntry *i; + char cDiv = '['; + fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt); + for(i=&yypParser->yystack[1]; i<=yypParser->yytos; i++){ + fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]); + cDiv = ' '; + } + if (cDiv == '[') fprintf(yyTraceFILE,"["); + fprintf(yyTraceFILE,"]\n"); + } +#endif + return; +} diff --git a/bin/template_parser.h b/bin/template_parser.h new file mode 100644 index 0000000..944c8a2 --- /dev/null +++ b/bin/template_parser.h @@ -0,0 +1,20 @@ +#define tkTYPEDEF 1 +#define tkIDENTIFIER 2 +#define tkSTRUCT 3 +#define tkLBRACE 4 +#define tkRBRACE 5 +#define tkSEMI 6 +#define tkTEMPLATE 7 +#define tkLBRACKET 8 +#define tkINTEGER 9 +#define tkRBRACKET 10 +#define tkVOLATILE 11 +#define tkSIGNED 12 +#define tkUNSIGNED 13 +#define tkCHAR 14 +#define tkSHORT 15 +#define tkLONG 16 +#define tkTYPECODE 17 +#define tkVOID 18 +#define tkSTAR 19 +#define tkINT 20