linux/scripts/genksyms/parse.tab.c_shipped
<<
>>
Prefs
   1/* A Bison parser, made by GNU Bison 2.5.  */
   2
   3/* Bison implementation for Yacc-like parsers in C
   4   
   5      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
   6   
   7   This program is free software: you can redistribute it and/or modify
   8   it under the terms of the GNU General Public License as published by
   9   the Free Software Foundation, either version 3 of the License, or
  10   (at your option) any later version.
  11   
  12   This program is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16   
  17   You should have received a copy of the GNU General Public License
  18   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20/* As a special exception, you may create a larger work that contains
  21   part or all of the Bison parser skeleton and distribute that work
  22   under terms of your choice, so long as that work isn't itself a
  23   parser generator using the skeleton or a modified version thereof
  24   as a parser skeleton.  Alternatively, if you modify or redistribute
  25   the parser skeleton itself, you may (at your option) remove this
  26   special exception, which will cause the skeleton and the resulting
  27   Bison output files to be licensed under the GNU General Public
  28   License without this special exception.
  29   
  30   This special exception was added by the Free Software Foundation in
  31   version 2.2 of Bison.  */
  32
  33/* C LALR(1) parser skeleton written by Richard Stallman, by
  34   simplifying the original so-called "semantic" parser.  */
  35
  36/* All symbols defined below should begin with yy or YY, to avoid
  37   infringing on user name space.  This should be done even for local
  38   variables, as they might otherwise be expanded by user macros.
  39   There are some unavoidable exceptions within include files to
  40   define necessary library symbols; they are noted "INFRINGES ON
  41   USER NAME SPACE" below.  */
  42
  43/* Identify Bison output.  */
  44#define YYBISON 1
  45
  46/* Bison version.  */
  47#define YYBISON_VERSION "2.5"
  48
  49/* Skeleton name.  */
  50#define YYSKELETON_NAME "yacc.c"
  51
  52/* Pure parsers.  */
  53#define YYPURE 0
  54
  55/* Push parsers.  */
  56#define YYPUSH 0
  57
  58/* Pull parsers.  */
  59#define YYPULL 1
  60
  61/* Using locations.  */
  62#define YYLSP_NEEDED 0
  63
  64
  65
  66/* Copy the first part of user declarations.  */
  67
  68
  69
  70#include <assert.h>
  71#include <stdlib.h>
  72#include <string.h>
  73#include "genksyms.h"
  74
  75static int is_typedef;
  76static int is_extern;
  77static char *current_name;
  78static struct string_list *decl_spec;
  79
  80static void yyerror(const char *);
  81
  82static inline void
  83remove_node(struct string_list **p)
  84{
  85  struct string_list *node = *p;
  86  *p = node->next;
  87  free_node(node);
  88}
  89
  90static inline void
  91remove_list(struct string_list **pb, struct string_list **pe)
  92{
  93  struct string_list *b = *pb, *e = *pe;
  94  *pb = e;
  95  free_list(b, e);
  96}
  97
  98/* Record definition of a struct/union/enum */
  99static void record_compound(struct string_list **keyw,
 100                       struct string_list **ident,
 101                       struct string_list **body,
 102                       enum symbol_type type)
 103{
 104        struct string_list *b = *body, *i = *ident, *r;
 105
 106        if (i->in_source_file) {
 107                remove_node(keyw);
 108                (*ident)->tag = type;
 109                remove_list(body, ident);
 110                return;
 111        }
 112        r = copy_node(i); r->tag = type;
 113        r->next = (*keyw)->next; *body = r; (*keyw)->next = NULL;
 114        add_symbol(i->string, type, b, is_extern);
 115}
 116
 117
 118
 119
 120/* Enabling traces.  */
 121#ifndef YYDEBUG
 122# define YYDEBUG 1
 123#endif
 124
 125/* Enabling verbose error messages.  */
 126#ifdef YYERROR_VERBOSE
 127# undef YYERROR_VERBOSE
 128# define YYERROR_VERBOSE 1
 129#else
 130# define YYERROR_VERBOSE 0
 131#endif
 132
 133/* Enabling the token table.  */
 134#ifndef YYTOKEN_TABLE
 135# define YYTOKEN_TABLE 0
 136#endif
 137
 138
 139/* Tokens.  */
 140#ifndef YYTOKENTYPE
 141# define YYTOKENTYPE
 142   /* Put the tokens into the symbol table, so that GDB and other debuggers
 143      know about them.  */
 144   enum yytokentype {
 145     ASM_KEYW = 258,
 146     ATTRIBUTE_KEYW = 259,
 147     AUTO_KEYW = 260,
 148     BOOL_KEYW = 261,
 149     CHAR_KEYW = 262,
 150     CONST_KEYW = 263,
 151     DOUBLE_KEYW = 264,
 152     ENUM_KEYW = 265,
 153     EXTERN_KEYW = 266,
 154     EXTENSION_KEYW = 267,
 155     FLOAT_KEYW = 268,
 156     INLINE_KEYW = 269,
 157     INT_KEYW = 270,
 158     LONG_KEYW = 271,
 159     REGISTER_KEYW = 272,
 160     RESTRICT_KEYW = 273,
 161     SHORT_KEYW = 274,
 162     SIGNED_KEYW = 275,
 163     STATIC_KEYW = 276,
 164     STRUCT_KEYW = 277,
 165     TYPEDEF_KEYW = 278,
 166     UNION_KEYW = 279,
 167     UNSIGNED_KEYW = 280,
 168     VOID_KEYW = 281,
 169     VOLATILE_KEYW = 282,
 170     TYPEOF_KEYW = 283,
 171     EXPORT_SYMBOL_KEYW = 284,
 172     ASM_PHRASE = 285,
 173     ATTRIBUTE_PHRASE = 286,
 174     BRACE_PHRASE = 287,
 175     BRACKET_PHRASE = 288,
 176     EXPRESSION_PHRASE = 289,
 177     CHAR = 290,
 178     DOTS = 291,
 179     IDENT = 292,
 180     INT = 293,
 181     REAL = 294,
 182     STRING = 295,
 183     TYPE = 296,
 184     OTHER = 297,
 185     FILENAME = 298
 186   };
 187#endif
 188
 189
 190
 191#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 192typedef int YYSTYPE;
 193# define YYSTYPE_IS_TRIVIAL 1
 194# define yystype YYSTYPE /* obsolescent; will be withdrawn */
 195# define YYSTYPE_IS_DECLARED 1
 196#endif
 197
 198
 199/* Copy the second part of user declarations.  */
 200
 201
 202
 203#ifdef short
 204# undef short
 205#endif
 206
 207#ifdef YYTYPE_UINT8
 208typedef YYTYPE_UINT8 yytype_uint8;
 209#else
 210typedef unsigned char yytype_uint8;
 211#endif
 212
 213#ifdef YYTYPE_INT8
 214typedef YYTYPE_INT8 yytype_int8;
 215#elif (defined __STDC__ || defined __C99__FUNC__ \
 216     || defined __cplusplus || defined _MSC_VER)
 217typedef signed char yytype_int8;
 218#else
 219typedef short int yytype_int8;
 220#endif
 221
 222#ifdef YYTYPE_UINT16
 223typedef YYTYPE_UINT16 yytype_uint16;
 224#else
 225typedef unsigned short int yytype_uint16;
 226#endif
 227
 228#ifdef YYTYPE_INT16
 229typedef YYTYPE_INT16 yytype_int16;
 230#else
 231typedef short int yytype_int16;
 232#endif
 233
 234#ifndef YYSIZE_T
 235# ifdef __SIZE_TYPE__
 236#  define YYSIZE_T __SIZE_TYPE__
 237# elif defined size_t
 238#  define YYSIZE_T size_t
 239# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 240     || defined __cplusplus || defined _MSC_VER)
 241#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 242#  define YYSIZE_T size_t
 243# else
 244#  define YYSIZE_T unsigned int
 245# endif
 246#endif
 247
 248#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 249
 250#ifndef YY_
 251# if defined YYENABLE_NLS && YYENABLE_NLS
 252#  if ENABLE_NLS
 253#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 254#   define YY_(msgid) dgettext ("bison-runtime", msgid)
 255#  endif
 256# endif
 257# ifndef YY_
 258#  define YY_(msgid) msgid
 259# endif
 260#endif
 261
 262/* Suppress unused-variable warnings by "using" E.  */
 263#if ! defined lint || defined __GNUC__
 264# define YYUSE(e) ((void) (e))
 265#else
 266# define YYUSE(e) /* empty */
 267#endif
 268
 269/* Identity function, used to suppress warnings about constant conditions.  */
 270#ifndef lint
 271# define YYID(n) (n)
 272#else
 273#if (defined __STDC__ || defined __C99__FUNC__ \
 274     || defined __cplusplus || defined _MSC_VER)
 275static int
 276YYID (int yyi)
 277#else
 278static int
 279YYID (yyi)
 280    int yyi;
 281#endif
 282{
 283  return yyi;
 284}
 285#endif
 286
 287#if ! defined yyoverflow || YYERROR_VERBOSE
 288
 289/* The parser invokes alloca or malloc; define the necessary symbols.  */
 290
 291# ifdef YYSTACK_USE_ALLOCA
 292#  if YYSTACK_USE_ALLOCA
 293#   ifdef __GNUC__
 294#    define YYSTACK_ALLOC __builtin_alloca
 295#   elif defined __BUILTIN_VA_ARG_INCR
 296#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 297#   elif defined _AIX
 298#    define YYSTACK_ALLOC __alloca
 299#   elif defined _MSC_VER
 300#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 301#    define alloca _alloca
 302#   else
 303#    define YYSTACK_ALLOC alloca
 304#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
 305     || defined __cplusplus || defined _MSC_VER)
 306#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 307#     ifndef EXIT_SUCCESS
 308#      define EXIT_SUCCESS 0
 309#     endif
 310#    endif
 311#   endif
 312#  endif
 313# endif
 314
 315# ifdef YYSTACK_ALLOC
 316   /* Pacify GCC's `empty if-body' warning.  */
 317#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 318#  ifndef YYSTACK_ALLOC_MAXIMUM
 319    /* The OS might guarantee only one guard page at the bottom of the stack,
 320       and a page size can be as small as 4096 bytes.  So we cannot safely
 321       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 322       to allow for a few compiler-allocated temporary stack slots.  */
 323#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 324#  endif
 325# else
 326#  define YYSTACK_ALLOC YYMALLOC
 327#  define YYSTACK_FREE YYFREE
 328#  ifndef YYSTACK_ALLOC_MAXIMUM
 329#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 330#  endif
 331#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
 332       && ! ((defined YYMALLOC || defined malloc) \
 333             && (defined YYFREE || defined free)))
 334#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 335#   ifndef EXIT_SUCCESS
 336#    define EXIT_SUCCESS 0
 337#   endif
 338#  endif
 339#  ifndef YYMALLOC
 340#   define YYMALLOC malloc
 341#   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
 342     || defined __cplusplus || defined _MSC_VER)
 343void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 344#   endif
 345#  endif
 346#  ifndef YYFREE
 347#   define YYFREE free
 348#   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
 349     || defined __cplusplus || defined _MSC_VER)
 350void free (void *); /* INFRINGES ON USER NAME SPACE */
 351#   endif
 352#  endif
 353# endif
 354#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 355
 356
 357#if (! defined yyoverflow \
 358     && (! defined __cplusplus \
 359         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 360
 361/* A type that is properly aligned for any stack member.  */
 362union yyalloc
 363{
 364  yytype_int16 yyss_alloc;
 365  YYSTYPE yyvs_alloc;
 366};
 367
 368/* The size of the maximum gap between one aligned stack and the next.  */
 369# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 370
 371/* The size of an array large to enough to hold all stacks, each with
 372   N elements.  */
 373# define YYSTACK_BYTES(N) \
 374     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 375      + YYSTACK_GAP_MAXIMUM)
 376
 377# define YYCOPY_NEEDED 1
 378
 379/* Relocate STACK from its old location to the new one.  The
 380   local variables YYSIZE and YYSTACKSIZE give the old and new number of
 381   elements in the stack, and YYPTR gives the new location of the
 382   stack.  Advance YYPTR to a properly aligned location for the next
 383   stack.  */
 384# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
 385    do                                                                  \
 386      {                                                                 \
 387        YYSIZE_T yynewbytes;                                            \
 388        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
 389        Stack = &yyptr->Stack_alloc;                                    \
 390        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 391        yyptr += yynewbytes / sizeof (*yyptr);                          \
 392      }                                                                 \
 393    while (YYID (0))
 394
 395#endif
 396
 397#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
 398/* Copy COUNT objects from FROM to TO.  The source and destination do
 399   not overlap.  */
 400# ifndef YYCOPY
 401#  if defined __GNUC__ && 1 < __GNUC__
 402#   define YYCOPY(To, From, Count) \
 403      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 404#  else
 405#   define YYCOPY(To, From, Count)              \
 406      do                                        \
 407        {                                       \
 408          YYSIZE_T yyi;                         \
 409          for (yyi = 0; yyi < (Count); yyi++)   \
 410            (To)[yyi] = (From)[yyi];            \
 411        }                                       \
 412      while (YYID (0))
 413#  endif
 414# endif
 415#endif /* !YYCOPY_NEEDED */
 416
 417/* YYFINAL -- State number of the termination state.  */
 418#define YYFINAL  4
 419/* YYLAST -- Last index in YYTABLE.  */
 420#define YYLAST   532
 421
 422/* YYNTOKENS -- Number of terminals.  */
 423#define YYNTOKENS  53
 424/* YYNNTS -- Number of nonterminals.  */
 425#define YYNNTS  49
 426/* YYNRULES -- Number of rules.  */
 427#define YYNRULES  132
 428/* YYNRULES -- Number of states.  */
 429#define YYNSTATES  188
 430
 431/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 432#define YYUNDEFTOK  2
 433#define YYMAXUTOK   298
 434
 435#define YYTRANSLATE(YYX)                                                \
 436  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 437
 438/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 439static const yytype_uint8 yytranslate[] =
 440{
 441       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 442       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 443       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 444       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 445      47,    49,    48,     2,    46,     2,     2,     2,     2,     2,
 446       2,     2,     2,     2,     2,     2,     2,     2,    52,    44,
 447       2,    50,     2,     2,     2,     2,     2,     2,     2,     2,
 448       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 449       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 450       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 451       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 452       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 453       2,     2,     2,    51,     2,    45,     2,     2,     2,     2,
 454       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 455       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 456       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 457       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 458       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 459       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 460       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 461       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 462       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 463       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 464       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 465       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 466       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 467       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 468      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 469      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
 470      35,    36,    37,    38,    39,    40,    41,    42,    43
 471};
 472
 473#if YYDEBUG
 474/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 475   YYRHS.  */
 476static const yytype_uint16 yyprhs[] =
 477{
 478       0,     0,     3,     5,     8,     9,    12,    13,    18,    19,
 479      23,    25,    27,    29,    31,    34,    37,    41,    42,    44,
 480      46,    50,    55,    56,    58,    60,    63,    65,    67,    69,
 481      71,    73,    75,    77,    79,    81,    87,    92,    95,    98,
 482     101,   105,   109,   113,   116,   119,   122,   124,   126,   128,
 483     130,   132,   134,   136,   138,   140,   142,   144,   147,   148,
 484     150,   152,   155,   157,   159,   161,   163,   166,   168,   170,
 485     175,   180,   183,   187,   191,   194,   196,   198,   200,   205,
 486     210,   213,   217,   221,   224,   226,   230,   231,   233,   235,
 487     239,   242,   245,   247,   248,   250,   252,   257,   262,   265,
 488     269,   273,   277,   278,   280,   283,   287,   291,   292,   294,
 489     296,   299,   303,   306,   307,   309,   311,   315,   318,   321,
 490     323,   326,   327,   330,   334,   339,   341,   345,   347,   351,
 491     354,   355,   357
 492};
 493
 494/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 495static const yytype_int8 yyrhs[] =
 496{
 497      54,     0,    -1,    55,    -1,    54,    55,    -1,    -1,    56,
 498      57,    -1,    -1,    12,    23,    58,    60,    -1,    -1,    23,
 499      59,    60,    -1,    60,    -1,    84,    -1,    99,    -1,   101,
 500      -1,     1,    44,    -1,     1,    45,    -1,    64,    61,    44,
 501      -1,    -1,    62,    -1,    63,    -1,    62,    46,    63,    -1,
 502      74,   100,    95,    85,    -1,    -1,    65,    -1,    66,    -1,
 503      65,    66,    -1,    67,    -1,    68,    -1,     5,    -1,    17,
 504      -1,    21,    -1,    11,    -1,    14,    -1,    69,    -1,    73,
 505      -1,    28,    47,    65,    48,    49,    -1,    28,    47,    65,
 506      49,    -1,    22,    37,    -1,    24,    37,    -1,    10,    37,
 507      -1,    22,    37,    87,    -1,    24,    37,    87,    -1,    10,
 508      37,    96,    -1,    10,    96,    -1,    22,    87,    -1,    24,
 509      87,    -1,     7,    -1,    19,    -1,    15,    -1,    16,    -1,
 510      20,    -1,    25,    -1,    13,    -1,     9,    -1,    26,    -1,
 511       6,    -1,    41,    -1,    48,    71,    -1,    -1,    72,    -1,
 512      73,    -1,    72,    73,    -1,     8,    -1,    27,    -1,    31,
 513      -1,    18,    -1,    70,    74,    -1,    75,    -1,    37,    -1,
 514      75,    47,    78,    49,    -1,    75,    47,     1,    49,    -1,
 515      75,    33,    -1,    47,    74,    49,    -1,    47,     1,    49,
 516      -1,    70,    76,    -1,    77,    -1,    37,    -1,    41,    -1,
 517      77,    47,    78,    49,    -1,    77,    47,     1,    49,    -1,
 518      77,    33,    -1,    47,    76,    49,    -1,    47,     1,    49,
 519      -1,    79,    36,    -1,    79,    -1,    80,    46,    36,    -1,
 520      -1,    80,    -1,    81,    -1,    80,    46,    81,    -1,    65,
 521      82,    -1,    70,    82,    -1,    83,    -1,    -1,    37,    -1,
 522      41,    -1,    83,    47,    78,    49,    -1,    83,    47,     1,
 523      49,    -1,    83,    33,    -1,    47,    82,    49,    -1,    47,
 524       1,    49,    -1,    64,    74,    32,    -1,    -1,    86,    -1,
 525      50,    34,    -1,    51,    88,    45,    -1,    51,     1,    45,
 526      -1,    -1,    89,    -1,    90,    -1,    89,    90,    -1,    64,
 527      91,    44,    -1,     1,    44,    -1,    -1,    92,    -1,    93,
 528      -1,    92,    46,    93,    -1,    76,    95,    -1,    37,    94,
 529      -1,    94,    -1,    52,    34,    -1,    -1,    95,    31,    -1,
 530      51,    97,    45,    -1,    51,    97,    46,    45,    -1,    98,
 531      -1,    97,    46,    98,    -1,    37,    -1,    37,    50,    34,
 532      -1,    30,    44,    -1,    -1,    30,    -1,    29,    47,    37,
 533      49,    44,    -1
 534};
 535
 536/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 537static const yytype_uint16 yyrline[] =
 538{
 539       0,   123,   123,   124,   128,   128,   134,   134,   136,   136,
 540     138,   139,   140,   141,   142,   143,   147,   161,   162,   166,
 541     174,   187,   193,   194,   198,   199,   203,   209,   213,   214,
 542     215,   216,   217,   221,   222,   223,   224,   228,   230,   232,
 543     236,   238,   240,   245,   248,   249,   253,   254,   255,   256,
 544     257,   258,   259,   260,   261,   262,   263,   267,   272,   273,
 545     277,   278,   282,   282,   282,   283,   291,   292,   296,   305,
 546     307,   309,   311,   313,   320,   321,   325,   326,   327,   329,
 547     331,   333,   335,   340,   341,   342,   346,   347,   351,   352,
 548     357,   362,   364,   368,   369,   377,   381,   383,   385,   387,
 549     389,   394,   403,   404,   409,   414,   415,   419,   420,   424,
 550     425,   429,   431,   436,   437,   441,   442,   446,   447,   448,
 551     452,   456,   457,   461,   462,   466,   467,   470,   475,   483,
 552     487,   488,   492
 553};
 554#endif
 555
 556#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 557/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 558   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 559static const char *const yytname[] =
 560{
 561  "$end", "error", "$undefined", "ASM_KEYW", "ATTRIBUTE_KEYW",
 562  "AUTO_KEYW", "BOOL_KEYW", "CHAR_KEYW", "CONST_KEYW", "DOUBLE_KEYW",
 563  "ENUM_KEYW", "EXTERN_KEYW", "EXTENSION_KEYW", "FLOAT_KEYW",
 564  "INLINE_KEYW", "INT_KEYW", "LONG_KEYW", "REGISTER_KEYW", "RESTRICT_KEYW",
 565  "SHORT_KEYW", "SIGNED_KEYW", "STATIC_KEYW", "STRUCT_KEYW",
 566  "TYPEDEF_KEYW", "UNION_KEYW", "UNSIGNED_KEYW", "VOID_KEYW",
 567  "VOLATILE_KEYW", "TYPEOF_KEYW", "EXPORT_SYMBOL_KEYW", "ASM_PHRASE",
 568  "ATTRIBUTE_PHRASE", "BRACE_PHRASE", "BRACKET_PHRASE",
 569  "EXPRESSION_PHRASE", "CHAR", "DOTS", "IDENT", "INT", "REAL", "STRING",
 570  "TYPE", "OTHER", "FILENAME", "';'", "'}'", "','", "'('", "'*'", "')'",
 571  "'='", "'{'", "':'", "$accept", "declaration_seq", "declaration", "$@1",
 572  "declaration1", "$@2", "$@3", "simple_declaration",
 573  "init_declarator_list_opt", "init_declarator_list", "init_declarator",
 574  "decl_specifier_seq_opt", "decl_specifier_seq", "decl_specifier",
 575  "storage_class_specifier", "type_specifier", "simple_type_specifier",
 576  "ptr_operator", "cvar_qualifier_seq_opt", "cvar_qualifier_seq",
 577  "cvar_qualifier", "declarator", "direct_declarator", "nested_declarator",
 578  "direct_nested_declarator", "parameter_declaration_clause",
 579  "parameter_declaration_list_opt", "parameter_declaration_list",
 580  "parameter_declaration", "m_abstract_declarator",
 581  "direct_m_abstract_declarator", "function_definition", "initializer_opt",
 582  "initializer", "class_body", "member_specification_opt",
 583  "member_specification", "member_declaration",
 584  "member_declarator_list_opt", "member_declarator_list",
 585  "member_declarator", "member_bitfield_declarator", "attribute_opt",
 586  "enum_body", "enumerator_list", "enumerator", "asm_definition",
 587  "asm_phrase_opt", "export_definition", 0
 588};
 589#endif
 590
 591# ifdef YYPRINT
 592/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 593   token YYLEX-NUM.  */
 594static const yytype_uint16 yytoknum[] =
 595{
 596       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
 597     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
 598     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
 599     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
 600     295,   296,   297,   298,    59,   125,    44,    40,    42,    41,
 601      61,   123,    58
 602};
 603# endif
 604
 605/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 606static const yytype_uint8 yyr1[] =
 607{
 608       0,    53,    54,    54,    56,    55,    58,    57,    59,    57,
 609      57,    57,    57,    57,    57,    57,    60,    61,    61,    62,
 610      62,    63,    64,    64,    65,    65,    66,    66,    67,    67,
 611      67,    67,    67,    68,    68,    68,    68,    68,    68,    68,
 612      68,    68,    68,    68,    68,    68,    69,    69,    69,    69,
 613      69,    69,    69,    69,    69,    69,    69,    70,    71,    71,
 614      72,    72,    73,    73,    73,    73,    74,    74,    75,    75,
 615      75,    75,    75,    75,    76,    76,    77,    77,    77,    77,
 616      77,    77,    77,    78,    78,    78,    79,    79,    80,    80,
 617      81,    82,    82,    83,    83,    83,    83,    83,    83,    83,
 618      83,    84,    85,    85,    86,    87,    87,    88,    88,    89,
 619      89,    90,    90,    91,    91,    92,    92,    93,    93,    93,
 620      94,    95,    95,    96,    96,    97,    97,    98,    98,    99,
 621     100,   100,   101
 622};
 623
 624/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 625static const yytype_uint8 yyr2[] =
 626{
 627       0,     2,     1,     2,     0,     2,     0,     4,     0,     3,
 628       1,     1,     1,     1,     2,     2,     3,     0,     1,     1,
 629       3,     4,     0,     1,     1,     2,     1,     1,     1,     1,
 630       1,     1,     1,     1,     1,     5,     4,     2,     2,     2,
 631       3,     3,     3,     2,     2,     2,     1,     1,     1,     1,
 632       1,     1,     1,     1,     1,     1,     1,     2,     0,     1,
 633       1,     2,     1,     1,     1,     1,     2,     1,     1,     4,
 634       4,     2,     3,     3,     2,     1,     1,     1,     4,     4,
 635       2,     3,     3,     2,     1,     3,     0,     1,     1,     3,
 636       2,     2,     1,     0,     1,     1,     4,     4,     2,     3,
 637       3,     3,     0,     1,     2,     3,     3,     0,     1,     1,
 638       2,     3,     2,     0,     1,     1,     3,     2,     2,     1,
 639       2,     0,     2,     3,     4,     1,     3,     1,     3,     2,
 640       0,     1,     5
 641};
 642
 643/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
 644   Performed when YYTABLE doesn't specify something else to do.  Zero
 645   means the default is an error.  */
 646static const yytype_uint8 yydefact[] =
 647{
 648       4,     4,     2,     0,     1,     3,     0,    28,    55,    46,
 649      62,    53,     0,    31,     0,    52,    32,    48,    49,    29,
 650      65,    47,    50,    30,     0,     8,     0,    51,    54,    63,
 651       0,     0,     0,    64,    56,     5,    10,    17,    23,    24,
 652      26,    27,    33,    34,    11,    12,    13,    14,    15,    39,
 653       0,    43,     6,    37,     0,    44,    22,    38,    45,     0,
 654       0,   129,    68,     0,    58,     0,    18,    19,     0,   130,
 655      67,    25,    42,   127,     0,   125,    22,    40,     0,   113,
 656       0,     0,   109,     9,    17,    41,     0,     0,     0,     0,
 657      57,    59,    60,    16,     0,    66,   131,   101,   121,    71,
 658       0,     0,   123,     0,     7,   112,   106,    76,    77,     0,
 659       0,     0,   121,    75,     0,   114,   115,   119,   105,     0,
 660     110,   130,     0,    36,     0,    73,    72,    61,    20,   102,
 661       0,    93,     0,    84,    87,    88,   128,   124,   126,   118,
 662       0,    76,     0,   120,    74,   117,    80,     0,   111,     0,
 663      35,   132,   122,     0,    21,   103,    70,    94,    56,     0,
 664      93,    90,    92,    69,    83,     0,    82,    81,     0,     0,
 665     116,   104,     0,    95,     0,    91,    98,     0,    85,    89,
 666      79,    78,   100,    99,     0,     0,    97,    96
 667};
 668
 669/* YYDEFGOTO[NTERM-NUM].  */
 670static const yytype_int16 yydefgoto[] =
 671{
 672      -1,     1,     2,     3,    35,    76,    56,    36,    65,    66,
 673      67,    79,    38,    39,    40,    41,    42,    68,    90,    91,
 674      43,   121,    70,   112,   113,   132,   133,   134,   135,   161,
 675     162,    44,   154,   155,    55,    80,    81,    82,   114,   115,
 676     116,   117,   129,    51,    74,    75,    45,    98,    46
 677};
 678
 679/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 680   STATE-NUM.  */
 681#define YYPACT_NINF -135
 682static const yytype_int16 yypact[] =
 683{
 684    -135,    20,  -135,   321,  -135,  -135,    30,  -135,  -135,  -135,
 685    -135,  -135,   -28,  -135,     2,  -135,  -135,  -135,  -135,  -135,
 686    -135,  -135,  -135,  -135,    -6,  -135,     9,  -135,  -135,  -135,
 687      -5,    15,   -17,  -135,  -135,  -135,  -135,    18,   491,  -135,
 688    -135,  -135,  -135,  -135,  -135,  -135,  -135,  -135,  -135,   -22,
 689      31,  -135,  -135,    19,   106,  -135,   491,    19,  -135,   491,
 690      50,  -135,  -135,    11,    -3,    51,    57,  -135,    18,   -14,
 691      14,  -135,  -135,    48,    46,  -135,   491,  -135,    33,    32,
 692      59,   154,  -135,  -135,    18,  -135,   365,    56,    60,    61,
 693    -135,    -3,  -135,  -135,    18,  -135,  -135,  -135,  -135,  -135,
 694     202,    74,  -135,   -23,  -135,  -135,  -135,    77,  -135,    16,
 695     101,    49,  -135,    34,    92,    93,  -135,  -135,  -135,    94,
 696    -135,   110,    95,  -135,    97,  -135,  -135,  -135,  -135,   -20,
 697      96,   410,    99,   113,   100,  -135,  -135,  -135,  -135,  -135,
 698     103,  -135,   107,  -135,  -135,   111,  -135,   239,  -135,    32,
 699    -135,  -135,  -135,   123,  -135,  -135,  -135,  -135,  -135,     3,
 700      52,  -135,    38,  -135,  -135,   454,  -135,  -135,   117,   128,
 701    -135,  -135,   134,  -135,   135,  -135,  -135,   276,  -135,  -135,
 702    -135,  -135,  -135,  -135,   137,   138,  -135,  -135
 703};
 704
 705/* YYPGOTO[NTERM-NUM].  */
 706static const yytype_int16 yypgoto[] =
 707{
 708    -135,  -135,   187,  -135,  -135,  -135,  -135,   -50,  -135,  -135,
 709      98,     0,   -59,   -37,  -135,  -135,  -135,   -77,  -135,  -135,
 710     -54,   -30,  -135,   -90,  -135,  -134,  -135,  -135,    24,   -58,
 711    -135,  -135,  -135,  -135,   -18,  -135,  -135,   109,  -135,  -135,
 712      44,    87,    84,   148,  -135,   102,  -135,  -135,  -135
 713};
 714
 715/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 716   positive, shift that token.  If negative, reduce the rule which
 717   number is the opposite.  If YYTABLE_NINF, syntax error.  */
 718#define YYTABLE_NINF -109
 719static const yytype_int16 yytable[] =
 720{
 721      86,    71,   111,    37,   172,    10,    83,    69,    58,    49,
 722      92,   152,    88,   169,    73,    20,    96,   140,    97,   142,
 723       4,   144,   137,    50,    29,    52,   104,    61,    33,    50,
 724     153,    53,   111,    89,   111,    77,   -93,   127,    95,    85,
 725     157,   131,    59,   185,   173,    54,    57,    99,    62,    71,
 726     159,    64,   -93,   141,   160,    62,    84,   108,    63,    64,
 727      54,   100,    60,   109,    64,    63,    64,   146,    73,   107,
 728      54,   176,   111,   108,    47,    48,    84,   105,   106,   109,
 729      64,   147,   160,   160,   110,   177,   141,    87,   131,   157,
 730     108,   102,   103,   173,    71,    93,   109,    64,   101,   159,
 731      64,   174,   175,    94,   118,   124,   131,    78,   136,   125,
 732     126,     7,     8,     9,    10,    11,    12,    13,   131,    15,
 733      16,    17,    18,    19,    20,    21,    22,    23,    24,   110,
 734      26,    27,    28,    29,    30,   143,   148,    33,   105,   149,
 735      96,   151,   152,   -22,   150,   156,   165,    34,   163,   164,
 736     -22,  -107,   166,   -22,   -22,   119,   167,   171,   -22,     7,
 737       8,     9,    10,    11,    12,    13,   180,    15,    16,    17,
 738      18,    19,    20,    21,    22,    23,    24,   181,    26,    27,
 739      28,    29,    30,   182,   183,    33,   186,   187,     5,   179,
 740     120,   -22,   128,   170,   139,    34,   145,    72,   -22,  -108,
 741       0,   -22,   -22,   130,     0,   138,   -22,     7,     8,     9,
 742      10,    11,    12,    13,     0,    15,    16,    17,    18,    19,
 743      20,    21,    22,    23,    24,     0,    26,    27,    28,    29,
 744      30,     0,     0,    33,     0,     0,     0,     0,   -86,     0,
 745     168,     0,     0,    34,     7,     8,     9,    10,    11,    12,
 746      13,   -86,    15,    16,    17,    18,    19,    20,    21,    22,
 747      23,    24,     0,    26,    27,    28,    29,    30,     0,     0,
 748      33,     0,     0,     0,     0,   -86,     0,   184,     0,     0,
 749      34,     7,     8,     9,    10,    11,    12,    13,   -86,    15,
 750      16,    17,    18,    19,    20,    21,    22,    23,    24,     0,
 751      26,    27,    28,    29,    30,     0,     0,    33,     0,     0,
 752       0,     0,   -86,     0,     0,     0,     0,    34,     0,     0,
 753       0,     0,     6,     0,     0,   -86,     7,     8,     9,    10,
 754      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
 755      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
 756      31,    32,    33,     0,     0,     0,     0,     0,   -22,     0,
 757       0,     0,    34,     0,     0,   -22,     0,     0,   -22,   -22,
 758       7,     8,     9,    10,    11,    12,    13,     0,    15,    16,
 759      17,    18,    19,    20,    21,    22,    23,    24,     0,    26,
 760      27,    28,    29,    30,     0,     0,    33,     0,     0,     0,
 761       0,     0,     0,     0,     0,     0,    34,     0,     0,     0,
 762       0,     0,     0,   122,   123,     7,     8,     9,    10,    11,
 763      12,    13,     0,    15,    16,    17,    18,    19,    20,    21,
 764      22,    23,    24,     0,    26,    27,    28,    29,    30,     0,
 765       0,    33,     0,     0,     0,     0,     0,   157,     0,     0,
 766       0,   158,     0,     0,     0,     0,     0,   159,    64,     7,
 767       8,     9,    10,    11,    12,    13,     0,    15,    16,    17,
 768      18,    19,    20,    21,    22,    23,    24,     0,    26,    27,
 769      28,    29,    30,     0,     0,    33,     0,     0,     0,     0,
 770     178,     0,     0,     0,     0,    34,     7,     8,     9,    10,
 771      11,    12,    13,     0,    15,    16,    17,    18,    19,    20,
 772      21,    22,    23,    24,     0,    26,    27,    28,    29,    30,
 773       0,     0,    33,     0,     0,     0,     0,     0,     0,     0,
 774       0,     0,    34
 775};
 776
 777#define yypact_value_is_default(yystate) \
 778  ((yystate) == (-135))
 779
 780#define yytable_value_is_error(yytable_value) \
 781  YYID (0)
 782
 783static const yytype_int16 yycheck[] =
 784{
 785      59,    38,    79,     3,     1,     8,    56,    37,    26,    37,
 786      64,    31,     1,   147,    37,    18,    30,     1,    32,   109,
 787       0,   111,    45,    51,    27,    23,    76,    44,    31,    51,
 788      50,    37,   109,    63,   111,    53,    33,    91,    68,    57,
 789      37,   100,    47,   177,    41,    51,    37,    33,    37,    86,
 790      47,    48,    49,    37,   131,    37,    56,    41,    47,    48,
 791      51,    47,    47,    47,    48,    47,    48,    33,    37,    37,
 792      51,    33,   149,    41,    44,    45,    76,    44,    45,    47,
 793      48,    47,   159,   160,    52,    47,    37,    37,   147,    37,
 794      41,    45,    46,    41,   131,    44,    47,    48,    50,    47,
 795      48,   159,   160,    46,    45,    49,   165,     1,    34,    49,
 796      49,     5,     6,     7,     8,     9,    10,    11,   177,    13,
 797      14,    15,    16,    17,    18,    19,    20,    21,    22,    52,
 798      24,    25,    26,    27,    28,    34,    44,    31,    44,    46,
 799      30,    44,    31,    37,    49,    49,    46,    41,    49,    36,
 800      44,    45,    49,    47,    48,     1,    49,    34,    52,     5,
 801       6,     7,     8,     9,    10,    11,    49,    13,    14,    15,
 802      16,    17,    18,    19,    20,    21,    22,    49,    24,    25,
 803      26,    27,    28,    49,    49,    31,    49,    49,     1,   165,
 804      81,    37,    94,   149,   107,    41,   112,    49,    44,    45,
 805      -1,    47,    48,     1,    -1,   103,    52,     5,     6,     7,
 806       8,     9,    10,    11,    -1,    13,    14,    15,    16,    17,
 807      18,    19,    20,    21,    22,    -1,    24,    25,    26,    27,
 808      28,    -1,    -1,    31,    -1,    -1,    -1,    -1,    36,    -1,
 809       1,    -1,    -1,    41,     5,     6,     7,     8,     9,    10,
 810      11,    49,    13,    14,    15,    16,    17,    18,    19,    20,
 811      21,    22,    -1,    24,    25,    26,    27,    28,    -1,    -1,
 812      31,    -1,    -1,    -1,    -1,    36,    -1,     1,    -1,    -1,
 813      41,     5,     6,     7,     8,     9,    10,    11,    49,    13,
 814      14,    15,    16,    17,    18,    19,    20,    21,    22,    -1,
 815      24,    25,    26,    27,    28,    -1,    -1,    31,    -1,    -1,
 816      -1,    -1,    36,    -1,    -1,    -1,    -1,    41,    -1,    -1,
 817      -1,    -1,     1,    -1,    -1,    49,     5,     6,     7,     8,
 818       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
 819      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
 820      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    37,    -1,
 821      -1,    -1,    41,    -1,    -1,    44,    -1,    -1,    47,    48,
 822       5,     6,     7,     8,     9,    10,    11,    -1,    13,    14,
 823      15,    16,    17,    18,    19,    20,    21,    22,    -1,    24,
 824      25,    26,    27,    28,    -1,    -1,    31,    -1,    -1,    -1,
 825      -1,    -1,    -1,    -1,    -1,    -1,    41,    -1,    -1,    -1,
 826      -1,    -1,    -1,    48,    49,     5,     6,     7,     8,     9,
 827      10,    11,    -1,    13,    14,    15,    16,    17,    18,    19,
 828      20,    21,    22,    -1,    24,    25,    26,    27,    28,    -1,
 829      -1,    31,    -1,    -1,    -1,    -1,    -1,    37,    -1,    -1,
 830      -1,    41,    -1,    -1,    -1,    -1,    -1,    47,    48,     5,
 831       6,     7,     8,     9,    10,    11,    -1,    13,    14,    15,
 832      16,    17,    18,    19,    20,    21,    22,    -1,    24,    25,
 833      26,    27,    28,    -1,    -1,    31,    -1,    -1,    -1,    -1,
 834      36,    -1,    -1,    -1,    -1,    41,     5,     6,     7,     8,
 835       9,    10,    11,    -1,    13,    14,    15,    16,    17,    18,
 836      19,    20,    21,    22,    -1,    24,    25,    26,    27,    28,
 837      -1,    -1,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
 838      -1,    -1,    41
 839};
 840
 841/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 842   symbol of state STATE-NUM.  */
 843static const yytype_uint8 yystos[] =
 844{
 845       0,    54,    55,    56,     0,    55,     1,     5,     6,     7,
 846       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
 847      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
 848      28,    29,    30,    31,    41,    57,    60,    64,    65,    66,
 849      67,    68,    69,    73,    84,    99,   101,    44,    45,    37,
 850      51,    96,    23,    37,    51,    87,    59,    37,    87,    47,
 851      47,    44,    37,    47,    48,    61,    62,    63,    70,    74,
 852      75,    66,    96,    37,    97,    98,    58,    87,     1,    64,
 853      88,    89,    90,    60,    64,    87,    65,    37,     1,    74,
 854      71,    72,    73,    44,    46,    74,    30,    32,   100,    33,
 855      47,    50,    45,    46,    60,    44,    45,    37,    41,    47,
 856      52,    70,    76,    77,    91,    92,    93,    94,    45,     1,
 857      90,    74,    48,    49,    49,    49,    49,    73,    63,    95,
 858       1,    65,    78,    79,    80,    81,    34,    45,    98,    94,
 859       1,    37,    76,    34,    76,    95,    33,    47,    44,    46,
 860      49,    44,    31,    50,    85,    86,    49,    37,    41,    47,
 861      70,    82,    83,    49,    36,    46,    49,    49,     1,    78,
 862      93,    34,     1,    41,    82,    82,    33,    47,    36,    81,
 863      49,    49,    49,    49,     1,    78,    49,    49
 864};
 865
 866#define yyerrok         (yyerrstatus = 0)
 867#define yyclearin       (yychar = YYEMPTY)
 868#define YYEMPTY         (-2)
 869#define YYEOF           0
 870
 871#define YYACCEPT        goto yyacceptlab
 872#define YYABORT         goto yyabortlab
 873#define YYERROR         goto yyerrorlab
 874
 875
 876/* Like YYERROR except do call yyerror.  This remains here temporarily
 877   to ease the transition to the new meaning of YYERROR, for GCC.
 878   Once GCC version 2 has supplanted version 1, this can go.  However,
 879   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
 880   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
 881   discussed.  */
 882
 883#define YYFAIL          goto yyerrlab
 884#if defined YYFAIL
 885  /* This is here to suppress warnings from the GCC cpp's
 886     -Wunused-macros.  Normally we don't worry about that warning, but
 887     some users do, and we want to make it easy for users to remove
 888     YYFAIL uses, which will produce warnings from Bison 2.5.  */
 889#endif
 890
 891#define YYRECOVERING()  (!!yyerrstatus)
 892
 893#define YYBACKUP(Token, Value)                                  \
 894do                                                              \
 895  if (yychar == YYEMPTY && yylen == 1)                          \
 896    {                                                           \
 897      yychar = (Token);                                         \
 898      yylval = (Value);                                         \
 899      YYPOPSTACK (1);                                           \
 900      goto yybackup;                                            \
 901    }                                                           \
 902  else                                                          \
 903    {                                                           \
 904      yyerror (YY_("syntax error: cannot back up")); \
 905      YYERROR;                                                  \
 906    }                                                           \
 907while (YYID (0))
 908
 909
 910#define YYTERROR        1
 911#define YYERRCODE       256
 912
 913
 914/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 915   If N is 0, then set CURRENT to the empty location which ends
 916   the previous symbol: RHS[0] (always defined).  */
 917
 918#define YYRHSLOC(Rhs, K) ((Rhs)[K])
 919#ifndef YYLLOC_DEFAULT
 920# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
 921    do                                                                  \
 922      if (YYID (N))                                                    \
 923        {                                                               \
 924          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
 925          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
 926          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
 927          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
 928        }                                                               \
 929      else                                                              \
 930        {                                                               \
 931          (Current).first_line   = (Current).last_line   =              \
 932            YYRHSLOC (Rhs, 0).last_line;                                \
 933          (Current).first_column = (Current).last_column =              \
 934            YYRHSLOC (Rhs, 0).last_column;                              \
 935        }                                                               \
 936    while (YYID (0))
 937#endif
 938
 939
 940/* This macro is provided for backward compatibility. */
 941
 942#ifndef YY_LOCATION_PRINT
 943# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 944#endif
 945
 946
 947/* YYLEX -- calling `yylex' with the right arguments.  */
 948
 949#ifdef YYLEX_PARAM
 950# define YYLEX yylex (YYLEX_PARAM)
 951#else
 952# define YYLEX yylex ()
 953#endif
 954
 955/* Enable debugging if requested.  */
 956#if YYDEBUG
 957
 958# ifndef YYFPRINTF
 959#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 960#  define YYFPRINTF fprintf
 961# endif
 962
 963# define YYDPRINTF(Args)                        \
 964do {                                            \
 965  if (yydebug)                                  \
 966    YYFPRINTF Args;                             \
 967} while (YYID (0))
 968
 969# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
 970do {                                                                      \
 971  if (yydebug)                                                            \
 972    {                                                                     \
 973      YYFPRINTF (stderr, "%s ", Title);                                   \
 974      yy_symbol_print (stderr,                                            \
 975                  Type, Value); \
 976      YYFPRINTF (stderr, "\n");                                           \
 977    }                                                                     \
 978} while (YYID (0))
 979
 980
 981/*--------------------------------.
 982| Print this symbol on YYOUTPUT.  |
 983`--------------------------------*/
 984
 985/*ARGSUSED*/
 986#if (defined __STDC__ || defined __C99__FUNC__ \
 987     || defined __cplusplus || defined _MSC_VER)
 988static void
 989yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 990#else
 991static void
 992yy_symbol_value_print (yyoutput, yytype, yyvaluep)
 993    FILE *yyoutput;
 994    int yytype;
 995    YYSTYPE const * const yyvaluep;
 996#endif
 997{
 998  if (!yyvaluep)
 999    return;
1000# ifdef YYPRINT
1001  if (yytype < YYNTOKENS)
1002    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1003# else
1004  YYUSE (yyoutput);
1005# endif
1006  switch (yytype)
1007    {
1008      default:
1009        break;
1010    }
1011}
1012
1013
1014/*--------------------------------.
1015| Print this symbol on YYOUTPUT.  |
1016`--------------------------------*/
1017
1018#if (defined __STDC__ || defined __C99__FUNC__ \
1019     || defined __cplusplus || defined _MSC_VER)
1020static void
1021yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1022#else
1023static void
1024yy_symbol_print (yyoutput, yytype, yyvaluep)
1025    FILE *yyoutput;
1026    int yytype;
1027    YYSTYPE const * const yyvaluep;
1028#endif
1029{
1030  if (yytype < YYNTOKENS)
1031    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1032  else
1033    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1034
1035  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1036  YYFPRINTF (yyoutput, ")");
1037}
1038
1039/*------------------------------------------------------------------.
1040| yy_stack_print -- Print the state stack from its BOTTOM up to its |
1041| TOP (included).                                                   |
1042`------------------------------------------------------------------*/
1043
1044#if (defined __STDC__ || defined __C99__FUNC__ \
1045     || defined __cplusplus || defined _MSC_VER)
1046static void
1047yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1048#else
1049static void
1050yy_stack_print (yybottom, yytop)
1051    yytype_int16 *yybottom;
1052    yytype_int16 *yytop;
1053#endif
1054{
1055  YYFPRINTF (stderr, "Stack now");
1056  for (; yybottom <= yytop; yybottom++)
1057    {
1058      int yybot = *yybottom;
1059      YYFPRINTF (stderr, " %d", yybot);
1060    }
1061  YYFPRINTF (stderr, "\n");
1062}
1063
1064# define YY_STACK_PRINT(Bottom, Top)                            \
1065do {                                                            \
1066  if (yydebug)                                                  \
1067    yy_stack_print ((Bottom), (Top));                           \
1068} while (YYID (0))
1069
1070
1071/*------------------------------------------------.
1072| Report that the YYRULE is going to be reduced.  |
1073`------------------------------------------------*/
1074
1075#if (defined __STDC__ || defined __C99__FUNC__ \
1076     || defined __cplusplus || defined _MSC_VER)
1077static void
1078yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1079#else
1080static void
1081yy_reduce_print (yyvsp, yyrule)
1082    YYSTYPE *yyvsp;
1083    int yyrule;
1084#endif
1085{
1086  int yynrhs = yyr2[yyrule];
1087  int yyi;
1088  unsigned long int yylno = yyrline[yyrule];
1089  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1090             yyrule - 1, yylno);
1091  /* The symbols being reduced.  */
1092  for (yyi = 0; yyi < yynrhs; yyi++)
1093    {
1094      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
1095      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1096                       &(yyvsp[(yyi + 1) - (yynrhs)])
1097                                       );
1098      YYFPRINTF (stderr, "\n");
1099    }
1100}
1101
1102# define YY_REDUCE_PRINT(Rule)          \
1103do {                                    \
1104  if (yydebug)                          \
1105    yy_reduce_print (yyvsp, Rule); \
1106} while (YYID (0))
1107
1108/* Nonzero means print parse trace.  It is left uninitialized so that
1109   multiple parsers can coexist.  */
1110int yydebug;
1111#else /* !YYDEBUG */
1112# define YYDPRINTF(Args)
1113# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1114# define YY_STACK_PRINT(Bottom, Top)
1115# define YY_REDUCE_PRINT(Rule)
1116#endif /* !YYDEBUG */
1117
1118
1119/* YYINITDEPTH -- initial size of the parser's stacks.  */
1120#ifndef YYINITDEPTH
1121# define YYINITDEPTH 200
1122#endif
1123
1124/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1125   if the built-in stack extension method is used).
1126
1127   Do not make this value too large; the results are undefined if
1128   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1129   evaluated with infinite-precision integer arithmetic.  */
1130
1131#ifndef YYMAXDEPTH
1132# define YYMAXDEPTH 10000
1133#endif
1134
1135
1136#if YYERROR_VERBOSE
1137
1138# ifndef yystrlen
1139#  if defined __GLIBC__ && defined _STRING_H
1140#   define yystrlen strlen
1141#  else
1142/* Return the length of YYSTR.  */
1143#if (defined __STDC__ || defined __C99__FUNC__ \
1144     || defined __cplusplus || defined _MSC_VER)
1145static YYSIZE_T
1146yystrlen (const char *yystr)
1147#else
1148static YYSIZE_T
1149yystrlen (yystr)
1150    const char *yystr;
1151#endif
1152{
1153  YYSIZE_T yylen;
1154  for (yylen = 0; yystr[yylen]; yylen++)
1155    continue;
1156  return yylen;
1157}
1158#  endif
1159# endif
1160
1161# ifndef yystpcpy
1162#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1163#   define yystpcpy stpcpy
1164#  else
1165/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1166   YYDEST.  */
1167#if (defined __STDC__ || defined __C99__FUNC__ \
1168     || defined __cplusplus || defined _MSC_VER)
1169static char *
1170yystpcpy (char *yydest, const char *yysrc)
1171#else
1172static char *
1173yystpcpy (yydest, yysrc)
1174    char *yydest;
1175    const char *yysrc;
1176#endif
1177{
1178  char *yyd = yydest;
1179  const char *yys = yysrc;
1180
1181  while ((*yyd++ = *yys++) != '\0')
1182    continue;
1183
1184  return yyd - 1;
1185}
1186#  endif
1187# endif
1188
1189# ifndef yytnamerr
1190/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1191   quotes and backslashes, so that it's suitable for yyerror.  The
1192   heuristic is that double-quoting is unnecessary unless the string
1193   contains an apostrophe, a comma, or backslash (other than
1194   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1195   null, do not copy; instead, return the length of what the result
1196   would have been.  */
1197static YYSIZE_T
1198yytnamerr (char *yyres, const char *yystr)
1199{
1200  if (*yystr == '"')
1201    {
1202      YYSIZE_T yyn = 0;
1203      char const *yyp = yystr;
1204
1205      for (;;)
1206        switch (*++yyp)
1207          {
1208          case '\'':
1209          case ',':
1210            goto do_not_strip_quotes;
1211
1212          case '\\':
1213            if (*++yyp != '\\')
1214              goto do_not_strip_quotes;
1215            /* Fall through.  */
1216          default:
1217            if (yyres)
1218              yyres[yyn] = *yyp;
1219            yyn++;
1220            break;
1221
1222          case '"':
1223            if (yyres)
1224              yyres[yyn] = '\0';
1225            return yyn;
1226          }
1227    do_not_strip_quotes: ;
1228    }
1229
1230  if (! yyres)
1231    return yystrlen (yystr);
1232
1233  return yystpcpy (yyres, yystr) - yyres;
1234}
1235# endif
1236
1237/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1238   about the unexpected token YYTOKEN for the state stack whose top is
1239   YYSSP.
1240
1241   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
1242   not large enough to hold the message.  In that case, also set
1243   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
1244   required number of bytes is too large to store.  */
1245static int
1246yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1247                yytype_int16 *yyssp, int yytoken)
1248{
1249  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
1250  YYSIZE_T yysize = yysize0;
1251  YYSIZE_T yysize1;
1252  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1253  /* Internationalized format string. */
1254  const char *yyformat = 0;
1255  /* Arguments of yyformat. */
1256  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1257  /* Number of reported tokens (one for the "unexpected", one per
1258     "expected"). */
1259  int yycount = 0;
1260
1261  /* There are many possibilities here to consider:
1262     - Assume YYFAIL is not used.  It's too flawed to consider.  See
1263       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1264       for details.  YYERROR is fine as it does not invoke this
1265       function.
1266     - If this state is a consistent state with a default action, then
1267       the only way this function was invoked is if the default action
1268       is an error action.  In that case, don't check for expected
1269       tokens because there are none.
1270     - The only way there can be no lookahead present (in yychar) is if
1271       this state is a consistent state with a default action.  Thus,
1272       detecting the absence of a lookahead is sufficient to determine
1273       that there is no unexpected or expected token to report.  In that
1274       case, just report a simple "syntax error".
1275     - Don't assume there isn't a lookahead just because this state is a
1276       consistent state with a default action.  There might have been a
1277       previous inconsistent state, consistent state with a non-default
1278       action, or user semantic action that manipulated yychar.
1279     - Of course, the expected token list depends on states to have
1280       correct lookahead information, and it depends on the parser not
1281       to perform extra reductions after fetching a lookahead from the
1282       scanner and before detecting a syntax error.  Thus, state merging
1283       (from LALR or IELR) and default reductions corrupt the expected
1284       token list.  However, the list is correct for canonical LR with
1285       one exception: it will still contain any token that will not be
1286       accepted due to an error action in a later state.
1287  */
1288  if (yytoken != YYEMPTY)
1289    {
1290      int yyn = yypact[*yyssp];
1291      yyarg[yycount++] = yytname[yytoken];
1292      if (!yypact_value_is_default (yyn))
1293        {
1294          /* Start YYX at -YYN if negative to avoid negative indexes in
1295             YYCHECK.  In other words, skip the first -YYN actions for
1296             this state because they are default actions.  */
1297          int yyxbegin = yyn < 0 ? -yyn : 0;
1298          /* Stay within bounds of both yycheck and yytname.  */
1299          int yychecklim = YYLAST - yyn + 1;
1300          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1301          int yyx;
1302
1303          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1304            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1305                && !yytable_value_is_error (yytable[yyx + yyn]))
1306              {
1307                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1308                  {
1309                    yycount = 1;
1310                    yysize = yysize0;
1311                    break;
1312                  }
1313                yyarg[yycount++] = yytname[yyx];
1314                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1315                if (! (yysize <= yysize1
1316                       && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1317                  return 2;
1318                yysize = yysize1;
1319              }
1320        }
1321    }
1322
1323  switch (yycount)
1324    {
1325# define YYCASE_(N, S)                      \
1326      case N:                               \
1327        yyformat = S;                       \
1328      break
1329      YYCASE_(0, YY_("syntax error"));
1330      YYCASE_(1, YY_("syntax error, unexpected %s"));
1331      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1332      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1333      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1334      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1335# undef YYCASE_
1336    }
1337
1338  yysize1 = yysize + yystrlen (yyformat);
1339  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1340    return 2;
1341  yysize = yysize1;
1342
1343  if (*yymsg_alloc < yysize)
1344    {
1345      *yymsg_alloc = 2 * yysize;
1346      if (! (yysize <= *yymsg_alloc
1347             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1348        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1349      return 1;
1350    }
1351
1352  /* Avoid sprintf, as that infringes on the user's name space.
1353     Don't have undefined behavior even if the translation
1354     produced a string with the wrong number of "%s"s.  */
1355  {
1356    char *yyp = *yymsg;
1357    int yyi = 0;
1358    while ((*yyp = *yyformat) != '\0')
1359      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1360        {
1361          yyp += yytnamerr (yyp, yyarg[yyi++]);
1362          yyformat += 2;
1363        }
1364      else
1365        {
1366          yyp++;
1367          yyformat++;
1368        }
1369  }
1370  return 0;
1371}
1372#endif /* YYERROR_VERBOSE */
1373
1374/*-----------------------------------------------.
1375| Release the memory associated to this symbol.  |
1376`-----------------------------------------------*/
1377
1378/*ARGSUSED*/
1379#if (defined __STDC__ || defined __C99__FUNC__ \
1380     || defined __cplusplus || defined _MSC_VER)
1381static void
1382yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1383#else
1384static void
1385yydestruct (yymsg, yytype, yyvaluep)
1386    const char *yymsg;
1387    int yytype;
1388    YYSTYPE *yyvaluep;
1389#endif
1390{
1391  YYUSE (yyvaluep);
1392
1393  if (!yymsg)
1394    yymsg = "Deleting";
1395  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1396
1397  switch (yytype)
1398    {
1399
1400      default:
1401        break;
1402    }
1403}
1404
1405
1406/* Prevent warnings from -Wmissing-prototypes.  */
1407#ifdef YYPARSE_PARAM
1408#if defined __STDC__ || defined __cplusplus
1409int yyparse (void *YYPARSE_PARAM);
1410#else
1411int yyparse ();
1412#endif
1413#else /* ! YYPARSE_PARAM */
1414#if defined __STDC__ || defined __cplusplus
1415int yyparse (void);
1416#else
1417int yyparse ();
1418#endif
1419#endif /* ! YYPARSE_PARAM */
1420
1421
1422/* The lookahead symbol.  */
1423int yychar;
1424
1425/* The semantic value of the lookahead symbol.  */
1426YYSTYPE yylval;
1427
1428/* Number of syntax errors so far.  */
1429int yynerrs;
1430
1431
1432/*----------.
1433| yyparse.  |
1434`----------*/
1435
1436#ifdef YYPARSE_PARAM
1437#if (defined __STDC__ || defined __C99__FUNC__ \
1438     || defined __cplusplus || defined _MSC_VER)
1439int
1440yyparse (void *YYPARSE_PARAM)
1441#else
1442int
1443yyparse (YYPARSE_PARAM)
1444    void *YYPARSE_PARAM;
1445#endif
1446#else /* ! YYPARSE_PARAM */
1447#if (defined __STDC__ || defined __C99__FUNC__ \
1448     || defined __cplusplus || defined _MSC_VER)
1449int
1450yyparse (void)
1451#else
1452int
1453yyparse ()
1454
1455#endif
1456#endif
1457{
1458    int yystate;
1459    /* Number of tokens to shift before error messages enabled.  */
1460    int yyerrstatus;
1461
1462    /* The stacks and their tools:
1463       `yyss': related to states.
1464       `yyvs': related to semantic values.
1465
1466       Refer to the stacks thru separate pointers, to allow yyoverflow
1467       to reallocate them elsewhere.  */
1468
1469    /* The state stack.  */
1470    yytype_int16 yyssa[YYINITDEPTH];
1471    yytype_int16 *yyss;
1472    yytype_int16 *yyssp;
1473
1474    /* The semantic value stack.  */
1475    YYSTYPE yyvsa[YYINITDEPTH];
1476    YYSTYPE *yyvs;
1477    YYSTYPE *yyvsp;
1478
1479    YYSIZE_T yystacksize;
1480
1481  int yyn;
1482  int yyresult;
1483  /* Lookahead token as an internal (translated) token number.  */
1484  int yytoken;
1485  /* The variables used to return semantic value and location from the
1486     action routines.  */
1487  YYSTYPE yyval;
1488
1489#if YYERROR_VERBOSE
1490  /* Buffer for error messages, and its allocated size.  */
1491  char yymsgbuf[128];
1492  char *yymsg = yymsgbuf;
1493  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1494#endif
1495
1496#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1497
1498  /* The number of symbols on the RHS of the reduced rule.
1499     Keep to zero when no symbol should be popped.  */
1500  int yylen = 0;
1501
1502  yytoken = 0;
1503  yyss = yyssa;
1504  yyvs = yyvsa;
1505  yystacksize = YYINITDEPTH;
1506
1507  YYDPRINTF ((stderr, "Starting parse\n"));
1508
1509  yystate = 0;
1510  yyerrstatus = 0;
1511  yynerrs = 0;
1512  yychar = YYEMPTY; /* Cause a token to be read.  */
1513
1514  /* Initialize stack pointers.
1515     Waste one element of value and location stack
1516     so that they stay on the same level as the state stack.
1517     The wasted elements are never initialized.  */
1518  yyssp = yyss;
1519  yyvsp = yyvs;
1520
1521  goto yysetstate;
1522
1523/*------------------------------------------------------------.
1524| yynewstate -- Push a new state, which is found in yystate.  |
1525`------------------------------------------------------------*/
1526 yynewstate:
1527  /* In all cases, when you get here, the value and location stacks
1528     have just been pushed.  So pushing a state here evens the stacks.  */
1529  yyssp++;
1530
1531 yysetstate:
1532  *yyssp = yystate;
1533
1534  if (yyss + yystacksize - 1 <= yyssp)
1535    {
1536      /* Get the current used size of the three stacks, in elements.  */
1537      YYSIZE_T yysize = yyssp - yyss + 1;
1538
1539#ifdef yyoverflow
1540      {
1541        /* Give user a chance to reallocate the stack.  Use copies of
1542           these so that the &'s don't force the real ones into
1543           memory.  */
1544        YYSTYPE *yyvs1 = yyvs;
1545        yytype_int16 *yyss1 = yyss;
1546
1547        /* Each stack pointer address is followed by the size of the
1548           data in use in that stack, in bytes.  This used to be a
1549           conditional around just the two extra args, but that might
1550           be undefined if yyoverflow is a macro.  */
1551        yyoverflow (YY_("memory exhausted"),
1552                    &yyss1, yysize * sizeof (*yyssp),
1553                    &yyvs1, yysize * sizeof (*yyvsp),
1554                    &yystacksize);
1555
1556        yyss = yyss1;
1557        yyvs = yyvs1;
1558      }
1559#else /* no yyoverflow */
1560# ifndef YYSTACK_RELOCATE
1561      goto yyexhaustedlab;
1562# else
1563      /* Extend the stack our own way.  */
1564      if (YYMAXDEPTH <= yystacksize)
1565        goto yyexhaustedlab;
1566      yystacksize *= 2;
1567      if (YYMAXDEPTH < yystacksize)
1568        yystacksize = YYMAXDEPTH;
1569
1570      {
1571        yytype_int16 *yyss1 = yyss;
1572        union yyalloc *yyptr =
1573          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1574        if (! yyptr)
1575          goto yyexhaustedlab;
1576        YYSTACK_RELOCATE (yyss_alloc, yyss);
1577        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1578#  undef YYSTACK_RELOCATE
1579        if (yyss1 != yyssa)
1580          YYSTACK_FREE (yyss1);
1581      }
1582# endif
1583#endif /* no yyoverflow */
1584
1585      yyssp = yyss + yysize - 1;
1586      yyvsp = yyvs + yysize - 1;
1587
1588      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1589                  (unsigned long int) yystacksize));
1590
1591      if (yyss + yystacksize - 1 <= yyssp)
1592        YYABORT;
1593    }
1594
1595  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1596
1597  if (yystate == YYFINAL)
1598    YYACCEPT;
1599
1600  goto yybackup;
1601
1602/*-----------.
1603| yybackup.  |
1604`-----------*/
1605yybackup:
1606
1607  /* Do appropriate processing given the current state.  Read a
1608     lookahead token if we need one and don't already have one.  */
1609
1610  /* First try to decide what to do without reference to lookahead token.  */
1611  yyn = yypact[yystate];
1612  if (yypact_value_is_default (yyn))
1613    goto yydefault;
1614
1615  /* Not known => get a lookahead token if don't already have one.  */
1616
1617  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1618  if (yychar == YYEMPTY)
1619    {
1620      YYDPRINTF ((stderr, "Reading a token: "));
1621      yychar = YYLEX;
1622    }
1623
1624  if (yychar <= YYEOF)
1625    {
1626      yychar = yytoken = YYEOF;
1627      YYDPRINTF ((stderr, "Now at end of input.\n"));
1628    }
1629  else
1630    {
1631      yytoken = YYTRANSLATE (yychar);
1632      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1633    }
1634
1635  /* If the proper action on seeing token YYTOKEN is to reduce or to
1636     detect an error, take that action.  */
1637  yyn += yytoken;
1638  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1639    goto yydefault;
1640  yyn = yytable[yyn];
1641  if (yyn <= 0)
1642    {
1643      if (yytable_value_is_error (yyn))
1644        goto yyerrlab;
1645      yyn = -yyn;
1646      goto yyreduce;
1647    }
1648
1649  /* Count tokens shifted since error; after three, turn off error
1650     status.  */
1651  if (yyerrstatus)
1652    yyerrstatus--;
1653
1654  /* Shift the lookahead token.  */
1655  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1656
1657  /* Discard the shifted token.  */
1658  yychar = YYEMPTY;
1659
1660  yystate = yyn;
1661  *++yyvsp = yylval;
1662
1663  goto yynewstate;
1664
1665
1666/*-----------------------------------------------------------.
1667| yydefault -- do the default action for the current state.  |
1668`-----------------------------------------------------------*/
1669yydefault:
1670  yyn = yydefact[yystate];
1671  if (yyn == 0)
1672    goto yyerrlab;
1673  goto yyreduce;
1674
1675
1676/*-----------------------------.
1677| yyreduce -- Do a reduction.  |
1678`-----------------------------*/
1679yyreduce:
1680  /* yyn is the number of a rule to reduce with.  */
1681  yylen = yyr2[yyn];
1682
1683  /* If YYLEN is nonzero, implement the default value of the action:
1684     `$$ = $1'.
1685
1686     Otherwise, the following line sets YYVAL to garbage.
1687     This behavior is undocumented and Bison
1688     users should not rely upon it.  Assigning to YYVAL
1689     unconditionally makes the parser a bit smaller, and it avoids a
1690     GCC warning that YYVAL may be used uninitialized.  */
1691  yyval = yyvsp[1-yylen];
1692
1693
1694  YY_REDUCE_PRINT (yyn);
1695  switch (yyn)
1696    {
1697        case 4:
1698
1699    { is_typedef = 0; is_extern = 0; current_name = NULL; decl_spec = NULL; }
1700    break;
1701
1702  case 5:
1703
1704    { free_list(*(yyvsp[(2) - (2)]), NULL); *(yyvsp[(2) - (2)]) = NULL; }
1705    break;
1706
1707  case 6:
1708
1709    { is_typedef = 1; }
1710    break;
1711
1712  case 7:
1713
1714    { (yyval) = (yyvsp[(4) - (4)]); }
1715    break;
1716
1717  case 8:
1718
1719    { is_typedef = 1; }
1720    break;
1721
1722  case 9:
1723
1724    { (yyval) = (yyvsp[(3) - (3)]); }
1725    break;
1726
1727  case 14:
1728
1729    { (yyval) = (yyvsp[(2) - (2)]); }
1730    break;
1731
1732  case 15:
1733
1734    { (yyval) = (yyvsp[(2) - (2)]); }
1735    break;
1736
1737  case 16:
1738
1739    { if (current_name) {
1740                    struct string_list *decl = (*(yyvsp[(3) - (3)]))->next;
1741                    (*(yyvsp[(3) - (3)]))->next = NULL;
1742                    add_symbol(current_name,
1743                               is_typedef ? SYM_TYPEDEF : SYM_NORMAL,
1744                               decl, is_extern);
1745                    current_name = NULL;
1746                  }
1747                  (yyval) = (yyvsp[(3) - (3)]);
1748                }
1749    break;
1750
1751  case 17:
1752
1753    { (yyval) = NULL; }
1754    break;
1755
1756  case 19:
1757
1758    { struct string_list *decl = *(yyvsp[(1) - (1)]);
1759                  *(yyvsp[(1) - (1)]) = NULL;
1760                  add_symbol(current_name,
1761                             is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern);
1762                  current_name = NULL;
1763                  (yyval) = (yyvsp[(1) - (1)]);
1764                }
1765    break;
1766
1767  case 20:
1768
1769    { struct string_list *decl = *(yyvsp[(3) - (3)]);
1770                  *(yyvsp[(3) - (3)]) = NULL;
1771                  free_list(*(yyvsp[(2) - (3)]), NULL);
1772                  *(yyvsp[(2) - (3)]) = decl_spec;
1773                  add_symbol(current_name,
1774                             is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern);
1775                  current_name = NULL;
1776                  (yyval) = (yyvsp[(3) - (3)]);
1777                }
1778    break;
1779
1780  case 21:
1781
1782    { (yyval) = (yyvsp[(4) - (4)]) ? (yyvsp[(4) - (4)]) : (yyvsp[(3) - (4)]) ? (yyvsp[(3) - (4)]) : (yyvsp[(2) - (4)]) ? (yyvsp[(2) - (4)]) : (yyvsp[(1) - (4)]); }
1783    break;
1784
1785  case 22:
1786
1787    { decl_spec = NULL; }
1788    break;
1789
1790  case 24:
1791
1792    { decl_spec = *(yyvsp[(1) - (1)]); }
1793    break;
1794
1795  case 25:
1796
1797    { decl_spec = *(yyvsp[(2) - (2)]); }
1798    break;
1799
1800  case 26:
1801
1802    { /* Version 2 checksumming ignores storage class, as that
1803                     is really irrelevant to the linkage.  */
1804                  remove_node((yyvsp[(1) - (1)]));
1805                  (yyval) = (yyvsp[(1) - (1)]);
1806                }
1807    break;
1808
1809  case 31:
1810
1811    { is_extern = 1; (yyval) = (yyvsp[(1) - (1)]); }
1812    break;
1813
1814  case 32:
1815
1816    { is_extern = 0; (yyval) = (yyvsp[(1) - (1)]); }
1817    break;
1818
1819  case 37:
1820
1821    { remove_node((yyvsp[(1) - (2)])); (*(yyvsp[(2) - (2)]))->tag = SYM_STRUCT; (yyval) = (yyvsp[(2) - (2)]); }
1822    break;
1823
1824  case 38:
1825
1826    { remove_node((yyvsp[(1) - (2)])); (*(yyvsp[(2) - (2)]))->tag = SYM_UNION; (yyval) = (yyvsp[(2) - (2)]); }
1827    break;
1828
1829  case 39:
1830
1831    { remove_node((yyvsp[(1) - (2)])); (*(yyvsp[(2) - (2)]))->tag = SYM_ENUM; (yyval) = (yyvsp[(2) - (2)]); }
1832    break;
1833
1834  case 40:
1835
1836    { record_compound((yyvsp[(1) - (3)]), (yyvsp[(2) - (3)]), (yyvsp[(3) - (3)]), SYM_STRUCT); (yyval) = (yyvsp[(3) - (3)]); }
1837    break;
1838
1839  case 41:
1840
1841    { record_compound((yyvsp[(1) - (3)]), (yyvsp[(2) - (3)]), (yyvsp[(3) - (3)]), SYM_UNION); (yyval) = (yyvsp[(3) - (3)]); }
1842    break;
1843
1844  case 42:
1845
1846    { record_compound((yyvsp[(1) - (3)]), (yyvsp[(2) - (3)]), (yyvsp[(3) - (3)]), SYM_ENUM); (yyval) = (yyvsp[(3) - (3)]); }
1847    break;
1848
1849  case 43:
1850
1851    { add_symbol(NULL, SYM_ENUM, NULL, 0); (yyval) = (yyvsp[(2) - (2)]); }
1852    break;
1853
1854  case 44:
1855
1856    { (yyval) = (yyvsp[(2) - (2)]); }
1857    break;
1858
1859  case 45:
1860
1861    { (yyval) = (yyvsp[(2) - (2)]); }
1862    break;
1863
1864  case 56:
1865
1866    { (*(yyvsp[(1) - (1)]))->tag = SYM_TYPEDEF; (yyval) = (yyvsp[(1) - (1)]); }
1867    break;
1868
1869  case 57:
1870
1871    { (yyval) = (yyvsp[(2) - (2)]) ? (yyvsp[(2) - (2)]) : (yyvsp[(1) - (2)]); }
1872    break;
1873
1874  case 58:
1875
1876    { (yyval) = NULL; }
1877    break;
1878
1879  case 61:
1880
1881    { (yyval) = (yyvsp[(2) - (2)]); }
1882    break;
1883
1884  case 65:
1885
1886    { /* restrict has no effect in prototypes so ignore it */
1887                  remove_node((yyvsp[(1) - (1)]));
1888                  (yyval) = (yyvsp[(1) - (1)]);
1889                }
1890    break;
1891
1892  case 66:
1893
1894    { (yyval) = (yyvsp[(2) - (2)]); }
1895    break;
1896
1897  case 68:
1898
1899    { if (current_name != NULL) {
1900                    error_with_pos("unexpected second declaration name");
1901                    YYERROR;
1902                  } else {
1903                    current_name = (*(yyvsp[(1) - (1)]))->string;
1904                    (yyval) = (yyvsp[(1) - (1)]);
1905                  }
1906                }
1907    break;
1908
1909  case 69:
1910
1911    { (yyval) = (yyvsp[(4) - (4)]); }
1912    break;
1913
1914  case 70:
1915
1916    { (yyval) = (yyvsp[(4) - (4)]); }
1917    break;
1918
1919  case 71:
1920
1921    { (yyval) = (yyvsp[(2) - (2)]); }
1922    break;
1923
1924  case 72:
1925
1926    { (yyval) = (yyvsp[(3) - (3)]); }
1927    break;
1928
1929  case 73:
1930
1931    { (yyval) = (yyvsp[(3) - (3)]); }
1932    break;
1933
1934  case 74:
1935
1936    { (yyval) = (yyvsp[(2) - (2)]); }
1937    break;
1938
1939  case 78:
1940
1941    { (yyval) = (yyvsp[(4) - (4)]); }
1942    break;
1943
1944  case 79:
1945
1946    { (yyval) = (yyvsp[(4) - (4)]); }
1947    break;
1948
1949  case 80:
1950
1951    { (yyval) = (yyvsp[(2) - (2)]); }
1952    break;
1953
1954  case 81:
1955
1956    { (yyval) = (yyvsp[(3) - (3)]); }
1957    break;
1958
1959  case 82:
1960
1961    { (yyval) = (yyvsp[(3) - (3)]); }
1962    break;
1963
1964  case 83:
1965
1966    { (yyval) = (yyvsp[(2) - (2)]); }
1967    break;
1968
1969  case 85:
1970
1971    { (yyval) = (yyvsp[(3) - (3)]); }
1972    break;
1973
1974  case 86:
1975
1976    { (yyval) = NULL; }
1977    break;
1978
1979  case 89:
1980
1981    { (yyval) = (yyvsp[(3) - (3)]); }
1982    break;
1983
1984  case 90:
1985
1986    { (yyval) = (yyvsp[(2) - (2)]) ? (yyvsp[(2) - (2)]) : (yyvsp[(1) - (2)]); }
1987    break;
1988
1989  case 91:
1990
1991    { (yyval) = (yyvsp[(2) - (2)]) ? (yyvsp[(2) - (2)]) : (yyvsp[(1) - (2)]); }
1992    break;
1993
1994  case 93:
1995
1996    { (yyval) = NULL; }
1997    break;
1998
1999  case 94:
2000
2001    { /* For version 2 checksums, we don't want to remember
2002                     private parameter names.  */
2003                  remove_node((yyvsp[(1) - (1)]));
2004                  (yyval) = (yyvsp[(1) - (1)]);
2005                }
2006    break;
2007
2008  case 95:
2009
2010    { remove_node((yyvsp[(1) - (1)]));
2011                  (yyval) = (yyvsp[(1) - (1)]);
2012                }
2013    break;
2014
2015  case 96:
2016
2017    { (yyval) = (yyvsp[(4) - (4)]); }
2018    break;
2019
2020  case 97:
2021
2022    { (yyval) = (yyvsp[(4) - (4)]); }
2023    break;
2024
2025  case 98:
2026
2027    { (yyval) = (yyvsp[(2) - (2)]); }
2028    break;
2029
2030  case 99:
2031
2032    { (yyval) = (yyvsp[(3) - (3)]); }
2033    break;
2034
2035  case 100:
2036
2037    { (yyval) = (yyvsp[(3) - (3)]); }
2038    break;
2039
2040  case 101:
2041
2042    { struct string_list *decl = *(yyvsp[(2) - (3)]);
2043                  *(yyvsp[(2) - (3)]) = NULL;
2044                  add_symbol(current_name, SYM_NORMAL, decl, is_extern);
2045                  (yyval) = (yyvsp[(3) - (3)]);
2046                }
2047    break;
2048
2049  case 102:
2050
2051    { (yyval) = NULL; }
2052    break;
2053
2054  case 104:
2055
2056    { remove_list((yyvsp[(2) - (2)]), &(*(yyvsp[(1) - (2)]))->next); (yyval) = (yyvsp[(2) - (2)]); }
2057    break;
2058
2059  case 105:
2060
2061    { (yyval) = (yyvsp[(3) - (3)]); }
2062    break;
2063
2064  case 106:
2065
2066    { (yyval) = (yyvsp[(3) - (3)]); }
2067    break;
2068
2069  case 107:
2070
2071    { (yyval) = NULL; }
2072    break;
2073
2074  case 110:
2075
2076    { (yyval) = (yyvsp[(2) - (2)]); }
2077    break;
2078
2079  case 111:
2080
2081    { (yyval) = (yyvsp[(3) - (3)]); }
2082    break;
2083
2084  case 112:
2085
2086    { (yyval) = (yyvsp[(2) - (2)]); }
2087    break;
2088
2089  case 113:
2090
2091    { (yyval) = NULL; }
2092    break;
2093
2094  case 116:
2095
2096    { (yyval) = (yyvsp[(3) - (3)]); }
2097    break;
2098
2099  case 117:
2100
2101    { (yyval) = (yyvsp[(2) - (2)]) ? (yyvsp[(2) - (2)]) : (yyvsp[(1) - (2)]); }
2102    break;
2103
2104  case 118:
2105
2106    { (yyval) = (yyvsp[(2) - (2)]); }
2107    break;
2108
2109  case 120:
2110
2111    { (yyval) = (yyvsp[(2) - (2)]); }
2112    break;
2113
2114  case 121:
2115
2116    { (yyval) = NULL; }
2117    break;
2118
2119  case 123:
2120
2121    { (yyval) = (yyvsp[(3) - (3)]); }
2122    break;
2123
2124  case 124:
2125
2126    { (yyval) = (yyvsp[(4) - (4)]); }
2127    break;
2128
2129  case 127:
2130
2131    {
2132                        const char *name = strdup((*(yyvsp[(1) - (1)]))->string);
2133                        add_symbol(name, SYM_ENUM_CONST, NULL, 0);
2134                }
2135    break;
2136
2137  case 128:
2138
2139    {
2140                        const char *name = strdup((*(yyvsp[(1) - (3)]))->string);
2141                        struct string_list *expr = copy_list_range(*(yyvsp[(3) - (3)]), *(yyvsp[(2) - (3)]));
2142                        add_symbol(name, SYM_ENUM_CONST, expr, 0);
2143                }
2144    break;
2145
2146  case 129:
2147
2148    { (yyval) = (yyvsp[(2) - (2)]); }
2149    break;
2150
2151  case 130:
2152
2153    { (yyval) = NULL; }
2154    break;
2155
2156  case 132:
2157
2158    { export_symbol((*(yyvsp[(3) - (5)]))->string); (yyval) = (yyvsp[(5) - (5)]); }
2159    break;
2160
2161
2162
2163      default: break;
2164    }
2165  /* User semantic actions sometimes alter yychar, and that requires
2166     that yytoken be updated with the new translation.  We take the
2167     approach of translating immediately before every use of yytoken.
2168     One alternative is translating here after every semantic action,
2169     but that translation would be missed if the semantic action invokes
2170     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2171     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
2172     incorrect destructor might then be invoked immediately.  In the
2173     case of YYERROR or YYBACKUP, subsequent parser actions might lead
2174     to an incorrect destructor call or verbose syntax error message
2175     before the lookahead is translated.  */
2176  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2177
2178  YYPOPSTACK (yylen);
2179  yylen = 0;
2180  YY_STACK_PRINT (yyss, yyssp);
2181
2182  *++yyvsp = yyval;
2183
2184  /* Now `shift' the result of the reduction.  Determine what state
2185     that goes to, based on the state we popped back to and the rule
2186     number reduced by.  */
2187
2188  yyn = yyr1[yyn];
2189
2190  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2191  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2192    yystate = yytable[yystate];
2193  else
2194    yystate = yydefgoto[yyn - YYNTOKENS];
2195
2196  goto yynewstate;
2197
2198
2199/*------------------------------------.
2200| yyerrlab -- here on detecting error |
2201`------------------------------------*/
2202yyerrlab:
2203  /* Make sure we have latest lookahead translation.  See comments at
2204     user semantic actions for why this is necessary.  */
2205  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2206
2207  /* If not already recovering from an error, report this error.  */
2208  if (!yyerrstatus)
2209    {
2210      ++yynerrs;
2211#if ! YYERROR_VERBOSE
2212      yyerror (YY_("syntax error"));
2213#else
2214# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2215                                        yyssp, yytoken)
2216      {
2217        char const *yymsgp = YY_("syntax error");
2218        int yysyntax_error_status;
2219        yysyntax_error_status = YYSYNTAX_ERROR;
2220        if (yysyntax_error_status == 0)
2221          yymsgp = yymsg;
2222        else if (yysyntax_error_status == 1)
2223          {
2224            if (yymsg != yymsgbuf)
2225              YYSTACK_FREE (yymsg);
2226            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2227            if (!yymsg)
2228              {
2229                yymsg = yymsgbuf;
2230                yymsg_alloc = sizeof yymsgbuf;
2231                yysyntax_error_status = 2;
2232              }
2233            else
2234              {
2235                yysyntax_error_status = YYSYNTAX_ERROR;
2236                yymsgp = yymsg;
2237              }
2238          }
2239        yyerror (yymsgp);
2240        if (yysyntax_error_status == 2)
2241          goto yyexhaustedlab;
2242      }
2243# undef YYSYNTAX_ERROR
2244#endif
2245    }
2246
2247
2248
2249  if (yyerrstatus == 3)
2250    {
2251      /* If just tried and failed to reuse lookahead token after an
2252         error, discard it.  */
2253
2254      if (yychar <= YYEOF)
2255        {
2256          /* Return failure if at end of input.  */
2257          if (yychar == YYEOF)
2258            YYABORT;
2259        }
2260      else
2261        {
2262          yydestruct ("Error: discarding",
2263                      yytoken, &yylval);
2264          yychar = YYEMPTY;
2265        }
2266    }
2267
2268  /* Else will try to reuse lookahead token after shifting the error
2269     token.  */
2270  goto yyerrlab1;
2271
2272
2273/*---------------------------------------------------.
2274| yyerrorlab -- error raised explicitly by YYERROR.  |
2275`---------------------------------------------------*/
2276yyerrorlab:
2277
2278  /* Pacify compilers like GCC when the user code never invokes
2279     YYERROR and the label yyerrorlab therefore never appears in user
2280     code.  */
2281  if (/*CONSTCOND*/ 0)
2282     goto yyerrorlab;
2283
2284  /* Do not reclaim the symbols of the rule which action triggered
2285     this YYERROR.  */
2286  YYPOPSTACK (yylen);
2287  yylen = 0;
2288  YY_STACK_PRINT (yyss, yyssp);
2289  yystate = *yyssp;
2290  goto yyerrlab1;
2291
2292
2293/*-------------------------------------------------------------.
2294| yyerrlab1 -- common code for both syntax error and YYERROR.  |
2295`-------------------------------------------------------------*/
2296yyerrlab1:
2297  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
2298
2299  for (;;)
2300    {
2301      yyn = yypact[yystate];
2302      if (!yypact_value_is_default (yyn))
2303        {
2304          yyn += YYTERROR;
2305          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2306            {
2307              yyn = yytable[yyn];
2308              if (0 < yyn)
2309                break;
2310            }
2311        }
2312
2313      /* Pop the current state because it cannot handle the error token.  */
2314      if (yyssp == yyss)
2315        YYABORT;
2316
2317
2318      yydestruct ("Error: popping",
2319                  yystos[yystate], yyvsp);
2320      YYPOPSTACK (1);
2321      yystate = *yyssp;
2322      YY_STACK_PRINT (yyss, yyssp);
2323    }
2324
2325  *++yyvsp = yylval;
2326
2327
2328  /* Shift the error token.  */
2329  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2330
2331  yystate = yyn;
2332  goto yynewstate;
2333
2334
2335/*-------------------------------------.
2336| yyacceptlab -- YYACCEPT comes here.  |
2337`-------------------------------------*/
2338yyacceptlab:
2339  yyresult = 0;
2340  goto yyreturn;
2341
2342/*-----------------------------------.
2343| yyabortlab -- YYABORT comes here.  |
2344`-----------------------------------*/
2345yyabortlab:
2346  yyresult = 1;
2347  goto yyreturn;
2348
2349#if !defined(yyoverflow) || YYERROR_VERBOSE
2350/*-------------------------------------------------.
2351| yyexhaustedlab -- memory exhaustion comes here.  |
2352`-------------------------------------------------*/
2353yyexhaustedlab:
2354  yyerror (YY_("memory exhausted"));
2355  yyresult = 2;
2356  /* Fall through.  */
2357#endif
2358
2359yyreturn:
2360  if (yychar != YYEMPTY)
2361    {
2362      /* Make sure we have latest lookahead translation.  See comments at
2363         user semantic actions for why this is necessary.  */
2364      yytoken = YYTRANSLATE (yychar);
2365      yydestruct ("Cleanup: discarding lookahead",
2366                  yytoken, &yylval);
2367    }
2368  /* Do not reclaim the symbols of the rule which action triggered
2369     this YYABORT or YYACCEPT.  */
2370  YYPOPSTACK (yylen);
2371  YY_STACK_PRINT (yyss, yyssp);
2372  while (yyssp != yyss)
2373    {
2374      yydestruct ("Cleanup: popping",
2375                  yystos[*yyssp], yyvsp);
2376      YYPOPSTACK (1);
2377    }
2378#ifndef yyoverflow
2379  if (yyss != yyssa)
2380    YYSTACK_FREE (yyss);
2381#endif
2382#if YYERROR_VERBOSE
2383  if (yymsg != yymsgbuf)
2384    YYSTACK_FREE (yymsg);
2385#endif
2386  /* Make sure YYID is used.  */
2387  return YYID (yyresult);
2388}
2389
2390
2391
2392
2393
2394static void
2395yyerror(const char *e)
2396{
2397  error_with_pos("%s", e);
2398}
2399
2400
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.