From 94e6899b1037c7551b68177e0c1a9af7f63d8d9e Mon Sep 17 00:00:00 2001 From: Bdale Garbee Date: Wed, 11 Jan 2012 11:16:57 -0700 Subject: [PATCH] oops, should actually include the new patch in the repo! --- debian/patches/regenerate_parser.c | 3852 ++++++++++++++++++++++++++++ 1 file changed, 3852 insertions(+) create mode 100644 debian/patches/regenerate_parser.c diff --git a/debian/patches/regenerate_parser.c b/debian/patches/regenerate_parser.c new file mode 100644 index 0000000..9aa5b05 --- /dev/null +++ b/debian/patches/regenerate_parser.c @@ -0,0 +1,3852 @@ +diff --git a/as31/parser.c b/as31/parser.c +index dd388a9..53a9c8f 100644 +--- a/as31/parser.c ++++ b/as31/parser.c +@@ -1,30 +1,37 @@ +-/* A Bison parser, made by GNU Bison 1.875d. */ ++/* A Bison parser, made by GNU Bison 2.5. */ + +-/* Skeleton parser for Yacc-like parsing with Bison, +- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. +- +- This program is free software; you can redistribute it and/or modify ++/* Bison implementation for Yacc-like parsers in C ++ ++ Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. ++ ++ This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by +- the Free Software Foundation; either version 2, or (at your option) +- any later version. +- ++ the Free Software Foundation, either version 3 of the License, or ++ (at your option) any later version. ++ + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. +- ++ + You should have received a copy of the GNU General Public License +- along with this program; if not, write to the Free Software +- Foundation, Inc., 59 Temple Place - Suite 330, +- Boston, MA 02111-1307, USA. */ +- +-/* As a special exception, when this file is copied by Bison into a +- Bison output file, you may use that output file without restriction. +- This special exception was added by the Free Software Foundation +- in version 1.24 of Bison. */ +- +-/* Written by Richard Stallman by simplifying the original so called +- ``semantic'' parser. */ ++ along with this program. If not, see . */ ++ ++/* As a special exception, you may create a larger work that contains ++ part or all of the Bison parser skeleton and distribute that work ++ under terms of your choice, so long as that work isn't itself a ++ parser generator using the skeleton or a modified version thereof ++ as a parser skeleton. Alternatively, if you modify or redistribute ++ the parser skeleton itself, you may (at your option) remove this ++ special exception, which will cause the skeleton and the resulting ++ Bison output files to be licensed under the GNU General Public ++ License without this special exception. ++ ++ This special exception was added by the Free Software Foundation in ++ version 2.2 of Bison. */ ++ ++/* C LALR(1) parser skeleton written by Richard Stallman, by ++ simplifying the original so-called "semantic" parser. */ + + /* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local +@@ -36,17 +43,80 @@ + /* Identify Bison output. */ + #define YYBISON 1 + ++/* Bison version. */ ++#define YYBISON_VERSION "2.5" ++ + /* Skeleton name. */ + #define YYSKELETON_NAME "yacc.c" + + /* Pure parsers. */ + #define YYPURE 0 + ++/* Push parsers. */ ++#define YYPUSH 0 ++ ++/* Pull parsers. */ ++#define YYPULL 1 ++ + /* Using locations. */ + #define YYLSP_NEEDED 0 + + + ++/* Copy the first part of user declarations. */ ++ ++/* Line 268 of yacc.c */ ++#line 21 "parser.y" ++ ++ ++#include ++#include ++ ++#define NOPE ++#include "as31.h" ++#undef NOPE ++ ++#define YYSTYPE union ystack ++ ++static unsigned char bytebuf[1024]; /* used by dumplist() */ ++static int bytecount; ++ ++ ++void yyerror(const char *s); ++int makeop(struct opcode * op, struct mode *m, int add); ++void inclc(int i); ++char *padline(char *line); ++void dumplist(char *txt, int show); ++void genbyte(int b); ++void genstr(const char *s); ++void genword(unsigned long w); ++ ++/* ------------------------ G R A M M E R ----------------------------- */ ++ ++ ++ ++/* Line 268 of yacc.c */ ++#line 100 "y.tab.c" ++ ++/* Enabling traces. */ ++#ifndef YYDEBUG ++# define YYDEBUG 0 ++#endif ++ ++/* Enabling verbose error messages. */ ++#ifdef YYERROR_VERBOSE ++# undef YYERROR_VERBOSE ++# define YYERROR_VERBOSE 1 ++#else ++# define YYERROR_VERBOSE 0 ++#endif ++ ++/* Enabling the token table. */ ++#ifndef YYTOKEN_TABLE ++# define YYTOKEN_TABLE 0 ++#endif ++ ++ + /* Tokens. */ + #ifndef YYTOKENTYPE + # define YYTOKENTYPE +@@ -123,6 +193,7 @@ + SYMBOL = 325 + }; + #endif ++/* Tokens. */ + #define STRING 258 + #define D_ORG 259 + #define D_BYTE 260 +@@ -195,113 +266,184 @@ + + + +-/* Copy the first part of user declarations. */ +-#line 21 "parser.y" +- +- +-#include +-#include +- +-#define NOPE +-#include "as31.h" +-#undef NOPE +- +-#define YYSTYPE union ystack +- +-static unsigned char bytebuf[1024]; /* used by dumplist() */ +-static int bytecount; ++#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED ++typedef int YYSTYPE; ++# define YYSTYPE_IS_TRIVIAL 1 ++# define yystype YYSTYPE /* obsolescent; will be withdrawn */ ++# define YYSTYPE_IS_DECLARED 1 ++#endif + + +-void yyerror(const char *s); +-int makeop(struct opcode * op, struct mode *m, int add); +-void inclc(int i); +-char *padline(char *line); +-void dumplist(char *txt, int show); +-void genbyte(int b); +-void genstr(const char *s); +-void genword(unsigned long w); ++/* Copy the second part of user declarations. */ + +-/* ------------------------ G R A M M E R ----------------------------- */ + ++/* Line 343 of yacc.c */ ++#line 282 "y.tab.c" + ++#ifdef short ++# undef short ++#endif + +-/* Enabling traces. */ +-#ifndef YYDEBUG +-# define YYDEBUG 0 ++#ifdef YYTYPE_UINT8 ++typedef YYTYPE_UINT8 yytype_uint8; ++#else ++typedef unsigned char yytype_uint8; + #endif + +-/* Enabling verbose error messages. */ +-#ifdef YYERROR_VERBOSE +-# undef YYERROR_VERBOSE +-# define YYERROR_VERBOSE 1 ++#ifdef YYTYPE_INT8 ++typedef YYTYPE_INT8 yytype_int8; ++#elif (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++typedef signed char yytype_int8; + #else +-# define YYERROR_VERBOSE 0 ++typedef short int yytype_int8; + #endif + +-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +-typedef int YYSTYPE; +-# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +-# define YYSTYPE_IS_DECLARED 1 +-# define YYSTYPE_IS_TRIVIAL 1 ++#ifdef YYTYPE_UINT16 ++typedef YYTYPE_UINT16 yytype_uint16; ++#else ++typedef unsigned short int yytype_uint16; + #endif + ++#ifdef YYTYPE_INT16 ++typedef YYTYPE_INT16 yytype_int16; ++#else ++typedef short int yytype_int16; ++#endif + ++#ifndef YYSIZE_T ++# ifdef __SIZE_TYPE__ ++# define YYSIZE_T __SIZE_TYPE__ ++# elif defined size_t ++# define YYSIZE_T size_t ++# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++# include /* INFRINGES ON USER NAME SPACE */ ++# define YYSIZE_T size_t ++# else ++# define YYSIZE_T unsigned int ++# endif ++#endif + +-/* Copy the second part of user declarations. */ ++#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + ++#ifndef YY_ ++# if defined YYENABLE_NLS && YYENABLE_NLS ++# if ENABLE_NLS ++# include /* INFRINGES ON USER NAME SPACE */ ++# define YY_(msgid) dgettext ("bison-runtime", msgid) ++# endif ++# endif ++# ifndef YY_ ++# define YY_(msgid) msgid ++# endif ++#endif + +-/* Line 214 of yacc.c. */ +-#line 255 "y.tab.c" ++/* Suppress unused-variable warnings by "using" E. */ ++#if ! defined lint || defined __GNUC__ ++# define YYUSE(e) ((void) (e)) ++#else ++# define YYUSE(e) /* empty */ ++#endif + +-#if ! defined (yyoverflow) || YYERROR_VERBOSE ++/* Identity function, used to suppress warnings about constant conditions. */ ++#ifndef lint ++# define YYID(n) (n) ++#else ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++static int ++YYID (int yyi) ++#else ++static int ++YYID (yyi) ++ int yyi; ++#endif ++{ ++ return yyi; ++} ++#endif + +-# ifndef YYFREE +-# define YYFREE free +-# endif +-# ifndef YYMALLOC +-# define YYMALLOC malloc +-# endif ++#if ! defined yyoverflow || YYERROR_VERBOSE + + /* The parser invokes alloca or malloc; define the necessary symbols. */ + + # ifdef YYSTACK_USE_ALLOCA + # if YYSTACK_USE_ALLOCA +-# define YYSTACK_ALLOC alloca +-# endif +-# else +-# if defined (alloca) || defined (_ALLOCA_H) +-# define YYSTACK_ALLOC alloca +-# else + # ifdef __GNUC__ + # define YYSTACK_ALLOC __builtin_alloca ++# elif defined __BUILTIN_VA_ARG_INCR ++# include /* INFRINGES ON USER NAME SPACE */ ++# elif defined _AIX ++# define YYSTACK_ALLOC __alloca ++# elif defined _MSC_VER ++# include /* INFRINGES ON USER NAME SPACE */ ++# define alloca _alloca ++# else ++# define YYSTACK_ALLOC alloca ++# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++# include /* INFRINGES ON USER NAME SPACE */ ++# ifndef EXIT_SUCCESS ++# define EXIT_SUCCESS 0 ++# endif ++# endif + # endif + # endif + # endif + + # ifdef YYSTACK_ALLOC +- /* Pacify GCC's `empty if-body' warning. */ +-# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +-# else +-# if defined (__STDC__) || defined (__cplusplus) +-# include /* INFRINGES ON USER NAME SPACE */ +-# define YYSIZE_T size_t ++ /* Pacify GCC's `empty if-body' warning. */ ++# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) ++# ifndef YYSTACK_ALLOC_MAXIMUM ++ /* The OS might guarantee only one guard page at the bottom of the stack, ++ and a page size can be as small as 4096 bytes. So we cannot safely ++ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number ++ to allow for a few compiler-allocated temporary stack slots. */ ++# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ + # endif ++# else + # define YYSTACK_ALLOC YYMALLOC + # define YYSTACK_FREE YYFREE ++# ifndef YYSTACK_ALLOC_MAXIMUM ++# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM ++# endif ++# if (defined __cplusplus && ! defined EXIT_SUCCESS \ ++ && ! ((defined YYMALLOC || defined malloc) \ ++ && (defined YYFREE || defined free))) ++# include /* INFRINGES ON USER NAME SPACE */ ++# ifndef EXIT_SUCCESS ++# define EXIT_SUCCESS 0 ++# endif ++# endif ++# ifndef YYMALLOC ++# define YYMALLOC malloc ++# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ ++# endif ++# endif ++# ifndef YYFREE ++# define YYFREE free ++# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++void free (void *); /* INFRINGES ON USER NAME SPACE */ ++# endif ++# endif + # endif +-#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ ++#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + + +-#if (! defined (yyoverflow) \ +- && (! defined (__cplusplus) \ +- || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) ++#if (! defined yyoverflow \ ++ && (! defined __cplusplus \ ++ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + + /* A type that is properly aligned for any stack member. */ + union yyalloc + { +- short int yyss; +- YYSTYPE yyvs; +- }; ++ yytype_int16 yyss_alloc; ++ YYSTYPE yyvs_alloc; ++}; + + /* The size of the maximum gap between one aligned stack and the next. */ + # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) +@@ -309,74 +451,72 @@ union yyalloc + /* The size of an array large to enough to hold all stacks, each with + N elements. */ + # define YYSTACK_BYTES(N) \ +- ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \ ++ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +-/* Copy COUNT objects from FROM to TO. The source and destination do +- not overlap. */ +-# ifndef YYCOPY +-# if defined (__GNUC__) && 1 < __GNUC__ +-# define YYCOPY(To, From, Count) \ +- __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +-# else +-# define YYCOPY(To, From, Count) \ +- do \ +- { \ +- register YYSIZE_T yyi; \ +- for (yyi = 0; yyi < (Count); yyi++) \ +- (To)[yyi] = (From)[yyi]; \ +- } \ +- while (0) +-# endif +-# endif ++# define YYCOPY_NEEDED 1 + + /* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +-# define YYSTACK_RELOCATE(Stack) \ ++# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ +- YYCOPY (&yyptr->Stack, Stack, yysize); \ +- Stack = &yyptr->Stack; \ ++ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ ++ Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ +- while (0) ++ while (YYID (0)) + + #endif + +-#if defined (__STDC__) || defined (__cplusplus) +- typedef signed char yysigned_char; +-#else +- typedef short int yysigned_char; +-#endif ++#if defined YYCOPY_NEEDED && YYCOPY_NEEDED ++/* Copy COUNT objects from FROM to TO. The source and destination do ++ not overlap. */ ++# ifndef YYCOPY ++# if defined __GNUC__ && 1 < __GNUC__ ++# define YYCOPY(To, From, Count) \ ++ __builtin_memcpy (To, From, (Count) * sizeof (*(From))) ++# else ++# define YYCOPY(To, From, Count) \ ++ do \ ++ { \ ++ YYSIZE_T yyi; \ ++ for (yyi = 0; yyi < (Count); yyi++) \ ++ (To)[yyi] = (From)[yyi]; \ ++ } \ ++ while (YYID (0)) ++# endif ++# endif ++#endif /* !YYCOPY_NEEDED */ + +-/* YYFINAL -- State number of the termination state. */ ++/* YYFINAL -- State number of the termination state. */ + #define YYFINAL 155 + /* YYLAST -- Last index in YYTABLE. */ + #define YYLAST 599 + +-/* YYNTOKENS -- Number of terminals. */ ++/* YYNTOKENS -- Number of terminals. */ + #define YYNTOKENS 89 +-/* YYNNTS -- Number of nonterminals. */ ++/* YYNNTS -- Number of nonterminals. */ + #define YYNNTS 35 +-/* YYNRULES -- Number of rules. */ ++/* YYNRULES -- Number of rules. */ + #define YYNRULES 165 +-/* YYNRULES -- Number of states. */ ++/* YYNRULES -- Number of states. */ + #define YYNSTATES 316 + + /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ + #define YYUNDEFTOK 2 + #define YYMAXUTOK 325 + +-#define YYTRANSLATE(YYX) \ ++#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + + /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +-static const unsigned char yytranslate[] = ++static const yytype_uint8 yytranslate[] = + { + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 81, 2, 2, 2, 2, 2, 2, 2, 2, 2, +@@ -416,7 +556,7 @@ static const unsigned char yytranslate[] = + #if YYDEBUG + /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +-static const unsigned short int yyprhs[] = ++static const yytype_uint16 yyprhs[] = + { + 0, 0, 3, 5, 8, 10, 14, 16, 19, 22, + 24, 25, 29, 33, 37, 41, 45, 51, 57, 60, +@@ -437,8 +577,8 @@ static const unsigned short int yyprhs[] = + 551, 553, 555, 557, 559, 561 + }; + +-/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +-static const yysigned_char yyrhs[] = ++/* YYRHS -- A `-1'-separated list of the rules' RHS. */ ++static const yytype_int8 yyrhs[] = + { + 90, 0, -1, 91, -1, 91, 92, -1, 92, -1, + 99, 80, 93, -1, 93, -1, 95, 81, -1, 103, +@@ -500,7 +640,7 @@ static const yysigned_char yyrhs[] = + }; + + /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +-static const unsigned short int yyrline[] = ++static const yytype_uint16 yyrline[] = + { + 0, 126, 126, 131, 132, 135, 145, 148, 153, 159, + 164, 164, 183, 190, 191, 192, 195, 204, 210, 213, +@@ -522,9 +662,9 @@ static const unsigned short int yyrline[] = + }; + #endif + +-#if YYDEBUG || YYERROR_VERBOSE +-/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. +- First, the terminals, then, starting at YYNTOKENS, nonterminals. */ ++#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE ++/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. ++ First, the terminals, then, starting at YYNTOKENS, nonterminals. */ + static const char *const yytname[] = + { + "$end", "error", "$undefined", "STRING", "D_ORG", "D_BYTE", "D_WORD", +@@ -537,7 +677,7 @@ static const char *const yytname[] = + "R5", "R6", "R7", "VALUE", "SYMBOL", "'+'", "'-'", "'*'", "'/'", "'%'", + "'|'", "'&'", "'>'", "'<'", "':'", "'\\n'", "'.'", "','", "'('", "')'", + "'@'", "'#'", "'!'", "$accept", "program", "linelist", "line", +- "linerest", "@1", "directive", "defexpr", "flag", "flagv", "undefsym", ++ "linerest", "$@1", "directive", "defexpr", "flag", "flagv", "undefsym", + "blist", "wlist", "expr", "instr", "two_op1", "two_op2", "two_op3", + "two_op4", "two_op5", "two_op6", "single_op1", "single_op2", "three_op1", + "rel", "rel2", "bit", "bitv", "reg", "regi", "data8", "data16", "addr11", +@@ -548,7 +688,7 @@ static const char *const yytname[] = + # ifdef YYPRINT + /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +-static const unsigned short int yytoknum[] = ++static const yytype_uint16 yytoknum[] = + { + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, +@@ -563,7 +703,7 @@ static const unsigned short int yytoknum[] = + # endif + + /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +-static const unsigned char yyr1[] = ++static const yytype_uint8 yyr1[] = + { + 0, 89, 90, 91, 91, 92, 92, 93, 93, 93, + 94, 93, 95, 95, 95, 95, 95, 95, 95, 96, +@@ -585,7 +725,7 @@ static const unsigned char yyr1[] = + }; + + /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +-static const unsigned char yyr2[] = ++static const yytype_uint8 yyr2[] = + { + 0, 2, 1, 2, 1, 3, 1, 2, 2, 1, + 0, 3, 3, 3, 3, 3, 5, 5, 2, 1, +@@ -606,10 +746,10 @@ static const unsigned char yyr2[] = + 1, 1, 1, 1, 1, 1 + }; + +-/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state +- STATE-NUM when YYTABLE doesn't specify something else to do. Zero ++/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. ++ Performed when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +-static const unsigned char yydefact[] = ++static const yytype_uint8 yydefact[] = + { + 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +@@ -645,8 +785,8 @@ static const unsigned char yydefact[] = + 137, 97, 95, 98, 96, 138 + }; + +-/* YYDEFGOTO[NTERM-NUM]. */ +-static const short int yydefgoto[] = ++/* YYDEFGOTO[NTERM-NUM]. */ ++static const yytype_int16 yydefgoto[] = + { + -1, 49, 50, 51, 52, 56, 53, 203, 297, 298, + 54, 206, 208, 69, 55, 65, 71, 72, 106, 101, +@@ -657,7 +797,7 @@ static const short int yydefgoto[] = + /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ + #define YYPACT_NINF -239 +-static const short int yypact[] = ++static const yytype_int16 yypact[] = + { + 370, -239, 139, -24, -24, 139, 120, 70, 15, 15, + -19, 470, -12, 292, 441, 23, 23, 139, -45, 23, +@@ -694,7 +834,7 @@ static const short int yypact[] = + }; + + /* YYPGOTO[NTERM-NUM]. */ +-static const short int yypgoto[] = ++static const yytype_int16 yypgoto[] = + { + -239, -239, -239, 214, 107, -239, -239, 116, -239, -239, + 114, -239, -239, -2, -239, 21, 33, 238, 26, -239, +@@ -704,10 +844,9 @@ static const short int yypgoto[] = + + /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which +- number is the opposite. If zero, do what YYDEFACT says. +- If YYTABLE_NINF, syntax error. */ ++ number is the opposite. If YYTABLE_NINF, syntax error. */ + #define YYTABLE_NINF -3 +-static const short int yytable[] = ++static const yytype_int16 yytable[] = + { + 62, 107, 107, 62, 242, 107, 85, 205, 277, 232, + 197, 187, 102, 291, 99, 109, 103, 99, 109, 109, +@@ -771,7 +910,13 @@ static const short int yytable[] = + 169, 170, 171, 165, 166, 167, 168, 169, 170, 171 + }; + +-static const short int yycheck[] = ++#define yypact_value_is_default(yystate) \ ++ ((yystate) == (-239)) ++ ++#define yytable_value_is_error(yytable_value) \ ++ YYID (0) ++ ++static const yytype_int16 yycheck[] = + { + 2, 15, 16, 5, 190, 19, 7, 3, 246, 56, + 60, 96, 13, 3, 11, 17, 13, 14, 20, 21, +@@ -837,7 +982,7 @@ static const short int yycheck[] = + + /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +-static const unsigned char yystos[] = ++static const yytype_uint8 yystos[] = + { + 0, 1, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, +@@ -873,22 +1018,6 @@ static const unsigned char yystos[] = + 113, 58, 59, 56, 56, 113 + }; + +-#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +-# define YYSIZE_T __SIZE_TYPE__ +-#endif +-#if ! defined (YYSIZE_T) && defined (size_t) +-# define YYSIZE_T size_t +-#endif +-#if ! defined (YYSIZE_T) +-# if defined (__STDC__) || defined (__cplusplus) +-# include /* INFRINGES ON USER NAME SPACE */ +-# define YYSIZE_T size_t +-# endif +-#endif +-#if ! defined (YYSIZE_T) +-# define YYSIZE_T unsigned int +-#endif +- + #define yyerrok (yyerrstatus = 0) + #define yyclearin (yychar = YYEMPTY) + #define YYEMPTY (-2) +@@ -901,9 +1030,18 @@ static const unsigned char yystos[] = + + /* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. +- Once GCC version 2 has supplanted version 1, this can go. */ ++ Once GCC version 2 has supplanted version 1, this can go. However, ++ YYFAIL appears to be in use. Nevertheless, it is formally deprecated ++ in Bison 2.4.2's NEWS entry, where a plan to phase it out is ++ discussed. */ + + #define YYFAIL goto yyerrlab ++#if defined YYFAIL ++ /* This is here to suppress warnings from the GCC cpp's ++ -Wunused-macros. Normally we don't worry about that warning, but ++ some users do, and we want to make it easy for users to remove ++ YYFAIL uses, which will produce warnings from Bison 2.5. */ ++#endif + + #define YYRECOVERING() (!!yyerrstatus) + +@@ -913,31 +1051,54 @@ do \ + { \ + yychar = (Token); \ + yylval = (Value); \ +- yytoken = YYTRANSLATE (yychar); \ +- YYPOPSTACK; \ ++ YYPOPSTACK (1); \ + goto yybackup; \ + } \ + else \ +- { \ +- yyerror ("syntax error: cannot back up");\ ++ { \ ++ yyerror (YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +-while (0) ++while (YYID (0)) ++ + + #define YYTERROR 1 + #define YYERRCODE 256 + +-/* YYLLOC_DEFAULT -- Compute the default location (before the actions +- are run). */ + ++/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. ++ If N is 0, then set CURRENT to the empty location which ends ++ the previous symbol: RHS[0] (always defined). */ ++ ++#define YYRHSLOC(Rhs, K) ((Rhs)[K]) + #ifndef YYLLOC_DEFAULT +-# define YYLLOC_DEFAULT(Current, Rhs, N) \ +- ((Current).first_line = (Rhs)[1].first_line, \ +- (Current).first_column = (Rhs)[1].first_column, \ +- (Current).last_line = (Rhs)[N].last_line, \ +- (Current).last_column = (Rhs)[N].last_column) ++# define YYLLOC_DEFAULT(Current, Rhs, N) \ ++ do \ ++ if (YYID (N)) \ ++ { \ ++ (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ ++ (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ ++ (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ ++ (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ ++ } \ ++ else \ ++ { \ ++ (Current).first_line = (Current).last_line = \ ++ YYRHSLOC (Rhs, 0).last_line; \ ++ (Current).first_column = (Current).last_column = \ ++ YYRHSLOC (Rhs, 0).last_column; \ ++ } \ ++ while (YYID (0)) ++#endif ++ ++ ++/* This macro is provided for backward compatibility. */ ++ ++#ifndef YY_LOCATION_PRINT ++# define YY_LOCATION_PRINT(File, Loc) ((void) 0) + #endif + ++ + /* YYLEX -- calling `yylex' with the right arguments. */ + + #ifdef YYLEX_PARAM +@@ -958,43 +1119,100 @@ while (0) + do { \ + if (yydebug) \ + YYFPRINTF Args; \ +-} while (0) ++} while (YYID (0)) + +-# define YYDSYMPRINT(Args) \ +-do { \ +- if (yydebug) \ +- yysymprint Args; \ +-} while (0) ++# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ ++do { \ ++ if (yydebug) \ ++ { \ ++ YYFPRINTF (stderr, "%s ", Title); \ ++ yy_symbol_print (stderr, \ ++ Type, Value); \ ++ YYFPRINTF (stderr, "\n"); \ ++ } \ ++} while (YYID (0)) + +-# define YYDSYMPRINTF(Title, Token, Value, Location) \ +-do { \ +- if (yydebug) \ +- { \ +- YYFPRINTF (stderr, "%s ", Title); \ +- yysymprint (stderr, \ +- Token, Value); \ +- YYFPRINTF (stderr, "\n"); \ +- } \ +-} while (0) ++ ++/*--------------------------------. ++| Print this symbol on YYOUTPUT. | ++`--------------------------------*/ ++ ++/*ARGSUSED*/ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++static void ++yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) ++#else ++static void ++yy_symbol_value_print (yyoutput, yytype, yyvaluep) ++ FILE *yyoutput; ++ int yytype; ++ YYSTYPE const * const yyvaluep; ++#endif ++{ ++ if (!yyvaluep) ++ return; ++# ifdef YYPRINT ++ if (yytype < YYNTOKENS) ++ YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); ++# else ++ YYUSE (yyoutput); ++# endif ++ switch (yytype) ++ { ++ default: ++ break; ++ } ++} ++ ++ ++/*--------------------------------. ++| Print this symbol on YYOUTPUT. | ++`--------------------------------*/ ++ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++static void ++yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) ++#else ++static void ++yy_symbol_print (yyoutput, yytype, yyvaluep) ++ FILE *yyoutput; ++ int yytype; ++ YYSTYPE const * const yyvaluep; ++#endif ++{ ++ if (yytype < YYNTOKENS) ++ YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); ++ else ++ YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); ++ ++ yy_symbol_value_print (yyoutput, yytype, yyvaluep); ++ YYFPRINTF (yyoutput, ")"); ++} + + /*------------------------------------------------------------------. + | yy_stack_print -- Print the state stack from its BOTTOM up to its | + | TOP (included). | + `------------------------------------------------------------------*/ + +-#if defined (__STDC__) || defined (__cplusplus) ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) + static void +-yy_stack_print (short int *bottom, short int *top) ++yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) + #else + static void +-yy_stack_print (bottom, top) +- short int *bottom; +- short int *top; ++yy_stack_print (yybottom, yytop) ++ yytype_int16 *yybottom; ++ yytype_int16 *yytop; + #endif + { + YYFPRINTF (stderr, "Stack now"); +- for (/* Nothing. */; bottom <= top; ++bottom) +- YYFPRINTF (stderr, " %d", *bottom); ++ for (; yybottom <= yytop; yybottom++) ++ { ++ int yybot = *yybottom; ++ YYFPRINTF (stderr, " %d", yybot); ++ } + YYFPRINTF (stderr, "\n"); + } + +@@ -1002,45 +1220,52 @@ yy_stack_print (bottom, top) + do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +-} while (0) ++} while (YYID (0)) + + + /*------------------------------------------------. + | Report that the YYRULE is going to be reduced. | + `------------------------------------------------*/ + +-#if defined (__STDC__) || defined (__cplusplus) ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) + static void +-yy_reduce_print (int yyrule) ++yy_reduce_print (YYSTYPE *yyvsp, int yyrule) + #else + static void +-yy_reduce_print (yyrule) ++yy_reduce_print (yyvsp, yyrule) ++ YYSTYPE *yyvsp; + int yyrule; + #endif + { ++ int yynrhs = yyr2[yyrule]; + int yyi; +- unsigned int yylno = yyrline[yyrule]; +- YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", +- yyrule - 1, yylno); +- /* Print the symbols being reduced, and their result. */ +- for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) +- YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); +- YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); ++ unsigned long int yylno = yyrline[yyrule]; ++ YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", ++ yyrule - 1, yylno); ++ /* The symbols being reduced. */ ++ for (yyi = 0; yyi < yynrhs; yyi++) ++ { ++ YYFPRINTF (stderr, " $%d = ", yyi + 1); ++ yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], ++ &(yyvsp[(yyi + 1) - (yynrhs)]) ++ ); ++ YYFPRINTF (stderr, "\n"); ++ } + } + + # define YY_REDUCE_PRINT(Rule) \ + do { \ + if (yydebug) \ +- yy_reduce_print (Rule); \ +-} while (0) ++ yy_reduce_print (yyvsp, Rule); \ ++} while (YYID (0)) + + /* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ + int yydebug; + #else /* !YYDEBUG */ + # define YYDPRINTF(Args) +-# define YYDSYMPRINT(Args) +-# define YYDSYMPRINTF(Title, Token, Value, Location) ++# define YY_SYMBOL_PRINT(Title, Type, Value, Location) + # define YY_STACK_PRINT(Bottom, Top) + # define YY_REDUCE_PRINT(Rule) + #endif /* !YYDEBUG */ +@@ -1055,61 +1280,58 @@ int yydebug; + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if +- SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) ++ YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +-#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 +-# undef YYMAXDEPTH +-#endif +- + #ifndef YYMAXDEPTH + # define YYMAXDEPTH 10000 + #endif + +- + + #if YYERROR_VERBOSE + + # ifndef yystrlen +-# if defined (__GLIBC__) && defined (_STRING_H) ++# if defined __GLIBC__ && defined _STRING_H + # define yystrlen strlen + # else + /* Return the length of YYSTR. */ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) + static YYSIZE_T +-# if defined (__STDC__) || defined (__cplusplus) + yystrlen (const char *yystr) +-# else ++#else ++static YYSIZE_T + yystrlen (yystr) +- const char *yystr; +-# endif ++ const char *yystr; ++#endif + { +- register const char *yys = yystr; +- +- while (*yys++ != '\0') ++ YYSIZE_T yylen; ++ for (yylen = 0; yystr[yylen]; yylen++) + continue; +- +- return yys - yystr - 1; ++ return yylen; + } + # endif + # endif + + # ifndef yystpcpy +-# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) ++# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE + # define yystpcpy stpcpy + # else + /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) + static char * +-# if defined (__STDC__) || defined (__cplusplus) + yystpcpy (char *yydest, const char *yysrc) +-# else ++#else ++static char * + yystpcpy (yydest, yysrc) +- char *yydest; +- const char *yysrc; +-# endif ++ char *yydest; ++ const char *yysrc; ++#endif + { +- register char *yyd = yydest; +- register const char *yys = yysrc; ++ char *yyd = yydest; ++ const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; +@@ -1119,84 +1341,232 @@ yystpcpy (yydest, yysrc) + # endif + # endif + +-#endif /* !YYERROR_VERBOSE */ ++# ifndef yytnamerr ++/* Copy to YYRES the contents of YYSTR after stripping away unnecessary ++ quotes and backslashes, so that it's suitable for yyerror. The ++ heuristic is that double-quoting is unnecessary unless the string ++ contains an apostrophe, a comma, or backslash (other than ++ backslash-backslash). YYSTR is taken from yytname. If YYRES is ++ null, do not copy; instead, return the length of what the result ++ would have been. */ ++static YYSIZE_T ++yytnamerr (char *yyres, const char *yystr) ++{ ++ if (*yystr == '"') ++ { ++ YYSIZE_T yyn = 0; ++ char const *yyp = yystr; ++ ++ for (;;) ++ switch (*++yyp) ++ { ++ case '\'': ++ case ',': ++ goto do_not_strip_quotes; ++ ++ case '\\': ++ if (*++yyp != '\\') ++ goto do_not_strip_quotes; ++ /* Fall through. */ ++ default: ++ if (yyres) ++ yyres[yyn] = *yyp; ++ yyn++; ++ break; ++ ++ case '"': ++ if (yyres) ++ yyres[yyn] = '\0'; ++ return yyn; ++ } ++ do_not_strip_quotes: ; ++ } + +- ++ if (! yyres) ++ return yystrlen (yystr); + +-#if YYDEBUG +-/*--------------------------------. +-| Print this symbol on YYOUTPUT. | +-`--------------------------------*/ ++ return yystpcpy (yyres, yystr) - yyres; ++} ++# endif + +-#if defined (__STDC__) || defined (__cplusplus) +-static void +-yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) +-#else +-static void +-yysymprint (yyoutput, yytype, yyvaluep) +- FILE *yyoutput; +- int yytype; +- YYSTYPE *yyvaluep; +-#endif ++/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message ++ about the unexpected token YYTOKEN for the state stack whose top is ++ YYSSP. ++ ++ Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is ++ not large enough to hold the message. In that case, also set ++ *YYMSG_ALLOC to the required number of bytes. Return 2 if the ++ required number of bytes is too large to store. */ ++static int ++yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, ++ yytype_int16 *yyssp, int yytoken) + { +- /* Pacify ``unused variable'' warnings. */ +- (void) yyvaluep; ++ YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); ++ YYSIZE_T yysize = yysize0; ++ YYSIZE_T yysize1; ++ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; ++ /* Internationalized format string. */ ++ const char *yyformat = 0; ++ /* Arguments of yyformat. */ ++ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; ++ /* Number of reported tokens (one for the "unexpected", one per ++ "expected"). */ ++ int yycount = 0; ++ ++ /* There are many possibilities here to consider: ++ - Assume YYFAIL is not used. It's too flawed to consider. See ++ ++ for details. YYERROR is fine as it does not invoke this ++ function. ++ - If this state is a consistent state with a default action, then ++ the only way this function was invoked is if the default action ++ is an error action. In that case, don't check for expected ++ tokens because there are none. ++ - The only way there can be no lookahead present (in yychar) is if ++ this state is a consistent state with a default action. Thus, ++ detecting the absence of a lookahead is sufficient to determine ++ that there is no unexpected or expected token to report. In that ++ case, just report a simple "syntax error". ++ - Don't assume there isn't a lookahead just because this state is a ++ consistent state with a default action. There might have been a ++ previous inconsistent state, consistent state with a non-default ++ action, or user semantic action that manipulated yychar. ++ - Of course, the expected token list depends on states to have ++ correct lookahead information, and it depends on the parser not ++ to perform extra reductions after fetching a lookahead from the ++ scanner and before detecting a syntax error. Thus, state merging ++ (from LALR or IELR) and default reductions corrupt the expected ++ token list. However, the list is correct for canonical LR with ++ one exception: it will still contain any token that will not be ++ accepted due to an error action in a later state. ++ */ ++ if (yytoken != YYEMPTY) ++ { ++ int yyn = yypact[*yyssp]; ++ yyarg[yycount++] = yytname[yytoken]; ++ if (!yypact_value_is_default (yyn)) ++ { ++ /* Start YYX at -YYN if negative to avoid negative indexes in ++ YYCHECK. In other words, skip the first -YYN actions for ++ this state because they are default actions. */ ++ int yyxbegin = yyn < 0 ? -yyn : 0; ++ /* Stay within bounds of both yycheck and yytname. */ ++ int yychecklim = YYLAST - yyn + 1; ++ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ++ int yyx; ++ ++ for (yyx = yyxbegin; yyx < yyxend; ++yyx) ++ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR ++ && !yytable_value_is_error (yytable[yyx + yyn])) ++ { ++ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ++ { ++ yycount = 1; ++ yysize = yysize0; ++ break; ++ } ++ yyarg[yycount++] = yytname[yyx]; ++ yysize1 = yysize + yytnamerr (0, yytname[yyx]); ++ if (! (yysize <= yysize1 ++ && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) ++ return 2; ++ yysize = yysize1; ++ } ++ } ++ } + +- if (yytype < YYNTOKENS) +- { +- YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); +-# ifdef YYPRINT +- YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +-# endif ++ switch (yycount) ++ { ++# define YYCASE_(N, S) \ ++ case N: \ ++ yyformat = S; \ ++ break ++ YYCASE_(0, YY_("syntax error")); ++ YYCASE_(1, YY_("syntax error, unexpected %s")); ++ YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ++ YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ++ YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ++ YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); ++# undef YYCASE_ + } +- else +- YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + +- switch (yytype) ++ yysize1 = yysize + yystrlen (yyformat); ++ if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) ++ return 2; ++ yysize = yysize1; ++ ++ if (*yymsg_alloc < yysize) + { +- default: +- break; ++ *yymsg_alloc = 2 * yysize; ++ if (! (yysize <= *yymsg_alloc ++ && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) ++ *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; ++ return 1; + } +- YYFPRINTF (yyoutput, ")"); ++ ++ /* Avoid sprintf, as that infringes on the user's name space. ++ Don't have undefined behavior even if the translation ++ produced a string with the wrong number of "%s"s. */ ++ { ++ char *yyp = *yymsg; ++ int yyi = 0; ++ while ((*yyp = *yyformat) != '\0') ++ if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ++ { ++ yyp += yytnamerr (yyp, yyarg[yyi++]); ++ yyformat += 2; ++ } ++ else ++ { ++ yyp++; ++ yyformat++; ++ } ++ } ++ return 0; + } ++#endif /* YYERROR_VERBOSE */ + +-#endif /* ! YYDEBUG */ + /*-----------------------------------------------. + | Release the memory associated to this symbol. | + `-----------------------------------------------*/ + +-#if defined (__STDC__) || defined (__cplusplus) ++/*ARGSUSED*/ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) + static void +-yydestruct (int yytype, YYSTYPE *yyvaluep) ++yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) + #else + static void +-yydestruct (yytype, yyvaluep) ++yydestruct (yymsg, yytype, yyvaluep) ++ const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; + #endif + { +- /* Pacify ``unused variable'' warnings. */ +- (void) yyvaluep; ++ YYUSE (yyvaluep); ++ ++ if (!yymsg) ++ yymsg = "Deleting"; ++ YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: +- break; ++ break; + } + } +- + +-/* Prevent warnings from -Wmissing-prototypes. */ + ++/* Prevent warnings from -Wmissing-prototypes. */ + #ifdef YYPARSE_PARAM +-# if defined (__STDC__) || defined (__cplusplus) ++#if defined __STDC__ || defined __cplusplus + int yyparse (void *YYPARSE_PARAM); +-# else ++#else + int yyparse (); +-# endif ++#endif + #else /* ! YYPARSE_PARAM */ +-#if defined (__STDC__) || defined (__cplusplus) ++#if defined __STDC__ || defined __cplusplus + int yyparse (void); + #else + int yyparse (); +@@ -1204,7 +1574,6 @@ int yyparse (); + #endif /* ! YYPARSE_PARAM */ + + +- + /* The lookahead symbol. */ + int yychar; + +@@ -1215,20 +1584,23 @@ YYSTYPE yylval; + int yynerrs; + + +- + /*----------. + | yyparse. | + `----------*/ + + #ifdef YYPARSE_PARAM +-# if defined (__STDC__) || defined (__cplusplus) +-int yyparse (void *YYPARSE_PARAM) +-# else +-int yyparse (YYPARSE_PARAM) +- void *YYPARSE_PARAM; +-# endif ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++int ++yyparse (void *YYPARSE_PARAM) ++#else ++int ++yyparse (YYPARSE_PARAM) ++ void *YYPARSE_PARAM; ++#endif + #else /* ! YYPARSE_PARAM */ +-#if defined (__STDC__) || defined (__cplusplus) ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) + int + yyparse (void) + #else +@@ -1238,64 +1610,69 @@ yyparse () + #endif + #endif + { +- +- register int yystate; +- register int yyn; +- int yyresult; +- /* Number of tokens to shift before error messages enabled. */ +- int yyerrstatus; +- /* Lookahead token as an internal (translated) token number. */ +- int yytoken = 0; ++ int yystate; ++ /* Number of tokens to shift before error messages enabled. */ ++ int yyerrstatus; + +- /* Three stacks and their tools: +- `yyss': related to states, +- `yyvs': related to semantic values, +- `yyls': related to locations. ++ /* The stacks and their tools: ++ `yyss': related to states. ++ `yyvs': related to semantic values. + +- Refer to the stacks thru separate pointers, to allow yyoverflow +- to reallocate them elsewhere. */ ++ Refer to the stacks thru separate pointers, to allow yyoverflow ++ to reallocate them elsewhere. */ + +- /* The state stack. */ +- short int yyssa[YYINITDEPTH]; +- short int *yyss = yyssa; +- register short int *yyssp; ++ /* The state stack. */ ++ yytype_int16 yyssa[YYINITDEPTH]; ++ yytype_int16 *yyss; ++ yytype_int16 *yyssp; + +- /* The semantic value stack. */ +- YYSTYPE yyvsa[YYINITDEPTH]; +- YYSTYPE *yyvs = yyvsa; +- register YYSTYPE *yyvsp; ++ /* The semantic value stack. */ ++ YYSTYPE yyvsa[YYINITDEPTH]; ++ YYSTYPE *yyvs; ++ YYSTYPE *yyvsp; + ++ YYSIZE_T yystacksize; + +- +-#define YYPOPSTACK (yyvsp--, yyssp--) +- +- YYSIZE_T yystacksize = YYINITDEPTH; +- ++ int yyn; ++ int yyresult; ++ /* Lookahead token as an internal (translated) token number. */ ++ int yytoken; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + ++#if YYERROR_VERBOSE ++ /* Buffer for error messages, and its allocated size. */ ++ char yymsgbuf[128]; ++ char *yymsg = yymsgbuf; ++ YYSIZE_T yymsg_alloc = sizeof yymsgbuf; ++#endif ++ ++#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + +- /* When reducing, the number of symbols on the RHS of the reduced +- rule. */ +- int yylen; ++ /* The number of symbols on the RHS of the reduced rule. ++ Keep to zero when no symbol should be popped. */ ++ int yylen = 0; ++ ++ yytoken = 0; ++ yyss = yyssa; ++ yyvs = yyvsa; ++ yystacksize = YYINITDEPTH; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; +- yychar = YYEMPTY; /* Cause a token to be read. */ ++ yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ +- + yyssp = yyss; + yyvsp = yyvs; + +- + goto yysetstate; + + /*------------------------------------------------------------. +@@ -1303,8 +1680,7 @@ yyparse () + `------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks +- have just been pushed. so pushing a state here evens the stacks. +- */ ++ have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: +@@ -1317,21 +1693,19 @@ yyparse () + + #ifdef yyoverflow + { +- /* Give user a chance to reallocate the stack. Use copies of ++ /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; +- short int *yyss1 = yyss; +- ++ yytype_int16 *yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ +- yyoverflow ("parser stack overflow", ++ yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), +- + &yystacksize); + + yyss = yyss1; +@@ -1339,24 +1713,23 @@ yyparse () + } + #else /* no yyoverflow */ + # ifndef YYSTACK_RELOCATE +- goto yyoverflowlab; ++ goto yyexhaustedlab; + # else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) +- goto yyoverflowlab; ++ goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { +- short int *yyss1 = yyss; ++ yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) +- goto yyoverflowlab; +- YYSTACK_RELOCATE (yyss); +- YYSTACK_RELOCATE (yyvs); +- ++ goto yyexhaustedlab; ++ YYSTACK_RELOCATE (yyss_alloc, yyss); ++ YYSTACK_RELOCATE (yyvs_alloc, yyvs); + # undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); +@@ -1367,7 +1740,6 @@ yyparse () + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + +- + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + +@@ -1377,6 +1749,9 @@ yyparse () + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + ++ if (yystate == YYFINAL) ++ YYACCEPT; ++ + goto yybackup; + + /*-----------. +@@ -1384,14 +1759,12 @@ yyparse () + `-----------*/ + yybackup: + +-/* Do appropriate processing given the current state. */ +-/* Read a lookahead token if we need one and don't already have one. */ +-/* yyresume: */ ++ /* Do appropriate processing given the current state. Read a ++ lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ +- + yyn = yypact[yystate]; +- if (yyn == YYPACT_NINF) ++ if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ +@@ -1411,7 +1784,7 @@ yybackup: + else + { + yytoken = YYTRANSLATE (yychar); +- YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); ++ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to +@@ -1422,31 +1795,26 @@ yybackup: + yyn = yytable[yyn]; + if (yyn <= 0) + { +- if (yyn == 0 || yyn == YYTABLE_NINF) +- goto yyerrlab; ++ if (yytable_value_is_error (yyn)) ++ goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + +- if (yyn == YYFINAL) +- YYACCEPT; +- +- /* Shift the lookahead token. */ +- YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); +- +- /* Discard the token being shifted unless it is eof. */ +- if (yychar != YYEOF) +- yychar = YYEMPTY; +- +- *++yyvsp = yylval; +- +- + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + ++ /* Shift the lookahead token. */ ++ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); ++ ++ /* Discard the shifted token. */ ++ yychar = YYEMPTY; ++ + yystate = yyn; ++ *++yyvsp = yylval; ++ + goto yynewstate; + + +@@ -1482,58 +1850,72 @@ yyreduce: + switch (yyn) + { + case 2: ++ ++/* Line 1806 of yacc.c */ + #line 127 "parser.y" + { + } + break; + + case 5: ++ ++/* Line 1806 of yacc.c */ + #line 136 "parser.y" + { + if (abort_asap) {YYABORT;} + if( pass1 ) { +- yyvsp[-2].sym->type = LABEL; +- yyvsp[-2].sym->value = lc; ++ (yyvsp[(1) - (3)]).sym->type = LABEL; ++ (yyvsp[(1) - (3)]).sym->value = lc; + } +- inclc(yyvsp[0].value); ++ inclc((yyvsp[(3) - (3)]).value); + bytecount = 0; + } + break; + + case 6: ++ ++/* Line 1806 of yacc.c */ + #line 145 "parser.y" +- { inclc(yyvsp[0].value); bytecount = 0; } ++ { inclc((yyvsp[(1) - (1)]).value); bytecount = 0; } + break; + + case 7: ++ ++/* Line 1806 of yacc.c */ + #line 148 "parser.y" + { +- yyval.value = yyvsp[-1].value; ++ (yyval).value = (yyvsp[(1) - (2)]).value; + if( dashl && pass2 ) +- dumplist(yyvsp[0].str,1); ++ dumplist((yyvsp[(2) - (2)]).str,1); + } + break; + + case 8: ++ ++/* Line 1806 of yacc.c */ + #line 153 "parser.y" + { +- yyval.value = yyvsp[-1].value; ++ (yyval).value = (yyvsp[(1) - (2)]).value; + if( dashl && pass2 ) +- dumplist(yyvsp[0].str,1); ++ dumplist((yyvsp[(2) - (2)]).str,1); + + } + break; + + case 9: ++ ++/* Line 1806 of yacc.c */ + #line 159 "parser.y" + { +- yyval.value = 0; ++ (yyval).value = 0; + if( dashl && pass2 ) +- dumplist(yyvsp[0].str,0); ++ dumplist((yyvsp[(1) - (1)]).str,0); + } + break; + + case 10: ++ ++/* Line 1806 of yacc.c */ + #line 164 "parser.y" + { + seek_eol(); +@@ -1541,987 +1923,1249 @@ yyreduce: + break; + + case 11: ++ ++/* Line 1806 of yacc.c */ + #line 167 "parser.y" + { +- yyval.value = 0; ++ (yyval).value = 0; + if( dashl && pass2 ) +- dumplist(yyvsp[-2].str,0); ++ dumplist((yyvsp[(1) - (3)]).str,0); + } + break; + + case 12: ++ ++/* Line 1806 of yacc.c */ + #line 184 "parser.y" + { +- lc = yyvsp[0].val.v; ++ lc = (yyvsp[(3) - (3)]).val.v; + if( pass2 ) emitaddr(lc); + bytecount = 0; +- yyval.value = 0; ++ (yyval).value = 0; + } + break; + + case 13: ++ ++/* Line 1806 of yacc.c */ + #line 190 "parser.y" +- { yyval.value = yyvsp[0].value; } ++ { (yyval).value = (yyvsp[(3) - (3)]).value; } + break; + + case 14: ++ ++/* Line 1806 of yacc.c */ + #line 191 "parser.y" +- { yyval.value = yyvsp[0].value; } ++ { (yyval).value = (yyvsp[(3) - (3)]).value; } + break; + + case 15: ++ ++/* Line 1806 of yacc.c */ + #line 192 "parser.y" +- { yyval.value = yyvsp[0].val.v; ++ { (yyval).value = (yyvsp[(3) - (3)]).val.v; + if( pass2 ) +- emitaddr(lc+yyval.value); } ++ emitaddr(lc+(yyval).value); } + break; + + case 16: ++ ++/* Line 1806 of yacc.c */ + #line 196 "parser.y" + { +- if( yyvsp[0].val.d == 0 ) ++ if( (yyvsp[(5) - (5)]).val.d == 0 ) + warn("Expression is undefined in pass 1"); +- yyvsp[-2].sym->type = LABEL; +- yyvsp[-2].sym->value = yyvsp[0].val.v; +- yyval.value = 0; ++ (yyvsp[(3) - (5)]).sym->type = LABEL; ++ (yyvsp[(3) - (5)]).sym->value = (yyvsp[(5) - (5)]).val.v; ++ (yyval).value = 0; + } + break; + + case 17: ++ ++/* Line 1806 of yacc.c */ + #line 205 "parser.y" + { +- yyvsp[-2].sym->type = LABEL; +- yyvsp[-2].sym->value = yyvsp[0].value; +- yyval.value = 0; ++ (yyvsp[(3) - (5)]).sym->type = LABEL; ++ (yyvsp[(3) - (5)]).sym->value = (yyvsp[(5) - (5)]).value; ++ (yyval).value = 0; + } + break; + + case 18: ++ ++/* Line 1806 of yacc.c */ + #line 210 "parser.y" +- { yyval.value = 0; } ++ { (yyval).value = 0; } + break; + + case 19: ++ ++/* Line 1806 of yacc.c */ + #line 214 "parser.y" + { +- if( yyvsp[0].val.d == 0 ) ++ if( (yyvsp[(1) - (1)]).val.d == 0 ) + warn("Expression is undefined in pass 1"); +- if( !(isbit16(yyvsp[0].val.v)) ) ++ if( !(isbit16((yyvsp[(1) - (1)]).val.v)) ) + warn("Value greater than 16-bits"); +- yyval.value = yyvsp[0].val.v; ++ (yyval).value = (yyvsp[(1) - (1)]).val.v; + } + break; + + case 20: ++ ++/* Line 1806 of yacc.c */ + #line 224 "parser.y" + { +- if( !isbit8(yyvsp[-1].value) ) ++ if( !isbit8((yyvsp[(1) - (2)]).value) ) + warn("Bit address exceeds 8-bits"); +- if( isbmram(yyvsp[-1].value) ) +- yyval.value = (yyvsp[-1].value-0x20)*8+ yyvsp[0].value; +- else if( isbmsfr(yyvsp[-1].value) ) +- yyval.value = yyvsp[-1].value + yyvsp[0].value; ++ if( isbmram((yyvsp[(1) - (2)]).value) ) ++ (yyval).value = ((yyvsp[(1) - (2)]).value-0x20)*8+ (yyvsp[(2) - (2)]).value; ++ else if( isbmsfr((yyvsp[(1) - (2)]).value) ) ++ (yyval).value = (yyvsp[(1) - (2)]).value + (yyvsp[(2) - (2)]).value; + else + warn("Invalid bit addressable RAM location"); + } + break; + + case 21: ++ ++/* Line 1806 of yacc.c */ + #line 237 "parser.y" + { +- if( yyvsp[0].sym->type == UNDEF ) +- warn("Symbol %s must be defined in pass 1",yyvsp[0].sym->name); +- yyval.value = yyvsp[0].sym->value; ++ if( (yyvsp[(1) - (1)]).sym->type == UNDEF ) ++ warn("Symbol %s must be defined in pass 1",(yyvsp[(1) - (1)]).sym->name); ++ (yyval).value = (yyvsp[(1) - (1)]).sym->value; + } + break; + + case 22: ++ ++/* Line 1806 of yacc.c */ + #line 242 "parser.y" +- { yyval.value = yyvsp[0].value; } ++ { (yyval).value = (yyvsp[(1) - (1)]).value; } + break; + + case 23: ++ ++/* Line 1806 of yacc.c */ + #line 247 "parser.y" + { +- if( yyvsp[0].sym->type != UNDEF && pass1) +- warn("Attempt to redefine symbol: %s",yyvsp[0].sym->name); +- yyval.sym = yyvsp[0].sym; ++ if( (yyvsp[(1) - (1)]).sym->type != UNDEF && pass1) ++ warn("Attempt to redefine symbol: %s",(yyvsp[(1) - (1)]).sym->name); ++ (yyval).sym = (yyvsp[(1) - (1)]).sym; + } + break; + + case 24: ++ ++/* Line 1806 of yacc.c */ + #line 255 "parser.y" + { +- if( pass2 ) genbyte(yyvsp[0].value); +- yyval.value = yyvsp[-2].value + 1; ++ if( pass2 ) genbyte((yyvsp[(3) - (3)]).value); ++ (yyval).value = (yyvsp[(1) - (3)]).value + 1; + } + break; + + case 25: ++ ++/* Line 1806 of yacc.c */ + #line 260 "parser.y" + { + if( pass1 ) +- yyval.value = yyvsp[-2].value + yyvsp[0].value; ++ (yyval).value = (yyvsp[(1) - (3)]).value + (yyvsp[(3) - (3)]).value; + else { +- yyval.value = yyvsp[-2].value + strlen(yyvsp[0].str); +- genstr(yyvsp[0].str); ++ (yyval).value = (yyvsp[(1) - (3)]).value + strlen((yyvsp[(3) - (3)]).str); ++ genstr((yyvsp[(3) - (3)]).str); + +- free(yyvsp[0].str); ++ free((yyvsp[(3) - (3)]).str); + } + } + break; + + case 26: ++ ++/* Line 1806 of yacc.c */ + #line 271 "parser.y" + { +- if( pass2 ) genbyte(yyvsp[0].value); +- yyval.value = 1; ++ if( pass2 ) genbyte((yyvsp[(1) - (1)]).value); ++ (yyval).value = 1; + } + break; + + case 27: ++ ++/* Line 1806 of yacc.c */ + #line 276 "parser.y" + { + if( pass1 ) +- yyval.value = yyvsp[0].value; ++ (yyval).value = (yyvsp[(1) - (1)]).value; + else { +- yyval.value = strlen(yyvsp[0].str); +- genstr(yyvsp[0].str); +- free(yyvsp[0].str); ++ (yyval).value = strlen((yyvsp[(1) - (1)]).str); ++ genstr((yyvsp[(1) - (1)]).str); ++ free((yyvsp[(1) - (1)]).str); + } + } + break; + + case 28: ++ ++/* Line 1806 of yacc.c */ + #line 288 "parser.y" + { +- if( pass2 ) genword(yyvsp[0].value); +- yyval.value = yyvsp[-2].value + 2; ++ if( pass2 ) genword((yyvsp[(3) - (3)]).value); ++ (yyval).value = (yyvsp[(1) - (3)]).value + 2; + } + break; + + case 29: ++ ++/* Line 1806 of yacc.c */ + #line 293 "parser.y" + { +- if( pass2 ) genword(yyvsp[0].value); +- yyval.value = 2; ++ if( pass2 ) genword((yyvsp[(1) - (1)]).value); ++ (yyval).value = 2; + } + break; + + case 30: ++ ++/* Line 1806 of yacc.c */ + #line 306 "parser.y" +- { yyval.val.v = lc; +- yyval.val.d = 1; } ++ { (yyval).val.v = lc; ++ (yyval).val.d = 1; } + break; + + case 31: ++ ++/* Line 1806 of yacc.c */ + #line 309 "parser.y" +- { yyval.val.v = yyvsp[-1].val.v; +- yyval.val.d = yyvsp[-1].val.d; } ++ { (yyval).val.v = (yyvsp[(2) - (3)]).val.v; ++ (yyval).val.d = (yyvsp[(2) - (3)]).val.d; } + break; + + case 32: ++ ++/* Line 1806 of yacc.c */ + #line 312 "parser.y" +- { yyval.val.v = -yyvsp[0].val.v; +- yyval.val.d = yyvsp[0].val.d; } ++ { (yyval).val.v = -(yyvsp[(2) - (2)]).val.v; ++ (yyval).val.d = (yyvsp[(2) - (2)]).val.d; } + break; + + case 33: ++ ++/* Line 1806 of yacc.c */ + #line 315 "parser.y" +- { yyval.val.v = yyvsp[-2].val.v | yyvsp[0].val.v; +- yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; } ++ { (yyval).val.v = (yyvsp[(1) - (3)]).val.v | (yyvsp[(3) - (3)]).val.v; ++ (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; } + break; + + case 34: ++ ++/* Line 1806 of yacc.c */ + #line 318 "parser.y" +- { yyval.val.v = yyvsp[-2].val.v & yyvsp[0].val.v; +- yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; } ++ { (yyval).val.v = (yyvsp[(1) - (3)]).val.v & (yyvsp[(3) - (3)]).val.v; ++ (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; } + break; + + case 35: ++ ++/* Line 1806 of yacc.c */ + #line 321 "parser.y" +- { yyval.val.v = yyvsp[-2].val.v * yyvsp[0].val.v; +- yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; } ++ { (yyval).val.v = (yyvsp[(1) - (3)]).val.v * (yyvsp[(3) - (3)]).val.v; ++ (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; } + break; + + case 36: ++ ++/* Line 1806 of yacc.c */ + #line 324 "parser.y" +- { yyval.val.v = yyvsp[-2].val.v / yyvsp[0].val.v; +- yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; } ++ { (yyval).val.v = (yyvsp[(1) - (3)]).val.v / (yyvsp[(3) - (3)]).val.v; ++ (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; } + break; + + case 37: ++ ++/* Line 1806 of yacc.c */ + #line 327 "parser.y" +- { yyval.val.v = yyvsp[-2].val.v % yyvsp[0].val.v; +- yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; } ++ { (yyval).val.v = (yyvsp[(1) - (3)]).val.v % (yyvsp[(3) - (3)]).val.v; ++ (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; } + break; + + case 38: ++ ++/* Line 1806 of yacc.c */ + #line 330 "parser.y" +- { yyval.val.v = yyvsp[-2].val.v - yyvsp[0].val.v; +- yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; } ++ { (yyval).val.v = (yyvsp[(1) - (3)]).val.v - (yyvsp[(3) - (3)]).val.v; ++ (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; } + break; + + case 39: ++ ++/* Line 1806 of yacc.c */ + #line 333 "parser.y" +- { yyval.val.v = yyvsp[-2].val.v + yyvsp[0].val.v; +- yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; } ++ { (yyval).val.v = (yyvsp[(1) - (3)]).val.v + (yyvsp[(3) - (3)]).val.v; ++ (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; } + break; + + case 40: ++ ++/* Line 1806 of yacc.c */ + #line 336 "parser.y" +- { yyval.val.v = yyvsp[-3].val.v >> yyvsp[0].val.v; +- yyval.val.d = yyvsp[-3].val.d && yyvsp[0].val.d; } ++ { (yyval).val.v = (yyvsp[(1) - (4)]).val.v >> (yyvsp[(4) - (4)]).val.v; ++ (yyval).val.d = (yyvsp[(1) - (4)]).val.d && (yyvsp[(4) - (4)]).val.d; } + break; + + case 41: ++ ++/* Line 1806 of yacc.c */ + #line 339 "parser.y" +- { yyval.val.v = yyvsp[-3].val.v << yyvsp[0].val.v; +- yyval.val.d = yyvsp[-3].val.d && yyvsp[0].val.d; } ++ { (yyval).val.v = (yyvsp[(1) - (4)]).val.v << (yyvsp[(4) - (4)]).val.v; ++ (yyval).val.d = (yyvsp[(1) - (4)]).val.d && (yyvsp[(4) - (4)]).val.d; } + break; + + case 42: ++ ++/* Line 1806 of yacc.c */ + #line 342 "parser.y" + { + if( pass1 ) { +- yyval.val.v = yyvsp[0].sym->value; +- yyval.val.d = (yyvsp[0].sym->type != UNDEF); ++ (yyval).val.v = (yyvsp[(1) - (1)]).sym->value; ++ (yyval).val.d = ((yyvsp[(1) - (1)]).sym->type != UNDEF); + } + else { +- if( yyvsp[0].sym->type == UNDEF ) +- warn("Undefined symbol %s",yyvsp[0].sym->name); +- yyval.val.v = yyvsp[0].sym->value; +- yyval.val.d = 1; ++ if( (yyvsp[(1) - (1)]).sym->type == UNDEF ) ++ warn("Undefined symbol %s",(yyvsp[(1) - (1)]).sym->name); ++ (yyval).val.v = (yyvsp[(1) - (1)]).sym->value; ++ (yyval).val.d = 1; + } + } + break; + + case 43: ++ ++/* Line 1806 of yacc.c */ + #line 354 "parser.y" +- { yyval.val.v = yyvsp[0].val.v; yyval.val.d=1; } ++ { (yyval).val.v = (yyvsp[(1) - (1)]).val.v; (yyval).val.d=1; } + break; + + case 44: ++ ++/* Line 1806 of yacc.c */ + #line 367 "parser.y" +- { yyval.value = makeop(yyvsp[0].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (1)]).op,NULL,0); } + break; + + case 45: ++ ++/* Line 1806 of yacc.c */ + #line 369 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 46: ++ ++/* Line 1806 of yacc.c */ + #line 371 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 47: ++ ++/* Line 1806 of yacc.c */ + #line 373 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 48: ++ ++/* Line 1806 of yacc.c */ + #line 375 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 49: ++ ++/* Line 1806 of yacc.c */ + #line 377 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 50: ++ ++/* Line 1806 of yacc.c */ + #line 379 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 51: ++ ++/* Line 1806 of yacc.c */ + #line 381 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,4); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,4); } + break; + + case 52: ++ ++/* Line 1806 of yacc.c */ + #line 383 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 53: ++ ++/* Line 1806 of yacc.c */ + #line 385 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,4); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,4); } + break; + + case 54: ++ ++/* Line 1806 of yacc.c */ + #line 387 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,6); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,6); } + break; + + case 55: ++ ++/* Line 1806 of yacc.c */ + #line 389 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 56: ++ ++/* Line 1806 of yacc.c */ + #line 391 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,4); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,4); } + break; + + case 57: ++ ++/* Line 1806 of yacc.c */ + #line 393 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,6); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,6); } + break; + + case 58: ++ ++/* Line 1806 of yacc.c */ + #line 395 "parser.y" +- { if( get_md(yyvsp[0].mode) == 3 ) ++ { if( get_md((yyvsp[(2) - (2)]).mode) == 3 ) + warn("Immediate mode is illegal"); +- yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); ++ (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); + } + break; + + case 59: ++ ++/* Line 1806 of yacc.c */ + #line 400 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 60: ++ ++/* Line 1806 of yacc.c */ + #line 402 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,NULL,4); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,4); } + break; + + case 61: ++ ++/* Line 1806 of yacc.c */ + #line 404 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 62: ++ ++/* Line 1806 of yacc.c */ + #line 406 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); } + break; + + case 63: ++ ++/* Line 1806 of yacc.c */ + #line 408 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); } + break; + + case 64: ++ ++/* Line 1806 of yacc.c */ + #line 410 "parser.y" +- { yyval.value = makeop(yyvsp[-4].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (5)]).op,NULL,0); } + break; + + case 65: ++ ++/* Line 1806 of yacc.c */ + #line 412 "parser.y" +- { yyval.value = makeop(yyvsp[-4].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (5)]).op,NULL,0); } + break; + + case 66: ++ ++/* Line 1806 of yacc.c */ + #line 414 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); } + break; + + case 67: ++ ++/* Line 1806 of yacc.c */ + #line 416 "parser.y" +- { yyval.value = makeop(yyvsp[0].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (1)]).op,NULL,0); } + break; + + case 68: ++ ++/* Line 1806 of yacc.c */ + #line 418 "parser.y" +- { yyval.value = makeop(yyvsp[0].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (1)]).op,NULL,0); } + break; + + case 69: ++ ++/* Line 1806 of yacc.c */ + #line 420 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); } + break; + + case 70: ++ ++/* Line 1806 of yacc.c */ + #line 422 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); } + break; + + case 71: ++ ++/* Line 1806 of yacc.c */ + #line 424 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); } + break; + + case 72: ++ ++/* Line 1806 of yacc.c */ + #line 426 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); } + break; + + case 73: ++ ++/* Line 1806 of yacc.c */ + #line 428 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); } + break; + + case 74: ++ ++/* Line 1806 of yacc.c */ + #line 430 "parser.y" +- { if( get_md(yyvsp[0].mode) != 2 ) ++ { if( get_md((yyvsp[(2) - (2)]).mode) != 2 ) + warn("Invalid addressing mode"); +- yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,-2); } ++ (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,-2); } + break; + + case 75: ++ ++/* Line 1806 of yacc.c */ + #line 434 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 76: ++ ++/* Line 1806 of yacc.c */ + #line 436 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 77: ++ ++/* Line 1806 of yacc.c */ + #line 438 "parser.y" +- { if( get_md(yyvsp[0].mode) == 0 ) ++ { if( get_md((yyvsp[(2) - (2)]).mode) == 0 ) + warn("Invalid addressing mode"); +- yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,-1); } ++ (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,-1); } + break; + + case 78: ++ ++/* Line 1806 of yacc.c */ + #line 442 "parser.y" + { + struct mode tmp; + set_md(tmp,0); + set_ov(tmp,0); + set_sz(tmp,1); +- set_b1(tmp,yyvsp[0].value); +- yyval.value = makeop(yyvsp[-1].op,&tmp,0); ++ set_b1(tmp,(yyvsp[(2) - (2)]).value); ++ (yyval).value = makeop((yyvsp[(1) - (2)]).op,&tmp,0); + } + break; + + case 79: ++ ++/* Line 1806 of yacc.c */ + #line 451 "parser.y" + { + struct mode tmp; + set_md(tmp,0); + set_ov(tmp,0); + set_sz(tmp,1); +- set_b1(tmp,yyvsp[0].value); +- yyval.value = makeop(yyvsp[-1].op,&tmp,0); ++ set_b1(tmp,(yyvsp[(2) - (2)]).value); ++ (yyval).value = makeop((yyvsp[(1) - (2)]).op,&tmp,0); + } + break; + + case 80: ++ ++/* Line 1806 of yacc.c */ + #line 460 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 81: ++ ++/* Line 1806 of yacc.c */ + #line 462 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 82: ++ ++/* Line 1806 of yacc.c */ + #line 464 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 83: ++ ++/* Line 1806 of yacc.c */ + #line 466 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 84: ++ ++/* Line 1806 of yacc.c */ + #line 468 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 85: ++ ++/* Line 1806 of yacc.c */ + #line 470 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 86: ++ ++/* Line 1806 of yacc.c */ + #line 472 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 87: ++ ++/* Line 1806 of yacc.c */ + #line 474 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 88: ++ ++/* Line 1806 of yacc.c */ + #line 476 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 89: ++ ++/* Line 1806 of yacc.c */ + #line 478 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 90: ++ ++/* Line 1806 of yacc.c */ + #line 480 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 91: ++ ++/* Line 1806 of yacc.c */ + #line 482 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 92: ++ ++/* Line 1806 of yacc.c */ + #line 484 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); } + break; + + case 93: ++ ++/* Line 1806 of yacc.c */ + #line 486 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,4); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,4); } + break; + + case 94: ++ ++/* Line 1806 of yacc.c */ + #line 488 "parser.y" +- { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,6); } ++ { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,6); } + break; + + case 95: ++ ++/* Line 1806 of yacc.c */ + #line 492 "parser.y" +- { yyval.value = makeop(yyvsp[-6].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (7)]).op,NULL,0); } + break; + + case 96: ++ ++/* Line 1806 of yacc.c */ + #line 494 "parser.y" +- { yyval.value = makeop(yyvsp[-6].op,NULL,0); } ++ { (yyval).value = makeop((yyvsp[(1) - (7)]).op,NULL,0); } + break; + + case 97: ++ ++/* Line 1806 of yacc.c */ + #line 496 "parser.y" +- { yyval.value = makeop(yyvsp[-6].op,NULL,1); } ++ { (yyval).value = makeop((yyvsp[(1) - (7)]).op,NULL,1); } + break; + + case 98: ++ ++/* Line 1806 of yacc.c */ + #line 498 "parser.y" +- { yyval.value = makeop(yyvsp[-6].op,NULL,1); } ++ { (yyval).value = makeop((yyvsp[(1) - (7)]).op,NULL,1); } + break; + + case 99: ++ ++/* Line 1806 of yacc.c */ + #line 501 "parser.y" +- { yyval.value = makeop(yyvsp[-4].op,NULL,yyvsp[0].value); } ++ { (yyval).value = makeop((yyvsp[(1) - (5)]).op,NULL,(yyvsp[(5) - (5)]).value); } + break; + + case 100: ++ ++/* Line 1806 of yacc.c */ + #line 503 "parser.y" +- { yyval.value = makeop(yyvsp[-4].op,NULL,2); } ++ { (yyval).value = makeop((yyvsp[(1) - (5)]).op,NULL,2); } + break; + + case 101: ++ ++/* Line 1806 of yacc.c */ + #line 505 "parser.y" +- { yyval.value = makeop(yyvsp[-4].op,NULL,yyvsp[-2].value+3); } ++ { (yyval).value = makeop((yyvsp[(1) - (5)]).op,NULL,(yyvsp[(3) - (5)]).value+3); } + break; + + case 102: ++ ++/* Line 1806 of yacc.c */ + #line 507 "parser.y" +- { yyval.value = makeop(yyvsp[-4].op,NULL,5); } ++ { (yyval).value = makeop((yyvsp[(1) - (5)]).op,NULL,5); } + break; + + case 103: ++ ++/* Line 1806 of yacc.c */ + #line 519 "parser.y" + { +- set_md(yyval.mode,0); +- set_ov(yyval.mode, yyvsp[0].value); +- set_sz(yyval.mode, 0); ++ set_md((yyval).mode,0); ++ set_ov((yyval).mode, (yyvsp[(3) - (3)]).value); ++ set_sz((yyval).mode, 0); + } + break; + + case 104: ++ ++/* Line 1806 of yacc.c */ + #line 525 "parser.y" + { +- set_md(yyval.mode,1); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,1); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(3) - (3)]).value); + } + break; + + case 105: ++ ++/* Line 1806 of yacc.c */ + #line 532 "parser.y" + { +- set_md(yyval.mode,2); +- set_ov(yyval.mode,yyvsp[0].value); +- set_sz(yyval.mode,0); ++ set_md((yyval).mode,2); ++ set_ov((yyval).mode,(yyvsp[(4) - (4)]).value); ++ set_sz((yyval).mode,0); + } + break; + + case 106: ++ ++/* Line 1806 of yacc.c */ + #line 538 "parser.y" + { +- set_md(yyval.mode,3); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,3); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(4) - (4)]).value); + } + break; + + case 107: ++ ++/* Line 1806 of yacc.c */ + #line 547 "parser.y" + { +- set_md(yyval.mode,0); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[-2].value); ++ set_md((yyval).mode,0); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(1) - (3)]).value); + } + break; + + case 108: ++ ++/* Line 1806 of yacc.c */ + #line 554 "parser.y" + { +- set_md(yyval.mode,1); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,2); +- set_b1(yyval.mode,yyvsp[-3].value); +- set_b2(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,1); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,2); ++ set_b1((yyval).mode,(yyvsp[(1) - (4)]).value); ++ set_b2((yyval).mode,(yyvsp[(4) - (4)]).value); + } + break; + + case 109: ++ ++/* Line 1806 of yacc.c */ + #line 564 "parser.y" + { +- set_md(yyval.mode,0); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,0); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(3) - (3)]).value); + } + break; + + case 110: ++ ++/* Line 1806 of yacc.c */ + #line 571 "parser.y" + { +- set_md(yyval.mode,1); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,1); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(4) - (4)]).value); + } + break; + + case 111: ++ ++/* Line 1806 of yacc.c */ + #line 578 "parser.y" + { +- set_md(yyval.mode,1); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,1); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(4) - (4)]).value); + } + break; + + case 112: ++ ++/* Line 1806 of yacc.c */ + #line 587 "parser.y" + { +- set_md(yyval.mode,0); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,2); +- set_b1(yyval.mode,yyvsp[-2].value); +- set_b2(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,0); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,2); ++ set_b1((yyval).mode,(yyvsp[(1) - (3)]).value); ++ set_b2((yyval).mode,(yyvsp[(3) - (3)]).value); + } + break; + + case 113: ++ ++/* Line 1806 of yacc.c */ + #line 597 "parser.y" + { +- set_md(yyval.mode,0); +- set_ov(yyval.mode,yyvsp[-2].value); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,0); ++ set_ov((yyval).mode,(yyvsp[(1) - (3)]).value); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(3) - (3)]).value); + } + break; + + case 114: ++ ++/* Line 1806 of yacc.c */ + #line 604 "parser.y" + { +- set_md(yyval.mode,1); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,2); +- set_b1(yyval.mode,yyvsp[-2].value); +- set_b2(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,1); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,2); ++ set_b1((yyval).mode,(yyvsp[(1) - (3)]).value); ++ set_b2((yyval).mode,(yyvsp[(3) - (3)]).value); + } + break; + + case 115: ++ ++/* Line 1806 of yacc.c */ + #line 614 "parser.y" + { +- set_md(yyval.mode,0); +- set_ov(yyval.mode,yyvsp[-2].value); +- set_sz(yyval.mode,0); ++ set_md((yyval).mode,0); ++ set_ov((yyval).mode,(yyvsp[(1) - (3)]).value); ++ set_sz((yyval).mode,0); + } + break; + + case 116: ++ ++/* Line 1806 of yacc.c */ + #line 620 "parser.y" + { +- set_md(yyval.mode,1); +- set_ov(yyval.mode,yyvsp[-2].value); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,1); ++ set_ov((yyval).mode,(yyvsp[(1) - (3)]).value); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(3) - (3)]).value); + } + break; + + case 117: ++ ++/* Line 1806 of yacc.c */ + #line 627 "parser.y" + { +- set_md(yyval.mode,2); +- set_ov(yyval.mode,yyvsp[-3].value); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,2); ++ set_ov((yyval).mode,(yyvsp[(1) - (4)]).value); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(4) - (4)]).value); + } + break; + + case 118: ++ ++/* Line 1806 of yacc.c */ + #line 634 "parser.y" + { +- set_md(yyval.mode,3); +- set_ov(yyval.mode,yyvsp[0].value); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[-2].value); ++ set_md((yyval).mode,3); ++ set_ov((yyval).mode,(yyvsp[(3) - (3)]).value); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(1) - (3)]).value); + } + break; + + case 119: ++ ++/* Line 1806 of yacc.c */ + #line 641 "parser.y" + { +- set_md(yyval.mode,4); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,2); +- set_b1(yyval.mode,yyvsp[0].value); +- set_b2(yyval.mode,yyvsp[-2].value); ++ set_md((yyval).mode,4); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,2); ++ set_b1((yyval).mode,(yyvsp[(3) - (3)]).value); ++ set_b2((yyval).mode,(yyvsp[(1) - (3)]).value); + } + break; + + case 120: ++ ++/* Line 1806 of yacc.c */ + #line 649 "parser.y" + { +- set_md(yyval.mode,5); +- set_ov(yyval.mode,yyvsp[0].value); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[-3].value); ++ set_md((yyval).mode,5); ++ set_ov((yyval).mode,(yyvsp[(4) - (4)]).value); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(1) - (4)]).value); + } + break; + + case 121: ++ ++/* Line 1806 of yacc.c */ + #line 656 "parser.y" + { +- set_md(yyval.mode,6); +- set_ov(yyval.mode,yyvsp[-2].value); +- set_sz(yyval.mode,0); ++ set_md((yyval).mode,6); ++ set_ov((yyval).mode,(yyvsp[(2) - (4)]).value); ++ set_sz((yyval).mode,0); + } + break; + + case 122: ++ ++/* Line 1806 of yacc.c */ + #line 662 "parser.y" + { +- set_md(yyval.mode,7); +- set_ov(yyval.mode,yyvsp[-2].value); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,7); ++ set_ov((yyval).mode,(yyvsp[(2) - (4)]).value); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(4) - (4)]).value); + } + break; + + case 123: ++ ++/* Line 1806 of yacc.c */ + #line 669 "parser.y" + { +- set_md(yyval.mode,8); +- set_ov(yyval.mode,yyvsp[-3].value); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,8); ++ set_ov((yyval).mode,(yyvsp[(2) - (5)]).value); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(5) - (5)]).value); + } + break; + + case 124: ++ ++/* Line 1806 of yacc.c */ + #line 676 "parser.y" + { +- set_md(yyval.mode,9); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,2); +- set_b1(yyval.mode, (yyvsp[0].value & 0xff00) >> 8 ); +- set_b2(yyval.mode, (yyvsp[0].value & 0x00ff) ); ++ set_md((yyval).mode,9); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,2); ++ set_b1((yyval).mode, ((yyvsp[(4) - (4)]).value & 0xff00) >> 8 ); ++ set_b2((yyval).mode, ((yyvsp[(4) - (4)]).value & 0x00ff) ); + } + break; + + case 125: ++ ++/* Line 1806 of yacc.c */ + #line 684 "parser.y" + { +- set_md(yyval.mode,10); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,10); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(3) - (3)]).value); + } + break; + + case 126: ++ ++/* Line 1806 of yacc.c */ + #line 700 "parser.y" + { +- set_md(yyval.mode,11); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[-2].value); ++ set_md((yyval).mode,11); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(1) - (3)]).value); + } + break; + + case 127: ++ ++/* Line 1806 of yacc.c */ + #line 707 "parser.y" + { + if( pass2 ) { +- if( !isbit8(yyvsp[-3].value) ) ++ if( !isbit8((yyvsp[(1) - (4)]).value) ) + warn("Bit address exceeds 8-bits"); +- if( isbmram(yyvsp[-3].value) ) +- set_b1(yyval.mode, (yyvsp[-3].value-0x20)*8+ yyvsp[-2].value ); +- else if( isbmsfr(yyvsp[-3].value) ) +- set_b1(yyval.mode, yyvsp[-3].value + yyvsp[-2].value ); ++ if( isbmram((yyvsp[(1) - (4)]).value) ) ++ set_b1((yyval).mode, ((yyvsp[(1) - (4)]).value-0x20)*8+ (yyvsp[(2) - (4)]).value ); ++ else if( isbmsfr((yyvsp[(1) - (4)]).value) ) ++ set_b1((yyval).mode, (yyvsp[(1) - (4)]).value + (yyvsp[(2) - (4)]).value ); + else + warn("Invalid bit addressable RAM location"); + } +- set_md(yyval.mode,11); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,1); ++ set_md((yyval).mode,11); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,1); + } + break; + + case 128: ++ ++/* Line 1806 of yacc.c */ + #line 726 "parser.y" + { +- set_md(yyval.mode,0); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,0); ++ set_md((yyval).mode,0); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,0); + } + break; + + case 129: ++ ++/* Line 1806 of yacc.c */ + #line 733 "parser.y" + { +- set_md(yyval.mode,1); +- set_ov(yyval.mode,yyvsp[0].value); +- set_sz(yyval.mode,0); ++ set_md((yyval).mode,1); ++ set_ov((yyval).mode,(yyvsp[(1) - (1)]).value); ++ set_sz((yyval).mode,0); + } + break; + + case 130: ++ ++/* Line 1806 of yacc.c */ + #line 739 "parser.y" + { +- set_md(yyval.mode,2); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,2); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(1) - (1)]).value); + } + break; + + case 131: ++ ++/* Line 1806 of yacc.c */ + #line 746 "parser.y" + { +- set_md(yyval.mode,3); +- set_ov(yyval.mode,yyvsp[0].value); +- set_sz(yyval.mode,0); ++ set_md((yyval).mode,3); ++ set_ov((yyval).mode,(yyvsp[(2) - (2)]).value); ++ set_sz((yyval).mode,0); + } + break; + + case 132: ++ ++/* Line 1806 of yacc.c */ + #line 754 "parser.y" + { +- set_md(yyval.mode,0); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,0); ++ set_md((yyval).mode,0); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,0); + } + break; + + case 133: ++ ++/* Line 1806 of yacc.c */ + #line 760 "parser.y" + { +- set_md(yyval.mode,1); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,0); ++ set_md((yyval).mode,1); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,0); + } + break; + + case 134: ++ ++/* Line 1806 of yacc.c */ + #line 766 "parser.y" + { +- set_md(yyval.mode,2); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,2); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(1) - (1)]).value); + } + break; + + case 135: ++ ++/* Line 1806 of yacc.c */ + #line 775 "parser.y" + { +- set_md(yyval.mode,0); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,2); +- set_b1(yyval.mode,yyvsp[-2].value); +- set_b2(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,0); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,2); ++ set_b1((yyval).mode,(yyvsp[(3) - (5)]).value); ++ set_b2((yyval).mode,(yyvsp[(5) - (5)]).value); + } + break; + + case 136: ++ ++/* Line 1806 of yacc.c */ + #line 783 "parser.y" + { +- set_md(yyval.mode,1); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,2); +- set_b1(yyval.mode,yyvsp[-2].value); +- set_b2(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,1); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,2); ++ set_b1((yyval).mode,(yyvsp[(4) - (6)]).value); ++ set_b2((yyval).mode,(yyvsp[(6) - (6)]).value); + } + break; + + case 137: ++ ++/* Line 1806 of yacc.c */ + #line 791 "parser.y" + { +- set_md(yyval.mode,2); +- set_ov(yyval.mode,yyvsp[-5].value); +- set_sz(yyval.mode,2); +- set_b1(yyval.mode,yyvsp[-2].value); +- set_b2(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,2); ++ set_ov((yyval).mode,(yyvsp[(1) - (6)]).value); ++ set_sz((yyval).mode,2); ++ set_b1((yyval).mode,(yyvsp[(4) - (6)]).value); ++ set_b2((yyval).mode,(yyvsp[(6) - (6)]).value); + } + break; + + case 138: ++ ++/* Line 1806 of yacc.c */ + #line 799 "parser.y" + { +- set_md(yyval.mode,3); +- set_ov(yyval.mode,yyvsp[-5].value); +- set_sz(yyval.mode,2); +- set_b1(yyval.mode,yyvsp[-2].value); +- set_b2(yyval.mode,yyvsp[0].value); ++ set_md((yyval).mode,3); ++ set_ov((yyval).mode,(yyvsp[(2) - (7)]).value); ++ set_sz((yyval).mode,2); ++ set_b1((yyval).mode,(yyvsp[(5) - (7)]).value); ++ set_b2((yyval).mode,(yyvsp[(7) - (7)]).value); + } + break; + + case 139: ++ ++/* Line 1806 of yacc.c */ + #line 809 "parser.y" + { + long offset; + if( pass2 ) { +- offset = yyvsp[0].val.v - (lc+3); ++ offset = (yyvsp[(1) - (1)]).val.v - (lc+3); + if( offset > 127 || offset < -128 ) + warn("Relative offset exceeds -128 / +127"); +- yyval.value = offset; ++ (yyval).value = offset; + } + } + break; + + case 140: ++ ++/* Line 1806 of yacc.c */ + #line 826 "parser.y" + { + long offset; + if( pass2 ) { +- offset = yyvsp[0].val.v - (lc+2); /* different! */ ++ offset = (yyvsp[(1) - (1)]).val.v - (lc+2); /* different! */ + if( offset > 127 || offset < -128 ) + warn("Relative offset exceeds -128 / +127"); +- yyval.value = offset; ++ (yyval).value = offset; + } + } + break; + + case 141: ++ ++/* Line 1806 of yacc.c */ + #line 839 "parser.y" + { + if( pass2 ) { +- if( !isbit8(yyvsp[-1].value) ) ++ if( !isbit8((yyvsp[(1) - (2)]).value) ) + warn("Bit address exceeds 8-bits"); +- if( isbmram(yyvsp[-1].value) ) +- yyval.value = (yyvsp[-1].value-0x20)*8+yyvsp[0].value; +- else if( isbmsfr(yyvsp[-1].value) ) +- yyval.value = yyvsp[-1].value + yyvsp[0].value; ++ if( isbmram((yyvsp[(1) - (2)]).value) ) ++ (yyval).value = ((yyvsp[(1) - (2)]).value-0x20)*8+(yyvsp[(2) - (2)]).value; ++ else if( isbmsfr((yyvsp[(1) - (2)]).value) ) ++ (yyval).value = (yyvsp[(1) - (2)]).value + (yyvsp[(2) - (2)]).value; + else + warn("Invalid bit addressable RAM location"); + } +@@ -2529,201 +3173,259 @@ yyreduce: + break; + + case 142: ++ ++/* Line 1806 of yacc.c */ + #line 852 "parser.y" + { + if( pass2 ) { +- if( !isbit8(yyvsp[0].value) ) ++ if( !isbit8((yyvsp[(1) - (1)]).value) ) + warn("Bit address exceeds 8-bits"); +- yyval.value = yyvsp[0].value; ++ (yyval).value = (yyvsp[(1) - (1)]).value; + } + } + break; + + case 143: ++ ++/* Line 1806 of yacc.c */ + #line 862 "parser.y" + { +- if( yyvsp[0].sym->type == UNDEF && pass2 ) +- warn("Symbol %s undefined",yyvsp[0].sym->name); +- yyval.value = yyvsp[0].sym->value; ++ if( (yyvsp[(1) - (1)]).sym->type == UNDEF && pass2 ) ++ warn("Symbol %s undefined",(yyvsp[(1) - (1)]).sym->name); ++ (yyval).value = (yyvsp[(1) - (1)]).sym->value; + } + break; + + case 144: ++ ++/* Line 1806 of yacc.c */ + #line 867 "parser.y" +- { yyval.value = yyvsp[0].value; } ++ { (yyval).value = (yyvsp[(1) - (1)]).value; } + break; + + case 145: ++ ++/* Line 1806 of yacc.c */ + #line 870 "parser.y" +- { yyval.value = 0; } ++ { (yyval).value = 0; } + break; + + case 146: ++ ++/* Line 1806 of yacc.c */ + #line 871 "parser.y" +- { yyval.value = 1; } ++ { (yyval).value = 1; } + break; + + case 147: ++ ++/* Line 1806 of yacc.c */ + #line 872 "parser.y" +- { yyval.value = 2; } ++ { (yyval).value = 2; } + break; + + case 148: ++ ++/* Line 1806 of yacc.c */ + #line 873 "parser.y" +- { yyval.value = 3; } ++ { (yyval).value = 3; } + break; + + case 149: ++ ++/* Line 1806 of yacc.c */ + #line 874 "parser.y" +- { yyval.value = 4; } ++ { (yyval).value = 4; } + break; + + case 150: ++ ++/* Line 1806 of yacc.c */ + #line 875 "parser.y" +- { yyval.value = 5; } ++ { (yyval).value = 5; } + break; + + case 151: ++ ++/* Line 1806 of yacc.c */ + #line 876 "parser.y" +- { yyval.value = 6; } ++ { (yyval).value = 6; } + break; + + case 152: ++ ++/* Line 1806 of yacc.c */ + #line 877 "parser.y" +- { yyval.value = 7; } ++ { (yyval).value = 7; } + break; + + case 153: ++ ++/* Line 1806 of yacc.c */ + #line 880 "parser.y" +- { yyval.value = 0; } ++ { (yyval).value = 0; } + break; + + case 154: ++ ++/* Line 1806 of yacc.c */ + #line 881 "parser.y" +- { yyval.value = 1; } ++ { (yyval).value = 1; } + break; + + case 155: ++ ++/* Line 1806 of yacc.c */ + #line 883 "parser.y" +- { yyval.value = 0; ++ { (yyval).value = 0; + warn("Illegal indirect register: @r2"); } + break; + + case 156: ++ ++/* Line 1806 of yacc.c */ + #line 886 "parser.y" +- { yyval.value = 0; ++ { (yyval).value = 0; + warn("Illegal indirect register: @r3"); } + break; + + case 157: ++ ++/* Line 1806 of yacc.c */ + #line 889 "parser.y" +- { yyval.value = 0; ++ { (yyval).value = 0; + warn("Illegal indirect register: @r4"); } + break; + + case 158: ++ ++/* Line 1806 of yacc.c */ + #line 892 "parser.y" +- { yyval.value = 0; ++ { (yyval).value = 0; + warn("Illegal indirect register: @r5"); } + break; + + case 159: ++ ++/* Line 1806 of yacc.c */ + #line 895 "parser.y" +- { yyval.value = 0; ++ { (yyval).value = 0; + warn("Illegal indirect register: @r6"); } + break; + + case 160: ++ ++/* Line 1806 of yacc.c */ + #line 898 "parser.y" +- { yyval.value = 0; ++ { (yyval).value = 0; + warn("Illegal indirect register: @r7"); } + break; + + case 161: ++ ++/* Line 1806 of yacc.c */ + #line 903 "parser.y" + { + if( pass2 ) { +- if( !isbit8(yyvsp[0].val.v) ) ++ if( !isbit8((yyvsp[(1) - (1)]).val.v) ) + warn("Expression greater than 8-bits"); + } +- yyval.value = yyvsp[0].val.v; ++ (yyval).value = (yyvsp[(1) - (1)]).val.v; + } + break; + + case 162: ++ ++/* Line 1806 of yacc.c */ + #line 913 "parser.y" + { + if( pass2 ) { +- if( !isbit16(yyvsp[0].val.v) ) ++ if( !isbit16((yyvsp[(1) - (1)]).val.v) ) + warn("Expression greater than 16-bits"); + } +- yyval.value = yyvsp[0].val.v; ++ (yyval).value = (yyvsp[(1) - (1)]).val.v; + } + break; + + case 163: ++ ++/* Line 1806 of yacc.c */ + #line 923 "parser.y" + { + if( pass2 ) { +- if( !isbit16(yyvsp[0].val.v) ) ++ if( !isbit16((yyvsp[(1) - (1)]).val.v) ) + warn("Address greater than 16-bits"); +- if( (yyvsp[0].val.v & size11) != ((lc+2) & size11) ) ++ if( ((yyvsp[(1) - (1)]).val.v & size11) != ((lc+2) & size11) ) + warn("Address outside current 2K page"); + } +- set_md(yyval.mode,0); +- set_ov(yyval.mode, (yyvsp[0].val.v&0x0700)>>3 ); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,yyvsp[0].val.v&0x00ff); ++ set_md((yyval).mode,0); ++ set_ov((yyval).mode, ((yyvsp[(1) - (1)]).val.v&0x0700)>>3 ); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,(yyvsp[(1) - (1)]).val.v&0x00ff); + } + break; + + case 164: ++ ++/* Line 1806 of yacc.c */ + #line 938 "parser.y" + { + if( pass2 ) { +- if( !isbit16(yyvsp[0].val.v) ) ++ if( !isbit16((yyvsp[(1) - (1)]).val.v) ) + warn("Address greater than 16-bits"); + } +- set_md(yyval.mode,0); +- set_ov(yyval.mode, 0 ); +- set_sz(yyval.mode,2); +- set_b1(yyval.mode, (yyvsp[0].val.v & 0xff00 ) >> 8 ); +- set_b2(yyval.mode, (yyvsp[0].val.v & 0x00ff ) ); ++ set_md((yyval).mode,0); ++ set_ov((yyval).mode, 0 ); ++ set_sz((yyval).mode,2); ++ set_b1((yyval).mode, ((yyvsp[(1) - (1)]).val.v & 0xff00 ) >> 8 ); ++ set_b2((yyval).mode, ((yyvsp[(1) - (1)]).val.v & 0x00ff ) ); + } + break; + + case 165: ++ ++/* Line 1806 of yacc.c */ + #line 952 "parser.y" + { + long offset=0; + if( pass2 ) { +- offset = yyvsp[0].val.v - (lc+2); ++ offset = (yyvsp[(1) - (1)]).val.v - (lc+2); + if( offset>127 || offset<-128 ) + warn("Relative offset exceeds -128 / +127"); + } +- set_md(yyval.mode,0); +- set_ov(yyval.mode,0); +- set_sz(yyval.mode,1); +- set_b1(yyval.mode,offset); ++ set_md((yyval).mode,0); ++ set_ov((yyval).mode,0); ++ set_sz((yyval).mode,1); ++ set_b1((yyval).mode,offset); + + } + break; + + +- } +- +-/* Line 1010 of yacc.c. */ +-#line 2717 "y.tab.c" +- +- yyvsp -= yylen; +- yyssp -= yylen; +- + ++/* Line 1806 of yacc.c */ ++#line 3408 "y.tab.c" ++ default: break; ++ } ++ /* User semantic actions sometimes alter yychar, and that requires ++ that yytoken be updated with the new translation. We take the ++ approach of translating immediately before every use of yytoken. ++ One alternative is translating here after every semantic action, ++ but that translation would be missed if the semantic action invokes ++ YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or ++ if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an ++ incorrect destructor might then be invoked immediately. In the ++ case of YYERROR or YYBACKUP, subsequent parser actions might lead ++ to an incorrect destructor call or verbose syntax error message ++ before the lookahead is translated. */ ++ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); ++ ++ YYPOPSTACK (yylen); ++ yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + +- + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ +@@ -2743,70 +3445,48 @@ yyreduce: + | yyerrlab -- here on detecting error | + `------------------------------------*/ + yyerrlab: ++ /* Make sure we have latest lookahead translation. See comments at ++ user semantic actions for why this is necessary. */ ++ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ++ + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +-#if YYERROR_VERBOSE +- yyn = yypact[yystate]; +- +- if (YYPACT_NINF < yyn && yyn < YYLAST) +- { +- YYSIZE_T yysize = 0; +- int yytype = YYTRANSLATE (yychar); +- const char* yyprefix; +- char *yymsg; +- int yyx; +- +- /* Start YYX at -YYN if negative to avoid negative indexes in +- YYCHECK. */ +- int yyxbegin = yyn < 0 ? -yyn : 0; +- +- /* Stay within bounds of both yycheck and yytname. */ +- int yychecklim = YYLAST - yyn; +- int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; +- int yycount = 0; +- +- yyprefix = ", expecting "; +- for (yyx = yyxbegin; yyx < yyxend; ++yyx) +- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) +- { +- yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); +- yycount += 1; +- if (yycount == 5) +- { +- yysize = 0; +- break; +- } +- } +- yysize += (sizeof ("syntax error, unexpected ") +- + yystrlen (yytname[yytype])); +- yymsg = (char *) YYSTACK_ALLOC (yysize); +- if (yymsg != 0) +- { +- char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); +- yyp = yystpcpy (yyp, yytname[yytype]); +- +- if (yycount < 5) +- { +- yyprefix = ", expecting "; +- for (yyx = yyxbegin; yyx < yyxend; ++yyx) +- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) +- { +- yyp = yystpcpy (yyp, yyprefix); +- yyp = yystpcpy (yyp, yytname[yyx]); +- yyprefix = " or "; +- } +- } +- yyerror (yymsg); +- YYSTACK_FREE (yymsg); +- } +- else +- yyerror ("syntax error; also virtual memory exhausted"); +- } +- else +-#endif /* YYERROR_VERBOSE */ +- yyerror ("syntax error"); ++#if ! YYERROR_VERBOSE ++ yyerror (YY_("syntax error")); ++#else ++# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ ++ yyssp, yytoken) ++ { ++ char const *yymsgp = YY_("syntax error"); ++ int yysyntax_error_status; ++ yysyntax_error_status = YYSYNTAX_ERROR; ++ if (yysyntax_error_status == 0) ++ yymsgp = yymsg; ++ else if (yysyntax_error_status == 1) ++ { ++ if (yymsg != yymsgbuf) ++ YYSTACK_FREE (yymsg); ++ yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); ++ if (!yymsg) ++ { ++ yymsg = yymsgbuf; ++ yymsg_alloc = sizeof yymsgbuf; ++ yysyntax_error_status = 2; ++ } ++ else ++ { ++ yysyntax_error_status = YYSYNTAX_ERROR; ++ yymsgp = yymsg; ++ } ++ } ++ yyerror (yymsgp); ++ if (yysyntax_error_status == 2) ++ goto yyexhaustedlab; ++ } ++# undef YYSYNTAX_ERROR ++#endif + } + + +@@ -2817,25 +3497,16 @@ yyerrlab: + error, discard it. */ + + if (yychar <= YYEOF) +- { +- /* If at end of input, pop the error token, +- then the rest of the stack, then return failure. */ ++ { ++ /* Return failure if at end of input. */ + if (yychar == YYEOF) +- for (;;) +- { +- YYPOPSTACK; +- if (yyssp == yyss) +- YYABORT; +- YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); +- yydestruct (yystos[*yyssp], yyvsp); +- } +- } ++ YYABORT; ++ } + else + { +- YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); +- yydestruct (yytoken, &yylval); ++ yydestruct ("Error: discarding", ++ yytoken, &yylval); + yychar = YYEMPTY; +- + } + } + +@@ -2849,15 +3520,17 @@ yyerrlab: + `---------------------------------------------------*/ + yyerrorlab: + +-#ifdef __GNUC__ +- /* Pacify GCC when the user code never invokes YYERROR and the label +- yyerrorlab therefore never appears in user code. */ +- if (0) ++ /* Pacify compilers like GCC when the user code never invokes ++ YYERROR and the label yyerrorlab therefore never appears in user ++ code. */ ++ if (/*CONSTCOND*/ 0) + goto yyerrorlab; +-#endif + +- yyvsp -= yylen; +- yyssp -= yylen; ++ /* Do not reclaim the symbols of the rule which action triggered ++ this YYERROR. */ ++ YYPOPSTACK (yylen); ++ yylen = 0; ++ YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + +@@ -2871,7 +3544,7 @@ yyerrlab1: + for (;;) + { + yyn = yypact[yystate]; +- if (yyn != YYPACT_NINF) ++ if (!yypact_value_is_default (yyn)) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) +@@ -2886,21 +3559,20 @@ yyerrlab1: + if (yyssp == yyss) + YYABORT; + +- YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); +- yydestruct (yystos[yystate], yyvsp); +- YYPOPSTACK; ++ ++ yydestruct ("Error: popping", ++ yystos[yystate], yyvsp); ++ YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + +- if (yyn == YYFINAL) +- YYACCEPT; +- +- YYDPRINTF ((stderr, "Shifting error token, ")); +- + *++yyvsp = yylval; + + ++ /* Shift the error token. */ ++ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); ++ + yystate = yyn; + goto yynewstate; + +@@ -2919,25 +3591,50 @@ yyabortlab: + yyresult = 1; + goto yyreturn; + +-#ifndef yyoverflow +-/*----------------------------------------------. +-| yyoverflowlab -- parser overflow comes here. | +-`----------------------------------------------*/ +-yyoverflowlab: +- yyerror ("parser stack overflow"); ++#if !defined(yyoverflow) || YYERROR_VERBOSE ++/*-------------------------------------------------. ++| yyexhaustedlab -- memory exhaustion comes here. | ++`-------------------------------------------------*/ ++yyexhaustedlab: ++ yyerror (YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ + #endif + + yyreturn: ++ if (yychar != YYEMPTY) ++ { ++ /* Make sure we have latest lookahead translation. See comments at ++ user semantic actions for why this is necessary. */ ++ yytoken = YYTRANSLATE (yychar); ++ yydestruct ("Cleanup: discarding lookahead", ++ yytoken, &yylval); ++ } ++ /* Do not reclaim the symbols of the rule which action triggered ++ this YYABORT or YYACCEPT. */ ++ YYPOPSTACK (yylen); ++ YY_STACK_PRINT (yyss, yyssp); ++ while (yyssp != yyss) ++ { ++ yydestruct ("Cleanup: popping", ++ yystos[*yyssp], yyvsp); ++ YYPOPSTACK (1); ++ } + #ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); + #endif +- return yyresult; ++#if YYERROR_VERBOSE ++ if (yymsg != yymsgbuf) ++ YYSTACK_FREE (yymsg); ++#endif ++ /* Make sure YYID is used. */ ++ return YYID (yyresult); + } + + ++ ++/* Line 2067 of yacc.c */ + #line 967 "parser.y" + + +@@ -2991,13 +3688,13 @@ int makeop(struct opcode * op, struct mode *m, int add) + * + */ + +-#define indx(a) ( (a)/(sizeof(long)*8) ) +-#define bit(a) ( 1 << ((a)%(sizeof(long)*8)) ) ++#define indx(a) ( (a)/(32) ) ++#define bit(a) ( 1 << ((a)%(32)) ) + + #define getloc(a) (regions[indx(a)] & bit(a)) + #define setloc(a) (regions[indx(a)] |= bit(a)) + +-static unsigned long regions[ 0x10000/(sizeof(long)*8) ]; ++static unsigned long regions[ 0x10000/(32) ]; + + void inclc(int i) + { +@@ -3101,4 +3798,3 @@ void genword(unsigned long w) + } + + +- -- 2.30.2