util/cbfstool/fmd_parser.c_shipped

   1 /* A Bison parser, made by GNU Bison 3.8.2.  */
   2
   3 /* Bison implementation for Yacc-like parsers in C
   4
   5    Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
   6    Inc.
   7
   8    This program is free software: you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation, either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  20
  21 /* As a special exception, you may create a larger work that contains
  22    part or all of the Bison parser skeleton and distribute that work
  23    under terms of your choice, so long as that work isn't itself a
  24    parser generator using the skeleton or a modified version thereof
  25    as a parser skeleton.  Alternatively, if you modify or redistribute
  26    the parser skeleton itself, you may (at your option) remove this
  27    special exception, which will cause the skeleton and the resulting
  28    Bison output files to be licensed under the GNU General Public
  29    License without this special exception.
  30
  31    This special exception was added by the Free Software Foundation in
  32    version 2.2 of Bison.  */
  33
  34 /* C LALR(1) parser skeleton written by Richard Stallman, by
  35    simplifying the original so-called "semantic" parser.  */
  36
  37 /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
  38    especially those whose name start with YY_ or yy_.  They are
  39    private implementation details that can be changed or removed.  */
  40
  41 /* All symbols defined below should begin with yy or YY, to avoid
  42    infringing on user name space.  This should be done even for local
  43    variables, as they might otherwise be expanded by user macros.
  44    There are some unavoidable exceptions within include files to
  45    define necessary library symbols; they are noted "INFRINGES ON
  46    USER NAME SPACE" below.  */
  47
  48 /* Identify Bison output, and Bison version.  */
  49 #define YYBISON 30802
  50
  51 /* Bison version string.  */
  52 #define YYBISON_VERSION "3.8.2"
  53
  54 /* Skeleton name.  */
  55 #define YYSKELETON_NAME "yacc.c"
  56
  57 /* Pure parsers.  */
  58 #define YYPURE 0
  59
  60 /* Push parsers.  */
  61 #define YYPUSH 0
  62
  63 /* Pull parsers.  */
  64 #define YYPULL 1
  65
  66
  67
  68
  69 /* First part of user prologue.  */
  70
  71 #include "fmd_scanner.h"
  72 #include "common.h"
  73
  74 #include <stdlib.h>
  75
  76 struct flashmap_descriptor *res = NULL;
  77
  78
  79 # ifndef YY_CAST
  80 #  ifdef __cplusplus
  81 #   define YY_CAST(Type, Val) static_cast<Type> (Val)
  82 #   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
  83 #  else
  84 #   define YY_CAST(Type, Val) ((Type) (Val))
  85 #   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
  86 #  endif
  87 # endif
  88 # ifndef YY_NULLPTR
  89 #  if defined __cplusplus
  90 #   if 201103L <= __cplusplus
  91 #    define YY_NULLPTR nullptr
  92 #   else
  93 #    define YY_NULLPTR 0
  94 #   endif
  95 #  else
  96 #   define YY_NULLPTR ((void*)0)
  97 #  endif
  98 # endif
  99
 100 #include "fmd_parser.h_shipped"
 101 /* Symbol kind.  */
 102 enum yysymbol_kind_t
 103 {
 104   YYSYMBOL_YYEMPTY = -2,
 105   YYSYMBOL_YYEOF = 0,                      /* "end of file"  */
 106   YYSYMBOL_YYerror = 1,                    /* error  */
 107   YYSYMBOL_YYUNDEF = 2,                    /* "invalid token"  */
 108   YYSYMBOL_INTEGER = 3,                    /* INTEGER  */
 109   YYSYMBOL_OCTAL = 4,                      /* OCTAL  */
 110   YYSYMBOL_STRING = 5,                     /* STRING  */
 111   YYSYMBOL_FLAG_CBFS = 6,                  /* FLAG_CBFS  */
 112   YYSYMBOL_FLAG_PRESERVE = 7,              /* FLAG_PRESERVE  */
 113   YYSYMBOL_8_ = 8,                         /* '('  */
 114   YYSYMBOL_9_ = 9,                         /* ')'  */
 115   YYSYMBOL_10_ = 10,                       /* '@'  */
 116   YYSYMBOL_11_ = 11,                       /* '{'  */
 117   YYSYMBOL_12_ = 12,                       /* '}'  */
 118   YYSYMBOL_YYACCEPT = 13,                  /* $accept  */
 119   YYSYMBOL_flash_chip = 14,                /* flash_chip  */
 120   YYSYMBOL_flash_region = 15,              /* flash_region  */
 121   YYSYMBOL_region_name = 16,               /* region_name  */
 122   YYSYMBOL_region_flags_opt = 17,          /* region_flags_opt  */
 123   YYSYMBOL_region_flags = 18,              /* region_flags  */
 124   YYSYMBOL_region_flag = 19,               /* region_flag  */
 125   YYSYMBOL_region_offset_opt = 20,         /* region_offset_opt  */
 126   YYSYMBOL_region_offset = 21,             /* region_offset  */
 127   YYSYMBOL_region_size_opt = 22,           /* region_size_opt  */
 128   YYSYMBOL_region_size = 23,               /* region_size  */
 129   YYSYMBOL_region_list_opt = 24,           /* region_list_opt  */
 130   YYSYMBOL_region_list = 25,               /* region_list  */
 131   YYSYMBOL_region_list_entries = 26        /* region_list_entries  */
 132 };
 133 typedef enum yysymbol_kind_t yysymbol_kind_t;
 134
 135
 136
 137
 138 #ifdef short
 139 # undef short
 140 #endif
 141
 142 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
 143    <limits.h> and (if available) <stdint.h> are included
 144    so that the code can choose integer types of a good width.  */
 145
 146 #ifndef __PTRDIFF_MAX__
 147 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
 148 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
 149 #  include <stdint.h> /* INFRINGES ON USER NAME SPACE */
 150 #  define YY_STDINT_H
 151 # endif
 152 #endif
 153
 154 /* Narrow types that promote to a signed type and that can represent a
 155    signed or unsigned integer of at least N bits.  In tables they can
 156    save space and decrease cache pressure.  Promoting to a signed type
 157    helps avoid bugs in integer arithmetic.  */
 158
 159 #ifdef __INT_LEAST8_MAX__
 160 typedef __INT_LEAST8_TYPE__ yytype_int8;
 161 #elif defined YY_STDINT_H
 162 typedef int_least8_t yytype_int8;
 163 #else
 164 typedef signed char yytype_int8;
 165 #endif
 166
 167 #ifdef __INT_LEAST16_MAX__
 168 typedef __INT_LEAST16_TYPE__ yytype_int16;
 169 #elif defined YY_STDINT_H
 170 typedef int_least16_t yytype_int16;
 171 #else
 172 typedef short yytype_int16;
 173 #endif
 174
 175 /* Work around bug in HP-UX 11.23, which defines these macros
 176    incorrectly for preprocessor constants.  This workaround can likely
 177    be removed in 2023, as HPE has promised support for HP-UX 11.23
 178    (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
 179    <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>.  */
 180 #ifdef __hpux
 181 # undef UINT_LEAST8_MAX
 182 # undef UINT_LEAST16_MAX
 183 # define UINT_LEAST8_MAX 255
 184 # define UINT_LEAST16_MAX 65535
 185 #endif
 186
 187 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
 188 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
 189 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
 190        && UINT_LEAST8_MAX <= INT_MAX)
 191 typedef uint_least8_t yytype_uint8;
 192 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
 193 typedef unsigned char yytype_uint8;
 194 #else
 195 typedef short yytype_uint8;
 196 #endif
 197
 198 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
 199 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
 200 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
 201        && UINT_LEAST16_MAX <= INT_MAX)
 202 typedef uint_least16_t yytype_uint16;
 203 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
 204 typedef unsigned short yytype_uint16;
 205 #else
 206 typedef int yytype_uint16;
 207 #endif
 208
 209 #ifndef YYPTRDIFF_T
 210 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
 211 #  define YYPTRDIFF_T __PTRDIFF_TYPE__
 212 #  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
 213 # elif defined PTRDIFF_MAX
 214 #  ifndef ptrdiff_t
 215 #   include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 216 #  endif
 217 #  define YYPTRDIFF_T ptrdiff_t
 218 #  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
 219 # else
 220 #  define YYPTRDIFF_T long
 221 #  define YYPTRDIFF_MAXIMUM LONG_MAX
 222 # endif
 223 #endif
 224
 225 #ifndef YYSIZE_T
 226 # ifdef __SIZE_TYPE__
 227 #  define YYSIZE_T __SIZE_TYPE__
 228 # elif defined size_t
 229 #  define YYSIZE_T size_t
 230 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
 231 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 232 #  define YYSIZE_T size_t
 233 # else
 234 #  define YYSIZE_T unsigned
 235 # endif
 236 #endif
 237
 238 #define YYSIZE_MAXIMUM                                  \
 239   YY_CAST (YYPTRDIFF_T,                                 \
 240            (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
 241             ? YYPTRDIFF_MAXIMUM                         \
 242             : YY_CAST (YYSIZE_T, -1)))
 243
 244 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
 245
 246
 247 /* Stored state numbers (used for stacks). */
 248 typedef yytype_int8 yy_state_t;
 249
 250 /* State numbers in computations.  */
 251 typedef int yy_state_fast_t;
 252
 253 #ifndef YY_
 254 # if defined YYENABLE_NLS && YYENABLE_NLS
 255 #  if ENABLE_NLS
 256 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 257 #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
 258 #  endif
 259 # endif
 260 # ifndef YY_
 261 #  define YY_(Msgid) Msgid
 262 # endif
 263 #endif
 264
 265
 266 #ifndef YY_ATTRIBUTE_PURE
 267 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
 268 #  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
 269 # else
 270 #  define YY_ATTRIBUTE_PURE
 271 # endif
 272 #endif
 273
 274 #ifndef YY_ATTRIBUTE_UNUSED
 275 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
 276 #  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
 277 # else
 278 #  define YY_ATTRIBUTE_UNUSED
 279 # endif
 280 #endif
 281
 282 /* Suppress unused-variable warnings by "using" E.  */
 283 #if ! defined lint || defined __GNUC__
 284 # define YY_USE(E) ((void) (E))
 285 #else
 286 # define YY_USE(E) /* empty */
 287 #endif
 288
 289 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
 290 #if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
 291 # if __GNUC__ * 100 + __GNUC_MINOR__ < 407
 292 #  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
 293     _Pragma ("GCC diagnostic push")                                     \
 294     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
 295 # else
 296 #  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
 297     _Pragma ("GCC diagnostic push")                                     \
 298     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
 299     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
 300 # endif
 301 # define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
 302     _Pragma ("GCC diagnostic pop")
 303 #else
 304 # define YY_INITIAL_VALUE(Value) Value
 305 #endif
 306 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 307 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 308 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
 309 #endif
 310 #ifndef YY_INITIAL_VALUE
 311 # define YY_INITIAL_VALUE(Value) /* Nothing. */
 312 #endif
 313
 314 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
 315 # define YY_IGNORE_USELESS_CAST_BEGIN                          \
 316     _Pragma ("GCC diagnostic push")                            \
 317     _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
 318 # define YY_IGNORE_USELESS_CAST_END            \
 319     _Pragma ("GCC diagnostic pop")
 320 #endif
 321 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
 322 # define YY_IGNORE_USELESS_CAST_BEGIN
 323 # define YY_IGNORE_USELESS_CAST_END
 324 #endif
 325
 326
 327 #define YY_ASSERT(E) ((void) (0 && (E)))
 328
 329 #if !defined yyoverflow
 330
 331 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 332
 333 # ifdef YYSTACK_USE_ALLOCA
 334 #  if YYSTACK_USE_ALLOCA
 335 #   ifdef __GNUC__
 336 #    define YYSTACK_ALLOC __builtin_alloca
 337 #   elif defined __BUILTIN_VA_ARG_INCR
 338 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 339 #   elif defined _AIX
 340 #    define YYSTACK_ALLOC __alloca
 341 #   elif defined _MSC_VER
 342 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 343 #    define alloca _alloca
 344 #   else
 345 #    define YYSTACK_ALLOC alloca
 346 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
 347 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 348       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
 349 #     ifndef EXIT_SUCCESS
 350 #      define EXIT_SUCCESS 0
 351 #     endif
 352 #    endif
 353 #   endif
 354 #  endif
 355 # endif
 356
 357 # ifdef YYSTACK_ALLOC
 358    /* Pacify GCC's 'empty if-body' warning.  */
 359 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 360 #  ifndef YYSTACK_ALLOC_MAXIMUM
 361     /* The OS might guarantee only one guard page at the bottom of the stack,
 362        and a page size can be as small as 4096 bytes.  So we cannot safely
 363        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 364        to allow for a few compiler-allocated temporary stack slots.  */
 365 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 366 #  endif
 367 # else
 368 #  define YYSTACK_ALLOC YYMALLOC
 369 #  define YYSTACK_FREE YYFREE
 370 #  ifndef YYSTACK_ALLOC_MAXIMUM
 371 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 372 #  endif
 373 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
 374        && ! ((defined YYMALLOC || defined malloc) \
 375              && (defined YYFREE || defined free)))
 376 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 377 #   ifndef EXIT_SUCCESS
 378 #    define EXIT_SUCCESS 0
 379 #   endif
 380 #  endif
 381 #  ifndef YYMALLOC
 382 #   define YYMALLOC malloc
 383 #   if ! defined malloc && ! defined EXIT_SUCCESS
 384 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 385 #   endif
 386 #  endif
 387 #  ifndef YYFREE
 388 #   define YYFREE free
 389 #   if ! defined free && ! defined EXIT_SUCCESS
 390 void free (void *); /* INFRINGES ON USER NAME SPACE */
 391 #   endif
 392 #  endif
 393 # endif
 394 #endif /* !defined yyoverflow */
 395
 396 #if (! defined yyoverflow \
 397      && (! defined __cplusplus \
 398          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 399
 400 /* A type that is properly aligned for any stack member.  */
 401 union yyalloc
 402 {
 403   yy_state_t yyss_alloc;
 404   YYSTYPE yyvs_alloc;
 405 };
 406
 407 /* The size of the maximum gap between one aligned stack and the next.  */
 408 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
 409
 410 /* The size of an array large to enough to hold all stacks, each with
 411    N elements.  */
 412 # define YYSTACK_BYTES(N) \
 413      ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
 414       + YYSTACK_GAP_MAXIMUM)
 415
 416 # define YYCOPY_NEEDED 1
 417
 418 /* Relocate STACK from its old location to the new one.  The
 419    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 420    elements in the stack, and YYPTR gives the new location of the
 421    stack.  Advance YYPTR to a properly aligned location for the next
 422    stack.  */
 423 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
 424     do                                                                  \
 425       {                                                                 \
 426         YYPTRDIFF_T yynewbytes;                                         \
 427         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
 428         Stack = &yyptr->Stack_alloc;                                    \
 429         yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
 430         yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
 431       }                                                                 \
 432     while (0)
 433
 434 #endif
 435
 436 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
 437 /* Copy COUNT objects from SRC to DST.  The source and destination do
 438    not overlap.  */
 439 # ifndef YYCOPY
 440 #  if defined __GNUC__ && 1 < __GNUC__
 441 #   define YYCOPY(Dst, Src, Count) \
 442       __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
 443 #  else
 444 #   define YYCOPY(Dst, Src, Count)              \
 445       do                                        \
 446         {                                       \
 447           YYPTRDIFF_T yyi;                      \
 448           for (yyi = 0; yyi < (Count); yyi++)   \
 449             (Dst)[yyi] = (Src)[yyi];            \
 450         }                                       \
 451       while (0)
 452 #  endif
 453 # endif
 454 #endif /* !YYCOPY_NEEDED */
 455
 456 /* YYFINAL -- State number of the termination state.  */
 457 #define YYFINAL  4
 458 /* YYLAST -- Last index in YYTABLE.  */
 459 #define YYLAST   23
 460
 461 /* YYNTOKENS -- Number of terminals.  */
 462 #define YYNTOKENS  13
 463 /* YYNNTS -- Number of nonterminals.  */
 464 #define YYNNTS  14
 465 /* YYNRULES -- Number of rules.  */
 466 #define YYNRULES  21
 467 /* YYNSTATES -- Number of states.  */
 468 #define YYNSTATES  31
 469
 470 /* YYMAXUTOK -- Last valid token kind.  */
 471 #define YYMAXUTOK   262
 472
 473
 474 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
 475    as returned by yylex, with out-of-bounds checking.  */
 476 #define YYTRANSLATE(YYX)                                \
 477   (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
 478    ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
 479    : YYSYMBOL_YYUNDEF)
 480
 481 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
 482    as returned by yylex.  */
 483 static const yytype_int8 yytranslate[] =
 484 {
 485        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 486        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 487        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 488        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 489        8,     9,     2,     2,     2,     2,     2,     2,     2,     2,
 490        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 491        2,     2,     2,     2,    10,     2,     2,     2,     2,     2,
 492        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 493        2,     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,    11,     2,    12,     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,     1,     2,     3,     4,
 511        5,     6,     7
 512 };
 513
 514 #if YYDEBUG
 515 /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 516 static const yytype_int8 yyrline[] =
 517 {
 518        0,    68,    68,    74,    88,    95,    96,    97,    97,    98,
 519       99,   100,   101,   102,   103,   104,   105,   107,   111,   112,
 520      113,   124
 521 };
 522 #endif
 523
 524 /** Accessing symbol of state STATE.  */
 525 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
 526
 527 #if YYDEBUG || 0
 528 /* The user-facing name of the symbol whose (internal) number is
 529    YYSYMBOL.  No bounds checking.  */
 530 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
 531
 532 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 533    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 534 static const char *const yytname[] =
 535 {
 536   "\"end of file\"", "error", "\"invalid token\"", "INTEGER", "OCTAL",
 537   "STRING", "FLAG_CBFS", "FLAG_PRESERVE", "'('", "')'", "'@'", "'{'",
 538   "'}'", "$accept", "flash_chip", "flash_region", "region_name",
 539   "region_flags_opt", "region_flags", "region_flag", "region_offset_opt",
 540   "region_offset", "region_size_opt", "region_size", "region_list_opt",
 541   "region_list", "region_list_entries", YY_NULLPTR
 542 };
 543
 544 static const char *
 545 yysymbol_name (yysymbol_kind_t yysymbol)
 546 {
 547   return yytname[yysymbol];
 548 }
 549 #endif
 550
 551 #define YYPACT_NINF (-12)
 552
 553 #define yypact_value_is_default(Yyn) \
 554   ((Yyn) == YYPACT_NINF)
 555
 556 #define YYTABLE_NINF (-1)
 557
 558 #define yytable_value_is_error(Yyn) \
 559   0
 560
 561 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 562    STATE-NUM.  */
 563 static const yytype_int8 yypact[] =
 564 {
 565       -1,   -12,     1,    -2,   -12,     2,     3,   -12,   -12,   -12,
 566        0,    -1,   -12,   -12,     4,    -5,    -4,    -2,   -12,   -12,
 567      -12,   -12,     5,    -4,     3,   -12,   -12,     0,   -12,   -12,
 568      -12
 569 };
 570
 571 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
 572    Performed when YYTABLE does not specify something else to do.  Zero
 573    means the default is an error.  */
 574 static const yytype_int8 yydefact[] =
 575 {
 576        0,     4,     0,    11,     1,     0,     0,    12,    13,    16,
 577        0,     0,     2,    20,     5,     0,     0,    11,    19,    21,
 578        9,    10,     0,     7,    14,     6,     8,    17,    15,     3,
 579       18
 580 };
 581
 582 /* YYPGOTO[NTERM-NUM].  */
 583 static const yytype_int8 yypgoto[] =
 584 {
 585      -12,   -12,    -6,    10,   -12,   -10,   -12,     6,   -12,   -12,
 586       -9,   -12,   -11,   -12
 587 };
 588
 589 /* YYDEFGOTO[NTERM-NUM].  */
 590 static const yytype_int8 yydefgoto[] =
 591 {
 592        0,     2,    13,    14,    17,    22,    23,     6,     7,    27,
 593       10,    29,    12,    15
 594 };
 595
 596 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
 597    positive, shift that token.  If negative, reduce the rule whose
 598    number is the opposite.  If YYTABLE_NINF, syntax error.  */
 599 static const yytype_int8 yytable[] =
 600 {
 601        1,     4,    20,    21,     1,     8,     9,    18,     5,    19,
 602        3,    11,    16,    26,    25,    28,    30,     0,     0,     0,
 603        0,     0,     0,    24
 604 };
 605
 606 static const yytype_int8 yycheck[] =
 607 {
 608        5,     0,     6,     7,     5,     3,     3,    12,    10,    15,
 609        0,    11,     8,    23,     9,    24,    27,    -1,    -1,    -1,
 610       -1,    -1,    -1,    17
 611 };
 612
 613 /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
 614    state STATE-NUM.  */
 615 static const yytype_int8 yystos[] =
 616 {
 617        0,     5,    14,    16,     0,    10,    20,    21,     3,     3,
 618       23,    11,    25,    15,    16,    26,     8,    17,    12,    15,
 619        6,     7,    18,    19,    20,     9,    18,    22,    23,    24,
 620       25
 621 };
 622
 623 /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.  */
 624 static const yytype_int8 yyr1[] =
 625 {
 626        0,    13,    14,    15,    16,    17,    17,    18,    18,    19,
 627       19,    20,    20,    21,    22,    22,    23,    24,    24,    25,
 628       26,    26
 629 };
 630
 631 /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.  */
 632 static const yytype_int8 yyr2[] =
 633 {
 634        0,     2,     4,     5,     1,     0,     3,     1,     2,     1,
 635        1,     0,     1,     2,     0,     1,     1,     0,     1,     3,
 636        1,     2
 637 };
 638
 639
 640 enum { YYENOMEM = -2 };
 641
 642 #define yyerrok         (yyerrstatus = 0)
 643 #define yyclearin       (yychar = YYEMPTY)
 644
 645 #define YYACCEPT        goto yyacceptlab
 646 #define YYABORT         goto yyabortlab
 647 #define YYERROR         goto yyerrorlab
 648 #define YYNOMEM         goto yyexhaustedlab
 649
 650
 651 #define YYRECOVERING()  (!!yyerrstatus)
 652
 653 #define YYBACKUP(Token, Value)                                    \
 654   do                                                              \
 655     if (yychar == YYEMPTY)                                        \
 656       {                                                           \
 657         yychar = (Token);                                         \
 658         yylval = (Value);                                         \
 659         YYPOPSTACK (yylen);                                       \
 660         yystate = *yyssp;                                         \
 661         goto yybackup;                                            \
 662       }                                                           \
 663     else                                                          \
 664       {                                                           \
 665         yyerror (YY_("syntax error: cannot back up")); \
 666         YYERROR;                                                  \
 667       }                                                           \
 668   while (0)
 669
 670 /* Backward compatibility with an undocumented macro.
 671    Use YYerror or YYUNDEF. */
 672 #define YYERRCODE YYUNDEF
 673
 674
 675 /* Enable debugging if requested.  */
 676 #if YYDEBUG
 677
 678 # ifndef YYFPRINTF
 679 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 680 #  define YYFPRINTF fprintf
 681 # endif
 682
 683 # define YYDPRINTF(Args)                        \
 684 do {                                            \
 685   if (yydebug)                                  \
 686     YYFPRINTF Args;                             \
 687 } while (0)
 688
 689
 690
 691
 692 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)                    \
 693 do {                                                                      \
 694   if (yydebug)                                                            \
 695     {                                                                     \
 696       YYFPRINTF (stderr, "%s ", Title);                                   \
 697       yy_symbol_print (stderr,                                            \
 698                   Kind, Value); \
 699       YYFPRINTF (stderr, "\n");                                           \
 700     }                                                                     \
 701 } while (0)
 702
 703
 704 /*-----------------------------------.
 705 | Print this symbol's value on YYO.  |
 706 `-----------------------------------*/
 707
 708 static void
 709 yy_symbol_value_print (FILE *yyo,
 710                        yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
 711 {
 712   FILE *yyoutput = yyo;
 713   YY_USE (yyoutput);
 714   if (!yyvaluep)
 715     return;
 716   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 717   YY_USE (yykind);
 718   YY_IGNORE_MAYBE_UNINITIALIZED_END
 719 }
 720
 721
 722 /*---------------------------.
 723 | Print this symbol on YYO.  |
 724 `---------------------------*/
 725
 726 static void
 727 yy_symbol_print (FILE *yyo,
 728                  yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
 729 {
 730   YYFPRINTF (yyo, "%s %s (",
 731              yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
 732
 733   yy_symbol_value_print (yyo, yykind, yyvaluep);
 734   YYFPRINTF (yyo, ")");
 735 }
 736
 737 /*------------------------------------------------------------------.
 738 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 739 | TOP (included).                                                   |
 740 `------------------------------------------------------------------*/
 741
 742 static void
 743 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
 744 {
 745   YYFPRINTF (stderr, "Stack now");
 746   for (; yybottom <= yytop; yybottom++)
 747     {
 748       int yybot = *yybottom;
 749       YYFPRINTF (stderr, " %d", yybot);
 750     }
 751   YYFPRINTF (stderr, "\n");
 752 }
 753
 754 # define YY_STACK_PRINT(Bottom, Top)                            \
 755 do {                                                            \
 756   if (yydebug)                                                  \
 757     yy_stack_print ((Bottom), (Top));                           \
 758 } while (0)
 759
 760
 761 /*------------------------------------------------.
 762 | Report that the YYRULE is going to be reduced.  |
 763 `------------------------------------------------*/
 764
 765 static void
 766 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
 767                  int yyrule)
 768 {
 769   int yylno = yyrline[yyrule];
 770   int yynrhs = yyr2[yyrule];
 771   int yyi;
 772   YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
 773              yyrule - 1, yylno);
 774   /* The symbols being reduced.  */
 775   for (yyi = 0; yyi < yynrhs; yyi++)
 776     {
 777       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
 778       yy_symbol_print (stderr,
 779                        YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
 780                        &yyvsp[(yyi + 1) - (yynrhs)]);
 781       YYFPRINTF (stderr, "\n");
 782     }
 783 }
 784
 785 # define YY_REDUCE_PRINT(Rule)          \
 786 do {                                    \
 787   if (yydebug)                          \
 788     yy_reduce_print (yyssp, yyvsp, Rule); \
 789 } while (0)
 790
 791 /* Nonzero means print parse trace.  It is left uninitialized so that
 792    multiple parsers can coexist.  */
 793 int yydebug;
 794 #else /* !YYDEBUG */
 795 # define YYDPRINTF(Args) ((void) 0)
 796 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
 797 # define YY_STACK_PRINT(Bottom, Top)
 798 # define YY_REDUCE_PRINT(Rule)
 799 #endif /* !YYDEBUG */
 800
 801
 802 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 803 #ifndef YYINITDEPTH
 804 # define YYINITDEPTH 200
 805 #endif
 806
 807 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 808    if the built-in stack extension method is used).
 809
 810    Do not make this value too large; the results are undefined if
 811    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
 812    evaluated with infinite-precision integer arithmetic.  */
 813
 814 #ifndef YYMAXDEPTH
 815 # define YYMAXDEPTH 10000
 816 #endif
 817
 818
 819
 820
 821
 822
 823 /*-----------------------------------------------.
 824 | Release the memory associated to this symbol.  |
 825 `-----------------------------------------------*/
 826
 827 static void
 828 yydestruct (const char *yymsg,
 829             yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
 830 {
 831   YY_USE (yyvaluep);
 832   if (!yymsg)
 833     yymsg = "Deleting";
 834   YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
 835
 836   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 837   YY_USE (yykind);
 838   YY_IGNORE_MAYBE_UNINITIALIZED_END
 839 }
 840
 841
 842 /* Lookahead token kind.  */
 843 int yychar;
 844
 845 /* The semantic value of the lookahead symbol.  */
 846 YYSTYPE yylval;
 847 /* Number of syntax errors so far.  */
 848 int yynerrs;
 849
 850
 851
 852
 853 /*----------.
 854 | yyparse.  |
 855 `----------*/
 856
 857 int
 858 yyparse (void)
 859 {
 860     yy_state_fast_t yystate = 0;
 861     /* Number of tokens to shift before error messages enabled.  */
 862     int yyerrstatus = 0;
 863
 864     /* Refer to the stacks through separate pointers, to allow yyoverflow
 865        to reallocate them elsewhere.  */
 866
 867     /* Their size.  */
 868     YYPTRDIFF_T yystacksize = YYINITDEPTH;
 869
 870     /* The state stack: array, bottom, top.  */
 871     yy_state_t yyssa[YYINITDEPTH];
 872     yy_state_t *yyss = yyssa;
 873     yy_state_t *yyssp = yyss;
 874
 875     /* The semantic value stack: array, bottom, top.  */
 876     YYSTYPE yyvsa[YYINITDEPTH];
 877     YYSTYPE *yyvs = yyvsa;
 878     YYSTYPE *yyvsp = yyvs;
 879
 880   int yyn;
 881   /* The return value of yyparse.  */
 882   int yyresult;
 883   /* Lookahead symbol kind.  */
 884   yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
 885   /* The variables used to return semantic value and location from the
 886      action routines.  */
 887   YYSTYPE yyval;
 888
 889
 890
 891 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 892
 893   /* The number of symbols on the RHS of the reduced rule.
 894      Keep to zero when no symbol should be popped.  */
 895   int yylen = 0;
 896
 897   YYDPRINTF ((stderr, "Starting parse\n"));
 898
 899   yychar = YYEMPTY; /* Cause a token to be read.  */
 900
 901   goto yysetstate;
 902
 903
 904 /*------------------------------------------------------------.
 905 | yynewstate -- push a new state, which is found in yystate.  |
 906 `------------------------------------------------------------*/
 907 yynewstate:
 908   /* In all cases, when you get here, the value and location stacks
 909      have just been pushed.  So pushing a state here evens the stacks.  */
 910   yyssp++;
 911
 912
 913 /*--------------------------------------------------------------------.
 914 | yysetstate -- set current state (the top of the stack) to yystate.  |
 915 `--------------------------------------------------------------------*/
 916 yysetstate:
 917   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 918   YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
 919   YY_IGNORE_USELESS_CAST_BEGIN
 920   *yyssp = YY_CAST (yy_state_t, yystate);
 921   YY_IGNORE_USELESS_CAST_END
 922   YY_STACK_PRINT (yyss, yyssp);
 923
 924   if (yyss + yystacksize - 1 <= yyssp)
 925 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
 926     YYNOMEM;
 927 #else
 928     {
 929       /* Get the current used size of the three stacks, in elements.  */
 930       YYPTRDIFF_T yysize = yyssp - yyss + 1;
 931
 932 # if defined yyoverflow
 933       {
 934         /* Give user a chance to reallocate the stack.  Use copies of
 935            these so that the &'s don't force the real ones into
 936            memory.  */
 937         yy_state_t *yyss1 = yyss;
 938         YYSTYPE *yyvs1 = yyvs;
 939
 940         /* Each stack pointer address is followed by the size of the
 941            data in use in that stack, in bytes.  This used to be a
 942            conditional around just the two extra args, but that might
 943            be undefined if yyoverflow is a macro.  */
 944         yyoverflow (YY_("memory exhausted"),
 945                     &yyss1, yysize * YYSIZEOF (*yyssp),
 946                     &yyvs1, yysize * YYSIZEOF (*yyvsp),
 947                     &yystacksize);
 948         yyss = yyss1;
 949         yyvs = yyvs1;
 950       }
 951 # else /* defined YYSTACK_RELOCATE */
 952       /* Extend the stack our own way.  */
 953       if (YYMAXDEPTH <= yystacksize)
 954         YYNOMEM;
 955       yystacksize *= 2;
 956       if (YYMAXDEPTH < yystacksize)
 957         yystacksize = YYMAXDEPTH;
 958
 959       {
 960         yy_state_t *yyss1 = yyss;
 961         union yyalloc *yyptr =
 962           YY_CAST (union yyalloc *,
 963                    YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
 964         if (! yyptr)
 965           YYNOMEM;
 966         YYSTACK_RELOCATE (yyss_alloc, yyss);
 967         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
 968 #  undef YYSTACK_RELOCATE
 969         if (yyss1 != yyssa)
 970           YYSTACK_FREE (yyss1);
 971       }
 972 # endif
 973
 974       yyssp = yyss + yysize - 1;
 975       yyvsp = yyvs + yysize - 1;
 976
 977       YY_IGNORE_USELESS_CAST_BEGIN
 978       YYDPRINTF ((stderr, "Stack size increased to %ld\n",
 979                   YY_CAST (long, yystacksize)));
 980       YY_IGNORE_USELESS_CAST_END
 981
 982       if (yyss + yystacksize - 1 <= yyssp)
 983         YYABORT;
 984     }
 985 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
 986
 987
 988   if (yystate == YYFINAL)
 989     YYACCEPT;
 990
 991   goto yybackup;
 992
 993
 994 /*-----------.
 995 | yybackup.  |
 996 `-----------*/
 997 yybackup:
 998   /* Do appropriate processing given the current state.  Read a
 999      lookahead token if we need one and don't already have one.  */
1000
1001   /* First try to decide what to do without reference to lookahead token.  */
1002   yyn = yypact[yystate];
1003   if (yypact_value_is_default (yyn))
1004     goto yydefault;
1005
1006   /* Not known => get a lookahead token if don't already have one.  */
1007
1008   /* YYCHAR is either empty, or end-of-input, or a valid lookahead.  */
1009   if (yychar == YYEMPTY)
1010     {
1011       YYDPRINTF ((stderr, "Reading a token\n"));
1012       yychar = yylex ();
1013     }
1014
1015   if (yychar <= YYEOF)
1016     {
1017       yychar = YYEOF;
1018       yytoken = YYSYMBOL_YYEOF;
1019       YYDPRINTF ((stderr, "Now at end of input.\n"));
1020     }
1021   else if (yychar == YYerror)
1022     {
1023       /* The scanner already issued an error message, process directly
1024          to error recovery.  But do not keep the error token as
1025          lookahead, it is too special and may lead us to an endless
1026          loop in error recovery. */
1027       yychar = YYUNDEF;
1028       yytoken = YYSYMBOL_YYerror;
1029       goto yyerrlab1;
1030     }
1031   else
1032     {
1033       yytoken = YYTRANSLATE (yychar);
1034       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1035     }
1036
1037   /* If the proper action on seeing token YYTOKEN is to reduce or to
1038      detect an error, take that action.  */
1039   yyn += yytoken;
1040   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1041     goto yydefault;
1042   yyn = yytable[yyn];
1043   if (yyn <= 0)
1044     {
1045       if (yytable_value_is_error (yyn))
1046         goto yyerrlab;
1047       yyn = -yyn;
1048       goto yyreduce;
1049     }
1050
1051   /* Count tokens shifted since error; after three, turn off error
1052      status.  */
1053   if (yyerrstatus)
1054     yyerrstatus--;
1055
1056   /* Shift the lookahead token.  */
1057   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1058   yystate = yyn;
1059   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1060   *++yyvsp = yylval;
1061   YY_IGNORE_MAYBE_UNINITIALIZED_END
1062
1063   /* Discard the shifted token.  */
1064   yychar = YYEMPTY;
1065   goto yynewstate;
1066
1067
1068 /*-----------------------------------------------------------.
1069 | yydefault -- do the default action for the current state.  |
1070 `-----------------------------------------------------------*/
1071 yydefault:
1072   yyn = yydefact[yystate];
1073   if (yyn == 0)
1074     goto yyerrlab;
1075   goto yyreduce;
1076
1077
1078 /*-----------------------------.
1079 | yyreduce -- do a reduction.  |
1080 `-----------------------------*/
1081 yyreduce:
1082   /* yyn is the number of a rule to reduce with.  */
1083   yylen = yyr2[yyn];
1084
1085   /* If YYLEN is nonzero, implement the default value of the action:
1086      '$$ = $1'.
1087
1088      Otherwise, the following line sets YYVAL to garbage.
1089      This behavior is undocumented and Bison
1090      users should not rely upon it.  Assigning to YYVAL
1091      unconditionally makes the parser a bit smaller, and it avoids a
1092      GCC warning that YYVAL may be used uninitialized.  */
1093   yyval = yyvsp[1-yylen];
1094
1095
1096   YY_REDUCE_PRINT (yyn);
1097   switch (yyn)
1098     {
1099   case 2: /* flash_chip: region_name region_offset_opt region_size region_list  */
1100 {
1101         union flashmap_flags flags = { .v=0 };
1102         if (!(res = parse_descriptor((yyvsp[-3].strval), flags, (yyvsp[-2].maybe_intval), (yyvsp[-1].maybe_intval), (yyvsp[0].region_listhdr))))
1103                 YYABORT;
1104 }
1105     break;
1106
1107   case 3: /* flash_region: region_name region_flags_opt region_offset_opt region_size_opt region_list_opt  */
1108 {
1109         struct flashmap_descriptor *node = parse_descriptor((yyvsp[-4].strval), (yyvsp[-3].flags), (yyvsp[-2].maybe_intval), (yyvsp[-1].maybe_intval), (yyvsp[0].region_listhdr));
1110         if (!node)
1111                 YYABORT;
1112
1113         if (node->flags.f.cbfs && !fmd_process_flag_cbfs(node)) {
1114                 ERROR("Section '%s' cannot have flag 'CBFS''\n", node->name);
1115                 YYABORT;
1116         }
1117
1118         (yyval.region_ptr) = node;
1119 }
1120     break;
1121
1122   case 4: /* region_name: STRING  */
1123 {
1124         if (!(yyvsp[0].strval)) {
1125                 perror("E: While allocating section name");
1126                 YYABORT;
1127         }
1128 }
1129     break;
1130
1131   case 5: /* region_flags_opt: %empty  */
1132                   { (yyval.flags) = (union flashmap_flags){ .v=0 }; }
1133     break;
1134
1135   case 6: /* region_flags_opt: '(' region_flags ')'  */
1136                                { (yyval.flags) = (yyvsp[-1].flags); }
1137     break;
1138
1139   case 8: /* region_flags: region_flag region_flags  */
1140                                                      { (yyval.flags).v = (yyvsp[-1].flags).v | (yyvsp[0].flags).v; }
1141     break;
1142
1143   case 9: /* region_flag: FLAG_CBFS  */
1144                        { (yyval.flags).v = 0; (yyval.flags).f.cbfs = 1; }
1145     break;
1146
1147   case 10: /* region_flag: FLAG_PRESERVE  */
1148                            { (yyval.flags).v = 0; (yyval.flags).f.preserve = 1; }
1149     break;
1150
1151   case 11: /* region_offset_opt: %empty  */
1152                    { (yyval.maybe_intval) = (struct unsigned_option){false, 0}; }
1153     break;
1154
1155   case 13: /* region_offset: '@' INTEGER  */
1156                            { (yyval.maybe_intval) = (struct unsigned_option){true, (yyvsp[0].intval)}; }
1157     break;
1158
1159   case 14: /* region_size_opt: %empty  */
1160                  { (yyval.maybe_intval) = (struct unsigned_option){false, 0}; }
1161     break;
1162
1163   case 16: /* region_size: INTEGER  */
1164                      { (yyval.maybe_intval) = (struct unsigned_option){true, (yyvsp[0].intval)}; }
1165     break;
1166
1167   case 17: /* region_list_opt: %empty  */
1168 {
1169         (yyval.region_listhdr) = (struct descriptor_list)
1170                                         {.len = 0, .head = NULL, .tail = NULL};
1171 }
1172     break;
1173
1174   case 19: /* region_list: '{' region_list_entries '}'  */
1175                                          { (yyval.region_listhdr) = (yyvsp[-1].region_listhdr); }
1176     break;
1177
1178   case 20: /* region_list_entries: flash_region  */
1179 {
1180         struct descriptor_node *node = malloc(sizeof(*node));
1181         if (!node) {
1182                 perror("E: While allocating linked list node");
1183                 YYABORT;
1184         }
1185         node->val = (yyvsp[0].region_ptr);
1186         node->next = NULL;
1187         (yyval.region_listhdr) = (struct descriptor_list){.len = 1, .head = node, .tail = node};
1188 }
1189     break;
1190
1191   case 21: /* region_list_entries: region_list_entries flash_region  */
1192 {
1193         struct descriptor_node *node = malloc(sizeof(*node));
1194         if (!node) {
1195                 perror("E: While allocating linked list node");
1196                 YYABORT;
1197         }
1198         node->val = (yyvsp[0].region_ptr);
1199         node->next = NULL;
1200
1201         (yyvsp[-1].region_listhdr).tail->next = node;
1202         (yyval.region_listhdr) = (struct descriptor_list)
1203                         {.len = (yyvsp[-1].region_listhdr).len + 1, .head = (yyvsp[-1].region_listhdr).head, .tail = node};
1204 }
1205     break;
1206
1207
1208
1209       default: break;
1210     }
1211   /* User semantic actions sometimes alter yychar, and that requires
1212      that yytoken be updated with the new translation.  We take the
1213      approach of translating immediately before every use of yytoken.
1214      One alternative is translating here after every semantic action,
1215      but that translation would be missed if the semantic action invokes
1216      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1217      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
1218      incorrect destructor might then be invoked immediately.  In the
1219      case of YYERROR or YYBACKUP, subsequent parser actions might lead
1220      to an incorrect destructor call or verbose syntax error message
1221      before the lookahead is translated.  */
1222   YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
1223
1224   YYPOPSTACK (yylen);
1225   yylen = 0;
1226
1227   *++yyvsp = yyval;
1228
1229   /* Now 'shift' the result of the reduction.  Determine what state
1230      that goes to, based on the state we popped back to and the rule
1231      number reduced by.  */
1232   {
1233     const int yylhs = yyr1[yyn] - YYNTOKENS;
1234     const int yyi = yypgoto[yylhs] + *yyssp;
1235     yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1236                ? yytable[yyi]
1237                : yydefgoto[yylhs]);
1238   }
1239
1240   goto yynewstate;
1241
1242
1243 /*--------------------------------------.
1244 | yyerrlab -- here on detecting error.  |
1245 `--------------------------------------*/
1246 yyerrlab:
1247   /* Make sure we have latest lookahead translation.  See comments at
1248      user semantic actions for why this is necessary.  */
1249   yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
1250   /* If not already recovering from an error, report this error.  */
1251   if (!yyerrstatus)
1252     {
1253       ++yynerrs;
1254       yyerror (YY_("syntax error"));
1255     }
1256
1257   if (yyerrstatus == 3)
1258     {
1259       /* If just tried and failed to reuse lookahead token after an
1260          error, discard it.  */
1261
1262       if (yychar <= YYEOF)
1263         {
1264           /* Return failure if at end of input.  */
1265           if (yychar == YYEOF)
1266             YYABORT;
1267         }
1268       else
1269         {
1270           yydestruct ("Error: discarding",
1271                       yytoken, &yylval);
1272           yychar = YYEMPTY;
1273         }
1274     }
1275
1276   /* Else will try to reuse lookahead token after shifting the error
1277      token.  */
1278   goto yyerrlab1;
1279
1280
1281 /*---------------------------------------------------.
1282 | yyerrorlab -- error raised explicitly by YYERROR.  |
1283 `---------------------------------------------------*/
1284 yyerrorlab:
1285   /* Pacify compilers when the user code never invokes YYERROR and the
1286      label yyerrorlab therefore never appears in user code.  */
1287   if (0)
1288     YYERROR;
1289   ++yynerrs;
1290
1291   /* Do not reclaim the symbols of the rule whose action triggered
1292      this YYERROR.  */
1293   YYPOPSTACK (yylen);
1294   yylen = 0;
1295   YY_STACK_PRINT (yyss, yyssp);
1296   yystate = *yyssp;
1297   goto yyerrlab1;
1298
1299
1300 /*-------------------------------------------------------------.
1301 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
1302 `-------------------------------------------------------------*/
1303 yyerrlab1:
1304   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1305
1306   /* Pop stack until we find a state that shifts the error token.  */
1307   for (;;)
1308     {
1309       yyn = yypact[yystate];
1310       if (!yypact_value_is_default (yyn))
1311         {
1312           yyn += YYSYMBOL_YYerror;
1313           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
1314             {
1315               yyn = yytable[yyn];
1316               if (0 < yyn)
1317                 break;
1318             }
1319         }
1320
1321       /* Pop the current state because it cannot handle the error token.  */
1322       if (yyssp == yyss)
1323         YYABORT;
1324
1325
1326       yydestruct ("Error: popping",
1327                   YY_ACCESSING_SYMBOL (yystate), yyvsp);
1328       YYPOPSTACK (1);
1329       yystate = *yyssp;
1330       YY_STACK_PRINT (yyss, yyssp);
1331     }
1332
1333   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1334   *++yyvsp = yylval;
1335   YY_IGNORE_MAYBE_UNINITIALIZED_END
1336
1337
1338   /* Shift the error token.  */
1339   YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
1340
1341   yystate = yyn;
1342   goto yynewstate;
1343
1344
1345 /*-------------------------------------.
1346 | yyacceptlab -- YYACCEPT comes here.  |
1347 `-------------------------------------*/
1348 yyacceptlab:
1349   yyresult = 0;
1350   goto yyreturnlab;
1351
1352
1353 /*-----------------------------------.
1354 | yyabortlab -- YYABORT comes here.  |
1355 `-----------------------------------*/
1356 yyabortlab:
1357   yyresult = 1;
1358   goto yyreturnlab;
1359
1360
1361 /*-----------------------------------------------------------.
1362 | yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here.  |
1363 `-----------------------------------------------------------*/
1364 yyexhaustedlab:
1365   yyerror (YY_("memory exhausted"));
1366   yyresult = 2;
1367   goto yyreturnlab;
1368
1369
1370 /*----------------------------------------------------------.
1371 | yyreturnlab -- parsing is finished, clean up and return.  |
1372 `----------------------------------------------------------*/
1373 yyreturnlab:
1374   if (yychar != YYEMPTY)
1375     {
1376       /* Make sure we have latest lookahead translation.  See comments at
1377          user semantic actions for why this is necessary.  */
1378       yytoken = YYTRANSLATE (yychar);
1379       yydestruct ("Cleanup: discarding lookahead",
1380                   yytoken, &yylval);
1381     }
1382   /* Do not reclaim the symbols of the rule whose action triggered
1383      this YYABORT or YYACCEPT.  */
1384   YYPOPSTACK (yylen);
1385   YY_STACK_PRINT (yyss, yyssp);
1386   while (yyssp != yyss)
1387     {
1388       yydestruct ("Cleanup: popping",
1389                   YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
1390       YYPOPSTACK (1);
1391     }
1392 #ifndef yyoverflow
1393   if (yyss != yyssa)
1394     YYSTACK_FREE (yyss);
1395 #endif
1396
1397   return yyresult;
1398 }
1399
1400
1401
1402 struct flashmap_descriptor *parse_descriptor(
1403         char *name, union flashmap_flags flags, struct unsigned_option offset,
1404         struct unsigned_option size, struct descriptor_list children)
1405 {
1406         struct flashmap_descriptor *region = malloc(sizeof(*region));
1407         if (!region) {
1408                 perror("E: While allocating descriptor section");
1409                 return NULL;
1410         }
1411         region->name = name;
1412         region->flags = flags;
1413         region->offset_known = offset.val_known;
1414         region->offset = offset.val;
1415         region->size_known = size.val_known;
1416         region->size = size.val;
1417         region->list_len = children.len;
1418         if (region->list_len) {
1419                 region->list = malloc(region->list_len * sizeof(*region->list));
1420                 if (!region->list) {
1421                         perror("E: While allocating node children array");
1422                         return NULL;
1423                 }
1424                 struct descriptor_node *cur_node = children.head;
1425                 for (unsigned idx = 0; idx < region->list_len; ++idx) {
1426                         region->list[idx] = cur_node->val;
1427
1428                         struct descriptor_node *next_node = cur_node->next;
1429                         free(cur_node);
1430                         cur_node = next_node;
1431                 }
1432         } else {
1433                 region->list = NULL;
1434         }
1435         return region;
1436 }
1437
1438 void yyerror(const char *s)
1439 {
1440         fprintf(stderr, "%s\n", s);
1441 }