data/bison.simple

   1 m4_divert(-1)                                                       -*- C -*-
   2
   3 # b4_sint_type(MAX)
   4 # -----------------
   5 # Return the smallest signed int type able to handle the number MAX.
   6 m4_define([b4_sint_type],
   7 [m4_if(m4_eval([$1 <= 127]),        [1], [signed char],
   8        m4_eval([$1 <= 32767]),      [1], [signed short],
   9        [signed int])])
  10
  11
  12 # b4_uint_type(MAX)
  13 # -----------------
  14 # Return the smallest unsigned int type able to handle the number MAX.
  15 m4_define([b4_uint_type],
  16 [m4_if(m4_eval([$1 <= 255]),        [1], [unsigned char],
  17        m4_eval([$1 <= 65535]),      [1], [unsigned short],
  18        [unsigned int])])
  19
  20
  21 # b4_lhs_value([TYPE])
  22 # --------------------
  23 # Expansion of $<TYPE>$.
  24 m4_define([b4_lhs_value],
  25 [yyval[]m4_ifval([$1], [.$1])])
  26
  27
  28 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
  29 # --------------------------------------
  30 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
  31 # symbols on RHS.
  32 m4_define([b4_rhs_value],
  33 [yyvsp@<:@m4_eval([$2 - $1])@:>@m4_ifval([$3], [.$3])])
  34
  35
  36
  37 ## ----------- ##
  38 ## Locations.  ##
  39 ## ----------- ##
  40
  41 # b4_location_if(IF-TRUE, IF-FALSE)
  42 # ---------------------------------
  43 # Expand IF-TRUE, if locations are used, IF-FALSE otherwise.
  44 m4_define([b4_location_if],
  45 [m4_if(b4_locations_flag, [1],
  46        [$1],
  47        [$2])])
  48
  49
  50 # b4_lhs_location()
  51 # -----------------
  52 # Expansion of @$.
  53 m4_define([b4_lhs_location],
  54 [yyloc])
  55
  56
  57 # b4_rhs_location(RULE-LENGTH, NUM)
  58 # ---------------------------------
  59 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
  60 # on RHS.
  61 m4_define([b4_rhs_location],
  62 [yylsp@<:@m4_eval([$2 - $1])@:>@])
  63
  64
  65
  66 ## -------------- ##
  67 ## %pure-parser.  ##
  68 ## -------------- ##
  69
  70 # b4_pure_if(IF-TRUE, IF-FALSE)
  71 # -----------------------------
  72 # Expand IF-TRUE, if %pure-parser, IF-FALSE otherwise.
  73 m4_define([b4_pure_if],
  74 [m4_if(b4_pure, [1],
  75        [$1],
  76        [$2])])
  77
  78
  79 ## ------------------- ##
  80 ## Output file names.  ##
  81 ## ------------------- ##
  82
  83 m4_define_default([b4_input_suffix], [.y])
  84
  85 m4_define_default([b4_output_parser_suffix],
  86 [m4_translit(b4_input_suffix, [yY], [cC])])
  87
  88 m4_define_default([b4_output_parser_name],
  89 [b4_output_prefix[]b4_output_infix[]b4_output_parser_suffix[]])
  90
  91
  92 m4_define_default([b4_output_header_suffix],
  93 [m4_translit(b4_input_suffix, [yY], [hH])])
  94
  95 m4_define_default([b4_output_header_name],
  96 [b4_output_prefix[]b4_output_infix[]b4_output_header_suffix[]])
  97
  98 m4_define_default([b4_header_guard],
  99                   [m4_bpatsubst(m4_toupper([BISON_]b4_output_header_name),
 100                                 [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])])
 101
 102
 103 ## ------------------------- ##
 104 ## Assigning token numbers.  ##
 105 ## ------------------------- ##
 106
 107 # b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
 108 # -----------------------------------------
 109 # Output the definition of this token as #define.
 110 m4_define([b4_token_define],
 111 [#define $1 $2
 112 ])
 113
 114
 115 # b4_token_enum(TOKEN-NAME, TOKEN-NUMBER)
 116 # ---------------------------------------
 117 # Output the definition of this token as an enum.
 118 m4_define([b4_token_enum],
 119 [$1 = $2])
 120
 121
 122 # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 123 # -------------------------------------------------------
 124 # Output the definition of the tokens (if there are) as enums and #define.
 125 m4_define([b4_token_defines],
 126 [m4_if([$@], [[]], [],
 127 [/* Tokens.  */
 128 #ifndef YYTOKENTYPE
 129 # if defined (__STDC__) || defined (__cplusplus)
 130    /* Put the tokens into the symbol table, so that GDB and other debuggers
 131       know about them.  */
 132    enum yytokentype {
 133 m4_map_sep([     b4_token_enum], [,
 134 ],
 135            [$@])
 136    };
 137 # endif
 138   /* POSIX requires `int' for tokens in interfaces.  */
 139 # define YYTOKENTYPE int
 140 #endif /* !YYTOKENTYPE */
 141 m4_map([b4_token_define], [$@])
 142 ])
 143 ])
 144
 145
 146 m4_divert(0)dnl
 147 #output "b4_output_parser_name"
 148 /* A Bison parser, made from b4_filename
 149    by GNU bison b4_version.  */
 150
 151 /* Skeleton output parser for Bison,
 152    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
 153    Foundation, Inc.
 154
 155    This program is free software; you can redistribute it and/or modify
 156    it under the terms of the GNU General Public License as published by
 157    the Free Software Foundation; either version 2, or (at your option)
 158    any later version.
 159
 160    This program is distributed in the hope that it will be useful,
 161    but WITHOUT ANY WARRANTY; without even the implied warranty of
 162    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 163    GNU General Public License for more details.
 164
 165    You should have received a copy of the GNU General Public License
 166    along with this program; if not, write to the Free Software
 167    Foundation, Inc., 59 Temple Place - Suite 330,
 168    Boston, MA 02111-1307, USA.  */
 169
 170 /* As a special exception, when this file is copied by Bison into a
 171    Bison output file, you may use that output file without restriction.
 172    This special exception was added by the Free Software Foundation
 173    in version 1.24 of Bison.  */
 174
 175 /* This is the parser code that is written into each bison parser when
 176    the %semantic_parser declaration is not specified in the grammar.
 177    It was written by Richard Stallman by simplifying the original so
 178    called ``semantic'' parser.  */
 179
 180 /* All symbols defined below should begin with yy or YY, to avoid
 181    infringing on user name space.  This should be done even for local
 182    variables, as they might otherwise be expanded by user macros.
 183    There are some unavoidable exceptions within include files to
 184    define necessary library symbols; they are noted "INFRINGES ON
 185    USER NAME SPACE" below.  */
 186
 187 /* Identify Bison output.  */
 188 #define YYBISON 1
 189
 190 /* Pure parsers.  */
 191 #define YYPURE  b4_pure
 192
 193 /* Using locations.  */
 194 #define YYLSP_NEEDED b4_locations_flag
 195
 196 m4_if(b4_prefix[], [yy], [],
 197 [/* If NAME_PREFIX is specified substitute the variables and functions
 198    names.  */
 199 #define yyparse b4_prefix[]parse
 200 #define yylex   b4_prefix[]lex
 201 #define yyerror b4_prefix[]error
 202 #define yylval  b4_prefix[]lval
 203 #define yychar  b4_prefix[]char
 204 #define yydebug b4_prefix[]debug
 205 #define yynerrs b4_prefix[]nerrs
 206 b4_location_if([#define yylloc b4_prefix[]lloc])])
 207
 208 /* Copy the first part of user declarations.  */
 209 b4_pre_prologue
 210
 211 b4_token_defines(b4_tokens)
 212
 213 /* Enabling traces.  */
 214 #ifndef YYDEBUG
 215 # define YYDEBUG b4_debug
 216 #endif
 217
 218 /* Enabling verbose error messages.  */
 219 #ifdef YYERROR_VERBOSE
 220 # undef YYERROR_VERBOSE
 221 # define YYERROR_VERBOSE 1
 222 #else
 223 # define YYERROR_VERBOSE b4_error_verbose
 224 #endif
 225
 226 #ifndef YYSTYPE
 227 m4_ifdef([b4_stype],
 228 [#line b4_stype_line "b4_filename"
 229 typedef union b4_stype yystype;
 230 /* Line __line__ of __file__.  */
 231 #line __oline__ "__ofile__"],
 232 [typedef int yystype;])
 233 # define YYSTYPE yystype
 234 # define YYSTYPE_IS_TRIVIAL 1
 235 #endif
 236
 237 #ifndef YYLTYPE
 238 typedef struct yyltype
 239 {
 240   int first_line;
 241   int first_column;
 242   int last_line;
 243   int last_column;
 244 } yyltype;
 245 # define YYLTYPE b4_ltype
 246 # define YYLTYPE_IS_TRIVIAL 1
 247 #endif
 248
 249 /* Copy the second part of user declarations.  */
 250 b4_post_prologue
 251
 252 /* Line __line__ of __file__.  */
 253 #line __oline__ "__ofile__"
 254
 255 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 256
 257 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 258
 259 # if YYSTACK_USE_ALLOCA
 260 #  define YYSTACK_ALLOC alloca
 261 # else
 262 #  ifndef YYSTACK_USE_ALLOCA
 263 #   if defined (alloca) || defined (_ALLOCA_H)
 264 #    define YYSTACK_ALLOC alloca
 265 #   else
 266 #    ifdef __GNUC__
 267 #     define YYSTACK_ALLOC __builtin_alloca
 268 #    endif
 269 #   endif
 270 #  endif
 271 # endif
 272
 273 # ifdef YYSTACK_ALLOC
 274    /* Pacify GCC's `empty if-body' warning. */
 275 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 276 # else
 277 #  if defined (__STDC__) || defined (__cplusplus)
 278 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 279 #   define YYSIZE_T size_t
 280 #  endif
 281 #  define YYSTACK_ALLOC malloc
 282 #  define YYSTACK_FREE free
 283 # endif
 284 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
 285
 286
 287 #if (! defined (yyoverflow) \
 288      && (! defined (__cplusplus) \
 289          || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 290
 291 /* A type that is properly aligned for any stack member.  */
 292 union yyalloc
 293 {
 294   short yyss;
 295   YYSTYPE yyvs;
 296   b4_location_if([  YYLTYPE yyls;
 297 ])dnl
 298 };
 299
 300 /* The size of the maximum gap between one aligned stack and the next.  */
 301 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
 302
 303 /* The size of an array large to enough to hold all stacks, each with
 304    N elements.  */
 305 b4_location_if(
 306 [# define YYSTACK_BYTES(N) \
 307      ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))      \
 308       + 2 * YYSTACK_GAP_MAX)],
 309 [# define YYSTACK_BYTES(N) \
 310      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
 311       + YYSTACK_GAP_MAX)])
 312
 313 /* Copy COUNT objects from FROM to TO.  The source and destination do
 314    not overlap.  */
 315 # ifndef YYCOPY
 316 #  if 1 < __GNUC__
 317 #   define YYCOPY(To, From, Count) \
 318       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 319 #  else
 320 #   define YYCOPY(To, From, Count)              \
 321       do                                        \
 322         {                                       \
 323           register YYSIZE_T yyi;                \
 324           for (yyi = 0; yyi < (Count); yyi++)   \
 325             (To)[[yyi]] = (From)[[yyi]];        \
 326         }                                       \
 327       while (0)
 328 #  endif
 329 # endif
 330
 331 /* Relocate STACK from its old location to the new one.  The
 332    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 333    elements in the stack, and YYPTR gives the new location of the
 334    stack.  Advance YYPTR to a properly aligned location for the next
 335    stack.  */
 336 # define YYSTACK_RELOCATE(Stack)                                        \
 337     do                                                                  \
 338       {                                                                 \
 339         YYSIZE_T yynewbytes;                                            \
 340         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 341         Stack = &yyptr->Stack;                                          \
 342         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
 343         yyptr += yynewbytes / sizeof (*yyptr);                          \
 344       }                                                                 \
 345     while (0)
 346
 347 #endif
 348
 349 /* YYFINAL -- State number of the termination state. */
 350 #define YYFINAL  b4_final
 351 #define YYFLAG   b4_flag
 352 #define YYLAST   b4_last
 353
 354 /* YYNTOKENS -- Number of terminals. */
 355 #define YYNTOKENS  b4_ntokens
 356 /* YYNNTS -- Number of nonterminals. */
 357 #define YYNNTS  b4_nnts
 358 /* YYNRULES -- Number of rules. */
 359 #define YYNRULES  b4_nrules
 360 /* YYNRULES -- Number of states. */
 361 #define YYNSTATES  b4_nstates
 362
 363 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 364 #define YYUNDEFTOK  b4_undef_token_number
 365 #define YYMAXUTOK   b4_user_token_number_max
 366
 367 #define YYTRANSLATE(X) \
 368   ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK)
 369
 370 /* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX.  */
 371 static const b4_uint_type(b4_translate_max) yytranslate[[]] =
 372 {
 373   b4_translate
 374 };
 375
 376 #if YYDEBUG
 377 /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
 378    YYRHS.  */
 379 static const b4_uint_type(b4_prhs_max) yyprhs[[]] =
 380 {
 381   b4_prhs
 382 };
 383
 384 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 385 static const b4_sint_type(b4_rhs_max) yyrhs[[]] =
 386 {
 387   b4_rhs
 388 };
 389
 390 /* YYRLINE[[YYN]] -- source line where rule number YYN was defined.  */
 391 static const b4_uint_type(b4_rline_max) yyrline[[]] =
 392 {
 393   b4_rline
 394 };
 395 #endif
 396
 397 #if YYDEBUG || YYERROR_VERBOSE
 398 /* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
 399    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 400 static const char *const yytname[[]] =
 401 {
 402   b4_tname
 403 };
 404 #endif
 405
 406 /* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to
 407    token YYLEX-NUM.  */
 408 static const short yytoknum[[]] =
 409 {
 410   b4_toknum
 411 };
 412
 413 /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */
 414 static const b4_uint_type(b4_r1_max) yyr1[[]] =
 415 {
 416   b4_r1
 417 };
 418
 419 /* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN.  */
 420 static const b4_uint_type(b4_r2_max) yyr2[[]] =
 421 {
 422   b4_r2
 423 };
 424
 425 /* YYDEFACT[[STATE-NAME]] -- Default rule to reduce with in state
 426    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 427    means the default is an error.  */
 428 static const short yydefact[[]] =
 429 {
 430   b4_defact
 431 };
 432
 433 /* YYPGOTO[[NTERM-NUM]]. */
 434 static const short yydefgoto[[]] =
 435 {
 436   b4_defgoto
 437 };
 438
 439 /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
 440    STATE-NUM.  */
 441 static const short yypact[[]] =
 442 {
 443   b4_pact
 444 };
 445
 446 /* YYPGOTO[[NTERM-NUM]].  */
 447 static const short yypgoto[[]] =
 448 {
 449   b4_pgoto
 450 };
 451
 452 /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
 453    positive, shift that token.  If negative, reduce the rule which
 454    number is the opposite.  If zero, do what YYDEFACT says.  */
 455 static const short yytable[[]] =
 456 {
 457   b4_table
 458 };
 459
 460 static const short yycheck[[]] =
 461 {
 462   b4_check
 463 };
 464
 465 /* YYSTOS[[STATE-NUM]] -- The (internal number of the) accessing
 466    symbol of state STATE-NUM.  */
 467 static const b4_uint_type(b4_stos_max) yystos[[]] =
 468 {
 469   b4_stos
 470 };
 471
 472 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 473 # define YYSIZE_T __SIZE_TYPE__
 474 #endif
 475 #if ! defined (YYSIZE_T) && defined (size_t)
 476 # define YYSIZE_T size_t
 477 #endif
 478 #if ! defined (YYSIZE_T)
 479 # if defined (__STDC__) || defined (__cplusplus)
 480 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 481 #  define YYSIZE_T size_t
 482 # endif
 483 #endif
 484 #if ! defined (YYSIZE_T)
 485 # define YYSIZE_T unsigned int
 486 #endif
 487
 488 #define yyerrok         (yyerrstatus = 0)
 489 #define yyclearin       (yychar = YYEMPTY)
 490 #define YYEMPTY         -2
 491 #define YYEOF           0
 492
 493 #define YYACCEPT        goto yyacceptlab
 494 #define YYABORT         goto yyabortlab
 495 #define YYERROR         goto yyerrlab1
 496
 497 /* Like YYERROR except do call yyerror.  This remains here temporarily
 498    to ease the transition to the new meaning of YYERROR, for GCC.
 499    Once GCC version 2 has supplanted version 1, this can go.  */
 500
 501 #define YYFAIL          goto yyerrlab
 502
 503 #define YYRECOVERING()  (!!yyerrstatus)
 504
 505 #define YYBACKUP(Token, Value)                                  \
 506 do                                                              \
 507   if (yychar == YYEMPTY && yylen == 1)                          \
 508     {                                                           \
 509       yychar = (Token);                                         \
 510       yylval = (Value);                                         \
 511       yychar1 = YYTRANSLATE (yychar);                           \
 512       YYPOPSTACK;                                               \
 513       goto yybackup;                                            \
 514     }                                                           \
 515   else                                                          \
 516     {                                                           \
 517       yyerror ("syntax error: cannot back up");                 \
 518       YYERROR;                                                  \
 519     }                                                           \
 520 while (0)
 521
 522 #define YYTERROR        1
 523 #define YYERRCODE       256
 524
 525 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
 526    are run).  */
 527
 528 #ifndef YYLLOC_DEFAULT
 529 # define YYLLOC_DEFAULT(Current, Rhs, N)           \
 530   Current.first_line   = Rhs[[1]].first_line;      \
 531   Current.first_column = Rhs[[1]].first_column;    \
 532   Current.last_line    = Rhs[[N]].last_line;       \
 533   Current.last_column  = Rhs[[N]].last_column;
 534 #endif
 535
 536 /* YYLEX -- calling `yylex' with the right arguments.  */
 537
 538 b4_pure_if(
 539 [#ifdef YYLEX_PARAM
 540 # define YYLEX  yylex (&yylval, b4_location_if([&yylloc, ])YYLEX_PARAM)
 541 #else
 542 # define YYLEX  yylex (&yylval, b4_location_if([&yylloc, ]))
 543 #endif],
 544 [#define YYLEX  yylex ()])
 545
 546 /* Enable debugging if requested.  */
 547 #if YYDEBUG
 548
 549 # ifndef YYFPRINTF
 550 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 551 #  define YYFPRINTF fprintf
 552 # endif
 553
 554 # define YYDPRINTF(Args)                        \
 555 do {                                            \
 556   if (yydebug)                                  \
 557     YYFPRINTF Args;                             \
 558 } while (0)
 559 /* Nonzero means print parse trace.  It is left uninitialized so that
 560    multiple parsers can coexist.  */
 561 int yydebug;
 562 #else /* !YYDEBUG */
 563 # define YYDPRINTF(Args)
 564 #endif /* !YYDEBUG */
 565
 566 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 567 #ifndef YYINITDEPTH
 568 # define YYINITDEPTH b4_initdepth
 569 #endif
 570
 571 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 572    if the built-in stack extension method is used).
 573
 574    Do not make this value too large; the results are undefined if
 575    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
 576    evaluated with infinite-precision integer arithmetic.  */
 577
 578 #if YYMAXDEPTH == 0
 579 # undef YYMAXDEPTH
 580 #endif
 581
 582 #ifndef YYMAXDEPTH
 583 # define YYMAXDEPTH b4_maxdepth
 584 #endif
 585
 586 \f
 587
 588 #if YYERROR_VERBOSE
 589
 590 # ifndef yystrlen
 591 #  if defined (__GLIBC__) && defined (_STRING_H)
 592 #   define yystrlen strlen
 593 #  else
 594 /* Return the length of YYSTR.  */
 595 static YYSIZE_T
 596 #   if defined (__STDC__) || defined (__cplusplus)
 597 yystrlen (const char *yystr)
 598 #   else
 599 yystrlen (yystr)
 600      const char *yystr;
 601 #   endif
 602 {
 603   register const char *yys = yystr;
 604
 605   while (*yys++ != '\0')
 606     continue;
 607
 608   return yys - yystr - 1;
 609 }
 610 #  endif
 611 # endif
 612
 613 # ifndef yystpcpy
 614 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 615 #   define yystpcpy stpcpy
 616 #  else
 617 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 618    YYDEST.  */
 619 static char *
 620 #   if defined (__STDC__) || defined (__cplusplus)
 621 yystpcpy (char *yydest, const char *yysrc)
 622 #   else
 623 yystpcpy (yydest, yysrc)
 624      char *yydest;
 625      const char *yysrc;
 626 #   endif
 627 {
 628   register char *yyd = yydest;
 629   register const char *yys = yysrc;
 630
 631   while ((*yyd++ = *yys++) != '\0')
 632     continue;
 633
 634   return yyd - 1;
 635 }
 636 #  endif
 637 # endif
 638
 639 #endif /* !YYERROR_VERBOSE */
 640
 641 \f
 642
 643 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 644    into yyparse.  The argument should have type void *.
 645    It should actually point to an object.
 646    Grammar actions can access the variable by casting it
 647    to the proper pointer type.  */
 648
 649 #ifdef YYPARSE_PARAM
 650 # if defined (__STDC__) || defined (__cplusplus)
 651 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 652 #  define YYPARSE_PARAM_DECL
 653 # else
 654 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
 655 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 656 # endif
 657 #else /* !YYPARSE_PARAM */
 658 # define YYPARSE_PARAM_ARG
 659 # define YYPARSE_PARAM_DECL
 660 #endif /* !YYPARSE_PARAM */
 661
 662 /* Prevent warning if -Wstrict-prototypes.  */
 663 #ifdef __GNUC__
 664 # ifdef YYPARSE_PARAM
 665 int yyparse (void *);
 666 # else
 667 int yyparse (void);
 668 # endif
 669 #endif
 670
 671 #if defined (__STDC__) || defined (__cplusplus)
 672 static void yydestructor (int yytype,
 673                           YYSTYPE yyvalue[]b4_location_if([, YYLTYPE yylocation]));
 674 # if YYDEBUG
 675 static void yysymprint (FILE* out, int yytype,
 676                         YYSTYPE yyvalue[]b4_location_if([, YYLTYPE yylocation]));
 677 # endif
 678 #endif
 679
 680 m4_divert_push([KILL])# ======================== M4 code.
 681 # b4_declare_parser_variables
 682 # ---------------------------
 683 # Declare the variables that are global, or local to YYPARSE if
 684 #  pure-parser
 685 m4_define([b4_declare_parser_variables],
 686 [/* The lookahead symbol.  */
 687 int yychar;
 688
 689 /* The semantic value of the lookahead symbol.  */
 690 YYSTYPE yylval;
 691
 692 /* Number of parse errors so far.  */
 693 int yynerrs;b4_location_if([
 694 /* Location data for the lookahead symbol.  */
 695 YYLTYPE yylloc;])
 696 ])
 697 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
 698
 699 b4_pure_if([],
 700            [b4_declare_parser_variables])
 701
 702 int
 703 yyparse (YYPARSE_PARAM_ARG)
 704      YYPARSE_PARAM_DECL
 705 {[
 706   ]b4_pure_if([b4_declare_parser_variables])[
 707   register int yystate;
 708   register int yyn;
 709   int yyresult;
 710   /* Number of tokens to shift before error messages enabled.  */
 711   int yyerrstatus;
 712   /* Lookahead token as an internal (translated) token number.  */
 713   int yychar1 = 0;
 714
 715   /* Three stacks and their tools:
 716      `yyss': related to states,
 717      `yyvs': related to semantic values,
 718      `yyls': related to locations.
 719
 720      Refer to the stacks thru separate pointers, to allow yyoverflow
 721      to reallocate them elsewhere.  */
 722
 723   /* The state stack.  */
 724   short yyssa[YYINITDEPTH];
 725   short *yyss = yyssa;
 726   register short *yyssp;
 727
 728   /* The semantic value stack.  */
 729   YYSTYPE yyvsa[YYINITDEPTH];
 730   YYSTYPE *yyvs = yyvsa;
 731   register YYSTYPE *yyvsp;
 732
 733 ]b4_location_if(
 734 [[  /* The location stack.  */
 735   YYLTYPE yylsa[YYINITDEPTH];
 736   YYLTYPE *yyls = yylsa;
 737   YYLTYPE *yylsp;]])[
 738
 739 #define YYPOPSTACK   (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
 740
 741   YYSIZE_T yystacksize = YYINITDEPTH;
 742
 743   /* The variables used to return semantic value and location from the
 744      action routines.  */
 745   YYSTYPE yyval;
 746 ]b4_location_if([  YYLTYPE yyloc;])[
 747
 748   /* When reducing, the number of symbols on the RHS of the reduced
 749      rule.  */
 750   int yylen;
 751
 752   YYDPRINTF ((stderr, "Starting parse\n"));
 753
 754   yystate = 0;
 755   yyerrstatus = 0;
 756   yynerrs = 0;
 757   yychar = YYEMPTY;             /* Cause a token to be read.  */
 758
 759   /* Initialize stack pointers.
 760      Waste one element of value and location stack
 761      so that they stay on the same level as the state stack.
 762      The wasted elements are never initialized.  */
 763
 764   yyssp = yyss;
 765   yyvsp = yyvs;
 766 ]b4_location_if([  yylsp = yyls;])[
 767   goto yysetstate;
 768
 769 /*------------------------------------------------------------.
 770 | yynewstate -- Push a new state, which is found in yystate.  |
 771 `------------------------------------------------------------*/
 772  yynewstate:
 773   /* In all cases, when you get here, the value and location stacks
 774      have just been pushed. so pushing a state here evens the stacks.
 775      */
 776   yyssp++;
 777
 778  yysetstate:
 779   *yyssp = yystate;
 780
 781   if (yyssp >= yyss + yystacksize - 1)
 782     {
 783       /* Get the current used size of the three stacks, in elements.  */
 784       YYSIZE_T yysize = yyssp - yyss + 1;
 785
 786 #ifdef yyoverflow
 787       {
 788         /* Give user a chance to reallocate the stack. Use copies of
 789            these so that the &'s don't force the real ones into
 790            memory.  */
 791         YYSTYPE *yyvs1 = yyvs;
 792         short *yyss1 = yyss;
 793 ]b4_location_if([       YYLTYPE *yyls1 = yyls;])[
 794
 795         /* Each stack pointer address is followed by the size of the
 796            data in use in that stack, in bytes.  This used to be a
 797            conditional around just the two extra args, but that might
 798            be undefined if yyoverflow is a macro.  */
 799         yyoverflow ("parser stack overflow",
 800                     &yyss1, yysize * sizeof (*yyssp),
 801                     &yyvs1, yysize * sizeof (*yyvsp),
 802 ]b4_location_if([                   &yyls1, yysize * sizeof (*yylsp),])[
 803                     &yystacksize);
 804 ]b4_location_if([       yyls = yyls1;])[
 805         yyss = yyss1;
 806         yyvs = yyvs1;
 807       }
 808 #else /* no yyoverflow */
 809 # ifndef YYSTACK_RELOCATE
 810       goto yyoverflowlab;
 811 # else
 812       /* Extend the stack our own way.  */
 813       if (yystacksize >= YYMAXDEPTH)
 814         goto yyoverflowlab;
 815       yystacksize *= 2;
 816       if (yystacksize > YYMAXDEPTH)
 817         yystacksize = YYMAXDEPTH;
 818
 819       {
 820         short *yyss1 = yyss;
 821         union yyalloc *yyptr =
 822           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 823         if (! yyptr)
 824           goto yyoverflowlab;
 825         YYSTACK_RELOCATE (yyss);
 826         YYSTACK_RELOCATE (yyvs);
 827 ]b4_location_if([       YYSTACK_RELOCATE (yyls);])[
 828 #  undef YYSTACK_RELOCATE
 829         if (yyss1 != yyssa)
 830           YYSTACK_FREE (yyss1);
 831       }
 832 # endif
 833 #endif /* no yyoverflow */
 834
 835       yyssp = yyss + yysize - 1;
 836       yyvsp = yyvs + yysize - 1;
 837 ]b4_location_if([      yylsp = yyls + yysize - 1;])[
 838
 839       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 840                   (unsigned long int) yystacksize));
 841
 842       if (yyssp >= yyss + yystacksize - 1)
 843         YYABORT;
 844     }
 845
 846   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 847
 848   goto yybackup;
 849
 850 /*-----------.
 851 | yybackup.  |
 852 `-----------*/
 853 yybackup:
 854
 855 /* Do appropriate processing given the current state.  */
 856 /* Read a lookahead token if we need one and don't already have one.  */
 857 /* yyresume: */
 858
 859   /* First try to decide what to do without reference to lookahead token.  */
 860
 861   yyn = yypact[yystate];
 862   if (yyn == YYFLAG)
 863     goto yydefault;
 864
 865   /* Not known => get a lookahead token if don't already have one.  */
 866
 867   /* yychar is either YYEMPTY or YYEOF
 868      or a valid token in external form.  */
 869
 870   if (yychar == YYEMPTY)
 871     {
 872       YYDPRINTF ((stderr, "Reading a token: "));
 873       yychar = YYLEX;
 874     }
 875
 876   /* Convert token to internal form (in yychar1) for indexing tables with.  */
 877
 878   if (yychar <= 0)              /* This means end of input.  */
 879     {
 880       yychar1 = 0;
 881       yychar = YYEOF;           /* Don't call YYLEX any more.  */
 882
 883       YYDPRINTF ((stderr, "Now at end of input.\n"));
 884     }
 885   else
 886     {
 887       yychar1 = YYTRANSLATE (yychar);
 888
 889 #if YYDEBUG
 890      /* We have to keep this `#if YYDEBUG', since we use variables
 891         which are defined only if `YYDEBUG' is set.  */
 892       if (yydebug)
 893         {
 894           YYFPRINTF (stderr, "Next token is ");
 895           yysymprint (stderr, yychar1, yylval]b4_location_if([, yyloc])[);
 896           YYFPRINTF (stderr, "\n");
 897         }
 898 #endif
 899     }
 900
 901   yyn += yychar1;
 902   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 903     goto yydefault;
 904
 905   yyn = yytable[yyn];
 906
 907   /* yyn is what to do for this token type in this state.
 908      Negative => reduce, -yyn is rule number.
 909      Positive => shift, yyn is new state.
 910        New state is final state => don't bother to shift,
 911        just return success.
 912      0, or most negative number => error.  */
 913
 914   if (yyn < 0)
 915     {
 916       if (yyn == YYFLAG)
 917         goto yyerrlab;
 918       yyn = -yyn;
 919       goto yyreduce;
 920     }
 921   else if (yyn == 0)
 922     goto yyerrlab;
 923
 924   if (yyn == YYFINAL)
 925     YYACCEPT;
 926
 927   /* Shift the lookahead token.  */
 928   YYDPRINTF ((stderr, "Shifting token %d (%s), ",
 929               yychar, yytname[yychar1]));
 930
 931   /* Discard the token being shifted unless it is eof.  */
 932   if (yychar != YYEOF)
 933     yychar = YYEMPTY;
 934
 935   *++yyvsp = yylval;
 936 ]b4_location_if([  *++yylsp = yylloc;])[
 937
 938   /* Count tokens shifted since error; after three, turn off error
 939      status.  */
 940   if (yyerrstatus)
 941     yyerrstatus--;
 942
 943   yystate = yyn;
 944   goto yynewstate;
 945
 946
 947 /*-----------------------------------------------------------.
 948 | yydefault -- do the default action for the current state.  |
 949 `-----------------------------------------------------------*/
 950 yydefault:
 951   yyn = yydefact[yystate];
 952   if (yyn == 0)
 953     goto yyerrlab;
 954   goto yyreduce;
 955
 956
 957 /*-----------------------------.
 958 | yyreduce -- Do a reduction.  |
 959 `-----------------------------*/
 960 yyreduce:
 961   /* yyn is the number of a rule to reduce with.  */
 962   yylen = yyr2[yyn];
 963
 964   /* If YYLEN is nonzero, implement the default value of the action:
 965      `$$ = $1'.
 966
 967      Otherwise, the following line sets YYVAL to the semantic value of
 968      the lookahead token.  This behavior is undocumented and Bison
 969      users should not rely upon it.  Assigning to YYVAL
 970      unconditionally makes the parser a bit smaller, and it avoids a
 971      GCC warning that YYVAL may be used uninitialized.  */
 972   yyval = yyvsp[1-yylen];
 973
 974 ]b4_location_if(
 975 [  /* Default location. */
 976   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[
 977
 978 #if YYDEBUG
 979   /* We have to keep this `#if YYDEBUG', since we use variables which
 980      are defined only if `YYDEBUG' is set.  */
 981   if (yydebug)
 982     {
 983       int yyi;
 984
 985       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
 986                  yyn - 1, yyrline[yyn]);
 987
 988       /* Print the symbols being reduced, and their result.  */
 989       for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
 990         YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
 991       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 992     }
 993 #endif
 994   switch (yyn)
 995     ]{
 996       b4_actions
 997     }
 998
 999 /* Line __line__ of __file__.  */
1000 #line __oline__ "__ofile__"
1001 \f
1002 [  yyvsp -= yylen;
1003   yyssp -= yylen;
1004 ]b4_location_if([  yylsp -= yylen;])[
1005
1006 #if YYDEBUG
1007   if (yydebug)
1008     {
1009       short *yyssp1 = yyss - 1;
1010       YYFPRINTF (stderr, "state stack now");
1011       while (yyssp1 != yyssp)
1012         YYFPRINTF (stderr, " %d", *++yyssp1);
1013       YYFPRINTF (stderr, "\n");
1014     }
1015 #endif
1016
1017   *++yyvsp = yyval;
1018 ]b4_location_if([  *++yylsp = yyloc;])[
1019
1020   /* Now `shift' the result of the reduction.  Determine what state
1021      that goes to, based on the state we popped back to and the rule
1022      number reduced by.  */
1023
1024   yyn = yyr1[yyn];
1025
1026   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1027   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1028     yystate = yytable[yystate];
1029   else
1030     yystate = yydefgoto[yyn - YYNTOKENS];
1031
1032   goto yynewstate;
1033
1034
1035 /*------------------------------------.
1036 | yyerrlab -- here on detecting error |
1037 `------------------------------------*/
1038 yyerrlab:
1039   /* If not already recovering from an error, report this error.  */
1040   if (!yyerrstatus)
1041     {
1042       ++yynerrs;
1043
1044 #if YYERROR_VERBOSE
1045       yyn = yypact[yystate];
1046
1047       if (yyn > YYFLAG && yyn < YYLAST)
1048         {
1049           YYSIZE_T yysize = 0;
1050           char *yymsg;
1051           int yyx, yycount;
1052
1053           yycount = 0;
1054           /* Start YYX at -YYN if negative to avoid negative indexes in
1055              YYCHECK.  */
1056           for (yyx = yyn < 0 ? -yyn : 0;
1057                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1058             if (yycheck[yyx + yyn] == yyx)
1059               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1060           yysize += yystrlen ("parse error, unexpected ") + 1;
1061           yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
1062           yymsg = (char *) YYSTACK_ALLOC (yysize);
1063           if (yymsg != 0)
1064             {
1065               char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
1066               yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
1067
1068               if (yycount < 5)
1069                 {
1070                   yycount = 0;
1071                   for (yyx = yyn < 0 ? -yyn : 0;
1072                        yyx < (int) (sizeof (yytname) / sizeof (char *));
1073                        yyx++)
1074                     if (yycheck[yyx + yyn] == yyx)
1075                       {
1076                         const char *yyq = ! yycount ? ", expecting " : " or ";
1077                         yyp = yystpcpy (yyp, yyq);
1078                         yyp = yystpcpy (yyp, yytname[yyx]);
1079                         yycount++;
1080                       }
1081                 }
1082               yyerror (yymsg);
1083               YYSTACK_FREE (yymsg);
1084             }
1085           else
1086             yyerror ("parse error; also virtual memory exhausted");
1087         }
1088       else
1089 #endif /* YYERROR_VERBOSE */
1090         yyerror ("parse error");
1091     }
1092   goto yyerrlab1;
1093
1094
1095 /*----------------------------------------------------.
1096 | yyerrlab1 -- error raised explicitly by an action.  |
1097 `----------------------------------------------------*/
1098 yyerrlab1:
1099   if (yyerrstatus == 3)
1100     {
1101       /* If just tried and failed to reuse lookahead token after an
1102          error, discard it.  */
1103
1104       /* Return failure if at end of input.  */
1105       if (yychar == YYEOF)
1106         {
1107           /* Pop the error token.  */
1108           YYPOPSTACK;
1109           /* Pop the rest of the stack.  */
1110           while (yyssp > yyss)
1111             {
1112 #if YYDEBUG
1113               if (yydebug)
1114                 {
1115                   YYFPRINTF (stderr, "Error: popping ");
1116                   yysymprint (stderr,
1117                               yystos[*yyssp],
1118                               *yyvsp]b4_location_if([, *yylsp])[);
1119                   YYFPRINTF (stderr, "\n");
1120                 }
1121 #endif
1122               yydestructor (yystos[*yyssp], *yyvsp]b4_location_if([, *yylsp])[);
1123               YYPOPSTACK;
1124             }
1125           YYABORT;
1126         }
1127
1128       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1129                   yychar, yytname[yychar1]));
1130       yydestructor (yychar1, yylval]b4_location_if([, yylloc])[);
1131       yychar = YYEMPTY;
1132     }
1133
1134   /* Else will try to reuse lookahead token after shifting the error
1135      token.  */
1136
1137   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1138
1139   for (;;)
1140     {
1141       yyn = yypact[yystate];
1142       if (yyn != YYFLAG)
1143         {
1144           yyn += YYTERROR;
1145           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1146             {
1147               yyn = yytable[yyn];
1148               if (0 < yyn)
1149                 break;
1150             }
1151         }
1152
1153       /* Pop the current state because it cannot handle the error token.  */
1154       if (yyssp == yyss)
1155         YYABORT;
1156
1157 #if YYDEBUG
1158       if (yydebug)
1159         {
1160           YYFPRINTF (stderr, "Error: popping ");
1161           yysymprint (stderr,
1162                       yystos[*yyssp],
1163                       *yyvsp]b4_location_if([, *yylsp])[);
1164           YYFPRINTF (stderr, "\n");
1165         }
1166 #endif
1167
1168       yydestructor (yystos[yystate], *yyvsp]b4_location_if([, *yylsp])[);
1169       yyvsp--;
1170       yystate = *--yyssp;
1171 ]b4_location_if([      yylsp--;])[
1172
1173 #if YYDEBUG
1174       if (yydebug)
1175         {
1176           short *yyssp1 = yyss - 1;
1177           YYFPRINTF (stderr, "Error: state stack now");
1178           while (yyssp1 != yyssp)
1179             YYFPRINTF (stderr, " %d", *++yyssp1);
1180           YYFPRINTF (stderr, "\n");
1181         }
1182 #endif
1183     }
1184
1185   if (yyn == YYFINAL)
1186     YYACCEPT;
1187
1188   YYDPRINTF ((stderr, "Shifting error token, "));
1189
1190   *++yyvsp = yylval;
1191 ]b4_location_if([  *++yylsp = yylloc;])[
1192
1193   yystate = yyn;
1194   goto yynewstate;
1195
1196
1197 /*-------------------------------------.
1198 | yyacceptlab -- YYACCEPT comes here.  |
1199 `-------------------------------------*/
1200 yyacceptlab:
1201   yyresult = 0;
1202   goto yyreturn;
1203
1204 /*-----------------------------------.
1205 | yyabortlab -- YYABORT comes here.  |
1206 `-----------------------------------*/
1207 yyabortlab:
1208   yyresult = 1;
1209   goto yyreturn;
1210
1211 #ifndef yyoverflow
1212 /*----------------------------------------------.
1213 | yyoverflowlab -- parser overflow comes here.  |
1214 `----------------------------------------------*/
1215 yyoverflowlab:
1216   yyerror ("parser stack overflow");
1217   yyresult = 2;
1218   /* Fall through.  */
1219 #endif
1220
1221 yyreturn:
1222 #ifndef yyoverflow
1223   if (yyss != yyssa)
1224     YYSTACK_FREE (yyss);
1225 #endif
1226   return yyresult;
1227 ]}
1228
1229
1230 /*-----------------------------------------------.
1231 | Release the memory associated to this symbol.  |
1232 `-----------------------------------------------*/
1233
1234 m4_divert_push([KILL])# M4 code.
1235 # b4_symbol_destructor(SYMBOL-NUMBER, DESTRUCTOR, TYPE-NAME)
1236 # ----------------------------------------------------------
1237 m4_define([b4_symbol_destructor],
1238 [m4_pushdef([b4_dollar_dollar], [yyvalue.$6])dnl
1239 m4_pushdef([b4_at_dollar], [yylocation])dnl
1240       case $4: /* $3 */
1241 #line $2 "$1"
1242         $5;
1243 #line __oline__ "__ofile__"
1244         break;
1245 m4_popdef([b4_at_dollar])dnl
1246 m4_popdef([b4_dollar_dollar])])
1247
1248 m4_divert_pop([KILL])dnl# End of M4 code.
1249 static void
1250 yydestructor (int yytype,
1251               YYSTYPE yyvalue[]b4_location_if([, YYLTYPE yylocation]))
1252 {
1253   switch (yytype)
1254     {
1255 m4_map([b4_symbol_destructor], m4_defn([b4_symbol_destructors]))dnl
1256       default:
1257         break;
1258     }
1259 }
1260
1261
1262 #if YYDEBUG
1263 /*---------------------------.
1264 | Print this symbol on OUT.  |
1265 `---------------------------*/
1266
1267 m4_divert_push([KILL])# M4 code.
1268 # b4_symbol_printer(SYMBOL-NUMBER, PRINTER, TYPE-NAME)
1269 # ----------------------------------------------------------
1270 m4_define([b4_symbol_printer],
1271 [m4_pushdef([b4_dollar_dollar], [yyvalue.$6])dnl
1272 m4_pushdef([b4_at_dollar], [yylocation])dnl
1273       case $4: /* $3 */
1274 #line $2 "$1"
1275         $5;
1276 #line __oline__ "__ofile__"
1277         break;
1278 m4_popdef([b4_at_dollar])dnl
1279 m4_popdef([b4_dollar_dollar])])
1280
1281 m4_divert_pop([KILL])dnl# End of M4 code.
1282 static void
1283 yysymprint (FILE* out, int yytype,
1284             YYSTYPE yyvalue[]b4_location_if([, YYLTYPE yylocation]))
1285 {
1286   if (yytype < YYNTOKENS)
1287     YYFPRINTF (out, "token %d (%s ", yytoknum[[yytype]], yytname[[yytype]]);
1288   else
1289     YYFPRINTF (out, "nterm %s (", yytname[[yytype]]);
1290 # ifdef YYPRINT
1291   YYPRINT (out, yytype, yyvalue);
1292 # else
1293   switch (yytype)
1294     {
1295 m4_map([b4_symbol_printer], m4_defn([b4_symbol_printers]))dnl
1296       default:
1297         break;
1298     }
1299 # endif /* !defined YYPRINT. */
1300   YYFPRINTF (out, ")");
1301 }
1302 #endif /* YYDEBUG. */
1303
1304 b4_epilogue
1305 m4_if(b4_defines_flag, 0, [],
1306 [#output "b4_output_header_name"
1307 #ifndef b4_header_guard
1308 # define b4_header_guard
1309
1310 b4_token_defines(b4_tokens)
1311
1312 #ifndef YYSTYPE
1313 m4_ifdef([b4_stype],
1314 [#line b4_stype_line "b4_filename"
1315 typedef union b4_stype yystype;
1316 /* Line __line__ of __file__.  */
1317 #line __oline__ "__ofile__"],
1318 [typedef int yystype;])
1319 # define YYSTYPE yystype
1320 #endif
1321
1322 b4_pure_if([],
1323 [extern YYSTYPE b4_prefix[]lval;])
1324
1325 b4_location_if(
1326 [#ifndef YYLTYPE
1327 typedef struct yyltype
1328 {
1329   int first_line;
1330   int first_column;
1331   int last_line;
1332   int last_column;
1333 } yyltype;
1334 # define YYLTYPE yyltype
1335 #endif
1336
1337 m4_if(b4_pure, [0],
1338 [extern YYLTYPE b4_prefix[]lloc;])
1339 ])
1340 #endif /* not b4_header_guard */
1341 ])