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