git.gag.com Git - debian/as31/blob - debian/patches/regenerate_parser.c

   1 diff --git a/as31/parser.c b/as31/parser.c
   2 index dd388a9..53a9c8f 100644
   3 --- a/as31/parser.c
   4 +++ b/as31/parser.c
   5 @@ -1,30 +1,37 @@
   6 -/* A Bison parser, made by GNU Bison 1.875d.  */
   7 +/* A Bison parser, made by GNU Bison 2.5.  */
   8
   9 -/* Skeleton parser for Yacc-like parsing with Bison,
  10 -   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
  11 -
  12 -   This program is free software; you can redistribute it and/or modify
  13 +/* Bison implementation for Yacc-like parsers in C
  14 +
  15 +      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
  16 +
  17 +   This program is free software: you can redistribute it and/or modify
  18     it under the terms of the GNU General Public License as published by
  19 -   the Free Software Foundation; either version 2, or (at your option)
  20 -   any later version.
  21 -
  22 +   the Free Software Foundation, either version 3 of the License, or
  23 +   (at your option) any later version.
  24 +
  25     This program is distributed in the hope that it will be useful,
  26     but WITHOUT ANY WARRANTY; without even the implied warranty of
  27     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28     GNU General Public License for more details.
  29 -
  30 +
  31     You should have received a copy of the GNU General Public License
  32 -   along with this program; if not, write to the Free Software
  33 -   Foundation, Inc., 59 Temple Place - Suite 330,
  34 -   Boston, MA 02111-1307, USA.  */
  35 -
  36 -/* As a special exception, when this file is copied by Bison into a
  37 -   Bison output file, you may use that output file without restriction.
  38 -   This special exception was added by the Free Software Foundation
  39 -   in version 1.24 of Bison.  */
  40 -
  41 -/* Written by Richard Stallman by simplifying the original so called
  42 -   ``semantic'' parser.  */
  43 +   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  44 +
  45 +/* As a special exception, you may create a larger work that contains
  46 +   part or all of the Bison parser skeleton and distribute that work
  47 +   under terms of your choice, so long as that work isn't itself a
  48 +   parser generator using the skeleton or a modified version thereof
  49 +   as a parser skeleton.  Alternatively, if you modify or redistribute
  50 +   the parser skeleton itself, you may (at your option) remove this
  51 +   special exception, which will cause the skeleton and the resulting
  52 +   Bison output files to be licensed under the GNU General Public
  53 +   License without this special exception.
  54 +
  55 +   This special exception was added by the Free Software Foundation in
  56 +   version 2.2 of Bison.  */
  57 +
  58 +/* C LALR(1) parser skeleton written by Richard Stallman, by
  59 +   simplifying the original so-called "semantic" parser.  */
  60
  61  /* All symbols defined below should begin with yy or YY, to avoid
  62     infringing on user name space.  This should be done even for local
  63 @@ -36,17 +43,80 @@
  64  /* Identify Bison output.  */
  65  #define YYBISON 1
  66
  67 +/* Bison version.  */
  68 +#define YYBISON_VERSION "2.5"
  69 +
  70  /* Skeleton name.  */
  71  #define YYSKELETON_NAME "yacc.c"
  72
  73  /* Pure parsers.  */
  74  #define YYPURE 0
  75
  76 +/* Push parsers.  */
  77 +#define YYPUSH 0
  78 +
  79 +/* Pull parsers.  */
  80 +#define YYPULL 1
  81 +
  82  /* Using locations.  */
  83  #define YYLSP_NEEDED 0
  84
  85
  86
  87 +/* Copy the first part of user declarations.  */
  88 +
  89 +/* Line 268 of yacc.c  */
  90 +#line 21 "parser.y"
  91 +
  92 +
  93 +#include <stdio.h>
  94 +#include <stdlib.h>
  95 +
  96 +#define NOPE
  97 +#include "as31.h"
  98 +#undef NOPE
  99 +
 100 +#define YYSTYPE union ystack
 101 +
 102 +static unsigned char bytebuf[1024];            /* used by dumplist() */
 103 +static int bytecount;
 104 +
 105 +
 106 +void yyerror(const char *s);
 107 +int makeop(struct opcode * op, struct mode *m, int add);
 108 +void inclc(int i);
 109 +char *padline(char *line);
 110 +void dumplist(char *txt, int show);
 111 +void genbyte(int b);
 112 +void genstr(const char *s);
 113 +void genword(unsigned long w);
 114 +
 115 +/* ------------------------ G R A M M E R ----------------------------- */
 116 +
 117 +
 118 +
 119 +/* Line 268 of yacc.c  */
 120 +#line 100 "y.tab.c"
 121 +
 122 +/* Enabling traces.  */
 123 +#ifndef YYDEBUG
 124 +# define YYDEBUG 0
 125 +#endif
 126 +
 127 +/* Enabling verbose error messages.  */
 128 +#ifdef YYERROR_VERBOSE
 129 +# undef YYERROR_VERBOSE
 130 +# define YYERROR_VERBOSE 1
 131 +#else
 132 +# define YYERROR_VERBOSE 0
 133 +#endif
 134 +
 135 +/* Enabling the token table.  */
 136 +#ifndef YYTOKEN_TABLE
 137 +# define YYTOKEN_TABLE 0
 138 +#endif
 139 +
 140 +
 141  /* Tokens.  */
 142  #ifndef YYTOKENTYPE
 143  # define YYTOKENTYPE
 144 @@ -123,6 +193,7 @@
 145       SYMBOL = 325
 146     };
 147  #endif
 148 +/* Tokens.  */
 149  #define STRING 258
 150  #define D_ORG 259
 151  #define D_BYTE 260
 152 @@ -195,113 +266,184 @@
 153
 154
 155
 156 -/* Copy the first part of user declarations.  */
 157 -#line 21 "parser.y"
 158 -
 159 -
 160 -#include <stdio.h>
 161 -#include <stdlib.h>
 162 -
 163 -#define NOPE
 164 -#include "as31.h"
 165 -#undef NOPE
 166 -
 167 -#define YYSTYPE union ystack
 168 -
 169 -static unsigned char bytebuf[1024];            /* used by dumplist() */
 170 -static int bytecount;
 171 +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 172 +typedef int YYSTYPE;
 173 +# define YYSTYPE_IS_TRIVIAL 1
 174 +# define yystype YYSTYPE /* obsolescent; will be withdrawn */
 175 +# define YYSTYPE_IS_DECLARED 1
 176 +#endif
 177
 178
 179 -void yyerror(const char *s);
 180 -int makeop(struct opcode * op, struct mode *m, int add);
 181 -void inclc(int i);
 182 -char *padline(char *line);
 183 -void dumplist(char *txt, int show);
 184 -void genbyte(int b);
 185 -void genstr(const char *s);
 186 -void genword(unsigned long w);
 187 +/* Copy the second part of user declarations.  */
 188
 189 -/* ------------------------ G R A M M E R ----------------------------- */
 190
 191 +/* Line 343 of yacc.c  */
 192 +#line 282 "y.tab.c"
 193
 194 +#ifdef short
 195 +# undef short
 196 +#endif
 197
 198 -/* Enabling traces.  */
 199 -#ifndef YYDEBUG
 200 -# define YYDEBUG 0
 201 +#ifdef YYTYPE_UINT8
 202 +typedef YYTYPE_UINT8 yytype_uint8;
 203 +#else
 204 +typedef unsigned char yytype_uint8;
 205  #endif
 206
 207 -/* Enabling verbose error messages.  */
 208 -#ifdef YYERROR_VERBOSE
 209 -# undef YYERROR_VERBOSE
 210 -# define YYERROR_VERBOSE 1
 211 +#ifdef YYTYPE_INT8
 212 +typedef YYTYPE_INT8 yytype_int8;
 213 +#elif (defined __STDC__ || defined __C99__FUNC__ \
 214 +     || defined __cplusplus || defined _MSC_VER)
 215 +typedef signed char yytype_int8;
 216  #else
 217 -# define YYERROR_VERBOSE 0
 218 +typedef short int yytype_int8;
 219  #endif
 220
 221 -#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
 222 -typedef int YYSTYPE;
 223 -# define yystype YYSTYPE /* obsolescent; will be withdrawn */
 224 -# define YYSTYPE_IS_DECLARED 1
 225 -# define YYSTYPE_IS_TRIVIAL 1
 226 +#ifdef YYTYPE_UINT16
 227 +typedef YYTYPE_UINT16 yytype_uint16;
 228 +#else
 229 +typedef unsigned short int yytype_uint16;
 230  #endif
 231
 232 +#ifdef YYTYPE_INT16
 233 +typedef YYTYPE_INT16 yytype_int16;
 234 +#else
 235 +typedef short int yytype_int16;
 236 +#endif
 237
 238 +#ifndef YYSIZE_T
 239 +# ifdef __SIZE_TYPE__
 240 +#  define YYSIZE_T __SIZE_TYPE__
 241 +# elif defined size_t
 242 +#  define YYSIZE_T size_t
 243 +# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 244 +     || defined __cplusplus || defined _MSC_VER)
 245 +#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 246 +#  define YYSIZE_T size_t
 247 +# else
 248 +#  define YYSIZE_T unsigned int
 249 +# endif
 250 +#endif
 251
 252 -/* Copy the second part of user declarations.  */
 253 +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 254
 255 +#ifndef YY_
 256 +# if defined YYENABLE_NLS && YYENABLE_NLS
 257 +#  if ENABLE_NLS
 258 +#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 259 +#   define YY_(msgid) dgettext ("bison-runtime", msgid)
 260 +#  endif
 261 +# endif
 262 +# ifndef YY_
 263 +#  define YY_(msgid) msgid
 264 +# endif
 265 +#endif
 266
 267 -/* Line 214 of yacc.c.  */
 268 -#line 255 "y.tab.c"
 269 +/* Suppress unused-variable warnings by "using" E.  */
 270 +#if ! defined lint || defined __GNUC__
 271 +# define YYUSE(e) ((void) (e))
 272 +#else
 273 +# define YYUSE(e) /* empty */
 274 +#endif
 275
 276 -#if ! defined (yyoverflow) || YYERROR_VERBOSE
 277 +/* Identity function, used to suppress warnings about constant conditions.  */
 278 +#ifndef lint
 279 +# define YYID(n) (n)
 280 +#else
 281 +#if (defined __STDC__ || defined __C99__FUNC__ \
 282 +     || defined __cplusplus || defined _MSC_VER)
 283 +static int
 284 +YYID (int yyi)
 285 +#else
 286 +static int
 287 +YYID (yyi)
 288 +    int yyi;
 289 +#endif
 290 +{
 291 +  return yyi;
 292 +}
 293 +#endif
 294
 295 -# ifndef YYFREE
 296 -#  define YYFREE free
 297 -# endif
 298 -# ifndef YYMALLOC
 299 -#  define YYMALLOC malloc
 300 -# endif
 301 +#if ! defined yyoverflow || YYERROR_VERBOSE
 302
 303  /* The parser invokes alloca or malloc; define the necessary symbols.  */
 304
 305  # ifdef YYSTACK_USE_ALLOCA
 306  #  if YYSTACK_USE_ALLOCA
 307 -#   define YYSTACK_ALLOC alloca
 308 -#  endif
 309 -# else
 310 -#  if defined (alloca) || defined (_ALLOCA_H)
 311 -#   define YYSTACK_ALLOC alloca
 312 -#  else
 313  #   ifdef __GNUC__
 314  #    define YYSTACK_ALLOC __builtin_alloca
 315 +#   elif defined __BUILTIN_VA_ARG_INCR
 316 +#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 317 +#   elif defined _AIX
 318 +#    define YYSTACK_ALLOC __alloca
 319 +#   elif defined _MSC_VER
 320 +#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 321 +#    define alloca _alloca
 322 +#   else
 323 +#    define YYSTACK_ALLOC alloca
 324 +#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
 325 +     || defined __cplusplus || defined _MSC_VER)
 326 +#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 327 +#     ifndef EXIT_SUCCESS
 328 +#      define EXIT_SUCCESS 0
 329 +#     endif
 330 +#    endif
 331  #   endif
 332  #  endif
 333  # endif
 334
 335  # ifdef YYSTACK_ALLOC
 336 -   /* Pacify GCC's `empty if-body' warning. */
 337 -#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 338 -# else
 339 -#  if defined (__STDC__) || defined (__cplusplus)
 340 -#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 341 -#   define YYSIZE_T size_t
 342 +   /* Pacify GCC's `empty if-body' warning.  */
 343 +#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 344 +#  ifndef YYSTACK_ALLOC_MAXIMUM
 345 +    /* The OS might guarantee only one guard page at the bottom of the stack,
 346 +       and a page size can be as small as 4096 bytes.  So we cannot safely
 347 +       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 348 +       to allow for a few compiler-allocated temporary stack slots.  */
 349 +#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 350  #  endif
 351 +# else
 352  #  define YYSTACK_ALLOC YYMALLOC
 353  #  define YYSTACK_FREE YYFREE
 354 +#  ifndef YYSTACK_ALLOC_MAXIMUM
 355 +#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 356 +#  endif
 357 +#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
 358 +       && ! ((defined YYMALLOC || defined malloc) \
 359 +            && (defined YYFREE || defined free)))
 360 +#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 361 +#   ifndef EXIT_SUCCESS
 362 +#    define EXIT_SUCCESS 0
 363 +#   endif
 364 +#  endif
 365 +#  ifndef YYMALLOC
 366 +#   define YYMALLOC malloc
 367 +#   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
 368 +     || defined __cplusplus || defined _MSC_VER)
 369 +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 370 +#   endif
 371 +#  endif
 372 +#  ifndef YYFREE
 373 +#   define YYFREE free
 374 +#   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
 375 +     || defined __cplusplus || defined _MSC_VER)
 376 +void free (void *); /* INFRINGES ON USER NAME SPACE */
 377 +#   endif
 378 +#  endif
 379  # endif
 380 -#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
 381 +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 382
 383
 384 -#if (! defined (yyoverflow) \
 385 -     && (! defined (__cplusplus) \
 386 -        || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
 387 +#if (! defined yyoverflow \
 388 +     && (! defined __cplusplus \
 389 +        || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 390
 391  /* A type that is properly aligned for any stack member.  */
 392  union yyalloc
 393  {
 394 -  short int yyss;
 395 -  YYSTYPE yyvs;
 396 -  };
 397 +  yytype_int16 yyss_alloc;
 398 +  YYSTYPE yyvs_alloc;
 399 +};
 400
 401  /* The size of the maximum gap between one aligned stack and the next.  */
 402  # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 403 @@ -309,74 +451,72 @@ union yyalloc
 404  /* The size of an array large to enough to hold all stacks, each with
 405     N elements.  */
 406  # define YYSTACK_BYTES(N) \
 407 -     ((N) * (sizeof (short int) + sizeof (YYSTYPE))                    \
 408 +     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 409        + YYSTACK_GAP_MAXIMUM)
 410
 411 -/* Copy COUNT objects from FROM to TO.  The source and destination do
 412 -   not overlap.  */
 413 -# ifndef YYCOPY
 414 -#  if defined (__GNUC__) && 1 < __GNUC__
 415 -#   define YYCOPY(To, From, Count) \
 416 -      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 417 -#  else
 418 -#   define YYCOPY(To, From, Count)             \
 419 -      do                                       \
 420 -       {                                       \
 421 -         register YYSIZE_T yyi;                \
 422 -         for (yyi = 0; yyi < (Count); yyi++)   \
 423 -           (To)[yyi] = (From)[yyi];            \
 424 -       }                                       \
 425 -      while (0)
 426 -#  endif
 427 -# endif
 428 +# define YYCOPY_NEEDED 1
 429
 430  /* Relocate STACK from its old location to the new one.  The
 431     local variables YYSIZE and YYSTACKSIZE give the old and new number of
 432     elements in the stack, and YYPTR gives the new location of the
 433     stack.  Advance YYPTR to a properly aligned location for the next
 434     stack.  */
 435 -# define YYSTACK_RELOCATE(Stack)                                       \
 436 +# define YYSTACK_RELOCATE(Stack_alloc, Stack)                          \
 437      do                                                                 \
 438        {                                                                        \
 439         YYSIZE_T yynewbytes;                                            \
 440 -       YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 441 -       Stack = &yyptr->Stack;                                          \
 442 +       YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
 443 +       Stack = &yyptr->Stack_alloc;                                    \
 444         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 445         yyptr += yynewbytes / sizeof (*yyptr);                          \
 446        }                                                                        \
 447 -    while (0)
 448 +    while (YYID (0))
 449
 450  #endif
 451
 452 -#if defined (__STDC__) || defined (__cplusplus)
 453 -   typedef signed char yysigned_char;
 454 -#else
 455 -   typedef short int yysigned_char;
 456 -#endif
 457 +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
 458 +/* Copy COUNT objects from FROM to TO.  The source and destination do
 459 +   not overlap.  */
 460 +# ifndef YYCOPY
 461 +#  if defined __GNUC__ && 1 < __GNUC__
 462 +#   define YYCOPY(To, From, Count) \
 463 +      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 464 +#  else
 465 +#   define YYCOPY(To, From, Count)             \
 466 +      do                                       \
 467 +       {                                       \
 468 +         YYSIZE_T yyi;                         \
 469 +         for (yyi = 0; yyi < (Count); yyi++)   \
 470 +           (To)[yyi] = (From)[yyi];            \
 471 +       }                                       \
 472 +      while (YYID (0))
 473 +#  endif
 474 +# endif
 475 +#endif /* !YYCOPY_NEEDED */
 476
 477 -/* YYFINAL -- State number of the termination state. */
 478 +/* YYFINAL -- State number of the termination state.  */
 479  #define YYFINAL  155
 480  /* YYLAST -- Last index in YYTABLE.  */
 481  #define YYLAST   599
 482
 483 -/* YYNTOKENS -- Number of terminals. */
 484 +/* YYNTOKENS -- Number of terminals.  */
 485  #define YYNTOKENS  89
 486 -/* YYNNTS -- Number of nonterminals. */
 487 +/* YYNNTS -- Number of nonterminals.  */
 488  #define YYNNTS  35
 489 -/* YYNRULES -- Number of rules. */
 490 +/* YYNRULES -- Number of rules.  */
 491  #define YYNRULES  165
 492 -/* YYNRULES -- Number of states. */
 493 +/* YYNRULES -- Number of states.  */
 494  #define YYNSTATES  316
 495
 496  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 497  #define YYUNDEFTOK  2
 498  #define YYMAXUTOK   325
 499
 500 -#define YYTRANSLATE(YYX)                                               \
 501 +#define YYTRANSLATE(YYX)                                               \
 502    ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 503
 504  /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 505 -static const unsigned char yytranslate[] =
 506 +static const yytype_uint8 yytranslate[] =
 507  {
 508         0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 509        81,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 510 @@ -416,7 +556,7 @@ static const unsigned char yytranslate[] =
 511  #if YYDEBUG
 512  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 513     YYRHS.  */
 514 -static const unsigned short int yyprhs[] =
 515 +static const yytype_uint16 yyprhs[] =
 516  {
 517         0,     0,     3,     5,     8,    10,    14,    16,    19,    22,
 518        24,    25,    29,    33,    37,    41,    45,    51,    57,    60,
 519 @@ -437,8 +577,8 @@ static const unsigned short int yyprhs[] =
 520       551,   553,   555,   557,   559,   561
 521  };
 522
 523 -/* YYRHS -- A `-1'-separated list of the rules' RHS. */
 524 -static const yysigned_char yyrhs[] =
 525 +/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 526 +static const yytype_int8 yyrhs[] =
 527  {
 528        90,     0,    -1,    91,    -1,    91,    92,    -1,    92,    -1,
 529        99,    80,    93,    -1,    93,    -1,    95,    81,    -1,   103,
 530 @@ -500,7 +640,7 @@ static const yysigned_char yyrhs[] =
 531  };
 532
 533  /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 534 -static const unsigned short int yyrline[] =
 535 +static const yytype_uint16 yyrline[] =
 536  {
 537         0,   126,   126,   131,   132,   135,   145,   148,   153,   159,
 538       164,   164,   183,   190,   191,   192,   195,   204,   210,   213,
 539 @@ -522,9 +662,9 @@ static const unsigned short int yyrline[] =
 540  };
 541  #endif
 542
 543 -#if YYDEBUG || YYERROR_VERBOSE
 544 -/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 545 -   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 546 +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 547 +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 548 +   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 549  static const char *const yytname[] =
 550  {
 551    "$end", "error", "$undefined", "STRING", "D_ORG", "D_BYTE", "D_WORD",
 552 @@ -537,7 +677,7 @@ static const char *const yytname[] =
 553    "R5", "R6", "R7", "VALUE", "SYMBOL", "'+'", "'-'", "'*'", "'/'", "'%'",
 554    "'|'", "'&'", "'>'", "'<'", "':'", "'\\n'", "'.'", "','", "'('", "')'",
 555    "'@'", "'#'", "'!'", "$accept", "program", "linelist", "line",
 556 -  "linerest", "@1", "directive", "defexpr", "flag", "flagv", "undefsym",
 557 +  "linerest", "$@1", "directive", "defexpr", "flag", "flagv", "undefsym",
 558    "blist", "wlist", "expr", "instr", "two_op1", "two_op2", "two_op3",
 559    "two_op4", "two_op5", "two_op6", "single_op1", "single_op2", "three_op1",
 560    "rel", "rel2", "bit", "bitv", "reg", "regi", "data8", "data16", "addr11",
 561 @@ -548,7 +688,7 @@ static const char *const yytname[] =
 562  # ifdef YYPRINT
 563  /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 564     token YYLEX-NUM.  */
 565 -static const unsigned short int yytoknum[] =
 566 +static const yytype_uint16 yytoknum[] =
 567  {
 568         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
 569       265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
 570 @@ -563,7 +703,7 @@ static const unsigned short int yytoknum[] =
 571  # endif
 572
 573  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 574 -static const unsigned char yyr1[] =
 575 +static const yytype_uint8 yyr1[] =
 576  {
 577         0,    89,    90,    91,    91,    92,    92,    93,    93,    93,
 578        94,    93,    95,    95,    95,    95,    95,    95,    95,    96,
 579 @@ -585,7 +725,7 @@ static const unsigned char yyr1[] =
 580  };
 581
 582  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 583 -static const unsigned char yyr2[] =
 584 +static const yytype_uint8 yyr2[] =
 585  {
 586         0,     2,     1,     2,     1,     3,     1,     2,     2,     1,
 587         0,     3,     3,     3,     3,     3,     5,     5,     2,     1,
 588 @@ -606,10 +746,10 @@ static const unsigned char yyr2[] =
 589         1,     1,     1,     1,     1,     1
 590  };
 591
 592 -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
 593 -   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 594 +/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
 595 +   Performed when YYTABLE doesn't specify something else to do.  Zero
 596     means the default is an error.  */
 597 -static const unsigned char yydefact[] =
 598 +static const yytype_uint8 yydefact[] =
 599  {
 600         0,    10,     0,     0,     0,     0,     0,     0,     0,     0,
 601         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 602 @@ -645,8 +785,8 @@ static const unsigned char yydefact[] =
 603       137,    97,    95,    98,    96,   138
 604  };
 605
 606 -/* YYDEFGOTO[NTERM-NUM]. */
 607 -static const short int yydefgoto[] =
 608 +/* YYDEFGOTO[NTERM-NUM].  */
 609 +static const yytype_int16 yydefgoto[] =
 610  {
 611        -1,    49,    50,    51,    52,    56,    53,   203,   297,   298,
 612        54,   206,   208,    69,    55,    65,    71,    72,   106,   101,
 613 @@ -657,7 +797,7 @@ static const short int yydefgoto[] =
 614  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 615     STATE-NUM.  */
 616  #define YYPACT_NINF -239
 617 -static const short int yypact[] =
 618 +static const yytype_int16 yypact[] =
 619  {
 620       370,  -239,   139,   -24,   -24,   139,   120,    70,    15,    15,
 621       -19,   470,   -12,   292,   441,    23,    23,   139,   -45,    23,
 622 @@ -694,7 +834,7 @@ static const short int yypact[] =
 623  };
 624
 625  /* YYPGOTO[NTERM-NUM].  */
 626 -static const short int yypgoto[] =
 627 +static const yytype_int16 yypgoto[] =
 628  {
 629      -239,  -239,  -239,   214,   107,  -239,  -239,   116,  -239,  -239,
 630       114,  -239,  -239,    -2,  -239,    21,    33,   238,    26,  -239,
 631 @@ -704,10 +844,9 @@ static const short int yypgoto[] =
 632
 633  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 634     positive, shift that token.  If negative, reduce the rule which
 635 -   number is the opposite.  If zero, do what YYDEFACT says.
 636 -   If YYTABLE_NINF, syntax error.  */
 637 +   number is the opposite.  If YYTABLE_NINF, syntax error.  */
 638  #define YYTABLE_NINF -3
 639 -static const short int yytable[] =
 640 +static const yytype_int16 yytable[] =
 641  {
 642        62,   107,   107,    62,   242,   107,    85,   205,   277,   232,
 643       197,   187,   102,   291,    99,   109,   103,    99,   109,   109,
 644 @@ -771,7 +910,13 @@ static const short int yytable[] =
 645       169,   170,   171,   165,   166,   167,   168,   169,   170,   171
 646  };
 647
 648 -static const short int yycheck[] =
 649 +#define yypact_value_is_default(yystate) \
 650 +  ((yystate) == (-239))
 651 +
 652 +#define yytable_value_is_error(yytable_value) \
 653 +  YYID (0)
 654 +
 655 +static const yytype_int16 yycheck[] =
 656  {
 657         2,    15,    16,     5,   190,    19,     7,     3,   246,    56,
 658        60,    96,    13,     3,    11,    17,    13,    14,    20,    21,
 659 @@ -837,7 +982,7 @@ static const short int yycheck[] =
 660
 661  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 662     symbol of state STATE-NUM.  */
 663 -static const unsigned char yystos[] =
 664 +static const yytype_uint8 yystos[] =
 665  {
 666         0,     1,    11,    12,    13,    14,    15,    16,    17,    18,
 667        19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
 668 @@ -873,22 +1018,6 @@ static const unsigned char yystos[] =
 669       113,    58,    59,    56,    56,   113
 670  };
 671
 672 -#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 673 -# define YYSIZE_T __SIZE_TYPE__
 674 -#endif
 675 -#if ! defined (YYSIZE_T) && defined (size_t)
 676 -# define YYSIZE_T size_t
 677 -#endif
 678 -#if ! defined (YYSIZE_T)
 679 -# if defined (__STDC__) || defined (__cplusplus)
 680 -#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 681 -#  define YYSIZE_T size_t
 682 -# endif
 683 -#endif
 684 -#if ! defined (YYSIZE_T)
 685 -# define YYSIZE_T unsigned int
 686 -#endif
 687 -
 688  #define yyerrok                (yyerrstatus = 0)
 689  #define yyclearin      (yychar = YYEMPTY)
 690  #define YYEMPTY                (-2)
 691 @@ -901,9 +1030,18 @@ static const unsigned char yystos[] =
 692
 693  /* Like YYERROR except do call yyerror.  This remains here temporarily
 694     to ease the transition to the new meaning of YYERROR, for GCC.
 695 -   Once GCC version 2 has supplanted version 1, this can go.  */
 696 +   Once GCC version 2 has supplanted version 1, this can go.  However,
 697 +   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
 698 +   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
 699 +   discussed.  */
 700
 701  #define YYFAIL         goto yyerrlab
 702 +#if defined YYFAIL
 703 +  /* This is here to suppress warnings from the GCC cpp's
 704 +     -Wunused-macros.  Normally we don't worry about that warning, but
 705 +     some users do, and we want to make it easy for users to remove
 706 +     YYFAIL uses, which will produce warnings from Bison 2.5.  */
 707 +#endif
 708
 709  #define YYRECOVERING()  (!!yyerrstatus)
 710
 711 @@ -913,31 +1051,54 @@ do                                                               \
 712      {                                                          \
 713        yychar = (Token);                                                \
 714        yylval = (Value);                                                \
 715 -      yytoken = YYTRANSLATE (yychar);                          \
 716 -      YYPOPSTACK;                                              \
 717 +      YYPOPSTACK (1);                                          \
 718        goto yybackup;                                           \
 719      }                                                          \
 720    else                                                         \
 721 -    {                                                          \
 722 -      yyerror ("syntax error: cannot back up");\
 723 +    {                                                          \
 724 +      yyerror (YY_("syntax error: cannot back up")); \
 725        YYERROR;                                                 \
 726      }                                                          \
 727 -while (0)
 728 +while (YYID (0))
 729 +
 730
 731  #define YYTERROR       1
 732  #define YYERRCODE      256
 733
 734 -/* YYLLOC_DEFAULT -- Compute the default location (before the actions
 735 -   are run).  */
 736
 737 +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 738 +   If N is 0, then set CURRENT to the empty location which ends
 739 +   the previous symbol: RHS[0] (always defined).  */
 740 +
 741 +#define YYRHSLOC(Rhs, K) ((Rhs)[K])
 742  #ifndef YYLLOC_DEFAULT
 743 -# define YYLLOC_DEFAULT(Current, Rhs, N)               \
 744 -   ((Current).first_line   = (Rhs)[1].first_line,      \
 745 -    (Current).first_column = (Rhs)[1].first_column,    \
 746 -    (Current).last_line    = (Rhs)[N].last_line,       \
 747 -    (Current).last_column  = (Rhs)[N].last_column)
 748 +# define YYLLOC_DEFAULT(Current, Rhs, N)                               \
 749 +    do                                                                 \
 750 +      if (YYID (N))                                                    \
 751 +       {                                                               \
 752 +         (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
 753 +         (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
 754 +         (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
 755 +         (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
 756 +       }                                                               \
 757 +      else                                                             \
 758 +       {                                                               \
 759 +         (Current).first_line   = (Current).last_line   =              \
 760 +           YYRHSLOC (Rhs, 0).last_line;                                \
 761 +         (Current).first_column = (Current).last_column =              \
 762 +           YYRHSLOC (Rhs, 0).last_column;                              \
 763 +       }                                                               \
 764 +    while (YYID (0))
 765 +#endif
 766 +
 767 +
 768 +/* This macro is provided for backward compatibility. */
 769 +
 770 +#ifndef YY_LOCATION_PRINT
 771 +# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 772  #endif
 773
 774 +
 775  /* YYLEX -- calling `yylex' with the right arguments.  */
 776
 777  #ifdef YYLEX_PARAM
 778 @@ -958,43 +1119,100 @@ while (0)
 779  do {                                           \
 780    if (yydebug)                                 \
 781      YYFPRINTF Args;                            \
 782 -} while (0)
 783 +} while (YYID (0))
 784
 785 -# define YYDSYMPRINT(Args)                     \
 786 -do {                                           \
 787 -  if (yydebug)                                 \
 788 -    yysymprint Args;                           \
 789 -} while (0)
 790 +# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                   \
 791 +do {                                                                     \
 792 +  if (yydebug)                                                           \
 793 +    {                                                                    \
 794 +      YYFPRINTF (stderr, "%s ", Title);                                          \
 795 +      yy_symbol_print (stderr,                                           \
 796 +                 Type, Value); \
 797 +      YYFPRINTF (stderr, "\n");                                                  \
 798 +    }                                                                    \
 799 +} while (YYID (0))
 800
 801 -# define YYDSYMPRINTF(Title, Token, Value, Location)           \
 802 -do {                                                           \
 803 -  if (yydebug)                                                 \
 804 -    {                                                          \
 805 -      YYFPRINTF (stderr, "%s ", Title);                                \
 806 -      yysymprint (stderr,                                      \
 807 -                  Token, Value);       \
 808 -      YYFPRINTF (stderr, "\n");                                        \
 809 -    }                                                          \
 810 -} while (0)
 811 +
 812 +/*--------------------------------.
 813 +| Print this symbol on YYOUTPUT.  |
 814 +`--------------------------------*/
 815 +
 816 +/*ARGSUSED*/
 817 +#if (defined __STDC__ || defined __C99__FUNC__ \
 818 +     || defined __cplusplus || defined _MSC_VER)
 819 +static void
 820 +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 821 +#else
 822 +static void
 823 +yy_symbol_value_print (yyoutput, yytype, yyvaluep)
 824 +    FILE *yyoutput;
 825 +    int yytype;
 826 +    YYSTYPE const * const yyvaluep;
 827 +#endif
 828 +{
 829 +  if (!yyvaluep)
 830 +    return;
 831 +# ifdef YYPRINT
 832 +  if (yytype < YYNTOKENS)
 833 +    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 834 +# else
 835 +  YYUSE (yyoutput);
 836 +# endif
 837 +  switch (yytype)
 838 +    {
 839 +      default:
 840 +       break;
 841 +    }
 842 +}
 843 +
 844 +
 845 +/*--------------------------------.
 846 +| Print this symbol on YYOUTPUT.  |
 847 +`--------------------------------*/
 848 +
 849 +#if (defined __STDC__ || defined __C99__FUNC__ \
 850 +     || defined __cplusplus || defined _MSC_VER)
 851 +static void
 852 +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 853 +#else
 854 +static void
 855 +yy_symbol_print (yyoutput, yytype, yyvaluep)
 856 +    FILE *yyoutput;
 857 +    int yytype;
 858 +    YYSTYPE const * const yyvaluep;
 859 +#endif
 860 +{
 861 +  if (yytype < YYNTOKENS)
 862 +    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 863 +  else
 864 +    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 865 +
 866 +  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
 867 +  YYFPRINTF (yyoutput, ")");
 868 +}
 869
 870  /*------------------------------------------------------------------.
 871  | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 872  | TOP (included).                                                   |
 873  `------------------------------------------------------------------*/
 874
 875 -#if defined (__STDC__) || defined (__cplusplus)
 876 +#if (defined __STDC__ || defined __C99__FUNC__ \
 877 +     || defined __cplusplus || defined _MSC_VER)
 878  static void
 879 -yy_stack_print (short int *bottom, short int *top)
 880 +yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
 881  #else
 882  static void
 883 -yy_stack_print (bottom, top)
 884 -    short int *bottom;
 885 -    short int *top;
 886 +yy_stack_print (yybottom, yytop)
 887 +    yytype_int16 *yybottom;
 888 +    yytype_int16 *yytop;
 889  #endif
 890  {
 891    YYFPRINTF (stderr, "Stack now");
 892 -  for (/* Nothing. */; bottom <= top; ++bottom)
 893 -    YYFPRINTF (stderr, " %d", *bottom);
 894 +  for (; yybottom <= yytop; yybottom++)
 895 +    {
 896 +      int yybot = *yybottom;
 897 +      YYFPRINTF (stderr, " %d", yybot);
 898 +    }
 899    YYFPRINTF (stderr, "\n");
 900  }
 901
 902 @@ -1002,45 +1220,52 @@ yy_stack_print (bottom, top)
 903  do {                                                           \
 904    if (yydebug)                                                 \
 905      yy_stack_print ((Bottom), (Top));                          \
 906 -} while (0)
 907 +} while (YYID (0))
 908
 909
 910  /*------------------------------------------------.
 911  | Report that the YYRULE is going to be reduced.  |
 912  `------------------------------------------------*/
 913
 914 -#if defined (__STDC__) || defined (__cplusplus)
 915 +#if (defined __STDC__ || defined __C99__FUNC__ \
 916 +     || defined __cplusplus || defined _MSC_VER)
 917  static void
 918 -yy_reduce_print (int yyrule)
 919 +yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
 920  #else
 921  static void
 922 -yy_reduce_print (yyrule)
 923 +yy_reduce_print (yyvsp, yyrule)
 924 +    YYSTYPE *yyvsp;
 925      int yyrule;
 926  #endif
 927  {
 928 +  int yynrhs = yyr2[yyrule];
 929    int yyi;
 930 -  unsigned int yylno = yyrline[yyrule];
 931 -  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
 932 -             yyrule - 1, yylno);
 933 -  /* Print the symbols being reduced, and their result.  */
 934 -  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
 935 -    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
 936 -  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
 937 +  unsigned long int yylno = yyrline[yyrule];
 938 +  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
 939 +            yyrule - 1, yylno);
 940 +  /* The symbols being reduced.  */
 941 +  for (yyi = 0; yyi < yynrhs; yyi++)
 942 +    {
 943 +      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
 944 +      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 945 +                      &(yyvsp[(yyi + 1) - (yynrhs)])
 946 +                                      );
 947 +      YYFPRINTF (stderr, "\n");
 948 +    }
 949  }
 950
 951  # define YY_REDUCE_PRINT(Rule)         \
 952  do {                                   \
 953    if (yydebug)                         \
 954 -    yy_reduce_print (Rule);            \
 955 -} while (0)
 956 +    yy_reduce_print (yyvsp, Rule); \
 957 +} while (YYID (0))
 958
 959  /* Nonzero means print parse trace.  It is left uninitialized so that
 960     multiple parsers can coexist.  */
 961  int yydebug;
 962  #else /* !YYDEBUG */
 963  # define YYDPRINTF(Args)
 964 -# define YYDSYMPRINT(Args)
 965 -# define YYDSYMPRINTF(Title, Token, Value, Location)
 966 +# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 967  # define YY_STACK_PRINT(Bottom, Top)
 968  # define YY_REDUCE_PRINT(Rule)
 969  #endif /* !YYDEBUG */
 970 @@ -1055,61 +1280,58 @@ int yydebug;
 971     if the built-in stack extension method is used).
 972
 973     Do not make this value too large; the results are undefined if
 974 -   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
 975 +   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
 976     evaluated with infinite-precision integer arithmetic.  */
 977
 978 -#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
 979 -# undef YYMAXDEPTH
 980 -#endif
 981 -
 982  #ifndef YYMAXDEPTH
 983  # define YYMAXDEPTH 10000
 984  #endif
 985
 986 -\f
 987
 988  #if YYERROR_VERBOSE
 989
 990  # ifndef yystrlen
 991 -#  if defined (__GLIBC__) && defined (_STRING_H)
 992 +#  if defined __GLIBC__ && defined _STRING_H
 993  #   define yystrlen strlen
 994  #  else
 995  /* Return the length of YYSTR.  */
 996 +#if (defined __STDC__ || defined __C99__FUNC__ \
 997 +     || defined __cplusplus || defined _MSC_VER)
 998  static YYSIZE_T
 999 -#   if defined (__STDC__) || defined (__cplusplus)
