--- /dev/null
+#define YY_cl_ucsim_parser_h_included
+#define YY_USE_CLASS
+
+/* A Bison++ parser, made from cmdpars.y */
+
+ /* with Bison++ version bison++ Version 1.21.9-1, adapted from GNU bison by coetmeur@icdc.fr
+Maintained by Magnus Ekdahl <magnus@debian.org>
+ */
+
+#define YY_USE_CLASS
+
+#line 1 "/usr/share/bison++/bison.cc"
+/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
+/* Skeleton output parser for bison,
+ Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 1, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ As a special exception, when this file is copied by Bison++ into a
+ Bison++ output file, you may use that output file without restriction.
+ This special exception was added by the Free Software Foundation
+ in version 1.24 of Bison, and has been in Bison++ since 1.21.9.
+
+*/
+
+/* HEADER SECTION */
+#if defined( _MSDOS ) || defined(MSDOS) || defined(__MSDOS__)
+ #define __MSDOS_AND_ALIKE
+#endif
+
+#if defined(_WINDOWS) && defined(_MSC_VER)
+ #define __HAVE_NO_ALLOCA
+ #define __MSDOS_AND_ALIKE
+#endif
+
+#ifndef alloca
+ #if defined( __GNUC__)
+ #define alloca __builtin_alloca
+
+ #elif (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
+ #include <alloca.h>
+
+ #elif defined (__MSDOS_AND_ALIKE)
+ #include <malloc.h>
+ #ifndef __TURBOC__
+ /* MS C runtime lib */
+ #define alloca _alloca
+ #endif
+
+ #elif defined(_AIX)
+ /* pragma must be put before any C/C++ instruction !! */
+ #pragma alloca
+ #include <malloc.h>
+
+ #elif defined(__hpux)
+ #ifdef __cplusplus
+ extern "C" {
+ void *alloca (unsigned int);
+ };
+ #else /* not __cplusplus */
+ void *alloca ();
+ #endif /* not __cplusplus */
+
+ #endif /* not _AIX not MSDOS, or __TURBOC__ or _AIX, not sparc. */
+#endif /* alloca not defined. */
+
+#ifdef c_plusplus
+ #ifndef __cplusplus
+ #define __cplusplus
+ #endif
+#endif
+
+#ifdef __cplusplus
+ #ifndef YY_USE_CLASS
+/*#warning "For C++ its recomended to use bison++, otherwise classes won't be generated"*/
+ #endif
+#else
+ #ifndef __STDC__
+ #define const
+ #endif
+ #ifdef YY_USE_CLASS
+ #error "This is a C++ header generated by bison++, please use a C++ compiler!"
+ #endif
+#endif
+
+#include <stdio.h>
+#define YYBISON 1
+
+ #line 88 "/usr/share/bison++/bison.cc"
+#line 3 "cmdpars.y"
+
+#include "cmdlexcl.h"
+#include "memcl.h"
+#include "globals.h"
+#include "stypes.h"
+#define YY_cl_ucsim_parser_INHERIT : public cl_base
+#define YY_cl_ucsim_parser_MEMBERS class cl_ucsim_lexer *lexer_object;\
+virtual ~YY_cl_ucsim_parser_CLASS(void) { delete lexer_object; }
+#define YY_cl_ucsim_parser_CONSTRUCTOR_PARAM \
+class cl_ucsim_lexer *the_lexer
+#define YY_cl_ucsim_parser_CONSTRUCTOR_CODE \
+lexer_object= the_lexer;
+
+#line 43 "cmdpars.y"
+typedef union {
+ long number;
+ class cl_memory *memory_object;
+ struct {
+ class cl_memory *memory;
+ long address;
+ } memory;
+ struct {
+ class cl_memory *memory;
+ long mem_address, bit_address;
+ long mask;
+ } bit;
+} yy_cl_ucsim_parser_stype;
+#define YY_cl_ucsim_parser_STYPE yy_cl_ucsim_parser_stype
+
+#line 88 "/usr/share/bison++/bison.cc"
+/* %{ and %header{ and %union, during decl */
+#define YY_cl_ucsim_parser_BISON 1
+
+#ifndef YY_cl_ucsim_parser_COMPATIBILITY
+ #ifndef YY_USE_CLASS
+ #define YY_cl_ucsim_parser_COMPATIBILITY 1
+ #else
+ #define YY_cl_ucsim_parser_COMPATIBILITY 0
+ #endif
+#endif
+
+#if YY_cl_ucsim_parser_COMPATIBILITY != 0
+ /* backward compatibility */
+ #ifdef YYLTYPE
+ #ifndef YY_cl_ucsim_parser_LTYPE
+ #define YY_cl_ucsim_parser_LTYPE YYLTYPE
+ #endif
+ #endif
+/* Testing alternative bison solution
+ /#ifdef YYSTYPE*/
+#ifndef YY_cl_ucsim_parser_STYPE
+ #define YY_cl_ucsim_parser_STYPE YYSTYPE
+#endif
+/*#endif*/
+ #ifdef YYDEBUG
+ #ifndef YY_cl_ucsim_parser_DEBUG
+ #define YY_cl_ucsim_parser_DEBUG YYDEBUG
+ #endif
+ #endif
+
+ /* use goto to be compatible */
+ #ifndef YY_cl_ucsim_parser_USE_GOTO
+ #define YY_cl_ucsim_parser_USE_GOTO 1
+ #endif
+#endif
+
+/* use no goto to be clean in C++ */
+#ifndef YY_cl_ucsim_parser_USE_GOTO
+ #define YY_cl_ucsim_parser_USE_GOTO 0
+#endif
+
+#ifndef YY_cl_ucsim_parser_PURE
+
+ #line 130 "/usr/share/bison++/bison.cc"
+#define YY_cl_ucsim_parser_PURE 1
+
+#line 130 "/usr/share/bison++/bison.cc"
+/* YY_cl_ucsim_parser_PURE */
+#endif
+
+/* section apres lecture def, avant lecture grammaire S2 */
+
+ #line 134 "/usr/share/bison++/bison.cc"
+
+#line 134 "/usr/share/bison++/bison.cc"
+/* prefix */
+#ifndef YY_cl_ucsim_parser_DEBUG
+
+ #line 136 "/usr/share/bison++/bison.cc"
+
+#line 136 "/usr/share/bison++/bison.cc"
+/* YY_cl_ucsim_parser_DEBUG */
+#endif
+
+
+#ifndef YY_cl_ucsim_parser_LSP_NEEDED
+
+ #line 141 "/usr/share/bison++/bison.cc"
+
+#line 141 "/usr/share/bison++/bison.cc"
+ /* YY_cl_ucsim_parser_LSP_NEEDED*/
+#endif
+
+
+
+/* DEFAULT LTYPE*/
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+#ifndef YY_cl_ucsim_parser_LTYPE
+#ifndef BISON_YYLTYPE_ISDECLARED
+#define BISON_YYLTYPE_ISDECLARED
+typedef
+ struct yyltype
+ {
+ int timestamp;
+ int first_line;
+ int first_column;
+ int last_line;
+ int last_column;
+ char *text;
+ }
+ yyltype;
+
+#endif
+#define YY_cl_ucsim_parser_LTYPE yyltype
+#endif
+#endif
+/* DEFAULT STYPE*/
+ /* We used to use `unsigned long' as YY_cl_ucsim_parser_STYPE on MSDOS,
+ but it seems better to be consistent.
+ Most programs should declare their own type anyway. */
+
+#ifndef YY_cl_ucsim_parser_STYPE
+#define YY_cl_ucsim_parser_STYPE int
+#endif
+/* DEFAULT MISCELANEOUS */
+#ifndef YY_cl_ucsim_parser_PARSE
+#define YY_cl_ucsim_parser_PARSE yyparse
+#endif
+#ifndef YY_cl_ucsim_parser_LEX
+#define YY_cl_ucsim_parser_LEX yylex
+#endif
+#ifndef YY_cl_ucsim_parser_LVAL
+#define YY_cl_ucsim_parser_LVAL yylval
+#endif
+#ifndef YY_cl_ucsim_parser_LLOC
+#define YY_cl_ucsim_parser_LLOC yylloc
+#endif
+#ifndef YY_cl_ucsim_parser_CHAR
+#define YY_cl_ucsim_parser_CHAR yychar
+#endif
+#ifndef YY_cl_ucsim_parser_NERRS
+#define YY_cl_ucsim_parser_NERRS yynerrs
+#endif
+#ifndef YY_cl_ucsim_parser_DEBUG_FLAG
+#define YY_cl_ucsim_parser_DEBUG_FLAG yydebug
+#endif
+#ifndef YY_cl_ucsim_parser_ERROR
+#define YY_cl_ucsim_parser_ERROR yyerror
+#endif
+
+#ifndef YY_cl_ucsim_parser_PARSE_PARAM
+ #ifndef YY_USE_CLASS
+ #ifdef YYPARSE_PARAM
+ #define YY_cl_ucsim_parser_PARSE_PARAM void* YYPARSE_PARAM
+ #else
+ #ifndef __STDC__
+ #ifndef __cplusplus
+ #define YY_cl_ucsim_parser_PARSE_PARAM
+ #endif
+ #endif
+ #endif
+ #endif
+ #ifndef YY_cl_ucsim_parser_PARSE_PARAM
+ #define YY_cl_ucsim_parser_PARSE_PARAM void
+ #endif
+#endif
+
+#if YY_cl_ucsim_parser_COMPATIBILITY != 0
+/* backward compatibility */
+#ifdef YY_cl_ucsim_parser_LTYPE
+#ifndef YYLTYPE
+#define YYLTYPE YY_cl_ucsim_parser_LTYPE
+#else
+/* WARNING obsolete !!! user defined YYLTYPE not reported into generated header */
+#endif
+#endif
+
+/* Removed due to bison compabilityproblems
+/#ifndef YYSTYPE
+/#define YYSTYPE YY_cl_ucsim_parser_STYPE
+/#else*/
+/* WARNING obsolete !!! user defined YYSTYPE not reported into generated header */
+/*#endif*/
+
+#ifdef YY_cl_ucsim_parser_PURE
+# ifndef YYPURE
+# define YYPURE YY_cl_ucsim_parser_PURE
+# endif
+#endif
+
+#ifdef YY_cl_ucsim_parser_DEBUG
+# ifndef YYDEBUG
+# define YYDEBUG YY_cl_ucsim_parser_DEBUG
+# endif
+#endif
+
+#ifndef YY_cl_ucsim_parser_ERROR_VERBOSE
+ #ifdef YYERROR_VERBOSE
+ #define YY_cl_ucsim_parser_ERROR_VERBOSE YYERROR_VERBOSE
+ #endif
+#endif
+
+#ifndef YY_cl_ucsim_parser_LSP_NEEDED
+# ifdef YYLSP_NEEDED
+# define YY_cl_ucsim_parser_LSP_NEEDED YYLSP_NEEDED
+# endif
+#endif
+
+#endif
+
+#ifndef YY_USE_CLASS
+/* TOKEN C */
+
+ #line 263 "/usr/share/bison++/bison.cc"
+#define PTOK_PLUS 258
+#define PTOK_MINUS 259
+#define PTOK_ASTERIX 260
+#define PTOK_SLASH 261
+#define PTOK_EQUAL 262
+#define PTOK_LEFT_PAREN 263
+#define PTOK_RIGHT_PAREN 264
+#define PTOK_LEFT_BRACKET 265
+#define PTOK_RIGHT_BRACKET 266
+#define PTOK_DOT 267
+#define PTOK_AMPERSAND 268
+#define PTOK_MEMORY_OBJECT 269
+#define PTOK_MEMORY 270
+#define PTOK_NUMBER 271
+#define PTOK_BIT 272
+#define UNARYMINUS 273
+
+
+#line 263 "/usr/share/bison++/bison.cc"
+ /* #defines tokens */
+#else
+/* CLASS */
+#ifndef YY_cl_ucsim_parser_CLASS
+#define YY_cl_ucsim_parser_CLASS cl_ucsim_parser
+#endif
+#ifndef YY_cl_ucsim_parser_INHERIT
+#define YY_cl_ucsim_parser_INHERIT
+#endif
+#ifndef YY_cl_ucsim_parser_MEMBERS
+#define YY_cl_ucsim_parser_MEMBERS
+#endif
+#ifndef YY_cl_ucsim_parser_LEX_BODY
+#define YY_cl_ucsim_parser_LEX_BODY
+#endif
+#ifndef YY_cl_ucsim_parser_ERROR_BODY
+#define YY_cl_ucsim_parser_ERROR_BODY
+#endif
+#ifndef YY_cl_ucsim_parser_CONSTRUCTOR_PARAM
+#define YY_cl_ucsim_parser_CONSTRUCTOR_PARAM
+#endif
+#ifndef YY_cl_ucsim_parser_CONSTRUCTOR_CODE
+#define YY_cl_ucsim_parser_CONSTRUCTOR_CODE
+#endif
+#ifndef YY_cl_ucsim_parser_CONSTRUCTOR_INIT
+#define YY_cl_ucsim_parser_CONSTRUCTOR_INIT
+#endif
+/* choose between enum and const */
+#ifndef YY_cl_ucsim_parser_USE_CONST_TOKEN
+#define YY_cl_ucsim_parser_USE_CONST_TOKEN 0
+/* yes enum is more compatible with flex, */
+/* so by default we use it */
+#endif
+#if YY_cl_ucsim_parser_USE_CONST_TOKEN != 0
+#ifndef YY_cl_ucsim_parser_ENUM_TOKEN
+#define YY_cl_ucsim_parser_ENUM_TOKEN yy_cl_ucsim_parser_enum_token
+#endif
+#endif
+
+class YY_cl_ucsim_parser_CLASS YY_cl_ucsim_parser_INHERIT
+{
+public:
+#if YY_cl_ucsim_parser_USE_CONST_TOKEN != 0
+/* static const int token ... */
+
+ #line 307 "/usr/share/bison++/bison.cc"
+static const int PTOK_PLUS;
+static const int PTOK_MINUS;
+static const int PTOK_ASTERIX;
+static const int PTOK_SLASH;
+static const int PTOK_EQUAL;
+static const int PTOK_LEFT_PAREN;
+static const int PTOK_RIGHT_PAREN;
+static const int PTOK_LEFT_BRACKET;
+static const int PTOK_RIGHT_BRACKET;
+static const int PTOK_DOT;
+static const int PTOK_AMPERSAND;
+static const int PTOK_MEMORY_OBJECT;
+static const int PTOK_MEMORY;
+static const int PTOK_NUMBER;
+static const int PTOK_BIT;
+static const int UNARYMINUS;
+
+
+#line 307 "/usr/share/bison++/bison.cc"
+ /* decl const */
+#else
+enum YY_cl_ucsim_parser_ENUM_TOKEN { YY_cl_ucsim_parser_NULL_TOKEN=0
+
+ #line 310 "/usr/share/bison++/bison.cc"
+ ,PTOK_PLUS=258
+ ,PTOK_MINUS=259
+ ,PTOK_ASTERIX=260
+ ,PTOK_SLASH=261
+ ,PTOK_EQUAL=262
+ ,PTOK_LEFT_PAREN=263
+ ,PTOK_RIGHT_PAREN=264
+ ,PTOK_LEFT_BRACKET=265
+ ,PTOK_RIGHT_BRACKET=266
+ ,PTOK_DOT=267
+ ,PTOK_AMPERSAND=268
+ ,PTOK_MEMORY_OBJECT=269
+ ,PTOK_MEMORY=270
+ ,PTOK_NUMBER=271
+ ,PTOK_BIT=272
+ ,UNARYMINUS=273
+
+
+#line 310 "/usr/share/bison++/bison.cc"
+ /* enum token */
+ }; /* end of enum declaration */
+#endif
+public:
+ int YY_cl_ucsim_parser_PARSE (YY_cl_ucsim_parser_PARSE_PARAM);
+ virtual void YY_cl_ucsim_parser_ERROR(char *msg) YY_cl_ucsim_parser_ERROR_BODY;
+#ifdef YY_cl_ucsim_parser_PURE
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ virtual int YY_cl_ucsim_parser_LEX (YY_cl_ucsim_parser_STYPE *YY_cl_ucsim_parser_LVAL,YY_cl_ucsim_parser_LTYPE *YY_cl_ucsim_parser_LLOC) YY_cl_ucsim_parser_LEX_BODY;
+#else
+ virtual int YY_cl_ucsim_parser_LEX (YY_cl_ucsim_parser_STYPE *YY_cl_ucsim_parser_LVAL) YY_cl_ucsim_parser_LEX_BODY;
+#endif
+#else
+ virtual int YY_cl_ucsim_parser_LEX() YY_cl_ucsim_parser_LEX_BODY;
+ YY_cl_ucsim_parser_STYPE YY_cl_ucsim_parser_LVAL;
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ YY_cl_ucsim_parser_LTYPE YY_cl_ucsim_parser_LLOC;
+#endif
+ int YY_cl_ucsim_parser_NERRS;
+ int YY_cl_ucsim_parser_CHAR;
+#endif
+#if YY_cl_ucsim_parser_DEBUG != 0
+ int YY_cl_ucsim_parser_DEBUG_FLAG; /* nonzero means print parse trace */
+#endif
+public:
+ YY_cl_ucsim_parser_CLASS(YY_cl_ucsim_parser_CONSTRUCTOR_PARAM);
+public:
+ YY_cl_ucsim_parser_MEMBERS
+};
+/* other declare folow */
+#if YY_cl_ucsim_parser_USE_CONST_TOKEN != 0
+
+ #line 341 "/usr/share/bison++/bison.cc"
+const int YY_cl_ucsim_parser_CLASS::PTOK_PLUS=258;
+const int YY_cl_ucsim_parser_CLASS::PTOK_MINUS=259;
+const int YY_cl_ucsim_parser_CLASS::PTOK_ASTERIX=260;
+const int YY_cl_ucsim_parser_CLASS::PTOK_SLASH=261;
+const int YY_cl_ucsim_parser_CLASS::PTOK_EQUAL=262;
+const int YY_cl_ucsim_parser_CLASS::PTOK_LEFT_PAREN=263;
+const int YY_cl_ucsim_parser_CLASS::PTOK_RIGHT_PAREN=264;
+const int YY_cl_ucsim_parser_CLASS::PTOK_LEFT_BRACKET=265;
+const int YY_cl_ucsim_parser_CLASS::PTOK_RIGHT_BRACKET=266;
+const int YY_cl_ucsim_parser_CLASS::PTOK_DOT=267;
+const int YY_cl_ucsim_parser_CLASS::PTOK_AMPERSAND=268;
+const int YY_cl_ucsim_parser_CLASS::PTOK_MEMORY_OBJECT=269;
+const int YY_cl_ucsim_parser_CLASS::PTOK_MEMORY=270;
+const int YY_cl_ucsim_parser_CLASS::PTOK_NUMBER=271;
+const int YY_cl_ucsim_parser_CLASS::PTOK_BIT=272;
+const int YY_cl_ucsim_parser_CLASS::UNARYMINUS=273;
+
+
+#line 341 "/usr/share/bison++/bison.cc"
+ /* const YY_cl_ucsim_parser_CLASS::token */
+#endif
+/*apres const */
+YY_cl_ucsim_parser_CLASS::YY_cl_ucsim_parser_CLASS(YY_cl_ucsim_parser_CONSTRUCTOR_PARAM) YY_cl_ucsim_parser_CONSTRUCTOR_INIT
+{
+#if YY_cl_ucsim_parser_DEBUG != 0
+YY_cl_ucsim_parser_DEBUG_FLAG=0;
+#endif
+YY_cl_ucsim_parser_CONSTRUCTOR_CODE;
+};
+#endif
+
+ #line 352 "/usr/share/bison++/bison.cc"
+
+
+#define YYFINAL 37
+#define YYFLAG -32768
+#define YYNTBASE 19
+
+#define YYTRANSLATE(x) ((unsigned)(x) <= 273 ? yytranslate[x] : 25)
+
+static const char yytranslate[] = { 0,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18
+};
+
+#if YY_cl_ucsim_parser_DEBUG != 0
+static const short yyprhs[] = { 0,
+ 0, 2, 6, 10, 12, 16, 20, 24, 28, 31,
+ 33, 37, 39, 41, 43, 46, 49, 51, 56, 58
+};
+
+static const short yyrhs[] = { 21,
+ 0, 23, 7, 21, 0, 24, 7, 21, 0, 20,
+ 0, 21, 3, 21, 0, 21, 4, 21, 0, 21,
+ 5, 21, 0, 21, 6, 21, 0, 4, 21, 0,
+ 22, 0, 8, 21, 9, 0, 16, 0, 23, 0,
+ 24, 0, 13, 23, 0, 13, 24, 0, 15, 0,
+ 14, 10, 21, 11, 0, 17, 0, 23, 12, 21,
+ 0
+};
+
+#endif
+
+#if (YY_cl_ucsim_parser_DEBUG != 0) || defined(YY_cl_ucsim_parser_ERROR_VERBOSE)
+static const short yyrline[] = { 0,
+ 59, 63, 69, 86, 88, 89, 90, 91, 98, 99,
+ 100, 101, 102, 103, 106, 108, 119, 121, 127, 129
+};
+
+static const char * const yytname[] = { "$","error","$illegal.","PTOK_PLUS",
+"PTOK_MINUS","PTOK_ASTERIX","PTOK_SLASH","PTOK_EQUAL","PTOK_LEFT_PAREN","PTOK_RIGHT_PAREN",
+"PTOK_LEFT_BRACKET","PTOK_RIGHT_BRACKET","PTOK_DOT","PTOK_AMPERSAND","PTOK_MEMORY_OBJECT",
+"PTOK_MEMORY","PTOK_NUMBER","PTOK_BIT","UNARYMINUS","ucsim_grammar","assignment",
+"expression","address_of_expression","memory","bit",""
+};
+#endif
+
+static const short yyr1[] = { 0,
+ 19, 20, 20, 21, 21, 21, 21, 21, 21, 21,
+ 21, 21, 21, 21, 22, 22, 23, 23, 24, 24
+};
+
+static const short yyr2[] = { 0,
+ 1, 3, 3, 1, 3, 3, 3, 3, 2, 1,
+ 3, 1, 1, 1, 2, 2, 1, 4, 1, 3
+};
+
+static const short yydefact[] = { 0,
+ 0, 0, 0, 0, 17, 12, 19, 4, 1, 10,
+ 13, 14, 9, 0, 15, 16, 0, 0, 0, 0,
+ 0, 0, 0, 0, 11, 0, 5, 6, 7, 8,
+ 2, 20, 3, 18, 0, 0, 0
+};
+
+static const short yydefgoto[] = { 35,
+ 8, 9, 10, 11, 12
+};
+
+static const short yypact[] = { -2,
+ -2, -2, -10, 23,-32768,-32768,-32768,-32768, 32,-32768,
+ -4, 33,-32768, 25, 27,-32768, -2, -2, -2, -2,
+ -2, -2, -2, -2,-32768, 21, 4, 4,-32768,-32768,
+ 32, 32, 32,-32768, 41, 42,-32768
+};
+
+static const short yypgoto[] = {-32768,
+-32768, -1,-32768, 40, 43
+};
+
+
+#define YYLAST 46
+
+
+static const short yytable[] = { 13,
+ 14, 1, 22, 4, 5, 2, 7, 23, 20, 21,
+ 3, 4, 5, 6, 7, 26, 27, 28, 29, 30,
+ 31, 32, 33, 18, 19, 20, 21, 18, 19, 20,
+ 21, 34, 17, 25, 18, 19, 20, 21, 23, 24,
+ 36, 37, 15, 0, 0, 16
+};
+
+static const short yycheck[] = { 1,
+ 2, 4, 7, 14, 15, 8, 17, 12, 5, 6,
+ 13, 14, 15, 16, 17, 17, 18, 19, 20, 21,
+ 22, 23, 24, 3, 4, 5, 6, 3, 4, 5,
+ 6, 11, 10, 9, 3, 4, 5, 6, 12, 7,
+ 0, 0, 3, -1, -1, 3
+};
+
+#line 352 "/usr/share/bison++/bison.cc"
+ /* fattrs + tables */
+
+/* parser code folow */
+
+
+/* This is the parser code that is written into each bison parser
+ when the %semantic_parser declaration is not specified in the grammar.
+ It was written by Richard Stallman by simplifying the hairy parser
+ used when %semantic_parser is specified. */
+
+/* Note: dollar marks section change
+ the next is replaced by the list of actions, each action
+ as one case of the switch. */
+
+#if YY_cl_ucsim_parser_USE_GOTO != 0
+/*
+ SUPRESSION OF GOTO : on some C++ compiler (sun c++)
+ the goto is strictly forbidden if any constructor/destructor
+ is used in the whole function (very stupid isn't it ?)
+ so goto are to be replaced with a 'while/switch/case construct'
+ here are the macro to keep some apparent compatibility
+*/
+#define YYGOTO(lb) {yy_gotostate=lb;continue;}
+#define YYBEGINGOTO enum yy_labels yy_gotostate=yygotostart; \
+ for(;;) switch(yy_gotostate) { case yygotostart: {
+#define YYLABEL(lb) } case lb: {
+#define YYENDGOTO } }
+#define YYBEGINDECLARELABEL enum yy_labels {yygotostart
+#define YYDECLARELABEL(lb) ,lb
+#define YYENDDECLARELABEL };
+#else
+/* macro to keep goto */
+#define YYGOTO(lb) goto lb
+#define YYBEGINGOTO
+#define YYLABEL(lb) lb:
+#define YYENDGOTO
+#define YYBEGINDECLARELABEL
+#define YYDECLARELABEL(lb)
+#define YYENDDECLARELABEL
+#endif
+/* LABEL DECLARATION */
+YYBEGINDECLARELABEL
+ YYDECLARELABEL(yynewstate)
+ YYDECLARELABEL(yybackup)
+/* YYDECLARELABEL(yyresume) */
+ YYDECLARELABEL(yydefault)
+ YYDECLARELABEL(yyreduce)
+ YYDECLARELABEL(yyerrlab) /* here on detecting error */
+ YYDECLARELABEL(yyerrlab1) /* here on error raised explicitly by an action */
+ YYDECLARELABEL(yyerrdefault) /* current state does not do anything special for the error token. */
+ YYDECLARELABEL(yyerrpop) /* pop the current state because it cannot handle the error token */
+ YYDECLARELABEL(yyerrhandle)
+YYENDDECLARELABEL
+/* ALLOCA SIMULATION */
+/* __HAVE_NO_ALLOCA */
+#ifdef __HAVE_NO_ALLOCA
+int __alloca_free_ptr(char *ptr,char *ref)
+{if(ptr!=ref) free(ptr);
+ return 0;}
+
+#define __ALLOCA_alloca(size) malloc(size)
+#define __ALLOCA_free(ptr,ref) __alloca_free_ptr((char *)ptr,(char *)ref)
+
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+#define __ALLOCA_return(num) \
+ do { return( __ALLOCA_free(yyss,yyssa)+\
+ __ALLOCA_free(yyvs,yyvsa)+\
+ __ALLOCA_free(yyls,yylsa)+\
+ (num)); } while(0)
+#else
+#define __ALLOCA_return(num) \
+ do { return( __ALLOCA_free(yyss,yyssa)+\
+ __ALLOCA_free(yyvs,yyvsa)+\
+ (num)); } while(0)
+#endif
+#else
+#define __ALLOCA_return(num) do { return(num); } while(0)
+#define __ALLOCA_alloca(size) alloca(size)
+#define __ALLOCA_free(ptr,ref)
+#endif
+
+/* ENDALLOCA SIMULATION */
+
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (YY_cl_ucsim_parser_CHAR = YYEMPTY)
+#define YYEMPTY -2
+#define YYEOF 0
+#define YYACCEPT __ALLOCA_return(0)
+#define YYABORT __ALLOCA_return(1)
+#define YYERROR YYGOTO(yyerrlab1)
+/* Like YYERROR except do call yyerror.
+ This remains here temporarily to ease the
+ transition to the new meaning of YYERROR, for GCC.
+ Once GCC version 2 has supplanted version 1, this can go. */
+#define YYFAIL YYGOTO(yyerrlab)
+#define YYRECOVERING() (!!yyerrstatus)
+#define YYBACKUP(token, value) \
+do \
+ if (YY_cl_ucsim_parser_CHAR == YYEMPTY && yylen == 1) \
+ { YY_cl_ucsim_parser_CHAR = (token), YY_cl_ucsim_parser_LVAL = (value); \
+ yychar1 = YYTRANSLATE (YY_cl_ucsim_parser_CHAR); \
+ YYPOPSTACK; \
+ YYGOTO(yybackup); \
+ } \
+ else \
+ { YY_cl_ucsim_parser_ERROR ("syntax error: cannot back up"); YYERROR; } \
+while (0)
+
+#define YYTERROR 1
+#define YYERRCODE 256
+
+#ifndef YY_cl_ucsim_parser_PURE
+/* UNPURE */
+#define YYLEX YY_cl_ucsim_parser_LEX()
+#ifndef YY_USE_CLASS
+/* If nonreentrant, and not class , generate the variables here */
+int YY_cl_ucsim_parser_CHAR; /* the lookahead symbol */
+YY_cl_ucsim_parser_STYPE YY_cl_ucsim_parser_LVAL; /* the semantic value of the */
+ /* lookahead symbol */
+int YY_cl_ucsim_parser_NERRS; /* number of parse errors so far */
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+YY_cl_ucsim_parser_LTYPE YY_cl_ucsim_parser_LLOC; /* location data for the lookahead */
+ /* symbol */
+#endif
+#endif
+
+
+#else
+/* PURE */
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+#define YYLEX YY_cl_ucsim_parser_LEX(&YY_cl_ucsim_parser_LVAL, &YY_cl_ucsim_parser_LLOC)
+#else
+#define YYLEX YY_cl_ucsim_parser_LEX(&YY_cl_ucsim_parser_LVAL)
+#endif
+#endif
+#ifndef YY_USE_CLASS
+#if YY_cl_ucsim_parser_DEBUG != 0
+int YY_cl_ucsim_parser_DEBUG_FLAG; /* nonzero means print parse trace */
+/* Since this is uninitialized, it does not stop multiple parsers
+ from coexisting. */
+#endif
+#endif
+
+
+
+/* YYINITDEPTH indicates the initial size of the parser's stacks */
+
+#ifndef YYINITDEPTH
+#define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH is the maximum size the stacks can grow to
+ (effective only if the built-in stack extension method is used). */
+
+#if YYMAXDEPTH == 0
+#undef YYMAXDEPTH
+#endif
+
+#ifndef YYMAXDEPTH
+#define YYMAXDEPTH 10000
+#endif
+
+
+#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
+#define __yy_bcopy(FROM,TO,COUNT) __builtin_memcpy(TO,FROM,COUNT)
+#else /* not GNU C or C++ */
+
+/* This is the most reliable way to avoid incompatibilities
+ in available built-in functions on various systems. */
+
+#ifdef __cplusplus
+static void __yy_bcopy (char *from, char *to, int count)
+#else
+#ifdef __STDC__
+static void __yy_bcopy (char *from, char *to, int count)
+#else
+static void __yy_bcopy (from, to, count)
+ char *from;
+ char *to;
+ int count;
+#endif
+#endif
+{
+ register char *f = from;
+ register char *t = to;
+ register int i = count;
+
+ while (i-- > 0)
+ *t++ = *f++;
+}
+#endif
+
+
+int
+#ifdef YY_USE_CLASS
+ YY_cl_ucsim_parser_CLASS::
+#endif
+ YY_cl_ucsim_parser_PARSE(YY_cl_ucsim_parser_PARSE_PARAM)
+#ifndef __STDC__
+#ifndef __cplusplus
+#ifndef YY_USE_CLASS
+/* parameter definition without protypes */
+YY_cl_ucsim_parser_PARSE_PARAM_DEF
+#endif
+#endif
+#endif
+{
+ register int yystate;
+ register int yyn;
+ register short *yyssp;
+ register YY_cl_ucsim_parser_STYPE *yyvsp;
+ int yyerrstatus; /* number of tokens to shift before error messages enabled */
+ int yychar1=0; /* lookahead token as an internal (translated) token number */
+
+ short yyssa[YYINITDEPTH]; /* the state stack */
+ YY_cl_ucsim_parser_STYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
+
+ short *yyss = yyssa; /* refer to the stacks thru separate pointers */
+ YY_cl_ucsim_parser_STYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
+
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ YY_cl_ucsim_parser_LTYPE yylsa[YYINITDEPTH]; /* the location stack */
+ YY_cl_ucsim_parser_LTYPE *yyls = yylsa;
+ YY_cl_ucsim_parser_LTYPE *yylsp;
+
+#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
+#else
+#define YYPOPSTACK (yyvsp--, yyssp--)
+#endif
+
+ int yystacksize = YYINITDEPTH;
+
+#ifdef YY_cl_ucsim_parser_PURE
+ int YY_cl_ucsim_parser_CHAR;
+ YY_cl_ucsim_parser_STYPE YY_cl_ucsim_parser_LVAL;
+ int YY_cl_ucsim_parser_NERRS;
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ YY_cl_ucsim_parser_LTYPE YY_cl_ucsim_parser_LLOC;
+#endif
+#endif
+
+ YY_cl_ucsim_parser_STYPE yyval; /* the variable used to return */
+ /* semantic values from the action */
+ /* routines */
+
+ int yylen;
+/* start loop, in which YYGOTO may be used. */
+YYBEGINGOTO
+
+#if YY_cl_ucsim_parser_DEBUG != 0
+ if (YY_cl_ucsim_parser_DEBUG_FLAG)
+ fprintf(stderr, "Starting parse\n");
+#endif
+ yystate = 0;
+ yyerrstatus = 0;
+ YY_cl_ucsim_parser_NERRS = 0;
+ YY_cl_ucsim_parser_CHAR = YYEMPTY; /* Cause a token to be read. */
+
+ /* Initialize stack pointers.
+ Waste one element of value and location stack
+ so that they stay on the same level as the state stack.
+ The wasted elements are never initialized. */
+
+ yyssp = yyss - 1;
+ yyvsp = yyvs;
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ yylsp = yyls;
+#endif
+
+/* Push a new state, which is found in yystate . */
+/* In all cases, when you get here, the value and location stacks
+ have just been pushed. so pushing a state here evens the stacks. */
+YYLABEL(yynewstate)
+
+ *++yyssp = yystate;
+
+ if (yyssp >= yyss + yystacksize - 1)
+ {
+ /* Give user a chance to reallocate the stack */
+ /* Use copies of these so that the &'s don't force the real ones into memory. */
+ YY_cl_ucsim_parser_STYPE *yyvs1 = yyvs;
+ short *yyss1 = yyss;
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ YY_cl_ucsim_parser_LTYPE *yyls1 = yyls;
+#endif
+
+ /* Get the current used size of the three stacks, in elements. */
+ int size = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+ /* Each stack pointer address is followed by the size of
+ the data in use in that stack, in bytes. */
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ /* This used to be a conditional around just the two extra args,
+ but that might be undefined if yyoverflow is a macro. */
+ yyoverflow("parser stack overflow",
+ &yyss1, size * sizeof (*yyssp),
+ &yyvs1, size * sizeof (*yyvsp),
+ &yyls1, size * sizeof (*yylsp),
+ &yystacksize);
+#else
+ yyoverflow("parser stack overflow",
+ &yyss1, size * sizeof (*yyssp),
+ &yyvs1, size * sizeof (*yyvsp),
+ &yystacksize);
+#endif
+
+ yyss = yyss1; yyvs = yyvs1;
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ yyls = yyls1;
+#endif
+#else /* no yyoverflow */
+ /* Extend the stack our own way. */
+ if (yystacksize >= YYMAXDEPTH)
+ {
+ YY_cl_ucsim_parser_ERROR("parser stack overflow");
+ __ALLOCA_return(2);
+ }
+ yystacksize *= 2;
+ if (yystacksize > YYMAXDEPTH)
+ yystacksize = YYMAXDEPTH;
+ yyss = (short *) __ALLOCA_alloca (yystacksize * sizeof (*yyssp));
+ __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
+ __ALLOCA_free(yyss1,yyssa);
+ yyvs = (YY_cl_ucsim_parser_STYPE *) __ALLOCA_alloca (yystacksize * sizeof (*yyvsp));
+ __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
+ __ALLOCA_free(yyvs1,yyvsa);
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ yyls = (YY_cl_ucsim_parser_LTYPE *) __ALLOCA_alloca (yystacksize * sizeof (*yylsp));
+ __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
+ __ALLOCA_free(yyls1,yylsa);
+#endif
+#endif /* no yyoverflow */
+
+ yyssp = yyss + size - 1;
+ yyvsp = yyvs + size - 1;
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ yylsp = yyls + size - 1;
+#endif
+
+#if YY_cl_ucsim_parser_DEBUG != 0
+ if (YY_cl_ucsim_parser_DEBUG_FLAG)
+ fprintf(stderr, "Stack size increased to %d\n", yystacksize);
+#endif
+
+ if (yyssp >= yyss + yystacksize - 1)
+ YYABORT;
+ }
+
+#if YY_cl_ucsim_parser_DEBUG != 0
+ if (YY_cl_ucsim_parser_DEBUG_FLAG)
+ fprintf(stderr, "Entering state %d\n", yystate);
+#endif
+
+ YYGOTO(yybackup);
+YYLABEL(yybackup)
+
+/* Do appropriate processing given the current state. */
+/* Read a lookahead token if we need one and don't already have one. */
+/* YYLABEL(yyresume) */
+
+ /* First try to decide what to do without reference to lookahead token. */
+
+ yyn = yypact[yystate];
+ if (yyn == YYFLAG)
+ YYGOTO(yydefault);
+
+ /* Not known => get a lookahead token if don't already have one. */
+
+ /* yychar is either YYEMPTY or YYEOF
+ or a valid token in external form. */
+
+ if (YY_cl_ucsim_parser_CHAR == YYEMPTY)
+ {
+#if YY_cl_ucsim_parser_DEBUG != 0
+ if (YY_cl_ucsim_parser_DEBUG_FLAG)
+ fprintf(stderr, "Reading a token: ");
+#endif
+ YY_cl_ucsim_parser_CHAR = YYLEX;
+ }
+
+ /* Convert token to internal form (in yychar1) for indexing tables with */
+
+ if (YY_cl_ucsim_parser_CHAR <= 0) /* This means end of input. */
+ {
+ yychar1 = 0;
+ YY_cl_ucsim_parser_CHAR = YYEOF; /* Don't call YYLEX any more */
+
+#if YY_cl_ucsim_parser_DEBUG != 0
+ if (YY_cl_ucsim_parser_DEBUG_FLAG)
+ fprintf(stderr, "Now at end of input.\n");
+#endif
+ }
+ else
+ {
+ yychar1 = YYTRANSLATE(YY_cl_ucsim_parser_CHAR);
+
+#if YY_cl_ucsim_parser_DEBUG != 0
+ if (YY_cl_ucsim_parser_DEBUG_FLAG)
+ {
+ fprintf (stderr, "Next token is %d (%s", YY_cl_ucsim_parser_CHAR, yytname[yychar1]);
+ /* Give the individual parser a way to print the precise meaning
+ of a token, for further debugging info. */
+#ifdef YYPRINT
+ YYPRINT (stderr, YY_cl_ucsim_parser_CHAR, YY_cl_ucsim_parser_LVAL);
+#endif
+ fprintf (stderr, ")\n");
+ }
+#endif
+ }
+
+ yyn += yychar1;
+ if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+ YYGOTO(yydefault);
+
+ yyn = yytable[yyn];
+
+ /* yyn is what to do for this token type in this state.
+ Negative => reduce, -yyn is rule number.
+ Positive => shift, yyn is new state.
+ New state is final state => don't bother to shift,
+ just return success.
+ 0, or most negative number => error. */
+
+ if (yyn < 0)
+ {
+ if (yyn == YYFLAG)
+ YYGOTO(yyerrlab);
+ yyn = -yyn;
+ YYGOTO(yyreduce);
+ }
+ else if (yyn == 0)
+ YYGOTO(yyerrlab);
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+ /* Shift the lookahead token. */
+
+#if YY_cl_ucsim_parser_DEBUG != 0
+ if (YY_cl_ucsim_parser_DEBUG_FLAG)
+ fprintf(stderr, "Shifting token %d (%s), ", YY_cl_ucsim_parser_CHAR, yytname[yychar1]);
+#endif
+
+ /* Discard the token being shifted unless it is eof. */
+ if (YY_cl_ucsim_parser_CHAR != YYEOF)
+ YY_cl_ucsim_parser_CHAR = YYEMPTY;
+
+ *++yyvsp = YY_cl_ucsim_parser_LVAL;
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ *++yylsp = YY_cl_ucsim_parser_LLOC;
+#endif
+
+ /* count tokens shifted since error; after three, turn off error status. */
+ if (yyerrstatus) yyerrstatus--;
+
+ yystate = yyn;
+ YYGOTO(yynewstate);
+
+/* Do the default action for the current state. */
+YYLABEL(yydefault)
+
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ YYGOTO(yyerrlab);
+
+/* Do a reduction. yyn is the number of a rule to reduce with. */
+YYLABEL(yyreduce)
+ yylen = yyr2[yyn];
+ if (yylen > 0)
+ yyval = yyvsp[1-yylen]; /* implement default value of the action */
+
+#if YY_cl_ucsim_parser_DEBUG != 0
+ if (YY_cl_ucsim_parser_DEBUG_FLAG)
+ {
+ int i;
+
+ fprintf (stderr, "Reducing via rule %d (line %d), ",
+ yyn, yyrline[yyn]);
+
+ /* Print the symbols being reduced, and their result. */
+ for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
+ fprintf (stderr, "%s ", yytname[yyrhs[i]]);
+ fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+ }
+#endif
+
+
+ #line 839 "/usr/share/bison++/bison.cc"
+
+ switch (yyn) {
+
+case 1:
+#line 60 "cmdpars.y"
+{ application->dd_printf("%d\n", yyvsp[0].number); ;
+ break;}
+case 2:
+#line 65 "cmdpars.y"
+{
+ yyvsp[-2].memory.memory->write(yyvsp[-2].memory.address, yyvsp[0].number);
+ yyval.number= yyvsp[0].number;
+ ;
+ break;}
+case 3:
+#line 70 "cmdpars.y"
+{
+ if (yyvsp[0].number)
+ {
+ yyvsp[-2].bit.memory->write(yyvsp[-2].bit.mem_address,
+ yyvsp[-2].bit.memory->read(yyvsp[-2].bit.mem_address) | yyvsp[-2].bit.mask);
+ yyval.number= 1;
+ }
+ else
+ {
+ yyvsp[-2].bit.memory->write(yyvsp[-2].bit.mem_address,
+ yyvsp[-2].bit.memory->read(yyvsp[-2].bit.mem_address) & ~(yyvsp[-2].bit.mask));
+ yyval.number= 0;
+ }
+ ;
+ break;}
+case 4:
+#line 87 "cmdpars.y"
+{ yyval.number= yyvsp[0].number; ;
+ break;}
+case 5:
+#line 88 "cmdpars.y"
+{ yyval.number= yyvsp[-2].number + yyvsp[0].number; ;
+ break;}
+case 6:
+#line 89 "cmdpars.y"
+{ yyval.number= yyvsp[-2].number - yyvsp[0].number; ;
+ break;}
+case 7:
+#line 90 "cmdpars.y"
+{ yyval.number= yyvsp[-2].number * yyvsp[0].number; ;
+ break;}
+case 8:
+#line 92 "cmdpars.y"
+{
+ if (yyvsp[0].number == 0)
+ yyerror("Divide by zero");
+ else
+ yyval.number= yyvsp[-2].number / yyvsp[0].number;
+ ;
+ break;}
+case 9:
+#line 98 "cmdpars.y"
+{ yyval.number= -yyvsp[0].number; ;
+ break;}
+case 10:
+#line 99 "cmdpars.y"
+{ yyval.number= yyvsp[0].number; ;
+ break;}
+case 11:
+#line 100 "cmdpars.y"
+{ yyval.number= yyvsp[-1].number; ;
+ break;}
+case 12:
+#line 101 "cmdpars.y"
+{ yyval.number= yyvsp[0].number; ;
+ break;}
+case 13:
+#line 102 "cmdpars.y"
+{ yyval.number= yyvsp[0].memory.memory->read(yyvsp[0].memory.address); ;
+ break;}
+case 14:
+#line 103 "cmdpars.y"
+{ yyval.number= (yyvsp[0].bit.memory->read(yyvsp[0].bit.mem_address) & yyvsp[0].bit.mask)?1:0; ;
+ break;}
+case 15:
+#line 107 "cmdpars.y"
+{ yyval.number= yyvsp[0].memory.address; ;
+ break;}
+case 16:
+#line 109 "cmdpars.y"
+{
+ yyval.number= yyvsp[0].bit.bit_address;
+ if (yyval.number < 0)
+ {
+ yyerror("Bit has no address.");
+ yyval.number= 0;
+ }
+ ;
+ break;}
+case 18:
+#line 122 "cmdpars.y"
+{
+ yyval.memory.memory= yyvsp[-3].memory_object;
+ yyval.memory.address= yyvsp[-1].number;
+ ;
+ break;}
+case 20:
+#line 130 "cmdpars.y"
+{
+ yyval.bit.memory= yyvsp[-2].memory.memory;
+ yyval.bit.mem_address= yyvsp[-2].memory.address;
+ yyval.bit.mask= 1 << yyvsp[0].number;
+ yyval.bit.bit_address= -1;
+ class cl_uc *uc= application->get_uc();
+ if (uc)
+ yyval.bit.bit_address= uc->bit_address(yyvsp[-2].memory.memory, yyvsp[-2].memory.address, yyvsp[0].number);
+ ;
+ break;}
+}
+
+#line 839 "/usr/share/bison++/bison.cc"
+ /* the action file gets copied in in place of this dollarsign */
+ yyvsp -= yylen;
+ yyssp -= yylen;
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ yylsp -= yylen;
+#endif
+
+#if YY_cl_ucsim_parser_DEBUG != 0
+ if (YY_cl_ucsim_parser_DEBUG_FLAG)
+ {
+ short *ssp1 = yyss - 1;
+ fprintf (stderr, "state stack now");
+ while (ssp1 != yyssp)
+ fprintf (stderr, " %d", *++ssp1);
+ fprintf (stderr, "\n");
+ }
+#endif
+
+ *++yyvsp = yyval;
+
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ yylsp++;
+ if (yylen == 0)
+ {
+ yylsp->first_line = YY_cl_ucsim_parser_LLOC.first_line;
+ yylsp->first_column = YY_cl_ucsim_parser_LLOC.first_column;
+ yylsp->last_line = (yylsp-1)->last_line;
+ yylsp->last_column = (yylsp-1)->last_column;
+ yylsp->text = 0;
+ }
+ else
+ {
+ yylsp->last_line = (yylsp+yylen-1)->last_line;
+ yylsp->last_column = (yylsp+yylen-1)->last_column;
+ }
+#endif
+
+ /* Now "shift" the result of the reduction.
+ Determine what state that goes to,
+ based on the state we popped back to
+ and the rule number reduced by. */
+
+ yyn = yyr1[yyn];
+
+ yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+ if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+ yystate = yytable[yystate];
+ else
+ yystate = yydefgoto[yyn - YYNTBASE];
+
+ YYGOTO(yynewstate);
+
+YYLABEL(yyerrlab) /* here on detecting error */
+
+ if (! yyerrstatus)
+ /* If not already recovering from an error, report this error. */
+ {
+ ++YY_cl_ucsim_parser_NERRS;
+
+#ifdef YY_cl_ucsim_parser_ERROR_VERBOSE
+ yyn = yypact[yystate];
+
+ if (yyn > YYFLAG && yyn < YYLAST)
+ {
+ int size = 0;
+ char *msg;
+ int x, count;
+
+ count = 0;
+ /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
+ for (x = (yyn < 0 ? -yyn : 0);
+ x < (sizeof(yytname) / sizeof(char *)); x++)
+ if (yycheck[x + yyn] == x)
+ size += strlen(yytname[x]) + 15, count++;
+ msg = (char *) malloc(size + 15);
+ if (msg != 0)
+ {
+ strcpy(msg, "parse error");
+
+ if (count < 5)
+ {
+ count = 0;
+ for (x = (yyn < 0 ? -yyn : 0);
+ x < (sizeof(yytname) / sizeof(char *)); x++)
+ if (yycheck[x + yyn] == x)
+ {
+ strcat(msg, count == 0 ? ", expecting `" : " or `");
+ strcat(msg, yytname[x]);
+ strcat(msg, "'");
+ count++;
+ }
+ }
+ YY_cl_ucsim_parser_ERROR(msg);
+ free(msg);
+ }
+ else
+ YY_cl_ucsim_parser_ERROR ("parse error; also virtual memory exceeded");
+ }
+ else
+#endif /* YY_cl_ucsim_parser_ERROR_VERBOSE */
+ YY_cl_ucsim_parser_ERROR("parse error");
+ }
+
+ YYGOTO(yyerrlab1);
+YYLABEL(yyerrlab1) /* here on error raised explicitly by an action */
+
+ if (yyerrstatus == 3)
+ {
+ /* if just tried and failed to reuse lookahead token after an error, discard it. */
+
+ /* return failure if at end of input */
+ if (YY_cl_ucsim_parser_CHAR == YYEOF)
+ YYABORT;
+
+#if YY_cl_ucsim_parser_DEBUG != 0
+ if (YY_cl_ucsim_parser_DEBUG_FLAG)
+ fprintf(stderr, "Discarding token %d (%s).\n", YY_cl_ucsim_parser_CHAR, yytname[yychar1]);
+#endif
+
+ YY_cl_ucsim_parser_CHAR = YYEMPTY;
+ }
+
+ /* Else will try to reuse lookahead token
+ after shifting the error token. */
+
+ yyerrstatus = 3; /* Each real token shifted decrements this */
+
+ YYGOTO(yyerrhandle);
+
+YYLABEL(yyerrdefault) /* current state does not do anything special for the error token. */
+
+#if 0
+ /* This is wrong; only states that explicitly want error tokens
+ should shift them. */
+ yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
+ if (yyn) YYGOTO(yydefault);
+#endif
+
+YYLABEL(yyerrpop) /* pop the current state because it cannot handle the error token */
+
+ if (yyssp == yyss) YYABORT;
+ yyvsp--;
+ yystate = *--yyssp;
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ yylsp--;
+#endif
+
+#if YY_cl_ucsim_parser_DEBUG != 0
+ if (YY_cl_ucsim_parser_DEBUG_FLAG)
+ {
+ short *ssp1 = yyss - 1;
+ fprintf (stderr, "Error: state stack now");
+ while (ssp1 != yyssp)
+ fprintf (stderr, " %d", *++ssp1);
+ fprintf (stderr, "\n");
+ }
+#endif
+
+YYLABEL(yyerrhandle)
+
+ yyn = yypact[yystate];
+ if (yyn == YYFLAG)
+ YYGOTO(yyerrdefault);
+
+ yyn += YYTERROR;
+ if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+ YYGOTO(yyerrdefault);
+
+ yyn = yytable[yyn];
+ if (yyn < 0)
+ {
+ if (yyn == YYFLAG)
+ YYGOTO(yyerrpop);
+ yyn = -yyn;
+ YYGOTO(yyreduce);
+ }
+ else if (yyn == 0)
+ YYGOTO(yyerrpop);
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+#if YY_cl_ucsim_parser_DEBUG != 0
+ if (YY_cl_ucsim_parser_DEBUG_FLAG)
+ fprintf(stderr, "Shifting error token, ");
+#endif
+
+ *++yyvsp = YY_cl_ucsim_parser_LVAL;
+#ifdef YY_cl_ucsim_parser_LSP_NEEDED
+ *++yylsp = YY_cl_ucsim_parser_LLOC;
+#endif
+
+ yystate = yyn;
+ YYGOTO(yynewstate);
+/* end loop, in which YYGOTO may be used. */
+ YYENDGOTO
+}
+
+/* END */
+
+ #line 1038 "/usr/share/bison++/bison.cc"
+#line 141 "cmdpars.y"
+
+
+int
+YY_cl_ucsim_parser_CLASS::yylex(YY_cl_ucsim_parser_STYPE *yylval)
+{
+ lexer_object->activate_lexer_to_parse_into(yylval);
+ return(lexer_object->yylex());
+}
+
+void
+YY_cl_ucsim_parser_CLASS::yyerror(char *msg)
+{
+ application->dd_printf("Parser error: %s\n", msg);
+}
projects / fw / sdcc / blobdiff