1000  yystrlen (const char *yystr)
1001 -#   else
1002 +#else
1003 +static YYSIZE_T
1004  yystrlen (yystr)
1005 -     const char *yystr;
1006 -#   endif
1007 +    const char *yystr;
1008 +#endif
1009  {
1010 -  register const char *yys = yystr;
1011 -
1012 -  while (*yys++ != '\0')
1013 +  YYSIZE_T yylen;
1014 +  for (yylen = 0; yystr[yylen]; yylen++)
1015      continue;
1016 -
1017 -  return yys - yystr - 1;
1018 +  return yylen;
1019  }
1020  #  endif
1021  # endif
1022
1023  # ifndef yystpcpy
1024 -#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
1025 +#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1026  #   define yystpcpy stpcpy
1027  #  else
1028  /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1029     YYDEST.  */
1030 +#if (defined __STDC__ || defined __C99__FUNC__ \
1031 +     || defined __cplusplus || defined _MSC_VER)
1032  static char *
1033 -#   if defined (__STDC__) || defined (__cplusplus)
1034  yystpcpy (char *yydest, const char *yysrc)
1035 -#   else
1036 +#else
1037 +static char *
1038  yystpcpy (yydest, yysrc)
1039 -     char *yydest;
1040 -     const char *yysrc;
1041 -#   endif
1042 +    char *yydest;
1043 +    const char *yysrc;
1044 +#endif
1045  {
1046 -  register char *yyd = yydest;
1047 -  register const char *yys = yysrc;
1048 +  char *yyd = yydest;
1049 +  const char *yys = yysrc;
1050
1051    while ((*yyd++ = *yys++) != '\0')
1052      continue;
1053 @@ -1119,84 +1341,232 @@ yystpcpy (yydest, yysrc)
1054  #  endif
1055  # endif
1056
1057 -#endif /* !YYERROR_VERBOSE */
1058 +# ifndef yytnamerr
1059 +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1060 +   quotes and backslashes, so that it's suitable for yyerror.  The
1061 +   heuristic is that double-quoting is unnecessary unless the string
1062 +   contains an apostrophe, a comma, or backslash (other than
1063 +   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1064 +   null, do not copy; instead, return the length of what the result
1065 +   would have been.  */
1066 +static YYSIZE_T
1067 +yytnamerr (char *yyres, const char *yystr)
1068 +{
1069 +  if (*yystr == '"')
1070 +    {
1071 +      YYSIZE_T yyn = 0;
1072 +      char const *yyp = yystr;
1073 +
1074 +      for (;;)
1075 +       switch (*++yyp)
1076 +         {
1077 +         case '\'':
1078 +         case ',':
1079 +           goto do_not_strip_quotes;
1080 +
1081 +         case '\\':
1082 +           if (*++yyp != '\\')
1083 +             goto do_not_strip_quotes;
1084 +           /* Fall through.  */
1085 +         default:
1086 +           if (yyres)
1087 +             yyres[yyn] = *yyp;
1088 +           yyn++;
1089 +           break;
1090 +
1091 +         case '"':
1092 +           if (yyres)
1093 +             yyres[yyn] = '\0';
1094 +           return yyn;
1095 +         }
1096 +    do_not_strip_quotes: ;
1097 +    }
1098
1099 -\f
1100 +  if (! yyres)
1101 +    return yystrlen (yystr);
1102
1103 -#if YYDEBUG
1104 -/*--------------------------------.
1105 -| Print this symbol on YYOUTPUT.  |
1106 -`--------------------------------*/
1107 +  return yystpcpy (yyres, yystr) - yyres;
1108 +}
1109 +# endif
1110
1111 -#if defined (__STDC__) || defined (__cplusplus)
1112 -static void
1113 -yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
1114 -#else
1115 -static void
1116 -yysymprint (yyoutput, yytype, yyvaluep)
1117 -    FILE *yyoutput;
1118 -    int yytype;
1119 -    YYSTYPE *yyvaluep;
1120 -#endif
1121 +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1122 +   about the unexpected token YYTOKEN for the state stack whose top is
1123 +   YYSSP.
1124 +
1125 +   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
1126 +   not large enough to hold the message.  In that case, also set
1127 +   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
1128 +   required number of bytes is too large to store.  */
1129 +static int
1130 +yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1131 +                yytype_int16 *yyssp, int yytoken)
1132  {
1133 -  /* Pacify ``unused variable'' warnings.  */
1134 -  (void) yyvaluep;
1135 +  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
1136 +  YYSIZE_T yysize = yysize0;
1137 +  YYSIZE_T yysize1;
1138 +  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1139 +  /* Internationalized format string. */
1140 +  const char *yyformat = 0;
1141 +  /* Arguments of yyformat. */
1142 +  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1143 +  /* Number of reported tokens (one for the "unexpected", one per
1144 +     "expected"). */
1145 +  int yycount = 0;
1146 +
1147 +  /* There are many possibilities here to consider:
1148 +     - Assume YYFAIL is not used.  It's too flawed to consider.  See
1149 +       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1150 +       for details.  YYERROR is fine as it does not invoke this
1151 +       function.
1152 +     - If this state is a consistent state with a default action, then
1153 +       the only way this function was invoked is if the default action
1154 +       is an error action.  In that case, don't check for expected
1155 +       tokens because there are none.
1156 +     - The only way there can be no lookahead present (in yychar) is if
1157 +       this state is a consistent state with a default action.  Thus,
1158 +       detecting the absence of a lookahead is sufficient to determine
1159 +       that there is no unexpected or expected token to report.  In that
1160 +       case, just report a simple "syntax error".
1161 +     - Don't assume there isn't a lookahead just because this state is a
1162 +       consistent state with a default action.  There might have been a
1163 +       previous inconsistent state, consistent state with a non-default
1164 +       action, or user semantic action that manipulated yychar.
1165 +     - Of course, the expected token list depends on states to have
1166 +       correct lookahead information, and it depends on the parser not
1167 +       to perform extra reductions after fetching a lookahead from the
1168 +       scanner and before detecting a syntax error.  Thus, state merging
1169 +       (from LALR or IELR) and default reductions corrupt the expected
1170 +       token list.  However, the list is correct for canonical LR with
1171 +       one exception: it will still contain any token that will not be
1172 +       accepted due to an error action in a later state.
1173 +  */
1174 +  if (yytoken != YYEMPTY)
1175 +    {
1176 +      int yyn = yypact[*yyssp];
1177 +      yyarg[yycount++] = yytname[yytoken];
1178 +      if (!yypact_value_is_default (yyn))
1179 +        {
1180 +          /* Start YYX at -YYN if negative to avoid negative indexes in
1181 +             YYCHECK.  In other words, skip the first -YYN actions for
1182 +             this state because they are default actions.  */
1183 +          int yyxbegin = yyn < 0 ? -yyn : 0;
1184 +          /* Stay within bounds of both yycheck and yytname.  */
1185 +          int yychecklim = YYLAST - yyn + 1;
1186 +          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1187 +          int yyx;
1188 +
1189 +          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1190 +            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1191 +                && !yytable_value_is_error (yytable[yyx + yyn]))
1192 +              {
1193 +                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1194 +                  {
1195 +                    yycount = 1;
1196 +                    yysize = yysize0;
1197 +                    break;
1198 +                  }
1199 +                yyarg[yycount++] = yytname[yyx];
1200 +                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1201 +                if (! (yysize <= yysize1
1202 +                       && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1203 +                  return 2;
1204 +                yysize = yysize1;
1205 +              }
1206 +        }
1207 +    }
1208
1209 -  if (yytype < YYNTOKENS)
1210 -    {
1211 -      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1212 -# ifdef YYPRINT
1213 -      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1214 -# endif
1215 +  switch (yycount)
1216 +    {
1217 +# define YYCASE_(N, S)                      \
1218 +      case N:                               \
1219 +        yyformat = S;                       \
1220 +      break
1221 +      YYCASE_(0, YY_("syntax error"));
1222 +      YYCASE_(1, YY_("syntax error, unexpected %s"));
1223 +      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1224 +      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1225 +      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1226 +      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1227 +# undef YYCASE_
1228      }
1229 -  else
1230 -    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1231
1232 -  switch (yytype)
1233 +  yysize1 = yysize + yystrlen (yyformat);
1234 +  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1235 +    return 2;
1236 +  yysize = yysize1;
1237 +
1238 +  if (*yymsg_alloc < yysize)
1239      {
1240 -      default:
1241 -        break;
1242 +      *yymsg_alloc = 2 * yysize;
1243 +      if (! (yysize <= *yymsg_alloc
1244 +             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1245 +        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1246 +      return 1;
1247      }
1248 -  YYFPRINTF (yyoutput, ")");
1249 +
1250 +  /* Avoid sprintf, as that infringes on the user's name space.
1251 +     Don't have undefined behavior even if the translation
1252 +     produced a string with the wrong number of "%s"s.  */
1253 +  {
1254 +    char *yyp = *yymsg;
1255 +    int yyi = 0;
1256 +    while ((*yyp = *yyformat) != '\0')
1257 +      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1258 +        {
1259 +          yyp += yytnamerr (yyp, yyarg[yyi++]);
1260 +          yyformat += 2;
1261 +        }
1262 +      else
1263 +        {
1264 +          yyp++;
1265 +          yyformat++;
1266 +        }
1267 +  }
1268 +  return 0;
1269  }
1270 +#endif /* YYERROR_VERBOSE */
1271
1272 -#endif /* ! YYDEBUG */
1273  /*-----------------------------------------------.
1274  | Release the memory associated to this symbol.  |
1275  `-----------------------------------------------*/
1276
1277 -#if defined (__STDC__) || defined (__cplusplus)
1278 +/*ARGSUSED*/
1279 +#if (defined __STDC__ || defined __C99__FUNC__ \
1280 +     || defined __cplusplus || defined _MSC_VER)
1281  static void
1282 -yydestruct (int yytype, YYSTYPE *yyvaluep)
1283 +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1284  #else
1285  static void
1286 -yydestruct (yytype, yyvaluep)
1287 +yydestruct (yymsg, yytype, yyvaluep)
1288 +    const char *yymsg;
1289      int yytype;
1290      YYSTYPE *yyvaluep;
1291  #endif
1292  {
1293 -  /* Pacify ``unused variable'' warnings.  */
1294 -  (void) yyvaluep;
1295 +  YYUSE (yyvaluep);
1296 +
1297 +  if (!yymsg)
1298 +    yymsg = "Deleting";
1299 +  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1300
1301    switch (yytype)
1302      {
1303
1304        default:
1305 -        break;
1306 +       break;
1307      }
1308  }
1309 -\f
1310
1311 -/* Prevent warnings from -Wmissing-prototypes.  */
1312
1313 +/* Prevent warnings from -Wmissing-prototypes.  */
1314  #ifdef YYPARSE_PARAM
1315 -# if defined (__STDC__) || defined (__cplusplus)
1316 +#if defined __STDC__ || defined __cplusplus
1317  int yyparse (void *YYPARSE_PARAM);
1318 -# else
1319 +#else
1320  int yyparse ();
1321 -# endif
1322 +#endif
1323  #else /* ! YYPARSE_PARAM */
1324 -#if defined (__STDC__) || defined (__cplusplus)
1325 +#if defined __STDC__ || defined __cplusplus
1326  int yyparse (void);
1327  #else
1328  int yyparse ();
1329 @@ -1204,7 +1574,6 @@ int yyparse ();
1330  #endif /* ! YYPARSE_PARAM */
1331
1332
1333 -
1334  /* The lookahead symbol.  */
1335  int yychar;
1336
1337 @@ -1215,20 +1584,23 @@ YYSTYPE yylval;
1338  int yynerrs;
1339
1340
1341 -
1342  /*----------.
1343  | yyparse.  |
1344  `----------*/
1345
1346  #ifdef YYPARSE_PARAM
1347 -# if defined (__STDC__) || defined (__cplusplus)
1348 -int yyparse (void *YYPARSE_PARAM)
1349 -# else
1350 -int yyparse (YYPARSE_PARAM)
1351 -  void *YYPARSE_PARAM;
1352 -# endif
1353 +#if (defined __STDC__ || defined __C99__FUNC__ \
1354 +     || defined __cplusplus || defined _MSC_VER)
1355 +int
1356 +yyparse (void *YYPARSE_PARAM)
1357 +#else
1358 +int
1359 +yyparse (YYPARSE_PARAM)
1360 +    void *YYPARSE_PARAM;
1361 +#endif
1362  #else /* ! YYPARSE_PARAM */
1363 -#if defined (__STDC__) || defined (__cplusplus)
1364 +#if (defined __STDC__ || defined __C99__FUNC__ \
1365 +     || defined __cplusplus || defined _MSC_VER)
1366  int
1367  yyparse (void)
1368  #else
1369 @@ -1238,64 +1610,69 @@ yyparse ()
1370  #endif
1371  #endif
1372  {
1373 -
1374 -  register int yystate;
1375 -  register int yyn;
1376 -  int yyresult;
1377 -  /* Number of tokens to shift before error messages enabled.  */
1378 -  int yyerrstatus;
1379 -  /* Lookahead token as an internal (translated) token number.  */
1380 -  int yytoken = 0;
1381 +    int yystate;
1382 +    /* Number of tokens to shift before error messages enabled.  */
1383 +    int yyerrstatus;
1384
1385 -  /* Three stacks and their tools:
1386 -     `yyss': related to states,
1387 -     `yyvs': related to semantic values,
1388 -     `yyls': related to locations.
1389 +    /* The stacks and their tools:
1390 +       `yyss': related to states.
1391 +       `yyvs': related to semantic values.
1392
1393 -     Refer to the stacks thru separate pointers, to allow yyoverflow
1394 -     to reallocate them elsewhere.  */
1395 +       Refer to the stacks thru separate pointers, to allow yyoverflow
1396 +       to reallocate them elsewhere.  */
1397
1398 -  /* The state stack.  */
1399 -  short int yyssa[YYINITDEPTH];
1400 -  short int *yyss = yyssa;
1401 -  register short int *yyssp;
1402 +    /* The state stack.  */
1403 +    yytype_int16 yyssa[YYINITDEPTH];
1404 +    yytype_int16 *yyss;
1405 +    yytype_int16 *yyssp;
1406
1407 -  /* The semantic value stack.  */
1408 -  YYSTYPE yyvsa[YYINITDEPTH];
1409 -  YYSTYPE *yyvs = yyvsa;
1410 -  register YYSTYPE *yyvsp;
1411 +    /* The semantic value stack.  */
1412 +    YYSTYPE yyvsa[YYINITDEPTH];
1413 +    YYSTYPE *yyvs;
1414 +    YYSTYPE *yyvsp;
1415
1416 +    YYSIZE_T yystacksize;
1417
1418 -
1419 -#define YYPOPSTACK   (yyvsp--, yyssp--)
1420 -
1421 -  YYSIZE_T yystacksize = YYINITDEPTH;
1422 -
1423 +  int yyn;
1424 +  int yyresult;
1425 +  /* Lookahead token as an internal (translated) token number.  */
1426 +  int yytoken;
1427    /* The variables used to return semantic value and location from the
1428       action routines.  */
1429    YYSTYPE yyval;
1430
1431 +#if YYERROR_VERBOSE
1432 +  /* Buffer for error messages, and its allocated size.  */
1433 +  char yymsgbuf[128];
1434 +  char *yymsg = yymsgbuf;
1435 +  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1436 +#endif
1437 +
1438 +#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1439
1440 -  /* When reducing, the number of symbols on the RHS of the reduced
1441 -     rule.  */
1442 -  int yylen;
1443 +  /* The number of symbols on the RHS of the reduced rule.
1444 +     Keep to zero when no symbol should be popped.  */
1445 +  int yylen = 0;
1446 +
1447 +  yytoken = 0;
1448 +  yyss = yyssa;
1449 +  yyvs = yyvsa;
1450 +  yystacksize = YYINITDEPTH;
1451
1452    YYDPRINTF ((stderr, "Starting parse\n"));
1453
1454    yystate = 0;
1455    yyerrstatus = 0;
1456    yynerrs = 0;
1457 -  yychar = YYEMPTY;            /* Cause a token to be read.  */
1458 +  yychar = YYEMPTY; /* Cause a token to be read.  */
1459
1460    /* Initialize stack pointers.
1461       Waste one element of value and location stack
1462       so that they stay on the same level as the state stack.
1463       The wasted elements are never initialized.  */
1464 -
1465    yyssp = yyss;
1466    yyvsp = yyvs;
1467
1468 -
1469    goto yysetstate;
1470
1471  /*------------------------------------------------------------.
1472 @@ -1303,8 +1680,7 @@ yyparse ()
1473  `------------------------------------------------------------*/
1474   yynewstate:
1475    /* In all cases, when you get here, the value and location stacks
1476 -     have just been pushed. so pushing a state here evens the stacks.
1477 -     */
1478 +     have just been pushed.  So pushing a state here evens the stacks.  */
1479    yyssp++;
1480
1481   yysetstate:
1482 @@ -1317,21 +1693,19 @@ yyparse ()
1483
1484  #ifdef yyoverflow
1485        {
1486 -       /* Give user a chance to reallocate the stack. Use copies of
1487 +       /* Give user a chance to reallocate the stack.  Use copies of
1488            these so that the &'s don't force the real ones into
1489            memory.  */
1490         YYSTYPE *yyvs1 = yyvs;
1491 -       short int *yyss1 = yyss;
1492 -
1493 +       yytype_int16 *yyss1 = yyss;
1494
1495         /* Each stack pointer address is followed by the size of the
1496            data in use in that stack, in bytes.  This used to be a
1497            conditional around just the two extra args, but that might
1498            be undefined if yyoverflow is a macro.  */
1499 -       yyoverflow ("parser stack overflow",
1500 +       yyoverflow (YY_("memory exhausted"),
1501                     &yyss1, yysize * sizeof (*yyssp),
1502                     &yyvs1, yysize * sizeof (*yyvsp),
1503 -
1504                     &yystacksize);
1505
1506         yyss = yyss1;
1507 @@ -1339,24 +1713,23 @@ yyparse ()
1508        }
1509  #else /* no yyoverflow */
1510  # ifndef YYSTACK_RELOCATE
1511 -      goto yyoverflowlab;
1512 +      goto yyexhaustedlab;
1513  # else
1514        /* Extend the stack our own way.  */
1515        if (YYMAXDEPTH <= yystacksize)
1516 -       goto yyoverflowlab;
1517 +       goto yyexhaustedlab;
1518        yystacksize *= 2;
1519        if (YYMAXDEPTH < yystacksize)
1520         yystacksize = YYMAXDEPTH;
1521
1522        {
1523 -       short int *yyss1 = yyss;
1524 +       yytype_int16 *yyss1 = yyss;
1525         union yyalloc *yyptr =
1526           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1527         if (! yyptr)
1528 -         goto yyoverflowlab;
1529 -       YYSTACK_RELOCATE (yyss);
1530 -       YYSTACK_RELOCATE (yyvs);
1531 -
1532 +         goto yyexhaustedlab;
1533 +       YYSTACK_RELOCATE (yyss_alloc, yyss);
1534 +       YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1535  #  undef YYSTACK_RELOCATE
1536         if (yyss1 != yyssa)
1537           YYSTACK_FREE (yyss1);
1538 @@ -1367,7 +1740,6 @@ yyparse ()
1539        yyssp = yyss + yysize - 1;
1540        yyvsp = yyvs + yysize - 1;
1541
1542 -
1543        YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1544                   (unsigned long int) yystacksize));
1545
1546 @@ -1377,6 +1749,9 @@ yyparse ()
1547
1548    YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1549
1550 +  if (yystate == YYFINAL)
1551 +    YYACCEPT;
1552 +
1553    goto yybackup;
1554
1555  /*-----------.
1556 @@ -1384,14 +1759,12 @@ yyparse ()
1557  `-----------*/
1558  yybackup:
1559
1560 -/* Do appropriate processing given the current state.  */
1561 -/* Read a lookahead token if we need one and don't already have one.  */
1562 -/* yyresume: */
1563 +  /* Do appropriate processing given the current state.  Read a
1564 +     lookahead token if we need one and don't already have one.  */
1565
1566    /* First try to decide what to do without reference to lookahead token.  */
1567 -
1568    yyn = yypact[yystate];
1569 -  if (yyn == YYPACT_NINF)
1570 +  if (yypact_value_is_default (yyn))
1571      goto yydefault;
1572
1573    /* Not known => get a lookahead token if don't already have one.  */
1574 @@ -1411,7 +1784,7 @@ yybackup:
1575    else
1576      {
1577        yytoken = YYTRANSLATE (yychar);
1578 -      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
1579 +      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1580      }
1581
1582    /* If the proper action on seeing token YYTOKEN is to reduce or to
1583 @@ -1422,31 +1795,26 @@ yybackup:
1584    yyn = yytable[yyn];
1585    if (yyn <= 0)
1586      {
1587 -      if (yyn == 0 || yyn == YYTABLE_NINF)
1588 -       goto yyerrlab;
1589 +      if (yytable_value_is_error (yyn))
1590 +        goto yyerrlab;
1591        yyn = -yyn;
1592        goto yyreduce;
1593      }
1594
1595 -  if (yyn == YYFINAL)
1596 -    YYACCEPT;
1597 -
1598 -  /* Shift the lookahead token.  */
1599 -  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
1600 -
1601 -  /* Discard the token being shifted unless it is eof.  */
1602 -  if (yychar != YYEOF)
1603 -    yychar = YYEMPTY;
1604 -
1605 -  *++yyvsp = yylval;
1606 -
1607 -
1608    /* Count tokens shifted since error; after three, turn off error
1609       status.  */
1610    if (yyerrstatus)
1611      yyerrstatus--;
1612
1613 +  /* Shift the lookahead token.  */
1614 +  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1615 +
1616 +  /* Discard the shifted token.  */
1617 +  yychar = YYEMPTY;
1618 +
1619    yystate = yyn;
1620 +  *++yyvsp = yylval;
1621 +
1622    goto yynewstate;
1623
1624
1625 @@ -1482,58 +1850,72 @@ yyreduce:
1626    switch (yyn)
1627      {
1628          case 2:
1629 +
1630 +/* Line 1806 of yacc.c  */
1631  #line 127 "parser.y"
1632      {
1633  }
1634      break;
1635
1636    case 5:
1637 +
1638 +/* Line 1806 of yacc.c  */
1639  #line 136 "parser.y"
1640      {
1641         if (abort_asap) {YYABORT;}
1642         if( pass1 ) {
1643 -               yyvsp[-2].sym->type = LABEL;
1644 -               yyvsp[-2].sym->value = lc;
1645 +               (yyvsp[(1) - (3)]).sym->type = LABEL;
1646 +               (yyvsp[(1) - (3)]).sym->value = lc;
1647         }
1648 -       inclc(yyvsp[0].value);
1649 +       inclc((yyvsp[(3) - (3)]).value);
1650         bytecount = 0;
1651  }
1652      break;
1653
1654    case 6:
1655 +
1656 +/* Line 1806 of yacc.c  */
1657  #line 145 "parser.y"
1658 -    { inclc(yyvsp[0].value); bytecount = 0; }
1659 +    { inclc((yyvsp[(1) - (1)]).value); bytecount = 0; }
1660      break;
1661
1662    case 7:
1663 +
1664 +/* Line 1806 of yacc.c  */
1665  #line 148 "parser.y"
1666      {
1667 -                                               yyval.value = yyvsp[-1].value;
1668 +                                               (yyval).value = (yyvsp[(1) - (2)]).value;
1669                                                 if( dashl && pass2 )
1670 -                                                       dumplist(yyvsp[0].str,1);
1671 +                                                       dumplist((yyvsp[(2) - (2)]).str,1);
1672                                         }
1673      break;
1674
1675    case 8:
1676 +
1677 +/* Line 1806 of yacc.c  */
1678  #line 153 "parser.y"
1679      {
1680 -                                               yyval.value = yyvsp[-1].value;
1681 +                                               (yyval).value = (yyvsp[(1) - (2)]).value;
1682                                                 if( dashl && pass2 )
1683 -                                                       dumplist(yyvsp[0].str,1);
1684 +                                                       dumplist((yyvsp[(2) - (2)]).str,1);
1685
1686                                         }
1687      break;
1688
1689    case 9:
1690 +
1691 +/* Line 1806 of yacc.c  */
1692  #line 159 "parser.y"
1693      {
1694 -                                               yyval.value = 0;
1695 +                                               (yyval).value = 0;
1696                                                 if( dashl && pass2 )
1697 -                                                       dumplist(yyvsp[0].str,0);
1698 +                                                       dumplist((yyvsp[(1) - (1)]).str,0);
1699                                         }
1700      break;
1701
1702    case 10:
1703 +
1704 +/* Line 1806 of yacc.c  */
1705  #line 164 "parser.y"
1706      {
1707                                                 seek_eol();
1708 @@ -1541,987 +1923,1249 @@ yyreduce:
1709      break;
1710
1711    case 11:
1712 +
1713 +/* Line 1806 of yacc.c  */
1714  #line 167 "parser.y"
1715      {
1716 -                                               yyval.value = 0;
1717 +                                               (yyval).value = 0;
1718                                                 if( dashl && pass2 )
1719 -                                                       dumplist(yyvsp[-2].str,0);
1720 +                                                       dumplist((yyvsp[(1) - (3)]).str,0);
1721                                         }
1722      break;
1723
1724    case 12:
1725 +
1726 +/* Line 1806 of yacc.c  */
1727  #line 184 "parser.y"
1728      {
1729 -       lc = yyvsp[0].val.v;
1730 +       lc = (yyvsp[(3) - (3)]).val.v;
1731         if( pass2 ) emitaddr(lc);
1732         bytecount = 0;
1733 -       yyval.value = 0;
1734 +       (yyval).value = 0;
1735  }
1736      break;
1737
1738    case 13:
1739 +
1740 +/* Line 1806 of yacc.c  */
1741  #line 190 "parser.y"
1742 -    { yyval.value = yyvsp[0].value; }
1743 +    { (yyval).value = (yyvsp[(3) - (3)]).value; }
1744      break;
1745
1746    case 14:
1747 +
1748 +/* Line 1806 of yacc.c  */
1749  #line 191 "parser.y"
1750 -    { yyval.value = yyvsp[0].value; }
1751 +    { (yyval).value = (yyvsp[(3) - (3)]).value; }
1752      break;
1753
1754    case 15:
1755 +
1756 +/* Line 1806 of yacc.c  */
1757  #line 192 "parser.y"
1758 -    { yyval.value = yyvsp[0].val.v;
1759 +    { (yyval).value = (yyvsp[(3) - (3)]).val.v;
1760                                           if( pass2 )
1761 -                                               emitaddr(lc+yyval.value); }
1762 +                                               emitaddr(lc+(yyval).value); }
1763      break;
1764
1765    case 16:
1766 +
1767 +/* Line 1806 of yacc.c  */
1768  #line 196 "parser.y"
1769      {
1770 -       if( yyvsp[0].val.d == 0 )
1771 +       if( (yyvsp[(5) - (5)]).val.d == 0 )
1772                 warn("Expression is undefined in pass 1");
1773 -       yyvsp[-2].sym->type = LABEL;
1774 -       yyvsp[-2].sym->value = yyvsp[0].val.v;
1775 -       yyval.value = 0;
1776 +       (yyvsp[(3) - (5)]).sym->type = LABEL;
1777 +       (yyvsp[(3) - (5)]).sym->value = (yyvsp[(5) - (5)]).val.v;
1778 +       (yyval).value = 0;
1779  }
1780      break;
1781
1782    case 17:
1783 +
1784 +/* Line 1806 of yacc.c  */
1785  #line 205 "parser.y"
1786      {
1787 -       yyvsp[-2].sym->type = LABEL;
1788 -       yyvsp[-2].sym->value = yyvsp[0].value;
1789 -       yyval.value = 0;
1790 +       (yyvsp[(3) - (5)]).sym->type = LABEL;
1791 +       (yyvsp[(3) - (5)]).sym->value = (yyvsp[(5) - (5)]).value;
1792 +       (yyval).value = 0;
1793  }
1794      break;
1795
1796    case 18:
1797 +
1798 +/* Line 1806 of yacc.c  */
1799  #line 210 "parser.y"
1800 -    { yyval.value = 0; }
1801 +    { (yyval).value = 0; }
1802      break;
1803
1804    case 19:
1805 +
1806 +/* Line 1806 of yacc.c  */
1807  #line 214 "parser.y"
1808      {
1809 -               if( yyvsp[0].val.d == 0 )
1810 +               if( (yyvsp[(1) - (1)]).val.d == 0 )
1811                         warn("Expression is undefined in pass 1");
1812 -               if( !(isbit16(yyvsp[0].val.v)) )
1813 +               if( !(isbit16((yyvsp[(1) - (1)]).val.v)) )
1814                         warn("Value greater than 16-bits");
1815 -               yyval.value = yyvsp[0].val.v;
1816 +               (yyval).value = (yyvsp[(1) - (1)]).val.v;
1817  }
1818      break;
1819
1820    case 20:
1821 +
1822 +/* Line 1806 of yacc.c  */
1823  #line 224 "parser.y"
1824      {
1825 -       if( !isbit8(yyvsp[-1].value) )
1826 +       if( !isbit8((yyvsp[(1) - (2)]).value) )
1827                 warn("Bit address exceeds 8-bits");
1828 -       if( isbmram(yyvsp[-1].value) )
1829 -               yyval.value = (yyvsp[-1].value-0x20)*8+ yyvsp[0].value;
1830 -       else if( isbmsfr(yyvsp[-1].value) )
1831 -               yyval.value = yyvsp[-1].value + yyvsp[0].value;
1832 +       if( isbmram((yyvsp[(1) - (2)]).value) )
1833 +               (yyval).value = ((yyvsp[(1) - (2)]).value-0x20)*8+ (yyvsp[(2) - (2)]).value;
1834 +       else if( isbmsfr((yyvsp[(1) - (2)]).value) )
1835 +               (yyval).value = (yyvsp[(1) - (2)]).value + (yyvsp[(2) - (2)]).value;
1836         else
1837                 warn("Invalid bit addressable RAM location");
1838  }
1839      break;
1840
1841    case 21:
1842 +
1843 +/* Line 1806 of yacc.c  */
1844  #line 237 "parser.y"
1845      {
1846 -       if( yyvsp[0].sym->type == UNDEF )
1847 -               warn("Symbol %s must be defined in pass 1",yyvsp[0].sym->name);
1848 -       yyval.value = yyvsp[0].sym->value;
1849 +       if( (yyvsp[(1) - (1)]).sym->type == UNDEF )
1850 +               warn("Symbol %s must be defined in pass 1",(yyvsp[(1) - (1)]).sym->name);
1851 +       (yyval).value = (yyvsp[(1) - (1)]).sym->value;
1852  }
1853      break;
1854
1855    case 22:
1856 +
1857 +/* Line 1806 of yacc.c  */
1858  #line 242 "parser.y"
1859 -    { yyval.value = yyvsp[0].value; }
1860 +    { (yyval).value = (yyvsp[(1) - (1)]).value; }
1861      break;
1862
1863    case 23:
1864 +
1865 +/* Line 1806 of yacc.c  */
1866  #line 247 "parser.y"
1867      {
1868 -       if( yyvsp[0].sym->type != UNDEF && pass1)
1869 -               warn("Attempt to redefine symbol: %s",yyvsp[0].sym->name);
1870 -       yyval.sym = yyvsp[0].sym;
1871 +       if( (yyvsp[(1) - (1)]).sym->type != UNDEF && pass1)
1872 +               warn("Attempt to redefine symbol: %s",(yyvsp[(1) - (1)]).sym->name);
1873 +       (yyval).sym = (yyvsp[(1) - (1)]).sym;
1874  }
1875      break;
1876
1877    case 24:
1878 +
1879 +/* Line 1806 of yacc.c  */
1880  #line 255 "parser.y"
1881      {
1882 -       if( pass2 ) genbyte(yyvsp[0].value);
1883 -       yyval.value = yyvsp[-2].value + 1;
1884 +       if( pass2 ) genbyte((yyvsp[(3) - (3)]).value);
1885 +       (yyval).value = (yyvsp[(1) - (3)]).value + 1;
1886  }
1887      break;
1888
1889    case 25:
1890 +
1891 +/* Line 1806 of yacc.c  */
1892  #line 260 "parser.y"
1893      {
1894         if( pass1 )
1895 -               yyval.value = yyvsp[-2].value + yyvsp[0].value;
1896 +               (yyval).value = (yyvsp[(1) - (3)]).value + (yyvsp[(3) - (3)]).value;
1897         else {
1898 -               yyval.value = yyvsp[-2].value + strlen(yyvsp[0].str);
1899 -               genstr(yyvsp[0].str);
1900 +               (yyval).value = (yyvsp[(1) - (3)]).value + strlen((yyvsp[(3) - (3)]).str);
1901 +               genstr((yyvsp[(3) - (3)]).str);
1902
1903 -               free(yyvsp[0].str);
1904 +               free((yyvsp[(3) - (3)]).str);
1905         }
1906  }
1907      break;
1908
1909    case 26:
1910 +
1911 +/* Line 1806 of yacc.c  */
1912  #line 271 "parser.y"
1913      {
1914 -       if( pass2 ) genbyte(yyvsp[0].value);
1915 -       yyval.value = 1;
1916 +       if( pass2 ) genbyte((yyvsp[(1) - (1)]).value);
1917 +       (yyval).value = 1;
1918  }
1919      break;
1920
1921    case 27:
1922 +
1923 +/* Line 1806 of yacc.c  */
1924  #line 276 "parser.y"
1925      {
1926         if( pass1 )
1927 -               yyval.value = yyvsp[0].value;
1928 +               (yyval).value = (yyvsp[(1) - (1)]).value;
1929         else {
1930 -               yyval.value = strlen(yyvsp[0].str);
1931 -               genstr(yyvsp[0].str);
1932 -               free(yyvsp[0].str);
1933 +               (yyval).value = strlen((yyvsp[(1) - (1)]).str);
1934 +               genstr((yyvsp[(1) - (1)]).str);
1935 +               free((yyvsp[(1) - (1)]).str);
1936         }
1937  }
1938      break;
1939
1940    case 28:
1941 +
1942 +/* Line 1806 of yacc.c  */
1943  #line 288 "parser.y"
1944      {
1945 -       if( pass2 ) genword(yyvsp[0].value);
1946 -       yyval.value = yyvsp[-2].value + 2;
1947 +       if( pass2 ) genword((yyvsp[(3) - (3)]).value);
1948 +       (yyval).value = (yyvsp[(1) - (3)]).value + 2;
1949  }
1950      break;
1951
1952    case 29:
1953 +
1954 +/* Line 1806 of yacc.c  */
1955  #line 293 "parser.y"
1956      {
1957 -       if( pass2 ) genword(yyvsp[0].value);
1958 -       yyval.value = 2;
1959 +       if( pass2 ) genword((yyvsp[(1) - (1)]).value);
1960 +       (yyval).value = 2;
1961  }
1962      break;
1963
1964    case 30:
1965 +
1966 +/* Line 1806 of yacc.c  */
1967  #line 306 "parser.y"
1968 -    { yyval.val.v = lc;
1969 -                                         yyval.val.d = 1; }
1970 +    { (yyval).val.v = lc;
1971 +                                         (yyval).val.d = 1; }
1972      break;
1973
1974    case 31:
1975 +
1976 +/* Line 1806 of yacc.c  */
1977  #line 309 "parser.y"
1978 -    { yyval.val.v = yyvsp[-1].val.v;
1979 -                                         yyval.val.d = yyvsp[-1].val.d; }
1980 +    { (yyval).val.v = (yyvsp[(2) - (3)]).val.v;
1981 +                                         (yyval).val.d = (yyvsp[(2) - (3)]).val.d; }
1982      break;
1983
1984    case 32:
1985 +
1986 +/* Line 1806 of yacc.c  */
1987  #line 312 "parser.y"
1988 -    { yyval.val.v = -yyvsp[0].val.v;
1989 -                                         yyval.val.d = yyvsp[0].val.d;  }
1990 +    { (yyval).val.v = -(yyvsp[(2) - (2)]).val.v;
1991 +                                         (yyval).val.d = (yyvsp[(2) - (2)]).val.d;  }
1992      break;
1993
1994    case 33:
1995 +
1996 +/* Line 1806 of yacc.c  */
1997  #line 315 "parser.y"
1998 -    { yyval.val.v = yyvsp[-2].val.v | yyvsp[0].val.v;
1999 -                                         yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; }
2000 +    { (yyval).val.v = (yyvsp[(1) - (3)]).val.v | (yyvsp[(3) - (3)]).val.v;
2001 +                                         (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; }
2002      break;
2003
2004    case 34:
2005 +
2006 +/* Line 1806 of yacc.c  */
2007  #line 318 "parser.y"
2008 -    { yyval.val.v = yyvsp[-2].val.v & yyvsp[0].val.v;
2009 -                                         yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; }
2010 +    { (yyval).val.v = (yyvsp[(1) - (3)]).val.v & (yyvsp[(3) - (3)]).val.v;
2011 +                                         (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; }
2012      break;
2013
2014    case 35:
2015 +
2016 +/* Line 1806 of yacc.c  */
2017  #line 321 "parser.y"
2018 -    { yyval.val.v = yyvsp[-2].val.v * yyvsp[0].val.v;
2019 -                                         yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; }
2020 +    { (yyval).val.v = (yyvsp[(1) - (3)]).val.v * (yyvsp[(3) - (3)]).val.v;
2021 +                                         (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; }
2022      break;
2023
2024    case 36:
2025 +
2026 +/* Line 1806 of yacc.c  */
2027  #line 324 "parser.y"
2028 -    { yyval.val.v = yyvsp[-2].val.v / yyvsp[0].val.v;
2029 -                                         yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; }
2030 +    { (yyval).val.v = (yyvsp[(1) - (3)]).val.v / (yyvsp[(3) - (3)]).val.v;
2031 +                                         (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; }
2032      break;
2033
2034    case 37:
2035 +
2036 +/* Line 1806 of yacc.c  */
2037  #line 327 "parser.y"
2038 -    { yyval.val.v = yyvsp[-2].val.v % yyvsp[0].val.v;
2039 -                                         yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; }
2040 +    { (yyval).val.v = (yyvsp[(1) - (3)]).val.v % (yyvsp[(3) - (3)]).val.v;
2041 +                                         (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; }
2042      break;
2043
2044    case 38:
2045 +
2046 +/* Line 1806 of yacc.c  */
2047  #line 330 "parser.y"
2048 -    { yyval.val.v = yyvsp[-2].val.v - yyvsp[0].val.v;
2049 -                                         yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; }
2050 +    { (yyval).val.v = (yyvsp[(1) - (3)]).val.v - (yyvsp[(3) - (3)]).val.v;
2051 +                                         (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; }
2052      break;
2053
2054    case 39:
2055 +
2056 +/* Line 1806 of yacc.c  */
2057  #line 333 "parser.y"
2058 -    { yyval.val.v = yyvsp[-2].val.v + yyvsp[0].val.v;
2059 -                                         yyval.val.d = yyvsp[-2].val.d && yyvsp[0].val.d; }
2060 +    { (yyval).val.v = (yyvsp[(1) - (3)]).val.v + (yyvsp[(3) - (3)]).val.v;
2061 +                                         (yyval).val.d = (yyvsp[(1) - (3)]).val.d && (yyvsp[(3) - (3)]).val.d; }
2062      break;
2063
2064    case 40:
2065 +
2066 +/* Line 1806 of yacc.c  */
2067  #line 336 "parser.y"
2068 -    { yyval.val.v = yyvsp[-3].val.v >> yyvsp[0].val.v;
2069 -                                         yyval.val.d = yyvsp[-3].val.d && yyvsp[0].val.d; }
2070 +    { (yyval).val.v = (yyvsp[(1) - (4)]).val.v >> (yyvsp[(4) - (4)]).val.v;
2071 +                                         (yyval).val.d = (yyvsp[(1) - (4)]).val.d && (yyvsp[(4) - (4)]).val.d; }
2072      break;
2073
2074    case 41:
2075 +
2076 +/* Line 1806 of yacc.c  */
2077  #line 339 "parser.y"
2078 -    { yyval.val.v = yyvsp[-3].val.v << yyvsp[0].val.v;
2079 -                                         yyval.val.d = yyvsp[-3].val.d && yyvsp[0].val.d; }
2080 +    { (yyval).val.v = (yyvsp[(1) - (4)]).val.v << (yyvsp[(4) - (4)]).val.v;
2081 +                                         (yyval).val.d = (yyvsp[(1) - (4)]).val.d && (yyvsp[(4) - (4)]).val.d; }
2082      break;
2083
2084    case 42:
2085 +
2086 +/* Line 1806 of yacc.c  */
2087  #line 342 "parser.y"
2088      {
2089         if( pass1 ) {
2090 -               yyval.val.v = yyvsp[0].sym->value;
2091 -               yyval.val.d = (yyvsp[0].sym->type != UNDEF);
2092 +               (yyval).val.v = (yyvsp[(1) - (1)]).sym->value;
2093 +               (yyval).val.d = ((yyvsp[(1) - (1)]).sym->type != UNDEF);
2094         }
2095         else {
2096 -               if( yyvsp[0].sym->type == UNDEF )
2097 -                       warn("Undefined symbol %s",yyvsp[0].sym->name);
2098 -               yyval.val.v = yyvsp[0].sym->value;
2099 -               yyval.val.d = 1;
2100 +               if( (yyvsp[(1) - (1)]).sym->type == UNDEF )
2101 +                       warn("Undefined symbol %s",(yyvsp[(1) - (1)]).sym->name);
2102 +               (yyval).val.v = (yyvsp[(1) - (1)]).sym->value;
2103 +               (yyval).val.d = 1;
2104         }
2105  }
2106      break;
2107
2108    case 43:
2109 +
2110 +/* Line 1806 of yacc.c  */
2111  #line 354 "parser.y"
2112 -    { yyval.val.v = yyvsp[0].val.v; yyval.val.d=1; }
2113 +    { (yyval).val.v = (yyvsp[(1) - (1)]).val.v; (yyval).val.d=1; }
2114      break;
2115
2116    case 44:
2117 +
2118 +/* Line 1806 of yacc.c  */
2119  #line 367 "parser.y"
2120 -    { yyval.value = makeop(yyvsp[0].op,NULL,0); }
2121 +    { (yyval).value = makeop((yyvsp[(1) - (1)]).op,NULL,0); }
2122      break;
2123
2124    case 45:
2125 +
2126 +/* Line 1806 of yacc.c  */
2127  #line 369 "parser.y"
2128 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2129 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2130      break;
2131
2132    case 46:
2133 +
2134 +/* Line 1806 of yacc.c  */
2135  #line 371 "parser.y"
2136 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2137 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2138      break;
2139
2140    case 47:
2141 +
2142 +/* Line 1806 of yacc.c  */
2143  #line 373 "parser.y"
2144 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2145 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2146      break;
2147
2148    case 48:
2149 +
2150 +/* Line 1806 of yacc.c  */
2151  #line 375 "parser.y"
2152 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2153 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2154      break;
2155
2156    case 49:
2157 +
2158 +/* Line 1806 of yacc.c  */
2159  #line 377 "parser.y"
2160 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2161 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2162      break;
2163
2164    case 50:
2165 +
2166 +/* Line 1806 of yacc.c  */
2167  #line 379 "parser.y"
2168 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2169 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2170      break;
2171
2172    case 51:
2173 +
2174 +/* Line 1806 of yacc.c  */
2175  #line 381 "parser.y"
2176 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,4); }
2177 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,4); }
2178      break;
2179
2180    case 52:
2181 +
2182 +/* Line 1806 of yacc.c  */
2183  #line 383 "parser.y"
2184 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2185 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2186      break;
2187
2188    case 53:
2189 +
2190 +/* Line 1806 of yacc.c  */
2191  #line 385 "parser.y"
2192 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,4); }
2193 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,4); }
2194      break;
2195
2196    case 54:
2197 +
2198 +/* Line 1806 of yacc.c  */
2199  #line 387 "parser.y"
2200 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,6); }
2201 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,6); }
2202      break;
2203
2204    case 55:
2205 +
2206 +/* Line 1806 of yacc.c  */
2207  #line 389 "parser.y"
2208 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2209 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2210      break;
2211
2212    case 56:
2213 +
2214 +/* Line 1806 of yacc.c  */
2215  #line 391 "parser.y"
2216 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,4); }
2217 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,4); }
2218      break;
2219
2220    case 57:
2221 +
2222 +/* Line 1806 of yacc.c  */
2223  #line 393 "parser.y"
2224 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,6); }
2225 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,6); }
2226      break;
2227
2228    case 58:
2229 +
2230 +/* Line 1806 of yacc.c  */
2231  #line 395 "parser.y"
2232 -    { if( get_md(yyvsp[0].mode) == 3 )
2233 +    { if( get_md((yyvsp[(2) - (2)]).mode) == 3 )
2234                                         warn("Immediate mode is illegal");
2235 -                                 yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0);
2236 +                                 (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0);
2237                                 }
2238      break;
2239
2240    case 59:
2241 +
2242 +/* Line 1806 of yacc.c  */
2243  #line 400 "parser.y"
2244 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2245 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2246      break;
2247
2248    case 60:
2249 +
2250 +/* Line 1806 of yacc.c  */
2251  #line 402 "parser.y"
2252 -    { yyval.value = makeop(yyvsp[-1].op,NULL,4); }
2253 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,4); }
2254      break;
2255
2256    case 61:
2257 +
2258 +/* Line 1806 of yacc.c  */
2259  #line 404 "parser.y"
2260 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2261 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2262      break;
2263
2264    case 62:
2265 +
2266 +/* Line 1806 of yacc.c  */
2267  #line 406 "parser.y"
2268 -    { yyval.value = makeop(yyvsp[-1].op,NULL,0); }
2269 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); }
2270      break;
2271
2272    case 63:
2273 +
2274 +/* Line 1806 of yacc.c  */
2275  #line 408 "parser.y"
2276 -    { yyval.value = makeop(yyvsp[-1].op,NULL,0); }
2277 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); }
2278      break;
2279
2280    case 64:
2281 +
2282 +/* Line 1806 of yacc.c  */
2283  #line 410 "parser.y"
2284 -    { yyval.value = makeop(yyvsp[-4].op,NULL,0); }
2285 +    { (yyval).value = makeop((yyvsp[(1) - (5)]).op,NULL,0); }
2286      break;
2287
2288    case 65:
2289 +
2290 +/* Line 1806 of yacc.c  */
2291  #line 412 "parser.y"
2292 -    { yyval.value = makeop(yyvsp[-4].op,NULL,0); }
2293 +    { (yyval).value = makeop((yyvsp[(1) - (5)]).op,NULL,0); }
2294      break;
2295
2296    case 66:
2297 +
2298 +/* Line 1806 of yacc.c  */
2299  #line 414 "parser.y"
2300 -    { yyval.value = makeop(yyvsp[-1].op,NULL,0); }
2301 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); }
2302      break;
2303
2304    case 67:
2305 +
2306 +/* Line 1806 of yacc.c  */
2307  #line 416 "parser.y"
2308 -    { yyval.value = makeop(yyvsp[0].op,NULL,0); }
2309 +    { (yyval).value = makeop((yyvsp[(1) - (1)]).op,NULL,0); }
2310      break;
2311
2312    case 68:
2313 +
2314 +/* Line 1806 of yacc.c  */
2315  #line 418 "parser.y"
2316 -    { yyval.value = makeop(yyvsp[0].op,NULL,0); }
2317 +    { (yyval).value = makeop((yyvsp[(1) - (1)]).op,NULL,0); }
2318      break;
2319
2320    case 69:
2321 +
2322 +/* Line 1806 of yacc.c  */
2323  #line 420 "parser.y"
2324 -    { yyval.value = makeop(yyvsp[-1].op,NULL,0); }
2325 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); }
2326      break;
2327
2328    case 70:
2329 +
2330 +/* Line 1806 of yacc.c  */
2331  #line 422 "parser.y"
2332 -    { yyval.value = makeop(yyvsp[-1].op,NULL,0); }
2333 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); }
2334      break;
2335
2336    case 71:
2337 +
2338 +/* Line 1806 of yacc.c  */
2339  #line 424 "parser.y"
2340 -    { yyval.value = makeop(yyvsp[-1].op,NULL,0); }
2341 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); }
2342      break;
2343
2344    case 72:
2345 +
2346 +/* Line 1806 of yacc.c  */
2347  #line 426 "parser.y"
2348 -    { yyval.value = makeop(yyvsp[-1].op,NULL,0); }
2349 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); }
2350      break;
2351
2352    case 73:
2353 +
2354 +/* Line 1806 of yacc.c  */
2355  #line 428 "parser.y"
2356 -    { yyval.value = makeop(yyvsp[-1].op,NULL,0); }
2357 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,NULL,0); }
2358      break;
2359
2360    case 74:
2361 +
2362 +/* Line 1806 of yacc.c  */
2363  #line 430 "parser.y"
2364 -    { if( get_md(yyvsp[0].mode) != 2 )
2365 +    { if( get_md((yyvsp[(2) - (2)]).mode) != 2 )
2366                                         warn("Invalid addressing mode");
2367 -                                 yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,-2); }
2368 +                                 (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,-2); }
2369      break;
2370
2371    case 75:
2372 +
2373 +/* Line 1806 of yacc.c  */
2374  #line 434 "parser.y"
2375 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2376 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2377      break;
2378
2379    case 76:
2380 +
2381 +/* Line 1806 of yacc.c  */
2382  #line 436 "parser.y"
2383 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2384 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2385      break;
2386
2387    case 77:
2388 +
2389 +/* Line 1806 of yacc.c  */
2390  #line 438 "parser.y"
2391 -    { if( get_md(yyvsp[0].mode) == 0 )
2392 +    { if( get_md((yyvsp[(2) - (2)]).mode) == 0 )
2393                                         warn("Invalid addressing mode");
2394 -                                 yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,-1); }
2395 +                                 (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,-1); }
2396      break;
2397
2398    case 78:
2399 +
2400 +/* Line 1806 of yacc.c  */
2401  #line 442 "parser.y"
2402      {
2403                                    struct mode tmp;
2404                                         set_md(tmp,0);
2405                                         set_ov(tmp,0);
2406                                         set_sz(tmp,1);
2407 -                                       set_b1(tmp,yyvsp[0].value);
2408 -                                       yyval.value = makeop(yyvsp[-1].op,&tmp,0);
2409 +                                       set_b1(tmp,(yyvsp[(2) - (2)]).value);
2410 +                                       (yyval).value = makeop((yyvsp[(1) - (2)]).op,&tmp,0);
2411                                 }
2412      break;
2413
2414    case 79:
2415 +
2416 +/* Line 1806 of yacc.c  */
2417  #line 451 "parser.y"
2418      {
2419                                    struct mode tmp;
2420                                         set_md(tmp,0);
2421                                         set_ov(tmp,0);
2422                                         set_sz(tmp,1);
2423 -                                       set_b1(tmp,yyvsp[0].value);
2424 -                                       yyval.value = makeop(yyvsp[-1].op,&tmp,0);
2425 +                                       set_b1(tmp,(yyvsp[(2) - (2)]).value);
2426 +                                       (yyval).value = makeop((yyvsp[(1) - (2)]).op,&tmp,0);
2427                                 }
2428      break;
2429
2430    case 80:
2431 +
2432 +/* Line 1806 of yacc.c  */
2433  #line 460 "parser.y"
2434 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2435 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2436      break;
2437
2438    case 81:
2439 +
2440 +/* Line 1806 of yacc.c  */
2441  #line 462 "parser.y"
2442 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2443 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2444      break;
2445
2446    case 82:
2447 +
2448 +/* Line 1806 of yacc.c  */
2449  #line 464 "parser.y"
2450 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2451 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2452      break;
2453
2454    case 83:
2455 +
2456 +/* Line 1806 of yacc.c  */
2457  #line 466 "parser.y"
2458 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2459 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2460      break;
2461
2462    case 84:
2463 +
2464 +/* Line 1806 of yacc.c  */
2465  #line 468 "parser.y"
2466 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2467 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2468      break;
2469
2470    case 85:
2471 +
2472 +/* Line 1806 of yacc.c  */
2473  #line 470 "parser.y"
2474 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2475 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2476      break;
2477
2478    case 86:
2479 +
2480 +/* Line 1806 of yacc.c  */
2481  #line 472 "parser.y"
2482 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2483 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2484      break;
2485
2486    case 87:
2487 +
2488 +/* Line 1806 of yacc.c  */
2489  #line 474 "parser.y"
2490 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2491 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2492      break;
2493
2494    case 88:
2495 +
2496 +/* Line 1806 of yacc.c  */
2497  #line 476 "parser.y"
2498 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2499 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2500      break;
2501
2502    case 89:
2503 +
2504 +/* Line 1806 of yacc.c  */
2505  #line 478 "parser.y"
2506 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2507 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2508      break;
2509
2510    case 90:
2511 +
2512 +/* Line 1806 of yacc.c  */
2513  #line 480 "parser.y"
2514 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2515 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2516      break;
2517
2518    case 91:
2519 +
2520 +/* Line 1806 of yacc.c  */
2521  #line 482 "parser.y"
2522 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2523 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2524      break;
2525
2526    case 92:
2527 +
2528 +/* Line 1806 of yacc.c  */
2529  #line 484 "parser.y"
2530 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,0); }
2531 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,0); }
2532      break;
2533
2534    case 93:
2535 +
2536 +/* Line 1806 of yacc.c  */
2537  #line 486 "parser.y"
2538 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,4); }
2539 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,4); }
2540      break;
2541
2542    case 94:
2543 +
2544 +/* Line 1806 of yacc.c  */
2545  #line 488 "parser.y"
2546 -    { yyval.value = makeop(yyvsp[-1].op,&yyvsp[0].mode,6); }
2547 +    { (yyval).value = makeop((yyvsp[(1) - (2)]).op,&(yyvsp[(2) - (2)]).mode,6); }
2548      break;
2549
2550    case 95:
2551 +
2552 +/* Line 1806 of yacc.c  */
2553  #line 492 "parser.y"
2554 -    { yyval.value = makeop(yyvsp[-6].op,NULL,0); }
2555 +    { (yyval).value = makeop((yyvsp[(1) - (7)]).op,NULL,0); }
2556      break;
2557
2558    case 96:
2559 +
2560 +/* Line 1806 of yacc.c  */
2561  #line 494 "parser.y"
2562 -    { yyval.value = makeop(yyvsp[-6].op,NULL,0); }
2563 +    { (yyval).value = makeop((yyvsp[(1) - (7)]).op,NULL,0); }
2564      break;
2565
2566    case 97:
2567 +
2568 +/* Line 1806 of yacc.c  */
2569  #line 496 "parser.y"
2570 -    { yyval.value = makeop(yyvsp[-6].op,NULL,1); }
2571 +    { (yyval).value = makeop((yyvsp[(1) - (7)]).op,NULL,1); }
2572      break;
2573
2574    case 98:
2575 +
2576 +/* Line 1806 of yacc.c  */
2577  #line 498 "parser.y"
2578 -    { yyval.value = makeop(yyvsp[-6].op,NULL,1); }
2579 +    { (yyval).value = makeop((yyvsp[(1) - (7)]).op,NULL,1); }
2580      break;
2581
2582    case 99:
2583 +
2584 +/* Line 1806 of yacc.c  */
2585  #line 501 "parser.y"
2586 -    { yyval.value = makeop(yyvsp[-4].op,NULL,yyvsp[0].value); }
2587 +    { (yyval).value = makeop((yyvsp[(1) - (5)]).op,NULL,(yyvsp[(5) - (5)]).value); }
2588      break;
2589
2590    case 100:
2591 +
2592 +/* Line 1806 of yacc.c  */
2593  #line 503 "parser.y"
2594 -    { yyval.value = makeop(yyvsp[-4].op,NULL,2); }
2595 +    { (yyval).value = makeop((yyvsp[(1) - (5)]).op,NULL,2); }
2596      break;
2597
2598    case 101:
2599 +
2600 +/* Line 1806 of yacc.c  */
2601  #line 505 "parser.y"
2602 -    { yyval.value = makeop(yyvsp[-4].op,NULL,yyvsp[-2].value+3); }
2603 +    { (yyval).value = makeop((yyvsp[(1) - (5)]).op,NULL,(yyvsp[(3) - (5)]).value+3); }
2604      break;
2605
2606    case 102:
2607 +
2608 +/* Line 1806 of yacc.c  */
2609  #line 507 "parser.y"
2610 -    { yyval.value = makeop(yyvsp[-4].op,NULL,5); }
2611 +    { (yyval).value = makeop((yyvsp[(1) - (5)]).op,NULL,5); }
2612      break;
2613
2614    case 103:
2615 +
2616 +/* Line 1806 of yacc.c  */
2617  #line 519 "parser.y"
2618      {
2619 -                                       set_md(yyval.mode,0);
2620 -                                       set_ov(yyval.mode, yyvsp[0].value);
2621 -                                       set_sz(yyval.mode, 0);
2622 +                                       set_md((yyval).mode,0);
2623 +                                       set_ov((yyval).mode, (yyvsp[(3) - (3)]).value);
2624 +                                       set_sz((yyval).mode, 0);
2625                                 }
2626      break;
2627
2628    case 104:
2629 +
2630 +/* Line 1806 of yacc.c  */
2631  #line 525 "parser.y"
2632      {
2633 -                                       set_md(yyval.mode,1);
2634 -                                       set_ov(yyval.mode,0);
2635 -                                       set_sz(yyval.mode,1);
2636 -                                       set_b1(yyval.mode,yyvsp[0].value);
2637 +                                       set_md((yyval).mode,1);
2638 +                                       set_ov((yyval).mode,0);
2639 +                                       set_sz((yyval).mode,1);
2640 +                                       set_b1((yyval).mode,(yyvsp[(3) - (3)]).value);
2641                                 }
2642      break;
2643
2644    case 105:
2645 +
2646 +/* Line 1806 of yacc.c  */
2647  #line 532 "parser.y"
2648      {
2649 -                                       set_md(yyval.mode,2);
2650 -                                       set_ov(yyval.mode,yyvsp[0].value);
2651 -                                       set_sz(yyval.mode,0);
2652 +                                       set_md((yyval).mode,2);
2653 +                                       set_ov((yyval).mode,(yyvsp[(4) - (4)]).value);
2654 +                                       set_sz((yyval).mode,0);
2655                                 }
2656      break;
2657
2658    case 106:
2659 +
2660 +/* Line 1806 of yacc.c  */
2661  #line 538 "parser.y"
2662      {
2663 -                                       set_md(yyval.mode,3);
2664 -                                       set_ov(yyval.mode,0);
2665 -                                       set_sz(yyval.mode,1);
2666 -                                       set_b1(yyval.mode,yyvsp[0].value);
2667 +                                       set_md((yyval).mode,3);
2668 +                                       set_ov((yyval).mode,0);
2669 +                                       set_sz((yyval).mode,1);
2670 +                                       set_b1((yyval).mode,(yyvsp[(4) - (4)]).value);
2671                                 }
2672      break;
2673
2674    case 107:
2675 +
2676 +/* Line 1806 of yacc.c  */
2677  #line 547 "parser.y"
2678      {
2679 -                                       set_md(yyval.mode,0);
2680 -                                       set_ov(yyval.mode,0);
2681 -                                       set_sz(yyval.mode,1);
2682 -                                       set_b1(yyval.mode,yyvsp[-2].value);
2683 +                                       set_md((yyval).mode,0);
2684 +                                       set_ov((yyval).mode,0);
2685 +                                       set_sz((yyval).mode,1);
2686 +                                       set_b1((yyval).mode,(yyvsp[(1) - (3)]).value);
2687                                 }
2688      break;
2689
2690    case 108:
2691 +
2692 +/* Line 1806 of yacc.c  */
2693  #line 554 "parser.y"
2694      {
2695 -                                       set_md(yyval.mode,1);
2696 -                                       set_ov(yyval.mode,0);
2697 -                                       set_sz(yyval.mode,2);
2698 -                                       set_b1(yyval.mode,yyvsp[-3].value);
2699 -                                       set_b2(yyval.mode,yyvsp[0].value);
2700 +                                       set_md((yyval).mode,1);
2701 +                                       set_ov((yyval).mode,0);
2702 +                                       set_sz((yyval).mode,2);
2703 +                                       set_b1((yyval).mode,(yyvsp[(1) - (4)]).value);
2704 +                                       set_b2((yyval).mode,(yyvsp[(4) - (4)]).value);
2705                                 }
2706      break;
2707
2708    case 109:
2709 +
2710 +/* Line 1806 of yacc.c  */
2711  #line 564 "parser.y"
2712      {
2713 -                                       set_md(yyval.mode,0);
2714 -                                       set_ov(yyval.mode,0);
2715 -                                       set_sz(yyval.mode,1);
2716 -                                       set_b1(yyval.mode,yyvsp[0].value);
2717 +                                       set_md((yyval).mode,0);
2718 +                                       set_ov((yyval).mode,0);
2719 +                                       set_sz((yyval).mode,1);
2720 +                                       set_b1((yyval).mode,(yyvsp[(3) - (3)]).value);
2721                                 }
2722      break;
2723
2724    case 110:
2725 +
2726 +/* Line 1806 of yacc.c  */
2727  #line 571 "parser.y"
2728      {
2729 -                                       set_md(yyval.mode,1);
2730 -                                       set_ov(yyval.mode,0);
2731 -                                       set_sz(yyval.mode,1);
2732 -                                       set_b1(yyval.mode,yyvsp[0].value);
2733 +                                       set_md((yyval).mode,1);
2734 +                                       set_ov((yyval).mode,0);
2735 +                                       set_sz((yyval).mode,1);
2736 +                                       set_b1((yyval).mode,(yyvsp[(4) - (4)]).value);
2737                                 }
2738      break;
2739
2740    case 111:
2741 +
2742 +/* Line 1806 of yacc.c  */
2743  #line 578 "parser.y"
2744      {
2745 -                                       set_md(yyval.mode,1);
2746 -                                       set_ov(yyval.mode,0);
2747 -                                       set_sz(yyval.mode,1);
2748 -                                       set_b1(yyval.mode,yyvsp[0].value);
2749 +                                       set_md((yyval).mode,1);
2750 +                                       set_ov((yyval).mode,0);
2751 +                                       set_sz((yyval).mode,1);
2752 +                                       set_b1((yyval).mode,(yyvsp[(4) - (4)]).value);
2753                                 }
2754      break;
2755
2756    case 112:
2757 +
2758 +/* Line 1806 of yacc.c  */
2759  #line 587 "parser.y"
2760      {
2761 -                                       set_md(yyval.mode,0);
2762 -                                       set_ov(yyval.mode,0);
2763 -                                       set_sz(yyval.mode,2);
2764 -                                       set_b1(yyval.mode,yyvsp[-2].value);
2765 -                                       set_b2(yyval.mode,yyvsp[0].value);
2766 +                                       set_md((yyval).mode,0);
2767 +                                       set_ov((yyval).mode,0);
2768 +                                       set_sz((yyval).mode,2);
2769 +                                       set_b1((yyval).mode,(yyvsp[(1) - (3)]).value);
2770 +                                       set_b2((yyval).mode,(yyvsp[(3) - (3)]).value);
2771                                 }
2772      break;
2773
2774    case 113:
2775 +
2776 +/* Line 1806 of yacc.c  */
2777  #line 597 "parser.y"
2778      {
2779 -                                       set_md(yyval.mode,0);
2780 -                                       set_ov(yyval.mode,yyvsp[-2].value);
2781 -                                       set_sz(yyval.mode,1);
2782 -                                       set_b1(yyval.mode,yyvsp[0].value);
2783 +                                       set_md((yyval).mode,0);
2784 +                                       set_ov((yyval).mode,(yyvsp[(1) - (3)]).value);
2785 +                                       set_sz((yyval).mode,1);
2786 +                                       set_b1((yyval).mode,(yyvsp[(3) - (3)]).value);
2787                                 }
2788      break;
2789
2790    case 114:
2791 +
2792 +/* Line 1806 of yacc.c  */
2793  #line 604 "parser.y"
2794      {
2795 -                                       set_md(yyval.mode,1);
2796 -                                       set_ov(yyval.mode,0);
2797 -                                       set_sz(yyval.mode,2);
2798 -                                       set_b1(yyval.mode,yyvsp[-2].value);
2799 -                                       set_b2(yyval.mode,yyvsp[0].value);
2800 +                                       set_md((yyval).mode,1);
2801 +                                       set_ov((yyval).mode,0);
2802 +                                       set_sz((yyval).mode,2);
2803 +                                       set_b1((yyval).mode,(yyvsp[(1) - (3)]).value);
2804 +                                       set_b2((yyval).mode,(yyvsp[(3) - (3)]).value);
2805                                 }
2806      break;
2807
2808    case 115:
2809 +
2810 +/* Line 1806 of yacc.c  */
2811  #line 614 "parser.y"
2812      {
2813 -                                       set_md(yyval.mode,0);
2814 -                                       set_ov(yyval.mode,yyvsp[-2].value);
2815 -                                       set_sz(yyval.mode,0);
2816 +                                       set_md((yyval).mode,0);
2817 +                                       set_ov((yyval).mode,(yyvsp[(1) - (3)]).value);
2818 +                                       set_sz((yyval).mode,0);
2819                                 }
2820      break;
2821
2822    case 116:
2823 +
2824 +/* Line 1806 of yacc.c  */
2825  #line 620 "parser.y"
2826      {
2827 -                                       set_md(yyval.mode,1);
2828 -                                       set_ov(yyval.mode,yyvsp[-2].value);
2829 -                                       set_sz(yyval.mode,1);
2830 -                                       set_b1(yyval.mode,yyvsp[0].value);
2831 +                                       set_md((yyval).mode,1);
2832 +                                       set_ov((yyval).mode,(yyvsp[(1) - (3)]).value);
2833 +                                       set_sz((yyval).mode,1);
2834 +                                       set_b1((yyval).mode,(yyvsp[(3) - (3)]).value);
2835                                 }
2836      break;
2837
2838    case 117:
2839 +
2840 +/* Line 1806 of yacc.c  */
2841  #line 627 "parser.y"
2842      {
2843 -                                       set_md(yyval.mode,2);
2844 -                                       set_ov(yyval.mode,yyvsp[-3].value);
2845 -                                       set_sz(yyval.mode,1);
2846 -                                       set_b1(yyval.mode,yyvsp[0].value);
2847 +                                       set_md((yyval).mode,2);
2848 +                                       set_ov((yyval).mode,(yyvsp[(1) - (4)]).value);
2849 +                                       set_sz((yyval).mode,1);
2850 +                                       set_b1((yyval).mode,(yyvsp[(4) - (4)]).value);
2851                                 }
2852      break;
2853
2854    case 118:
2855 +
2856 +/* Line 1806 of yacc.c  */
2857  #line 634 "parser.y"
2858      {
2859 -                                       set_md(yyval.mode,3);
2860 -                                       set_ov(yyval.mode,yyvsp[0].value);
2861 -                                       set_sz(yyval.mode,1);
2862 -                                       set_b1(yyval.mode,yyvsp[-2].value);
2863 +                                       set_md((yyval).mode,3);
2864 +                                       set_ov((yyval).mode,(yyvsp[(3) - (3)]).value);
2865 +                                       set_sz((yyval).mode,1);
2866 +                                       set_b1((yyval).mode,(yyvsp[(1) - (3)]).value);
2867                                 }
2868      break;
2869
2870    case 119:
2871 +
2872 +/* Line 1806 of yacc.c  */
2873  #line 641 "parser.y"
2874      {
2875 -                                       set_md(yyval.mode,4);
2876 -                                       set_ov(yyval.mode,0);
2877 -                                       set_sz(yyval.mode,2);
2878 -                                       set_b1(yyval.mode,yyvsp[0].value);
2879 -                                       set_b2(yyval.mode,yyvsp[-2].value);
2880 +                                       set_md((yyval).mode,4);
2881 +                                       set_ov((yyval).mode,0);
2882 +                                       set_sz((yyval).mode,2);
2883 +                                       set_b1((yyval).mode,(yyvsp[(3) - (3)]).value);
2884 +                                       set_b2((yyval).mode,(yyvsp[(1) - (3)]).value);
2885                                 }
2886      break;
2887
2888    case 120:
2889 +
2890 +/* Line 1806 of yacc.c  */
2891  #line 649 "parser.y"
2892      {
2893 -                                       set_md(yyval.mode,5);
2894 -                                       set_ov(yyval.mode,yyvsp[0].value);
2895 -                                       set_sz(yyval.mode,1);
2896 -                                       set_b1(yyval.mode,yyvsp[-3].value);
2897 +                                       set_md((yyval).mode,5);
2898 +                                       set_ov((yyval).mode,(yyvsp[(4) - (4)]).value);
2899 +                                       set_sz((yyval).mode,1);
2900 +                                       set_b1((yyval).mode,(yyvsp[(1) - (4)]).value);
2901                                 }
2902      break;
2903
2904    case 121:
2905 +
2906 +/* Line 1806 of yacc.c  */
2907  #line 656 "parser.y"
2908      {
2909 -                                       set_md(yyval.mode,6);
2910 -                                       set_ov(yyval.mode,yyvsp[-2].value);
2911 -                                       set_sz(yyval.mode,0);
2912 +                                       set_md((yyval).mode,6);
2913 +                                       set_ov((yyval).mode,(yyvsp[(2) - (4)]).value);
2914 +                                       set_sz((yyval).mode,0);
2915                                 }
2916      break;
2917
2918    case 122:
2919 +
2920 +/* Line 1806 of yacc.c  */
2921  #line 662 "parser.y"
2922      {
2923 -                                       set_md(yyval.mode,7);
2924 -                                       set_ov(yyval.mode,yyvsp[-2].value);
2925 -                                       set_sz(yyval.mode,1);
2926 -                                       set_b1(yyval.mode,yyvsp[0].value);
2927 +                                       set_md((yyval).mode,7);
2928 +                                       set_ov((yyval).mode,(yyvsp[(2) - (4)]).value);
2929 +                                       set_sz((yyval).mode,1);
2930 +                                       set_b1((yyval).mode,(yyvsp[(4) - (4)]).value);
2931                                 }
2932      break;
2933
2934    case 123:
2935 +
2936 +/* Line 1806 of yacc.c  */
2937  #line 669 "parser.y"
2938      {
2939 -                                       set_md(yyval.mode,8);
2940 -                                       set_ov(yyval.mode,yyvsp[-3].value);
2941 -                                       set_sz(yyval.mode,1);
2942 -                                       set_b1(yyval.mode,yyvsp[0].value);
2943 +                                       set_md((yyval).mode,8);
2944 +                                       set_ov((yyval).mode,(yyvsp[(2) - (5)]).value);
2945 +                                       set_sz((yyval).mode,1);
2946 +                                       set_b1((yyval).mode,(yyvsp[(5) - (5)]).value);
2947                                 }
2948      break;
2949
2950    case 124:
2951 +
2952 +/* Line 1806 of yacc.c  */
2953  #line 676 "parser.y"
2954      {
2955 -                               set_md(yyval.mode,9);
2956 -                               set_ov(yyval.mode,0);
2957 -                               set_sz(yyval.mode,2);
2958 -                               set_b1(yyval.mode, (yyvsp[0].value & 0xff00) >> 8 );
2959 -                               set_b2(yyval.mode, (yyvsp[0].value & 0x00ff) );
2960 +                               set_md((yyval).mode,9);
2961 +                               set_ov((yyval).mode,0);
2962 +                               set_sz((yyval).mode,2);
2963 +                               set_b1((yyval).mode, ((yyvsp[(4) - (4)]).value & 0xff00) >> 8 );
2964 +                               set_b2((yyval).mode, ((yyvsp[(4) - (4)]).value & 0x00ff) );
2965                         }
2966      break;
2967
2968    case 125:
2969 +
2970 +/* Line 1806 of yacc.c  */
2971  #line 684 "parser.y"
2972      {
2973 -                                       set_md(yyval.mode,10);
2974 -                                       set_ov(yyval.mode,0);
2975 -                                       set_sz(yyval.mode,1);
2976 -                                       set_b1(yyval.mode,yyvsp[0].value);
2977 +                                       set_md((yyval).mode,10);
2978 +                                       set_ov((yyval).mode,0);
2979 +                                       set_sz((yyval).mode,1);
2980 +                                       set_b1((yyval).mode,(yyvsp[(3) - (3)]).value);
2981                                 }
2982      break;
2983
2984    case 126:
2985 +
2986 +/* Line 1806 of yacc.c  */
2987  #line 700 "parser.y"
2988      {
2989 -                                       set_md(yyval.mode,11);
2990 -                                       set_ov(yyval.mode,0);
2991 -                                       set_sz(yyval.mode,1);
2992 -                                       set_b1(yyval.mode,yyvsp[-2].value);
2993 +                                       set_md((yyval).mode,11);
2994 +                                       set_ov((yyval).mode,0);
2995 +                                       set_sz((yyval).mode,1);
2996 +                                       set_b1((yyval).mode,(yyvsp[(1) - (3)]).value);
2997                                 }
2998      break;
2999
3000    case 127:
3001 +
3002 +/* Line 1806 of yacc.c  */
3003  #line 707 "parser.y"
3004      {
3005         if( pass2 ) {
3006 -               if( !isbit8(yyvsp[-3].value) )
3007 +               if( !isbit8((yyvsp[(1) - (4)]).value) )
3008                         warn("Bit address exceeds 8-bits");
3009 -               if( isbmram(yyvsp[-3].value) )
3010 -                       set_b1(yyval.mode, (yyvsp[-3].value-0x20)*8+ yyvsp[-2].value );
3011 -               else if( isbmsfr(yyvsp[-3].value) )
3012 -                       set_b1(yyval.mode, yyvsp[-3].value + yyvsp[-2].value );
3013 +               if( isbmram((yyvsp[(1) - (4)]).value) )
3014 +                       set_b1((yyval).mode, ((yyvsp[(1) - (4)]).value-0x20)*8+ (yyvsp[(2) - (4)]).value );
3015 +               else if( isbmsfr((yyvsp[(1) - (4)]).value) )
3016 +                       set_b1((yyval).mode, (yyvsp[(1) - (4)]).value + (yyvsp[(2) - (4)]).value );
3017                 else
3018                         warn("Invalid bit addressable RAM location");
3019         }
3020 -       set_md(yyval.mode,11);
3021 -       set_ov(yyval.mode,0);
3022 -       set_sz(yyval.mode,1);
3023 +       set_md((yyval).mode,11);
3024 +       set_ov((yyval).mode,0);
3025 +       set_sz((yyval).mode,1);
3026  }
3027      break;
3028
3029    case 128:
3030 +
3031 +/* Line 1806 of yacc.c  */
3032  #line 726 "parser.y"
3033      {
3034 -                                       set_md(yyval.mode,0);
3035 -                                       set_ov(yyval.mode,0);
3036 -                                       set_sz(yyval.mode,0);
3037 +                                       set_md((yyval).mode,0);
3038 +                                       set_ov((yyval).mode,0);
3039 +                                       set_sz((yyval).mode,0);
3040                                 }
3041      break;
3042
3043    case 129:
3044 +
3045 +/* Line 1806 of yacc.c  */
3046  #line 733 "parser.y"
3047      {
3048 -                                       set_md(yyval.mode,1);
3049 -                                       set_ov(yyval.mode,yyvsp[0].value);
3050 -                                       set_sz(yyval.mode,0);
3051 +                                       set_md((yyval).mode,1);
3052 +                                       set_ov((yyval).mode,(yyvsp[(1) - (1)]).value);
3053 +                                       set_sz((yyval).mode,0);
3054                                 }
3055      break;
3056
3057    case 130:
3058 +
3059 +/* Line 1806 of yacc.c  */
3060  #line 739 "parser.y"
3061      {
3062 -                                       set_md(yyval.mode,2);
3063 -                                       set_ov(yyval.mode,0);
3064 -                                       set_sz(yyval.mode,1);
3065 -                                       set_b1(yyval.mode,yyvsp[0].value);
3066 +                                       set_md((yyval).mode,2);
3067 +                                       set_ov((yyval).mode,0);
3068 +                                       set_sz((yyval).mode,1);
3069 +                                       set_b1((yyval).mode,(yyvsp[(1) - (1)]).value);
3070                                 }
3071      break;
3072
3073    case 131:
3074 +
3075 +/* Line 1806 of yacc.c  */
3076  #line 746 "parser.y"
3077      {
3078 -                                       set_md(yyval.mode,3);
3079 -                                       set_ov(yyval.mode,yyvsp[0].value);
3080 -                                       set_sz(yyval.mode,0);
3081 +                                       set_md((yyval).mode,3);
3082 +                                       set_ov((yyval).mode,(yyvsp[(2) - (2)]).value);
3083 +                                       set_sz((yyval).mode,0);
3084                                 }
3085      break;
3086
3087    case 132:
3088 +
3089 +/* Line 1806 of yacc.c  */
3090  #line 754 "parser.y"
3091      {
3092 -                                       set_md(yyval.mode,0);
3093 -                                       set_ov(yyval.mode,0);
3094 -                                       set_sz(yyval.mode,0);
3095 +                                       set_md((yyval).mode,0);
3096 +                                       set_ov((yyval).mode,0);
3097 +                                       set_sz((yyval).mode,0);
3098                                 }
3099      break;
3100
3101    case 133:
3102 +
3103 +/* Line 1806 of yacc.c  */
3104  #line 760 "parser.y"
3105      {
3106 -                                       set_md(yyval.mode,1);
3107 -                                       set_ov(yyval.mode,0);
3108 -                                       set_sz(yyval.mode,0);
3109 +                                       set_md((yyval).mode,1);
3110 +                                       set_ov((yyval).mode,0);
3111 +                                       set_sz((yyval).mode,0);
3112                                 }
3113      break;
3114
3115    case 134:
3116 +
3117 +/* Line 1806 of yacc.c  */
3118  #line 766 "parser.y"
3119      {
3120 -                                       set_md(yyval.mode,2);
3121 -                                       set_ov(yyval.mode,0);
3122 -                                       set_sz(yyval.mode,1);
3123 -                                       set_b1(yyval.mode,yyvsp[0].value);
3124 +                                       set_md((yyval).mode,2);
3125 +                                       set_ov((yyval).mode,0);
3126 +                                       set_sz((yyval).mode,1);
3127 +                                       set_b1((yyval).mode,(yyvsp[(1) - (1)]).value);
3128                                 }
3129      break;
3130
3131    case 135:
3132 +
3133 +/* Line 1806 of yacc.c  */
3134  #line 775 "parser.y"
3135      {
3136 -                                       set_md(yyval.mode,0);
3137 -                                       set_ov(yyval.mode,0);
3138 -                                       set_sz(yyval.mode,2);
3139 -                                       set_b1(yyval.mode,yyvsp[-2].value);
3140 -                                       set_b2(yyval.mode,yyvsp[0].value);
3141 +                                       set_md((yyval).mode,0);
3142 +                                       set_ov((yyval).mode,0);
3143 +                                       set_sz((yyval).mode,2);
3144 +                                       set_b1((yyval).mode,(yyvsp[(3) - (5)]).value);
3145 +                                       set_b2((yyval).mode,(yyvsp[(5) - (5)]).value);
3146                                 }
3147      break;
3148
3149    case 136:
3150 +
3151 +/* Line 1806 of yacc.c  */
3152  #line 783 "parser.y"
3153      {
3154 -                                       set_md(yyval.mode,1);
3155 -                                       set_ov(yyval.mode,0);
3156 -                                       set_sz(yyval.mode,2);
3157 -                                       set_b1(yyval.mode,yyvsp[-2].value);
3158 -                                       set_b2(yyval.mode,yyvsp[0].value);
3159 +                                       set_md((yyval).mode,1);
3160 +                                       set_ov((yyval).mode,0);
3161 +                                       set_sz((yyval).mode,2);
3162 +                                       set_b1((yyval).mode,(yyvsp[(4) - (6)]).value);
3163 +                                       set_b2((yyval).mode,(yyvsp[(6) - (6)]).value);
3164                                 }
3165      break;
3166
3167    case 137:
3168 +
3169 +/* Line 1806 of yacc.c  */
3170  #line 791 "parser.y"
3171      {
3172 -                                       set_md(yyval.mode,2);
3173 -                                       set_ov(yyval.mode,yyvsp[-5].value);
3174 -                                       set_sz(yyval.mode,2);
3175 -                                       set_b1(yyval.mode,yyvsp[-2].value);
3176 -                                       set_b2(yyval.mode,yyvsp[0].value);
3177 +                                       set_md((yyval).mode,2);
3178 +                                       set_ov((yyval).mode,(yyvsp[(1) - (6)]).value);
3179 +                                       set_sz((yyval).mode,2);
3180 +                                       set_b1((yyval).mode,(yyvsp[(4) - (6)]).value);
3181 +                                       set_b2((yyval).mode,(yyvsp[(6) - (6)]).value);
3182                                 }
3183      break;
3184
3185    case 138:
3186 +
3187 +/* Line 1806 of yacc.c  */
3188  #line 799 "parser.y"
3189      {
3190 -                                       set_md(yyval.mode,3);
3191 -                                       set_ov(yyval.mode,yyvsp[-5].value);
3192 -                                       set_sz(yyval.mode,2);
3193 -                                       set_b1(yyval.mode,yyvsp[-2].value);
3194 -                                       set_b2(yyval.mode,yyvsp[0].value);
3195 +                                       set_md((yyval).mode,3);
3196 +                                       set_ov((yyval).mode,(yyvsp[(2) - (7)]).value);
3197 +                                       set_sz((yyval).mode,2);
3198 +                                       set_b1((yyval).mode,(yyvsp[(5) - (7)]).value);
3199 +                                       set_b2((yyval).mode,(yyvsp[(7) - (7)]).value);
3200                                 }
3201      break;
3202
3203    case 139:
3204 +
3205 +/* Line 1806 of yacc.c  */
3206  #line 809 "parser.y"
3207      {
3208                 long offset;
3209                 if( pass2 ) {
3210 -                       offset = yyvsp[0].val.v - (lc+3);
3211 +                       offset = (yyvsp[(1) - (1)]).val.v - (lc+3);
3212                         if( offset > 127 || offset < -128 )
3213                            warn("Relative offset exceeds -128 / +127");
3214 -                       yyval.value = offset;
3215 +                       (yyval).value = offset;
3216                 }
3217  }
3218      break;
3219
3220    case 140:
3221 +
3222 +/* Line 1806 of yacc.c  */
3223  #line 826 "parser.y"
3224      {
3225                 long offset;
3226                 if( pass2 ) {
3227 -                       offset = yyvsp[0].val.v - (lc+2); /* different! */
3228 +                       offset = (yyvsp[(1) - (1)]).val.v - (lc+2); /* different! */
3229                         if( offset > 127 || offset < -128 )
3230                            warn("Relative offset exceeds -128 / +127");
3231 -                       yyval.value = offset;
3232 +                       (yyval).value = offset;
3233                 }
3234  }
3235      break;
3236
3237    case 141:
3238 +
3239 +/* Line 1806 of yacc.c  */
3240  #line 839 "parser.y"
3241      {
3242         if( pass2 ) {
3243 -               if( !isbit8(yyvsp[-1].value) )
3244 +               if( !isbit8((yyvsp[(1) - (2)]).value) )
3245                         warn("Bit address exceeds 8-bits");
3246 -               if( isbmram(yyvsp[-1].value) )
3247 -                       yyval.value = (yyvsp[-1].value-0x20)*8+yyvsp[0].value;
3248 -               else if( isbmsfr(yyvsp[-1].value) )
3249 -                       yyval.value = yyvsp[-1].value + yyvsp[0].value;
3250 +               if( isbmram((yyvsp[(1) - (2)]).value) )
3251 +                       (yyval).value = ((yyvsp[(1) - (2)]).value-0x20)*8+(yyvsp[(2) - (2)]).value;
3252 +               else if( isbmsfr((yyvsp[(1) - (2)]).value) )
3253 +                       (yyval).value = (yyvsp[(1) - (2)]).value + (yyvsp[(2) - (2)]).value;
3254                 else
3255                         warn("Invalid bit addressable RAM location");
3256         }
3257 @@ -2529,201 +3173,259 @@ yyreduce:
3258      break;
3259
3260    case 142:
3261 +
3262 +/* Line 1806 of yacc.c  */
3263  #line 852 "parser.y"
3264      {
3265         if( pass2 ) {
3266 -               if( !isbit8(yyvsp[0].value) )
3267 +               if( !isbit8((yyvsp[(1) - (1)]).value) )
3268                         warn("Bit address exceeds 8-bits");
3269 -               yyval.value = yyvsp[0].value;
3270 +               (yyval).value = (yyvsp[(1) - (1)]).value;
3271         }
3272  }
3273      break;
3274
3275    case 143:
3276 +
3277 +/* Line 1806 of yacc.c  */
3278  #line 862 "parser.y"
3279      {
3280 -       if( yyvsp[0].sym->type == UNDEF && pass2 )
3281 -               warn("Symbol %s undefined",yyvsp[0].sym->name);
3282 -       yyval.value = yyvsp[0].sym->value;
3283 +       if( (yyvsp[(1) - (1)]).sym->type == UNDEF && pass2 )
3284 +               warn("Symbol %s undefined",(yyvsp[(1) - (1)]).sym->name);
3285 +       (yyval).value = (yyvsp[(1) - (1)]).sym->value;
3286  }
3287      break;
3288
3289    case 144:
3290 +
3291 +/* Line 1806 of yacc.c  */
3292  #line 867 "parser.y"
3293 -    { yyval.value = yyvsp[0].value; }
3294 +    { (yyval).value = (yyvsp[(1) - (1)]).value; }
3295      break;
3296
3297    case 145:
3298 +
3299 +/* Line 1806 of yacc.c  */
3300  #line 870 "parser.y"
3301 -    { yyval.value = 0; }
3302 +    { (yyval).value = 0; }
3303      break;
3304
3305    case 146:
3306 +
3307 +/* Line 1806 of yacc.c  */
3308  #line 871 "parser.y"
3309 -    { yyval.value = 1; }
3310 +    { (yyval).value = 1; }
3311      break;
3312
3313    case 147:
3314 +
3315 +/* Line 1806 of yacc.c  */
3316  #line 872 "parser.y"
3317 -    { yyval.value = 2; }
3318 +    { (yyval).value = 2; }
3319      break;
3320
3321    case 148:
3322 +
3323 +/* Line 1806 of yacc.c  */
3324  #line 873 "parser.y"
3325 -    { yyval.value = 3; }
3326 +    { (yyval).value = 3; }
3327      break;
3328
3329    case 149:
3330 +
3331 +/* Line 1806 of yacc.c  */
3332  #line 874 "parser.y"
3333 -    { yyval.value = 4; }
3334 +    { (yyval).value = 4; }
3335      break;
3336
3337    case 150:
3338 +
3339 +/* Line 1806 of yacc.c  */
3340  #line 875 "parser.y"
3341 -    { yyval.value = 5; }
3342 +    { (yyval).value = 5; }
3343      break;
3344
3345    case 151:
3346 +
3347 +/* Line 1806 of yacc.c  */
3348  #line 876 "parser.y"
3349 -    { yyval.value = 6; }
3350 +    { (yyval).value = 6; }
3351      break;
3352
3353    case 152:
3354 +
3355 +/* Line 1806 of yacc.c  */
3356  #line 877 "parser.y"
3357 -    { yyval.value = 7; }
3358 +    { (yyval).value = 7; }
3359      break;
3360
3361    case 153:
3362 +
3363 +/* Line 1806 of yacc.c  */
3364  #line 880 "parser.y"
3365 -    { yyval.value = 0; }
3366 +    { (yyval).value = 0; }
3367      break;
3368
3369    case 154:
3370 +
3371 +/* Line 1806 of yacc.c  */
3372  #line 881 "parser.y"
3373 -    { yyval.value = 1; }
3374 +    { (yyval).value = 1; }
3375      break;
3376
3377    case 155:
3378 +
3379 +/* Line 1806 of yacc.c  */
3380  #line 883 "parser.y"
3381 -    { yyval.value = 0;
3382 +    { (yyval).value = 0;
3383                                   warn("Illegal indirect register: @r2"); }
3384      break;
3385
3386    case 156:
3387 +
3388 +/* Line 1806 of yacc.c  */
3389  #line 886 "parser.y"
3390 -    { yyval.value = 0;
3391 +    { (yyval).value = 0;
3392                                   warn("Illegal indirect register: @r3"); }
3393      break;
3394
3395    case 157:
3396 +
3397 +/* Line 1806 of yacc.c  */
3398  #line 889 "parser.y"
3399 -    { yyval.value = 0;
3400 +    { (yyval).value = 0;
3401                                   warn("Illegal indirect register: @r4"); }
3402      break;
3403
3404    case 158:
3405 +
3406 +/* Line 1806 of yacc.c  */
3407  #line 892 "parser.y"
3408 -    { yyval.value = 0;
3409 +    { (yyval).value = 0;
3410                                   warn("Illegal indirect register: @r5"); }
3411      break;
3412
3413    case 159:
3414 +
3415 +/* Line 1806 of yacc.c  */
3416  #line 895 "parser.y"
3417 -    { yyval.value = 0;
3418 +    { (yyval).value = 0;
3419                                   warn("Illegal indirect register: @r6"); }
3420      break;
3421
3422    case 160:
3423 +
3424 +/* Line 1806 of yacc.c  */
3425  #line 898 "parser.y"
3426 -    { yyval.value = 0;
3427 +    { (yyval).value = 0;
3428                                   warn("Illegal indirect register: @r7"); }
3429      break;
3430
3431    case 161:
3432 +
3433 +/* Line 1806 of yacc.c  */
3434  #line 903 "parser.y"
3435      {
3436         if( pass2 ) {
3437 -               if( !isbit8(yyvsp[0].val.v) )
3438 +               if( !isbit8((yyvsp[(1) - (1)]).val.v) )
3439                         warn("Expression greater than 8-bits");
3440         }
3441 -       yyval.value = yyvsp[0].val.v;
3442 +       (yyval).value = (yyvsp[(1) - (1)]).val.v;
3443  }
3444      break;
3445
3446    case 162:
3447 +
3448 +/* Line 1806 of yacc.c  */
3449  #line 913 "parser.y"
3450      {
3451         if( pass2 ) {
3452 -               if( !isbit16(yyvsp[0].val.v) )
3453 +               if( !isbit16((yyvsp[(1) - (1)]).val.v) )
3454                         warn("Expression greater than 16-bits");
3455         }
3456 -       yyval.value = yyvsp[0].val.v;
3457 +       (yyval).value = (yyvsp[(1) - (1)]).val.v;
3458  }
3459      break;
3460
3461    case 163:
3462 +
3463 +/* Line 1806 of yacc.c  */
3464  #line 923 "parser.y"
3465      {
3466                 if( pass2 ) {
3467 -                       if( !isbit16(yyvsp[0].val.v)  )
3468 +                       if( !isbit16((yyvsp[(1) - (1)]).val.v)  )
3469                                 warn("Address greater than 16-bits");
3470 -                       if( (yyvsp[0].val.v & size11) != ((lc+2) & size11) )
3471 +                       if( ((yyvsp[(1) - (1)]).val.v & size11) != ((lc+2) & size11) )
3472                                 warn("Address outside current 2K page");
3473                 }
3474 -               set_md(yyval.mode,0);
3475 -               set_ov(yyval.mode, (yyvsp[0].val.v&0x0700)>>3 );
3476 -               set_sz(yyval.mode,1);
3477 -               set_b1(yyval.mode,yyvsp[0].val.v&0x00ff);
3478 +               set_md((yyval).mode,0);
3479 +               set_ov((yyval).mode, ((yyvsp[(1) - (1)]).val.v&0x0700)>>3 );
3480 +               set_sz((yyval).mode,1);
3481 +               set_b1((yyval).mode,(yyvsp[(1) - (1)]).val.v&0x00ff);
3482  }
3483      break;
3484
3485    case 164:
3486 +
3487 +/* Line 1806 of yacc.c  */
3488  #line 938 "parser.y"
3489      {
3490                 if( pass2 ) {
3491 -                       if( !isbit16(yyvsp[0].val.v)  )
3492 +                       if( !isbit16((yyvsp[(1) - (1)]).val.v)  )
3493                                 warn("Address greater than 16-bits");
3494                 }
3495 -               set_md(yyval.mode,0);
3496 -               set_ov(yyval.mode, 0 );
3497 -               set_sz(yyval.mode,2);
3498 -               set_b1(yyval.mode, (yyvsp[0].val.v & 0xff00 ) >> 8 );
3499 -               set_b2(yyval.mode, (yyvsp[0].val.v & 0x00ff ) );
3500 +               set_md((yyval).mode,0);
3501 +               set_ov((yyval).mode, 0 );
3502 +               set_sz((yyval).mode,2);
3503 +               set_b1((yyval).mode, ((yyvsp[(1) - (1)]).val.v & 0xff00 ) >> 8 );
3504 +               set_b2((yyval).mode, ((yyvsp[(1) - (1)]).val.v & 0x00ff ) );
3505  }
3506      break;
3507
3508    case 165:
3509 +
3510 +/* Line 1806 of yacc.c  */
3511  #line 952 "parser.y"
3512      {
3513                 long offset=0;
3514                 if( pass2 ) {
3515 -                       offset = yyvsp[0].val.v - (lc+2);
3516 +                       offset = (yyvsp[(1) - (1)]).val.v - (lc+2);
3517                         if( offset>127 || offset<-128 )
3518                            warn("Relative offset exceeds -128 / +127");
3519                 }
3520 -               set_md(yyval.mode,0);
3521 -               set_ov(yyval.mode,0);
3522 -               set_sz(yyval.mode,1);
3523 -               set_b1(yyval.mode,offset);
3524 +               set_md((yyval).mode,0);
3525 +               set_ov((yyval).mode,0);
3526 +               set_sz((yyval).mode,1);
3527 +               set_b1((yyval).mode,offset);
3528
3529  }
3530      break;
3531
3532
3533 -    }
3534 -
3535 -/* Line 1010 of yacc.c.  */
3536 -#line 2717 "y.tab.c"
3537 -\f
3538 -  yyvsp -= yylen;
3539 -  yyssp -= yylen;
3540 -
3541
3542 +/* Line 1806 of yacc.c  */
3543 +#line 3408 "y.tab.c"
3544 +      default: break;
3545 +    }
3546 +  /* User semantic actions sometimes alter yychar, and that requires
3547 +     that yytoken be updated with the new translation.  We take the
3548 +     approach of translating immediately before every use of yytoken.
3549 +     One alternative is translating here after every semantic action,
3550 +     but that translation would be missed if the semantic action invokes
3551 +     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
3552 +     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
3553 +     incorrect destructor might then be invoked immediately.  In the
3554 +     case of YYERROR or YYBACKUP, subsequent parser actions might lead
3555 +     to an incorrect destructor call or verbose syntax error message
3556 +     before the lookahead is translated.  */
3557 +  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3558 +
3559 +  YYPOPSTACK (yylen);
3560 +  yylen = 0;
3561    YY_STACK_PRINT (yyss, yyssp);
3562
3563    *++yyvsp = yyval;
3564
3565 -
3566    /* Now `shift' the result of the reduction.  Determine what state
3567       that goes to, based on the state we popped back to and the rule
3568       number reduced by.  */
3569 @@ -2743,70 +3445,48 @@ yyreduce:
3570  | yyerrlab -- here on detecting error |
3571  `------------------------------------*/
3572  yyerrlab:
3573 +  /* Make sure we have latest lookahead translation.  See comments at
3574 +     user semantic actions for why this is necessary.  */
3575 +  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
3576 +
3577    /* If not already recovering from an error, report this error.  */
3578    if (!yyerrstatus)
3579      {
3580        ++yynerrs;
3581 -#if YYERROR_VERBOSE
3582 -      yyn = yypact[yystate];
3583 -
3584 -      if (YYPACT_NINF < yyn && yyn < YYLAST)
3585 -       {
3586 -         YYSIZE_T yysize = 0;
3587 -         int yytype = YYTRANSLATE (yychar);
3588 -         const char* yyprefix;
3589 -         char *yymsg;
3590 -         int yyx;
3591 -
3592 -         /* Start YYX at -YYN if negative to avoid negative indexes in
3593 -            YYCHECK.  */
3594 -         int yyxbegin = yyn < 0 ? -yyn : 0;
3595 -
3596 -         /* Stay within bounds of both yycheck and yytname.  */
3597 -         int yychecklim = YYLAST - yyn;
3598 -         int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3599 -         int yycount = 0;
3600 -
3601 -         yyprefix = ", expecting ";
3602 -         for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3603 -           if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3604 -             {
3605 -               yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
3606 -               yycount += 1;
3607 -               if (yycount == 5)
3608 -                 {
3609 -                   yysize = 0;
3610 -                   break;
3611 -                 }
3612 -             }
3613 -         yysize += (sizeof ("syntax error, unexpected ")
3614 -                    + yystrlen (yytname[yytype]));
3615 -         yymsg = (char *) YYSTACK_ALLOC (yysize);
3616 -         if (yymsg != 0)
3617 -           {
3618 -             char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
3619 -             yyp = yystpcpy (yyp, yytname[yytype]);
3620 -
3621 -             if (yycount < 5)
3622 -               {
3623 -                 yyprefix = ", expecting ";
3624 -                 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3625 -                   if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3626 -                     {
3627 -                       yyp = yystpcpy (yyp, yyprefix);
3628 -                       yyp = yystpcpy (yyp, yytname[yyx]);
3629 -                       yyprefix = " or ";
3630 -                     }
3631 -               }
3632 -             yyerror (yymsg);
3633 -             YYSTACK_FREE (yymsg);
3634 -           }
3635 -         else
3636 -           yyerror ("syntax error; also virtual memory exhausted");
3637 -       }
3638 -      else
3639 -#endif /* YYERROR_VERBOSE */
3640 -       yyerror ("syntax error");
3641 +#if ! YYERROR_VERBOSE
3642 +      yyerror (YY_("syntax error"));
3643 +#else
3644 +# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
3645 +                                        yyssp, yytoken)
3646 +      {
3647 +        char const *yymsgp = YY_("syntax error");
3648 +        int yysyntax_error_status;
3649 +        yysyntax_error_status = YYSYNTAX_ERROR;
3650 +        if (yysyntax_error_status == 0)
3651 +          yymsgp = yymsg;
3652 +        else if (yysyntax_error_status == 1)
3653 +          {
3654 +            if (yymsg != yymsgbuf)
3655 +              YYSTACK_FREE (yymsg);
3656 +            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
3657 +            if (!yymsg)
3658 +              {
3659 +                yymsg = yymsgbuf;
3660 +                yymsg_alloc = sizeof yymsgbuf;
3661 +                yysyntax_error_status = 2;
3662 +              }
3663 +            else
3664 +              {
3665 +                yysyntax_error_status = YYSYNTAX_ERROR;
3666 +                yymsgp = yymsg;
3667 +              }
3668 +          }
3669 +        yyerror (yymsgp);
3670 +        if (yysyntax_error_status == 2)
3671 +          goto yyexhaustedlab;
3672 +      }
3673 +# undef YYSYNTAX_ERROR
3674 +#endif
3675      }
3676
3677
3678 @@ -2817,25 +3497,16 @@ yyerrlab:
3679          error, discard it.  */
3680
3681        if (yychar <= YYEOF)
3682 -        {
3683 -          /* If at end of input, pop the error token,
3684 -            then the rest of the stack, then return failure.  */
3685 +       {
3686 +         /* Return failure if at end of input.  */
3687           if (yychar == YYEOF)
3688 -            for (;;)
3689 -              {
3690 -                YYPOPSTACK;
3691 -                if (yyssp == yyss)
3692 -                  YYABORT;
3693 -                YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
3694 -                yydestruct (yystos[*yyssp], yyvsp);
3695 -              }
3696 -        }
3697 +           YYABORT;
3698 +       }
3699        else
3700         {
3701 -         YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
3702 -         yydestruct (yytoken, &yylval);
3703 +         yydestruct ("Error: discarding",
3704 +                     yytoken, &yylval);
3705           yychar = YYEMPTY;
3706 -
3707         }
3708      }
3709
3710 @@ -2849,15 +3520,17 @@ yyerrlab:
3711  `---------------------------------------------------*/
3712  yyerrorlab:
3713
3714 -#ifdef __GNUC__
3715 -  /* Pacify GCC when the user code never invokes YYERROR and the label
3716 -     yyerrorlab therefore never appears in user code.  */
3717 -  if (0)
3718 +  /* Pacify compilers like GCC when the user code never invokes
3719 +     YYERROR and the label yyerrorlab therefore never appears in user
3720 +     code.  */
3721 +  if (/*CONSTCOND*/ 0)
3722       goto yyerrorlab;
3723 -#endif
3724
3725 -  yyvsp -= yylen;
3726 -  yyssp -= yylen;
3727 +  /* Do not reclaim the symbols of the rule which action triggered
3728 +     this YYERROR.  */
3729 +  YYPOPSTACK (yylen);
3730 +  yylen = 0;
3731 +  YY_STACK_PRINT (yyss, yyssp);
3732    yystate = *yyssp;
3733    goto yyerrlab1;
3734
3735 @@ -2871,7 +3544,7 @@ yyerrlab1:
3736    for (;;)
3737      {
3738        yyn = yypact[yystate];
3739 -      if (yyn != YYPACT_NINF)
3740 +      if (!yypact_value_is_default (yyn))
3741         {
3742           yyn += YYTERROR;
3743           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3744 @@ -2886,21 +3559,20 @@ yyerrlab1:
3745        if (yyssp == yyss)
3746         YYABORT;
3747
3748 -      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
3749 -      yydestruct (yystos[yystate], yyvsp);
3750 -      YYPOPSTACK;
3751 +
3752 +      yydestruct ("Error: popping",
3753 +                 yystos[yystate], yyvsp);
3754 +      YYPOPSTACK (1);
3755        yystate = *yyssp;
3756        YY_STACK_PRINT (yyss, yyssp);
3757      }
3758
3759 -  if (yyn == YYFINAL)
3760 -    YYACCEPT;
3761 -
3762 -  YYDPRINTF ((stderr, "Shifting error token, "));
3763 -
3764    *++yyvsp = yylval;
3765
3766
3767 +  /* Shift the error token.  */
3768 +  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3769 +
3770    yystate = yyn;
3771    goto yynewstate;
3772
3773 @@ -2919,25 +3591,50 @@ yyabortlab:
3774    yyresult = 1;
3775    goto yyreturn;
3776
3777 -#ifndef yyoverflow
3778 -/*----------------------------------------------.
3779 -| yyoverflowlab -- parser overflow comes here.  |
3780 -`----------------------------------------------*/
3781 -yyoverflowlab:
3782 -  yyerror ("parser stack overflow");
3783 +#if !defined(yyoverflow) || YYERROR_VERBOSE
3784 +/*-------------------------------------------------.
3785 +| yyexhaustedlab -- memory exhaustion comes here.  |
3786 +`-------------------------------------------------*/
3787 +yyexhaustedlab:
3788 +  yyerror (YY_("memory exhausted"));
3789    yyresult = 2;
3790    /* Fall through.  */
3791  #endif
3792
3793  yyreturn:
3794 +  if (yychar != YYEMPTY)
3795 +    {
3796 +      /* Make sure we have latest lookahead translation.  See comments at
3797 +         user semantic actions for why this is necessary.  */
3798 +      yytoken = YYTRANSLATE (yychar);
3799 +      yydestruct ("Cleanup: discarding lookahead",
3800 +                  yytoken, &yylval);
3801 +    }
3802 +  /* Do not reclaim the symbols of the rule which action triggered
3803 +     this YYABORT or YYACCEPT.  */
3804 +  YYPOPSTACK (yylen);
3805 +  YY_STACK_PRINT (yyss, yyssp);
3806 +  while (yyssp != yyss)
3807 +    {
3808 +      yydestruct ("Cleanup: popping",
3809 +                 yystos[*yyssp], yyvsp);
3810 +      YYPOPSTACK (1);
3811 +    }
3812  #ifndef yyoverflow
3813    if (yyss != yyssa)
3814      YYSTACK_FREE (yyss);
3815  #endif
3816 -  return yyresult;
3817 +#if YYERROR_VERBOSE
3818 +  if (yymsg != yymsgbuf)
3819 +    YYSTACK_FREE (yymsg);
3820 +#endif
3821 +  /* Make sure YYID is used.  */
3822 +  return YYID (yyresult);
3823  }
3824
3825
3826 +
3827 +/* Line 2067 of yacc.c  */
3828  #line 967 "parser.y"
3829
3830
3831 @@ -2991,13 +3688,13 @@ int makeop(struct opcode * op, struct mode *m, int add)
3832   *
3833   */
3834
3835 -#define indx(a) ( (a)/(sizeof(long)*8) )
3836 -#define bit(a) ( 1 << ((a)%(sizeof(long)*8)) )
3837 +#define indx(a) ( (a)/(32) )
3838 +#define bit(a) ( 1 << ((a)%(32)) )
3839
3840  #define getloc(a) (regions[indx(a)] & bit(a))
3841  #define setloc(a) (regions[indx(a)] |= bit(a))
3842
3843 -static unsigned long regions[ 0x10000/(sizeof(long)*8) ];
3844 +static unsigned long regions[ 0x10000/(32) ];
3845
3846  void inclc(int i)
3847  {
3848 @@ -3101,4 +3798,3 @@ void genword(unsigned long w)
3849  }
3850
3851
3852 -