From 98c4f1bbebfb3cc6d8e031d36fd1da3c19e634fb Mon Sep 17 00:00:00 2001 From: Andrew Knight Date: Thu, 26 Mar 2015 06:14:16 +0200 Subject: [PATCH] Upgrade win_flex/win_bison to 2.5.5 (bison 3.0) This version is required by upstream ANGLE. win_bison conveniently uses a different executable name as the existing bison copy, avoiding conflicts. Change-Id: I2897ce97aef6795933d3ab8b5570a8494a55523e Reviewed-by: Lars Knoll --- gnuwin32/bin/data/README | 70 + gnuwin32/bin/data/bison.m4 | 1063 +++++++++ gnuwin32/bin/data/c++-skel.m4 | 26 + gnuwin32/bin/data/c++.m4 | 544 +++++ gnuwin32/bin/data/c-like.m4 | 65 + gnuwin32/bin/data/c-skel.m4 | 26 + gnuwin32/bin/data/c.m4 | 839 +++++++ gnuwin32/bin/data/glr.c | 2563 ++++++++++++++++++++ gnuwin32/bin/data/glr.cc | 345 +++ gnuwin32/bin/data/java-skel.m4 | 26 + gnuwin32/bin/data/java.m4 | 342 +++ gnuwin32/bin/data/lalr1.cc | 1161 +++++++++ gnuwin32/bin/data/lalr1.java | 1065 +++++++++ gnuwin32/bin/data/local.mk | 45 + gnuwin32/bin/data/location.cc | 335 +++ gnuwin32/bin/data/m4sugar/foreach.m4 | 362 +++ gnuwin32/bin/data/m4sugar/m4sugar.m4 | 3307 ++++++++++++++++++++++++++ gnuwin32/bin/data/stack.hh | 154 ++ gnuwin32/bin/data/variant.hh | 362 +++ gnuwin32/bin/data/xslt/bison.xsl | 105 + gnuwin32/bin/data/xslt/xml2dot.xsl | 397 ++++ gnuwin32/bin/data/xslt/xml2text.xsl | 569 +++++ gnuwin32/bin/data/xslt/xml2xhtml.xsl | 745 ++++++ gnuwin32/bin/data/yacc.c | 1915 +++++++++++++++ gnuwin32/bin/win_bison.exe | Bin 0 -> 539648 bytes gnuwin32/bin/win_flex.exe | Bin 528896 -> 546816 bytes 26 files changed, 16431 insertions(+) create mode 100644 gnuwin32/bin/data/README create mode 100644 gnuwin32/bin/data/bison.m4 create mode 100644 gnuwin32/bin/data/c++-skel.m4 create mode 100644 gnuwin32/bin/data/c++.m4 create mode 100644 gnuwin32/bin/data/c-like.m4 create mode 100644 gnuwin32/bin/data/c-skel.m4 create mode 100644 gnuwin32/bin/data/c.m4 create mode 100644 gnuwin32/bin/data/glr.c create mode 100644 gnuwin32/bin/data/glr.cc create mode 100644 gnuwin32/bin/data/java-skel.m4 create mode 100644 gnuwin32/bin/data/java.m4 create mode 100644 gnuwin32/bin/data/lalr1.cc create mode 100644 gnuwin32/bin/data/lalr1.java create mode 100644 gnuwin32/bin/data/local.mk create mode 100644 gnuwin32/bin/data/location.cc create mode 100644 gnuwin32/bin/data/m4sugar/foreach.m4 create mode 100644 gnuwin32/bin/data/m4sugar/m4sugar.m4 create mode 100644 gnuwin32/bin/data/stack.hh create mode 100644 gnuwin32/bin/data/variant.hh create mode 100644 gnuwin32/bin/data/xslt/bison.xsl create mode 100644 gnuwin32/bin/data/xslt/xml2dot.xsl create mode 100644 gnuwin32/bin/data/xslt/xml2text.xsl create mode 100644 gnuwin32/bin/data/xslt/xml2xhtml.xsl create mode 100644 gnuwin32/bin/data/yacc.c create mode 100644 gnuwin32/bin/win_bison.exe diff --git a/gnuwin32/bin/data/README b/gnuwin32/bin/data/README new file mode 100644 index 00000000..842c0041 --- /dev/null +++ b/gnuwin32/bin/data/README @@ -0,0 +1,70 @@ +-*- outline -*- + +This directory contains data needed by Bison. + +* Skeletons +Bison skeletons: the general shapes of the different parser kinds, +that are specialized for specific grammars by the bison program. + +Currently, the supported skeletons are: + +- yacc.c + It used to be named bison.simple: it corresponds to C Yacc + compatible LALR(1) parsers. + +- lalr1.cc + Produces a C++ parser class. + +- lalr1.java + Produces a Java parser class. + +- glr.c + A Generalized LR C parser based on Bison's LALR(1) tables. + +- glr.cc + A Generalized LR C++ parser. Actually a C++ wrapper around glr.c. + +These skeletons are the only ones supported by the Bison team. +Because the interface between skeletons and the bison program is not +finished, *we are not bound to it*. In particular, Bison is not +mature enough for us to consider that "foreign skeletons" are +supported. + +* m4sugar +This directory contains M4sugar, sort of an extended library for M4, +which is used by Bison to instantiate the skeletons. + +* xslt +This directory contains XSLT programs that transform Bison's XML output +into various formats. + +- bison.xsl + A library of routines used by the other XSLT programs. + +- xml2dot.xsl + Conversion into GraphViz's dot format. + +- xml2text.xsl + Conversion into text. + +- xml2xhtml.xsl + Conversion into XHTML. + +----- + +Copyright (C) 2002, 2008-2013 Free Software Foundation, Inc. + +This file is part of GNU Bison. + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . diff --git a/gnuwin32/bin/data/bison.m4 b/gnuwin32/bin/data/bison.m4 new file mode 100644 index 00000000..ca27159c --- /dev/null +++ b/gnuwin32/bin/data/bison.m4 @@ -0,0 +1,1063 @@ + -*- Autoconf -*- + +# Language-independent M4 Macros for Bison. + +# Copyright (C) 2002, 2004-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +## ---------------- ## +## Identification. ## +## ---------------- ## + +# b4_copyright(TITLE, [YEARS]) +# ---------------------------- +# If YEARS are not defined, use b4_copyright_years. +m4_define([b4_copyright], +[b4_comment([A Bison parser, made by GNU Bison b4_version.]) + +b4_comment([$1 + +]m4_dquote(m4_text_wrap([Copyright (C) +]m4_ifval([$2], [[$2]], [m4_defn([b4_copyright_years])])[ +Free Software Foundation, Inc.]))[ + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see .]) + +b4_comment([As a special exception, you may create a larger work that contains +part or all of the Bison parser skeleton and distribute that work +under terms of your choice, so long as that work isn't itself a +parser generator using the skeleton or a modified version thereof +as a parser skeleton. Alternatively, if you modify or redistribute +the parser skeleton itself, you may (at your option) remove this +special exception, which will cause the skeleton and the resulting +Bison output files to be licensed under the GNU General Public +License without this special exception. + +This special exception was added by the Free Software Foundation in +version 2.2 of Bison.])]) + + +## -------- ## +## Output. ## +## -------- ## + +# b4_output_begin(FILE) +# --------------------- +# Enable output, i.e., send to diversion 0, expand after "#", and +# generate the tag to output into FILE. Must be followed by EOL. +m4_define([b4_output_begin], +[m4_changecom() +m4_divert_push(0)dnl +@output(m4_unquote([$1])@)@dnl +]) + + +# b4_output_end() +# --------------- +# Output nothing, restore # as comment character (no expansions after #). +m4_define([b4_output_end], +[m4_divert_pop(0) +m4_changecom([#]) +]) + + +# b4_divert_kill(CODE) +# -------------------- +# Expand CODE for its side effects, discard its output. +m4_define([b4_divert_kill], +[m4_divert_text([KILL], [$1])]) + + +# b4_define_silent(MACRO, CODE) +# ----------------------------- +# Same as m4_define, but throw away the expansion of CODE. +m4_define([b4_define_silent], +[m4_define([$1], [b4_divert_kill([$2])])]) + + +## ---------------- ## +## Error handling. ## +## ---------------- ## + +# The following error handling macros print error directives that should not +# become arguments of other macro invocations since they would likely then be +# mangled. Thus, they print to stdout directly. + +# b4_cat(TEXT) +# ------------ +# Write TEXT to stdout. Precede the final newline with an @ so that it's +# escaped. For example: +# +# b4_cat([[@complain(invalid input@)]]) +m4_define([b4_cat], +[m4_syscmd([cat <<'_m4eof' +]m4_bpatsubst(m4_dquote($1), [_m4eof], [_m4@`eof])[@ +_m4eof +])dnl +m4_if(m4_sysval, [0], [], [m4_fatal([$0: cannot write to stdout])])]) + +# b4_error(KIND, START, END, FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------------------------- +# Write @KIND(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_error([[complain]], [[input.y:2.3]], [[input.y:5.4]], +# [[invalid %s]], [[foo]]) +m4_define([b4_error], +[b4_cat([[@complain][(]$1[@,]$2[@,]$3[@,]$4[]]dnl +[m4_if([$#], [4], [], + [m4_foreach([b4_arg], + m4_dquote(m4_shift(m4_shift(m4_shift(m4_shift($@))))), + [[@,]b4_arg])])[@)]])]) + +# b4_warn(FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------ +# Write @warn(FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_warn([[invalid value for '%s': %s]], [[foo]], [[3]]) +# +# As a simple test suite, this: +# +# m4_divert(-1) +# m4_define([asdf], [ASDF]) +# m4_define([fsa], [FSA]) +# m4_define([fdsa], [FDSA]) +# b4_warn_at([[[asdf), asdf]]], [[[fsa), fsa]]], [[[fdsa), fdsa]]]) +# b4_warn_at([[asdf), asdf]], [[fsa), fsa]], [[fdsa), fdsa]]) +# b4_warn_at() +# b4_warn_at(1) +# b4_warn_at(1, 2) +# +# Should produce this without newlines: +# +# @warn_at([asdf), asdf]@,@,@,[fsa), fsa]@,[fdsa), fdsa]@) +# @warn(asdf), asdf@,@,@,fsa), fsa@,fdsa), fdsa@) +# @warn(@) +# @warn(1@) +# @warn(1@,2@) +m4_define([b4_warn], +[b4_error([[warn]], [], [], $@)]) + +# b4_warn_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# --------------------------------------------------- +# Write @warn(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_warn_at([[input.y:2.3]], [[input.y:5.4]], [[invalid %s]], [[foo]]) +m4_define([b4_warn_at], +[b4_error([[warn]], $@)]) + +# b4_complain(FORMAT, [ARG1], [ARG2], ...) +# ---------------------------------------- +# Bounce to b4_complain_at. +# +# See b4_warn example. +m4_define([b4_complain], +[b4_error([[complain]], [], [], $@)]) + +# b4_complain_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------------------------- +# Write @complain(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# See b4_warn_at example. +m4_define([b4_complain_at], +[b4_error([[complain]], $@)]) + +# b4_fatal(FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------- +# Bounce to b4_fatal_at. +# +# See b4_warn example. +m4_define([b4_fatal], +[b4_error([[fatal]], [], [], $@)dnl +m4_exit(1)]) + +# b4_fatal_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# ---------------------------------------------------- +# Write @fatal(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout and exit. +# +# See b4_warn_at example. +m4_define([b4_fatal_at], +[b4_error([[fatal]], $@)dnl +m4_exit(1)]) + + +## ------------ ## +## Data Types. ## +## ------------ ## + +# b4_ints_in(INT1, INT2, LOW, HIGH) +# --------------------------------- +# Return 1 iff both INT1 and INT2 are in [LOW, HIGH], 0 otherwise. +m4_define([b4_ints_in], +[m4_eval([$3 <= $1 && $1 <= $4 && $3 <= $2 && $2 <= $4])]) + + +# b4_subtract(LHS, RHS) +# --------------------- +# Evaluate LHS - RHS if they are integer literals, otherwise expand +# to (LHS) - (RHS). +m4_define([b4_subtract], +[m4_bmatch([$1$2], [^[0123456789]*$], + [m4_eval([$1 - $2])], + [($1) - ($2)])]) + +# b4_join(ARG1, ...) +# _b4_join(ARG1, ...) +# ------------------- +# Join with comma, skipping empty arguments. +# b4_join calls itself recursively until it sees the first non-empty +# argument, then calls _b4_join which prepends each non-empty argument +# with a comma. +m4_define([b4_join], +[m4_if([$#$1], + [1], [], + [m4_ifval([$1], + [$1[]_$0(m4_shift($@))], + [$0(m4_shift($@))])])]) + +# _b4_join(ARGS1, ...) +# -------------------- +m4_define([_b4_join], +[m4_if([$#$1], + [1], [], + [m4_ifval([$1], [, $1])[]$0(m4_shift($@))])]) + + + + +# b4_integral_parser_tables_map(MACRO) +# ------------------------------------- +# Map MACRO on all the integral tables. MACRO is expected to have +# the signature MACRO(TABLE-NAME, CONTENT, COMMENT). +m4_define([b4_integral_parser_tables_map], +[$1([pact], [b4_pact], + [[YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing +STATE-NUM.]]) + +$1([defact], [b4_defact], + [[YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. +Performed when YYTABLE does not specify something else to do. Zero +means the default is an error.]]) + +$1([pgoto], [b4_pgoto], [[YYPGOTO[NTERM-NUM].]]) + +$1([defgoto], [b4_defgoto], [[YYDEFGOTO[NTERM-NUM].]]) + +$1([table], [b4_table], + [[YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If +positive, shift that token. If negative, reduce the rule whose +number is the opposite. If YYTABLE_NINF, syntax error.]]) + +$1([check], [b4_check]) + +$1([stos], [b4_stos], + [[YYSTOS[STATE-NUM] -- The (internal number of the) accessing +symbol of state STATE-NUM.]]) + +$1([r1], [b4_r1], + [[YYR1[YYN] -- Symbol number of symbol that rule YYN derives.]]) + +$1([r2], [b4_r2], + [[YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.]]) +]) + + +# b4_parser_tables_declare +# b4_parser_tables_define +# ------------------------ +# Define/declare the (deterministic) parser tables. +m4_define([b4_parser_tables_declare], +[b4_integral_parser_tables_map([b4_integral_parser_table_declare])]) + +m4_define([b4_parser_tables_define], +[b4_integral_parser_tables_map([b4_integral_parser_table_define])]) + + + +## ------------------ ## +## Decoding options. ## +## ------------------ ## + +# b4_flag_if(FLAG, IF-TRUE, IF-FALSE) +# ----------------------------------- +# Run IF-TRUE if b4_FLAG_flag is 1, IF-FALSE if FLAG is 0, otherwise fail. +m4_define([b4_flag_if], +[m4_case(b4_$1_flag, + [0], [$3], + [1], [$2], + [m4_fatal([invalid $1 value: ]b4_$1_flag)])]) + + +# b4_define_flag_if(FLAG) +# ----------------------- +# Define "b4_FLAG_if(IF-TRUE, IF-FALSE)" that depends on the +# value of the Boolean FLAG. +m4_define([b4_define_flag_if], +[_b4_define_flag_if($[1], $[2], [$1])]) + +# _b4_define_flag_if($1, $2, FLAG) +# -------------------------------- +# Work around the impossibility to define macros inside macros, +# because issuing '[$1]' is not possible in M4. GNU M4 should provide +# $$1 a la M5/TeX. +m4_define([_b4_define_flag_if], +[m4_if([$1$2], $[1]$[2], [], + [m4_fatal([$0: Invalid arguments: $@])])dnl +m4_define([b4_$3_if], + [b4_flag_if([$3], [$1], [$2])])]) + + +# b4_FLAG_if(IF-TRUE, IF-FALSE) +# ----------------------------- +# Expand IF-TRUE, if FLAG is true, IF-FALSE otherwise. +b4_define_flag_if([defines]) # Whether headers are requested. +b4_define_flag_if([glr]) # Whether a GLR parser is requested. +b4_define_flag_if([nondeterministic]) # Whether conflicts should be handled. +b4_define_flag_if([token_table]) # Whether yytoken_table is demanded. +b4_define_flag_if([yacc]) # Whether POSIX Yacc is emulated. + + +## --------- ## +## Symbols. ## +## --------- ## + +# In order to unify the handling of the various aspects of symbols +# (tag, type_name, whether terminal, etc.), bison.exe defines one +# macro per (token, field), where field can has_id, id, etc.: see +# src/output.c:prepare_symbols_definitions(). +# +# The various FIELDS are: +# +# - has_id: 0 or 1. +# Whether the symbol has an id. +# - id: string +# If has_id, the id. Guaranteed to be usable as a C identifier. +# Prefixed by api.token.prefix if defined. +# - tag: string. +# A representat of the symbol. Can be 'foo', 'foo.id', '"foo"' etc. +# - user_number: integer +# The assigned (external) number as used by yylex. +# - is_token: 0 or 1 +# Whether this is a terminal symbol. +# - number: integer +# The internalized number (used after yytranslate). +# - has_type: 0, 1 +# Whether has a semantic value. +# - type_tag: string +# When api.value.type=union, the generated name for the union member. +# yytype_INT etc. for symbols that has_id, otherwise yytype_1 etc. +# - type +# If it has a semantic value, its type tag, or, if variant are used, +# its type. +# In the case of api.value.type=union, type is the real type (e.g. int). +# - has_printer: 0, 1 +# - printer: string +# - printer_file: string +# - printer_line: integer +# If the symbol has a printer, everything about it. +# - has_destructor, destructor, destructor_file, destructor_line +# Likewise. +# +# The following macros provide access to these values. + +# b4_symbol_(NUM, FIELD) +# ---------------------- +# Recover a FIELD about symbol #NUM. Thanks to m4_indir, fails if +# undefined. +m4_define([b4_symbol_], +[m4_indir([b4_symbol($1, $2)])]) + + +# b4_symbol(NUM, FIELD) +# --------------------- +# Recover a FIELD about symbol #NUM. Thanks to m4_indir, fails if +# undefined. If FIELD = id, prepend the token prefix. +m4_define([b4_symbol], +[m4_case([$2], + [id], [m4_do([b4_percent_define_get([api.token.prefix])], + [b4_symbol_([$1], [id])])], + [b4_symbol_($@)])]) + + +# b4_symbol_if(NUM, FIELD, IF-TRUE, IF-FALSE) +# ------------------------------------------- +# If FIELD about symbol #NUM is 1 expand IF-TRUE, if is 0, expand IF-FALSE. +# Otherwise an error. +m4_define([b4_symbol_if], +[m4_case(b4_symbol([$1], [$2]), + [1], [$3], + [0], [$4], + [m4_fatal([$0: field $2 of $1 is not a Boolean:] b4_symbol([$1], [$2]))])]) + + +# b4_symbol_tag_comment(SYMBOL-NUM) +# --------------------------------- +# Issue a comment giving the tag of symbol NUM. +m4_define([b4_symbol_tag_comment], +[b4_comment([b4_symbol([$1], [tag])]) +]) + + +# b4_symbol_action_location(SYMBOL-NUM, KIND) +# ------------------------------------------- +# Report the location of the KIND action as FILE:LINE. +m4_define([b4_symbol_action_location], +[b4_symbol([$1], [$2_file]):b4_syncline([b4_symbol([$1], [$2_line])])]) + + +# b4_symbol_action(SYMBOL-NUM, KIND) +# ---------------------------------- +# Run the action KIND (destructor or printer) for SYMBOL-NUM. +# Same as in C, but using references instead of pointers. +m4_define([b4_symbol_action], +[b4_symbol_if([$1], [has_$2], +[b4_dollar_pushdef([(*yyvaluep)], + b4_symbol_if([$1], [has_type], + [m4_dquote(b4_symbol([$1], [type]))]), + [(*yylocationp)])dnl + b4_symbol_case_([$1])[]dnl +b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"]) + b4_symbol([$1], [$2]) +b4_syncline([@oline@], [@ofile@]) + break; + +b4_dollar_popdef[]dnl +])]) + + +# b4_symbol_destructor(SYMBOL-NUM) +# b4_symbol_printer(SYMBOL-NUM) +# -------------------------------- +m4_define([b4_symbol_destructor], [b4_symbol_action([$1], [destructor])]) +m4_define([b4_symbol_printer], [b4_symbol_action([$1], [printer])]) + + +# b4_symbol_actions(KIND, [TYPE = yytype]) +# ---------------------------------------- +# Emit the symbol actions for KIND ("printer" or "destructor"). +# Dispatch on TYPE. +m4_define([b4_symbol_actions], +[m4_pushdef([b4_actions_], m4_expand([b4_symbol_foreach([b4_symbol_$1])]))dnl +m4_ifval(m4_defn([b4_actions_]), +[switch (m4_default([$2], [yytype])) + { + m4_defn([b4_actions_]) + default: + break; + }dnl +], +[YYUSE (m4_default([$2], [yytype]));])dnl +m4_popdef([b4_actions_])dnl +]) + +# b4_symbol_case_(SYMBOL-NUM) +# --------------------------- +# Issue a "case NUM" for SYMBOL-NUM. +m4_define([b4_symbol_case_], +[case b4_symbol([$1], [number]): b4_symbol_tag_comment([$1])]) +]) + + +# b4_symbol_foreach(MACRO) +# ------------------------ +# Invoke MACRO(SYMBOL-NUM) for each SYMBOL-NUM. +m4_define([b4_symbol_foreach], + [m4_map([$1], m4_defn([b4_symbol_numbers]))]) + +# b4_symbol_map(MACRO) +# -------------------- +# Return a list (possibly empty elements) of MACRO invoked for each +# SYMBOL-NUM. +m4_define([b4_symbol_map], +[m4_map_args_sep([$1(], [)], [,], b4_symbol_numbers)]) + + +# b4_token_visible_if(NUM, IF-TRUE, IF-FALSE) +# ------------------------------------------- +# Whether NUM denotes a token that has an exported definition (i.e., +# shows in enum yytokentype). +m4_define([b4_token_visible_if], +[b4_symbol_if([$1], [is_token], + [b4_symbol_if([$1], [has_id], [$2], [$3])], + [$3])]) + +# b4_token_has_definition(NUM) +# ---------------------------- +# 1 if NUM is visible, nothing otherwise. +m4_define([b4_token_has_definition], +[b4_token_visible_if([$1], [1])]) + +# b4_any_token_visible_if([IF-TRUE], [IF-FALSE]) +# ---------------------------------------------- +# Whether there is a token that needs to be defined. +m4_define([b4_any_token_visible_if], +[m4_ifval(b4_symbol_foreach([b4_token_has_definition]), + [$1], [$2])]) + + +# b4_token_format(FORMAT, NUM) +# ---------------------------- +m4_define([b4_token_format], +[b4_token_visible_if([$2], +[m4_quote(m4_format([$1], + [b4_symbol([$2], [id])], + [b4_symbol([$2], [user_number])]))])]) + + +## ------- ## +## Types. ## +## ------- ## + +# b4_type_action_(NUMS) +# --------------------- +# Run actions for the symbol NUMS that all have the same type-name. +# Skip NUMS that have no type-name. +# +# To specify the action to run, define b4_dollar_dollar(NUMBER, +# TAG, TYPE). +m4_define([b4_type_action_], +[b4_symbol_if([$1], [has_type], +[m4_map([ b4_symbol_case_], [$@])[]dnl + b4_dollar_dollar([b4_symbol([$1], [number])], + [b4_symbol([$1], [tag])], + [b4_symbol([$1], [type])]); + break; + +])]) + +# b4_type_foreach(MACRO) +# ---------------------- +# Invoke MACRO(SYMBOL-NUMS) for each set of SYMBOL-NUMS for each type set. +m4_define([b4_type_foreach], + [m4_map([$1], m4_defn([b4_type_names]))]) + + + +## ----------- ## +## Synclines. ## +## ----------- ## + +# b4_basename(NAME) +# ----------------- +# Similar to POSIX basename; the differences don't matter here. +# Beware that NAME is not evaluated. +m4_define([b4_basename], +[m4_bpatsubst([$1], [^.*/\([^/]+\)/*$], [\1])]) + + +# b4_syncline(LINE, FILE) +# ----------------------- +m4_define([b4_syncline], +[b4_flag_if([synclines], +[b4_sync_start([$1], [$2]) b4_sync_end([__line__], + [b4_basename(m4_quote(__file__))])[]dnl +])]) + +# b4_sync_start(LINE, FILE) +# ----------------------- +# Syncline for the new place. Typically a directive for the compiler. +m4_define([b4_sync_start], [b4_comment([$2:$1])]) + +# b4_sync_end(LINE, FILE) +# ----------------------- +# Syncline for the current place, which ends. Typically a comment +# left for the reader. +m4_define([b4_sync_end], [b4_comment([$2:$1])]) + + +# b4_user_code(USER-CODE) +# ----------------------- +# Emit code from the user, ending it with synclines. +m4_define([b4_user_code], +[$1 +b4_syncline([@oline@], [@ofile@])]) + + +# b4_define_user_code(MACRO) +# -------------------------- +# From b4_MACRO, build b4_user_MACRO that includes the synclines. +m4_define([b4_define_user_code], +[m4_define([b4_user_$1], +[b4_user_code([b4_$1])])]) + + +# b4_user_actions +# b4_user_initial_action +# b4_user_post_prologue +# b4_user_pre_prologue +# b4_user_union_members +# ---------------------- +# Macros that issue user code, ending with synclines. +b4_define_user_code([actions]) +b4_define_user_code([initial_action]) +b4_define_user_code([post_prologue]) +b4_define_user_code([pre_prologue]) +b4_define_user_code([union_members]) + + +# b4_check_user_names(WHAT, USER-LIST, BISON-NAMESPACE) +# ----------------------------------------------------- +# Complain if any name of type WHAT is used by the user (as recorded in +# USER-LIST) but is not used by Bison (as recorded by macros in the +# namespace BISON-NAMESPACE). +# +# USER-LIST must expand to a list specifying all user occurrences of all names +# of type WHAT. Each item in the list must be a triplet specifying one +# occurrence: name, start boundary, and end boundary. Empty string names are +# fine. An empty list is fine. +# +# For example, to define b4_foo_user_names to be used for USER-LIST with three +# name occurrences and with correct quoting: +# +# m4_define([b4_foo_user_names], +# [[[[[[bar]], [[parser.y:1.7]], [[parser.y:1.16]]]], +# [[[[bar]], [[parser.y:5.7]], [[parser.y:5.16]]]], +# [[[[baz]], [[parser.y:8.7]], [[parser.y:8.16]]]]]]) +# +# The macro BISON-NAMESPACE(bar) must be defined iff the name bar of type WHAT +# is used by Bison (in the front-end or in the skeleton). Empty string names +# are fine, but it would be ugly for Bison to actually use one. +# +# For example, to use b4_foo_bison_names for BISON-NAMESPACE and define that +# the names bar and baz are used by Bison: +# +# m4_define([b4_foo_bison_names(bar)]) +# m4_define([b4_foo_bison_names(baz)]) +# +# To invoke b4_check_user_names with TYPE foo, with USER-LIST +# b4_foo_user_names, with BISON-NAMESPACE b4_foo_bison_names, and with correct +# quoting: +# +# b4_check_user_names([[foo]], [b4_foo_user_names], +# [[b4_foo_bison_names]]) +m4_define([b4_check_user_names], +[m4_foreach([b4_occurrence], $2, +[m4_pushdef([b4_occurrence], b4_occurrence)dnl +m4_pushdef([b4_user_name], m4_car(b4_occurrence))dnl +m4_pushdef([b4_start], m4_car(m4_shift(b4_occurrence)))dnl +m4_pushdef([b4_end], m4_shift(m4_shift(b4_occurrence)))dnl +m4_ifndef($3[(]m4_quote(b4_user_name)[)], + [b4_complain_at([b4_start], [b4_end], + [[%s '%s' is not used]], + [$1], [b4_user_name])])[]dnl +m4_popdef([b4_occurrence])dnl +m4_popdef([b4_user_name])dnl +m4_popdef([b4_start])dnl +m4_popdef([b4_end])dnl +])]) + + + +## --------------------- ## +## b4_percent_define_*. ## +## --------------------- ## + + +# b4_percent_define_use(VARIABLE) +# ------------------------------- +# Declare that VARIABLE was used. +m4_define([b4_percent_define_use], +[m4_define([b4_percent_define_bison_variables(]$1[)])dnl +]) + +# b4_percent_define_get(VARIABLE, [DEFAULT]) +# ------------------------------------------ +# Mimic muscle_percent_define_get in ../src/muscle-tab.h. That is, if +# the %define variable VARIABLE is defined, emit its value. Contrary +# to its C counterpart, return DEFAULT otherwise. Also, record +# Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_get([[foo]]) +m4_define([b4_percent_define_get], +[b4_percent_define_use([$1])dnl +b4_percent_define_ifdef_([$1], + [m4_indir([b4_percent_define(]$1[)])], + [$2])]) + +# b4_percent_define_get_loc(VARIABLE) +# ----------------------------------- +# Mimic muscle_percent_define_get_loc in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is undefined, complain fatally since that's +# a Bison or skeleton error. Otherwise, return its definition location in a +# form approriate for the first two arguments of b4_warn_at, b4_complain_at, or +# b4_fatal_at. Don't record this as a Bison usage of VARIABLE as there's no +# reason to suspect that the user-supplied value has yet influenced the output. +# +# For example: +# +# b4_complain_at(b4_percent_define_get_loc([[foo]]), [[invalid foo]]) +m4_define([b4_percent_define_get_loc], +[m4_ifdef([b4_percent_define_loc(]$1[)], + [m4_pushdef([b4_loc], m4_indir([b4_percent_define_loc(]$1[)]))dnl +b4_loc[]dnl +m4_popdef([b4_loc])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_define_get_kind(VARIABLE) +# ------------------------------------ +# Get the kind (code, keyword, string) of VARIABLE, i.e., how its +# value was defined (braces, not delimiters, quotes). +# +# If the %define variable VARIABLE is undefined, complain fatally +# since that's a Bison or skeleton error. Don't record this as a +# Bison usage of VARIABLE as there's no reason to suspect that the +# user-supplied value has yet influenced the output. +m4_define([b4_percent_define_get_kind], +[m4_ifdef([b4_percent_define_kind(]$1[)], + [m4_indir([b4_percent_define_kind(]$1[)])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_define_get_syncline(VARIABLE) +# ---------------------------------------- +# Mimic muscle_percent_define_get_syncline in ../src/muscle-tab.h exactly. +# That is, if the %define variable VARIABLE is undefined, complain fatally +# since that's a Bison or skeleton error. Otherwise, return its definition +# location as a b4_syncline invocation. Don't record this as a Bison usage of +# VARIABLE as there's no reason to suspect that the user-supplied value has yet +# influenced the output. +# +# For example: +# +# b4_percent_define_get_syncline([[foo]]) +m4_define([b4_percent_define_get_syncline], +[m4_ifdef([b4_percent_define_syncline(]$1[)], + [m4_indir([b4_percent_define_syncline(]$1[)])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_define_ifdef_(VARIABLE, IF-TRUE, [IF-FALSE]) +# ------------------------------------------------------ +# If the %define variable VARIABLE is defined, expand IF-TRUE, else expand +# IF-FALSE. Don't record usage of VARIABLE. +# +# For example: +# +# b4_percent_define_ifdef_([[foo]], [[it's defined]], [[it's undefined]]) +m4_define([b4_percent_define_ifdef_], +[m4_ifdef([b4_percent_define(]$1[)], + [$2], + [$3])]) + +# b4_percent_define_ifdef(VARIABLE, IF-TRUE, [IF-FALSE]) +# ------------------------------------------------------ +# Mimic muscle_percent_define_ifdef in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is defined, expand IF-TRUE, else expand +# IF-FALSE. Also, record Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]]) +m4_define([b4_percent_define_ifdef], +[b4_percent_define_ifdef_([$1], + [b4_percent_define_use([$1])$2], + [$3])]) + + +## --------- ## +## Options. ## +## --------- ## + + +# b4_percent_define_flag_if(VARIABLE, IF-TRUE, [IF-FALSE]) +# -------------------------------------------------------- +# Mimic muscle_percent_define_flag_if in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is defined to "" or "true", expand IF-TRUE. +# If it is defined to "false", expand IF-FALSE. Complain if it is undefined +# (a Bison or skeleton error since the default value should have been set +# already) or defined to any other value (possibly a user error). Also, record +# Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_flag_if([[foo]], [[it's true]], [[it's false]]) +m4_define([b4_percent_define_flag_if], +[b4_percent_define_ifdef([$1], + [m4_case(b4_percent_define_get([$1]), + [], [$2], [true], [$2], [false], [$3], + [m4_expand_once([b4_complain_at(b4_percent_define_get_loc([$1]), + [[invalid value for %%define Boolean variable '%s']], + [$1])], + [[b4_percent_define_flag_if($1)]])])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + + +# b4_percent_define_default(VARIABLE, DEFAULT, [KIND = keyword]) +# -------------------------------------------------------------- +# Mimic muscle_percent_define_default in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is undefined, set its value to DEFAULT. +# Don't record this as a Bison usage of VARIABLE as there's no reason to +# suspect that the value has yet influenced the output. +# +# For example: +# +# b4_percent_define_default([[foo]], [[default value]]) +m4_define([b4_percent_define_default], +[b4_percent_define_ifdef_([$1], [], + [m4_define([b4_percent_define(]$1[)], [$2])dnl + m4_define([b4_percent_define_kind(]$1[)], + [m4_default([$3], [keyword])])dnl + m4_define([b4_percent_define_loc(]$1[)], + [[[[:-1.-1]], + [[:-1.-1]]]])dnl + m4_define([b4_percent_define_syncline(]$1[)], [[]])])]) + + +# b4_percent_define_if_define(NAME, [VARIABLE = NAME]) +# ---------------------------------------------------- +# Define b4_NAME_if that executes its $1 or $2 depending whether +# VARIABLE was %defined. The characters '.' and `-' in VARIABLE are mapped +# to '_'. +m4_define([b4_percent_define_if_define_], +[m4_define(m4_bpatsubst([b4_$1_if], [[-.]], [_]), + [b4_percent_define_flag_if(m4_default([$2], [$1]), + [$3], [$4])])]) +m4_define([b4_percent_define_if_define], +[b4_percent_define_default([m4_default([$2], [$1])], [[false]]) +b4_percent_define_if_define_([$1], [$2], $[1], $[2])]) + + +# b4_percent_define_check_kind(VARIABLE, KIND, [DIAGNOSTIC = complain]) +# --------------------------------------------------------------------- +m4_define([b4_percent_define_check_kind], +[b4_percent_define_ifdef_([$1], + [m4_if(b4_percent_define_get_kind([$1]), [$2], [], + [b4_error([m4_default([$3], [complain])], + b4_percent_define_get_loc([$1]), + [m4_case([$2], + [code], [[%%define variable '%s' requires '{...}' values]], + [keyword], [[%%define variable '%s' requires keyword values]], + [string], [[%%define variable '%s' requires '"..."' values]])], + [$1])])])dnl +]) + + +# b4_percent_define_check_values(VALUES) +# -------------------------------------- +# Mimic muscle_percent_define_check_values in ../src/muscle-tab.h exactly +# except that the VALUES structure is more appropriate for M4. That is, VALUES +# is a list of sublists of strings. For each sublist, the first string is the +# name of a %define variable, and all remaining strings in that sublist are the +# valid values for that variable. Complain if such a variable is undefined (a +# Bison error since the default value should have been set already) or defined +# to any other value (possibly a user error). Don't record this as a Bison +# usage of the variable as there's no reason to suspect that the value has yet +# influenced the output. +# +# For example: +# +# b4_percent_define_check_values([[[[foo]], [[foo-value1]], [[foo-value2]]]], +# [[[[bar]], [[bar-value1]]]]) +m4_define([b4_percent_define_check_values], +[m4_foreach([b4_sublist], m4_quote($@), + [_b4_percent_define_check_values(b4_sublist)])]) + +m4_define([_b4_percent_define_check_values], +[b4_percent_define_ifdef_([$1], + [b4_percent_define_check_kind(]$1[, [keyword], [deprecated])dnl + m4_pushdef([b4_good_value], [0])dnl + m4_if($#, 1, [], + [m4_foreach([b4_value], m4_dquote(m4_shift($@)), + [m4_if(m4_indir([b4_percent_define(]$1[)]), b4_value, + [m4_define([b4_good_value], [1])])])])dnl + m4_if(b4_good_value, [0], + [b4_complain_at(b4_percent_define_get_loc([$1]), + [[invalid value for %%define variable '%s': '%s']], + [$1], + m4_dquote(m4_indir([b4_percent_define(]$1[)]))) + m4_foreach([b4_value], m4_dquote(m4_shift($@)), + [b4_error([[note]], b4_percent_define_get_loc([$1]), [] + [[accepted value: '%s']], + m4_dquote(b4_value))])])dnl + m4_popdef([b4_good_value])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_code_get([QUALIFIER]) +# -------------------------------- +# If any %code blocks for QUALIFIER are defined, emit them beginning with a +# comment and ending with synclines and a newline. If QUALIFIER is not +# specified or empty, do this for the unqualified %code blocks. Also, record +# Bison's usage of QUALIFIER (if specified) by defining +# b4_percent_code_bison_qualifiers(QUALIFIER). +# +# For example, to emit any unqualified %code blocks followed by any %code +# blocks for the qualifier foo: +# +# b4_percent_code_get +# b4_percent_code_get([[foo]]) +m4_define([b4_percent_code_get], +[m4_pushdef([b4_macro_name], [[b4_percent_code(]$1[)]])dnl +m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])dnl +m4_ifdef(b4_macro_name, +[b4_comment([m4_if([$#], [0], [[Unqualified %code]], + [["%code ]$1["]])[ blocks.]]) +b4_user_code([m4_indir(b4_macro_name)]) +])dnl +m4_popdef([b4_macro_name])]) + +# b4_percent_code_ifdef(QUALIFIER, IF-TRUE, [IF-FALSE]) +# ----------------------------------------------------- +# If any %code blocks for QUALIFIER (or unqualified %code blocks if +# QUALIFIER is empty) are defined, expand IF-TRUE, else expand IF-FALSE. +# Also, record Bison's usage of QUALIFIER (if specified) by defining +# b4_percent_code_bison_qualifiers(QUALIFIER). +m4_define([b4_percent_code_ifdef], +[m4_ifdef([b4_percent_code(]$1[)], + [m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])$2], + [$3])]) + + +## ------------------ ## +## Common variables. ## +## ------------------ ## + + +# b4_parse_assert_if([IF-ASSERTIONS-ARE-USED], [IF-NOT]) +# b4_parse_trace_if([IF-DEBUG-TRACES-ARE-ENABLED], [IF-NOT]) +# b4_token_ctor_if([IF-YYLEX-RETURNS-A-TOKEN], [IF-NOT]) +# ---------------------------------------------- +b4_percent_define_if_define([token_ctor], [api.token.constructor]) +b4_percent_define_if_define([locations]) # Whether locations are tracked. +b4_percent_define_if_define([parse.assert]) +b4_percent_define_if_define([parse.trace]) + + +# b4_bison_locations_if([IF-TRUE]) +# -------------------------------- +# Expand IF-TRUE if using locations, and using the default location +# type. +m4_define([b4_bison_locations_if], +[b4_locations_if([b4_percent_define_ifdef([[api.location.type]], [], [$1])])]) + + +# b4_error_verbose_if([IF-ERRORS-ARE-VERBOSE], [IF-NOT]) +# ------------------------------------------------------ +# Map %define parse.error "(simple|verbose)" to b4_error_verbose_if and +# b4_error_verbose_flag. +b4_percent_define_default([[parse.error]], [[simple]]) +b4_percent_define_check_values([[[[parse.error]], + [[simple]], [[verbose]]]]) +m4_define([b4_error_verbose_flag], + [m4_case(b4_percent_define_get([[parse.error]]), + [simple], [[0]], + [verbose], [[1]])]) +b4_define_flag_if([error_verbose]) + +# yytoken_table is needed to support verbose errors. +b4_error_verbose_if([m4_define([b4_token_table_flag], [1])]) + + +# b4_variant_if([IF-VARIANT-ARE-USED], [IF-NOT]) +# ---------------------------------------------- +b4_percent_define_if_define([variant]) +m4_define([b4_variant_flag], [[0]]) +b4_percent_define_ifdef([[api.value.type]], + [m4_case(b4_percent_define_get_kind([[api.value.type]]), [keyword], + [m4_case(b4_percent_define_get([[api.value.type]]), [variant], + [m4_define([b4_variant_flag], [[1]])])])]) +b4_define_flag_if([variant]) + + +## ----------------------------------------------------------- ## +## After processing the skeletons, check that all the user's ## +## %define variables and %code qualifiers were used by Bison. ## +## ----------------------------------------------------------- ## + +m4_define([b4_check_user_names_wrap], +[m4_ifdef([b4_percent_]$1[_user_]$2[s], + [b4_check_user_names([[%]$1 $2], + [b4_percent_]$1[_user_]$2[s], + [[b4_percent_]$1[_bison_]$2[s]])])]) + +m4_wrap_lifo([ +b4_check_user_names_wrap([[define]], [[variable]]) +b4_check_user_names_wrap([[code]], [[qualifier]]) +]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# m4_define_default([b4_lex_param], []) dnl breaks other skeletons +m4_define_default([b4_pre_prologue], []) +m4_define_default([b4_post_prologue], []) +m4_define_default([b4_epilogue], []) +m4_define_default([b4_parse_param], []) + +# The initial column and line. +m4_define_default([b4_location_initial_column], [1]) +m4_define_default([b4_location_initial_line], [1]) + + +## --------------- ## +## Sanity checks. ## +## --------------- ## + +# api.location.prefix={...} (Java and C++). +b4_percent_define_check_kind([api.location.type], [code], [deprecated]) + +# api.position.prefix={...} (Java). +b4_percent_define_check_kind([api.position.type], [code], [deprecated]) + +# api.prefix >< %name-prefix. +b4_percent_define_check_kind([api.prefix], [code], [deprecated]) +b4_percent_define_ifdef([api.prefix], +[m4_ifdef([b4_prefix], +[b4_complain_at(b4_percent_define_get_loc([api.prefix]), + [['%s' and '%s' cannot be used together]], + [%name-prefix], + [%define api.prefix])])]) + +# api.token.prefix={...} +# Make it a warning for those who used betas of Bison 3.0. +b4_percent_define_check_kind([api.token.prefix], [code], [deprecated]) + +# api.value.type >< %union. +b4_percent_define_ifdef([api.value.type], +[m4_ifdef([b4_union_members], +[b4_complain_at(b4_percent_define_get_loc([api.value.type]), + [['%s' and '%s' cannot be used together]], + [%union], + [%define api.value.type])])]) + +# api.value.type=union >< %yacc. +b4_percent_define_ifdef([api.value.type], +[m4_if(b4_percent_define_get([api.value.type]), [union], +[b4_yacc_if(dnl +[b4_complain_at(b4_percent_define_get_loc([api.value.type]), + [['%s' and '%s' cannot be used together]], + [%yacc], + [%define api.value.type "union"])])])]) diff --git a/gnuwin32/bin/data/c++-skel.m4 b/gnuwin32/bin/data/c++-skel.m4 new file mode 100644 index 00000000..06597a8b --- /dev/null +++ b/gnuwin32/bin/data/c++-skel.m4 @@ -0,0 +1,26 @@ + -*- Autoconf -*- + +# C++ skeleton dispatching for Bison. + +# Copyright (C) 2006-2007, 2009-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +b4_glr_if( [m4_define([b4_used_skeleton], [b4_pkgdatadir/[glr.cc]])]) +b4_nondeterministic_if([m4_define([b4_used_skeleton], [b4_pkgdatadir/[glr.cc]])]) + +m4_define_default([b4_used_skeleton], [b4_pkgdatadir/[lalr1.cc]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/gnuwin32/bin/data/c++.m4 b/gnuwin32/bin/data/c++.m4 new file mode 100644 index 00000000..be12c0a2 --- /dev/null +++ b/gnuwin32/bin/data/c++.m4 @@ -0,0 +1,544 @@ + -*- Autoconf -*- + +# C++ skeleton for Bison + +# Copyright (C) 2002-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_include(b4_pkgdatadir/[c.m4]) + +# b4_comment(TEXT, [PREFIX]) +# -------------------------- +# Put TEXT in comment. Prefix all the output lines with PREFIX. +m4_define([b4_comment], +[b4_comment_([$1], [$2// ], [$2// ])]) + +## -------- ## +## Checks. ## +## -------- ## + +b4_percent_define_check_kind([api.namespace], [code], [deprecated]) +b4_percent_define_check_kind([parser_class_name], [code], [deprecated]) + +## ---------------- ## +## Default values. ## +## ---------------- ## + +b4_percent_define_default([[parser_class_name]], [[parser]]) + +# Don't do that so that we remember whether we're using a user +# request, or the default value. +# +# b4_percent_define_default([[api.location.type]], [[location]]) + +b4_percent_define_default([[filename_type]], [[std::string]]) +# Make it a warning for those who used betas of Bison 3.0. +b4_percent_define_default([[api.namespace]], m4_defn([b4_prefix])) + +b4_percent_define_default([[global_tokens_and_yystype]], [[false]]) +b4_percent_define_default([[define_location_comparison]], + [m4_if(b4_percent_define_get([[filename_type]]), + [std::string], [[true]], [[false]])]) + + + +## ----------- ## +## Namespace. ## +## ----------- ## + +m4_define([b4_namespace_ref], [b4_percent_define_get([[api.namespace]])]) + + +# Don't permit an empty b4_namespace_ref. Any '::parser::foo' appended to it +# would compile as an absolute reference with 'parser' in the global namespace. +# b4_namespace_open would open an anonymous namespace and thus establish +# internal linkage. This would compile. However, it's cryptic, and internal +# linkage for the parser would be specified in all translation units that +# include the header, which is always generated. If we ever need to permit +# internal linkage somehow, surely we can find a cleaner approach. +m4_if(m4_bregexp(b4_namespace_ref, [^[ ]*$]), [-1], [], +[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]), + [[namespace reference is empty]])]) + +# Instead of assuming the C++ compiler will do it, Bison should reject any +# invalid b4_namepsace_ref that would be converted to a valid +# b4_namespace_open. The problem is that Bison doesn't always output +# b4_namespace_ref to uncommented code but should reserve the ability to do so +# in future releases without risking breaking any existing user grammars. +# Specifically, don't allow empty names as b4_namespace_open would just convert +# those into anonymous namespaces, and that might tempt some users. +m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*::]), [-1], [], +[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]), + [[namespace reference has consecutive "::"]])]) +m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*$]), [-1], [], +[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]), + [[namespace reference has a trailing "::"]])]) + +m4_define([b4_namespace_open], +[b4_user_code([b4_percent_define_get_syncline([[api.namespace]]) +[namespace ]m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref), + [^\(.\)[ ]*::], [\1])), + [::], [ { namespace ])[ {]])]) + +m4_define([b4_namespace_close], +[b4_user_code([b4_percent_define_get_syncline([[api.namespace]]) +m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref[ ]), + [^\(.\)[ ]*\(::\)?\([^][:]\|:[^:]\)*], + [\1])), + [::\([^][:]\|:[^:]\)*], [} ])[} // ]b4_namespace_ref])]) + + +# b4_token_enums +# -------------- +# Output the definition of the tokens as enums. +m4_define([b4_token_enums], +[[enum yytokentype + { + ]m4_join([, + ], + b4_symbol_map([b4_token_enum]))[ + };]dnl +]) + + + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + + +# b4_value_type_declare +# --------------------- +# Declare semantic_type. +m4_define([b4_value_type_declare], +[b4_value_type_setup[]dnl +[ /// Symbol semantic values. +]m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), +[code], +[[ typedef ]b4_percent_define_get([[api.value.type]])[ semantic_type;]], +[m4_bmatch(b4_percent_define_get([[api.value.type]]), +[union\|union-directive], +[[ union semantic_type + { + ]b4_user_union_members[ + };]])])dnl +]) + + +# b4_public_types_declare +# ----------------------- +# Define the public types: token, semantic value, location, and so forth. +# Depending on %define token_lex, may be output in the header or source file. +m4_define([b4_public_types_declare], +[[#ifndef ]b4_api_PREFIX[STYPE +]b4_value_type_declare[ +#else + typedef ]b4_api_PREFIX[STYPE semantic_type; +#endif]b4_locations_if([ + /// Symbol locations. + typedef b4_percent_define_get([[api.location.type]], + [[location]]) location_type;])[ + + /// Syntax errors thrown from user actions. + struct syntax_error : std::runtime_error + { + syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m);]b4_locations_if([ + location_type location;])[ + }; + + /// Tokens. + struct token + { + ]b4_token_enums[ + }; + + /// (External) token type, as returned by yylex. + typedef token::yytokentype token_type; + + /// Internal symbol number. + typedef int symbol_number_type; + + /// Internal symbol number for tokens (subsumed by symbol_number_type). + typedef ]b4_int_type_for([b4_translate])[ token_number_type; + + /// A complete symbol. + /// + /// Expects its Base type to provide access to the symbol type + /// via type_get(). + /// + /// Provide access to semantic value]b4_locations_if([ and location])[. + template + struct basic_symbol : Base + { + /// Alias to Base. + typedef Base super_type; + + /// Default constructor. + basic_symbol (); + + /// Copy constructor. + basic_symbol (const basic_symbol& other); +]b4_variant_if([[ + /// Constructor for valueless symbols, and symbols from each type. +]b4_type_foreach([b4_basic_symbol_constructor_declare])], [[ + /// Constructor for valueless symbols. + basic_symbol (typename Base::kind_type t]b4_locations_if([, + const location_type& l])[);]])[ + + /// Constructor for symbols with semantic value. + basic_symbol (typename Base::kind_type t, + const semantic_type& v]b4_locations_if([, + const location_type& l])[); + + ~basic_symbol (); + + /// Destructive move, \a s is emptied into this. + void move (basic_symbol& s); + + /// The semantic value. + semantic_type value;]b4_locations_if([ + + /// The location. + location_type location;])[ + + private: + /// Assignment operator. + basic_symbol& operator= (const basic_symbol& other); + }; + + /// Type access provider for token (enum) based symbols. + struct by_type + { + /// Default constructor. + by_type (); + + /// Copy constructor. + by_type (const by_type& other); + + /// The symbol type as needed by the constructor. + typedef token_type kind_type; + + /// Constructor from (external) token numbers. + by_type (kind_type t); + + /// Steal the symbol type from \a that. + void move (by_type& that); + + /// The (internal) type number (corresponding to \a type). + /// -1 when this symbol is empty. + symbol_number_type type_get () const; + + /// The token. + token_type token () const; + + enum { empty = 0 }; + + /// The symbol type. + /// -1 when this symbol is empty. + token_number_type type; + }; + + /// "External" symbols: returned by the scanner. + typedef basic_symbol symbol_type; + +]b4_symbol_constructor_declare]) + + +# b4_public_types_define +# ---------------------- +# Provide the implementation needed by the public types. +m4_define([b4_public_types_define], +[[ inline + ]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m) + : std::runtime_error (m)]b4_locations_if([ + , location (l)])[ + {} + + // basic_symbol. + template + inline + ]b4_parser_class_name[::basic_symbol::basic_symbol () + : value () + {} + + template + inline + ]b4_parser_class_name[::basic_symbol::basic_symbol (const basic_symbol& other) + : Base (other) + , value ()]b4_locations_if([ + , location (other.location)])[ + { + ]b4_variant_if([b4_symbol_variant([other.type_get ()], [value], [copy], + [other.value])], + [value = other.value;])[ + } + + + template + inline + ]b4_parser_class_name[::basic_symbol::basic_symbol (]b4_join( + [typename Base::kind_type t], + [const semantic_type& v], + b4_locations_if([const location_type& l]))[) + : Base (t) + , value (]b4_variant_if([], [v])[)]b4_locations_if([ + , location (l)])[ + {]b4_variant_if([[ + (void) v; + ]b4_symbol_variant([this->type_get ()], [value], [copy], [v])])[} + +]b4_variant_if([[ + // Implementation of basic_symbol constructor for each type. +]b4_type_foreach([b4_basic_symbol_constructor_define])], [[ + /// Constructor for valueless symbols. + template + inline + ]b4_parser_class_name[::basic_symbol::basic_symbol (]b4_join( + [typename Base::kind_type t], + b4_locations_if([const location_type& l]))[) + : Base (t) + , value ()]b4_locations_if([ + , location (l)])[ + {}]])[ + + template + inline + ]b4_parser_class_name[::basic_symbol::~basic_symbol () + {]b4_variant_if([[ + // User destructor. + symbol_number_type yytype = this->type_get (); + switch (yytype) + { +]b4_symbol_foreach([b4_symbol_destructor])dnl +[ default: + break; + } + + // Type destructor. + ]b4_symbol_variant([[yytype]], [[value]], [[template destroy]])])[ + } + + template + inline + void + ]b4_parser_class_name[::basic_symbol::move (basic_symbol& s) + { + super_type::move(s); + ]b4_variant_if([b4_symbol_variant([this->type_get ()], [value], [move], + [s.value])], + [value = s.value;])[]b4_locations_if([ + location = s.location;])[ + } + + // by_type. + inline + ]b4_parser_class_name[::by_type::by_type () + : type (empty) + {} + + inline + ]b4_parser_class_name[::by_type::by_type (const by_type& other) + : type (other.type) + {} + + inline + ]b4_parser_class_name[::by_type::by_type (token_type t) + : type (yytranslate_ (t)) + {} + + inline + void + ]b4_parser_class_name[::by_type::move (by_type& that) + { + type = that.type; + that.type = empty; + } + + inline + int + ]b4_parser_class_name[::by_type::type_get () const + { + return type; + } +]b4_token_ctor_if([[ + inline + ]b4_parser_class_name[::token_type + ]b4_parser_class_name[::by_type::token () const + { + // YYTOKNUM[NUM] -- (External) token number corresponding to the + // (internal) symbol number NUM (which must be that of a token). */ + static + const ]b4_int_type_for([b4_toknum])[ + yytoken_number_[] = + { + ]b4_toknum[ + }; + return static_cast (yytoken_number_[type]); + } +]])[]dnl +b4_symbol_constructor_define]) + + +# b4_symbol_constructor_declare +# b4_symbol_constructor_define +# ----------------------------- +# Declare/define symbol constructors for all the value types. +# Use at class-level. Redefined in variant.hh. +m4_define([b4_symbol_constructor_declare], []) +m4_define([b4_symbol_constructor_define], []) + + +# b4_yytranslate_define +# --------------------- +# Define yytranslate_. Sometimes used in the header file, +# sometimes in the cc file. +m4_define([b4_yytranslate_define], +[[ // Symbol number corresponding to token number t. + inline + ]b4_parser_class_name[::token_number_type + ]b4_parser_class_name[::yytranslate_ (]b4_token_ctor_if([token_type], + [int])[ t) + { + static + const token_number_type + translate_table[] = + { +]b4_translate[ + }; + const unsigned int user_token_number_max_ = ]b4_user_token_number_max[; + const token_number_type undef_token_ = ]b4_undef_token_number[; + + if (static_cast(t) <= yyeof_) + return yyeof_; + else if (static_cast (t) <= user_token_number_max_) + return translate_table[t]; + else + return undef_token_; + } +]]) + + +# b4_lhs_value([TYPE]) +# -------------------- +# Expansion of $$. +m4_define([b4_lhs_value], +[b4_symbol_value([yyval], [$1])]) + + +# b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) +# -------------------------------------- +# Expansion of $NUM, where the current rule has RULE-LENGTH +# symbols on RHS. +m4_define([b4_rhs_value], +[b4_symbol_value([yysemantic_stack_@{($1) - ($2)@}], [$3])]) + + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[(yylocation_stack_@{($1) - ($2)@})]) + + +# b4_parse_param_decl +# ------------------- +# Extra formal arguments of the constructor. +# Change the parameter names from "foo" into "foo_yyarg", so that +# there is no collision bw the user chosen attribute name, and the +# argument name in the constructor. +m4_define([b4_parse_param_decl], +[m4_ifset([b4_parse_param], + [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])]) + +m4_define([b4_parse_param_decl_1], +[$1_yyarg]) + + + +# b4_parse_param_cons +# ------------------- +# Extra initialisations of the constructor. +m4_define([b4_parse_param_cons], + [m4_ifset([b4_parse_param], + [ + b4_cc_constructor_calls(b4_parse_param)])]) +m4_define([b4_cc_constructor_calls], + [m4_map_sep([b4_cc_constructor_call], [, + ], [$@])]) +m4_define([b4_cc_constructor_call], + [$2 ($2_yyarg)]) + +# b4_parse_param_vars +# ------------------- +# Extra instance variables. +m4_define([b4_parse_param_vars], + [m4_ifset([b4_parse_param], + [ + // User arguments. +b4_cc_var_decls(b4_parse_param)])]) +m4_define([b4_cc_var_decls], + [m4_map_sep([b4_cc_var_decl], [ +], [$@])]) +m4_define([b4_cc_var_decl], + [ $1;]) + + +## ---------## +## Values. ## +## ---------## + +# b4_yylloc_default_define +# ------------------------ +# Define YYLLOC_DEFAULT. +m4_define([b4_yylloc_default_define], +[[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +# ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).begin = YYRHSLOC (Rhs, 1).begin; \ + (Current).end = YYRHSLOC (Rhs, N).end; \ + } \ + else \ + { \ + (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ + } \ + while (/*CONSTCOND*/ false) +# endif +]]) + +## -------- ## +## Checks. ## +## -------- ## + +b4_token_ctor_if([b4_variant_if([], + [b4_fatal_at(b4_percent_define_get_loc(api.token.constructor), + [cannot use '%s' without '%s'], + [%define api.token.constructor], + [%define api.value.type variant]))])]) diff --git a/gnuwin32/bin/data/c-like.m4 b/gnuwin32/bin/data/c-like.m4 new file mode 100644 index 00000000..eb06de2a --- /dev/null +++ b/gnuwin32/bin/data/c-like.m4 @@ -0,0 +1,65 @@ + -*- Autoconf -*- + +# Common code for C-like languages (C, C++, Java, etc.) + +# Copyright (C) 2012-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# b4_comment_(TEXT, OPEN, CONTINUE, END) +# -------------------------------------- +# Put TEXT in comment. Avoid trailing spaces: don't indent empty lines. +# Avoid adding indentation to the first line, as the indentation comes +# from OPEN. That's why we don't patsubst([$1], [^\(.\)], [ \1]). +# +# Prefix all the output lines with PREFIX. +m4_define([b4_comment_], +[$2[]m4_bpatsubst(m4_expand([[$1]]), [ +\(.\)], [ +$3\1])$4]) + + +# b4_comment(TEXT, [PREFIX]) +# -------------------------- +# Put TEXT in comment. Prefix all the output lines with PREFIX. +m4_define([b4_comment], +[b4_comment_([$1], [$2/* ], [$2 ], [ */])]) + + + + +# b4_dollar_dollar_(VALUE, FIELD, DEFAULT-FIELD) +# ---------------------------------------------- +# If FIELD (or DEFAULT-FIELD) is non-null, return "VALUE.FIELD", +# otherwise just VALUE. Be sure to pass "(VALUE)" is VALUE is a +# pointer. +m4_define([b4_dollar_dollar_], +[b4_symbol_value([$1], + m4_if([$2], [[]], + [[$3]], [[$2]]))]) + +# b4_dollar_pushdef(VALUE-POINTER, DEFAULT-FIELD, LOCATION) +# b4_dollar_popdef +# --------------------------------------------------------- +# Define b4_dollar_dollar for VALUE and DEFAULT-FIELD, +# and b4_at_dollar for LOCATION. +m4_define([b4_dollar_pushdef], +[m4_pushdef([b4_dollar_dollar], + [b4_dollar_dollar_([$1], m4_dquote($][1), [$2])])dnl +m4_pushdef([b4_at_dollar], [$3])dnl +]) +m4_define([b4_dollar_popdef], +[m4_popdef([b4_at_dollar])dnl +m4_popdef([b4_dollar_dollar])dnl +]) diff --git a/gnuwin32/bin/data/c-skel.m4 b/gnuwin32/bin/data/c-skel.m4 new file mode 100644 index 00000000..36904aaf --- /dev/null +++ b/gnuwin32/bin/data/c-skel.m4 @@ -0,0 +1,26 @@ + -*- Autoconf -*- + +# C skeleton dispatching for Bison. + +# Copyright (C) 2006-2007, 2009-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +b4_glr_if( [m4_define([b4_used_skeleton], [b4_pkgdatadir/[glr.c]])]) +b4_nondeterministic_if([m4_define([b4_used_skeleton], [b4_pkgdatadir/[glr.c]])]) + +m4_define_default([b4_used_skeleton], [b4_pkgdatadir/[yacc.c]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/gnuwin32/bin/data/c.m4 b/gnuwin32/bin/data/c.m4 new file mode 100644 index 00000000..b1b43948 --- /dev/null +++ b/gnuwin32/bin/data/c.m4 @@ -0,0 +1,839 @@ + -*- Autoconf -*- + +# C M4 Macros for Bison. + +# Copyright (C) 2002, 2004-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_include(b4_pkgdatadir/[c-like.m4]) + +# b4_tocpp(STRING) +# ---------------- +# Convert STRING into a valid C macro name. +m4_define([b4_tocpp], +[m4_toupper(m4_bpatsubst(m4_quote($1), [[^a-zA-Z0-9]+], [_]))]) + + +# b4_cpp_guard(FILE) +# ------------------ +# A valid C macro name to use as a CPP header guard for FILE. +m4_define([b4_cpp_guard], +[[YY_]b4_tocpp(m4_defn([b4_prefix])/[$1])[_INCLUDED]]) + + +# b4_cpp_guard_open(FILE) +# b4_cpp_guard_close(FILE) +# ------------------------ +# If FILE does not expand to nothing, open/close CPP inclusion guards for FILE. +m4_define([b4_cpp_guard_open], +[m4_ifval(m4_quote($1), +[#ifndef b4_cpp_guard([$1]) +# define b4_cpp_guard([$1])])]) + +m4_define([b4_cpp_guard_close], +[m4_ifval(m4_quote($1), +[#endif b4_comment([!b4_cpp_guard([$1])])])]) + + +## ---------------- ## +## Identification. ## +## ---------------- ## + +# b4_identification +# ----------------- +# Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or +# b4_pull_flag if they use the values of the %define variables api.pure or +# api.push-pull. +m4_define([b4_identification], +[[/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "]b4_version[" + +/* Skeleton name. */ +#define YYSKELETON_NAME ]b4_skeleton[]m4_ifdef([b4_pure_flag], [[ + +/* Pure parsers. */ +#define YYPURE ]b4_pure_flag])[]m4_ifdef([b4_push_flag], [[ + +/* Push parsers. */ +#define YYPUSH ]b4_push_flag])[]m4_ifdef([b4_pull_flag], [[ + +/* Pull parsers. */ +#define YYPULL ]b4_pull_flag])[ +]]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# b4_api_prefix, b4_api_PREFIX +# ---------------------------- +# Corresponds to %define api.prefix +b4_percent_define_default([[api.prefix]], [[yy]]) +m4_define([b4_api_prefix], +[b4_percent_define_get([[api.prefix]])]) +m4_define([b4_api_PREFIX], +[m4_toupper(b4_api_prefix)]) + + +# b4_prefix +# --------- +# If the %name-prefix is not given, it is api.prefix. +m4_define_default([b4_prefix], [b4_api_prefix]) + +# If the %union is not named, its name is YYSTYPE. +m4_define_default([b4_union_name], [b4_api_PREFIX[]STYPE]) + + +## ------------------------ ## +## Pure/impure interfaces. ## +## ------------------------ ## + +# b4_lex_formals +# -------------- +# All the yylex formal arguments. +# b4_lex_param arrives quoted twice, but we want to keep only one level. +m4_define([b4_lex_formals], +[b4_pure_if([[[[YYSTYPE *yylvalp]], [[&yylval]]][]dnl +b4_locations_if([, [[YYLTYPE *yyllocp], [&yylloc]]])])dnl +m4_ifdef([b4_lex_param], [, ]b4_lex_param)]) + + +# b4_lex +# ------ +# Call yylex. +m4_define([b4_lex], +[b4_function_call([yylex], [int], b4_lex_formals)]) + + +# b4_user_args +# ------------ +m4_define([b4_user_args], +[m4_ifset([b4_parse_param], [, b4_args(b4_parse_param)])]) + + +# b4_parse_param +# -------------- +# If defined, b4_parse_param arrives double quoted, but below we prefer +# it to be single quoted. +m4_define([b4_parse_param], +b4_parse_param) + + +# b4_parse_param_for(DECL, FORMAL, BODY) +# --------------------------------------- +# Iterate over the user parameters, binding the declaration to DECL, +# the formal name to FORMAL, and evaluating the BODY. +m4_define([b4_parse_param_for], +[m4_foreach([$1_$2], m4_defn([b4_parse_param]), +[m4_pushdef([$1], m4_unquote(m4_car($1_$2)))dnl +m4_pushdef([$2], m4_shift($1_$2))dnl +$3[]dnl +m4_popdef([$2])dnl +m4_popdef([$1])dnl +])]) + +# b4_parse_param_use([VAL], [LOC]) +# -------------------------------- +# 'YYUSE' VAL, LOC if locations are enabled, and all the parse-params. +m4_define([b4_parse_param_use], +[m4_ifvaln([$1], [ YYUSE ([$1]);])dnl +b4_locations_if([m4_ifvaln([$2], [ YYUSE ([$2]);])])dnl +b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal); +])dnl +]) + + +## ------------ ## +## Data Types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# MIN to MAX (included). +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char], + b4_ints_in($@, [-128], [127]), [1], [signed char], + + b4_ints_in($@, [0], [65535]), [1], [unsigned short int], + b4_ints_in($@, [-32768], [32767]), [1], [short int], + + m4_eval([0 <= $1]), [1], [unsigned int], + + [int])]) + + +# b4_int_type_for(NAME) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# 'NAME_min' to 'NAME_max' (included). +m4_define([b4_int_type_for], +[b4_int_type($1_min, $1_max)]) + + +# b4_table_value_equals(TABLE, VALUE, LITERAL) +# -------------------------------------------- +# Without inducing a comparison warning from the compiler, check if the +# literal value LITERAL equals VALUE from table TABLE, which must have +# TABLE_min and TABLE_max defined. +m4_define([b4_table_value_equals], +[m4_if(m4_eval($3 < m4_indir([b4_]$1[_min]) + || m4_indir([b4_]$1[_max]) < $3), [1], + [[0]], + [(!!(($2) == ($3)))])]) + + +## ----------------- ## +## Compiler issues. ## +## ----------------- ## + +# b4_attribute_define +# ------------------- +# Provide portability for __attribute__. +m4_define([b4_attribute_define], +[#ifndef __attribute__ +/* This feature is available in gcc versions 2.5 and later. */ +# if (! defined __GNUC__ || __GNUC__ < 2 \ + || (__GNUC__ == 2 && __GNUC_MINOR__ < 5)) +# define __attribute__(Spec) /* empty */ +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(E) ((void) (E)) +#else +# define YYUSE(E) /* empty */ +#endif + +#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_INITIAL_VALUE(Value) Value +#endif +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ +#endif +]) + + +## ---------## +## Values. ## +## ---------## + + +# b4_null_define +# -------------- +# Portability issues: define a YY_NULL appropriate for the current +# language (C, C++98, or C++11). +m4_define([b4_null_define], +[# ifndef YY_NULL +# if defined __cplusplus && 201103L <= __cplusplus +# define YY_NULL nullptr +# else +# define YY_NULL 0 +# endif +# endif[]dnl +]) + + +# b4_null +# ------- +# Return a null pointer constant. +m4_define([b4_null], [YY_NULL]) + +# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) +# ------------------------------------------------------------- +# Define "yy" whose contents is CONTENT. +m4_define([b4_integral_parser_table_define], +[m4_ifvaln([$3], [b4_comment([$3], [ ])])dnl +static const b4_int_type_for([$2]) yy$1[[]] = +{ + $2 +};dnl +]) + + +## ------------------------- ## +## Assigning token numbers. ## +## ------------------------- ## + +# b4_token_define(TOKEN-NUM) +# -------------------------- +# Output the definition of this token as #define. +m4_define([b4_token_define], +[b4_token_format([#define %s %s], [$1])]) + +# b4_token_defines +# ---------------- +# Output the definition of the tokens. +m4_define([b4_token_defines], +[b4_any_token_visible_if([/* Tokens. */ +m4_join([ +], b4_symbol_map([b4_token_define])) +])]) + + +# b4_token_enum(TOKEN-NUM) +# ------------------------ +# Output the definition of this token as an enum. +m4_define([b4_token_enum], +[b4_token_format([%s = %s], [$1])]) + + +# b4_token_enums +# -------------- +# Output the definition of the tokens (if there are) as enums. +m4_define([b4_token_enums], +[b4_any_token_visible_if([[/* Token type. */ +#ifndef ]b4_api_PREFIX[TOKENTYPE +# define ]b4_api_PREFIX[TOKENTYPE + enum ]b4_api_prefix[tokentype + { + ]m4_join([, + ], + b4_symbol_map([b4_token_enum]))[ + }; +#endif +]])]) + + +# b4_token_enums_defines +# ---------------------- +# Output the definition of the tokens (if there are any) as enums and, +# if POSIX Yacc is enabled, as #defines. +m4_define([b4_token_enums_defines], +[b4_token_enums[]b4_yacc_if([b4_token_defines])]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_symbol_value(VAL, [TYPE]) +# ---------------------------- +# Given a semantic value VAL ($$, $1 etc.), extract its value of type +# TYPE if TYPE is given, otherwise just return VAL. The result can be +# used safetly, it is put in parens to avoid nasty precedence issues. +# TYPE is *not* put in braces, provide some if needed. +m4_define([b4_symbol_value], +[($1[]m4_ifval([$2], [.$2]))]) + + + +## ---------------------- ## +## Defining C functions. ## +## ---------------------- ## + + +# b4_function_define(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ----------------------------------------------------------- +# Declare the function NAME in C. +m4_define([b4_function_define], +[$2 +$1 (b4_formals(m4_shift2($@)))[]dnl +]) + + +# b4_formals([DECL1, NAME1], ...) +# ------------------------------- +# The formal arguments of a C function definition. +m4_define([b4_formals], +[m4_if([$#], [0], [void], + [$#$1], [1], [void], + [m4_map_sep([b4_formal], [, ], [$@])])]) + +m4_define([b4_formal], +[$1]) + + + +## ----------------------- ## +## Declaring C functions. ## +## ----------------------- ## + + +# b4_function_declare(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ------------------------------------------------------------ +# Declare the function NAME. +m4_define([b4_function_declare], +[$2 $1 (b4_formals(m4_shift2($@)));[]dnl +]) + + + + +## --------------------- ## +## Calling C functions. ## +## --------------------- ## + + +# b4_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ----------------------------------------------------------- +# Call the function NAME with arguments NAME1, NAME2 etc. +m4_define([b4_function_call], +[$1 (b4_args(m4_shift2($@)))[]dnl +]) + + +# b4_args([DECL1, NAME1], ...) +# ---------------------------- +# Output the arguments NAME1, NAME2... +m4_define([b4_args], +[m4_map_sep([b4_arg], [, ], [$@])]) + +m4_define([b4_arg], +[$2]) + + +## ----------- ## +## Synclines. ## +## ----------- ## + +# b4_sync_start(LINE, FILE) +# ------------------------- +m4_define([b4_sync_start], [[#]line $1 $2]) + + +## -------------- ## +## User actions. ## +## -------------- ## + +# b4_case(LABEL, STATEMENTS) +# -------------------------- +m4_define([b4_case], +[ case $1: +$2 +b4_syncline([@oline@], [@ofile@]) + break;]) + + +# b4_predicate_case(LABEL, CONDITIONS) +# ------------------------------------ +m4_define([b4_predicate_case], +[ case $1: + if (! ($2)) YYERROR; +b4_syncline([@oline@], [@ofile@]) + break;]) + + +# b4_yydestruct_define +# -------------------- +# Define the "yydestruct" function. +m4_define_default([b4_yydestruct_define], +[[/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +]b4_function_define([yydestruct], + [static void], + [[const char *yymsg], [yymsg]], + [[int yytype], [yytype]], + [[YYSTYPE *yyvaluep], [yyvaluep]][]dnl +b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl +m4_ifset([b4_parse_param], [, b4_parse_param]))[ +{ +]b4_parse_param_use([yyvaluep], [yylocationp])dnl +[ if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + ]b4_symbol_actions([destructor])[ + YY_IGNORE_MAYBE_UNINITIALIZED_END +}]dnl +]) + + +# b4_yy_symbol_print_define +# ------------------------- +# Define the "yy_symbol_print" function. +m4_define_default([b4_yy_symbol_print_define], +[[ +/*----------------------------------------. +| Print this symbol's value on YYOUTPUT. | +`----------------------------------------*/ + +]b4_function_define([yy_symbol_value_print], + [static void], + [[FILE *yyoutput], [yyoutput]], + [[int yytype], [yytype]], + [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl +b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl +m4_ifset([b4_parse_param], [, b4_parse_param]))[ +{ + FILE *yyo = yyoutput; +]b4_parse_param_use([yyo], [yylocationp])dnl +[ if (!yyvaluep) + return;] +dnl glr.c does not feature yytoknum. +m4_if(b4_skeleton, ["yacc.c"], +[[# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# endif +]])dnl + b4_symbol_actions([printer])[ +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +]b4_function_define([yy_symbol_print], + [static void], + [[FILE *yyoutput], [yyoutput]], + [[int yytype], [yytype]], + [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl +b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl +m4_ifset([b4_parse_param], [, b4_parse_param]))[ +{ + YYFPRINTF (yyoutput, "%s %s (", + yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); + +]b4_locations_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp); + YYFPRINTF (yyoutput, ": "); +])dnl +[ yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl +b4_locations_if([, yylocationp])[]b4_user_args[); + YYFPRINTF (yyoutput, ")"); +}]dnl +]) + + +## ---------------- ## +## api.value.type. ## +## ---------------- ## + + +# ---------------------- # +# api.value.type=union. # +# ---------------------- # + +# b4_symbol_type_register(SYMBOL-NUM) +# ----------------------------------- +# Symbol SYMBOL-NUM has a type (for variant) instead of a type-tag. +# Extend the definition of %union's body with a field of that type, +# and extend the symbol's "type" field to point to the field name, +# instead of the type name. +m4_define([b4_symbol_type_register], +[m4_define([b4_symbol($1, type_tag)], + [b4_symbol_if([$1], [has_id], + [b4_symbol([$1], [id])], + [yytype_[]b4_symbol([$1], [number])])])dnl +m4_append([b4_user_union_members], +m4_expand([ + b4_symbol_tag_comment([$1])dnl + b4_symbol([$1], [type]) b4_symbol([$1], [type_tag]);])) +]) + + +# b4_type_define_tag(SYMBOL1-NUM, ...) +# ------------------------------------ +# For the batch of symbols SYMBOL1-NUM... (which all have the same +# type), enhance the %union definition for each of them, and set +# there "type" field to the field tag name, instead of the type name. +m4_define([b4_type_define_tag], +[b4_symbol_if([$1], [has_type], + [m4_map([b4_symbol_type_register], [$@])]) +]) + + +# b4_symbol_value_union(VAL, [TYPE]) +# ---------------------------------- +# Same of b4_symbol_value, but when api.value.type=union. +m4_define([b4_symbol_value_union], +[m4_ifval([$2], + [(*($2*)(&$1))], + [$1])]) +]) + + +# b4_value_type_setup_union +# ------------------------- +# Setup support for api.value.type=union. Symbols are defined with a +# type instead of a union member name: build the corresponding union, +# and give the symbols their tag. +m4_define([b4_value_type_setup_union], +[m4_define([b4_union_members]) +b4_type_foreach([b4_type_define_tag]) +m4_copy_force([b4_symbol_value_union], [b4_symbol_value]) +]) + + +# ---------------- # +# api.value.type. # +# ---------------- # + + +# b4_value_type_setup_variant +# --------------------------- +# Setup support for api.value.type=variant. By default, fail, specialized +# by other skeletons. +m4_define([b4_value_type_setup_variant], +[b4_complain_at(b4_percent_define_get_loc([[api.value.type]]), + [['%s' does not support '%s']], + [b4_skeleton], + [%define api.value.type variant])]) + + +# _b4_value_type_setup_keyword +# ---------------------------- +# api.value.type is defined with a keyword/string syntax. Check if +# that is properly defined, and prepare its use. +m4_define([_b4_value_type_setup_keyword], +[b4_percent_define_check_values([[[[api.value.type]], + [[none]], + [[union]], + [[union-directive]], + [[variant]], + [[yystype]]]])dnl +m4_case(b4_percent_define_get([[api.value.type]]), + [union], [b4_value_type_setup_union], + [variant], [b4_value_type_setup_variant])]) + + +# b4_value_type_setup +# ------------------- +# Check if api.value.type is properly defined, and possibly prepare +# its use. +b4_define_silent([b4_value_type_setup], +[# Define default value. +b4_percent_define_ifdef([[api.value.type]], [], +[# %union => api.value.type=union-directive +m4_ifdef([b4_union_members], +[m4_define([b4_percent_define_kind(api.value.type)], [keyword]) +m4_define([b4_percent_define(api.value.type)], [union-directive])], +[# no tag seen => api.value.type={int} +m4_if(b4_tag_seen_flag, 0, +[m4_define([b4_percent_define_kind(api.value.type)], [code]) +m4_define([b4_percent_define(api.value.type)], [int])], +[# otherwise api.value.type=yystype +m4_define([b4_percent_define_kind(api.value.type)], [keyword]) +m4_define([b4_percent_define(api.value.type)], [yystype])])])]) + +# Set up. +m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), + [keyword\|string], [_b4_value_type_setup_keyword]) +]) + + +## -------------- ## +## Declarations. ## +## -------------- ## + + +# b4_value_type_define +# -------------------- +m4_define([b4_value_type_define], +[b4_value_type_setup[]dnl +/* Value type. */ +m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), +[code], +[[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED +typedef ]b4_percent_define_get([[api.value.type]])[ ]b4_api_PREFIX[STYPE; +# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1 +# define ]b4_api_PREFIX[STYPE_IS_DECLARED 1 +#endif +]], +[m4_bmatch(b4_percent_define_get([[api.value.type]]), +[union\|union-directive], +[[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED +typedef union ]b4_union_name[ ]b4_api_PREFIX[STYPE; +union ]b4_union_name[ +{ +]b4_user_union_members[ +}; +# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1 +# define ]b4_api_PREFIX[STYPE_IS_DECLARED 1 +#endif +]])])]) + + +# b4_location_type_define +# ----------------------- +m4_define([b4_location_type_define], +[[/* Location type. */ +#if ! defined ]b4_api_PREFIX[LTYPE && ! defined ]b4_api_PREFIX[LTYPE_IS_DECLARED +typedef struct ]b4_api_PREFIX[LTYPE ]b4_api_PREFIX[LTYPE; +struct ]b4_api_PREFIX[LTYPE +{ + int first_line; + int first_column; + int last_line; + int last_column; +}; +# define ]b4_api_PREFIX[LTYPE_IS_DECLARED 1 +# define ]b4_api_PREFIX[LTYPE_IS_TRIVIAL 1 +#endif +]]) + + +# b4_declare_yylstype +# ------------------- +# Declarations that might either go into the header (if --defines) or +# in the parser body. Declare YYSTYPE/YYLTYPE, and yylval/yylloc. +m4_define([b4_declare_yylstype], +[b4_value_type_define[]b4_locations_if([ +b4_location_type_define]) + +b4_pure_if([], [[extern ]b4_api_PREFIX[STYPE ]b4_prefix[lval; +]b4_locations_if([[extern ]b4_api_PREFIX[LTYPE ]b4_prefix[lloc;]])])[]dnl +]) + + +# b4_YYDEBUG_define +# ----------------- +m4_define([b4_YYDEBUG_define], +[[/* Debug traces. */ +]m4_if(b4_api_prefix, [yy], +[[#ifndef YYDEBUG +# define YYDEBUG ]b4_parse_trace_if([1], [0])[ +#endif]], +[[#ifndef ]b4_api_PREFIX[DEBUG +# if defined YYDEBUG +#if YYDEBUG +# define ]b4_api_PREFIX[DEBUG 1 +# else +# define ]b4_api_PREFIX[DEBUG 0 +# endif +# else /* ! defined YYDEBUG */ +# define ]b4_api_PREFIX[DEBUG ]b4_parse_trace_if([1], [0])[ +# endif /* ! defined YYDEBUG */ +#endif /* ! defined ]b4_api_PREFIX[DEBUG */]])[]dnl +]) + +# b4_declare_yydebug +# ------------------ +m4_define([b4_declare_yydebug], +[b4_YYDEBUG_define[ +#if ]b4_api_PREFIX[DEBUG +extern int ]b4_prefix[debug; +#endif][]dnl +]) + +# b4_yylloc_default_define +# ------------------------ +# Define YYLLOC_DEFAULT. +m4_define([b4_yylloc_default_define], +[[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (0) +#endif +]]) + +# b4_yy_location_print_define +# --------------------------- +# Define YY_LOCATION_PRINT. +m4_define([b4_yy_location_print_define], +[b4_locations_if([[ +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +#ifndef YY_LOCATION_PRINT +# if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL + +/* Print *YYLOCP on YYO. Private, do not rely on its existence. */ + +__attribute__((__unused__)) +]b4_function_define([yy_location_print_], + [static unsigned], + [[FILE *yyo], [yyo]], + [[YYLTYPE const * const yylocp], [yylocp]])[ +{ + unsigned res = 0; + int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0; + if (0 <= yylocp->first_line) + { + res += YYFPRINTF (yyo, "%d", yylocp->first_line); + if (0 <= yylocp->first_column) + res += YYFPRINTF (yyo, ".%d", yylocp->first_column); + } + if (0 <= yylocp->last_line) + { + if (yylocp->first_line < yylocp->last_line) + { + res += YYFPRINTF (yyo, "-%d", yylocp->last_line); + if (0 <= end_col) + res += YYFPRINTF (yyo, ".%d", end_col); + } + else if (0 <= end_col && yylocp->first_column < end_col) + res += YYFPRINTF (yyo, "-%d", end_col); + } + return res; + } + +# define YY_LOCATION_PRINT(File, Loc) \ + yy_location_print_ (File, &(Loc)) + +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif]], +[[/* This macro is provided for backward compatibility. */ +#ifndef YY_LOCATION_PRINT +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +#endif]]) +]) + +# b4_yyloc_default +# ---------------- +# Expand to a possible default value for yylloc. +m4_define([b4_yyloc_default], +[[ +# if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL + = { ]m4_join([, ], + m4_defn([b4_location_initial_line]), + m4_defn([b4_location_initial_column]), + m4_defn([b4_location_initial_line]), + m4_defn([b4_location_initial_column]))[ } +# endif +]]) diff --git a/gnuwin32/bin/data/glr.c b/gnuwin32/bin/data/glr.c new file mode 100644 index 00000000..ff70890f --- /dev/null +++ b/gnuwin32/bin/data/glr.c @@ -0,0 +1,2563 @@ + -*- C -*- + +# GLR skeleton for Bison + +# Copyright (C) 2002-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +# If we are loaded by glr.cc, do not override c++.m4 definitions by +# those of c.m4. +m4_if(b4_skeleton, ["glr.c"], + [m4_include(b4_pkgdatadir/[c.m4])]) + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Stack parameters. +m4_define_default([b4_stack_depth_max], [10000]) +m4_define_default([b4_stack_depth_init], [200]) + + + +## ------------------------ ## +## Pure/impure interfaces. ## +## ------------------------ ## + +b4_define_flag_if([pure]) +# If glr.cc is including this file and thus has already set b4_pure_flag, +# do not change the value of b4_pure_flag, and do not record a use of api.pure. +m4_ifndef([b4_pure_flag], +[b4_percent_define_default([[api.pure]], [[false]]) + m4_define([b4_pure_flag], + [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])]) + +# b4_user_formals +# --------------- +# The possible parse-params formal arguments preceded by a comma. +# +# This is not shared with yacc.c in c.m4 because GLR relies on ISO C +# formal argument declarations. +m4_define([b4_user_formals], +[m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])]) + + +# b4_yyerror_args +# --------------- +# Optional effective arguments passed to yyerror: user args plus yylloc, and +# a trailing comma. +m4_define([b4_yyerror_args], +[b4_pure_if([b4_locations_if([yylocp, ])])dnl +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])]) + + +# b4_lyyerror_args +# ---------------- +# Same as above, but on the lookahead, hence &yylloc instead of yylocp. +m4_define([b4_lyyerror_args], +[b4_pure_if([b4_locations_if([&yylloc, ])])dnl +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])]) + + +# b4_pure_args +# ------------ +# Same as b4_yyerror_args, but with a leading comma. +m4_define([b4_pure_args], +[b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args]) + + +# b4_lpure_args +# ------------- +# Same as above, but on the lookahead, hence &yylloc instead of yylocp. +m4_define([b4_lpure_args], +[b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args]) + + + +# b4_pure_formals +# --------------- +# Arguments passed to yyerror: user formals plus yylocp with leading comma. +m4_define([b4_pure_formals], +[b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals]) + + +# b4_locuser_formals(LOC = yylocp) +# -------------------------------- +m4_define([b4_locuser_formals], +[b4_locations_if([, YYLTYPE *m4_default([$1], [yylocp])])[]b4_user_formals]) + + +# b4_locuser_args(LOC = yylocp) +# ----------------------------- +m4_define([b4_locuser_args], +[b4_locations_if([, m4_default([$1], [yylocp])])[]b4_user_args]) + + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_lhs_value([TYPE]) +# -------------------- +# Expansion of $$. +m4_define([b4_lhs_value], +[b4_symbol_value([(*yyvalp)], [$1])]) + + +# b4_rhs_data(RULE-LENGTH, NUM) +# ----------------------------- +# Expand to the semantic stack place that contains value and location +# of symbol number NUM in a rule of length RULE-LENGTH. +m4_define([b4_rhs_data], +[((yyGLRStackItem const *)yyvsp)@{YYFILL (b4_subtract([$2], [$1]))@}.yystate]) + + +# b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) +# -------------------------------------- +# Expansion of $NUM, where the current rule has RULE-LENGTH +# symbols on RHS. +m4_define([b4_rhs_value], +[b4_symbol_value([b4_rhs_data([$1], [$2]).yysemantics.yysval], [$3])]) + + + +## ----------- ## +## Locations. ## +## ----------- ## + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(*yylocp)]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[(b4_rhs_data([$1], [$2]).yyloc)]) + + +## -------------- ## +## Declarations. ## +## -------------- ## + +# b4_shared_declarations +# ---------------------- +# Declaration that might either go into the header (if --defines) +# or open coded in the parser body. glr.cc has its own definition. +m4_if(b4_skeleton, ["glr.c"], +[m4_define([b4_shared_declarations], +[b4_declare_yydebug[ +]b4_percent_code_get([[requires]])[ +]b4_token_enums[ +]b4_declare_yylstype[ +]b4_function_declare(b4_prefix[parse], [int], b4_parse_param)[ +]b4_percent_code_get([[provides]])[]dnl +]) +]) + +## -------------- ## +## Output files. ## +## -------------- ## + +b4_output_begin([b4_parser_file_name]) +b4_copyright([Skeleton implementation for Bison GLR parsers in C], + [2002-2013])[ + +/* C GLR parser skeleton written by Paul Hilfinger. */ + +]b4_identification + +b4_percent_code_get([[top]])[ +]m4_if(b4_api_prefix, [yy], [], +[[/* Substitute the type names. */ +#define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[ +#define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[ +]m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */ +#define yyparse ]b4_prefix[parse +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yydebug ]b4_prefix[debug +]]b4_pure_if([], [[ +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char +#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])]))[ + +/* First part of user declarations. */ +]b4_user_pre_prologue[ + +]b4_null_define[ + +]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]], + [b4_shared_declarations])[ + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[ +#endif + +/* Default (constant) value used for initialization for null + right-hand sides. Unlike the standard yacc.c template, here we set + the default value of $$ to a zeroed-out value. Since the default + value is undefined, this behavior is technically correct. */ +static YYSTYPE yyval_default;]b4_locations_if([[ +static YYLTYPE yyloc_default][]b4_yyloc_default;])[ + +/* Copy the second part of user declarations. */ +]b4_user_post_prologue +b4_percent_code_get[]dnl + +[#include +#include +#include + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif + +#ifndef YYFREE +# define YYFREE free +#endif +#ifndef YYMALLOC +# define YYMALLOC malloc +#endif +#ifndef YYREALLOC +# define YYREALLOC realloc +#endif + +#define YYSIZEMAX ((size_t) -1) + +#ifdef __cplusplus + typedef bool yybool; +#else + typedef unsigned char yybool; +#endif +#define yytrue 1 +#define yyfalse 0 + +#ifndef YYSETJMP +# include +# define YYJMP_BUF jmp_buf +# define YYSETJMP(Env) setjmp (Env) +/* Pacify clang. */ +# define YYLONGJMP(Env, Val) (longjmp (Env, Val), YYASSERT (0)) +#endif + +]b4_attribute_define[ + +#ifndef YYASSERT +# define YYASSERT(Condition) ((void) ((Condition) || (abort (), 0))) +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL ]b4_final_state_number[ +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST ]b4_last[ + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS ]b4_tokens_number[ +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS ]b4_nterms_number[ +/* YYNRULES -- Number of rules. */ +#define YYNRULES ]b4_rules_number[ +/* YYNRULES -- Number of states. */ +#define YYNSTATES ]b4_states_number[ +/* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */ +#define YYMAXRHS ]b4_r2_max[ +/* YYMAXLEFT -- Maximum number of symbols to the left of a handle + accessed by $0, $-1, etc., in any rule. */ +#define YYMAXLEFT ]b4_max_left_semantic_context[ + +/* YYTRANSLATE(X) -- Bison symbol number corresponding to X. */ +#define YYUNDEFTOK ]b4_undef_token_number[ +#define YYMAXUTOK ]b4_user_token_number_max[ + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const ]b4_int_type_for([b4_translate])[ yytranslate[] = +{ + ]b4_translate[ +}; + +#if ]b4_api_PREFIX[DEBUG +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const ]b4_int_type_for([b4_rline])[ yyrline[] = +{ + ]b4_rline[ +}; +#endif + +#if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[ +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + ]b4_tname[ +}; +#endif + +#define YYPACT_NINF ]b4_pact_ninf[ +#define YYTABLE_NINF ]b4_table_ninf[ + +]b4_parser_tables_define[ + +/* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ +static const ]b4_int_type_for([b4_dprec])[ yydprec[] = +{ + ]b4_dprec[ +}; + +/* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ +static const ]b4_int_type_for([b4_merger])[ yymerger[] = +{ + ]b4_merger[ +}; + +/* YYIMMEDIATE[RULE-NUM] -- True iff rule #RULE-NUM is not to be deferred, as + in the case of predicates. */ +static const yybool yyimmediate[] = +{ + ]b4_immediate[ +}; + +/* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of + list of conflicting reductions corresponding to action entry for + state STATE-NUM in yytable. 0 means no conflicts. The list in + yyconfl is terminated by a rule number of 0. */ +static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = +{ + ]b4_conflict_list_heads[ +}; + +/* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by + 0, pointed into by YYCONFLP. */ +]dnl Do not use b4_int_type_for here, since there are places where +dnl pointers onto yyconfl are taken, whose type is "short int *". +dnl We probably ought to introduce a type for confl. +[static const short int yyconfl[] = +{ + ]b4_conflicting_rules[ +}; + +/* Error token number */ +#define YYTERROR 1 + +]b4_locations_if([[ +]b4_yylloc_default_define[ +# define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) +]])[ + +]b4_pure_if( +[ +#undef yynerrs +#define yynerrs (yystackp->yyerrcnt) +#undef yychar +#define yychar (yystackp->yyrawchar) +#undef yylval +#define yylval (yystackp->yyval) +#undef yylloc +#define yylloc (yystackp->yyloc) +m4_if(b4_prefix[], [yy], [], +[#define b4_prefix[]nerrs yynerrs +#define b4_prefix[]char yychar +#define b4_prefix[]lval yylval +#define b4_prefix[]lloc yylloc])], +[YYSTYPE yylval;]b4_locations_if([[ +YYLTYPE yylloc;]])[ + +int yynerrs; +int yychar;])[ + +static const int YYEOF = 0; +static const int YYEMPTY = -2; + +typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; + +#define YYCHK(YYE) \ + do { \ + YYRESULTTAG yychk_flag = YYE; \ + if (yychk_flag != yyok) \ + return yychk_flag; \ + } while (0) + +#if ]b4_api_PREFIX[DEBUG + +# ifndef YYFPRINTF +# define YYFPRINTF fprintf +# endif + +]b4_yy_location_print_define[ + +# define YYDPRINTF(Args) \ + do { \ + if (yydebug) \ + YYFPRINTF Args; \ + } while (0) + +]b4_yy_symbol_print_define[ + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ + do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[); \ + YYFPRINTF (stderr, "\n"); \ + } \ + } while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; + +struct yyGLRStack; +static void yypstack (struct yyGLRStack* yystackp, size_t yyk) + __attribute__ ((__unused__)); +static void yypdumpstack (struct yyGLRStack* yystackp) + __attribute__ ((__unused__)); + +#else /* !]b4_api_PREFIX[DEBUG */ + +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) + +#endif /* !]b4_api_PREFIX[DEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH ]b4_stack_depth_init[ +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH ]b4_stack_depth_max[ +#endif + +/* Minimum number of free items on the stack allowed after an + allocation. This is to allow allocation and initialization + to be completed by functions that call yyexpandGLRStack before the + stack is expanded, thus insuring that all necessary pointers get + properly redirected to new data. */ +#define YYHEADROOM 2 + +#ifndef YYSTACKEXPANDABLE +# define YYSTACKEXPANDABLE 1 +#endif + +#if YYSTACKEXPANDABLE +# define YY_RESERVE_GLRSTACK(Yystack) \ + do { \ + if (Yystack->yyspaceLeft < YYHEADROOM) \ + yyexpandGLRStack (Yystack); \ + } while (0) +#else +# define YY_RESERVE_GLRSTACK(Yystack) \ + do { \ + if (Yystack->yyspaceLeft < YYHEADROOM) \ + yyMemoryExhausted (Yystack); \ + } while (0) +#endif + + +#if YYERROR_VERBOSE + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +yystpcpy (char *yydest, const char *yysrc) +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static size_t +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + size_t yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return strlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +#endif /* !YYERROR_VERBOSE */ + +/** State numbers, as in LALR(1) machine */ +typedef int yyStateNum; + +/** Rule numbers, as in LALR(1) machine */ +typedef int yyRuleNum; + +/** Grammar symbol */ +typedef int yySymbol; + +/** Item references, as in LALR(1) machine */ +typedef short int yyItemNum; + +typedef struct yyGLRState yyGLRState; +typedef struct yyGLRStateSet yyGLRStateSet; +typedef struct yySemanticOption yySemanticOption; +typedef union yyGLRStackItem yyGLRStackItem; +typedef struct yyGLRStack yyGLRStack; + +struct yyGLRState { + /** Type tag: always true. */ + yybool yyisState; + /** Type tag for yysemantics. If true, yysval applies, otherwise + * yyfirstVal applies. */ + yybool yyresolved; + /** Number of corresponding LALR(1) machine state. */ + yyStateNum yylrState; + /** Preceding state in this stack */ + yyGLRState* yypred; + /** Source position of the last token produced by my symbol */ + size_t yyposn; + union { + /** First in a chain of alternative reductions producing the + * non-terminal corresponding to this state, threaded through + * yynext. */ + yySemanticOption* yyfirstVal; + /** Semantic value for this state. */ + YYSTYPE yysval; + } yysemantics;]b4_locations_if([[ + /** Source location for this state. */ + YYLTYPE yyloc;]])[ +}; + +struct yyGLRStateSet { + yyGLRState** yystates; + /** During nondeterministic operation, yylookaheadNeeds tracks which + * stacks have actually needed the current lookahead. During deterministic + * operation, yylookaheadNeeds[0] is not maintained since it would merely + * duplicate yychar != YYEMPTY. */ + yybool* yylookaheadNeeds; + size_t yysize, yycapacity; +}; + +struct yySemanticOption { + /** Type tag: always false. */ + yybool yyisState; + /** Rule number for this reduction */ + yyRuleNum yyrule; + /** The last RHS state in the list of states to be reduced. */ + yyGLRState* yystate; + /** The lookahead for this reduction. */ + int yyrawchar; + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ + /** Next sibling in chain of options. To facilitate merging, + * options are chained in decreasing order by address. */ + yySemanticOption* yynext; +}; + +/** Type of the items in the GLR stack. The yyisState field + * indicates which item of the union is valid. */ +union yyGLRStackItem { + yyGLRState yystate; + yySemanticOption yyoption; +}; + +struct yyGLRStack { + int yyerrState; +]b4_locations_if([[ /* To compute the location of the error token. */ + yyGLRStackItem yyerror_range[3];]])[ +]b4_pure_if( +[ + int yyerrcnt; + int yyrawchar; + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ +])[ + YYJMP_BUF yyexception_buffer; + yyGLRStackItem* yyitems; + yyGLRStackItem* yynextFree; + size_t yyspaceLeft; + yyGLRState* yysplitPoint; + yyGLRState* yylastDeleted; + yyGLRStateSet yytops; +}; + +#if YYSTACKEXPANDABLE +static void yyexpandGLRStack (yyGLRStack* yystackp); +#endif + +static void yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) + __attribute__ ((__noreturn__)); +static void +yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) +{ + if (yymsg != YY_NULL) + yyerror (]b4_yyerror_args[yymsg); + YYLONGJMP (yystackp->yyexception_buffer, 1); +} + +static void yyMemoryExhausted (yyGLRStack* yystackp) + __attribute__ ((__noreturn__)); +static void +yyMemoryExhausted (yyGLRStack* yystackp) +{ + YYLONGJMP (yystackp->yyexception_buffer, 2); +} + +#if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE +/** A printable representation of TOKEN. */ +static inline const char* +yytokenName (yySymbol yytoken) +{ + if (yytoken == YYEMPTY) + return ""; + + return yytname[yytoken]; +} +#endif + +/** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting + * at YYVSP[YYLOW0].yystate.yypred. Leaves YYVSP[YYLOW1].yystate.yypred + * containing the pointer to the next state in the chain. */ +static void yyfillin (yyGLRStackItem *, int, int) __attribute__ ((__unused__)); +static void +yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1) +{ + int i; + yyGLRState *s = yyvsp[yylow0].yystate.yypred; + for (i = yylow0-1; i >= yylow1; i -= 1) + { +#if ]b4_api_PREFIX[DEBUG + yyvsp[i].yystate.yylrState = s->yylrState; +#endif + yyvsp[i].yystate.yyresolved = s->yyresolved; + if (s->yyresolved) + yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval; + else + /* The effect of using yysval or yyloc (in an immediate rule) is + * undefined. */ + yyvsp[i].yystate.yysemantics.yyfirstVal = YY_NULL;]b4_locations_if([[ + yyvsp[i].yystate.yyloc = s->yyloc;]])[ + s = yyvsp[i].yystate.yypred = s->yypred; + } +} + +/* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in + * YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1. + * For convenience, always return YYLOW1. */ +static inline int yyfill (yyGLRStackItem *, int *, int, yybool) + __attribute__ ((__unused__)); +static inline int +yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal) +{ + if (!yynormal && yylow1 < *yylow) + { + yyfillin (yyvsp, *yylow, yylow1); + *yylow = yylow1; + } + return yylow1; +} + +/** Perform user action for rule number YYN, with RHS length YYRHSLEN, + * and top stack item YYVSP. YYLVALP points to place to put semantic + * value ($$), and yylocp points to place for location information + * (@@$). Returns yyok for normal return, yyaccept for YYACCEPT, + * yyerr for YYERROR, yyabort for YYABORT. */ +static YYRESULTTAG +yyuserAction (yyRuleNum yyn, size_t yyrhslen, yyGLRStackItem* yyvsp, + yyGLRStack* yystackp, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + yybool yynormal __attribute__ ((__unused__)) = + (yystackp->yysplitPoint == YY_NULL); + int yylow; +]b4_parse_param_use([yyvalp], [yylocp])dnl +[ YYUSE (yyrhslen); +# undef yyerrok +# define yyerrok (yystackp->yyerrState = 0) +# undef YYACCEPT +# define YYACCEPT return yyaccept +# undef YYABORT +# define YYABORT return yyabort +# undef YYERROR +# define YYERROR return yyerrok, yyerr +# undef YYRECOVERING +# define YYRECOVERING() (yystackp->yyerrState != 0) +# undef yyclearin +# define yyclearin (yychar = YYEMPTY) +# undef YYFILL +# define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal) +# undef YYBACKUP +# define YYBACKUP(Token, Value) \ + return yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")), \ + yyerrok, yyerr + + yylow = 1; + if (yyrhslen == 0) + *yyvalp = yyval_default; + else + *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;]b4_locations_if([[ + YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); + yystackp->yyerror_range[1].yystate.yyloc = *yylocp; +]])[ + switch (yyn) + { + ]b4_user_actions[ + default: break; + } + + return yyok; +# undef yyerrok +# undef YYABORT +# undef YYACCEPT +# undef YYERROR +# undef YYBACKUP +# undef yyclearin +# undef YYRECOVERING +} + + +static void +yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) +{ + YYUSE (yy0); + YYUSE (yy1); + + switch (yyn) + { +]b4_mergers[ + default: break; + } +} + + /* Bison grammar-table manipulation. */ + +]b4_yydestruct_define[ + +/** Number of symbols composing the right hand side of rule #RULE. */ +static inline int +yyrhsLength (yyRuleNum yyrule) +{ + return yyr2[yyrule]; +} + +static void +yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[) +{ + if (yys->yyresolved) + yydestruct (yymsg, yystos[yys->yylrState], + &yys->yysemantics.yysval]b4_locuser_args([&yys->yyloc])[); + else + { +#if ]b4_api_PREFIX[DEBUG + if (yydebug) + { + if (yys->yysemantics.yyfirstVal) + YYFPRINTF (stderr, "%s unresolved ", yymsg); + else + YYFPRINTF (stderr, "%s incomplete ", yymsg); + yy_symbol_print (stderr, yystos[yys->yylrState], + YY_NULL]b4_locuser_args([&yys->yyloc])[); + YYFPRINTF (stderr, "\n"); + } +#endif + + if (yys->yysemantics.yyfirstVal) + { + yySemanticOption *yyoption = yys->yysemantics.yyfirstVal; + yyGLRState *yyrh; + int yyn; + for (yyrh = yyoption->yystate, yyn = yyrhsLength (yyoption->yyrule); + yyn > 0; + yyrh = yyrh->yypred, yyn -= 1) + yydestroyGLRState (yymsg, yyrh]b4_user_args[); + } + } +} + +/** Left-hand-side symbol for rule #YYRULE. */ +static inline yySymbol +yylhsNonterm (yyRuleNum yyrule) +{ + return yyr1[yyrule]; +} + +#define yypact_value_is_default(Yystate) \ + ]b4_table_value_equals([[pact]], [[Yystate]], [b4_pact_ninf])[ + +/** True iff LR state YYSTATE has only a default reduction (regardless + * of token). */ +static inline yybool +yyisDefaultedState (yyStateNum yystate) +{ + return yypact_value_is_default (yypact[yystate]); +} + +/** The default reduction for YYSTATE, assuming it has one. */ +static inline yyRuleNum +yydefaultAction (yyStateNum yystate) +{ + return yydefact[yystate]; +} + +#define yytable_value_is_error(Yytable_value) \ + ]b4_table_value_equals([[table]], [[Yytable_value]], [b4_table_ninf])[ + +/** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN. + * Result R means + * R < 0: Reduce on rule -R. + * R = 0: Error. + * R > 0: Shift to state R. + * Set *YYCONFLICTS to a pointer into yyconfl to a 0-terminated list + * of conflicting reductions. + */ +static inline void +yygetLRActions (yyStateNum yystate, int yytoken, + int* yyaction, const short int** yyconflicts) +{ + int yyindex = yypact[yystate] + yytoken; + if (yypact_value_is_default (yypact[yystate]) + || yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) + { + *yyaction = -yydefact[yystate]; + *yyconflicts = yyconfl; + } + else if (! yytable_value_is_error (yytable[yyindex])) + { + *yyaction = yytable[yyindex]; + *yyconflicts = yyconfl + yyconflp[yyindex]; + } + else + { + *yyaction = 0; + *yyconflicts = yyconfl + yyconflp[yyindex]; + } +} + +static inline yyStateNum +yyLRgotoState (yyStateNum yystate, yySymbol yylhs) +{ + int yyr = yypgoto[yylhs - YYNTOKENS] + yystate; + if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) + return yytable[yyr]; + else + return yydefgoto[yylhs - YYNTOKENS]; +} + +static inline yybool +yyisShiftAction (int yyaction) +{ + return 0 < yyaction; +} + +static inline yybool +yyisErrorAction (int yyaction) +{ + return yyaction == 0; +} + + /* GLRStates */ + +/** Return a fresh GLRStackItem in YYSTACKP. The item is an LR state + * if YYISSTATE, and otherwise a semantic option. Callers should call + * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient + * headroom. */ + +static inline yyGLRStackItem* +yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState) +{ + yyGLRStackItem* yynewItem = yystackp->yynextFree; + yystackp->yyspaceLeft -= 1; + yystackp->yynextFree += 1; + yynewItem->yystate.yyisState = yyisState; + return yynewItem; +} + +/** Add a new semantic action that will execute the action for rule + * YYRULE on the semantic values in YYRHS to the list of + * alternative actions for YYSTATE. Assumes that YYRHS comes from + * stack #YYK of *YYSTACKP. */ +static void +yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate, + yyGLRState* yyrhs, yyRuleNum yyrule) +{ + yySemanticOption* yynewOption = + &yynewGLRStackItem (yystackp, yyfalse)->yyoption; + yynewOption->yystate = yyrhs; + yynewOption->yyrule = yyrule; + if (yystackp->yytops.yylookaheadNeeds[yyk]) + { + yynewOption->yyrawchar = yychar; + yynewOption->yyval = yylval;]b4_locations_if([ + yynewOption->yyloc = yylloc;])[ + } + else + yynewOption->yyrawchar = YYEMPTY; + yynewOption->yynext = yystate->yysemantics.yyfirstVal; + yystate->yysemantics.yyfirstVal = yynewOption; + + YY_RESERVE_GLRSTACK (yystackp); +} + + /* GLRStacks */ + +/** Initialize YYSET to a singleton set containing an empty stack. */ +static yybool +yyinitStateSet (yyGLRStateSet* yyset) +{ + yyset->yysize = 1; + yyset->yycapacity = 16; + yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]); + if (! yyset->yystates) + return yyfalse; + yyset->yystates[0] = YY_NULL; + yyset->yylookaheadNeeds = + (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]); + if (! yyset->yylookaheadNeeds) + { + YYFREE (yyset->yystates); + return yyfalse; + } + return yytrue; +} + +static void yyfreeStateSet (yyGLRStateSet* yyset) +{ + YYFREE (yyset->yystates); + YYFREE (yyset->yylookaheadNeeds); +} + +/** Initialize *YYSTACKP to a single empty stack, with total maximum + * capacity for all stacks of YYSIZE. */ +static yybool +yyinitGLRStack (yyGLRStack* yystackp, size_t yysize) +{ + yystackp->yyerrState = 0; + yynerrs = 0; + yystackp->yyspaceLeft = yysize; + yystackp->yyitems = + (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystackp->yynextFree[0]); + if (!yystackp->yyitems) + return yyfalse; + yystackp->yynextFree = yystackp->yyitems; + yystackp->yysplitPoint = YY_NULL; + yystackp->yylastDeleted = YY_NULL; + return yyinitStateSet (&yystackp->yytops); +} + + +#if YYSTACKEXPANDABLE +# define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \ + &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE + +/** If *YYSTACKP is expandable, extend it. WARNING: Pointers into the + stack from outside should be considered invalid after this call. + We always expand when there are 1 or fewer items left AFTER an + allocation, so that we can avoid having external pointers exist + across an allocation. */ +static void +yyexpandGLRStack (yyGLRStack* yystackp) +{ + yyGLRStackItem* yynewItems; + yyGLRStackItem* yyp0, *yyp1; + size_t yynewSize; + size_t yyn; + size_t yysize = yystackp->yynextFree - yystackp->yyitems; + if (YYMAXDEPTH - YYHEADROOM < yysize) + yyMemoryExhausted (yystackp); + yynewSize = 2*yysize; + if (YYMAXDEPTH < yynewSize) + yynewSize = YYMAXDEPTH; + yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]); + if (! yynewItems) + yyMemoryExhausted (yystackp); + for (yyp0 = yystackp->yyitems, yyp1 = yynewItems, yyn = yysize; + 0 < yyn; + yyn -= 1, yyp0 += 1, yyp1 += 1) + { + *yyp1 = *yyp0; + if (*(yybool *) yyp0) + { + yyGLRState* yys0 = &yyp0->yystate; + yyGLRState* yys1 = &yyp1->yystate; + if (yys0->yypred != YY_NULL) + yys1->yypred = + YYRELOC (yyp0, yyp1, yys0->yypred, yystate); + if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != YY_NULL) + yys1->yysemantics.yyfirstVal = + YYRELOC (yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); + } + else + { + yySemanticOption* yyv0 = &yyp0->yyoption; + yySemanticOption* yyv1 = &yyp1->yyoption; + if (yyv0->yystate != YY_NULL) + yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate); + if (yyv0->yynext != YY_NULL) + yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption); + } + } + if (yystackp->yysplitPoint != YY_NULL) + yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems, + yystackp->yysplitPoint, yystate); + + for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1) + if (yystackp->yytops.yystates[yyn] != YY_NULL) + yystackp->yytops.yystates[yyn] = + YYRELOC (yystackp->yyitems, yynewItems, + yystackp->yytops.yystates[yyn], yystate); + YYFREE (yystackp->yyitems); + yystackp->yyitems = yynewItems; + yystackp->yynextFree = yynewItems + yysize; + yystackp->yyspaceLeft = yynewSize - yysize; +} +#endif + +static void +yyfreeGLRStack (yyGLRStack* yystackp) +{ + YYFREE (yystackp->yyitems); + yyfreeStateSet (&yystackp->yytops); +} + +/** Assuming that YYS is a GLRState somewhere on *YYSTACKP, update the + * splitpoint of *YYSTACKP, if needed, so that it is at least as deep as + * YYS. */ +static inline void +yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys) +{ + if (yystackp->yysplitPoint != YY_NULL && yystackp->yysplitPoint > yys) + yystackp->yysplitPoint = yys; +} + +/** Invalidate stack #YYK in *YYSTACKP. */ +static inline void +yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk) +{ + if (yystackp->yytops.yystates[yyk] != YY_NULL) + yystackp->yylastDeleted = yystackp->yytops.yystates[yyk]; + yystackp->yytops.yystates[yyk] = YY_NULL; +} + +/** Undelete the last stack in *YYSTACKP that was marked as deleted. Can + only be done once after a deletion, and only when all other stacks have + been deleted. */ +static void +yyundeleteLastStack (yyGLRStack* yystackp) +{ + if (yystackp->yylastDeleted == YY_NULL || yystackp->yytops.yysize != 0) + return; + yystackp->yytops.yystates[0] = yystackp->yylastDeleted; + yystackp->yytops.yysize = 1; + YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n")); + yystackp->yylastDeleted = YY_NULL; +} + +static inline void +yyremoveDeletes (yyGLRStack* yystackp) +{ + size_t yyi, yyj; + yyi = yyj = 0; + while (yyj < yystackp->yytops.yysize) + { + if (yystackp->yytops.yystates[yyi] == YY_NULL) + { + if (yyi == yyj) + { + YYDPRINTF ((stderr, "Removing dead stacks.\n")); + } + yystackp->yytops.yysize -= 1; + } + else + { + yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi]; + /* In the current implementation, it's unnecessary to copy + yystackp->yytops.yylookaheadNeeds[yyi] since, after + yyremoveDeletes returns, the parser immediately either enters + deterministic operation or shifts a token. However, it doesn't + hurt, and the code might evolve to need it. */ + yystackp->yytops.yylookaheadNeeds[yyj] = + yystackp->yytops.yylookaheadNeeds[yyi]; + if (yyj != yyi) + { + YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n", + (unsigned long int) yyi, (unsigned long int) yyj)); + } + yyj += 1; + } + yyi += 1; + } +} + +/** Shift to a new state on stack #YYK of *YYSTACKP, corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with (resolved) semantic + * value *YYVALP and source location *YYLOCP. */ +static inline void +yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, + size_t yyposn, + YYSTYPE* yyvalp]b4_locations_if([, YYLTYPE* yylocp])[) +{ + yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; + + yynewState->yylrState = yylrState; + yynewState->yyposn = yyposn; + yynewState->yyresolved = yytrue; + yynewState->yypred = yystackp->yytops.yystates[yyk]; + yynewState->yysemantics.yysval = *yyvalp;]b4_locations_if([ + yynewState->yyloc = *yylocp;])[ + yystackp->yytops.yystates[yyk] = yynewState; + + YY_RESERVE_GLRSTACK (yystackp); +} + +/** Shift stack #YYK of *YYSTACKP, to a new state corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with the (unresolved) + * semantic value of YYRHS under the action for YYRULE. */ +static inline void +yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, + size_t yyposn, yyGLRState* yyrhs, yyRuleNum yyrule) +{ + yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; + + yynewState->yylrState = yylrState; + yynewState->yyposn = yyposn; + yynewState->yyresolved = yyfalse; + yynewState->yypred = yystackp->yytops.yystates[yyk]; + yynewState->yysemantics.yyfirstVal = YY_NULL; + yystackp->yytops.yystates[yyk] = yynewState; + + /* Invokes YY_RESERVE_GLRSTACK. */ + yyaddDeferredAction (yystackp, yyk, yynewState, yyrhs, yyrule); +} + +#if !]b4_api_PREFIX[DEBUG +# define YY_REDUCE_PRINT(Args) +#else +# define YY_REDUCE_PRINT(Args) \ +do { \ + if (yydebug) \ + yy_reduce_print Args; \ +} while (0) + +/*----------------------------------------------------------------------. +| Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. | +`----------------------------------------------------------------------*/ + +static inline void +yy_reduce_print (int yynormal, yyGLRStackItem* yyvsp, size_t yyk, + yyRuleNum yyrule]b4_user_formals[) +{ + int yynrhs = yyrhsLength (yyrule);]b4_locations_if([ + int yylow = 1;])[ + int yyi; + YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n", + (unsigned long int) yyk, yyrule - 1, + (unsigned long int) yyrline[yyrule]); + if (! yynormal) + yyfillin (yyvsp, 1, -yynrhs); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, + yystos[yyvsp[yyi - yynrhs + 1].yystate.yylrState], + &yyvsp[yyi - yynrhs + 1].yystate.yysemantics.yysval + ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl + b4_user_args[); + if (!yyvsp[yyi - yynrhs + 1].yystate.yyresolved) + YYFPRINTF (stderr, " (unresolved)"); + YYFPRINTF (stderr, "\n"); + } +} +#endif + +/** Pop the symbols consumed by reduction #YYRULE from the top of stack + * #YYK of *YYSTACKP, and perform the appropriate semantic action on their + * semantic values. Assumes that all ambiguities in semantic values + * have been previously resolved. Set *YYVALP to the resulting value, + * and *YYLOCP to the computed location (if any). Return value is as + * for userAction. */ +static inline YYRESULTTAG +yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + int yynrhs = yyrhsLength (yyrule); + + if (yystackp->yysplitPoint == YY_NULL) + { + /* Standard special case: single stack. */ + yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; + YYASSERT (yyk == 0); + yystackp->yynextFree -= yynrhs; + yystackp->yyspaceLeft += yynrhs; + yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate; + YY_REDUCE_PRINT ((1, yyrhs, yyk, yyrule]b4_user_args[)); + return yyuserAction (yyrule, yynrhs, yyrhs, yystackp, + yyvalp]b4_locuser_args[); + } + else + { + int yyi; + yyGLRState* yys; + yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred + = yystackp->yytops.yystates[yyk];]b4_locations_if([[ + if (yynrhs == 0) + /* Set default location. */ + yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[ + for (yyi = 0; yyi < yynrhs; yyi += 1) + { + yys = yys->yypred; + YYASSERT (yys); + } + yyupdateSplit (yystackp, yys); + yystackp->yytops.yystates[yyk] = yys; + YY_REDUCE_PRINT ((0, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyk, yyrule]b4_user_args[)); + return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + yystackp, yyvalp]b4_locuser_args[); + } +} + +/** Pop items off stack #YYK of *YYSTACKP according to grammar rule YYRULE, + * and push back on the resulting nonterminal symbol. Perform the + * semantic action associated with YYRULE and store its value with the + * newly pushed state, if YYFORCEEVAL or if *YYSTACKP is currently + * unambiguous. Otherwise, store the deferred semantic action with + * the new state. If the new state would have an identical input + * position, LR state, and predecessor to an existing state on the stack, + * it is identified with that existing state, eliminating stack #YYK from + * *YYSTACKP. In this case, the semantic value is + * added to the options for the existing state's semantic value. + */ +static inline YYRESULTTAG +yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, + yybool yyforceEval]b4_user_formals[) +{ + size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn; + + if (yyforceEval || yystackp->yysplitPoint == YY_NULL) + { + YYRESULTTAG yyflag; + YYSTYPE yysval;]b4_locations_if([ + YYLTYPE yyloc;])[ + + yyflag = yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[); + if (yyflag == yyerr && yystackp->yysplitPoint != YY_NULL) + { + YYDPRINTF ((stderr, "Parse on stack %lu rejected by rule #%d.\n", + (unsigned long int) yyk, yyrule - 1)); + } + if (yyflag != yyok) + return yyflag; + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc); + yyglrShift (yystackp, yyk, + yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, + yylhsNonterm (yyrule)), + yyposn, &yysval]b4_locations_if([, &yyloc])[); + } + else + { + size_t yyi; + int yyn; + yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk]; + yyStateNum yynewLRState; + + for (yys = yystackp->yytops.yystates[yyk], yyn = yyrhsLength (yyrule); + 0 < yyn; yyn -= 1) + { + yys = yys->yypred; + YYASSERT (yys); + } + yyupdateSplit (yystackp, yys); + yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule)); + YYDPRINTF ((stderr, + "Reduced stack %lu by rule #%d; action deferred. " + "Now in state %d.\n", + (unsigned long int) yyk, yyrule - 1, yynewLRState)); + for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) + if (yyi != yyk && yystackp->yytops.yystates[yyi] != YY_NULL) + { + yyGLRState *yysplit = yystackp->yysplitPoint; + yyGLRState *yyp = yystackp->yytops.yystates[yyi]; + while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn) + { + if (yyp->yylrState == yynewLRState && yyp->yypred == yys) + { + yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule); + yymarkStackDeleted (yystackp, yyk); + YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n", + (unsigned long int) yyk, + (unsigned long int) yyi)); + return yyok; + } + yyp = yyp->yypred; + } + } + yystackp->yytops.yystates[yyk] = yys; + yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule); + } + return yyok; +} + +static size_t +yysplitStack (yyGLRStack* yystackp, size_t yyk) +{ + if (yystackp->yysplitPoint == YY_NULL) + { + YYASSERT (yyk == 0); + yystackp->yysplitPoint = yystackp->yytops.yystates[yyk]; + } + if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity) + { + yyGLRState** yynewStates; + yybool* yynewLookaheadNeeds; + + yynewStates = YY_NULL; + + if (yystackp->yytops.yycapacity + > (YYSIZEMAX / (2 * sizeof yynewStates[0]))) + yyMemoryExhausted (yystackp); + yystackp->yytops.yycapacity *= 2; + + yynewStates = + (yyGLRState**) YYREALLOC (yystackp->yytops.yystates, + (yystackp->yytops.yycapacity + * sizeof yynewStates[0])); + if (yynewStates == YY_NULL) + yyMemoryExhausted (yystackp); + yystackp->yytops.yystates = yynewStates; + + yynewLookaheadNeeds = + (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds, + (yystackp->yytops.yycapacity + * sizeof yynewLookaheadNeeds[0])); + if (yynewLookaheadNeeds == YY_NULL) + yyMemoryExhausted (yystackp); + yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds; + } + yystackp->yytops.yystates[yystackp->yytops.yysize] + = yystackp->yytops.yystates[yyk]; + yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize] + = yystackp->yytops.yylookaheadNeeds[yyk]; + yystackp->yytops.yysize += 1; + return yystackp->yytops.yysize-1; +} + +/** True iff YYY0 and YYY1 represent identical options at the top level. + * That is, they represent the same rule applied to RHS symbols + * that produce the same terminal symbols. */ +static yybool +yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1) +{ + if (yyy0->yyrule == yyy1->yyrule) + { + yyGLRState *yys0, *yys1; + int yyn; + for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, + yyn = yyrhsLength (yyy0->yyrule); + yyn > 0; + yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) + if (yys0->yyposn != yys1->yyposn) + return yyfalse; + return yytrue; + } + else + return yyfalse; +} + +/** Assuming identicalOptions (YYY0,YYY1), destructively merge the + * alternative semantic values for the RHS-symbols of YYY1 and YYY0. */ +static void +yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1) +{ + yyGLRState *yys0, *yys1; + int yyn; + for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, + yyn = yyrhsLength (yyy0->yyrule); + yyn > 0; + yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) + { + if (yys0 == yys1) + break; + else if (yys0->yyresolved) + { + yys1->yyresolved = yytrue; + yys1->yysemantics.yysval = yys0->yysemantics.yysval; + } + else if (yys1->yyresolved) + { + yys0->yyresolved = yytrue; + yys0->yysemantics.yysval = yys1->yysemantics.yysval; + } + else + { + yySemanticOption** yyz0p = &yys0->yysemantics.yyfirstVal; + yySemanticOption* yyz1 = yys1->yysemantics.yyfirstVal; + while (yytrue) + { + if (yyz1 == *yyz0p || yyz1 == YY_NULL) + break; + else if (*yyz0p == YY_NULL) + { + *yyz0p = yyz1; + break; + } + else if (*yyz0p < yyz1) + { + yySemanticOption* yyz = *yyz0p; + *yyz0p = yyz1; + yyz1 = yyz1->yynext; + (*yyz0p)->yynext = yyz; + } + yyz0p = &(*yyz0p)->yynext; + } + yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal; + } + } +} + +/** Y0 and Y1 represent two possible actions to take in a given + * parsing state; return 0 if no combination is possible, + * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */ +static int +yypreference (yySemanticOption* y0, yySemanticOption* y1) +{ + yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule; + int p0 = yydprec[r0], p1 = yydprec[r1]; + + if (p0 == p1) + { + if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1]) + return 0; + else + return 1; + } + if (p0 == 0 || p1 == 0) + return 0; + if (p0 < p1) + return 3; + if (p1 < p0) + return 2; + return 0; +} + +static YYRESULTTAG yyresolveValue (yyGLRState* yys, + yyGLRStack* yystackp]b4_user_formals[); + + +/** Resolve the previous YYN states starting at and including state YYS + * on *YYSTACKP. If result != yyok, some states may have been left + * unresolved possibly with empty semantic option chains. Regardless + * of whether result = yyok, each state has been left with consistent + * data so that yydestroyGLRState can be invoked if necessary. */ +static YYRESULTTAG +yyresolveStates (yyGLRState* yys, int yyn, + yyGLRStack* yystackp]b4_user_formals[) +{ + if (0 < yyn) + { + YYASSERT (yys->yypred); + YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[)); + if (! yys->yyresolved) + YYCHK (yyresolveValue (yys, yystackp]b4_user_args[)); + } + return yyok; +} + +/** Resolve the states for the RHS of YYOPT on *YYSTACKP, perform its + * user action, and return the semantic value and location in *YYVALP + * and *YYLOCP. Regardless of whether result = yyok, all RHS states + * have been destroyed (assuming the user action destroys all RHS + * semantic values if invoked). */ +static YYRESULTTAG +yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + int yynrhs = yyrhsLength (yyopt->yyrule); + YYRESULTTAG yyflag = + yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[); + if (yyflag != yyok) + { + yyGLRState *yys; + for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1) + yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); + return yyflag; + } + + yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[ + if (yynrhs == 0) + /* Set default location. */ + yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[ + { + int yychar_current = yychar; + YYSTYPE yylval_current = yylval;]b4_locations_if([ + YYLTYPE yylloc_current = yylloc;])[ + yychar = yyopt->yyrawchar; + yylval = yyopt->yyval;]b4_locations_if([ + yylloc = yyopt->yyloc;])[ + yyflag = yyuserAction (yyopt->yyrule, yynrhs, + yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + yystackp, yyvalp]b4_locuser_args[); + yychar = yychar_current; + yylval = yylval_current;]b4_locations_if([ + yylloc = yylloc_current;])[ + } + return yyflag; +} + +#if ]b4_api_PREFIX[DEBUG +static void +yyreportTree (yySemanticOption* yyx, int yyindent) +{ + int yynrhs = yyrhsLength (yyx->yyrule); + int yyi; + yyGLRState* yys; + yyGLRState* yystates[1 + YYMAXRHS]; + yyGLRState yyleftmost_state; + + for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred) + yystates[yyi] = yys; + if (yys == YY_NULL) + { + yyleftmost_state.yyposn = 0; + yystates[0] = &yyleftmost_state; + } + else + yystates[0] = yys; + + if (yyx->yystate->yyposn < yys->yyposn + 1) + YYFPRINTF (stderr, "%*s%s -> \n", + yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), + yyx->yyrule - 1); + else + YYFPRINTF (stderr, "%*s%s -> \n", + yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), + yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1), + (unsigned long int) yyx->yystate->yyposn); + for (yyi = 1; yyi <= yynrhs; yyi += 1) + { + if (yystates[yyi]->yyresolved) + { + if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) + YYFPRINTF (stderr, "%*s%s \n", yyindent+2, "", + yytokenName (yystos[yystates[yyi]->yylrState])); + else + YYFPRINTF (stderr, "%*s%s \n", yyindent+2, "", + yytokenName (yystos[yystates[yyi]->yylrState]), + (unsigned long int) (yystates[yyi-1]->yyposn + 1), + (unsigned long int) yystates[yyi]->yyposn); + } + else + yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2); + } +} +#endif + +static YYRESULTTAG +yyreportAmbiguity (yySemanticOption* yyx0, + yySemanticOption* yyx1]b4_pure_formals[) +{ + YYUSE (yyx0); + YYUSE (yyx1); + +#if ]b4_api_PREFIX[DEBUG + YYFPRINTF (stderr, "Ambiguity detected.\n"); + YYFPRINTF (stderr, "Option 1,\n"); + yyreportTree (yyx0, 2); + YYFPRINTF (stderr, "\nOption 2,\n"); + yyreportTree (yyx1, 2); + YYFPRINTF (stderr, "\n"); +#endif + + yyerror (]b4_yyerror_args[YY_("syntax is ambiguous")); + return yyabort; +}]b4_locations_if([[ + +/** Resolve the locations for each of the YYN1 states in *YYSTACKP, + * ending at YYS1. Has no effect on previously resolved states. + * The first semantic option of a state is always chosen. */ +static void +yyresolveLocations (yyGLRState* yys1, int yyn1, + yyGLRStack *yystackp]b4_user_formals[) +{ + if (0 < yyn1) + { + yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[); + if (!yys1->yyresolved) + { + yyGLRStackItem yyrhsloc[1 + YYMAXRHS]; + int yynrhs; + yySemanticOption *yyoption = yys1->yysemantics.yyfirstVal; + YYASSERT (yyoption != YY_NULL); + yynrhs = yyrhsLength (yyoption->yyrule); + if (yynrhs > 0) + { + yyGLRState *yys; + int yyn; + yyresolveLocations (yyoption->yystate, yynrhs, + yystackp]b4_user_args[); + for (yys = yyoption->yystate, yyn = yynrhs; + yyn > 0; + yys = yys->yypred, yyn -= 1) + yyrhsloc[yyn].yystate.yyloc = yys->yyloc; + } + else + { + /* Both yyresolveAction and yyresolveLocations traverse the GSS + in reverse rightmost order. It is only necessary to invoke + yyresolveLocations on a subforest for which yyresolveAction + would have been invoked next had an ambiguity not been + detected. Thus the location of the previous state (but not + necessarily the previous state itself) is guaranteed to be + resolved already. */ + yyGLRState *yyprevious = yyoption->yystate; + yyrhsloc[0].yystate.yyloc = yyprevious->yyloc; + } + { + int yychar_current = yychar; + YYSTYPE yylval_current = yylval; + YYLTYPE yylloc_current = yylloc; + yychar = yyoption->yyrawchar; + yylval = yyoption->yyval; + yylloc = yyoption->yyloc; + YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs); + yychar = yychar_current; + yylval = yylval_current; + yylloc = yylloc_current; + } + } + } +}]])[ + +/** Resolve the ambiguity represented in state YYS in *YYSTACKP, + * perform the indicated actions, and set the semantic value of YYS. + * If result != yyok, the chain of semantic options in YYS has been + * cleared instead or it has been left unmodified except that + * redundant options may have been removed. Regardless of whether + * result = yyok, YYS has been left with consistent data so that + * yydestroyGLRState can be invoked if necessary. */ +static YYRESULTTAG +yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[) +{ + yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal; + yySemanticOption* yybest = yyoptionList; + yySemanticOption** yypp; + yybool yymerge = yyfalse; + YYSTYPE yysval; + YYRESULTTAG yyflag;]b4_locations_if([ + YYLTYPE *yylocp = &yys->yyloc;])[ + + for (yypp = &yyoptionList->yynext; *yypp != YY_NULL; ) + { + yySemanticOption* yyp = *yypp; + + if (yyidenticalOptions (yybest, yyp)) + { + yymergeOptionSets (yybest, yyp); + *yypp = yyp->yynext; + } + else + { + switch (yypreference (yybest, yyp)) + { + case 0:]b4_locations_if([[ + yyresolveLocations (yys, 1, yystackp]b4_user_args[);]])[ + return yyreportAmbiguity (yybest, yyp]b4_pure_args[); + break; + case 1: + yymerge = yytrue; + break; + case 2: + break; + case 3: + yybest = yyp; + yymerge = yyfalse; + break; + default: + /* This cannot happen so it is not worth a YYASSERT (yyfalse), + but some compilers complain if the default case is + omitted. */ + break; + } + yypp = &yyp->yynext; + } + } + + if (yymerge) + { + yySemanticOption* yyp; + int yyprec = yydprec[yybest->yyrule]; + yyflag = yyresolveAction (yybest, yystackp, &yysval]b4_locuser_args[); + if (yyflag == yyok) + for (yyp = yybest->yynext; yyp != YY_NULL; yyp = yyp->yynext) + { + if (yyprec == yydprec[yyp->yyrule]) + { + YYSTYPE yysval_other;]b4_locations_if([ + YYLTYPE yydummy;])[ + yyflag = yyresolveAction (yyp, yystackp, &yysval_other]b4_locuser_args([&yydummy])[); + if (yyflag != yyok) + { + yydestruct ("Cleanup: discarding incompletely merged value for", + yystos[yys->yylrState], + &yysval]b4_locuser_args[); + break; + } + yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other); + } + } + } + else + yyflag = yyresolveAction (yybest, yystackp, &yysval]b4_locuser_args([yylocp])[); + + if (yyflag == yyok) + { + yys->yyresolved = yytrue; + yys->yysemantics.yysval = yysval; + } + else + yys->yysemantics.yyfirstVal = YY_NULL; + return yyflag; +} + +static YYRESULTTAG +yyresolveStack (yyGLRStack* yystackp]b4_user_formals[) +{ + if (yystackp->yysplitPoint != YY_NULL) + { + yyGLRState* yys; + int yyn; + + for (yyn = 0, yys = yystackp->yytops.yystates[0]; + yys != yystackp->yysplitPoint; + yys = yys->yypred, yyn += 1) + continue; + YYCHK (yyresolveStates (yystackp->yytops.yystates[0], yyn, yystackp + ]b4_user_args[)); + } + return yyok; +} + +static void +yycompressStack (yyGLRStack* yystackp) +{ + yyGLRState* yyp, *yyq, *yyr; + + if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == YY_NULL) + return; + + for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = YY_NULL; + yyp != yystackp->yysplitPoint; + yyr = yyp, yyp = yyq, yyq = yyp->yypred) + yyp->yypred = yyr; + + yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems; + yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1; + yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems; + yystackp->yysplitPoint = YY_NULL; + yystackp->yylastDeleted = YY_NULL; + + while (yyr != YY_NULL) + { + yystackp->yynextFree->yystate = *yyr; + yyr = yyr->yypred; + yystackp->yynextFree->yystate.yypred = &yystackp->yynextFree[-1].yystate; + yystackp->yytops.yystates[0] = &yystackp->yynextFree->yystate; + yystackp->yynextFree += 1; + yystackp->yyspaceLeft -= 1; + } +} + +static YYRESULTTAG +yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, + size_t yyposn]b4_pure_formals[) +{ + while (yystackp->yytops.yystates[yyk] != YY_NULL) + { + yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState; + YYDPRINTF ((stderr, "Stack %lu Entering state %d\n", + (unsigned long int) yyk, yystate)); + + YYASSERT (yystate != YYFINAL); + + if (yyisDefaultedState (yystate)) + { + YYRESULTTAG yyflag; + yyRuleNum yyrule = yydefaultAction (yystate); + if (yyrule == 0) + { + YYDPRINTF ((stderr, "Stack %lu dies.\n", + (unsigned long int) yyk)); + yymarkStackDeleted (yystackp, yyk); + return yyok; + } + yyflag = yyglrReduce (yystackp, yyk, yyrule, yyimmediate[yyrule]]b4_user_args[); + if (yyflag == yyerr) + { + YYDPRINTF ((stderr, + "Stack %lu dies " + "(predicate failure or explicit user error).\n", + (unsigned long int) yyk)); + yymarkStackDeleted (yystackp, yyk); + return yyok; + } + if (yyflag != yyok) + return yyflag; + } + else + { + yySymbol yytoken; + int yyaction; + const short int* yyconflicts; + + yystackp->yytops.yylookaheadNeeds[yyk] = yytrue; + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = ]b4_lex[; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); + + while (*yyconflicts != 0) + { + YYRESULTTAG yyflag; + size_t yynewStack = yysplitStack (yystackp, yyk); + YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n", + (unsigned long int) yynewStack, + (unsigned long int) yyk)); + yyflag = yyglrReduce (yystackp, yynewStack, + *yyconflicts, + yyimmediate[*yyconflicts]]b4_user_args[); + if (yyflag == yyok) + YYCHK (yyprocessOneStack (yystackp, yynewStack, + yyposn]b4_pure_args[)); + else if (yyflag == yyerr) + { + YYDPRINTF ((stderr, "Stack %lu dies.\n", + (unsigned long int) yynewStack)); + yymarkStackDeleted (yystackp, yynewStack); + } + else + return yyflag; + yyconflicts += 1; + } + + if (yyisShiftAction (yyaction)) + break; + else if (yyisErrorAction (yyaction)) + { + YYDPRINTF ((stderr, "Stack %lu dies.\n", + (unsigned long int) yyk)); + yymarkStackDeleted (yystackp, yyk); + break; + } + else + { + YYRESULTTAG yyflag = yyglrReduce (yystackp, yyk, -yyaction, + yyimmediate[-yyaction]]b4_user_args[); + if (yyflag == yyerr) + { + YYDPRINTF ((stderr, + "Stack %lu dies " + "(predicate failure or explicit user error).\n", + (unsigned long int) yyk)); + yymarkStackDeleted (yystackp, yyk); + break; + } + else if (yyflag != yyok) + return yyflag; + } + } + } + return yyok; +} + +static void +yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) +{ + if (yystackp->yyerrState != 0) + return; +#if ! YYERROR_VERBOSE + yyerror (]b4_lyyerror_args[YY_("syntax error")); +#else + { + yySymbol yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); + size_t yysize0 = yytnamerr (YY_NULL, yytokenName (yytoken)); + size_t yysize = yysize0; + yybool yysize_overflow = yyfalse; + char* yymsg = YY_NULL; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULL; + /* Arguments of yyformat. */ + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; + + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yytoken != YYEMPTY) + { + int yyn = yypact[yystackp->yytops.yystates[0]->yylrState]; + yyarg[yycount++] = yytokenName (yytoken); + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for this + state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + break; + } + yyarg[yycount++] = yytokenName (yyx); + { + size_t yysz = yysize + yytnamerr (YY_NULL, yytokenName (yyx)); + yysize_overflow |= yysz < yysize; + yysize = yysz; + } + } + } + } + + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + { + size_t yysz = yysize + strlen (yyformat); + yysize_overflow |= yysz < yysize; + yysize = yysz; + } + + if (!yysize_overflow) + yymsg = (char *) YYMALLOC (yysize); + + if (yymsg) + { + char *yyp = yymsg; + int yyi = 0; + while ((*yyp = *yyformat)) + { + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } + } + yyerror (]b4_lyyerror_args[yymsg); + YYFREE (yymsg); + } + else + { + yyerror (]b4_lyyerror_args[YY_("syntax error")); + yyMemoryExhausted (yystackp); + } + } +#endif /* YYERROR_VERBOSE */ + yynerrs += 1; +} + +/* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP, + yylval, and yylloc are the syntactic category, semantic value, and location + of the lookahead. */ +static void +yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) +{ + size_t yyk; + int yyj; + + if (yystackp->yyerrState == 3) + /* We just shifted the error token and (perhaps) took some + reductions. Skip tokens until we can proceed. */ + while (yytrue) + { + yySymbol yytoken; + if (yychar == YYEOF) + yyFail (yystackp][]b4_lpure_args[, YY_NULL); + if (yychar != YYEMPTY) + {]b4_locations_if([[ + /* We throw away the lookahead, but the error range + of the shifted error token must take it into account. */ + yyGLRState *yys = yystackp->yytops.yystates[0]; + yyGLRStackItem yyerror_range[3]; + yyerror_range[1].yystate.yyloc = yys->yyloc; + yyerror_range[2].yystate.yyloc = yylloc; + YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Error: discarding", + yytoken, &yylval]b4_locuser_args([&yylloc])[); + } + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = ]b4_lex[; + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + yyj = yypact[yystackp->yytops.yystates[0]->yylrState]; + if (yypact_value_is_default (yyj)) + return; + yyj += yytoken; + if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken) + { + if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0) + return; + } + else if (! yytable_value_is_error (yytable[yyj])) + return; + } + + /* Reduce to one stack. */ + for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1) + if (yystackp->yytops.yystates[yyk] != YY_NULL) + break; + if (yyk >= yystackp->yytops.yysize) + yyFail (yystackp][]b4_lpure_args[, YY_NULL); + for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1) + yymarkStackDeleted (yystackp, yyk); + yyremoveDeletes (yystackp); + yycompressStack (yystackp); + + /* Now pop stack until we find a state that shifts the error token. */ + yystackp->yyerrState = 3; + while (yystackp->yytops.yystates[0] != YY_NULL) + { + yyGLRState *yys = yystackp->yytops.yystates[0]; + yyj = yypact[yys->yylrState]; + if (! yypact_value_is_default (yyj)) + { + yyj += YYTERROR; + if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR + && yyisShiftAction (yytable[yyj])) + { + /* Shift the error token. */]b4_locations_if([[ + /* First adjust its location.*/ + YYLTYPE yyerrloc; + yystackp->yyerror_range[2].yystate.yyloc = yylloc; + YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[ + YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]], + &yylval, &yyerrloc); + yyglrShift (yystackp, 0, yytable[yyj], + yys->yyposn, &yylval]b4_locations_if([, &yyerrloc])[); + yys = yystackp->yytops.yystates[0]; + break; + } + }]b4_locations_if([[ + yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ + if (yys->yypred != YY_NULL) + yydestroyGLRState ("Error: popping", yys]b4_user_args[); + yystackp->yytops.yystates[0] = yys->yypred; + yystackp->yynextFree -= 1; + yystackp->yyspaceLeft += 1; + } + if (yystackp->yytops.yystates[0] == YY_NULL) + yyFail (yystackp][]b4_lpure_args[, YY_NULL); +} + +#define YYCHK1(YYE) \ + do { \ + switch (YYE) { \ + case yyok: \ + break; \ + case yyabort: \ + goto yyabortlab; \ + case yyaccept: \ + goto yyacceptlab; \ + case yyerr: \ + goto yyuser_error; \ + default: \ + goto yybuglab; \ + } \ + } while (0) + +/*----------. +| yyparse. | +`----------*/ + +]b4_function_define([yyparse], [int], b4_parse_param)[ +{ + int yyresult; + yyGLRStack yystack; + yyGLRStack* const yystackp = &yystack; + size_t yyposn; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yychar = YYEMPTY; + yylval = yyval_default;]b4_locations_if([ + yylloc = yyloc_default;])[ +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [yylloc])dnl + /* User initialization code. */ + b4_user_initial_action +b4_dollar_popdef])[]dnl +[ + if (! yyinitGLRStack (yystackp, YYINITDEPTH)) + goto yyexhaustedlab; + switch (YYSETJMP (yystack.yyexception_buffer)) + { + case 0: break; + case 1: goto yyabortlab; + case 2: goto yyexhaustedlab; + default: goto yybuglab; + } + yyglrShift (&yystack, 0, 0, 0, &yylval]b4_locations_if([, &yylloc])[); + yyposn = 0; + + while (yytrue) + { + /* For efficiency, we have two loops, the first of which is + specialized to deterministic operation (single stack, no + potential ambiguity). */ + /* Standard mode */ + while (yytrue) + { + yyRuleNum yyrule; + int yyaction; + const short int* yyconflicts; + + yyStateNum yystate = yystack.yytops.yystates[0]->yylrState; + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + if (yystate == YYFINAL) + goto yyacceptlab; + if (yyisDefaultedState (yystate)) + { + yyrule = yydefaultAction (yystate); + if (yyrule == 0) + { +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[)); + } + else + { + yySymbol yytoken; + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = ]b4_lex[; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); + if (*yyconflicts != 0) + break; + if (yyisShiftAction (yyaction)) + { + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + yychar = YYEMPTY; + yyposn += 1; + yyglrShift (&yystack, 0, yyaction, yyposn, &yylval]b4_locations_if([, &yylloc])[); + if (0 < yystack.yyerrState) + yystack.yyerrState -= 1; + } + else if (yyisErrorAction (yyaction)) + { +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + else + YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[)); + } + } + + while (yytrue) + { + yySymbol yytoken_to_shift; + size_t yys; + + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY; + + /* yyprocessOneStack returns one of three things: + + - An error flag. If the caller is yyprocessOneStack, it + immediately returns as well. When the caller is finally + yyparse, it jumps to an error label via YYCHK1. + + - yyok, but yyprocessOneStack has invoked yymarkStackDeleted + (&yystack, yys), which sets the top state of yys to NULL. Thus, + yyparse's following invocation of yyremoveDeletes will remove + the stack. + + - yyok, when ready to shift a token. + + Except in the first case, yyparse will invoke yyremoveDeletes and + then shift the next token onto all remaining stacks. This + synchronization of the shift (that is, after all preceding + reductions on all stacks) helps prevent double destructor calls + on yylval in the event of memory exhaustion. */ + + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[)); + yyremoveDeletes (&yystack); + if (yystack.yytops.yysize == 0) + { + yyundeleteLastStack (&yystack); + if (yystack.yytops.yysize == 0) + yyFail (&yystack][]b4_lpure_args[, YY_("syntax error")); + YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); + YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + + /* If any yyglrShift call fails, it will fail after shifting. Thus, + a copy of yylval will already be on stack 0 in the event of a + failure in the following loop. Thus, yychar is set to YYEMPTY + before the loop to make sure the user destructor for yylval isn't + called twice. */ + yytoken_to_shift = YYTRANSLATE (yychar); + yychar = YYEMPTY; + yyposn += 1; + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + { + int yyaction; + const short int* yyconflicts; + yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState; + yygetLRActions (yystate, yytoken_to_shift, &yyaction, + &yyconflicts); + /* Note that yyconflicts were handled by yyprocessOneStack. */ + YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys)); + YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc); + yyglrShift (&yystack, yys, yyaction, yyposn, + &yylval]b4_locations_if([, &yylloc])[); + YYDPRINTF ((stderr, "Stack %lu now in state #%d\n", + (unsigned long int) yys, + yystack.yytops.yystates[yys]->yylrState)); + } + + if (yystack.yytops.yysize == 1) + { + YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); + YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); + yycompressStack (&yystack); + break; + } + } + continue; + yyuser_error: + yyrecoverSyntaxError (&yystack]b4_user_args[); + yyposn = yystack.yytops.yystates[0]->yyposn; + } + + yyacceptlab: + yyresult = 0; + goto yyreturn; + + yybuglab: + YYASSERT (yyfalse); + goto yyabortlab; + + yyabortlab: + yyresult = 1; + goto yyreturn; + + yyexhaustedlab: + yyerror (]b4_lyyerror_args[YY_("memory exhausted")); + yyresult = 2; + goto yyreturn; + + yyreturn: + if (yychar != YYEMPTY) + yydestruct ("Cleanup: discarding lookahead", + YYTRANSLATE (yychar), &yylval]b4_locuser_args([&yylloc])[); + + /* If the stack is well-formed, pop the stack until it is empty, + destroying its entries as we go. But free the stack regardless + of whether it is well-formed. */ + if (yystack.yyitems) + { + yyGLRState** yystates = yystack.yytops.yystates; + if (yystates) + { + size_t yysize = yystack.yytops.yysize; + size_t yyk; + for (yyk = 0; yyk < yysize; yyk += 1) + if (yystates[yyk]) + { + while (yystates[yyk]) + { + yyGLRState *yys = yystates[yyk]; +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]] +)[ if (yys->yypred != YY_NULL) + yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); + yystates[yyk] = yys->yypred; + yystack.yynextFree -= 1; + yystack.yyspaceLeft += 1; + } + break; + } + } + yyfreeGLRStack (&yystack); + } + + return yyresult; +} + +/* DEBUGGING ONLY */ +#if ]b4_api_PREFIX[DEBUG +static void +yy_yypstack (yyGLRState* yys) +{ + if (yys->yypred) + { + yy_yypstack (yys->yypred); + YYFPRINTF (stderr, " -> "); + } + YYFPRINTF (stderr, "%d@@%lu", yys->yylrState, + (unsigned long int) yys->yyposn); +} + +static void +yypstates (yyGLRState* yyst) +{ + if (yyst == YY_NULL) + YYFPRINTF (stderr, ""); + else + yy_yypstack (yyst); + YYFPRINTF (stderr, "\n"); +} + +static void +yypstack (yyGLRStack* yystackp, size_t yyk) +{ + yypstates (yystackp->yytops.yystates[yyk]); +} + +#define YYINDEX(YYX) \ + ((YYX) == YY_NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems) + + +static void +yypdumpstack (yyGLRStack* yystackp) +{ + yyGLRStackItem* yyp; + size_t yyi; + for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1) + { + YYFPRINTF (stderr, "%3lu. ", + (unsigned long int) (yyp - yystackp->yyitems)); + if (*(yybool *) yyp) + { + YYFPRINTF (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld", + yyp->yystate.yyresolved, yyp->yystate.yylrState, + (unsigned long int) yyp->yystate.yyposn, + (long int) YYINDEX (yyp->yystate.yypred)); + if (! yyp->yystate.yyresolved) + YYFPRINTF (stderr, ", firstVal: %ld", + (long int) YYINDEX (yyp->yystate + .yysemantics.yyfirstVal)); + } + else + { + YYFPRINTF (stderr, "Option. rule: %d, state: %ld, next: %ld", + yyp->yyoption.yyrule - 1, + (long int) YYINDEX (yyp->yyoption.yystate), + (long int) YYINDEX (yyp->yyoption.yynext)); + } + YYFPRINTF (stderr, "\n"); + } + YYFPRINTF (stderr, "Tops:"); + for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) + YYFPRINTF (stderr, "%lu: %ld; ", (unsigned long int) yyi, + (long int) YYINDEX (yystackp->yytops.yystates[yyi])); + YYFPRINTF (stderr, "\n"); +} +#endif + +#undef yylval +#undef yychar +#undef yynerrs]b4_locations_if([ +#undef yylloc]) + +m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */ +#define yyparse ]b4_prefix[parse +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char +#define yydebug ]b4_prefix[debug +#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])])[ + +]b4_epilogue[]dnl +b4_output_end() + +# glr.cc produces its own header. +m4_if(b4_skeleton, ["glr.c"], +[b4_defines_if( +[b4_output_begin([b4_spec_defines_file]) +b4_copyright([Skeleton interface for Bison GLR parsers in C], + [2002-2013])[ + +]b4_cpp_guard_open([b4_spec_defines_file])[ +]b4_shared_declarations[ +]b4_cpp_guard_close([b4_spec_defines_file])[ +]b4_output_end() +])]) diff --git a/gnuwin32/bin/data/glr.cc b/gnuwin32/bin/data/glr.cc new file mode 100644 index 00000000..e57308bd --- /dev/null +++ b/gnuwin32/bin/data/glr.cc @@ -0,0 +1,345 @@ +# C++ GLR skeleton for Bison + +# Copyright (C) 2002-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +# This skeleton produces a C++ class that encapsulates a C glr parser. +# This is in order to reduce the maintenance burden. The glr.c +# skeleton is clean and pure enough so that there are no real +# problems. The C++ interface is the same as that of lalr1.cc. In +# fact, glr.c can replace yacc.c without the user noticing any +# difference, and similarly for glr.cc replacing lalr1.cc. +# +# The passing of parse-params +# +# The additional arguments are stored as members of the parser +# object, yyparser. The C routines need to carry yyparser +# throughout the C parser; that's easy: make yyparser an +# additional parse-param. But because the C++ skeleton needs to +# know the "real" original parse-param, we save them +# (b4_parse_param_orig). Note that b4_parse_param is overquoted +# (and c.m4 strips one level of quotes). This is a PITA, and +# explains why there are so many levels of quotes. +# +# The locations +# +# We use location.cc just like lalr1.cc, but because glr.c stores +# the locations in a union, the position and location classes +# must not have a constructor. Therefore, contrary to lalr1.cc, we +# must not define "b4_location_constructors". As a consequence the +# user must initialize the first positions (in particular the +# filename member). + +# We require a pure interface. +m4_define([b4_pure_flag], [1]) + +m4_include(b4_pkgdatadir/[c++.m4]) +b4_bison_locations_if([m4_include(b4_pkgdatadir/[location.cc])]) + +m4_define([b4_parser_class_name], + [b4_percent_define_get([[parser_class_name]])]) + +# Save the parse parameters. +m4_define([b4_parse_param_orig], m4_defn([b4_parse_param])) + +# b4_parse_param_wrap +# ------------------- +# New ones. +m4_ifset([b4_parse_param], +[m4_define([b4_parse_param_wrap], + [[b4_namespace_ref::b4_parser_class_name[& yyparser], [[yyparser]]],] +m4_defn([b4_parse_param]))], +[m4_define([b4_parse_param_wrap], + [[b4_namespace_ref::b4_parser_class_name[& yyparser], [[yyparser]]]]) +]) + + +# b4_yy_symbol_print_define +# ------------------------- +# Bypass the default implementation to generate the "yy_symbol_print" +# and "yy_symbol_value_print" functions. +m4_define([b4_yy_symbol_print_define], +[[ +/*--------------------. +| Print this symbol. | +`--------------------*/ + +]b4_function_define([yy_symbol_print], + [static void], + [[FILE *], []], + [[int yytype], [yytype]], + [[const ]b4_namespace_ref::b4_parser_class_name[::semantic_type *yyvaluep], + [yyvaluep]][]dnl +b4_locations_if([, + [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], + [yylocationp]]]), + b4_parse_param)[ +{ +]b4_parse_param_use[]dnl +[ yyparser.yy_symbol_print_ (yytype, yyvaluep]b4_locations_if([, yylocationp])[); +} +]])[ + +# Hijack the initial action to initialize the locations. +]b4_bison_locations_if([m4_define([b4_initial_action], +[yylloc.initialize ();]m4_ifdef([b4_initial_action], [ +m4_defn([b4_initial_action])]))])[ + +# Hijack the post prologue to insert early definition of YYLLOC_DEFAULT +# and declaration of yyerror. +]m4_append([b4_post_prologue], +[b4_syncline([@oline@], [@ofile@])[ +]b4_yylloc_default_define[ +#define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) +]b4_function_declare([yyerror], + [static void],b4_locations_if([ + [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], + [yylocationp]],]) + b4_parse_param, + [[const char* msg], [msg]])]) + + +#undef yynerrs +#undef yychar +#undef yylval]b4_locations_if([ +#undef yylloc]) + +m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */ +#define yyparse ]b4_prefix[parse +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yydebug ]b4_prefix[debug +]]b4_pure_if([], [[ +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char +#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])])) + +# Hijack the epilogue to define implementations (yyerror, parser member +# functions etc.). +m4_append([b4_epilogue], +[b4_syncline([@oline@], [@ofile@])[ + +/*------------------. +| Report an error. | +`------------------*/ + +]b4_function_define([yyerror], + [static void],b4_locations_if([ + [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], + [yylocationp]],]) + b4_parse_param, + [[const char* msg], [msg]])[ +{ +]b4_parse_param_use[]dnl +[ yyparser.error (]b4_locations_if([[*yylocationp, ]])[msg); +} + + +]b4_namespace_open[ +]dnl In this section, the parse params are the original parse_params. +m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl +[ /// Build a parser object. + ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ + :])[ +#if ]b4_api_PREFIX[DEBUG + ]m4_ifset([b4_parse_param], [ ], [ :])[yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ +#endif]b4_parse_param_cons[ + { + } + + ]b4_parser_class_name::~b4_parser_class_name[ () + { + } + + int + ]b4_parser_class_name[::parse () + { + return ::yyparse (*this]b4_user_args[); + } + +#if ]b4_api_PREFIX[DEBUG + /*--------------------. + | Print this symbol. | + `--------------------*/ + + inline void + ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, + const semantic_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) + {]b4_locations_if([[ + YYUSE (yylocationp);]])[ + YYUSE (yyvaluep); + std::ostream& yyoutput = debug_stream (); + std::ostream& yyo = yyoutput; + YYUSE (yyo); + ]b4_symbol_actions([printer])[ + } + + + void + ]b4_parser_class_name[::yy_symbol_print_ (int yytype, + const semantic_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) + { + *yycdebug_ << (yytype < YYNTOKENS ? "token" : "nterm") + << ' ' << yytname[yytype] << " ("]b4_locations_if([[ + << *yylocationp << ": "]])[; + yy_symbol_value_print_ (yytype, yyvaluep]b4_locations_if([[, yylocationp]])[); + *yycdebug_ << ')'; + } + + std::ostream& + ]b4_parser_class_name[::debug_stream () const + { + return *yycdebug_; + } + + void + ]b4_parser_class_name[::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + ]b4_parser_class_name[::debug_level_type + ]b4_parser_class_name[::debug_level () const + { + return yydebug; + } + + void + ]b4_parser_class_name[::set_debug_level (debug_level_type l) + { + // Actually, it is yydebug which is really used. + yydebug = l; + } + +#endif +]m4_popdef([b4_parse_param])dnl +b4_namespace_close +]) + +# b4_shared_declarations +# ---------------------- +# Declaration that might either go into the header (if --defines) +# or open coded in the parser body. +m4_define([b4_shared_declarations], +[m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl +b4_percent_code_get([[requires]])[ + +#include +#include +#include ]b4_defines_if([ +b4_bison_locations_if([[#include "location.hh"]])])[ + +]b4_YYDEBUG_define[ + +]b4_namespace_open[ +]b4_defines_if([], +[b4_bison_locations_if([b4_position_define +b4_location_define])])[ + + /// A Bison parser. + class ]b4_parser_class_name[ + { + public: +]b4_public_types_declare[ + + /// Build a parser object. + ]b4_parser_class_name[ (]b4_parse_param_decl[); + virtual ~]b4_parser_class_name[ (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + virtual int parse (); + + /// The current debugging stream. + std::ostream& debug_stream () const; + /// Set the current debugging stream. + void set_debug_stream (std::ostream &); + + /// Type for debugging levels. + typedef int debug_level_type; + /// The current debugging level. + debug_level_type debug_level () const; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); + + public: + /// Report a syntax error.]b4_locations_if([[ + /// \param loc where the syntax error is found.]])[ + /// \param msg a description of the syntax error. + virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); + +# if ]b4_api_PREFIX[DEBUG + public: + /// \brief Report a symbol value on the debug stream. + /// \param yytype The token type. + /// \param yyvaluep Its semantic value.]b4_locations_if([[ + /// \param yylocationp Its location.]])[ + virtual void yy_symbol_value_print_ (int yytype, + const semantic_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[); + /// \brief Report a symbol on the debug stream. + /// \param yytype The token type. + /// \param yyvaluep Its semantic value.]b4_locations_if([[ + /// \param yylocationp Its location.]])[ + virtual void yy_symbol_print_ (int yytype, + const semantic_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[); + private: + // Debugging. + std::ostream* yycdebug_; +#endif + +]b4_parse_param_vars[ + }; + +]dnl Redirections for glr.c. +b4_percent_define_flag_if([[global_tokens_and_yystype]], +[b4_token_defines]) +[ +#ifndef ]b4_api_PREFIX[STYPE +# define ]b4_api_PREFIX[STYPE ]b4_namespace_ref[::]b4_parser_class_name[::semantic_type +#endif +#ifndef ]b4_api_PREFIX[LTYPE +# define ]b4_api_PREFIX[LTYPE ]b4_namespace_ref[::]b4_parser_class_name[::location_type +#endif + +]b4_namespace_close[ +]b4_percent_code_get([[provides]])[ +]m4_popdef([b4_parse_param])dnl +]) + +b4_defines_if( +[b4_output_begin([b4_spec_defines_file]) +b4_copyright([Skeleton interface for Bison GLR parsers in C++], + [2002-2013])[ + +// C++ GLR parser skeleton written by Akim Demaille. + +]b4_cpp_guard_open([b4_spec_defines_file])[ +]b4_shared_declarations[ +]b4_cpp_guard_close([b4_spec_defines_file])[ +]b4_output_end()]) + +# Let glr.c (and b4_shared_declarations) believe that the user +# arguments include the parser itself. +m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_wrap])) +m4_include(b4_pkgdatadir/[glr.c]) +m4_popdef([b4_parse_param]) diff --git a/gnuwin32/bin/data/java-skel.m4 b/gnuwin32/bin/data/java-skel.m4 new file mode 100644 index 00000000..384a6370 --- /dev/null +++ b/gnuwin32/bin/data/java-skel.m4 @@ -0,0 +1,26 @@ + -*- Autoconf -*- + +# Java skeleton dispatching for Bison. + +# Copyright (C) 2007, 2009-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +b4_glr_if( [b4_complain([%%glr-parser not supported for Java])]) +b4_nondeterministic_if([b4_complain([%%nondeterministic-parser not supported for Java])]) + +m4_define_default([b4_used_skeleton], [b4_pkgdatadir/[lalr1.java]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/gnuwin32/bin/data/java.m4 b/gnuwin32/bin/data/java.m4 new file mode 100644 index 00000000..f985f977 --- /dev/null +++ b/gnuwin32/bin/data/java.m4 @@ -0,0 +1,342 @@ + -*- Autoconf -*- + +# Java language support for Bison + +# Copyright (C) 2007-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_include(b4_pkgdatadir/[c-like.m4]) + + +# b4_list2(LIST1, LIST2) +# ---------------------- +# Join two lists with a comma if necessary. +m4_define([b4_list2], + [$1[]m4_ifval(m4_quote($1), [m4_ifval(m4_quote($2), [[, ]])])[]$2]) + + +# b4_percent_define_get3(DEF, PRE, POST, NOT) +# ------------------------------------------- +# Expand to the value of DEF surrounded by PRE and POST if it's %define'ed, +# otherwise NOT. +m4_define([b4_percent_define_get3], + [m4_ifval(m4_quote(b4_percent_define_get([$1])), + [$2[]b4_percent_define_get([$1])[]$3], [$4])]) + + + +# b4_flag_value(BOOLEAN-FLAG) +# --------------------------- +m4_define([b4_flag_value], [b4_flag_if([$1], [true], [false])]) + + +# b4_public_if(TRUE, FALSE) +# ------------------------- +b4_percent_define_default([[public]], [[false]]) +m4_define([b4_public_if], +[b4_percent_define_flag_if([public], [$1], [$2])]) + + +# b4_abstract_if(TRUE, FALSE) +# --------------------------- +b4_percent_define_default([[abstract]], [[false]]) +m4_define([b4_abstract_if], +[b4_percent_define_flag_if([abstract], [$1], [$2])]) + + +# b4_final_if(TRUE, FALSE) +# --------------------------- +b4_percent_define_default([[final]], [[false]]) +m4_define([b4_final_if], +[b4_percent_define_flag_if([final], [$1], [$2])]) + + +# b4_strictfp_if(TRUE, FALSE) +# --------------------------- +b4_percent_define_default([[strictfp]], [[false]]) +m4_define([b4_strictfp_if], +[b4_percent_define_flag_if([strictfp], [$1], [$2])]) + + +# b4_lexer_if(TRUE, FALSE) +# ------------------------ +m4_define([b4_lexer_if], +[b4_percent_code_ifdef([[lexer]], [$1], [$2])]) + + +# b4_identification +# ----------------- +m4_define([b4_identification], +[ /** Version number for the Bison executable that generated this parser. */ + public static final String bisonVersion = "b4_version"; + + /** Name of the skeleton that generated this parser. */ + public static final String bisonSkeleton = b4_skeleton; +]) + + +## ------------ ## +## Data types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# MIN to MAX (included). +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [-128], [127]), [1], [byte], + b4_ints_in($@, [-32768], [32767]), [1], [short], + [int])]) + +# b4_int_type_for(NAME) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# 'NAME_min' to 'NAME_max' (included). +m4_define([b4_int_type_for], +[b4_int_type($1_min, $1_max)]) + +# b4_null +# ------- +m4_define([b4_null], [null]) + + +# b4_typed_parser_table_define(TYPE, NAME, DATA, COMMENT) +# ------------------------------------------------------- +m4_define([b4_typed_parser_table_define], +[m4_ifval([$4], [b4_comment([$4]) + ])dnl +[private static final ]$1[ yy$2_[] = yy$2_init(); + private static final ]$1[[] yy$2_init() + { + return new ]$1[[] + { + ]$3[ + }; + }]]) + + +# b4_integral_parser_table_define(NAME, DATA, COMMENT) +#----------------------------------------------------- +m4_define([b4_integral_parser_table_define], +[b4_typed_parser_table_define([b4_int_type_for([$2])], [$1], [$2], [$3])]) + + +## ------------------------- ## +## Assigning token numbers. ## +## ------------------------- ## + +# b4_token_enum(TOKEN-NUM) +# ------------------------ +# Output the definition of this token as an enum. +m4_define([b4_token_enum], +[b4_token_format([ /** Token number, to be returned by the scanner. */ + static final int %s = %s; +], [$1])]) + +# b4_token_enums +# -------------- +# Output the definition of the tokens (if there are) as enums. +m4_define([b4_token_enums], +[b4_any_token_visible_if([/* Tokens. */ +b4_symbol_foreach([b4_token_enum])])]) + +# b4-case(ID, CODE) +# ----------------- +# We need to fool Java's stupid unreachable code detection. +m4_define([b4_case], [ case $1: + if (yyn == $1) + $2; + break; + ]) + +# b4_predicate_case(LABEL, CONDITIONS) +# ------------------------------------ +m4_define([b4_predicate_case], [ case $1: + if (! ($2)) YYERROR; + break; + ]) + + +## -------- ## +## Checks. ## +## -------- ## + +b4_percent_define_check_kind([[api.value.type]], [code], [deprecated]) + +b4_percent_define_check_kind([[annotations]], [code], [deprecated]) +b4_percent_define_check_kind([[extends]], [code], [deprecated]) +b4_percent_define_check_kind([[implements]], [code], [deprecated]) +b4_percent_define_check_kind([[init_throws]], [code], [deprecated]) +b4_percent_define_check_kind([[lex_throws]], [code], [deprecated]) +b4_percent_define_check_kind([[parser_class_name]], [code], [deprecated]) +b4_percent_define_check_kind([[throws]], [code], [deprecated]) + + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +m4_define([b4_yystype], [b4_percent_define_get([[api.value.type]])]) +b4_percent_define_default([[api.value.type]], [[Object]]) + +# %name-prefix +m4_define_default([b4_prefix], [[YY]]) + +b4_percent_define_default([[parser_class_name]], [b4_prefix[]Parser]) +m4_define([b4_parser_class_name], [b4_percent_define_get([[parser_class_name]])]) + +b4_percent_define_default([[lex_throws]], [[java.io.IOException]]) +m4_define([b4_lex_throws], [b4_percent_define_get([[lex_throws]])]) + +b4_percent_define_default([[throws]], []) +m4_define([b4_throws], [b4_percent_define_get([[throws]])]) + +b4_percent_define_default([[init_throws]], []) +m4_define([b4_init_throws], [b4_percent_define_get([[init_throws]])]) + +b4_percent_define_default([[api.location.type]], [Location]) +m4_define([b4_location_type], [b4_percent_define_get([[api.location.type]])]) + +b4_percent_define_default([[api.position.type]], [Position]) +m4_define([b4_position_type], [b4_percent_define_get([[api.position.type]])]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_lhs_value([TYPE]) +# -------------------- +# Expansion of $$. +m4_define([b4_lhs_value], [yyval]) + + +# b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) +# -------------------------------------- +# Expansion of $NUM, where the current rule has RULE-LENGTH +# symbols on RHS. +# +# In this simple implementation, %token and %type have class names +# between the angle brackets. +m4_define([b4_rhs_value], +[(m4_ifval($3, [($3)])[](yystack.valueAt ($1-($2))))]) + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[yystack.locationAt ($1-($2))]) + + +# b4_lex_param +# b4_parse_param +# -------------- +# If defined, b4_lex_param arrives double quoted, but below we prefer +# it to be single quoted. Same for b4_parse_param. + +# TODO: should be in bison.m4 +m4_define_default([b4_lex_param], [[]]) +m4_define([b4_lex_param], b4_lex_param) +m4_define([b4_parse_param], b4_parse_param) + +# b4_lex_param_decl +# ----------------- +# Extra formal arguments of the constructor. +m4_define([b4_lex_param_decl], +[m4_ifset([b4_lex_param], + [b4_remove_comma([$1], + b4_param_decls(b4_lex_param))], + [$1])]) + +m4_define([b4_param_decls], + [m4_map([b4_param_decl], [$@])]) +m4_define([b4_param_decl], [, $1]) + +m4_define([b4_remove_comma], [m4_ifval(m4_quote($1), [$1, ], [])m4_shift2($@)]) + + + +# b4_parse_param_decl +# ------------------- +# Extra formal arguments of the constructor. +m4_define([b4_parse_param_decl], +[m4_ifset([b4_parse_param], + [b4_remove_comma([$1], + b4_param_decls(b4_parse_param))], + [$1])]) + + + +# b4_lex_param_call +# ----------------- +# Delegating the lexer parameters to the lexer constructor. +m4_define([b4_lex_param_call], + [m4_ifset([b4_lex_param], + [b4_remove_comma([$1], + b4_param_calls(b4_lex_param))], + [$1])]) +m4_define([b4_param_calls], + [m4_map([b4_param_call], [$@])]) +m4_define([b4_param_call], [, $2]) + + + +# b4_parse_param_cons +# ------------------- +# Extra initialisations of the constructor. +m4_define([b4_parse_param_cons], + [m4_ifset([b4_parse_param], + [b4_constructor_calls(b4_parse_param)])]) + +m4_define([b4_constructor_calls], + [m4_map([b4_constructor_call], [$@])]) +m4_define([b4_constructor_call], + [this.$2 = $2; + ]) + + + +# b4_parse_param_vars +# ------------------- +# Extra instance variables. +m4_define([b4_parse_param_vars], + [m4_ifset([b4_parse_param], + [ + /* User arguments. */ +b4_var_decls(b4_parse_param)])]) + +m4_define([b4_var_decls], + [m4_map_sep([b4_var_decl], [ +], [$@])]) +m4_define([b4_var_decl], + [ protected final $1;]) + + + +# b4_maybe_throws(THROWS) +# ----------------------- +# Expand to either an empty string or "throws THROWS". +m4_define([b4_maybe_throws], + [m4_ifval($1, [throws $1])]) diff --git a/gnuwin32/bin/data/lalr1.cc b/gnuwin32/bin/data/lalr1.cc new file mode 100644 index 00000000..3294f591 --- /dev/null +++ b/gnuwin32/bin/data/lalr1.cc @@ -0,0 +1,1161 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_include(b4_pkgdatadir/[c++.m4]) + +# api.value.type=variant is valid. +m4_define([b4_value_type_setup_variant]) + +# b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT) +# -------------------------------------------------------------- +# Declare "parser::yy_" whose contents is CONTENT. +m4_define([b4_integral_parser_table_declare], +[m4_ifval([$3], [b4_comment([$3], [ ]) +])dnl + static const b4_int_type_for([$2]) yy$1_[[]];dnl +]) + +# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) +# ------------------------------------------------------------- +# Define "parser::yy_" whose contents is CONTENT. +m4_define([b4_integral_parser_table_define], +[ const b4_int_type_for([$2]) + b4_parser_class_name::yy$1_[[]] = + { + $2 + };dnl +]) + +# b4_symbol_value_template(VAL, [TYPE]) +# ------------------------------------- +# Same as b4_symbol_value, but used in a template method. It makes +# a difference when using variants. Note that b4_value_type_setup_union +# overrides b4_symbol_value, so we must override it again. +m4_copy([b4_symbol_value], [b4_symbol_value_template]) +m4_append([b4_value_type_setup_union], + [m4_copy_force([b4_symbol_value_union], [b4_symbol_value_template])]) + +# b4_lhs_value([TYPE]) +# -------------------- +# Expansion of $$. +m4_define([b4_lhs_value], + [b4_symbol_value([yylhs.value], [$1])]) + + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], + [yylhs.location]) + + +# b4_rhs_data(RULE-LENGTH, NUM) +# ----------------------------- +# Return the data corresponding to the symbol #NUM, where the current +# rule has RULE-LENGTH symbols on RHS. +m4_define([b4_rhs_data], + [yystack_@{b4_subtract($@)@}]) + + +# b4_rhs_state(RULE-LENGTH, NUM) +# ------------------------------ +# The state corresponding to the symbol #NUM, where the current +# rule has RULE-LENGTH symbols on RHS. +m4_define([b4_rhs_state], + [b4_rhs_data([$1], [$2]).state]) + + +# b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) +# -------------------------------------- +# Expansion of $NUM, where the current rule has RULE-LENGTH +# symbols on RHS. +m4_define([b4_rhs_value], + [b4_symbol_value([b4_rhs_data([$1], [$2]).value], [$3])]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], + [b4_rhs_data([$1], [$2]).location]) + + +# b4_symbol_action(SYMBOL-NUM, KIND) +# ---------------------------------- +# Run the action KIND (destructor or printer) for SYMBOL-NUM. +# Same as in C, but using references instead of pointers. +m4_define([b4_symbol_action], +[b4_symbol_if([$1], [has_$2], +[m4_pushdef([b4_symbol_value], m4_defn([b4_symbol_value_template]))[]dnl +b4_dollar_pushdef([yysym.value], + b4_symbol_if([$1], [has_type], + [m4_dquote(b4_symbol([$1], [type]))]), + [yysym.location])dnl + b4_symbol_case_([$1]) +b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"]) + b4_symbol([$1], [$2]) +b4_syncline([@oline@], [@ofile@]) + break; + +m4_popdef([b4_symbol_value])[]dnl +b4_dollar_popdef[]dnl +])]) + + +# b4_lex +# ------ +# Call yylex. +m4_define([b4_lex], +[b4_token_ctor_if( +[b4_function_call([yylex], + [symbol_type], m4_ifdef([b4_lex_param], b4_lex_param))], +[b4_function_call([yylex], [int], + [b4_api_PREFIX[STYPE*], [&yyla.value]][]dnl +b4_locations_if([, [[location*], [&yyla.location]]])dnl +m4_ifdef([b4_lex_param], [, ]b4_lex_param))])]) + + +m4_pushdef([b4_copyright_years], + [2002-2013]) + +m4_define([b4_parser_class_name], + [b4_percent_define_get([[parser_class_name]])]) + +b4_bison_locations_if([# Backward compatibility. + m4_define([b4_location_constructors]) + m4_include(b4_pkgdatadir/[location.cc])]) +m4_include(b4_pkgdatadir/[stack.hh]) +b4_variant_if([m4_include(b4_pkgdatadir/[variant.hh])]) + +# b4_shared_declarations +# ---------------------- +# Declaration that might either go into the header (if --defines) +# or open coded in the parser body. +m4_define([b4_shared_declarations], +[b4_percent_code_get([[requires]])[ +]b4_parse_assert_if([# include ])[ +# include +# include +# include +# include ]b4_defines_if([[ +# include "stack.hh" +]b4_bison_locations_if([[# include "location.hh"]])])[ +]b4_variant_if([b4_variant_includes])[ + +]b4_YYDEBUG_define[ + +]b4_namespace_open[ + +]b4_defines_if([], +[b4_stack_define +b4_bison_locations_if([b4_position_define +b4_location_define])])[ + +]b4_variant_if([b4_variant_define])[ + + /// A Bison parser. + class ]b4_parser_class_name[ + { + public: +]b4_public_types_declare[ + /// Build a parser object. + ]b4_parser_class_name[ (]b4_parse_param_decl[); + virtual ~]b4_parser_class_name[ (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + virtual int parse (); + +#if ]b4_api_PREFIX[DEBUG + /// The current debugging stream. + std::ostream& debug_stream () const; + /// Set the current debugging stream. + void set_debug_stream (std::ostream &); + + /// Type for debugging levels. + typedef int debug_level_type; + /// The current debugging level. + debug_level_type debug_level () const; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); +#endif + + /// Report a syntax error.]b4_locations_if([[ + /// \param loc where the syntax error is found.]])[ + /// \param msg a description of the syntax error. + virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); + + /// Report a syntax error. + void error (const syntax_error& err); + + private: + /// This class is not copyable. + ]b4_parser_class_name[ (const ]b4_parser_class_name[&); + ]b4_parser_class_name[& operator= (const ]b4_parser_class_name[&); + + /// State numbers. + typedef int state_type; + + /// Generate an error message. + /// \param yystate the state where the error occurred. + /// \param yytoken the lookahead token type, or yyempty_. + virtual std::string yysyntax_error_ (state_type yystate, + symbol_number_type yytoken) const; + + /// Compute post-reduction state. + /// \param yystate the current state + /// \param yylhs the nonterminal to push on the stack + state_type yy_lr_goto_state_ (state_type yystate, int yylhs); + + /// Whether the given \c yypact_ value indicates a defaulted state. + /// \param yyvalue the value to check + static bool yy_pact_value_is_default_ (int yyvalue); + + /// Whether the given \c yytable_ value indicates a syntax error. + /// \param yyvalue the value to check + static bool yy_table_value_is_error_ (int yyvalue); + + static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_; + static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_; + + /// Convert a scanner token number \a t to a symbol number. + static token_number_type yytranslate_ (]b4_token_ctor_if([token_type], [int])[ t); + + // Tables. +]b4_parser_tables_declare[]b4_error_verbose_if([ + + /// Convert the symbol name \a n to a form suitable for a diagnostic. + static std::string yytnamerr_ (const char *n);])[ + +]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[ + /// For a symbol, its name in clear. + static const char* const yytname_[]; +]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[ +]b4_integral_parser_table_declare([rline], [b4_rline], + [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[ + /// Report on the debug stream that the rule \a r is going to be reduced. + virtual void yy_reduce_print_ (int r); + /// Print the state stack on the debug stream. + virtual void yystack_print_ (); + + // Debugging. + int yydebug_; + std::ostream* yycdebug_; + + /// \brief Display a symbol type, value and location. + /// \param yyo The output stream. + /// \param yysym The symbol. + template + void yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const; +#endif + + /// \brief Reclaim the memory associated to a symbol. + /// \param yymsg Why this token is reclaimed. + /// If null, print nothing. + /// \param s The symbol. + template + void yy_destroy_ (const char* yymsg, basic_symbol& yysym) const; + + private: + /// Type access provider for state based symbols. + struct by_state + { + /// Default constructor. + by_state (); + + /// The symbol type as needed by the constructor. + typedef state_type kind_type; + + /// Constructor. + by_state (kind_type s); + + /// Copy constructor. + by_state (const by_state& other); + + /// Steal the symbol type from \a that. + void move (by_state& that); + + /// The (internal) type number (corresponding to \a state). + /// "empty" when empty. + symbol_number_type type_get () const; + + enum { empty = 0 }; + + /// The state. + state_type state; + }; + + /// "Internal" symbol: element of the stack. + struct stack_symbol_type : basic_symbol + { + /// Superclass. + typedef basic_symbol super_type; + /// Construct an empty symbol. + stack_symbol_type (); + /// Steal the contents from \a sym to build this. + stack_symbol_type (state_type s, symbol_type& sym); + /// Assignment, needed by push_back. + stack_symbol_type& operator= (const stack_symbol_type& that); + }; + + /// Stack type. + typedef stack stack_type; + + /// The stack. + stack_type yystack_; + + /// Push a new state on the stack. + /// \param m a debug message to display + /// if null, no trace is output. + /// \param s the symbol + /// \warning the contents of \a s.value is stolen. + void yypush_ (const char* m, stack_symbol_type& s); + + /// Push a new look ahead token on the state on the stack. + /// \param m a debug message to display + /// if null, no trace is output. + /// \param s the state + /// \param sym the symbol (for its value and location). + /// \warning the contents of \a s.value is stolen. + void yypush_ (const char* m, state_type s, symbol_type& sym); + + /// Pop \a n symbols the three stacks. + void yypop_ (unsigned int n = 1); + + // Constants. + enum + { + yyeof_ = 0, + yylast_ = ]b4_last[, //< Last index in yytable_. + yynnts_ = ]b4_nterms_number[, //< Number of nonterminal symbols. + yyempty_ = -2, + yyfinal_ = ]b4_final_state_number[, //< Termination state number. + yyterror_ = 1, + yyerrcode_ = 256, + yyntokens_ = ]b4_tokens_number[ //< Number of tokens. + }; + +]b4_parse_param_vars[ + }; + +]b4_token_ctor_if([b4_yytranslate_define +b4_public_types_define])[ +]b4_namespace_close[ + +]b4_percent_define_flag_if([[global_tokens_and_yystype]], +[b4_token_defines + +#ifndef ]b4_api_PREFIX[STYPE + // Redirection for backward compatibility. +# define ]b4_api_PREFIX[STYPE b4_namespace_ref::b4_parser_class_name::semantic_type +#endif +])[ +]b4_percent_code_get([[provides]])[ +]]) + +b4_defines_if( +[b4_output_begin([b4_spec_defines_file]) +b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++]) +[ +/** + ** \file ]b4_spec_defines_file[ + ** Define the ]b4_namespace_ref[::parser class. + */ + +// C++ LALR(1) parser skeleton written by Akim Demaille. + +]b4_cpp_guard_open([b4_spec_defines_file])[ +]b4_shared_declarations[ +]b4_cpp_guard_close([b4_spec_defines_file]) +b4_output_end() +]) + + +b4_output_begin([b4_parser_file_name]) +b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++]) +b4_percent_code_get([[top]])[]dnl +m4_if(b4_prefix, [yy], [], +[ +// Take the name prefix into account. +#define yylex b4_prefix[]lex])[ + +// First part of user declarations. +]b4_user_pre_prologue[ + +]b4_null_define[ + +]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]], + [b4_shared_declarations])[ + +// User implementation prologue. +]b4_user_post_prologue[ +]b4_percent_code_get[ + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include // FIXME: INFRINGES ON USER NAME SPACE. +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + +]b4_locations_if([dnl +[#define YYRHSLOC(Rhs, K) ((Rhs)[K].location) +]b4_yylloc_default_define])[ + +// Suppress unused-variable warnings by "using" E. +#define YYUSE(E) ((void) (E)) + +// Enable debugging if requested. +#if ]b4_api_PREFIX[DEBUG + +// A pseudo ostream that takes yydebug_ into account. +# define YYCDEBUG if (yydebug_) (*yycdebug_) + +# define YY_SYMBOL_PRINT(Title, Symbol) \ + do { \ + if (yydebug_) \ + { \ + *yycdebug_ << Title << ' '; \ + yy_print_ (*yycdebug_, Symbol); \ + *yycdebug_ << std::endl; \ + } \ + } while (false) + +# define YY_REDUCE_PRINT(Rule) \ + do { \ + if (yydebug_) \ + yy_reduce_print_ (Rule); \ + } while (false) + +# define YY_STACK_PRINT() \ + do { \ + if (yydebug_) \ + yystack_print_ (); \ + } while (false) + +#else // !]b4_api_PREFIX[DEBUG + +# define YYCDEBUG if (false) std::cerr +# define YY_SYMBOL_PRINT(Title, Symbol) YYUSE(Symbol) +# define YY_REDUCE_PRINT(Rule) static_cast(0) +# define YY_STACK_PRINT() static_cast(0) + +#endif // !]b4_api_PREFIX[DEBUG + +#define yyerrok (yyerrstatus_ = 0) +#define yyclearin (yyempty = true) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYRECOVERING() (!!yyerrstatus_) + +]b4_namespace_open[]b4_error_verbose_if([[ + + /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ + std::string + ]b4_parser_class_name[::yytnamerr_ (const char *yystr) + { + if (*yystr == '"') + { + std::string yyr = ""; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + // Fall through. + default: + yyr += *yyp; + break; + + case '"': + return yyr; + } + do_not_strip_quotes: ; + } + + return yystr; + } +]])[ + + /// Build a parser object. + ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ + :])[ +#if ]b4_api_PREFIX[DEBUG + ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false), + yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ +#endif]b4_parse_param_cons[ + {} + + ]b4_parser_class_name::~b4_parser_class_name[ () + {} + + + /*---------------. + | Symbol types. | + `---------------*/ + +]b4_token_ctor_if([], [b4_public_types_define])[ + + // by_state. + inline + ]b4_parser_class_name[::by_state::by_state () + : state (empty) + {} + + inline + ]b4_parser_class_name[::by_state::by_state (const by_state& other) + : state (other.state) + {} + + inline + void + ]b4_parser_class_name[::by_state::move (by_state& that) + { + state = that.state; + that.state = empty; + } + + inline + ]b4_parser_class_name[::by_state::by_state (state_type s) + : state (s) + {} + + inline + ]b4_parser_class_name[::symbol_number_type + ]b4_parser_class_name[::by_state::type_get () const + { + return state == empty ? 0 : yystos_[state]; + } + + inline + ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type () + {} + + + inline + ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (state_type s, symbol_type& that) + : super_type (s]b4_locations_if([, that.location])[) + { + ]b4_variant_if([b4_symbol_variant([that.type_get ()], + [value], [move], [that.value])], + [[value = that.value;]])[ + // that is emptied. + that.type = empty; + } + + inline + ]b4_parser_class_name[::stack_symbol_type& + ]b4_parser_class_name[::stack_symbol_type::operator= (const stack_symbol_type& that) + { + state = that.state; + ]b4_variant_if([b4_symbol_variant([that.type_get ()], + [value], [copy], [that.value])], + [[value = that.value;]])[]b4_locations_if([ + location = that.location;])[ + return *this; + } + + + template + inline + void + ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, basic_symbol& yysym) const + { + if (yymsg) + YY_SYMBOL_PRINT (yymsg, yysym);]b4_variant_if([], [ + + // User destructor. + b4_symbol_actions([destructor], [yysym.type_get ()])])[ + } + +#if ]b4_api_PREFIX[DEBUG + template + void + ]b4_parser_class_name[::yy_print_ (std::ostream& yyo, + const basic_symbol& yysym) const + { + std::ostream& yyoutput = yyo; + YYUSE (yyoutput); + symbol_number_type yytype = yysym.type_get (); + yyo << (yytype < yyntokens_ ? "token" : "nterm") + << ' ' << yytname_[yytype] << " ("]b4_locations_if([ + << yysym.location << ": "])[; + ]b4_symbol_actions([printer])[ + yyo << ')'; + } +#endif + + inline + void + ]b4_parser_class_name[::yypush_ (const char* m, state_type s, symbol_type& sym) + { + stack_symbol_type t (s, sym); + yypush_ (m, t); + } + + inline + void + ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s) + { + if (m) + YY_SYMBOL_PRINT (m, s); + yystack_.push (s); + } + + inline + void + ]b4_parser_class_name[::yypop_ (unsigned int n) + { + yystack_.pop (n); + } + +#if ]b4_api_PREFIX[DEBUG + std::ostream& + ]b4_parser_class_name[::debug_stream () const + { + return *yycdebug_; + } + + void + ]b4_parser_class_name[::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + ]b4_parser_class_name[::debug_level_type + ]b4_parser_class_name[::debug_level () const + { + return yydebug_; + } + + void + ]b4_parser_class_name[::set_debug_level (debug_level_type l) + { + yydebug_ = l; + } +#endif // ]b4_api_PREFIX[DEBUG + + inline ]b4_parser_class_name[::state_type + ]b4_parser_class_name[::yy_lr_goto_state_ (state_type yystate, int yylhs) + { + int yyr = yypgoto_[yylhs - yyntokens_] + yystate; + if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) + return yytable_[yyr]; + else + return yydefgoto_[yylhs - yyntokens_]; + } + + inline bool + ]b4_parser_class_name[::yy_pact_value_is_default_ (int yyvalue) + { + return yyvalue == yypact_ninf_; + } + + inline bool + ]b4_parser_class_name[::yy_table_value_is_error_ (int yyvalue) + { + return yyvalue == yytable_ninf_; + } + + int + ]b4_parser_class_name[::parse () + { + /// Whether yyla contains a lookahead. + bool yyempty = true; + + // State. + int yyn; + int yylen = 0; + + // Error handling. + int yynerrs_ = 0; + int yyerrstatus_ = 0; + + /// The lookahead symbol. + symbol_type yyla;]b4_locations_if([[ + + /// The locations where the error started and ended. + stack_symbol_type yyerror_range[3];]])[ + + /// $$ and @@$. + stack_symbol_type yylhs; + + /// The return value of parse (). + int yyresult; + + // FIXME: This shoud be completely indented. It is not yet to + // avoid gratuitous conflicts when merging into the master branch. + try + { + YYCDEBUG << "Starting parse" << std::endl; + +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yyla.value], [], [yyla.location])dnl + // User initialization code. + b4_user_initial_action +b4_dollar_popdef])[]dnl + + [ /* Initialize the stack. The initial state will be set in + yynewstate, since the latter expects the semantical and the + location values to have been already stored, initialize these + stacks with a primary value. */ + yystack_.clear (); + yypush_ (YY_NULL, 0, yyla); + + // A new symbol was pushed on the stack. + yynewstate: + YYCDEBUG << "Entering state " << yystack_[0].state << std::endl; + + // Accept? + if (yystack_[0].state == yyfinal_) + goto yyacceptlab; + + goto yybackup; + + // Backup. + yybackup: + + // Try to take a decision without lookahead. + yyn = yypact_[yystack_[0].state]; + if (yy_pact_value_is_default_ (yyn)) + goto yydefault; + + // Read a lookahead token. + if (yyempty) + { + YYCDEBUG << "Reading a token: "; + try + {]b4_token_ctor_if([[ + symbol_type yylookahead (]b4_lex[); + yyla.move (yylookahead);]], [[ + yyla.type = yytranslate_ (]b4_lex[);]])[ + } + catch (const syntax_error& yyexc) + { + error (yyexc); + goto yyerrlab1; + } + yyempty = false; + } + YY_SYMBOL_PRINT ("Next token is", yyla); + + /* If the proper action on seeing token YYLA.TYPE is to reduce or + to detect an error, take that action. */ + yyn += yyla.type_get (); + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type_get ()) + goto yydefault; + + // Reduce or error. + yyn = yytable_[yyn]; + if (yyn <= 0) + { + if (yy_table_value_is_error_ (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + // Discard the token being shifted. + yyempty = true; + + // Count tokens shifted since error; after three, turn off error status. + if (yyerrstatus_) + --yyerrstatus_; + + // Shift the lookahead token. + yypush_ ("Shifting", yyn, yyla); + goto yynewstate; + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + yydefault: + yyn = yydefact_[yystack_[0].state]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + /*-----------------------------. + | yyreduce -- Do a reduction. | + `-----------------------------*/ + yyreduce: + yylen = yyr2_[yyn]; + yylhs.state = yy_lr_goto_state_(yystack_[yylen].state, yyr1_[yyn]);]b4_variant_if([ + /* Variants are always initialized to an empty instance of the + correct type. The default $$=$1 action is NOT applied when using + variants. */ + b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [build])],[ + /* If YYLEN is nonzero, implement the default value of the action: + '$$ = $1'. Otherwise, use the top of the stack. + + Otherwise, the following line sets YYLHS.VALUE to garbage. + This behavior is undocumented and Bison + users should not rely upon it. */ + if (yylen) + yylhs.value = yystack_@{yylen - 1@}.value; + else + yylhs.value = yystack_@{0@}.value;])[ +]b4_locations_if([dnl +[ + // Compute the default @@$. + { + slice slice (yystack_, yylen); + YYLLOC_DEFAULT (yylhs.location, slice, yylen); + }]])[ + + // Perform the reduction. + YY_REDUCE_PRINT (yyn); + try + { + switch (yyn) + { +]b4_user_actions[ + default: + break; + } + } + catch (const syntax_error& yyexc) + { + error (yyexc); + YYERROR; + } + YY_SYMBOL_PRINT ("-> $$ =", yylhs); + yypop_ (yylen); + yylen = 0; + YY_STACK_PRINT (); + + // Shift the result of the reduction. + yypush_ (YY_NULL, yylhs); + goto yynewstate; + + /*--------------------------------------. + | yyerrlab -- here on detecting error. | + `--------------------------------------*/ + yyerrlab: + // If not already recovering from an error, report this error. + if (!yyerrstatus_) + { + ++yynerrs_; + error (]b4_join(b4_locations_if([yyla.location]), + [[yysyntax_error_ (yystack_[0].state, + yyempty ? yyempty_ : yyla.type_get ())]])[); + } + +]b4_locations_if([[ + yyerror_range[1].location = yyla.location;]])[ + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + // Return failure if at end of input. + if (yyla.type_get () == yyeof_) + YYABORT; + else if (!yyempty) + { + yy_destroy_ ("Error: discarding", yyla); + yyempty = true; + } + } + + // Else will try to reuse lookahead token after shifting the error token. + goto yyerrlab1; + + + /*---------------------------------------------------. + | yyerrorlab -- error raised explicitly by YYERROR. | + `---------------------------------------------------*/ + yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (false) + goto yyerrorlab;]b4_locations_if([[ + yyerror_range[1].location = yystack_[yylen - 1].location;]])b4_variant_if([[ + /* $$ was initialized before running the user action. */ + YY_SYMBOL_PRINT ("Error: discarding", yylhs); + yylhs.~stack_symbol_type();]])[ + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + yypop_ (yylen); + yylen = 0; + goto yyerrlab1; + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + yyerrlab1: + yyerrstatus_ = 3; // Each real token shifted decrements this. + { + stack_symbol_type error_token; + for (;;) + { + yyn = yypact_[yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += yyterror_; + if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + // Pop the current state because it cannot handle the error token. + if (yystack_.size () == 1) + YYABORT; +]b4_locations_if([[ + yyerror_range[1].location = yystack_[0].location;]])[ + yy_destroy_ ("Error: popping", yystack_[0]); + yypop_ (); + YY_STACK_PRINT (); + } +]b4_locations_if([[ + yyerror_range[2].location = yyla.location; + YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);]])[ + + // Shift the error token. + error_token.state = yyn; + yypush_ ("Shifting", error_token); + } + goto yynewstate; + + // Accept. + yyacceptlab: + yyresult = 0; + goto yyreturn; + + // Abort. + yyabortlab: + yyresult = 1; + goto yyreturn; + + yyreturn: + if (!yyempty) + yy_destroy_ ("Cleanup: discarding lookahead", yyla); + + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + yypop_ (yylen); + while (1 < yystack_.size ()) + { + yy_destroy_ ("Cleanup: popping", yystack_[0]); + yypop_ (); + } + + return yyresult; + } + catch (...) + { + YYCDEBUG << "Exception caught: cleaning lookahead and stack" + << std::endl; + // Do not try to display the values of the reclaimed symbols, + // as their printer might throw an exception. + if (!yyempty) + yy_destroy_ (YY_NULL, yyla); + + while (1 < yystack_.size ()) + { + yy_destroy_ (YY_NULL, yystack_[0]); + yypop_ (); + } + throw; + } + } + + void + ]b4_parser_class_name[::error (const syntax_error& yyexc) + { + error (]b4_join(b4_locations_if([yyexc.location]), + [[yyexc.what()]])[); + } + + // Generate an error message. + std::string + ]b4_parser_class_name[::yysyntax_error_ (]dnl +b4_error_verbose_if([state_type yystate, symbol_number_type yytoken], + [state_type, symbol_number_type])[) const + {]b4_error_verbose_if([[ + std::string yyres; + // Number of reported tokens (one for the "unexpected", one per + // "expected"). + size_t yycount = 0; + // Its maximum. + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + // Arguments of yyformat. + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yytoken) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is + a consistent state with a default action. There might have + been a previous inconsistent state, consistent state with a + non-default action, or user semantic action that manipulated + yyla. (However, yyla is currently not documented for users.) + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state + merging (from LALR or IELR) and default reductions corrupt the + expected token list. However, the list is correct for + canonical LR with one exception: it will still contain any + token that will not be accepted due to an error action in a + later state. + */ + if (yytoken != yyempty_) + { + yyarg[yycount++] = yytname_[yytoken]; + int yyn = yypact_[yystate]; + if (!yy_pact_value_is_default_ (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + // Stay within bounds of both yycheck and yytname. + int yychecklim = yylast_ - yyn + 1; + int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_ + && !yy_table_value_is_error_ (yytable_[yyx + yyn])) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + break; + } + else + yyarg[yycount++] = yytname_[yyx]; + } + } + } + + char const* yyformat = YY_NULL; + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + // Argument number. + size_t yyi = 0; + for (char const* yyp = yyformat; *yyp; ++yyp) + if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) + { + yyres += yytnamerr_ (yyarg[yyi++]); + ++yyp; + } + else + yyres += *yyp; + return yyres;]], [[ + return YY_("syntax error");]])[ + } + + + const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[; + + const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[; + +]b4_parser_tables_define[ + +]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[ + // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + // First, the terminals, then, starting at \a yyntokens_, nonterminals. + const char* + const ]b4_parser_class_name[::yytname_[] = + { + ]b4_tname[ + }; + +]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[ +]b4_integral_parser_table_define([rline], [b4_rline])[ + + // Print the state stack on the debug stream. + void + ]b4_parser_class_name[::yystack_print_ () + { + *yycdebug_ << "Stack now"; + for (stack_type::const_iterator + i = yystack_.begin (), + i_end = yystack_.end (); + i != i_end; ++i) + *yycdebug_ << ' ' << i->state; + *yycdebug_ << std::endl; + } + + // Report on the debug stream that the rule \a yyrule is going to be reduced. + void + ]b4_parser_class_name[::yy_reduce_print_ (int yyrule) + { + unsigned int yylno = yyrline_[yyrule]; + int yynrhs = yyr2_[yyrule]; + // Print the symbols being reduced, and their result. + *yycdebug_ << "Reducing stack by rule " << yyrule - 1 + << " (line " << yylno << "):" << std::endl; + // The symbols being reduced. + for (int yyi = 0; yyi < yynrhs; yyi++) + YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", + ]b4_rhs_data(yynrhs, yyi + 1)[); + } +#endif // ]b4_api_PREFIX[DEBUG + +]b4_token_ctor_if([], [b4_yytranslate_define])[ +]b4_namespace_close[ +]b4_epilogue[]dnl +b4_output_end() + + +m4_popdef([b4_copyright_years])dnl diff --git a/gnuwin32/bin/data/lalr1.java b/gnuwin32/bin/data/lalr1.java new file mode 100644 index 00000000..d137ed81 --- /dev/null +++ b/gnuwin32/bin/data/lalr1.java @@ -0,0 +1,1065 @@ +# Java skeleton for Bison -*- autoconf -*- + +# Copyright (C) 2007-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_include(b4_pkgdatadir/[java.m4]) + +b4_defines_if([b4_fatal([%s: %%defines does not make sense in Java], + [b4_skeleton])]) + +# We do not depend on %debug in Java, but pacify warnings about +# non-used flags. +b4_parse_trace_if([0], [0]) + +m4_define([b4_symbol_no_destructor_assert], +[b4_symbol_if([$1], [has_destructor], + [b4_fatal([%s: %s: %%destructor does not make sense in Java], + [b4_skeleton], + [b4_symbol_action_location([$1], [destructor])])])]) +b4_symbol_foreach([b4_symbol_no_destructor_assert]) + +# Setup some macros for api.push-pull. +b4_percent_define_default([[api.push-pull]], [[pull]]) +b4_percent_define_check_values([[[[api.push-pull]], + [[pull]], [[push]], [[both]]]]) + +# Define m4 conditional macros that encode the value +# of the api.push-pull flag. +b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]]) +b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]]) +m4_case(b4_percent_define_get([[api.push-pull]]), + [pull], [m4_define([b4_push_flag], [[0]])], + [push], [m4_define([b4_pull_flag], [[0]])]) + +# Define a macro to be true when api.push-pull has the value "both". +m4_define([b4_both_if],[b4_push_if([b4_pull_if([$1],[$2])],[$2])]) + +# Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing +# tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the +# behavior of Bison at all when push parsing is already requested. +b4_define_flag_if([use_push_for_pull]) +b4_use_push_for_pull_if([ + b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])], + [m4_define([b4_push_flag], [[1]])])]) + +# Define a macro to encapsulate the parse state variables. +# This allows them to be defined either in parse() when doing +# pull parsing, or as class instance variable when doing push parsing. +m4_define([b4_define_state],[[ + /* Lookahead and lookahead in internal form. */ + int yychar = yyempty_; + int yytoken = 0; + + /* State. */ + int yyn = 0; + int yylen = 0; + int yystate = 0; + YYStack yystack = new YYStack (); + int label = YYNEWSTATE; + + /* Error handling. */ + int yynerrs_ = 0; + ]b4_locations_if([/* The location where the error started. */ + b4_location_type yyerrloc = null; + + /* Location. */ + b4_location_type yylloc = new b4_location_type (null, null);])[ + + /* Semantic value of the lookahead. */ + ]b4_yystype[ yylval = null; +]]) + +b4_output_begin([b4_parser_file_name]) +b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java], + [2007-2013]) + +b4_percent_define_ifdef([package], [package b4_percent_define_get([package]); +])[/* First part of user declarations. */ +]b4_user_pre_prologue +b4_user_post_prologue +b4_percent_code_get([[imports]]) +[/** + * A Bison parser, automatically generated from ]m4_bpatsubst(b4_file_name, [^"\(.*\)"$], [\1])[. + * + * @@author LALR (1) parser skeleton written by Paolo Bonzini. + */ +]b4_percent_define_get3([annotations], [], [ ])dnl +b4_public_if([public ])dnl +b4_abstract_if([abstract ])dnl +b4_final_if([final ])dnl +b4_strictfp_if([strictfp ])dnl +[class ]b4_parser_class_name[]dnl +b4_percent_define_get3([extends], [ extends ])dnl +b4_percent_define_get3([implements], [ implements ])[ +{ + ]b4_identification[ +]b4_error_verbose_if([[ + /** + * True if verbose error messages are enabled. + */ + private boolean yyErrorVerbose = true; + + /** + * Return whether verbose error messages are enabled. + */ + public final boolean getErrorVerbose() { return yyErrorVerbose; } + + /** + * Set the verbosity of error messages. + * @@param verbose True to request verbose error messages. + */ + public final void setErrorVerbose(boolean verbose) + { yyErrorVerbose = verbose; } +]]) + +b4_locations_if([[ + /** + * A class defining a pair of positions. Positions, defined by the + * ]b4_position_type[ class, denote a point in the input. + * Locations represent a part of the input through the beginning + * and ending positions. + */ + public class ]b4_location_type[ { + /** + * The first, inclusive, position in the range. + */ + public ]b4_position_type[ begin; + + /** + * The first position beyond the range. + */ + public ]b4_position_type[ end; + + /** + * Create a ]b4_location_type[ denoting an empty range located at + * a given point. + * @@param loc The position at which the range is anchored. + */ + public ]b4_location_type[ (]b4_position_type[ loc) { + this.begin = this.end = loc; + } + + /** + * Create a ]b4_location_type[ from the endpoints of the range. + * @@param begin The first position included in the range. + * @@param end The first position beyond the range. + */ + public ]b4_location_type[ (]b4_position_type[ begin, ]b4_position_type[ end) { + this.begin = begin; + this.end = end; + } + + /** + * Print a representation of the location. For this to be correct, + * ]b4_position_type[ should override the equals + * method. + */ + public String toString () { + if (begin.equals (end)) + return begin.toString (); + else + return begin.toString () + "-" + end.toString (); + } + } + +]]) + + b4_locations_if([[ + private ]b4_location_type[ yylloc (YYStack rhs, int n) + { + if (n > 0) + return new ]b4_location_type[ (rhs.locationAt (n-1).begin, rhs.locationAt (0).end); + else + return new ]b4_location_type[ (rhs.locationAt (0).end); + }]])[ + + /** + * Communication interface between the scanner and the Bison-generated + * parser ]b4_parser_class_name[. + */ + public interface Lexer { + /** Token returned by the scanner to signal the end of its input. */ + public static final int EOF = 0; + +]b4_token_enums[ + + ]b4_locations_if([[/** + * Method to retrieve the beginning position of the last scanned token. + * @@return the position at which the last scanned token starts. + */ + ]b4_position_type[ getStartPos (); + + /** + * Method to retrieve the ending position of the last scanned token. + * @@return the first position beyond the last scanned token. + */ + ]b4_position_type[ getEndPos ();]])[ + + /** + * Method to retrieve the semantic value of the last scanned token. + * @@return the semantic value of the last scanned token. + */ + ]b4_yystype[ getLVal (); + + /** + * Entry point for the scanner. Returns the token identifier corresponding + * to the next token and prepares to return the semantic value + * ]b4_locations_if([and beginning/ending positions ])[of the token. + * @@return the token identifier corresponding to the next token. + */ + int yylex () ]b4_maybe_throws([b4_lex_throws])[; + + /** + * Entry point for error reporting. Emits an error + * ]b4_locations_if([referring to the given location ])[in a user-defined way. + * + * ]b4_locations_if([[@@param loc The location of the element to which the + * error message is related]])[ + * @@param msg The string for the error message. + */ + void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String msg);] + } + + b4_lexer_if([[private class YYLexer implements Lexer { +]b4_percent_code_get([[lexer]])[ + } + + ]])[/** + * The object doing lexical analysis for us. + */ + private Lexer yylexer; + ] + b4_parse_param_vars + +b4_lexer_if([[ + /** + * Instantiates the Bison-generated parser. + */ + public ]b4_parser_class_name (b4_parse_param_decl([b4_lex_param_decl])[) ]b4_maybe_throws([b4_init_throws])[ + { + ]b4_percent_code_get([[init]])[ + this.yylexer = new YYLexer(]b4_lex_param_call[); + ]b4_parse_param_cons[ + } +]]) + + /** + * Instantiates the Bison-generated parser. + * @@param yylexer The scanner that will supply tokens to the parser. + */ + b4_lexer_if([[protected]], [[public]]) b4_parser_class_name[ (]b4_parse_param_decl([[Lexer yylexer]])[) ]b4_maybe_throws([b4_init_throws])[ + { + ]b4_percent_code_get([[init]])[ + this.yylexer = yylexer; + ]b4_parse_param_cons[ + } + + private java.io.PrintStream yyDebugStream = System.err; + + /** + * Return the PrintStream on which the debugging output is + * printed. + */ + public final java.io.PrintStream getDebugStream () { return yyDebugStream; } + + /** + * Set the PrintStream on which the debug output is printed. + * @@param s The stream that is used for debugging output. + */ + public final void setDebugStream(java.io.PrintStream s) { yyDebugStream = s; } + + private int yydebug = 0; + + /** + * Answer the verbosity of the debugging output; 0 means that all kinds of + * output from the parser are suppressed. + */ + public final int getDebugLevel() { return yydebug; } + + /** + * Set the verbosity of the debugging output; 0 means that all kinds of + * output from the parser are suppressed. + * @@param level The verbosity level for debugging output. + */ + public final void setDebugLevel(int level) { yydebug = level; } + + /** + * Print an error message via the lexer. + *]b4_locations_if([[ Use a null location.]])[ + * @@param msg The error message. + */ + public final void yyerror (String msg) + { + yylexer.yyerror (]b4_locations_if([[(]b4_location_type[)null, ]])[msg); + } +]b4_locations_if([[ + /** + * Print an error message via the lexer. + * @@param loc The location associated with the message. + * @@param msg The error message. + */ + public final void yyerror (]b4_location_type[ loc, String msg) + { + yylexer.yyerror (loc, msg); + } + + /** + * Print an error message via the lexer. + * @@param pos The position associated with the message. + * @@param msg The error message. + */ + public final void yyerror (]b4_position_type[ pos, String msg) + { + yylexer.yyerror (new ]b4_location_type[ (pos), msg); + }]]) + + [protected final void yycdebug (String s) { + if (yydebug > 0) + yyDebugStream.println (s); + } + + private final class YYStack { + private int[] stateStack = new int[16]; + ]b4_locations_if([[private ]b4_location_type[[] locStack = new ]b4_location_type[[16];]])[ + private ]b4_yystype[[] valueStack = new ]b4_yystype[[16]; + + public int size = 16; + public int height = -1; + + public final void push (int state, ]b4_yystype[ value]dnl + b4_locations_if([, ]b4_location_type[ loc])[) { + height++; + if (size == height) + { + int[] newStateStack = new int[size * 2]; + System.arraycopy (stateStack, 0, newStateStack, 0, height); + stateStack = newStateStack; + ]b4_locations_if([[ + ]b4_location_type[[] newLocStack = new ]b4_location_type[[size * 2]; + System.arraycopy (locStack, 0, newLocStack, 0, height); + locStack = newLocStack;]]) + + b4_yystype[[] newValueStack = new ]b4_yystype[[size * 2]; + System.arraycopy (valueStack, 0, newValueStack, 0, height); + valueStack = newValueStack; + + size *= 2; + } + + stateStack[height] = state; + ]b4_locations_if([[locStack[height] = loc;]])[ + valueStack[height] = value; + } + + public final void pop () { + pop (1); + } + + public final void pop (int num) { + // Avoid memory leaks... garbage collection is a white lie! + if (num > 0) { + java.util.Arrays.fill (valueStack, height - num + 1, height + 1, null); + ]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height + 1, null);]])[ + } + height -= num; + } + + public final int stateAt (int i) { + return stateStack[height - i]; + } + + ]b4_locations_if([[public final ]b4_location_type[ locationAt (int i) { + return locStack[height - i]; + } + + ]])[public final ]b4_yystype[ valueAt (int i) { + return valueStack[height - i]; + } + + // Print the state stack on the debug stream. + public void print (java.io.PrintStream out) + { + out.print ("Stack now"); + + for (int i = 0; i <= height; i++) + { + out.print (' '); + out.print (stateStack[i]); + } + out.println (); + } + } + + /** + * Returned by a Bison action in order to stop the parsing process and + * return success (true). + */ + public static final int YYACCEPT = 0; + + /** + * Returned by a Bison action in order to stop the parsing process and + * return failure (false). + */ + public static final int YYABORT = 1; + +]b4_push_if([ + /** + * Returned by a Bison action in order to request a new token. + */ + public static final int YYPUSH_MORE = 4;])[ + + /** + * Returned by a Bison action in order to start error recovery without + * printing an error message. + */ + public static final int YYERROR = 2; + + /** + * Internal return codes that are not supported for user semantic + * actions. + */ + private static final int YYERRLAB = 3; + private static final int YYNEWSTATE = 4; + private static final int YYDEFAULT = 5; + private static final int YYREDUCE = 6; + private static final int YYERRLAB1 = 7; + private static final int YYRETURN = 8; +]b4_push_if([[ private static final int YYGETTOKEN = 9; /* Signify that a new token is expected when doing push-parsing. */]])[ + + private int yyerrstatus_ = 0; + +]b4_push_if([dnl +b4_define_state])[ + /** + * Return whether error recovery is being done. In this state, the parser + * reads token until it reaches a known state, and then restarts normal + * operation. + */ + public final boolean recovering () + { + return yyerrstatus_ == 0; + } + + private int yyaction (int yyn, YYStack yystack, int yylen) ]b4_maybe_throws([b4_throws])[ + { + ]b4_yystype[ yyval; + ]b4_locations_if([b4_location_type[ yyloc = yylloc (yystack, yylen);]])[ + + /* If YYLEN is nonzero, implement the default value of the action: + '$$ = $1'. Otherwise, use the top of the stack. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. */ + if (yylen > 0) + yyval = yystack.valueAt (yylen - 1); + else + yyval = yystack.valueAt (0); + + yy_reduce_print (yyn, yystack); + + switch (yyn) + { + ]b4_user_actions[ + default: break; + } + + yy_symbol_print ("-> $$ =", yyr1_[yyn], yyval]b4_locations_if([, yyloc])[); + + yystack.pop (yylen); + yylen = 0; + + /* Shift the result of the reduction. */ + yyn = yyr1_[yyn]; + int yystate = yypgoto_[yyn - yyntokens_] + yystack.stateAt (0); + if (0 <= yystate && yystate <= yylast_ + && yycheck_[yystate] == yystack.stateAt (0)) + yystate = yytable_[yystate]; + else + yystate = yydefgoto_[yyn - yyntokens_]; + + yystack.push (yystate, yyval]b4_locations_if([, yyloc])[); + return YYNEWSTATE; + } + +]b4_error_verbose_if([[ + /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ + private final String yytnamerr_ (String yystr) + { + if (yystr.charAt (0) == '"') + { + StringBuffer yyr = new StringBuffer (); + strip_quotes: for (int i = 1; i < yystr.length (); i++) + switch (yystr.charAt (i)) + { + case '\'': + case ',': + break strip_quotes; + + case '\\': + if (yystr.charAt(++i) != '\\') + break strip_quotes; + /* Fall through. */ + default: + yyr.append (yystr.charAt (i)); + break; + + case '"': + return yyr.toString (); + } + } + else if (yystr.equals ("$end")) + return "end of input"; + + return yystr; + } +]])[ + + /*--------------------------------. + | Print this symbol on YYOUTPUT. | + `--------------------------------*/ + + private void yy_symbol_print (String s, int yytype, + ]b4_yystype[ yyvaluep]dnl + b4_locations_if([, Object yylocationp])[) + { + if (yydebug > 0) + yycdebug (s + (yytype < yyntokens_ ? " token " : " nterm ") + + yytname_[yytype] + " ("]b4_locations_if([ + + yylocationp + ": "])[ + + (yyvaluep == null ? "(null)" : yyvaluep.toString ()) + ")"); + } + +]b4_push_if([],[[ + /** + * Parse input from the scanner that was specified at object construction + * time. Return whether the end of the input was reached successfully. + * + * @@return true if the parsing succeeds. Note that this does not + * imply that there were no syntax errors. + */ + public boolean parse () ]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[]])[ +]b4_push_if([ + /** + * Push Parse input from external lexer + * + * @@param yylextoken current token + * @@param yylexval current lval +]b4_locations_if([ * @@param yylexloc current position])[ + * + * @@return YYACCEPT, YYABORT, YYPUSH_MORE + */ + public int push_parse (int yylextoken, b4_yystype yylexval[]b4_locations_if([, b4_location_type yylexloc])) + b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])])[ + { + ]b4_locations_if([/* @@$. */ + b4_location_type yyloc;])[ +]b4_push_if([],[[ +]b4_define_state[ + yycdebug ("Starting parse\n"); + yyerrstatus_ = 0; + + /* Initialize the stack. */ + yystack.push (yystate, yylval ]b4_locations_if([, yylloc])[); +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [yylloc])dnl + /* User initialization code. */ + b4_user_initial_action +b4_dollar_popdef[]dnl +])[ +]])[ +]b4_push_if([[ + if (!this.push_parse_initialized) + { + push_parse_initialize (); +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [yylloc])dnl + /* User initialization code. */ + b4_user_initial_action +b4_dollar_popdef[]dnl +])[ + yycdebug ("Starting parse\n"); + yyerrstatus_ = 0; + } else + label = YYGETTOKEN; + + boolean push_token_consumed = true; +]])[ + for (;;) + switch (label) + { + /* New state. Unlike in the C/C++ skeletons, the state is already + pushed when we come here. */ + case YYNEWSTATE: + yycdebug ("Entering state " + yystate + "\n"); + if (yydebug > 0) + yystack.print (yyDebugStream); + + /* Accept? */ + if (yystate == yyfinal_) + ]b4_push_if([{label = YYACCEPT; break;}], + [return true;])[ + + /* Take a decision. First try without lookahead. */ + yyn = yypact_[yystate]; + if (yy_pact_value_is_default_ (yyn)) + { + label = YYDEFAULT; + break; + } +]b4_push_if([ /* Fall Through */ + + case YYGETTOKEN:])[ + /* Read a lookahead token. */ + if (yychar == yyempty_) + { +]b4_push_if([[ + if (!push_token_consumed) + return YYPUSH_MORE; + yycdebug ("Reading a token: "); + yychar = yylextoken; + yylval = yylexval;]b4_locations_if([ + yylloc = yylexloc;])[ + push_token_consumed = false;]])[ +]b4_push_if([],[[ + yycdebug ("Reading a token: "); + yychar = yylexer.yylex (); + yylval = yylexer.getLVal ();]b4_locations_if([ + yylloc = new b4_location_type (yylexer.getStartPos (), + yylexer.getEndPos ());])[ +]])[ + } + + /* Convert token to internal form. */ + if (yychar <= Lexer.EOF) + { + yychar = yytoken = Lexer.EOF; + yycdebug ("Now at end of input.\n"); + } + else + { + yytoken = yytranslate_ (yychar); + yy_symbol_print ("Next token is", yytoken, + yylval]b4_locations_if([, yylloc])[); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) + label = YYDEFAULT; + + /* <= 0 means reduce or error. */ + else if ((yyn = yytable_[yyn]) <= 0) + { + if (yy_table_value_is_error_ (yyn)) + label = YYERRLAB; + else + { + yyn = -yyn; + label = YYREDUCE; + } + } + + else + { + /* Shift the lookahead token. */ + yy_symbol_print ("Shifting", yytoken, + yylval]b4_locations_if([, yylloc])[); + + /* Discard the token being shifted. */ + yychar = yyempty_; + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus_ > 0) + --yyerrstatus_; + + yystate = yyn; + yystack.push (yystate, yylval]b4_locations_if([, yylloc])[); + label = YYNEWSTATE; + } + break; + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + case YYDEFAULT: + yyn = yydefact_[yystate]; + if (yyn == 0) + label = YYERRLAB; + else + label = YYREDUCE; + break; + + /*-----------------------------. + | yyreduce -- Do a reduction. | + `-----------------------------*/ + case YYREDUCE: + yylen = yyr2_[yyn]; + label = yyaction (yyn, yystack, yylen); + yystate = yystack.stateAt (0); + break; + + /*------------------------------------. + | yyerrlab -- here on detecting error | + `------------------------------------*/ + case YYERRLAB: + /* If not already recovering from an error, report this error. */ + if (yyerrstatus_ == 0) + { + ++yynerrs_; + if (yychar == yyempty_) + yytoken = yyempty_; + yyerror (]b4_locations_if([yylloc, ])[yysyntax_error (yystate, yytoken)); + } + + ]b4_locations_if([yyerrloc = yylloc;])[ + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= Lexer.EOF) + { + /* Return failure if at end of input. */ + if (yychar == Lexer.EOF) + ]b4_push_if([{label = YYABORT; break;}],[return false;])[ + } + else + yychar = yyempty_; + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + label = YYERRLAB1; + break; + + /*-------------------------------------------------. + | errorlab -- error raised explicitly by YYERROR. | + `-------------------------------------------------*/ + case YYERROR: + + ]b4_locations_if([yyerrloc = yystack.locationAt (yylen - 1);])[ + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + yystack.pop (yylen); + yylen = 0; + yystate = yystack.stateAt (0); + label = YYERRLAB1; + break; + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + case YYERRLAB1: + yyerrstatus_ = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact_[yystate]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += yyterror_; + if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the + * error token. */ + if (yystack.height == 0) + ]b4_push_if([{label = YYABORT; break;}],[return false;])[ + + ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[ + yystack.pop (); + yystate = yystack.stateAt (0); + if (yydebug > 0) + yystack.print (yyDebugStream); + } + + if (label == YYABORT) + /* Leave the switch. */ + break; + +]b4_locations_if([ + /* Muck with the stack to setup for yylloc. */ + yystack.push (0, null, yylloc); + yystack.push (0, null, yyerrloc); + yyloc = yylloc (yystack, 2); + yystack.pop (2);])[ + + /* Shift the error token. */ + yy_symbol_print ("Shifting", yystos_[yyn], + yylval]b4_locations_if([, yyloc])[); + + yystate = yyn; + yystack.push (yyn, yylval]b4_locations_if([, yyloc])[); + label = YYNEWSTATE; + break; + + /* Accept. */ + case YYACCEPT: + ]b4_push_if([this.push_parse_initialized = false; return YYACCEPT;], + [return true;])[ + + /* Abort. */ + case YYABORT: + ]b4_push_if([this.push_parse_initialized = false; return YYABORT;], + [return false;])[ + } +} +]b4_push_if([[ + boolean push_parse_initialized = false; + + /** + * (Re-)Initialize the state of the push parser. + */ + public void push_parse_initialize() + { + /* Lookahead and lookahead in internal form. */ + this.yychar = yyempty_; + this.yytoken = 0; + + /* State. */ + this.yyn = 0; + this.yylen = 0; + this.yystate = 0; + this.yystack = new YYStack (); + this.label = YYNEWSTATE; + + /* Error handling. */ + this.yynerrs_ = 0; + ]b4_locations_if([/* The location where the error started. */ + this.yyerrloc = null; + this.yylloc = new b4_location_type (null, null);])[ + + /* Semantic value of the lookahead. */ + this.yylval = null; + + yystack.push (this.yystate, this.yylval]b4_locations_if([, this.yylloc])[); + + this.push_parse_initialized = true; + + } +]b4_locations_if([ + /** + * Push parse given input from an external lexer. + * + * @@param yylextoken current token + * @@param yylexval current lval + * @@param yyylexpos current position + * + * @@return YYACCEPT, YYABORT, YYPUSH_MORE + */ + public int push_parse (int yylextoken, b4_yystype yylexval, b4_position_type yylexpos) + b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])]) + { + return push_parse (yylextoken, yylexval, new b4_location_type (yylexpos)); + } +])[]]) + +b4_both_if([[ + /** + * Parse input from the scanner that was specified at object construction + * time. Return whether the end of the input was reached successfully. + * This version of parse () is defined only when api.push-push=both. + * + * @@return true if the parsing succeeds. Note that this does not + * imply that there were no syntax errors. + */ + public boolean parse () ]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[ + { + if (yylexer == null) + throw new NullPointerException("Null Lexer"); + int status; + do { + int token = yylexer.yylex(); + ]b4_yystype[ lval = yylexer.getLVal(); +]b4_locations_if([dnl + b4_location_type yyloc = new b4_location_type (yylexer.getStartPos (), + yylexer.getEndPos ());])[ + ]b4_locations_if([status = push_parse(token,lval,yyloc);],[ + status = push_parse(token,lval);])[ + } while (status == YYPUSH_MORE); + return (status == YYACCEPT); + } +]])[ + + // Generate an error message. + private String yysyntax_error (int yystate, int tok) + {]b4_error_verbose_if([[ + if (yyErrorVerbose) + { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, + then the only way this function was invoked is if the + default action is an error action. In that case, don't + check for expected tokens because there are none. + - The only way there can be no lookahead present (in tok) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this + state is a consistent state with a default action. There + might have been a previous inconsistent state, consistent + state with a non-default action, or user semantic action + that manipulated yychar. (However, yychar is currently out + of scope during semantic actions.) + - Of course, the expected token list depends on states to + have correct lookahead information, and it depends on the + parser not to perform extra reductions after fetching a + lookahead from the scanner and before detecting a syntax + error. Thus, state merging (from LALR or IELR) and default + reductions corrupt the expected token list. However, the + list is correct for canonical LR with one exception: it + will still contain any token that will not be accepted due + to an error action in a later state. + */ + if (tok != yyempty_) + { + /* FIXME: This method of building the message is not compatible + with internationalization. */ + StringBuffer res = + new StringBuffer ("syntax error, unexpected "); + res.append (yytnamerr_ (yytname_[tok])); + int yyn = yypact_[yystate]; + if (!yy_pact_value_is_default_ (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative + indexes in YYCHECK. In other words, skip the first + -YYN actions for this state because they are default + actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = yylast_ - yyn + 1; + int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; + int count = 0; + for (int x = yyxbegin; x < yyxend; ++x) + if (yycheck_[x + yyn] == x && x != yyterror_ + && !yy_table_value_is_error_ (yytable_[x + yyn])) + ++count; + if (count < 5) + { + count = 0; + for (int x = yyxbegin; x < yyxend; ++x) + if (yycheck_[x + yyn] == x && x != yyterror_ + && !yy_table_value_is_error_ (yytable_[x + yyn])) + { + res.append (count++ == 0 ? ", expecting " : " or "); + res.append (yytnamerr_ (yytname_[x])); + } + } + } + return res.toString (); + } + } +]])[ + return "syntax error"; + } + + /** + * Whether the given yypact_ value indicates a defaulted state. + * @@param yyvalue the value to check + */ + private static boolean yy_pact_value_is_default_ (int yyvalue) + { + return yyvalue == yypact_ninf_; + } + + /** + * Whether the given yytable_ + * value indicates a syntax error. + * @@param yyvalue the value to check + */ + private static boolean yy_table_value_is_error_ (int yyvalue) + { + return yyvalue == yytable_ninf_; + } + + private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[; + private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[; + + ]b4_parser_tables_define[ + ]b4_integral_parser_table_define([token_number], [b4_toknum], + [[YYTOKEN_NUMBER[YYLEX-NUM] -- Internal symbol number corresponding + to YYLEX-NUM.]])[ + + /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at \a yyntokens_, nonterminals. */ + ]b4_typed_parser_table_define([String], [tname], [b4_tname])[ + + ]b4_integral_parser_table_define([rline], [b4_rline], + [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[ + + + // Report on the debug stream that the rule yyrule is going to be reduced. + private void yy_reduce_print (int yyrule, YYStack yystack) + { + if (yydebug == 0) + return; + + int yylno = yyrline_[yyrule]; + int yynrhs = yyr2_[yyrule]; + /* Print the symbols being reduced, and their result. */ + yycdebug ("Reducing stack by rule " + (yyrule - 1) + + " (line " + yylno + "), "); + + /* The symbols being reduced. */ + for (int yyi = 0; yyi < yynrhs; yyi++) + yy_symbol_print (" $" + (yyi + 1) + " =", + yystos_[yystack.stateAt(yynrhs - (yyi + 1))], + ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([, + b4_rhs_location(yynrhs, yyi + 1)])[); + } + + /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ + ]b4_integral_parser_table_define([translate_table], [b4_translate])[ + + private static final ]b4_int_type_for([b4_translate])[ yytranslate_ (int t) + { + if (t >= 0 && t <= yyuser_token_number_max_) + return yytranslate_table_[t]; + else + return yyundef_token_; + } + + private static final int yylast_ = ]b4_last[; + private static final int yynnts_ = ]b4_nterms_number[; + private static final int yyempty_ = -2; + private static final int yyfinal_ = ]b4_final_state_number[; + private static final int yyterror_ = 1; + private static final int yyerrcode_ = 256; + private static final int yyntokens_ = ]b4_tokens_number[; + + private static final int yyuser_token_number_max_ = ]b4_user_token_number_max[; + private static final int yyundef_token_ = ]b4_undef_token_number[; + +]/* User implementation code. */ +b4_percent_code_get[]dnl + +} + +b4_epilogue[]dnl +b4_output_end() diff --git a/gnuwin32/bin/data/local.mk b/gnuwin32/bin/data/local.mk new file mode 100644 index 00000000..b8290522 --- /dev/null +++ b/gnuwin32/bin/data/local.mk @@ -0,0 +1,45 @@ +## Copyright (C) 2002, 2005-2013 Free Software Foundation, Inc. + +## This program is free software: you can redistribute it and/or modify +## it under the terms of the GNU General Public License as published by +## the Free Software Foundation, either version 3 of the License, or +## (at your option) any later version. +## +## This program is distributed in the hope that it will be useful, +## but WITHOUT ANY WARRANTY; without even the implied warranty of +## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +## GNU General Public License for more details. +## +## You should have received a copy of the GNU General Public License +## along with this program. If not, see . + +dist_pkgdata_DATA = \ + data/README \ + data/bison.m4 \ + data/c++-skel.m4 \ + data/c++.m4 \ + data/c-like.m4 \ + data/c-skel.m4 \ + data/c.m4 \ + data/glr.c \ + data/glr.cc \ + data/java-skel.m4 \ + data/java.m4 \ + data/lalr1.cc \ + data/lalr1.java \ + data/location.cc \ + data/stack.hh \ + data/variant.hh \ + data/yacc.c + +m4sugardir = $(pkgdatadir)/m4sugar +dist_m4sugar_DATA = \ + data/m4sugar/foreach.m4 \ + data/m4sugar/m4sugar.m4 + +xsltdir = $(pkgdatadir)/xslt +dist_xslt_DATA = \ + data/xslt/bison.xsl \ + data/xslt/xml2dot.xsl \ + data/xslt/xml2text.xsl \ + data/xslt/xml2xhtml.xsl diff --git a/gnuwin32/bin/data/location.cc b/gnuwin32/bin/data/location.cc new file mode 100644 index 00000000..9a60f250 --- /dev/null +++ b/gnuwin32/bin/data/location.cc @@ -0,0 +1,335 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_pushdef([b4_copyright_years], + [2002-2013]) + +# b4_position_define +# ------------------ +# Define class position. +m4_define([b4_position_define], +[[ /// Abstract a position. + class position + { + public:]m4_ifdef([b4_location_constructors], [[ + /// Construct a position. + explicit position (]b4_percent_define_get([[filename_type]])[* f = YY_NULL, + unsigned int l = ]b4_location_initial_line[u, + unsigned int c = ]b4_location_initial_column[u) + : filename (f) + , line (l) + , column (c) + { + } + +]])[ + /// Initialization. + void initialize (]b4_percent_define_get([[filename_type]])[* fn = YY_NULL, + unsigned int l = ]b4_location_initial_line[u, + unsigned int c = ]b4_location_initial_column[u) + { + filename = fn; + line = l; + column = c; + } + + /** \name Line and Column related manipulators + ** \{ */ + /// (line related) Advance to the COUNT next lines. + void lines (int count = 1) + { + if (count) + { + column = ]b4_location_initial_column[u; + line = add_ (line, count, ]b4_location_initial_line[); + } + } + + /// (column related) Advance to the COUNT next columns. + void columns (int count = 1) + { + column = add_ (column, count, ]b4_location_initial_column[); + } + /** \} */ + + /// File name to which this position refers. + ]b4_percent_define_get([[filename_type]])[* filename; + /// Current line number. + unsigned int line; + /// Current column number. + unsigned int column; + + private: + /// Compute max(min, lhs+rhs) (provided min <= lhs). + static unsigned int add_ (unsigned int lhs, int rhs, unsigned int min) + { + return (0 < rhs || -static_cast(rhs) < lhs + ? rhs + lhs + : min); + } + }; + + /// Add and assign a position. + inline position& + operator+= (position& res, int width) + { + res.columns (width); + return res; + } + + /// Add two position objects. + inline position + operator+ (position res, int width) + { + return res += width; + } + + /// Add and assign a position. + inline position& + operator-= (position& res, int width) + { + return res += -width; + } + + /// Add two position objects. + inline position + operator- (position res, int width) + { + return res -= width; + } +]b4_percent_define_flag_if([[define_location_comparison]], [[ + /// Compare two position objects. + inline bool + operator== (const position& pos1, const position& pos2) + { + return (pos1.line == pos2.line + && pos1.column == pos2.column + && (pos1.filename == pos2.filename + || (pos1.filename && pos2.filename + && *pos1.filename == *pos2.filename))); + } + + /// Compare two position objects. + inline bool + operator!= (const position& pos1, const position& pos2) + { + return !(pos1 == pos2); + } +]])[ + /** \brief Intercept output stream redirection. + ** \param ostr the destination output stream + ** \param pos a reference to the position to redirect + */ + template + inline std::basic_ostream& + operator<< (std::basic_ostream& ostr, const position& pos) + { + if (pos.filename) + ostr << *pos.filename << ':'; + return ostr << pos.line << '.' << pos.column; + } +]]) + + +# b4_location_define +# ------------------ +m4_define([b4_location_define], +[[ /// Abstract a location. + class location + { + public: +]m4_ifdef([b4_location_constructors], [ + /// Construct a location from \a b to \a e. + location (const position& b, const position& e) + : begin (b) + , end (e) + { + } + + /// Construct a 0-width location in \a p. + explicit location (const position& p = position ()) + : begin (p) + , end (p) + { + } + + /// Construct a 0-width location in \a f, \a l, \a c. + explicit location (]b4_percent_define_get([[filename_type]])[* f, + unsigned int l = ]b4_location_initial_line[u, + unsigned int c = ]b4_location_initial_column[u) + : begin (f, l, c) + , end (f, l, c) + { + } + +])[ + /// Initialization. + void initialize (]b4_percent_define_get([[filename_type]])[* f = YY_NULL, + unsigned int l = ]b4_location_initial_line[u, + unsigned int c = ]b4_location_initial_column[u) + { + begin.initialize (f, l, c); + end = begin; + } + + /** \name Line and Column related manipulators + ** \{ */ + public: + /// Reset initial location to final location. + void step () + { + begin = end; + } + + /// Extend the current location to the COUNT next columns. + void columns (int count = 1) + { + end += count; + } + + /// Extend the current location to the COUNT next lines. + void lines (int count = 1) + { + end.lines (count); + } + /** \} */ + + + public: + /// Beginning of the located region. + position begin; + /// End of the located region. + position end; + }; + + /// Join two location objects to create a location. + inline location operator+ (location res, const location& end) + { + res.end = end.end; + return res; + } + + /// Change end position in place. + inline location& operator+= (location& res, int width) + { + res.columns (width); + return res; + } + + /// Change end position. + inline location operator+ (location res, int width) + { + return res += width; + } + + /// Change end position in place. + inline location& operator-= (location& res, int width) + { + return res += -width; + } + + /// Change end position. + inline location operator- (const location& begin, int width) + { + return begin + -width; + } +]b4_percent_define_flag_if([[define_location_comparison]], [[ + /// Compare two location objects. + inline bool + operator== (const location& loc1, const location& loc2) + { + return loc1.begin == loc2.begin && loc1.end == loc2.end; + } + + /// Compare two location objects. + inline bool + operator!= (const location& loc1, const location& loc2) + { + return !(loc1 == loc2); + } +]])[ + /** \brief Intercept output stream redirection. + ** \param ostr the destination output stream + ** \param loc a reference to the location to redirect + ** + ** Avoid duplicate information. + */ + template + inline std::basic_ostream& + operator<< (std::basic_ostream& ostr, const location& loc) + { + unsigned int end_col = 0 < loc.end.column ? loc.end.column - 1 : 0; + ostr << loc.begin// << "(" << loc.end << ") " +; + if (loc.end.filename + && (!loc.begin.filename + || *loc.begin.filename != *loc.end.filename)) + ostr << '-' << loc.end.filename << ':' << loc.end.line << '.' << end_col; + else if (loc.begin.line < loc.end.line) + ostr << '-' << loc.end.line << '.' << end_col; + else if (loc.begin.column < end_col) + ostr << '-' << end_col; + return ostr; + } +]]) + + +b4_defines_if([ +b4_output_begin([b4_dir_prefix[]position.hh]) +b4_copyright([Positions for Bison parsers in C++])[ + +/** + ** \file ]b4_dir_prefix[position.hh + ** Define the ]b4_namespace_ref[::position class. + */ + +]b4_cpp_guard_open([b4_dir_prefix[]position.hh])[ + +# include // std::max +# include +# include + +]b4_null_define[ + +]b4_namespace_open[ +]b4_position_define[ +]b4_namespace_close[ +]b4_cpp_guard_close([b4_dir_prefix[]position.hh]) +b4_output_end() + + +b4_output_begin([b4_dir_prefix[]location.hh]) +b4_copyright([Locations for Bison parsers in C++])[ + +/** + ** \file ]b4_dir_prefix[location.hh + ** Define the ]b4_namespace_ref[::location class. + */ + +]b4_cpp_guard_open([b4_dir_prefix[]location.hh])[ + +# include "position.hh" + +]b4_namespace_open[ +]b4_location_define[ +]b4_namespace_close[ +]b4_cpp_guard_close([b4_dir_prefix[]location.hh]) +b4_output_end() +]) + + +m4_popdef([b4_copyright_years]) diff --git a/gnuwin32/bin/data/m4sugar/foreach.m4 b/gnuwin32/bin/data/m4sugar/foreach.m4 new file mode 100644 index 00000000..f6a63944 --- /dev/null +++ b/gnuwin32/bin/data/m4sugar/foreach.m4 @@ -0,0 +1,362 @@ +# -*- Autoconf -*- +# This file is part of Autoconf. +# foreach-based replacements for recursive functions. +# Speeds up GNU M4 1.4.x by avoiding quadratic $@ recursion, but penalizes +# GNU M4 1.6 by requiring more memory and macro expansions. +# +# Copyright (C) 2008-2013 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see . + +# Written by Eric Blake. + +# In M4 1.4.x, every byte of $@ is rescanned. This means that an +# algorithm on n arguments that recurses with one less argument each +# iteration will scan n * (n + 1) / 2 arguments, for O(n^2) time. In +# M4 1.6, this was fixed so that $@ is only scanned once, then +# back-references are made to information stored about the scan. +# Thus, n iterations need only scan n arguments, for O(n) time. +# Additionally, in M4 1.4.x, recursive algorithms did not clean up +# memory very well, requiring O(n^2) memory rather than O(n) for n +# iterations. +# +# This file is designed to overcome the quadratic nature of $@ +# recursion by writing a variant of m4_foreach that uses m4_for rather +# than $@ recursion to operate on the list. This involves more macro +# expansions, but avoids the need to rescan a quadratic number of +# arguments, making these replacements very attractive for M4 1.4.x. +# On the other hand, in any version of M4, expanding additional macros +# costs additional time; therefore, in M4 1.6, where $@ recursion uses +# fewer macros, these replacements actually pessimize performance. +# Additionally, the use of $10 to mean the tenth argument violates +# POSIX; although all versions of m4 1.4.x support this meaning, a +# future m4 version may switch to take it as the first argument +# concatenated with a literal 0, so the implementations in this file +# are not future-proof. Thus, this file is conditionally included as +# part of m4_init(), only when it is detected that M4 probably has +# quadratic behavior (ie. it lacks the macro __m4_version__). +# +# Please keep this file in sync with m4sugar.m4. + +# _m4_foreach(PRE, POST, IGNORED, ARG...) +# --------------------------------------- +# Form the common basis of the m4_foreach and m4_map macros. For each +# ARG, expand PRE[ARG]POST[]. The IGNORED argument makes recursion +# easier, and must be supplied rather than implicit. +# +# This version minimizes the number of times that $@ is evaluated by +# using m4_for to generate a boilerplate into _m4_f then passing $@ to +# that temporary macro. Thus, the recursion is done in m4_for without +# reparsing any user input, and is not quadratic. For an idea of how +# this works, note that m4_foreach(i,[1,2],[i]) calls +# _m4_foreach([m4_define([i],],[)i],[],[1],[2]) +# which defines _m4_f: +# $1[$4]$2[]$1[$5]$2[]_m4_popdef([_m4_f]) +# then calls _m4_f([m4_define([i],],[)i],[],[1],[2]) for a net result: +# m4_define([i],[1])i[]m4_define([i],[2])i[]_m4_popdef([_m4_f]). +m4_define([_m4_foreach], +[m4_if([$#], [3], [], + [m4_pushdef([_m4_f], _m4_for([4], [$#], [1], + [$0_([1], [2],], [)])[_m4_popdef([_m4_f])])_m4_f($@)])]) + +m4_define([_m4_foreach_], +[[$$1[$$3]$$2[]]]) + +# m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) +# ----------------------------------------------------------- +# Find the first VAL that SWITCH matches, and expand the corresponding +# IF-VAL. If there are no matches, expand DEFAULT. +# +# Use m4_for to create a temporary macro in terms of a boilerplate +# m4_if with final cleanup. If $# is even, we have DEFAULT; if it is +# odd, then rounding the last $# up in the temporary macro is +# harmless. For example, both m4_case(1,2,3,4,5) and +# m4_case(1,2,3,4,5,6) result in the intermediate _m4_case being +# m4_if([$1],[$2],[$3],[$1],[$4],[$5],_m4_popdef([_m4_case])[$6]) +m4_define([m4_case], +[m4_if(m4_eval([$# <= 2]), [1], [$2], +[m4_pushdef([_$0], [m4_if(]_m4_for([2], m4_eval([($# - 1) / 2 * 2]), [2], + [_$0_(], [)])[_m4_popdef( + [_$0])]m4_dquote($m4_eval([($# + 1) & ~1]))[)])_$0($@)])]) + +m4_define([_m4_case_], +[$0_([1], [$1], m4_incr([$1]))]) + +m4_define([_m4_case__], +[[[$$1],[$$2],[$$3],]]) + +# m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) +# ----------------------------------------------------- +# m4 equivalent of +# +# if (SWITCH =~ RE1) +# VAL1; +# elif (SWITCH =~ RE2) +# VAL2; +# elif ... +# ... +# else +# DEFAULT +# +# We build the temporary macro _m4_b: +# m4_define([_m4_b], _m4_defn([_m4_bmatch]))_m4_b([$1], [$2], [$3])... +# _m4_b([$1], [$m-1], [$m])_m4_b([], [], [$m+1]_m4_popdef([_m4_b])) +# then invoke m4_unquote(_m4_b($@)), for concatenation with later text. +m4_define([m4_bmatch], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [$2], + [m4_pushdef([_m4_b], [m4_define([_m4_b], + _m4_defn([_$0]))]_m4_for([3], m4_eval([($# + 1) / 2 * 2 - 1]), + [2], [_$0_(], [)])[_m4_b([], [],]m4_dquote([$]m4_eval( + [($# + 1) / 2 * 2]))[_m4_popdef([_m4_b]))])m4_unquote(_m4_b($@))])]) + +m4_define([_m4_bmatch], +[m4_if(m4_bregexp([$1], [$2]), [-1], [], [[$3]m4_define([$0])])]) + +m4_define([_m4_bmatch_], +[$0_([1], m4_decr([$1]), [$1])]) + +m4_define([_m4_bmatch__], +[[_m4_b([$$1], [$$2], [$$3])]]) + + +# m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT]) +# ------------------------------------------------------------------- +# Similar to m4_if, except that each TEST is expanded when encountered. +# If the expansion of TESTn matches the string VALn, the result is IF-VALn. +# The result is DEFAULT if no tests passed. This macro allows +# short-circuiting of expensive tests, where it pays to arrange quick +# filter tests to run first. +# +# m4_cond already guarantees either 3*n or 3*n + 1 arguments, 1 <= n. +# We only have to speed up _m4_cond, by building the temporary _m4_c: +# m4_define([_m4_c], _m4_defn([m4_unquote]))_m4_c([m4_if(($1), [($2)], +# [[$3]m4_define([_m4_c])])])_m4_c([m4_if(($4), [($5)], +# [[$6]m4_define([_m4_c])])])..._m4_c([m4_if(($m-2), [($m-1)], +# [[$m]m4_define([_m4_c])])])_m4_c([[$m+1]]_m4_popdef([_m4_c])) +# We invoke m4_unquote(_m4_c($@)), for concatenation with later text. +m4_define([_m4_cond], +[m4_pushdef([_m4_c], [m4_define([_m4_c], + _m4_defn([m4_unquote]))]_m4_for([2], m4_eval([$# / 3 * 3 - 1]), [3], + [$0_(], [)])[_m4_c(]m4_dquote(m4_dquote( + [$]m4_eval([$# / 3 * 3 + 1])))[_m4_popdef([_m4_c]))])m4_unquote(_m4_c($@))]) + +m4_define([_m4_cond_], +[$0_(m4_decr([$1]), [$1], m4_incr([$1]))]) + +m4_define([_m4_cond__], +[[_m4_c([m4_if(($$1), [($$2)], [[$$3]m4_define([_m4_c])])])]]) + +# m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) +# ---------------------------------------------------- +# m4 equivalent of +# +# $_ = STRING; +# s/RE1/SUBST1/g; +# s/RE2/SUBST2/g; +# ... +# +# m4_bpatsubsts already validated an odd number of arguments; we only +# need to speed up _m4_bpatsubsts. To avoid nesting, we build the +# temporary _m4_p: +# m4_define([_m4_p], [$1])m4_define([_m4_p], +# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$2], [$3]))m4_define([_m4_p], +# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$4], [$5]))m4_define([_m4_p],... +# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$m-1], [$m]))m4_unquote( +# _m4_defn([_m4_p])_m4_popdef([_m4_p])) +m4_define([_m4_bpatsubsts], +[m4_pushdef([_m4_p], [m4_define([_m4_p], + ]m4_dquote([$]1)[)]_m4_for([3], [$#], [2], [$0_(], + [)])[m4_unquote(_m4_defn([_m4_p])_m4_popdef([_m4_p]))])_m4_p($@)]) + +m4_define([_m4_bpatsubsts_], +[$0_(m4_decr([$1]), [$1])]) + +m4_define([_m4_bpatsubsts__], +[[m4_define([_m4_p], +m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$$1], [$$2]))]]) + +# m4_shiftn(N, ...) +# ----------------- +# Returns ... shifted N times. Useful for recursive "varargs" constructs. +# +# m4_shiftn already validated arguments; we only need to speed up +# _m4_shiftn. If N is 3, then we build the temporary _m4_s, defined as +# ,[$5],[$6],...,[$m]_m4_popdef([_m4_s]) +# before calling m4_shift(_m4_s($@)). +m4_define([_m4_shiftn], +[m4_if(m4_incr([$1]), [$#], [], [m4_pushdef([_m4_s], + _m4_for(m4_eval([$1 + 2]), [$#], [1], + [[,]m4_dquote($], [)])[_m4_popdef([_m4_s])])m4_shift(_m4_s($@))])]) + +# m4_do(STRING, ...) +# ------------------ +# This macro invokes all its arguments (in sequence, of course). It is +# useful for making your macros more structured and readable by dropping +# unnecessary dnl's and have the macros indented properly. +# +# Here, we use the temporary macro _m4_do, defined as +# $1[]$2[]...[]$n[]_m4_popdef([_m4_do]) +m4_define([m4_do], +[m4_if([$#], [0], [], + [m4_pushdef([_$0], _m4_for([1], [$#], [1], + [$], [[[]]])[_m4_popdef([_$0])])_$0($@)])]) + +# m4_dquote_elt(ARGS) +# ------------------- +# Return ARGS as an unquoted list of double-quoted arguments. +# +# _m4_foreach to the rescue. +m4_define([m4_dquote_elt], +[m4_if([$#], [0], [], [[[$1]]_m4_foreach([,m4_dquote(], [)], $@)])]) + +# m4_reverse(ARGS) +# ---------------- +# Output ARGS in reverse order. +# +# Invoke _m4_r($@) with the temporary _m4_r built as +# [$m], [$m-1], ..., [$2], [$1]_m4_popdef([_m4_r]) +m4_define([m4_reverse], +[m4_if([$#], [0], [], [$#], [1], [[$1]], +[m4_pushdef([_m4_r], [[$$#]]_m4_for(m4_decr([$#]), [1], [-1], + [[, ]m4_dquote($], [)])[_m4_popdef([_m4_r])])_m4_r($@)])]) + + +# m4_map_args_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...) +# ------------------------------------------------------------- +# Perform a pairwise grouping of consecutive ARGs, by expanding +# EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the +# final argument is expanded with END-EXPR([ARGn]). +# +# Build the temporary macro _m4_map_args_pair, with the $2([$m+1]) +# only output if $# is odd: +# $1([$3], [$4])[]$1([$5], [$6])[]...$1([$m-1], +# [$m])[]m4_default([$2], [$1])([$m+1])[]_m4_popdef([_m4_map_args_pair]) +m4_define([m4_map_args_pair], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [m4_fatal([$0: too few arguments: $#: $1])], + [$#], [2], [], + [$#], [3], [m4_default([$2], [$1])([$3])[]], + [m4_pushdef([_$0], _m4_for([3], + m4_eval([$# / 2 * 2 - 1]), [2], [_$0_(], [)])_$0_end( + [1], [2], [$#])[_m4_popdef([_$0])])_$0($@)])]) + +m4_define([_m4_map_args_pair_], +[$0_([1], [$1], m4_incr([$1]))]) + +m4_define([_m4_map_args_pair__], +[[$$1([$$2], [$$3])[]]]) + +m4_define([_m4_map_args_pair_end], +[m4_if(m4_eval([$3 & 1]), [1], [[m4_default([$$2], [$$1])([$$3])[]]])]) + +# m4_join(SEP, ARG1, ARG2...) +# --------------------------- +# Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG +# is the empty string. No expansion is performed on SEP or ARGs. +# +# Use a self-modifying separator, since we don't know how many +# arguments might be skipped before a separator is first printed, but +# be careful if the separator contains $. _m4_foreach to the rescue. +m4_define([m4_join], +[m4_pushdef([_m4_sep], [m4_define([_m4_sep], _m4_defn([m4_echo]))])]dnl +[_m4_foreach([_$0([$1],], [)], $@)_m4_popdef([_m4_sep])]) + +m4_define([_m4_join], +[m4_if([$2], [], [], [_m4_sep([$1])[$2]])]) + +# m4_joinall(SEP, ARG1, ARG2...) +# ------------------------------ +# Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP. +# No expansion is performed on SEP or ARGs. +# +# A bit easier than m4_join. _m4_foreach to the rescue. +m4_define([m4_joinall], +[[$2]m4_if(m4_eval([$# <= 2]), [1], [], + [_m4_foreach([$1], [], m4_shift($@))])]) + +# m4_list_cmp(A, B) +# ----------------- +# Compare the two lists of integer expressions A and B. +# +# m4_list_cmp takes care of any side effects; we only override +# _m4_list_cmp_raw, where we can safely expand lists multiple times. +# First, insert padding so that both lists are the same length; the +# trailing +0 is necessary to handle a missing list. Next, create a +# temporary macro to perform pairwise comparisons until an inequality +# is found. For example, m4_list_cmp([1], [1,2]) creates _m4_cmp as +# m4_if(m4_eval([($1) != ($3)]), [1], [m4_cmp([$1], [$3])], +# m4_eval([($2) != ($4)]), [1], [m4_cmp([$2], [$4])], +# [0]_m4_popdef([_m4_cmp])) +# then calls _m4_cmp([1+0], [0*2], [1], [2+0]) +m4_define([_m4_list_cmp_raw], +[m4_if([$1], [$2], 0, + [_m4_list_cmp($1+0_m4_list_pad(m4_count($1), m4_count($2)), + $2+0_m4_list_pad(m4_count($2), m4_count($1)))])]) + +m4_define([_m4_list_pad], +[m4_if(m4_eval($1 < $2), [1], + [_m4_for(m4_incr([$1]), [$2], [1], [,0*])])]) + +m4_define([_m4_list_cmp], +[m4_pushdef([_m4_cmp], [m4_if(]_m4_for( + [1], m4_eval([$# >> 1]), [1], [$0_(], [,]m4_eval([$# >> 1])[)])[ + [0]_m4_popdef([_m4_cmp]))])_m4_cmp($@)]) + +m4_define([_m4_list_cmp_], +[$0_([$1], m4_eval([$1 + $2]))]) + +m4_define([_m4_list_cmp__], +[[m4_eval([($$1) != ($$2)]), [1], [m4_cmp([$$1], [$$2])], +]]) + +# m4_max(EXPR, ...) +# m4_min(EXPR, ...) +# ----------------- +# Return the decimal value of the maximum (or minimum) in a series of +# integer expressions. +# +# _m4_foreach to the rescue; we only need to replace _m4_minmax. Here, +# we need a temporary macro to track the best answer so far, so that +# the foreach expression is tractable. +m4_define([_m4_minmax], +[m4_pushdef([_m4_best], m4_eval([$2]))_m4_foreach( + [m4_define([_m4_best], $1(_m4_best,], [))], m4_shift($@))]dnl +[_m4_best[]_m4_popdef([_m4_best])]) + +# m4_set_add_all(SET, VALUE...) +# ----------------------------- +# Add each VALUE into SET. This is O(n) in the number of VALUEs, and +# can be faster than calling m4_set_add for each VALUE. +# +# _m4_foreach to the rescue. If no deletions have occurred, then +# avoid the speed penalty of m4_set_add. +m4_define([m4_set_add_all], +[m4_if([$#], [0], [], [$#], [1], [], + [m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1]) + + m4_len(_m4_foreach(m4_ifdef([_m4_set_cleanup($1)], + [[m4_set_add]], [[_$0]])[([$1],], [)], $@))))])]) + +m4_define([_m4_set_add_all], +[m4_ifdef([_m4_set([$1],$2)], [], + [m4_define([_m4_set([$1],$2)], + [1])m4_pushdef([_m4_set([$1])], [$2])-])]) diff --git a/gnuwin32/bin/data/m4sugar/m4sugar.m4 b/gnuwin32/bin/data/m4sugar/m4sugar.m4 new file mode 100644 index 00000000..b732abc7 --- /dev/null +++ b/gnuwin32/bin/data/m4sugar/m4sugar.m4 @@ -0,0 +1,3307 @@ +divert(-1)# -*- Autoconf -*- +# This file is part of Autoconf. +# Base M4 layer. +# Requires GNU M4. +# +# Copyright (C) 1999-2013 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see . + +# Written by Akim Demaille. + +# Set the quotes, whatever the current quoting system. +changequote() +changequote([, ]) + +# Some old m4's don't support m4exit. But they provide +# equivalent functionality by core dumping because of the +# long macros we define. +ifdef([__gnu__], , +[errprint(M4sugar requires GNU M4. Install it before installing M4sugar or +set the M4 environment variable to its absolute file name.) +m4exit(2)]) + + +## ------------------------------- ## +## 1. Simulate --prefix-builtins. ## +## ------------------------------- ## + +# m4_define +# m4_defn +# m4_undefine +define([m4_define], defn([define])) +define([m4_defn], defn([defn])) +define([m4_undefine], defn([undefine])) + +m4_undefine([define]) +m4_undefine([defn]) +m4_undefine([undefine]) + + +# m4_copy(SRC, DST) +# ----------------- +# Define DST as the definition of SRC. +# What's the difference between: +# 1. m4_copy([from], [to]) +# 2. m4_define([to], [from($@)]) +# Well, obviously 1 is more expensive in space. Maybe 2 is more expensive +# in time, but because of the space cost of 1, it's not that obvious. +# Nevertheless, one huge difference is the handling of `$0'. If `from' +# uses `$0', then with 1, `to''s `$0' is `to', while it is `from' in 2. +# The user would certainly prefer to see `to'. +# +# This definition is in effect during m4sugar initialization, when +# there are no pushdef stacks; later on, we redefine it to something +# more powerful for all other clients to use. +m4_define([m4_copy], +[m4_define([$2], m4_defn([$1]))]) + + +# m4_rename(SRC, DST) +# ------------------- +# Rename the macro SRC to DST. +m4_define([m4_rename], +[m4_copy([$1], [$2])m4_undefine([$1])]) + + +# m4_rename_m4(MACRO-NAME) +# ------------------------ +# Rename MACRO-NAME to m4_MACRO-NAME. +m4_define([m4_rename_m4], +[m4_rename([$1], [m4_$1])]) + + +# m4_copy_unm4(m4_MACRO-NAME) +# --------------------------- +# Copy m4_MACRO-NAME to MACRO-NAME. +m4_define([m4_copy_unm4], +[m4_copy([$1], m4_bpatsubst([$1], [^m4_\(.*\)], [[\1]]))]) + + +# Some m4 internals have names colliding with tokens we might use. +# Rename them a` la `m4 --prefix-builtins'. Conditionals first, since +# some subsequent renames are conditional. +m4_rename_m4([ifdef]) +m4_rename([ifelse], [m4_if]) + +m4_rename_m4([builtin]) +m4_rename_m4([changecom]) +m4_rename_m4([changequote]) +m4_ifdef([changeword],dnl conditionally available in 1.4.x +[m4_undefine([changeword])]) +m4_rename_m4([debugfile]) +m4_rename_m4([debugmode]) +m4_rename_m4([decr]) +m4_rename_m4([divnum]) +m4_rename_m4([dumpdef]) +m4_rename_m4([errprint]) +m4_rename_m4([esyscmd]) +m4_rename_m4([eval]) +m4_rename_m4([format]) +m4_undefine([include]) +m4_rename_m4([incr]) +m4_rename_m4([index]) +m4_rename_m4([indir]) +m4_rename_m4([len]) +m4_rename([m4exit], [m4_exit]) +m4_undefine([m4wrap]) +m4_ifdef([mkstemp],dnl added in M4 1.4.8 +[m4_rename_m4([mkstemp]) +m4_copy([m4_mkstemp], [m4_maketemp]) +m4_undefine([maketemp])], +[m4_rename_m4([maketemp]) +m4_copy([m4_maketemp], [m4_mkstemp])]) +m4_rename([patsubst], [m4_bpatsubst]) +m4_rename_m4([popdef]) +m4_rename_m4([pushdef]) +m4_rename([regexp], [m4_bregexp]) +m4_rename_m4([shift]) +m4_undefine([sinclude]) +m4_rename_m4([substr]) +m4_ifdef([symbols],dnl present only in alpha-quality 1.4o +[m4_rename_m4([symbols])]) +m4_rename_m4([syscmd]) +m4_rename_m4([sysval]) +m4_rename_m4([traceoff]) +m4_rename_m4([traceon]) +m4_rename_m4([translit]) + +# _m4_defn(ARG) +# ------------- +# _m4_defn is for internal use only - it bypasses the wrapper, so it +# must only be used on one argument at a time, and only on macros +# known to be defined. Make sure this still works if the user renames +# m4_defn but not _m4_defn. +m4_copy([m4_defn], [_m4_defn]) + +# _m4_divert_raw(NUM) +# ------------------- +# _m4_divert_raw is for internal use only. Use this instead of +# m4_builtin([divert], NUM), so that tracing diversion flow is easier. +m4_rename([divert], [_m4_divert_raw]) + +# _m4_popdef(ARG...) +# ------------------ +# _m4_popdef is for internal use only - it bypasses the wrapper, so it +# must only be used on macros known to be defined. Make sure this +# still works if the user renames m4_popdef but not _m4_popdef. +m4_copy([m4_popdef], [_m4_popdef]) + +# _m4_undefine(ARG...) +# -------------------- +# _m4_undefine is for internal use only - it bypasses the wrapper, so +# it must only be used on macros known to be defined. Make sure this +# still works if the user renames m4_undefine but not _m4_undefine. +m4_copy([m4_undefine], [_m4_undefine]) + +# _m4_undivert(NUM...) +# -------------------- +# _m4_undivert is for internal use only, and should always be given +# arguments. Use this instead of m4_builtin([undivert], NUM...), so +# that tracing diversion flow is easier. +m4_rename([undivert], [_m4_undivert]) + + +## ------------------- ## +## 2. Error messages. ## +## ------------------- ## + + +# m4_location +# ----------- +# Output the current file, colon, and the current line number. +m4_define([m4_location], +[__file__:__line__]) + + +# m4_errprintn(MSG) +# ----------------- +# Same as `errprint', but with the missing end of line. +m4_define([m4_errprintn], +[m4_errprint([$1 +])]) + + +# m4_warning(MSG) +# --------------- +# Warn the user. +m4_define([m4_warning], +[m4_errprintn(m4_location[: warning: $1])]) + + +# m4_fatal(MSG, [EXIT-STATUS]) +# ---------------------------- +# Fatal the user. :) +m4_define([m4_fatal], +[m4_errprintn(m4_location[: error: $1] +m4_expansion_stack)m4_exit(m4_if([$2],, 1, [$2]))]) + + +# m4_assert(EXPRESSION, [EXIT-STATUS = 1]) +# ---------------------------------------- +# This macro ensures that EXPRESSION evaluates to true, and exits if +# EXPRESSION evaluates to false. +m4_define([m4_assert], +[m4_if(m4_eval([$1]), 0, + [m4_fatal([assert failed: $1], [$2])])]) + + + +## ------------- ## +## 3. Warnings. ## +## ------------- ## + + +# _m4_warn(CATEGORY, MESSAGE, [STACK-TRACE]) +# ------------------------------------------ +# Report a MESSAGE to the user if the CATEGORY of warnings is enabled. +# This is for traces only. +# If present, STACK-TRACE is a \n-separated list of "LOCATION: MESSAGE", +# where the last line (and no other) ends with "the top level". +# +# Within m4, the macro is a no-op. This macro really matters +# when autom4te post-processes the trace output. +m4_define([_m4_warn], []) + + +# m4_warn(CATEGORY, MESSAGE) +# -------------------------- +# Report a MESSAGE to the user if the CATEGORY of warnings is enabled. +m4_define([m4_warn], +[_m4_warn([$1], [$2], +m4_ifdef([_m4_expansion_stack], [m4_expansion_stack]))]) + + + +## ------------------- ## +## 4. File inclusion. ## +## ------------------- ## + + +# We also want to neutralize include (and sinclude for symmetry), +# but we want to extend them slightly: warn when a file is included +# several times. This is, in general, a dangerous operation, because +# too many people forget to quote the first argument of m4_define. +# +# For instance in the following case: +# m4_define(foo, [bar]) +# then a second reading will turn into +# m4_define(bar, [bar]) +# which is certainly not what was meant. + +# m4_include_unique(FILE) +# ----------------------- +# Declare that the FILE was loading; and warn if it has already +# been included. +m4_define([m4_include_unique], +[m4_ifdef([m4_include($1)], + [m4_warn([syntax], [file `$1' included several times])])dnl +m4_define([m4_include($1)])]) + + +# m4_include(FILE) +# ---------------- +# Like the builtin include, but warns against multiple inclusions. +m4_define([m4_include], +[m4_include_unique([$1])dnl +m4_builtin([include], [$1])]) + + +# m4_sinclude(FILE) +# ----------------- +# Like the builtin sinclude, but warns against multiple inclusions. +m4_define([m4_sinclude], +[m4_include_unique([$1])dnl +m4_builtin([sinclude], [$1])]) + + + +## ------------------------------------ ## +## 5. Additional branching constructs. ## +## ------------------------------------ ## + +# Both `m4_ifval' and `m4_ifset' tests against the empty string. The +# difference is that `m4_ifset' is specialized on macros. +# +# In case of arguments of macros, eg. $1, it makes little difference. +# In the case of a macro `FOO', you don't want to check `m4_ifval(FOO, +# TRUE)', because if `FOO' expands with commas, there is a shifting of +# the arguments. So you want to run `m4_ifval([FOO])', but then you just +# compare the *string* `FOO' against `', which, of course fails. +# +# So you want the variation `m4_ifset' that expects a macro name as $1. +# If this macro is both defined and defined to a non empty value, then +# it runs TRUE, etc. + + +# m4_ifblank(COND, [IF-BLANK], [IF-TEXT]) +# m4_ifnblank(COND, [IF-TEXT], [IF-BLANK]) +# ---------------------------------------- +# If COND is empty, or consists only of blanks (space, tab, newline), +# then expand IF-BLANK, otherwise expand IF-TEXT. This differs from +# m4_ifval only if COND has just whitespace, but it helps optimize in +# spite of users who mistakenly leave trailing space after what they +# thought was an empty argument: +# macro( +# [] +# ) +# +# Writing one macro in terms of the other causes extra overhead, so +# we inline both definitions. +m4_define([m4_ifblank], +[m4_if(m4_translit([[$1]], [ ][ ][ +]), [], [$2], [$3])]) + +m4_define([m4_ifnblank], +[m4_if(m4_translit([[$1]], [ ][ ][ +]), [], [$3], [$2])]) + + +# m4_ifval(COND, [IF-TRUE], [IF-FALSE]) +# ------------------------------------- +# If COND is not the empty string, expand IF-TRUE, otherwise IF-FALSE. +# Comparable to m4_ifdef. +m4_define([m4_ifval], +[m4_if([$1], [], [$3], [$2])]) + + +# m4_n(TEXT) +# ---------- +# If TEXT is not empty, return TEXT and a new line, otherwise nothing. +m4_define([m4_n], +[m4_if([$1], + [], [], + [$1 +])]) + + +# m4_ifvaln(COND, [IF-TRUE], [IF-FALSE]) +# -------------------------------------- +# Same as `m4_ifval', but add an extra newline to IF-TRUE or IF-FALSE +# unless that argument is empty. +m4_define([m4_ifvaln], +[m4_if([$1], + [], [m4_n([$3])], + [m4_n([$2])])]) + + +# m4_ifset(MACRO, [IF-TRUE], [IF-FALSE]) +# -------------------------------------- +# If MACRO has no definition, or of its definition is the empty string, +# expand IF-FALSE, otherwise IF-TRUE. +m4_define([m4_ifset], +[m4_ifdef([$1], + [m4_ifval(_m4_defn([$1]), [$2], [$3])], + [$3])]) + + +# m4_ifndef(NAME, [IF-NOT-DEFINED], [IF-DEFINED]) +# ----------------------------------------------- +m4_define([m4_ifndef], +[m4_ifdef([$1], [$3], [$2])]) + + +# m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) +# ----------------------------------------------------------- +# m4 equivalent of +# switch (SWITCH) +# { +# case VAL1: +# IF-VAL1; +# break; +# case VAL2: +# IF-VAL2; +# break; +# ... +# default: +# DEFAULT; +# break; +# }. +# All the values are optional, and the macro is robust to active +# symbols properly quoted. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_case], +[m4_if([$#], 0, [], + [$#], 1, [], + [$#], 2, [$2], + [$1], [$2], [$3], + [$0([$1], m4_shift3($@))])]) + + +# m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) +# ----------------------------------------------------- +# m4 equivalent of +# +# if (SWITCH =~ RE1) +# VAL1; +# elif (SWITCH =~ RE2) +# VAL2; +# elif ... +# ... +# else +# DEFAULT +# +# All the values are optional, and the macro is robust to active symbols +# properly quoted. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_bmatch], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [$2], + [m4_if(m4_bregexp([$1], [$2]), -1, [$0([$1], m4_shift3($@))], + [$3])])]) + +# m4_argn(N, ARGS...) +# ------------------- +# Extract argument N (greater than 0) from ARGS. Example: +# m4_define([b], [B]) +# m4_argn([2], [a], [b], [c]) => b +# +# Rather than using m4_car(m4_shiftn([$1], $@)), we exploit the fact that +# GNU m4 can directly reference any argument, through an indirect macro. +m4_define([m4_argn], +[m4_assert([0 < $1])]dnl +[m4_pushdef([_$0], [_m4_popdef([_$0])]m4_dquote([$]m4_incr([$1])))_$0($@)]) + + +# m4_car(ARGS...) +# m4_cdr(ARGS...) +# --------------- +# Manipulate m4 lists. m4_car returns the first argument. m4_cdr +# bundles all but the first argument into a quoted list. These two +# macros are generally used with list arguments, with quoting removed +# to break the list into multiple m4 ARGS. +m4_define([m4_car], [[$1]]) +m4_define([m4_cdr], +[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], + [$#], 1, [], + [m4_dquote(m4_shift($@))])]) + +# _m4_cdr(ARGS...) +# ---------------- +# Like m4_cdr, except include a leading comma unless only one argument +# remains. Why? Because comparing a large list against [] is more +# expensive in expansion time than comparing the number of arguments; so +# _m4_cdr can be used to reduce the number of arguments when it is time +# to end recursion. +m4_define([_m4_cdr], +[m4_if([$#], 1, [], + [, m4_dquote(m4_shift($@))])]) + + + +# m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT]) +# ------------------------------------------------------------------- +# Similar to m4_if, except that each TEST is expanded when encountered. +# If the expansion of TESTn matches the string VALn, the result is IF-VALn. +# The result is DEFAULT if no tests passed. This macro allows +# short-circuiting of expensive tests, where it pays to arrange quick +# filter tests to run first. +# +# For an example, consider a previous implementation of _AS_QUOTE_IFELSE: +# +# m4_if(m4_index([$1], [\]), [-1], [$2], +# m4_eval(m4_index([$1], [\\]) >= 0), [1], [$2], +# m4_eval(m4_index([$1], [\$]) >= 0), [1], [$2], +# m4_eval(m4_index([$1], [\`]) >= 0), [1], [$3], +# m4_eval(m4_index([$1], [\"]) >= 0), [1], [$3], +# [$2]) +# +# Here, m4_index is computed 5 times, and m4_eval 4, even if $1 contains +# no backslash. It is more efficient to do: +# +# m4_cond([m4_index([$1], [\])], [-1], [$2], +# [m4_eval(m4_index([$1], [\\]) >= 0)], [1], [$2], +# [m4_eval(m4_index([$1], [\$]) >= 0)], [1], [$2], +# [m4_eval(m4_index([$1], [\`]) >= 0)], [1], [$3], +# [m4_eval(m4_index([$1], [\"]) >= 0)], [1], [$3], +# [$2]) +# +# In the common case of $1 with no backslash, only one m4_index expansion +# occurs, and m4_eval is avoided altogether. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_cond], +[m4_if([$#], [0], [m4_fatal([$0: cannot be called without arguments])], + [$#], [1], [$1], + m4_eval([$# % 3]), [2], [m4_fatal([$0: missing an argument])], + [_$0($@)])]) + +m4_define([_m4_cond], +[m4_if(($1), [($2)], [$3], + [$#], [3], [], + [$#], [4], [$4], + [$0(m4_shift3($@))])]) + + +## ---------------------------------------- ## +## 6. Enhanced version of some primitives. ## +## ---------------------------------------- ## + +# m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) +# ---------------------------------------------------- +# m4 equivalent of +# +# $_ = STRING; +# s/RE1/SUBST1/g; +# s/RE2/SUBST2/g; +# ... +# +# All the values are optional, and the macro is robust to active symbols +# properly quoted. +# +# I would have liked to name this macro `m4_bpatsubst', unfortunately, +# due to quotation problems, I need to double quote $1 below, therefore +# the anchors are broken :( I can't let users be trapped by that. +# +# Recall that m4_shift3 always results in an argument. Hence, we need +# to distinguish between a final deletion vs. ending recursion. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_bpatsubsts], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [m4_unquote(m4_builtin([patsubst], [[$1]], [$2]))], + [$#], 3, [m4_unquote(m4_builtin([patsubst], [[$1]], [$2], [$3]))], + [_$0($@m4_if(m4_eval($# & 1), 0, [,]))])]) +m4_define([_m4_bpatsubsts], +[m4_if([$#], 2, [$1], + [$0(m4_builtin([patsubst], [[$1]], [$2], [$3]), + m4_shift3($@))])]) + + +# m4_copy(SRC, DST) +# ----------------- +# Define the pushdef stack DST as a copy of the pushdef stack SRC; +# give an error if DST is already defined. This is particularly nice +# for copying self-modifying pushdef stacks, where the top definition +# includes one-shot initialization that is later popped to the normal +# definition. This version intentionally does nothing if SRC is +# undefined. +# +# Some macros simply can't be renamed with this method: namely, anything +# involved in the implementation of m4_stack_foreach_sep. +m4_define([m4_copy], +[m4_ifdef([$2], [m4_fatal([$0: won't overwrite defined macro: $2])], + [m4_stack_foreach_sep([$1], [m4_pushdef([$2],], [)])])]dnl +[m4_ifdef([m4_location($1)], [m4_define([m4_location($2)], m4_location)])]) + + +# m4_copy_force(SRC, DST) +# m4_rename_force(SRC, DST) +# ------------------------- +# Like m4_copy/m4_rename, except blindly overwrite any existing DST. +# Note that m4_copy_force tolerates undefined SRC, while m4_rename_force +# does not. +m4_define([m4_copy_force], +[m4_ifdef([$2], [_m4_undefine([$2])])m4_copy($@)]) + +m4_define([m4_rename_force], +[m4_ifdef([$2], [_m4_undefine([$2])])m4_rename($@)]) + + +# m4_define_default(MACRO, VALUE) +# ------------------------------- +# If MACRO is undefined, set it to VALUE. +m4_define([m4_define_default], +[m4_ifndef([$1], [m4_define($@)])]) + + +# m4_default(EXP1, EXP2) +# m4_default_nblank(EXP1, EXP2) +# ----------------------------- +# Returns EXP1 if not empty/blank, otherwise EXP2. Expand the result. +# +# m4_default is called on hot paths, so inline the contents of m4_ifval, +# for one less round of expansion. +m4_define([m4_default], +[m4_if([$1], [], [$2], [$1])]) + +m4_define([m4_default_nblank], +[m4_ifblank([$1], [$2], [$1])]) + + +# m4_default_quoted(EXP1, EXP2) +# m4_default_nblank_quoted(EXP1, EXP2) +# ------------------------------------ +# Returns EXP1 if non empty/blank, otherwise EXP2. Leave the result quoted. +# +# For comparison: +# m4_define([active], [ACTIVE]) +# m4_default([active], [default]) => ACTIVE +# m4_default([], [active]) => ACTIVE +# -m4_default([ ], [active])- => - - +# -m4_default_nblank([ ], [active])- => -ACTIVE- +# m4_default_quoted([active], [default]) => active +# m4_default_quoted([], [active]) => active +# -m4_default_quoted([ ], [active])- => - - +# -m4_default_nblank_quoted([ ], [active])- => -active- +# +# m4_default macro is called on hot paths, so inline the contents of m4_ifval, +# for one less round of expansion. +m4_define([m4_default_quoted], +[m4_if([$1], [], [[$2]], [[$1]])]) + +m4_define([m4_default_nblank_quoted], +[m4_ifblank([$1], [[$2]], [[$1]])]) + + +# m4_defn(NAME) +# ------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). This replacement is not a full-featured +# replacement: if any of the defined macros contain unbalanced quoting, but +# when pasted together result in a well-quoted string, then only native m4 +# support is able to get it correct. But that's where quadrigraphs come in +# handy, if you really need unbalanced quotes inside your macros. +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_defn], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_defn([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + + +# m4_dumpdef(NAME...) +# ------------------- +# In m4 1.4.x, dumpdef writes to the current debugfile, rather than +# stderr. This in turn royally confuses autom4te; so we follow the +# lead of newer m4 and always dump to stderr. Unlike the original, +# this version requires an argument, since there is no convenient way +# in m4 1.4.x to grab the names of all defined macros. Newer m4 +# always dumps to stderr, regardless of the current debugfile; it also +# provides m4symbols as a way to grab all current macro names. But +# dumpdefs is not frequently called, so we don't need to worry about +# conditionally using these newer features. Also, this version +# doesn't sort multiple arguments. +# +# If we detect m4 1.6 or newer, then provide an alternate definition, +# installed during m4_init, that allows builtins through. +# Unfortunately, there is no nice way in m4 1.4.x to dump builtins. +m4_define([m4_dumpdef], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_ifdef([$1], [m4_errprintn( + [$1: ]m4_dquote(_m4_defn([$1])))], [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + +m4_define([_m4_dumpdef], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_builtin([dumpdef], [$1])], + [m4_map_args_sep([m4_builtin([dumpdef],], [)], [], $@)])]) + + +# m4_dumpdefs(NAME...) +# -------------------- +# Similar to `m4_dumpdef(NAME)', but if NAME was m4_pushdef'ed, display its +# value stack (most recent displayed first). Also, this version silently +# ignores undefined macros, rather than erroring out. +# +# This macro cheats, because it relies on the current definition of NAME +# while the second argument of m4_stack_foreach_lifo is evaluated (which +# would be undefined according to the API). +m4_define([m4_dumpdefs], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_stack_foreach_lifo([$1], [m4_dumpdef([$1])m4_ignore])], + [m4_map_args([$0], $@)])]) + +# m4_esyscmd_s(COMMAND) +# --------------------- +# Like m4_esyscmd, except strip any trailing newlines, thus behaving +# more like shell command substitution. +m4_define([m4_esyscmd_s], +[m4_chomp_all(m4_esyscmd([$1]))]) + + +# m4_popdef(NAME) +# --------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_popdef], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_popdef([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + + +# m4_shiftn(N, ...) +# ----------------- +# Returns ... shifted N times. Useful for recursive "varargs" constructs. +# +# Autoconf does not use this macro, because it is inherently slower than +# calling the common cases of m4_shift2 or m4_shift3 directly. But it +# might as well be fast for other clients, such as Libtool. One way to +# do this is to expand $@ only once in _m4_shiftn (otherwise, for long +# lists, the expansion of m4_if takes twice as much memory as what the +# list itself occupies, only to throw away the unused branch). The end +# result is strictly equivalent to +# m4_if([$1], 1, [m4_shift(,m4_shift(m4_shift($@)))], +# [_m4_shiftn(m4_decr([$1]), m4_shift(m4_shift($@)))]) +# but with the final `m4_shift(m4_shift($@)))' shared between the two +# paths. The first leg uses a no-op m4_shift(,$@) to balance out the (). +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_shiftn], +[m4_assert(0 < $1 && $1 < $#)_$0($@)]) + +m4_define([_m4_shiftn], +[m4_if([$1], 1, [m4_shift(], + [$0(m4_decr([$1])]), m4_shift(m4_shift($@)))]) + +# m4_shift2(...) +# m4_shift3(...) +# -------------- +# Returns ... shifted twice, and three times. Faster than m4_shiftn. +m4_define([m4_shift2], [m4_shift(m4_shift($@))]) +m4_define([m4_shift3], [m4_shift(m4_shift(m4_shift($@)))]) + +# _m4_shift2(...) +# _m4_shift3(...) +# --------------- +# Like m4_shift2 or m4_shift3, except include a leading comma unless shifting +# consumes all arguments. Why? Because in recursion, it is nice to +# distinguish between 1 element left and 0 elements left, based on how many +# arguments this shift expands to. +m4_define([_m4_shift2], +[m4_if([$#], [2], [], + [, m4_shift(m4_shift($@))])]) +m4_define([_m4_shift3], +[m4_if([$#], [3], [], + [, m4_shift(m4_shift(m4_shift($@)))])]) + + +# m4_undefine(NAME) +# ----------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_undefine], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_undefine([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + +# _m4_wrap(PRE, POST) +# ------------------- +# Helper macro for m4_wrap and m4_wrap_lifo. Allows nested calls to +# m4_wrap within wrapped text. Use _m4_defn and _m4_popdef for speed. +m4_define([_m4_wrap], +[m4_ifdef([$0_text], + [m4_define([$0_text], [$1]_m4_defn([$0_text])[$2])], + [m4_builtin([m4wrap], [m4_unquote( + _m4_defn([$0_text])_m4_popdef([$0_text]))])m4_define([$0_text], [$1$2])])]) + +# m4_wrap(TEXT) +# ------------- +# Append TEXT to the list of hooks to be executed at the end of input. +# Whereas the order of the original may be LIFO in the underlying m4, +# this version is always FIFO. +m4_define([m4_wrap], +[_m4_wrap([], [$1[]])]) + +# m4_wrap_lifo(TEXT) +# ------------------ +# Prepend TEXT to the list of hooks to be executed at the end of input. +# Whereas the order of m4_wrap may be FIFO in the underlying m4, this +# version is always LIFO. +m4_define([m4_wrap_lifo], +[_m4_wrap([$1[]])]) + +## ------------------------- ## +## 7. Quoting manipulation. ## +## ------------------------- ## + + +# m4_apply(MACRO, LIST) +# --------------------- +# Invoke MACRO, with arguments provided from the quoted list of +# comma-separated quoted arguments. If LIST is empty, invoke MACRO +# without arguments. The expansion will not be concatenated with +# subsequent text. +m4_define([m4_apply], +[m4_if([$2], [], [$1], [$1($2)])[]]) + +# _m4_apply(MACRO, LIST) +# ---------------------- +# Like m4_apply, except do nothing if LIST is empty. +m4_define([_m4_apply], +[m4_if([$2], [], [], [$1($2)[]])]) + + +# m4_count(ARGS) +# -------------- +# Return a count of how many ARGS are present. +m4_define([m4_count], [$#]) + + +# m4_curry(MACRO, ARG...) +# ----------------------- +# Perform argument currying. The expansion of this macro is another +# macro that takes exactly one argument, appends it to the end of the +# original ARG list, then invokes MACRO. For example: +# m4_curry([m4_curry], [m4_reverse], [1])([2])([3]) => 3, 2, 1 +# Not quite as practical as m4_incr, but you could also do: +# m4_define([add], [m4_eval(([$1]) + ([$2]))]) +# m4_define([add_one], [m4_curry([add], [1])]) +# add_one()([2]) => 3 +m4_define([m4_curry], [$1(m4_shift($@,)_$0]) +m4_define([_m4_curry], [[$1])]) + + +# m4_do(STRING, ...) +# ------------------ +# This macro invokes all its arguments (in sequence, of course). It is +# useful for making your macros more structured and readable by dropping +# unnecessary dnl's and have the macros indented properly. No concatenation +# occurs after a STRING; use m4_unquote(m4_join(,STRING)) for that. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_do], +[m4_if([$#], 0, [], + [$#], 1, [$1[]], + [$1[]$0(m4_shift($@))])]) + + +# m4_dquote(ARGS) +# --------------- +# Return ARGS as a quoted list of quoted arguments. +m4_define([m4_dquote], [[$@]]) + + +# m4_dquote_elt(ARGS) +# ------------------- +# Return ARGS as an unquoted list of double-quoted arguments. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_dquote_elt], +[m4_if([$#], [0], [], + [$#], [1], [[[$1]]], + [[[$1]],$0(m4_shift($@))])]) + + +# m4_echo(ARGS) +# ------------- +# Return the ARGS, with the same level of quoting. Whitespace after +# unquoted commas are consumed. +m4_define([m4_echo], [$@]) + + +# m4_expand(ARG) +# _m4_expand(ARG) +# --------------- +# Return the expansion of ARG as a single string. Unlike +# m4_quote($1), this preserves whitespace following single-quoted +# commas that appear within ARG. It also deals with shell case +# statements. +# +# m4_define([active], [ACT, IVE]) +# m4_define([active2], [[ACT, IVE]]) +# m4_quote(active, active2) +# => ACT,IVE,ACT, IVE +# m4_expand([active, active2]) +# => ACT, IVE, ACT, IVE +# +# Unfortunately, due to limitations in m4, ARG must expand to +# something with balanced quotes (use quadrigraphs to get around +# this), and should not contain the unlikely delimiters -=<{( or +# )}>=-. It is possible to have unbalanced quoted `(' or `)', as well +# as unbalanced unquoted `)'. m4_expand can handle unterminated +# comments or dnl on the final line, at the expense of speed; it also +# aids in detecting attempts to incorrectly change the current +# diversion inside ARG. Meanwhile, _m4_expand is faster but must be +# given a terminated expansion, and has no safety checks for +# mis-diverted text. +# +# Exploit that extra unquoted () will group unquoted commas and the +# following whitespace. m4_bpatsubst can't handle newlines inside $1, +# and m4_substr strips quoting. So we (ab)use m4_changequote, using +# temporary quotes to remove the delimiters that conveniently included +# the unquoted () that were added prior to the changequote. +# +# Thanks to shell case statements, too many people are prone to pass +# underquoted `)', so we try to detect that by passing a marker as a +# fourth argument; if the marker is not present, then we assume that +# we encountered an early `)', and re-expand the first argument, but +# this time with one more `(' in the second argument and in the +# open-quote delimiter. We must also ignore the slop from the +# previous try. The final macro is thus half line-noise, half art. +m4_define([m4_expand], +[m4_pushdef([m4_divert], _m4_defn([_m4_divert_unsafe]))]dnl +[m4_pushdef([m4_divert_push], _m4_defn([_m4_divert_unsafe]))]dnl +[m4_chomp(_$0([$1 +]))_m4_popdef([m4_divert], [m4_divert_push])]) + +m4_define([_m4_expand], [$0_([$1], [(], -=<{($1)}>=-, [}>=-])]) + +m4_define([_m4_expand_], +[m4_if([$4], [}>=-], + [m4_changequote([-=<{$2], [)}>=-])$3m4_changequote([, ])], + [$0([$1], [($2], -=<{($2$1)}>=-, [}>=-])m4_ignore$2])]) + + +# m4_ignore(ARGS) +# --------------- +# Expands to nothing. Useful for conditionally ignoring an arbitrary +# number of arguments (see _m4_list_cmp for an example). +m4_define([m4_ignore]) + + +# m4_make_list(ARGS) +# ------------------ +# Similar to m4_dquote, this creates a quoted list of quoted ARGS. This +# version is less efficient than m4_dquote, but separates each argument +# with a comma and newline, rather than just comma, for readability. +# When developing an m4sugar algorithm, you could temporarily use +# m4_pushdef([m4_dquote],m4_defn([m4_make_list])) +# around your code to make debugging easier. +m4_define([m4_make_list], [m4_join([, +], m4_dquote_elt($@))]) + + +# m4_noquote(STRING) +# ------------------ +# Return the result of ignoring all quotes in STRING and invoking the +# macros it contains. Among other things, this is useful for enabling +# macro invocations inside strings with [] blocks (for instance regexps +# and help-strings). On the other hand, since all quotes are disabled, +# any macro expanded during this time that relies on nested [] quoting +# will likely crash and burn. This macro is seldom useful; consider +# m4_unquote or m4_expand instead. +m4_define([m4_noquote], +[m4_changequote([-=<{(],[)}>=-])$1-=<{()}>=-m4_changequote([,])]) + + +# m4_quote(ARGS) +# -------------- +# Return ARGS as a single argument. Any whitespace after unquoted commas +# is stripped. There is always output, even when there were no arguments. +# +# It is important to realize the difference between `m4_quote(exp)' and +# `[exp]': in the first case you obtain the quoted *result* of the +# expansion of EXP, while in the latter you just obtain the string +# `exp'. +m4_define([m4_quote], [[$*]]) + + +# _m4_quote(ARGS) +# --------------- +# Like m4_quote, except that when there are no arguments, there is no +# output. For conditional scenarios (such as passing _m4_quote as the +# macro name in m4_mapall), this feature can be used to distinguish between +# one argument of the empty string vs. no arguments. However, in the +# normal case with arguments present, this is less efficient than m4_quote. +m4_define([_m4_quote], +[m4_if([$#], [0], [], [[$*]])]) + + +# m4_reverse(ARGS) +# ---------------- +# Output ARGS in reverse order. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_reverse], +[m4_if([$#], [0], [], [$#], [1], [[$1]], + [$0(m4_shift($@)), [$1]])]) + + +# m4_unquote(ARGS) +# ---------------- +# Remove one layer of quotes from each ARG, performing one level of +# expansion. For one argument, m4_unquote([arg]) is more efficient than +# m4_do([arg]), but for multiple arguments, the difference is that +# m4_unquote separates arguments with commas while m4_do concatenates. +# Follow this macro with [] if concatenation with subsequent text is +# undesired. +m4_define([m4_unquote], [$*]) + + +## -------------------------- ## +## 8. Implementing m4 loops. ## +## -------------------------- ## + + +# m4_for(VARIABLE, FIRST, LAST, [STEP = +/-1], EXPRESSION) +# -------------------------------------------------------- +# Expand EXPRESSION defining VARIABLE to FROM, FROM + 1, ..., TO with +# increments of STEP. Both limits are included, and bounds are +# checked for consistency. The algorithm is robust to indirect +# VARIABLE names. Changing VARIABLE inside EXPRESSION will not impact +# the number of iterations. +# +# Uses _m4_defn for speed, and avoid dnl in the macro body. Factor +# the _m4_for call so that EXPRESSION is only parsed once. +m4_define([m4_for], +[m4_pushdef([$1], m4_eval([$2]))]dnl +[m4_cond([m4_eval(([$3]) > ([$2]))], 1, + [m4_pushdef([_m4_step], m4_eval(m4_default_quoted([$4], + 1)))m4_assert(_m4_step > 0)_$0(_m4_defn([$1]), + m4_eval((([$3]) - ([$2])) / _m4_step * _m4_step + ([$2])), _m4_step,], + [m4_eval(([$3]) < ([$2]))], 1, + [m4_pushdef([_m4_step], m4_eval(m4_default_quoted([$4], + -1)))m4_assert(_m4_step < 0)_$0(_m4_defn([$1]), + m4_eval((([$2]) - ([$3])) / -(_m4_step) * _m4_step + ([$2])), _m4_step,], + [m4_pushdef([_m4_step])_$0(_m4_defn([$1]), _m4_defn([$1]), 0,])]dnl +[[m4_define([$1],], [)$5])m4_popdef([_m4_step], [$1])]) + +# _m4_for(COUNT, LAST, STEP, PRE, POST) +# ------------------------------------- +# Core of the loop, no consistency checks, all arguments are plain +# numbers. Expand PRE[COUNT]POST, then alter COUNT by STEP and +# iterate if COUNT is not LAST. +m4_define([_m4_for], +[$4[$1]$5[]m4_if([$1], [$2], [], + [$0(m4_eval([$1 + $3]), [$2], [$3], [$4], [$5])])]) + + +# Implementing `foreach' loops in m4 is much more tricky than it may +# seem. For example, the old M4 1.4.4 manual had an incorrect example, +# which looked like this (when translated to m4sugar): +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], +# | [m4_pushdef([$1])_foreach([$1], [$2], [$3])m4_popdef([$1])]) +# | m4_define([_arg1], [$1]) +# | m4_define([_foreach], +# | [m4_if([$2], [()], , +# | [m4_define([$1], _arg1$2)$3[]_foreach([$1], (m4_shift$2), [$3])])]) +# +# But then if you run +# +# | m4_define(a, 1) +# | m4_define(b, 2) +# | m4_define(c, 3) +# | foreach([f], [([a], [(b], [c)])], [echo f +# | ]) +# +# it gives +# +# => echo 1 +# => echo (2,3) +# +# which is not what is expected. +# +# Of course the problem is that many quotes are missing. So you add +# plenty of quotes at random places, until you reach the expected +# result. Alternatively, if you are a quoting wizard, you directly +# reach the following implementation (but if you really did, then +# apply to the maintenance of m4sugar!). +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) +# | m4_define([_arg1], [[$1]]) +# | m4_define([_foreach], +# | [m4_if($2, [()], , +# | [m4_define([$1], [_arg1$2])$3[]_foreach([$1], [(m4_shift$2)], [$3])])]) +# +# which this time answers +# +# => echo a +# => echo (b +# => echo c) +# +# Bingo! +# +# Well, not quite. +# +# With a better look, you realize that the parens are more a pain than +# a help: since anyway you need to quote properly the list, you end up +# with always using an outermost pair of parens and an outermost pair +# of quotes. Rejecting the parens both eases the implementation, and +# simplifies the use: +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) +# | m4_define([_arg1], [$1]) +# | m4_define([_foreach], +# | [m4_if($2, [], , +# | [m4_define([$1], [_arg1($2)])$3[]_foreach([$1], [m4_shift($2)], [$3])])]) +# +# +# Now, just replace the `$2' with `m4_quote($2)' in the outer `m4_if' +# to improve robustness, and you come up with a nice implementation +# that doesn't require extra parentheses in the user's LIST. +# +# But wait - now the algorithm is quadratic, because every recursion of +# the algorithm keeps the entire LIST and merely adds another m4_shift to +# the quoted text. If the user has a lot of elements in LIST, you can +# bring the system to its knees with the memory m4 then requires, or trip +# the m4 --nesting-limit recursion factor. The only way to avoid +# quadratic growth is ensure m4_shift is expanded prior to the recursion. +# Hence the design below. +# +# The M4 manual now includes a chapter devoted to this issue, with +# the lessons learned from m4sugar. And still, this design is only +# optimal for M4 1.6; see foreach.m4 for yet more comments on why +# M4 1.4.x uses yet another implementation. + + +# m4_foreach(VARIABLE, LIST, EXPRESSION) +# -------------------------------------- +# +# Expand EXPRESSION assigning each value of the LIST to VARIABLE. +# LIST should have the form `item_1, item_2, ..., item_n', i.e. the +# whole list must *quoted*. Quote members too if you don't want them +# to be expanded. +# +# This macro is robust to active symbols: +# | m4_define(active, [ACT, IVE]) +# | m4_foreach(Var, [active, active], [-Var-]) +# => -ACT--IVE--ACT--IVE- +# +# | m4_foreach(Var, [[active], [active]], [-Var-]) +# => -ACT, IVE--ACT, IVE- +# +# | m4_foreach(Var, [[[active]], [[active]]], [-Var-]) +# => -active--active- +# +# This macro is called frequently, so avoid extra expansions such as +# m4_ifval and dnl. Also, since $2 might be quite large, try to use it +# as little as possible in _m4_foreach; each extra use requires that much +# more memory for expansion. So, rather than directly compare $2 against +# [] and use m4_car/m4_cdr for recursion, we instead unbox the list (which +# requires swapping the argument order in the helper), insert an ignored +# third argument, and use m4_shift3 to detect when recursion is complete, +# at which point this looks very much like m4_map_args. +m4_define([m4_foreach], +[m4_if([$2], [], [], + [m4_pushdef([$1])_$0([m4_define([$1],], [)$3], [], + $2)m4_popdef([$1])])]) + +# _m4_foreach(PRE, POST, IGNORED, ARG...) +# --------------------------------------- +# Form the common basis of the m4_foreach and m4_map macros. For each +# ARG, expand PRE[ARG]POST[]. The IGNORED argument makes recursion +# easier, and must be supplied rather than implicit. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([_m4_foreach], +[m4_if([$#], [3], [], + [$1[$4]$2[]$0([$1], [$2], m4_shift3($@))])]) + + +# m4_foreach_w(VARIABLE, LIST, EXPRESSION) +# ---------------------------------------- +# Like m4_foreach, but the list is whitespace separated. Depending on +# EXPRESSION, it may be more efficient to use m4_map_args_w. +# +# This macro is robust to active symbols: +# m4_foreach_w([Var], [ active +# b act\ +# ive ], [-Var-])end +# => -active--b--active-end +# +# This used to use a slower implementation based on m4_foreach: +# m4_foreach([$1], m4_split(m4_normalize([$2]), [ ]), [$3]) +m4_define([m4_foreach_w], +[m4_pushdef([$1])m4_map_args_w([$2], + [m4_define([$1],], [)$3])m4_popdef([$1])]) + + +# m4_map(MACRO, LIST) +# m4_mapall(MACRO, LIST) +# ---------------------- +# Invoke MACRO($1), MACRO($2) etc. where $1, $2... are the elements of +# LIST. $1, $2... must in turn be lists, appropriate for m4_apply. +# If LIST contains an empty sublist, m4_map skips the expansion of +# MACRO, while m4_mapall expands MACRO with no arguments. +# +# Since LIST may be quite large, we want to minimize how often it +# appears in the expansion. Rather than use m4_car/m4_cdr iteration, +# we unbox the list, and use _m4_foreach for iteration. For m4_map, +# an empty list behaves like an empty sublist and gets ignored; for +# m4_mapall, we must special-case the empty list. +m4_define([m4_map], +[_m4_foreach([_m4_apply([$1],], [)], [], $2)]) + +m4_define([m4_mapall], +[m4_if([$2], [], [], + [_m4_foreach([m4_apply([$1],], [)], [], $2)])]) + + +# m4_map_sep(MACRO, [SEPARATOR], LIST) +# m4_mapall_sep(MACRO, [SEPARATOR], LIST) +# --------------------------------------- +# Invoke MACRO($1), SEPARATOR, MACRO($2), ..., MACRO($N) where $1, +# $2... $N are the elements of LIST, and are in turn lists appropriate +# for m4_apply. SEPARATOR is expanded, in order to allow the creation +# of a list of arguments by using a single-quoted comma as the +# separator. For each empty sublist, m4_map_sep skips the expansion +# of MACRO and SEPARATOR, while m4_mapall_sep expands MACRO with no +# arguments. +# +# For m4_mapall_sep, merely expand the first iteration without the +# separator, then include separator as part of subsequent recursion; +# but avoid extra expansion of LIST's side-effects via a helper macro. +# For m4_map_sep, things are trickier - we don't know if the first +# list element is an empty sublist, so we must define a self-modifying +# helper macro and use that as the separator instead. +m4_define([m4_map_sep], +[m4_pushdef([m4_Sep], [m4_define([m4_Sep], _m4_defn([m4_unquote]))])]dnl +[_m4_foreach([_m4_apply([m4_Sep([$2])[]$1],], [)], [], $3)m4_popdef([m4_Sep])]) + +m4_define([m4_mapall_sep], +[m4_if([$3], [], [], [_$0([$1], [$2], $3)])]) + +m4_define([_m4_mapall_sep], +[m4_apply([$1], [$3])_m4_foreach([m4_apply([$2[]$1],], [)], m4_shift2($@))]) + +# m4_map_args(EXPRESSION, ARG...) +# ------------------------------- +# Expand EXPRESSION([ARG]) for each argument. More efficient than +# m4_foreach([var], [ARG...], [EXPRESSION(m4_defn([var]))]) +# Shorthand for m4_map_args_sep([EXPRESSION(], [)], [], ARG...). +m4_define([m4_map_args], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [], + [$#], [2], [$1([$2])[]], + [_m4_foreach([$1(], [)], $@)])]) + + +# m4_map_args_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...) +# ------------------------------------------------------------- +# Perform a pairwise grouping of consecutive ARGs, by expanding +# EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the +# final argument is expanded with END-EXPR([ARGn]). +# +# For example: +# m4_define([show], [($*)m4_newline])dnl +# m4_map_args_pair([show], [], [a], [b], [c], [d], [e])dnl +# => (a,b) +# => (c,d) +# => (e) +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_map_args_pair], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [m4_fatal([$0: too few arguments: $#: $1])], + [$#], [2], [], + [$#], [3], [m4_default([$2], [$1])([$3])[]], + [$#], [4], [$1([$3], [$4])[]], + [$1([$3], [$4])[]$0([$1], [$2], m4_shift(m4_shift3($@)))])]) + + +# m4_map_args_sep([PRE], [POST], [SEP], ARG...) +# --------------------------------------------- +# Expand PRE[ARG]POST for each argument, with SEP between arguments. +m4_define([m4_map_args_sep], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [], + [$#], [2], [], + [$#], [3], [], + [$#], [4], [$1[$4]$2[]], + [$1[$4]$2[]_m4_foreach([$3[]$1], [$2], m4_shift3($@))])]) + + +# m4_map_args_w(STRING, [PRE], [POST], [SEP]) +# ------------------------------------------- +# Perform the expansion of PRE[word]POST[] for each word in STRING +# separated by whitespace. More efficient than: +# m4_foreach_w([var], [STRING], [PRE[]m4_defn([var])POST]) +# Additionally, expand SEP between words. +# +# As long as we have to use m4_bpatsubst to split the string, we might +# as well make it also apply PRE and POST; this avoids iteration +# altogether. But we must be careful of any \ in PRE or POST. +# _m4_strip returns a quoted string, but that's okay, since it also +# supplies an empty leading and trailing argument due to our +# intentional whitespace around STRING. We use m4_substr to strip the +# empty elements and remove the extra layer of quoting. +m4_define([m4_map_args_w], +[_$0(_m4_split([ ]m4_flatten([$1])[ ], [[ ]+], + m4_if(m4_index([$2$3$4], [\]), [-1], [[$3[]$4[]$2]], + [m4_bpatsubst([[$3[]$4[]$2]], [\\], [\\\\])])), + m4_len([[]$3[]$4]), m4_len([$4[]$2[]]))]) + +m4_define([_m4_map_args_w], +[m4_substr([$1], [$2], m4_eval(m4_len([$1]) - [$2] - [$3]))]) + + +# m4_stack_foreach(MACRO, FUNC) +# m4_stack_foreach_lifo(MACRO, FUNC) +# ---------------------------------- +# Pass each stacked definition of MACRO to the one-argument macro FUNC. +# m4_stack_foreach proceeds in FIFO order, while m4_stack_foreach_lifo +# processes the topmost definitions first. In addition, FUNC should +# not push or pop definitions of MACRO, and should not expect anything about +# the active definition of MACRO (it will not be the topmost, and may not +# be the one passed to FUNC either). +# +# Some macros simply can't be examined with this method: namely, +# anything involved in the implementation of _m4_stack_reverse. +m4_define([m4_stack_foreach], +[_m4_stack_reverse([$1], [m4_tmp-$1])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1], [$2(_m4_defn([m4_tmp-$1]))])]) + +m4_define([m4_stack_foreach_lifo], +[_m4_stack_reverse([$1], [m4_tmp-$1], [$2(_m4_defn([m4_tmp-$1]))])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1])]) + +# m4_stack_foreach_sep(MACRO, [PRE], [POST], [SEP]) +# m4_stack_foreach_sep_lifo(MACRO, [PRE], [POST], [SEP]) +# ------------------------------------------------------ +# Similar to m4_stack_foreach and m4_stack_foreach_lifo, in that every +# definition of a pushdef stack will be visited. But rather than +# passing the definition as a single argument to a macro, this variant +# expands the concatenation of PRE[]definition[]POST, and expands SEP +# between consecutive expansions. Note that m4_stack_foreach([a], [b]) +# is equivalent to m4_stack_foreach_sep([a], [b(], [)]). +m4_define([m4_stack_foreach_sep], +[_m4_stack_reverse([$1], [m4_tmp-$1])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1], [$2[]_m4_defn([m4_tmp-$1])$3], [$4[]])]) + +m4_define([m4_stack_foreach_sep_lifo], +[_m4_stack_reverse([$1], [m4_tmp-$1], [$2[]_m4_defn([m4_tmp-$1])$3], [$4[]])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1])]) + + +# _m4_stack_reverse(OLD, NEW, [ACTION], [SEP]) +# -------------------------------------------- +# A recursive worker for pushdef stack manipulation. Destructively +# copy the OLD stack into the NEW, and expanding ACTION for each +# iteration. After the first iteration, SEP is promoted to the front +# of ACTION (note that SEP should include a trailing [] if it is to +# avoid interfering with ACTION). The current definition is examined +# after the NEW has been pushed but before OLD has been popped; this +# order is important, as ACTION is permitted to operate on either +# _m4_defn([OLD]) or _m4_defn([NEW]). Since the operation is +# destructive, this macro is generally used twice, with a temporary +# macro name holding the swapped copy. +m4_define([_m4_stack_reverse], +[m4_ifdef([$1], [m4_pushdef([$2], + _m4_defn([$1]))$3[]_m4_popdef([$1])$0([$1], [$2], [$4$3])])]) + + + +## --------------------------- ## +## 9. More diversion support. ## +## --------------------------- ## + + +# m4_cleardivert(DIVERSION-NAME...) +# --------------------------------- +# Discard any text in DIVERSION-NAME. +# +# This works even inside m4_expand. +m4_define([m4_cleardivert], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [_m4_divert_raw([-1])m4_undivert($@)_m4_divert_raw( + _m4_divert(_m4_defn([_m4_divert_diversion]), [-]))])]) + + +# _m4_divert(DIVERSION-NAME or NUMBER, [NOWARN]) +# ---------------------------------------------- +# If DIVERSION-NAME is the name of a diversion, return its number, +# otherwise if it is a NUMBER return it. Issue a warning about +# the use of a number instead of a name, unless NOWARN is provided. +m4_define([_m4_divert], +[m4_ifdef([_m4_divert($1)], + [m4_indir([_m4_divert($1)])], + [m4_if([$2], [], [m4_warn([syntax], + [prefer named diversions])])$1])]) + +# KILL is only used to suppress output. +m4_define([_m4_divert(KILL)], -1) + +# The empty diversion name is a synonym for 0. +m4_define([_m4_divert()], 0) + + +# m4_divert_stack +# --------------- +# Print the diversion stack, if it's nonempty. The caller is +# responsible for any leading or trailing newline. +m4_define([m4_divert_stack], +[m4_stack_foreach_sep_lifo([_m4_divert_stack], [], [], [ +])]) + + +# m4_divert_stack_push(MACRO-NAME, DIVERSION-NAME) +# ------------------------------------------------ +# Form an entry of the diversion stack from caller MACRO-NAME and +# entering DIVERSION-NAME and push it. +m4_define([m4_divert_stack_push], +[m4_pushdef([_m4_divert_stack], m4_location[: $1: $2])]) + + +# m4_divert(DIVERSION-NAME) +# ------------------------- +# Change the diversion stream to DIVERSION-NAME. +m4_define([m4_divert], +[m4_popdef([_m4_divert_stack])]dnl +[m4_define([_m4_divert_diversion], [$1])]dnl +[m4_divert_stack_push([$0], [$1])]dnl +[_m4_divert_raw(_m4_divert([$1]))]) + + +# m4_divert_push(DIVERSION-NAME, [NOWARN]) +# ---------------------------------------- +# Change the diversion stream to DIVERSION-NAME, while stacking old values. +# For internal use only: if NOWARN is not empty, DIVERSION-NAME can be a +# number instead of a name. +m4_define([m4_divert_push], +[m4_divert_stack_push([$0], [$1])]dnl +[m4_pushdef([_m4_divert_diversion], [$1])]dnl +[_m4_divert_raw(_m4_divert([$1], [$2]))]) + + +# m4_divert_pop([DIVERSION-NAME]) +# ------------------------------- +# Change the diversion stream to its previous value, unstacking it. +# If specified, verify we left DIVERSION-NAME. +# When we pop the last value from the stack, we divert to -1. +m4_define([m4_divert_pop], +[m4_if([$1], [], [], + [$1], _m4_defn([_m4_divert_diversion]), [], + [m4_fatal([$0($1): diversion mismatch: +]m4_divert_stack)])]dnl +[_m4_popdef([_m4_divert_stack], [_m4_divert_diversion])]dnl +[m4_ifdef([_m4_divert_diversion], [], + [m4_fatal([too many m4_divert_pop])])]dnl +[_m4_divert_raw(_m4_divert(_m4_defn([_m4_divert_diversion]), [-]))]) + + +# m4_divert_text(DIVERSION-NAME, CONTENT) +# --------------------------------------- +# Output CONTENT into DIVERSION-NAME (which may be a number actually). +# An end of line is appended for free to CONTENT. +m4_define([m4_divert_text], +[m4_divert_push([$1])$2 +m4_divert_pop([$1])]) + + +# m4_divert_once(DIVERSION-NAME, CONTENT) +# --------------------------------------- +# Output CONTENT into DIVERSION-NAME once, if not already there. +# An end of line is appended for free to CONTENT. +m4_define([m4_divert_once], +[m4_expand_once([m4_divert_text([$1], [$2])])]) + + +# _m4_divert_unsafe(DIVERSION-NAME) +# --------------------------------- +# Issue a warning that the attempt to change the current diversion to +# DIVERSION-NAME is unsafe, because this macro is being expanded +# during argument collection of m4_expand. +m4_define([_m4_divert_unsafe], +[m4_fatal([$0: cannot change diversion to `$1' inside m4_expand])]) + + +# m4_undivert(DIVERSION-NAME...) +# ------------------------------ +# Undivert DIVERSION-NAME. Unlike the M4 version, this requires at +# least one DIVERSION-NAME; also, due to support for named diversions, +# this should not be used to undivert files. +m4_define([m4_undivert], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [_m4_undivert(_m4_divert([$1]))], + [m4_map_args([$0], $@)])]) + + +## --------------------------------------------- ## +## 10. Defining macros with bells and whistles. ## +## --------------------------------------------- ## + +# `m4_defun' is basically `m4_define' but it equips the macro with the +# needed machinery for `m4_require'. A macro must be m4_defun'd if +# either it is m4_require'd, or it m4_require's. +# +# Two things deserve attention and are detailed below: +# 1. Implementation of m4_require +# 2. Keeping track of the expansion stack +# +# 1. Implementation of m4_require +# =============================== +# +# Of course m4_defun calls m4_provide, so that a macro which has +# been expanded is not expanded again when m4_require'd, but the +# difficult part is the proper expansion of macros when they are +# m4_require'd. +# +# The implementation is based on three ideas, (i) using diversions to +# prepare the expansion of the macro and its dependencies (by Franc,ois +# Pinard), (ii) expand the most recently m4_require'd macros _after_ +# the previous macros (by Axel Thimm), and (iii) track instances of +# provide before require (by Eric Blake). +# +# +# The first idea: why use diversions? +# ----------------------------------- +# +# When a macro requires another, the other macro is expanded in new +# diversion, GROW. When the outer macro is fully expanded, we first +# undivert the most nested diversions (GROW - 1...), and finally +# undivert GROW. To understand why we need several diversions, +# consider the following example: +# +# | m4_defun([TEST1], [Test...m4_require([TEST2])1]) +# | m4_defun([TEST2], [Test...m4_require([TEST3])2]) +# | m4_defun([TEST3], [Test...3]) +# +# Because m4_require is not required to be first in the outer macros, we +# must keep the expansions of the various levels of m4_require separated. +# Right before executing the epilogue of TEST1, we have: +# +# GROW - 2: Test...3 +# GROW - 1: Test...2 +# GROW: Test...1 +# BODY: +# +# Finally the epilogue of TEST1 undiverts GROW - 2, GROW - 1, and +# GROW into the regular flow, BODY. +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: Test...3; Test...2; Test...1 +# +# (The semicolons are here for clarification, but of course are not +# emitted.) This is what Autoconf 2.0 (I think) to 2.13 (I'm sure) +# implement. +# +# +# The second idea: first required first out +# ----------------------------------------- +# +# The natural implementation of the idea above is buggy and produces +# very surprising results in some situations. Let's consider the +# following example to explain the bug: +# +# | m4_defun([TEST1], [m4_require([TEST2a])m4_require([TEST2b])]) +# | m4_defun([TEST2a], []) +# | m4_defun([TEST2b], [m4_require([TEST3])]) +# | m4_defun([TEST3], [m4_require([TEST2a])]) +# | +# | AC_INIT +# | TEST1 +# +# The dependencies between the macros are: +# +# 3 --- 2b +# / \ is m4_require'd by +# / \ left -------------------- right +# 2a ------------ 1 +# +# If you strictly apply the rules given in the previous section you get: +# +# GROW - 2: TEST3 +# GROW - 1: TEST2a; TEST2b +# GROW: TEST1 +# BODY: +# +# (TEST2a, although required by TEST3 is not expanded in GROW - 3 +# because is has already been expanded before in GROW - 1, so it has +# been AC_PROVIDE'd, so it is not expanded again) so when you undivert +# the stack of diversions, you get: +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: TEST3; TEST2a; TEST2b; TEST1 +# +# i.e., TEST2a is expanded after TEST3 although the latter required the +# former. +# +# Starting from 2.50, we use an implementation provided by Axel Thimm. +# The idea is simple: the order in which macros are emitted must be the +# same as the one in which macros are expanded. (The bug above can +# indeed be described as: a macro has been m4_provide'd before its +# dependent, but it is emitted after: the lack of correlation between +# emission and expansion order is guilty). +# +# How to do that? You keep the stack of diversions to elaborate the +# macros, but each time a macro is fully expanded, emit it immediately. +# +# In the example above, when TEST2a is expanded, but it's epilogue is +# not run yet, you have: +# +# GROW - 2: +# GROW - 1: TEST2a +# GROW: Elaboration of TEST1 +# BODY: +# +# The epilogue of TEST2a emits it immediately: +# +# GROW - 2: +# GROW - 1: +# GROW: Elaboration of TEST1 +# BODY: TEST2a +# +# TEST2b then requires TEST3, so right before the epilogue of TEST3, you +# have: +# +# GROW - 2: TEST3 +# GROW - 1: Elaboration of TEST2b +# GROW: Elaboration of TEST1 +# BODY: TEST2a +# +# The epilogue of TEST3 emits it: +# +# GROW - 2: +# GROW - 1: Elaboration of TEST2b +# GROW: Elaboration of TEST1 +# BODY: TEST2a; TEST3 +# +# TEST2b is now completely expanded, and emitted: +# +# GROW - 2: +# GROW - 1: +# GROW: Elaboration of TEST1 +# BODY: TEST2a; TEST3; TEST2b +# +# and finally, TEST1 is finished and emitted: +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: TEST2a; TEST3; TEST2b: TEST1 +# +# The idea is simple, but the implementation is a bit involved. If +# you are like me, you will want to see the actual functioning of this +# implementation to be convinced. The next section gives the full +# details. +# +# +# The Axel Thimm implementation at work +# ------------------------------------- +# +# We consider the macros above, and this configure.ac: +# +# AC_INIT +# TEST1 +# +# You should keep the definitions of _m4_defun_pro, _m4_defun_epi, and +# m4_require at hand to follow the steps. +# +# This implementation tries not to assume that the current diversion is +# BODY, so as soon as a macro (m4_defun'd) is expanded, we first +# record the current diversion under the name _m4_divert_dump (denoted +# DUMP below for short). This introduces an important difference with +# the previous versions of Autoconf: you cannot use m4_require if you +# are not inside an m4_defun'd macro, and especially, you cannot +# m4_require directly from the top level. +# +# We have not tried to simulate the old behavior (better yet, we +# diagnose it), because it is too dangerous: a macro m4_require'd from +# the top level is expanded before the body of `configure', i.e., before +# any other test was run. I let you imagine the result of requiring +# AC_STDC_HEADERS for instance, before AC_PROG_CC was actually run.... +# +# After AC_INIT was run, the current diversion is BODY. +# * AC_INIT was run +# DUMP: undefined +# diversion stack: BODY |- +# +# * TEST1 is expanded +# The prologue of TEST1 sets _m4_divert_dump, which is the diversion +# where the current elaboration will be dumped, to the current +# diversion. It also m4_divert_push to GROW, where the full +# expansion of TEST1 and its dependencies will be elaborated. +# DUMP: BODY +# BODY: empty +# diversions: GROW, BODY |- +# +# * TEST1 requires TEST2a +# _m4_require_call m4_divert_pushes another temporary diversion, +# GROW - 1, and expands TEST2a in there. +# DUMP: BODY +# BODY: empty +# GROW - 1: TEST2a +# diversions: GROW - 1, GROW, BODY |- +# Then the content of the temporary diversion is moved to DUMP and the +# temporary diversion is popped. +# DUMP: BODY +# BODY: TEST2a +# diversions: GROW, BODY |- +# +# * TEST1 requires TEST2b +# Again, _m4_require_call pushes GROW - 1 and heads to expand TEST2b. +# DUMP: BODY +# BODY: TEST2a +# diversions: GROW - 1, GROW, BODY |- +# +# * TEST2b requires TEST3 +# _m4_require_call pushes GROW - 2 and expands TEST3 here. +# (TEST3 requires TEST2a, but TEST2a has already been m4_provide'd, so +# nothing happens.) +# DUMP: BODY +# BODY: TEST2a +# GROW - 2: TEST3 +# diversions: GROW - 2, GROW - 1, GROW, BODY |- +# Then the diversion is appended to DUMP, and popped. +# DUMP: BODY +# BODY: TEST2a; TEST3 +# diversions: GROW - 1, GROW, BODY |- +# +# * TEST1 requires TEST2b (contd.) +# The content of TEST2b is expanded... +# DUMP: BODY +# BODY: TEST2a; TEST3 +# GROW - 1: TEST2b, +# diversions: GROW - 1, GROW, BODY |- +# ... and moved to DUMP. +# DUMP: BODY +# BODY: TEST2a; TEST3; TEST2b +# diversions: GROW, BODY |- +# +# * TEST1 is expanded: epilogue +# TEST1's own content is in GROW... +# DUMP: BODY +# BODY: TEST2a; TEST3; TEST2b +# GROW: TEST1 +# diversions: BODY |- +# ... and it's epilogue moves it to DUMP and then undefines DUMP. +# DUMP: undefined +# BODY: TEST2a; TEST3; TEST2b; TEST1 +# diversions: BODY |- +# +# +# The third idea: track macros provided before they were required +# --------------------------------------------------------------- +# +# Using just the first two ideas, Autoconf 2.50 through 2.63 still had +# a subtle bug for more than seven years. Let's consider the +# following example to explain the bug: +# +# | m4_defun([TEST1], [1]) +# | m4_defun([TEST2], [2[]m4_require([TEST1])]) +# | m4_defun([TEST3], [3 TEST1 m4_require([TEST2])]) +# | TEST3 +# +# After the prologue of TEST3, we are collecting text in GROW with the +# intent of dumping it in BODY during the epilogue. Next, we +# encounter the direct invocation of TEST1, which provides the macro +# in place in GROW. From there, we encounter a requirement for TEST2, +# which must be collected in a new diversion. While expanding TEST2, +# we encounter a requirement for TEST1, but since it has already been +# expanded, the Axel Thimm algorithm states that we can treat it as a +# no-op. But that would lead to an end result of `2 3 1', meaning +# that we have once again output a macro (TEST2) prior to its +# requirements (TEST1). +# +# The problem can only occur if a single defun'd macro first provides, +# then later indirectly requires, the same macro. Note that directly +# expanding then requiring a macro is okay: because the dependency was +# met, the require phase can be a no-op. For that matter, the outer +# macro can even require two helpers, where the first helper expands +# the macro, and the second helper indirectly requires the macro. +# Out-of-order expansion is only present if the inner macro is +# required by something that will be hoisted in front of where the +# direct expansion occurred. In other words, we must be careful not +# to warn on: +# +# | m4_defun([TEST4], [4]) +# | m4_defun([TEST5], [5 TEST4 m4_require([TEST4])]) +# | TEST5 => 5 4 +# +# or even the more complex: +# +# | m4_defun([TEST6], [6]) +# | m4_defun([TEST7], [7 TEST6]) +# | m4_defun([TEST8], [8 m4_require([TEST6])]) +# | m4_defun([TEST9], [9 m4_require([TEST8])]) +# | m4_defun([TEST10], [10 m4_require([TEST7]) m4_require([TEST9])]) +# | TEST10 => 7 6 8 9 10 +# +# So, to detect whether a require was direct or indirect, m4_defun and +# m4_require track the name of the macro that caused a diversion to be +# created (using the stack _m4_diverting, coupled with an O(1) lookup +# _m4_diverting([NAME])), and m4_provide stores the name associated +# with the diversion at which a macro was provided. A require call is +# direct if it occurs within the same diversion where the macro was +# provided, or if the diversion associated with the providing context +# has been collected. +# +# The implementation of the warning involves tracking the set of +# macros which have been provided since the start of the outermost +# defun'd macro (the set is named _m4_provide). When starting an +# outermost macro, the set is emptied; when a macro is provided, it is +# added to the set; when require expands the body of a macro, it is +# removed from the set; and when a macro is indirectly required, the +# set is checked. If a macro is in the set, then it has been provided +# before it was required, and we satisfy dependencies by expanding the +# macro as if it had never been provided; in the example given above, +# this means we now output `1 2 3 1'. Meanwhile, a warning is issued +# to inform the user that her macros trigger the bug in older autoconf +# versions, and that her output file now contains redundant contents +# (and possibly new problems, if the repeated macro was not +# idempotent). Meanwhile, macros defined by m4_defun_once instead of +# m4_defun are idempotent, avoiding any warning or duplicate output. +# +# +# 2. Keeping track of the expansion stack +# ======================================= +# +# When M4 expansion goes wrong it is often extremely hard to find the +# path amongst macros that drove to the failure. What is needed is +# the stack of macro `calls'. One could imagine that GNU M4 would +# maintain a stack of macro expansions, unfortunately it doesn't, so +# we do it by hand. This is of course extremely costly, but the help +# this stack provides is worth it. Nevertheless to limit the +# performance penalty this is implemented only for m4_defun'd macros, +# not for define'd macros. +# +# Each time we enter an m4_defun'd macros, we add a definition in +# _m4_expansion_stack, and when we exit the macro, we remove it (thanks +# to pushdef/popdef). m4_stack_foreach is used to print the expansion +# stack in the rare cases when it's needed. +# +# In addition, we want to detect circular m4_require dependencies. +# Each time we expand a macro FOO we define _m4_expanding(FOO); and +# m4_require(BAR) simply checks whether _m4_expanding(BAR) is defined. + + +# m4_expansion_stack +# ------------------ +# Expands to the entire contents of the expansion stack. The caller +# must supply a trailing newline. This macro always prints a +# location; check whether _m4_expansion_stack is defined to filter out +# the case when no defun'd macro is in force. +m4_define([m4_expansion_stack], +[m4_stack_foreach_sep_lifo([_$0], [_$0_entry(], [) +])m4_location[: the top level]]) + +# _m4_expansion_stack_entry(MACRO) +# -------------------------------- +# Format an entry for MACRO found on the expansion stack. +m4_define([_m4_expansion_stack_entry], +[_m4_defn([m4_location($1)])[: $1 is expanded from...]]) + +# m4_expansion_stack_push(MACRO) +# ------------------------------ +# Form an entry of the expansion stack on entry to MACRO and push it. +m4_define([m4_expansion_stack_push], +[m4_pushdef([_m4_expansion_stack], [$1])]) + + +# _m4_divert(GROW) +# ---------------- +# This diversion is used by the m4_defun/m4_require machinery. It is +# important to keep room before GROW because for each nested +# AC_REQUIRE we use an additional diversion (i.e., two m4_require's +# will use GROW - 2. More than 3 levels has never seemed to be +# needed.) +# +# ... +# - GROW - 2 +# m4_require'd code, 2 level deep +# - GROW - 1 +# m4_require'd code, 1 level deep +# - GROW +# m4_defun'd macros are elaborated here. + +m4_define([_m4_divert(GROW)], 10000) + + +# _m4_defun_pro(MACRO-NAME) +# ------------------------- +# The prologue for Autoconf macros. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and m4_defn overhead. +m4_define([_m4_defun_pro], +[m4_ifdef([_m4_expansion_stack], [], [_m4_defun_pro_outer([$1])])]dnl +[m4_expansion_stack_push([$1])m4_pushdef([_m4_expanding($1)])]) + +m4_define([_m4_defun_pro_outer], +[m4_set_delete([_m4_provide])]dnl +[m4_pushdef([_m4_diverting([$1])])m4_pushdef([_m4_diverting], [$1])]dnl +[m4_pushdef([_m4_divert_dump], m4_divnum)m4_divert_push([GROW])]) + +# _m4_defun_epi(MACRO-NAME) +# ------------------------- +# The Epilogue for Autoconf macros. MACRO-NAME only helps tracing +# the PRO/EPI pairs. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and m4_popdef overhead. +m4_define([_m4_defun_epi], +[_m4_popdef([_m4_expanding($1)], [_m4_expansion_stack])]dnl +[m4_ifdef([_m4_expansion_stack], [], [_m4_defun_epi_outer([$1])])]dnl +[m4_provide([$1])]) + +m4_define([_m4_defun_epi_outer], +[_m4_popdef([_m4_divert_dump], [_m4_diverting([$1])], [_m4_diverting])]dnl +[m4_divert_pop([GROW])m4_undivert([GROW])]) + + +# _m4_divert_dump +# --------------- +# If blank, we are outside of any defun'd macro. Otherwise, expands +# to the diversion number (not name) where require'd macros should be +# moved once completed. +m4_define([_m4_divert_dump]) + + +# m4_divert_require(DIVERSION, NAME-TO-CHECK, [BODY-TO-EXPAND]) +# ------------------------------------------------------------- +# Same as m4_require, but BODY-TO-EXPAND goes into the named DIVERSION; +# requirements still go in the current diversion though. +# +m4_define([m4_divert_require], +[m4_ifdef([_m4_expanding($2)], + [m4_fatal([$0: circular dependency of $2])])]dnl +[m4_if(_m4_divert_dump, [], + [m4_fatal([$0($2): cannot be used outside of an m4_defun'd macro])])]dnl +[m4_provide_if([$2], [], + [_m4_require_call([$2], [$3], _m4_divert([$1], [-]))])]) + + +# m4_defun(NAME, EXPANSION, [MACRO = m4_define]) +# ---------------------------------------------- +# Define a macro NAME which automatically provides itself. Add +# machinery so the macro automatically switches expansion to the +# diversion stack if it is not already using it, prior to EXPANSION. +# In this case, once finished, it will bring back all the code +# accumulated in the diversion stack. This, combined with m4_require, +# achieves the topological ordering of macros. We don't use this +# macro to define some frequently called macros that are not involved +# in ordering constraints, to save m4 processing. +# +# MACRO is an undocumented argument; when set to m4_pushdef, and NAME +# is already defined, the new definition is added to the pushdef +# stack, rather than overwriting the current definition. It can thus +# be used to write self-modifying macros, which pop themselves to a +# previously m4_define'd definition so that subsequent use of the +# macro is faster. +m4_define([m4_defun], +[m4_define([m4_location($1)], m4_location)]dnl +[m4_default([$3], [m4_define])([$1], + [_m4_defun_pro(]m4_dquote($[0])[)$2[]_m4_defun_epi(]m4_dquote($[0])[)])]) + + +# m4_defun_init(NAME, INIT, COMMON) +# --------------------------------- +# Like m4_defun, but split EXPANSION into two portions: INIT which is +# done only the first time NAME is invoked, and COMMON which is +# expanded every time. +# +# For now, the COMMON definition is always m4_define'd, giving an even +# lighter-weight definition. m4_defun allows self-providing, but once +# a macro is provided, m4_require no longer cares if it is m4_define'd +# or m4_defun'd. m4_defun also provides location tracking to identify +# dependency bugs, but once the INIT has been expanded, we know there +# are no dependency bugs. However, if a future use needs COMMON to be +# m4_defun'd, we can add a parameter, similar to the third parameter +# to m4_defun. +m4_define([m4_defun_init], +[m4_define([$1], [$3[]])m4_defun([$1], + [$2[]_m4_popdef(]m4_dquote($[0])[)m4_indir(]m4_dquote($[0])dnl +[m4_if(]m4_dquote($[#])[, [0], [], ]m4_dquote([,$]@)[))], [m4_pushdef])]) + + +# m4_defun_once(NAME, EXPANSION) +# ------------------------------ +# Like m4_defun, but guarantee that EXPANSION only happens once +# (thereafter, using NAME is a no-op). +# +# If _m4_divert_dump is empty, we are called at the top level; +# otherwise, we must ensure that we are required in front of the +# current defun'd macro. Use a helper macro so that EXPANSION need +# only occur once in the definition of NAME, since it might be large. +m4_define([m4_defun_once], +[m4_define([m4_location($1)], m4_location)]dnl +[m4_define([$1], [_m4_defun_once([$1], [$2], m4_if(_m4_divert_dump, [], + [[_m4_defun_pro([$1])m4_unquote(], [)_m4_defun_epi([$1])]], +m4_ifdef([_m4_diverting([$1])], [-]), [-], [[m4_unquote(], [)]], + [[_m4_require_call([$1],], [, _m4_divert_dump)]]))])]) + +m4_define([_m4_defun_once], +[m4_pushdef([$1])$3[$2[]m4_provide([$1])]$4]) + + +# m4_pattern_forbid(ERE, [WHY]) +# ----------------------------- +# Declare that no token matching the forbidden extended regular +# expression ERE should be seen in the output unless... +m4_define([m4_pattern_forbid], []) + + +# m4_pattern_allow(ERE) +# --------------------- +# ... that token also matches the allowed extended regular expression ERE. +# Both used via traces. +m4_define([m4_pattern_allow], []) + + +## --------------------------------- ## +## 11. Dependencies between macros. ## +## --------------------------------- ## + + +# m4_before(THIS-MACRO-NAME, CALLED-MACRO-NAME) +# --------------------------------------------- +# Issue a warning if CALLED-MACRO-NAME was called before THIS-MACRO-NAME. +m4_define([m4_before], +[m4_provide_if([$2], + [m4_warn([syntax], [$2 was called before $1])])]) + + +# m4_require(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK]) +# ----------------------------------------------------------- +# If NAME-TO-CHECK has never been expanded (actually, if it is not +# m4_provide'd), expand BODY-TO-EXPAND *before* the current macro +# expansion; follow the expansion with a newline. Once expanded, emit +# it in _m4_divert_dump. Keep track of the m4_require chain in +# _m4_expansion_stack. +# +# The normal cases are: +# +# - NAME-TO-CHECK == BODY-TO-EXPAND +# Which you can use for regular macros with or without arguments, e.g., +# m4_require([AC_PROG_CC], [AC_PROG_CC]) +# m4_require([AC_CHECK_HEADERS(threads.h)], [AC_CHECK_HEADERS(threads.h)]) +# which is just the same as +# m4_require([AC_PROG_CC]) +# m4_require([AC_CHECK_HEADERS(threads.h)]) +# +# - BODY-TO-EXPAND == m4_indir([NAME-TO-CHECK]) +# In the case of macros with irregular names. For instance: +# m4_require([AC_LANG_COMPILER(C)], [indir([AC_LANG_COMPILER(C)])]) +# which means `if the macro named `AC_LANG_COMPILER(C)' (the parens are +# part of the name, it is not an argument) has not been run, then +# call it.' +# Had you used +# m4_require([AC_LANG_COMPILER(C)], [AC_LANG_COMPILER(C)]) +# then m4_require would have tried to expand `AC_LANG_COMPILER(C)', i.e., +# call the macro `AC_LANG_COMPILER' with `C' as argument. +# +# You could argue that `AC_LANG_COMPILER', when it receives an argument +# such as `C' should dispatch the call to `AC_LANG_COMPILER(C)'. But this +# `extension' prevents `AC_LANG_COMPILER' from having actual arguments that +# it passes to `AC_LANG_COMPILER(C)'. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and other overhead on the common path. +m4_define([m4_require], +[m4_ifdef([_m4_expanding($1)], + [m4_fatal([$0: circular dependency of $1])])]dnl +[m4_if(_m4_divert_dump, [], + [m4_fatal([$0($1): cannot be used outside of an ]dnl +m4_if([$0], [m4_require], [[m4_defun]], [[AC_DEFUN]])['d macro])])]dnl +[m4_provide_if([$1], [m4_set_contains([_m4_provide], [$1], + [_m4_require_check([$1], _m4_defn([m4_provide($1)]), [$0])], [m4_ignore])], + [_m4_require_call])([$1], [$2], _m4_divert_dump)]) + + +# _m4_require_call(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK], +# DIVERSION-NUMBER) +# ----------------------------------------------------------------- +# If m4_require decides to expand the body, it calls this macro. The +# expansion is placed in DIVERSION-NUMBER. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and other overhead on the common path. +# The use of a witness macro protecting the warning allows aclocal +# to silence any warnings when probing for what macros are required +# and must therefore be located, when using the Autoconf-without-aclocal-m4 +# autom4te language. For more background, see: +# https://lists.gnu.org/archive/html/automake-patches/2012-11/msg00035.html +m4_define([_m4_require_call], +[m4_pushdef([_m4_divert_grow], m4_decr(_m4_divert_grow))]dnl +[m4_pushdef([_m4_diverting([$1])])m4_pushdef([_m4_diverting], [$1])]dnl +[m4_divert_push(_m4_divert_grow, [-])]dnl +[m4_if([$2], [], [$1], [$2]) +m4_provide_if([$1], [m4_set_remove([_m4_provide], [$1])], + [m4_ifndef([m4_require_silent_probe], + [m4_warn([syntax], [$1 is m4_require'd but not m4_defun'd])])])]dnl +[_m4_divert_raw($3)_m4_undivert(_m4_divert_grow)]dnl +[m4_divert_pop(_m4_divert_grow)_m4_popdef([_m4_divert_grow], +[_m4_diverting([$1])], [_m4_diverting])]) + + +# _m4_require_check(NAME-TO-CHECK, OWNER, CALLER) +# ----------------------------------------------- +# NAME-TO-CHECK has been identified as previously expanded in the +# diversion owned by OWNER. If this is a problem, warn on behalf of +# CALLER and return _m4_require_call; otherwise return m4_ignore. +m4_define([_m4_require_check], +[m4_if(_m4_defn([_m4_diverting]), [$2], [m4_ignore], + m4_ifdef([_m4_diverting([$2])], [-]), [-], [m4_warn([syntax], + [$3: `$1' was expanded before it was required +http://www.gnu.org/software/autoconf/manual/autoconf.html#Expanded-Before-Required])_m4_require_call], + [m4_ignore])]) + + +# _m4_divert_grow +# --------------- +# The counter for _m4_require_call. +m4_define([_m4_divert_grow], _m4_divert([GROW])) + + +# m4_expand_once(TEXT, [WITNESS = TEXT]) +# -------------------------------------- +# If TEXT has never been expanded, expand it *here*. Use WITNESS as +# as a memory that TEXT has already been expanded. +m4_define([m4_expand_once], +[m4_provide_if(m4_default_quoted([$2], [$1]), + [], + [m4_provide(m4_default_quoted([$2], [$1]))[]$1])]) + + +# m4_provide(MACRO-NAME) +# ---------------------- +m4_define([m4_provide], +[m4_ifdef([m4_provide($1)], [], +[m4_set_add([_m4_provide], [$1], [m4_define([m4_provide($1)], + m4_ifdef([_m4_diverting], [_m4_defn([_m4_diverting])]))])])]) + + +# m4_provide_if(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED) +# ------------------------------------------------------- +# If MACRO-NAME is provided do IF-PROVIDED, else IF-NOT-PROVIDED. +# The purpose of this macro is to provide the user with a means to +# check macros which are provided without letting her know how the +# information is coded. +m4_define([m4_provide_if], +[m4_ifdef([m4_provide($1)], + [$2], [$3])]) + + +## --------------------- ## +## 12. Text processing. ## +## --------------------- ## + + +# m4_cr_letters +# m4_cr_LETTERS +# m4_cr_Letters +# ------------- +m4_define([m4_cr_letters], [abcdefghijklmnopqrstuvwxyz]) +m4_define([m4_cr_LETTERS], [ABCDEFGHIJKLMNOPQRSTUVWXYZ]) +m4_define([m4_cr_Letters], +m4_defn([m4_cr_letters])dnl +m4_defn([m4_cr_LETTERS])dnl +) + + +# m4_cr_digits +# ------------ +m4_define([m4_cr_digits], [0123456789]) + + +# m4_cr_alnum +# ----------- +m4_define([m4_cr_alnum], +m4_defn([m4_cr_Letters])dnl +m4_defn([m4_cr_digits])dnl +) + + +# m4_cr_symbols1 +# m4_cr_symbols2 +# -------------- +m4_define([m4_cr_symbols1], +m4_defn([m4_cr_Letters])dnl +_) + +m4_define([m4_cr_symbols2], +m4_defn([m4_cr_symbols1])dnl +m4_defn([m4_cr_digits])dnl +) + +# m4_cr_all +# --------- +# The character range representing everything, with `-' as the last +# character, since it is special to m4_translit. Use with care, because +# it contains characters special to M4 (fortunately, both ASCII and EBCDIC +# have [] in order, so m4_defn([m4_cr_all]) remains a valid string). It +# also contains characters special to terminals, so it should never be +# displayed in an error message. Also, attempts to map [ and ] to other +# characters via m4_translit must deal with the fact that m4_translit does +# not add quotes to the output. +# +# In EBCDIC, $ is immediately followed by *, which leads to problems +# if m4_cr_all is inlined into a macro definition; so swap them. +# +# It is mainly useful in generating inverted character range maps, for use +# in places where m4_translit is faster than an equivalent m4_bpatsubst; +# the regex `[^a-z]' is equivalent to: +# m4_translit(m4_dquote(m4_defn([m4_cr_all])), [a-z]) +m4_define([m4_cr_all], +m4_translit(m4_dquote(m4_format(m4_dquote(m4_for( + ,1,255,,[[%c]]))m4_for([i],1,255,,[,i]))), [$*-], [*$])-) + + +# _m4_define_cr_not(CATEGORY) +# --------------------------- +# Define m4_cr_not_CATEGORY as the inverse of m4_cr_CATEGORY. +m4_define([_m4_define_cr_not], +[m4_define([m4_cr_not_$1], + m4_translit(m4_dquote(m4_defn([m4_cr_all])), + m4_defn([m4_cr_$1])))]) + + +# m4_cr_not_letters +# m4_cr_not_LETTERS +# m4_cr_not_Letters +# m4_cr_not_digits +# m4_cr_not_alnum +# m4_cr_not_symbols1 +# m4_cr_not_symbols2 +# ------------------ +# Inverse character sets +_m4_define_cr_not([letters]) +_m4_define_cr_not([LETTERS]) +_m4_define_cr_not([Letters]) +_m4_define_cr_not([digits]) +_m4_define_cr_not([alnum]) +_m4_define_cr_not([symbols1]) +_m4_define_cr_not([symbols2]) + + +# m4_newline([STRING]) +# -------------------- +# Expands to a newline, possibly followed by STRING. Exists mostly for +# formatting reasons. +m4_define([m4_newline], [ +$1]) + + +# m4_re_escape(STRING) +# -------------------- +# Escape RE active characters in STRING. +m4_define([m4_re_escape], +[m4_bpatsubst([$1], + [[][*+.?\^$]], [\\\&])]) + + +# m4_re_string +# ------------ +# Regexp for `[a-zA-Z_0-9]*' +# m4_dquote provides literal [] for the character class. +m4_define([m4_re_string], +m4_dquote(m4_defn([m4_cr_symbols2]))dnl +[*]dnl +) + + +# m4_re_word +# ---------- +# Regexp for `[a-zA-Z_][a-zA-Z_0-9]*' +m4_define([m4_re_word], +m4_dquote(m4_defn([m4_cr_symbols1]))dnl +m4_defn([m4_re_string])dnl +) + + +# m4_tolower(STRING) +# m4_toupper(STRING) +# ------------------ +# These macros convert STRING to lowercase or uppercase. +# +# Rather than expand the m4_defn each time, we inline them up front. +m4_define([m4_tolower], +[m4_translit([[$1]], ]m4_dquote(m4_defn([m4_cr_LETTERS]))[, + ]m4_dquote(m4_defn([m4_cr_letters]))[)]) +m4_define([m4_toupper], +[m4_translit([[$1]], ]m4_dquote(m4_defn([m4_cr_letters]))[, + ]m4_dquote(m4_defn([m4_cr_LETTERS]))[)]) + + +# m4_split(STRING, [REGEXP]) +# -------------------------- +# Split STRING into an m4 list of quoted elements. The elements are +# quoted with [ and ]. Beginning spaces and end spaces *are kept*. +# Use m4_strip to remove them. +# +# REGEXP specifies where to split. Default is [\t ]+. +# +# If STRING is empty, the result is an empty list. +# +# Pay attention to the m4_changequotes. When m4 reads the definition of +# m4_split, it still has quotes set to [ and ]. Luckily, these are matched +# in the macro body, so the definition is stored correctly. Use the same +# alternate quotes as m4_noquote; it must be unlikely to appear in $1. +# +# Also, notice that $1 is quoted twice, since we want the result to +# be quoted. Then you should understand that the argument of +# patsubst is -=<{(STRING)}>=- (i.e., with additional -=<{( and )}>=-). +# +# This macro is safe on active symbols, i.e.: +# m4_define(active, ACTIVE) +# m4_split([active active ])end +# => [active], [active], []end +# +# Optimize on regex of ` ' (space), since m4_foreach_w already guarantees +# that the list contains single space separators, and a common case is +# splitting a single-element list. This macro is called frequently, +# so avoid unnecessary dnl inside the definition. +m4_define([m4_split], +[m4_if([$1], [], [], + [$2], [ ], [m4_if(m4_index([$1], [ ]), [-1], [[[$1]]], + [_$0([$1], [$2], [, ])])], + [$2], [], [_$0([$1], [[ ]+], [, ])], + [_$0([$1], [$2], [, ])])]) + +m4_define([_m4_split], +[m4_changequote([-=<{(],[)}>=-])]dnl +[[m4_bpatsubst(-=<{(-=<{($1)}>=-)}>=-, -=<{($2)}>=-, + -=<{(]$3[)}>=-)]m4_changequote([, ])]) + + +# m4_chomp(STRING) +# m4_chomp_all(STRING) +# -------------------- +# Return STRING quoted, but without a trailing newline. m4_chomp +# removes at most one newline, while m4_chomp_all removes all +# consecutive trailing newlines. Embedded newlines are not touched, +# and a trailing backslash-newline leaves just a trailing backslash. +# +# m4_bregexp is slower than m4_index, and we don't always want to +# remove all newlines; hence the two variants. We massage characters +# to give a nicer pattern to match, particularly since m4_bregexp is +# line-oriented. Both versions must guarantee a match, to avoid bugs +# with precision -1 in m4_format in older m4. +m4_define([m4_chomp], +[m4_format([[%.*s]], m4_index(m4_translit([[$1]], [ +/.], [/ ])[./.], [/.]), [$1])]) + +m4_define([m4_chomp_all], +[m4_format([[%.*s]], m4_bregexp(m4_translit([[$1]], [ +/], [/ ]), [/*$]), [$1])]) + + +# m4_flatten(STRING) +# ------------------ +# If STRING contains end of lines, replace them with spaces. If there +# are backslashed end of lines, remove them. This macro is safe with +# active symbols. +# m4_define(active, ACTIVE) +# m4_flatten([active +# act\ +# ive])end +# => active activeend +# +# In m4, m4_bpatsubst is expensive, so first check for a newline. +m4_define([m4_flatten], +[m4_if(m4_index([$1], [ +]), [-1], [[$1]], + [m4_translit(m4_bpatsubst([[[$1]]], [\\ +]), [ +], [ ])])]) + + +# m4_strip(STRING) +# ---------------- +# Expands into STRING with tabs and spaces singled out into a single +# space, and removing leading and trailing spaces. +# +# This macro is robust to active symbols. +# m4_define(active, ACTIVE) +# m4_strip([ active active ])end +# => active activeend +# +# First, notice that we guarantee trailing space. Why? Because regular +# expressions are greedy, and `.* ?' would always group the space into the +# .* portion. The algorithm is simpler by avoiding `?' at the end. The +# algorithm correctly strips everything if STRING is just ` '. +# +# Then notice the second pattern: it is in charge of removing the +# leading/trailing spaces. Why not just `[^ ]'? Because they are +# applied to over-quoted strings, i.e. more or less [STRING], due +# to the limitations of m4_bpatsubsts. So the leading space in STRING +# is the *second* character; equally for the trailing space. +m4_define([m4_strip], +[m4_bpatsubsts([$1 ], + [[ ]+], [ ], + [^. ?\(.*\) .$], [[[\1]]])]) + + +# m4_normalize(STRING) +# -------------------- +# Apply m4_flatten and m4_strip to STRING. +# +# The argument is quoted, so that the macro is robust to active symbols: +# +# m4_define(active, ACTIVE) +# m4_normalize([ act\ +# ive +# active ])end +# => active activeend + +m4_define([m4_normalize], +[m4_strip(m4_flatten([$1]))]) + + + +# m4_join(SEP, ARG1, ARG2...) +# --------------------------- +# Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG +# is the empty string. No expansion is performed on SEP or ARGs. +# +# Since the number of arguments to join can be arbitrarily long, we +# want to avoid having more than one $@ in the macro definition; +# otherwise, the expansion would require twice the memory of the already +# long list. Hence, m4_join merely looks for the first non-empty element, +# and outputs just that element; while _m4_join looks for all non-empty +# elements, and outputs them following a separator. The final trick to +# note is that we decide between recursing with $0 or _$0 based on the +# nested m4_if ending with `_'. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_join], +[m4_if([$#], [1], [], + [$#], [2], [[$2]], + [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift2($@))])]) +m4_define([_m4_join], +[m4_if([$#$2], [2], [], + [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift2($@))])]) + +# m4_joinall(SEP, ARG1, ARG2...) +# ------------------------------ +# Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP. +# No expansion is performed on SEP or ARGs. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_joinall], [[$2]_$0([$1], m4_shift($@))]) +m4_define([_m4_joinall], +[m4_if([$#], [2], [], [[$1$3]$0([$1], m4_shift2($@))])]) + +# m4_combine([SEPARATOR], PREFIX-LIST, [INFIX], SUFFIX...) +# -------------------------------------------------------- +# Produce the pairwise combination of every element in the quoted, +# comma-separated PREFIX-LIST with every element from the SUFFIX arguments. +# Each pair is joined with INFIX, and pairs are separated by SEPARATOR. +# No expansion occurs on SEPARATOR, INFIX, or elements of either list. +# +# For example: +# m4_combine([, ], [[a], [b], [c]], [-], [1], [2], [3]) +# => a-1, a-2, a-3, b-1, b-2, b-3, c-1, c-2, c-3 +# +# This definition is a bit hairy; the thing to realize is that we want +# to construct m4_map_args_sep([[prefix$3]], [], [[$1]], m4_shift3($@)) +# as the inner loop, using each prefix generated by the outer loop, +# and without recalculating m4_shift3 every outer iteration. +m4_define([m4_combine], +[m4_if([$2], [], [], m4_eval([$# > 3]), [1], +[m4_map_args_sep([m4_map_args_sep(m4_dquote(], [)[[$3]], [], [[$1]],]]]dnl +[m4_dquote(m4_dquote(m4_shift3($@)))[[)], [[$1]], $2)])]) + + +# m4_append(MACRO-NAME, STRING, [SEPARATOR]) +# ------------------------------------------ +# Redefine MACRO-NAME to hold its former content plus `SEPARATOR`'STRING' +# at the end. It is valid to use this macro with MACRO-NAME undefined, +# in which case no SEPARATOR is added. Be aware that the criterion is +# `not being defined', and not `not being empty'. +# +# Note that neither STRING nor SEPARATOR are expanded here; rather, when +# you expand MACRO-NAME, they will be expanded at that point in time. +# +# This macro is robust to active symbols. It can be used to grow +# strings. +# +# | m4_define(active, ACTIVE)dnl +# | m4_append([sentence], [This is an])dnl +# | m4_append([sentence], [ active ])dnl +# | m4_append([sentence], [symbol.])dnl +# | sentence +# | m4_undefine([active])dnl +# | sentence +# => This is an ACTIVE symbol. +# => This is an active symbol. +# +# It can be used to define hooks. +# +# | m4_define(active, ACTIVE)dnl +# | m4_append([hooks], [m4_define([act1], [act2])])dnl +# | m4_append([hooks], [m4_define([act2], [active])])dnl +# | m4_undefine([active])dnl +# | act1 +# | hooks +# | act1 +# => act1 +# => +# => active +# +# It can also be used to create lists, although this particular usage was +# broken prior to autoconf 2.62. +# | m4_append([list], [one], [, ])dnl +# | m4_append([list], [two], [, ])dnl +# | m4_append([list], [three], [, ])dnl +# | list +# | m4_dquote(list) +# => one, two, three +# => [one],[two],[three] +# +# Note that m4_append can benefit from amortized O(n) m4 behavior, if +# the underlying m4 implementation is smart enough to avoid copying existing +# contents when enlarging a macro's definition into any pre-allocated storage +# (m4 1.4.x unfortunately does not implement this optimization). We do +# not implement m4_prepend, since it is inherently O(n^2) (pre-allocated +# storage only occurs at the end of a macro, so the existing contents must +# always be moved). +# +# Use _m4_defn for speed. +m4_define([m4_append], +[m4_define([$1], m4_ifdef([$1], [_m4_defn([$1])[$3]])[$2])]) + + +# m4_append_uniq(MACRO-NAME, STRING, [SEPARATOR], [IF-UNIQ], [IF-DUP]) +# -------------------------------------------------------------------- +# Like `m4_append', but append only if not yet present. Additionally, +# expand IF-UNIQ if STRING was appended, or IF-DUP if STRING was already +# present. Also, warn if SEPARATOR is not empty and occurs within STRING, +# as the algorithm no longer guarantees uniqueness. +# +# Note that while m4_append can be O(n) (depending on the quality of the +# underlying M4 implementation), m4_append_uniq is inherently O(n^2) +# because each append operation searches the entire string. +m4_define([m4_append_uniq], +[m4_ifval([$3], [m4_if(m4_index([$2], [$3]), [-1], [], + [m4_warn([syntax], + [$0: `$2' contains `$3'])])])_$0($@)]) +m4_define([_m4_append_uniq], +[m4_ifdef([$1], + [m4_if(m4_index([$3]_m4_defn([$1])[$3], [$3$2$3]), [-1], + [m4_append([$1], [$2], [$3])$4], [$5])], + [m4_define([$1], [$2])$4])]) + +# m4_append_uniq_w(MACRO-NAME, STRINGS) +# ------------------------------------- +# For each of the words in the whitespace separated list STRINGS, append +# only the unique strings to the definition of MACRO-NAME. +# +# Use _m4_defn for speed. +m4_define([m4_append_uniq_w], +[m4_map_args_w([$2], [_m4_append_uniq([$1],], [, [ ])])]) + + +# m4_escape(STRING) +# ----------------- +# Output quoted STRING, but with embedded #, $, [ and ] turned into +# quadrigraphs. +# +# It is faster to check if STRING is already good using m4_translit +# than to blindly perform four m4_bpatsubst. +# +# Because the translit is stripping quotes, it must also neutralize +# anything that might be in a macro name, as well as comments, commas, +# and parentheses. All the problem characters are unified so that a +# single m4_index can scan the result. +# +# Rather than expand m4_defn every time m4_escape is expanded, we +# inline its expansion up front. +m4_define([m4_escape], +[m4_if(m4_index(m4_translit([$1], + [[]#,()]]m4_dquote(m4_defn([m4_cr_symbols2]))[, [$$$]), [$]), + [-1], [m4_echo], [_$0])([$1])]) + +m4_define([_m4_escape], +[m4_changequote([-=<{(],[)}>=-])]dnl +[m4_bpatsubst(m4_bpatsubst(m4_bpatsubst(m4_bpatsubst( + -=<{(-=<{(-=<{(-=<{(-=<{($1)}>=-)}>=-)}>=-)}>=-)}>=-, + -=<{(#)}>=-, -=<{(@%:@)}>=-), + -=<{(\[)}>=-, -=<{(@<:@)}>=-), + -=<{(\])}>=-, -=<{(@:>@)}>=-), + -=<{(\$)}>=-, -=<{(@S|@)}>=-)m4_changequote([,])]) + + +# m4_text_wrap(STRING, [PREFIX], [FIRST-PREFIX], [WIDTH]) +# ------------------------------------------------------- +# Expands into STRING wrapped to hold in WIDTH columns (default = 79). +# If PREFIX is given, each line is prefixed with it. If FIRST-PREFIX is +# specified, then the first line is prefixed with it. As a special case, +# if the length of FIRST-PREFIX is greater than that of PREFIX, then +# FIRST-PREFIX will be left alone on the first line. +# +# No expansion occurs on the contents STRING, PREFIX, or FIRST-PREFIX, +# although quadrigraphs are correctly recognized. More precisely, +# you may redefine m4_qlen to recognize whatever escape sequences that +# you will post-process. +# +# Typical outputs are: +# +# m4_text_wrap([Short string */], [ ], [/* ], 20) +# => /* Short string */ +# +# m4_text_wrap([Much longer string */], [ ], [/* ], 20) +# => /* Much longer +# => string */ +# +# m4_text_wrap([Short doc.], [ ], [ --short ], 30) +# => --short Short doc. +# +# m4_text_wrap([Short doc.], [ ], [ --too-wide ], 30) +# => --too-wide +# => Short doc. +# +# m4_text_wrap([Super long documentation.], [ ], [ --too-wide ], 30) +# => --too-wide +# => Super long +# => documentation. +# +# FIXME: there is no checking of a longer PREFIX than WIDTH, but do +# we really want to bother with people trying each single corner +# of a software? +# +# This macro does not leave a trailing space behind the last word of a line, +# which complicates it a bit. The algorithm is otherwise stupid and simple: +# all the words are preceded by m4_Separator which is defined to empty for +# the first word, and then ` ' (single space) for all the others. +# +# The algorithm uses a helper that uses $2 through $4 directly, rather than +# using local variables, to avoid m4_defn overhead, or expansion swallowing +# any $. It also bypasses m4_popdef overhead with _m4_popdef since no user +# macro expansion occurs in the meantime. Also, the definition is written +# with m4_do, to avoid time wasted on dnl during expansion (since this is +# already a time-consuming macro). +m4_define([m4_text_wrap], +[_$0(m4_escape([$1]), [$2], m4_default_quoted([$3], [$2]), + m4_default_quoted([$4], [79]))]) + +m4_define([_m4_text_wrap], +m4_do(dnl set up local variables, to avoid repeated calculations +[[m4_pushdef([m4_Indent], m4_qlen([$2]))]], +[[m4_pushdef([m4_Cursor], m4_qlen([$3]))]], +[[m4_pushdef([m4_Separator], [m4_define([m4_Separator], [ ])])]], +dnl expand the first prefix, then check its length vs. regular prefix +dnl same length: nothing special +dnl prefix1 longer: output on line by itself, and reset cursor +dnl prefix1 shorter: pad to length of prefix, and reset cursor +[[[$3]m4_cond([m4_Cursor], m4_Indent, [], + [m4_eval(m4_Cursor > m4_Indent)], [1], [ +[$2]m4_define([m4_Cursor], m4_Indent)], + [m4_format([%*s], m4_max([0], + m4_eval(m4_Indent - m4_Cursor)), [])m4_define([m4_Cursor], m4_Indent)])]], +dnl now, for each word, compute the cursor after the word is output, then +dnl check if the cursor would exceed the wrap column +dnl if so, reset cursor, and insert newline and prefix +dnl if not, insert the separator (usually a space) +dnl either way, insert the word +[[m4_map_args_w([$1], [$0_word(], [, [$2], [$4])])]], +dnl finally, clean up the local variables +[[_m4_popdef([m4_Separator], [m4_Cursor], [m4_Indent])]])) + +m4_define([_m4_text_wrap_word], +[m4_define([m4_Cursor], m4_eval(m4_Cursor + m4_qlen([$1]) + 1))]dnl +[m4_if(m4_eval(m4_Cursor > ([$3])), + [1], [m4_define([m4_Cursor], m4_eval(m4_Indent + m4_qlen([$1]) + 1)) +[$2]], + [m4_Separator[]])[$1]]) + +# m4_text_box(MESSAGE, [FRAME-CHARACTER = `-']) +# --------------------------------------------- +# Turn MESSAGE into: +# ## ------- ## +# ## MESSAGE ## +# ## ------- ## +# using FRAME-CHARACTER in the border. +# +# Quadrigraphs are correctly recognized. More precisely, you may +# redefine m4_qlen to recognize whatever escape sequences that you +# will post-process. +m4_define([m4_text_box], +[m4_pushdef([m4_Border], + m4_translit(m4_format([[[%*s]]], m4_decr(m4_qlen(_m4_expand([$1 +]))), []), [ ], m4_default_quoted([$2], [-])))]dnl +[[##] _m4_defn([m4_Border]) [##] +[##] $1 [##] +[##] _m4_defn([m4_Border]) [##]_m4_popdef([m4_Border])]) + + +# m4_qlen(STRING) +# --------------- +# Expands to the length of STRING after autom4te converts all quadrigraphs. +# +# If you use some other means of post-processing m4 output rather than +# autom4te, then you may redefine this macro to recognize whatever +# escape sequences your post-processor will handle. For that matter, +# m4_define([m4_qlen], m4_defn([m4_len])) is sufficient if you don't +# do any post-processing. +# +# Avoid bpatsubsts for the common case of no quadrigraphs. Cache +# results, as configure scripts tend to ask about lengths of common +# strings like `/*' and `*/' rather frequently. Minimize the number +# of times that $1 occurs in m4_qlen, so there is less text to parse +# on a cache hit. +m4_define([m4_qlen], +[m4_ifdef([$0-$1], [_m4_defn([$0-]], [_$0(])[$1])]) +m4_define([_m4_qlen], +[m4_define([m4_qlen-$1], +m4_if(m4_index([$1], [@]), [-1], [m4_len([$1])], + [m4_len(m4_bpatsubst([[$1]], + [@\(\(<:\|:>\|S|\|%:\|\{:\|:\}\)\(@\)\|&t@\)], + [\3]))]))_m4_defn([m4_qlen-$1])]) + +# m4_copyright_condense(TEXT) +# --------------------------- +# Condense the copyright notice in TEXT to only display the final +# year, wrapping the results to fit in 80 columns. +m4_define([m4_copyright_condense], +[m4_text_wrap(m4_bpatsubst(m4_flatten([[$1]]), +[(C)[- ,0-9]*\([1-9][0-9][0-9][0-9]\)], [(C) \1]))]) + +## ----------------------- ## +## 13. Number processing. ## +## ----------------------- ## + +# m4_cmp(A, B) +# ------------ +# Compare two integer expressions. +# A < B -> -1 +# A = B -> 0 +# A > B -> 1 +m4_define([m4_cmp], +[m4_eval((([$1]) > ([$2])) - (([$1]) < ([$2])))]) + + +# m4_list_cmp(A, B) +# ----------------- +# +# Compare the two lists of integer expressions A and B. For instance: +# m4_list_cmp([1, 0], [1]) -> 0 +# m4_list_cmp([1, 0], [1, 0]) -> 0 +# m4_list_cmp([1, 2], [1, 0]) -> 1 +# m4_list_cmp([1, 2, 3], [1, 2]) -> 1 +# m4_list_cmp([1, 2, -3], [1, 2]) -> -1 +# m4_list_cmp([1, 0], [1, 2]) -> -1 +# m4_list_cmp([1], [1, 2]) -> -1 +# m4_define([xa], [oops])dnl +# m4_list_cmp([[0xa]], [5+5]) -> 0 +# +# Rather than face the overhead of m4_case, we use a helper function whose +# expansion includes the name of the macro to invoke on the tail, either +# m4_ignore or m4_unquote. This is particularly useful when comparing +# long lists, since less text is being expanded for deciding when to end +# recursion. The recursion is between a pair of macros that alternate +# which list is trimmed by one element; this is more efficient than +# calling m4_cdr on both lists from a single macro. Guarantee exactly +# one expansion of both lists' side effects. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_list_cmp], +[_$0_raw(m4_dquote($1), m4_dquote($2))]) + +m4_define([_m4_list_cmp_raw], +[m4_if([$1], [$2], [0], [_m4_list_cmp_1([$1], $2)])]) + +m4_define([_m4_list_cmp], +[m4_if([$1], [], [0m4_ignore], [$2], [0], [m4_unquote], [$2m4_ignore])]) + +m4_define([_m4_list_cmp_1], +[_m4_list_cmp_2([$2], [m4_shift2($@)], $1)]) + +m4_define([_m4_list_cmp_2], +[_m4_list_cmp([$1$3], m4_cmp([$3+0], [$1+0]))( + [_m4_list_cmp_1(m4_dquote(m4_shift3($@)), $2)])]) + +# m4_max(EXPR, ...) +# m4_min(EXPR, ...) +# ----------------- +# Return the decimal value of the maximum (or minimum) in a series of +# integer expressions. +# +# M4 1.4.x doesn't provide ?:. Hence this huge m4_eval. Avoid m4_eval +# if both arguments are identical, but be aware of m4_max(0xa, 10) (hence +# the use of <=, not just <, in the second multiply). +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_max], +[m4_if([$#], [0], [m4_fatal([too few arguments to $0])], + [$#], [1], [m4_eval([$1])], + [$#$1], [2$2], [m4_eval([$1])], + [$#], [2], [_$0($@)], + [_m4_minmax([_$0], $@)])]) + +m4_define([_m4_max], +[m4_eval((([$1]) > ([$2])) * ([$1]) + (([$1]) <= ([$2])) * ([$2]))]) + +m4_define([m4_min], +[m4_if([$#], [0], [m4_fatal([too few arguments to $0])], + [$#], [1], [m4_eval([$1])], + [$#$1], [2$2], [m4_eval([$1])], + [$#], [2], [_$0($@)], + [_m4_minmax([_$0], $@)])]) + +m4_define([_m4_min], +[m4_eval((([$1]) < ([$2])) * ([$1]) + (([$1]) >= ([$2])) * ([$2]))]) + +# _m4_minmax(METHOD, ARG1, ARG2...) +# --------------------------------- +# Common recursion code for m4_max and m4_min. METHOD must be _m4_max +# or _m4_min, and there must be at least two arguments to combine. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([_m4_minmax], +[m4_if([$#], [3], [$1([$2], [$3])], + [$0([$1], $1([$2], [$3]), m4_shift3($@))])]) + + +# m4_sign(A) +# ---------- +# The sign of the integer expression A. +m4_define([m4_sign], +[m4_eval((([$1]) > 0) - (([$1]) < 0))]) + + + +## ------------------------ ## +## 14. Version processing. ## +## ------------------------ ## + + +# m4_version_unletter(VERSION) +# ---------------------------- +# Normalize beta version numbers with letters to numeric expressions, which +# can then be handed to m4_eval for the purpose of comparison. +# +# Nl -> (N+1).-1.(l#) +# +# for example: +# [2.14a] -> [0,2,14+1,-1,[0r36:a]] -> 2.15.-1.10 +# [2.14b] -> [0,2,15+1,-1,[0r36:b]] -> 2.15.-1.11 +# [2.61aa.b] -> [0,2.61,1,-1,[0r36:aa],+1,-1,[0r36:b]] -> 2.62.-1.370.1.-1.11 +# [08] -> [0,[0r10:0]8] -> 8 +# +# This macro expects reasonable version numbers, but can handle double +# letters and does not expand any macros. Original version strings can +# use both `.' and `-' separators. +# +# Inline constant expansions, to avoid m4_defn overhead. +# _m4_version_unletter is the real workhorse used by m4_version_compare, +# but since [0r36:a] and commas are less readable than 10 and dots, we +# provide a wrapper for human use. +m4_define([m4_version_unletter], +[m4_substr(m4_map_args([.m4_eval], m4_unquote(_$0([$1]))), [3])]) +m4_define([_m4_version_unletter], +[m4_bpatsubst(m4_bpatsubst(m4_translit([[[[0,$1]]]], [.-], [,,]),]dnl +m4_dquote(m4_dquote(m4_defn([m4_cr_Letters])))[[+], + [+1,-1,[0r36:\&]]), [,0], [,[0r10:0]])]) + + +# m4_version_compare(VERSION-1, VERSION-2) +# ---------------------------------------- +# Compare the two version numbers and expand into +# -1 if VERSION-1 < VERSION-2 +# 0 if = +# 1 if > +# +# Since _m4_version_unletter does not output side effects, we can +# safely bypass the overhead of m4_version_cmp. +m4_define([m4_version_compare], +[_m4_list_cmp_raw(_m4_version_unletter([$1]), _m4_version_unletter([$2]))]) + + +# m4_PACKAGE_NAME +# m4_PACKAGE_TARNAME +# m4_PACKAGE_VERSION +# m4_PACKAGE_STRING +# m4_PACKAGE_BUGREPORT +# -------------------- +# If m4sugar/version.m4 is present, then define version strings. This +# file is optional, provided by Autoconf but absent in Bison. +m4_sinclude([m4sugar/version.m4]) + + +# m4_version_prereq(VERSION, [IF-OK], [IF-NOT = FAIL]) +# ---------------------------------------------------- +# Check this Autoconf version against VERSION. +m4_define([m4_version_prereq], +m4_ifdef([m4_PACKAGE_VERSION], +[[m4_if(m4_version_compare(]m4_dquote(m4_defn([m4_PACKAGE_VERSION]))[, [$1]), + [-1], + [m4_default([$3], + [m4_fatal([Autoconf version $1 or higher is required], + [63])])], + [$2])]], +[[m4_fatal([m4sugar/version.m4 not found])]])) + + +## ------------------ ## +## 15. Set handling. ## +## ------------------ ## + +# Autoconf likes to create arbitrarily large sets; for example, as of +# this writing, the configure.ac for coreutils tracks a set of more +# than 400 AC_SUBST. How do we track all of these set members, +# without introducing duplicates? We could use m4_append_uniq, with +# the set NAME residing in the contents of the macro NAME. +# Unfortunately, m4_append_uniq is quadratic for set creation, because +# it costs O(n) to search the string for each of O(n) insertions; not +# to mention that with m4 1.4.x, even using m4_append is slow, costing +# O(n) rather than O(1) per insertion. Other set operations, not used +# by Autoconf but still possible by manipulation of the definition +# tracked in macro NAME, include O(n) deletion of one element and O(n) +# computation of set size. Because the set is exposed to the user via +# the definition of a single macro, we cannot cache any data about the +# set without risking the cache being invalidated by the user +# redefining NAME. +# +# Can we do better? Yes, because m4 gives us an O(1) search function +# for free: ifdef. Additionally, even m4 1.4.x gives us an O(1) +# insert operation for free: pushdef. But to use these, we must +# represent the set via a group of macros; to keep the set consistent, +# we must hide the set so that the user can only manipulate it through +# accessor macros. The contents of the set are maintained through two +# access points; _m4_set([name]) is a pushdef stack of values in the +# set, useful for O(n) traversal of the set contents; while the +# existence of _m4_set([name],value) with no particular value is +# useful for O(1) querying of set membership. And since the user +# cannot externally manipulate the set, we are free to add additional +# caching macros for other performance improvements. Deletion can be +# O(1) per element rather than O(n), by reworking the definition of +# _m4_set([name],value) to be 0 or 1 based on current membership, and +# adding _m4_set_cleanup(name) to defer the O(n) cleanup of +# _m4_set([name]) until we have another reason to do an O(n) +# traversal. The existence of _m4_set_cleanup(name) can then be used +# elsewhere to determine if we must dereference _m4_set([name],value), +# or assume that definition implies set membership. Finally, size can +# be tracked in an O(1) fashion with _m4_set_size(name). +# +# The quoting in _m4_set([name],value) is chosen so that there is no +# ambiguity with a set whose name contains a comma, and so that we can +# supply the value via _m4_defn([_m4_set([name])]) without needing any +# quote manipulation. + +# m4_set_add(SET, VALUE, [IF-UNIQ], [IF-DUP]) +# ------------------------------------------- +# Add VALUE as an element of SET. Expand IF-UNIQ on the first +# addition, and IF-DUP if it is already in the set. Addition of one +# element is O(1), such that overall set creation is O(n). +# +# We do not want to add a duplicate for a previously deleted but +# unpruned element, but it is just as easy to check existence directly +# as it is to query _m4_set_cleanup($1). +m4_define([m4_set_add], +[m4_ifdef([_m4_set([$1],$2)], + [m4_if(m4_indir([_m4_set([$1],$2)]), [0], + [m4_define([_m4_set([$1],$2)], + [1])_m4_set_size([$1], [m4_incr])$3], [$4])], + [m4_define([_m4_set([$1],$2)], + [1])m4_pushdef([_m4_set([$1])], + [$2])_m4_set_size([$1], [m4_incr])$3])]) + +# m4_set_add_all(SET, VALUE...) +# ----------------------------- +# Add each VALUE into SET. This is O(n) in the number of VALUEs, and +# can be faster than calling m4_set_add for each VALUE. +# +# Implement two recursion helpers; the check variant is slower but +# handles the case where an element has previously been removed but +# not pruned. The recursion helpers ignore their second argument, so +# that we can use the faster m4_shift2 and 2 arguments, rather than +# _m4_shift2 and one argument, as the signal to end recursion. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_set_add_all], +[m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1]) + + m4_len(m4_ifdef([_m4_set_cleanup($1)], [_$0_check], [_$0])([$1], $@))))]) + +m4_define([_m4_set_add_all], +[m4_if([$#], [2], [], + [m4_ifdef([_m4_set([$1],$3)], [], + [m4_define([_m4_set([$1],$3)], [1])m4_pushdef([_m4_set([$1])], + [$3])-])$0([$1], m4_shift2($@))])]) + +m4_define([_m4_set_add_all_check], +[m4_if([$#], [2], [], + [m4_set_add([$1], [$3])$0([$1], m4_shift2($@))])]) + +# m4_set_contains(SET, VALUE, [IF-PRESENT], [IF-ABSENT]) +# ------------------------------------------------------ +# Expand IF-PRESENT if SET contains VALUE, otherwise expand IF-ABSENT. +# This is always O(1). +m4_define([m4_set_contains], +[m4_ifdef([_m4_set_cleanup($1)], + [m4_if(m4_ifdef([_m4_set([$1],$2)], + [m4_indir([_m4_set([$1],$2)])], [0]), [1], [$3], [$4])], + [m4_ifdef([_m4_set([$1],$2)], [$3], [$4])])]) + +# m4_set_contents(SET, [SEP]) +# --------------------------- +# Expand to a single string containing all the elements in SET, +# separated by SEP, without modifying SET. No provision is made for +# disambiguating set elements that contain non-empty SEP as a +# sub-string, or for recognizing a set that contains only the empty +# string. Order of the output is not guaranteed. If any elements +# have been previously removed from the set, this action will prune +# the unused memory. This is O(n) in the size of the set before +# pruning. +# +# Use _m4_popdef for speed. The existence of _m4_set_cleanup($1) +# determines which version of _1 helper we use. +m4_define([m4_set_contents], +[m4_set_map_sep([$1], [], [], [[$2]])]) + +# _m4_set_contents_1(SET) +# _m4_set_contents_1c(SET) +# _m4_set_contents_2(SET, [PRE], [POST], [SEP]) +# --------------------------------------------- +# Expand to a list of quoted elements currently in the set, each +# surrounded by PRE and POST, and moving SEP in front of PRE on +# recursion. To avoid nesting limit restrictions, the algorithm must +# be broken into two parts; _1 destructively copies the stack in +# reverse into _m4_set_($1), producing no output; then _2 +# destructively copies _m4_set_($1) back into the stack in reverse. +# If no elements were deleted, then this visits the set in the order +# that elements were inserted. Behavior is undefined if PRE/POST/SEP +# tries to recursively list or modify SET in any way other than +# calling m4_set_remove on the current element. Use _1 if all entries +# in the stack are guaranteed to be in the set, and _1c to prune +# removed entries. Uses _m4_defn and _m4_popdef for speed. +m4_define([_m4_set_contents_1], +[_m4_stack_reverse([_m4_set([$1])], [_m4_set_($1)])]) + +m4_define([_m4_set_contents_1c], +[m4_ifdef([_m4_set([$1])], + [m4_set_contains([$1], _m4_defn([_m4_set([$1])]), + [m4_pushdef([_m4_set_($1)], _m4_defn([_m4_set([$1])]))], + [_m4_popdef([_m4_set([$1],]_m4_defn( + [_m4_set([$1])])[)])])_m4_popdef([_m4_set([$1])])$0([$1])], + [_m4_popdef([_m4_set_cleanup($1)])])]) + +m4_define([_m4_set_contents_2], +[_m4_stack_reverse([_m4_set_($1)], [_m4_set([$1])], + [$2[]_m4_defn([_m4_set_($1)])$3], [$4[]])]) + +# m4_set_delete(SET) +# ------------------ +# Delete all elements in SET, and reclaim any memory occupied by the +# set. This is O(n) in the set size. +# +# Use _m4_defn and _m4_popdef for speed. +m4_define([m4_set_delete], +[m4_ifdef([_m4_set([$1])], + [_m4_popdef([_m4_set([$1],]_m4_defn([_m4_set([$1])])[)], + [_m4_set([$1])])$0([$1])], + [m4_ifdef([_m4_set_cleanup($1)], + [_m4_popdef([_m4_set_cleanup($1)])])m4_ifdef( + [_m4_set_size($1)], + [_m4_popdef([_m4_set_size($1)])])])]) + +# m4_set_difference(SET1, SET2) +# ----------------------------- +# Produce a LIST of quoted elements that occur in SET1 but not SET2. +# Output a comma prior to any elements, to distinguish the empty +# string from no elements. This can be directly used as a series of +# arguments, such as for m4_join, or wrapped inside quotes for use in +# m4_foreach. Order of the output is not guaranteed. +# +# Short-circuit the idempotence relation. +m4_define([m4_set_difference], +[m4_if([$1], [$2], [], [m4_set_map_sep([$1], [_$0([$2],], [)])])]) + +m4_define([_m4_set_difference], +[m4_set_contains([$1], [$2], [], [,[$2]])]) + +# m4_set_dump(SET, [SEP]) +# ----------------------- +# Expand to a single string containing all the elements in SET, +# separated by SEP, then delete SET. In general, if you only need to +# list the contents once, this is faster than m4_set_contents. No +# provision is made for disambiguating set elements that contain +# non-empty SEP as a sub-string. Order of the output is not +# guaranteed. This is O(n) in the size of the set before pruning. +# +# Use _m4_popdef for speed. Use existence of _m4_set_cleanup($1) to +# decide if more expensive recursion is needed. +m4_define([m4_set_dump], +[m4_ifdef([_m4_set_size($1)], + [_m4_popdef([_m4_set_size($1)])])m4_ifdef([_m4_set_cleanup($1)], + [_$0_check], [_$0])([$1], [], [$2])]) + +# _m4_set_dump(SET, [SEP], [PREP]) +# _m4_set_dump_check(SET, [SEP], [PREP]) +# -------------------------------------- +# Print SEP and the current element, then delete the element and +# recurse with empty SEP changed to PREP. The check variant checks +# whether the element has been previously removed. Use _m4_defn and +# _m4_popdef for speed. +m4_define([_m4_set_dump], +[m4_ifdef([_m4_set([$1])], + [[$2]_m4_defn([_m4_set([$1])])_m4_popdef([_m4_set([$1],]_m4_defn( + [_m4_set([$1])])[)], [_m4_set([$1])])$0([$1], [$2$3])])]) + +m4_define([_m4_set_dump_check], +[m4_ifdef([_m4_set([$1])], + [m4_set_contains([$1], _m4_defn([_m4_set([$1])]), + [[$2]_m4_defn([_m4_set([$1])])])_m4_popdef( + [_m4_set([$1],]_m4_defn([_m4_set([$1])])[)], + [_m4_set([$1])])$0([$1], [$2$3])], + [_m4_popdef([_m4_set_cleanup($1)])])]) + +# m4_set_empty(SET, [IF-EMPTY], [IF-ELEMENTS]) +# -------------------------------------------- +# Expand IF-EMPTY if SET has no elements, otherwise IF-ELEMENTS. +m4_define([m4_set_empty], +[m4_ifdef([_m4_set_size($1)], + [m4_if(m4_indir([_m4_set_size($1)]), [0], [$2], [$3])], [$2])]) + +# m4_set_foreach(SET, VAR, ACTION) +# -------------------------------- +# For each element of SET, define VAR to the element and expand +# ACTION. ACTION should not recursively list SET's contents, add +# elements to SET, nor delete any element from SET except the one +# currently in VAR. The order that the elements are visited in is not +# guaranteed. This is faster than the corresponding m4_foreach([VAR], +# m4_indir([m4_dquote]m4_set_listc([SET])), [ACTION]) +m4_define([m4_set_foreach], +[m4_pushdef([$2])m4_set_map_sep([$1], [m4_define([$2],], [)$3])]) + +# m4_set_intersection(SET1, SET2) +# ------------------------------- +# Produce a LIST of quoted elements that occur in both SET1 or SET2. +# Output a comma prior to any elements, to distinguish the empty +# string from no elements. This can be directly used as a series of +# arguments, such as for m4_join, or wrapped inside quotes for use in +# m4_foreach. Order of the output is not guaranteed. +# +# Iterate over the smaller set, and short-circuit the idempotence +# relation. +m4_define([m4_set_intersection], +[m4_if([$1], [$2], [m4_set_listc([$1])], + m4_eval(m4_set_size([$2]) < m4_set_size([$1])), [1], [$0([$2], [$1])], + [m4_set_map_sep([$1], [_$0([$2],], [)])])]) + +m4_define([_m4_set_intersection], +[m4_set_contains([$1], [$2], [,[$2]])]) + +# m4_set_list(SET) +# m4_set_listc(SET) +# ----------------- +# Produce a LIST of quoted elements of SET. This can be directly used +# as a series of arguments, such as for m4_join or m4_set_add_all, or +# wrapped inside quotes for use in m4_foreach or m4_map. With +# m4_set_list, there is no way to distinguish an empty set from a set +# containing only the empty string; with m4_set_listc, a leading comma +# is output if there are any elements. +m4_define([m4_set_list], +[m4_set_map_sep([$1], [], [], [,])]) + +m4_define([m4_set_listc], +[m4_set_map_sep([$1], [,])]) + +# m4_set_map(SET, ACTION) +# ----------------------- +# For each element of SET, expand ACTION with a single argument of the +# current element. ACTION should not recursively list SET's contents, +# add elements to SET, nor delete any element from SET except the one +# passed as an argument. The order that the elements are visited in +# is not guaranteed. This is faster than either of the corresponding +# m4_map_args([ACTION]m4_set_listc([SET])) +# m4_set_foreach([SET], [VAR], [ACTION(m4_defn([VAR]))]) +m4_define([m4_set_map], +[m4_set_map_sep([$1], [$2(], [)])]) + +# m4_set_map_sep(SET, [PRE], [POST], [SEP]) +# ----------------------------------------- +# For each element of SET, expand PRE[value]POST[], and expand SEP +# between elements. +m4_define([m4_set_map_sep], +[m4_ifdef([_m4_set_cleanup($1)], [_m4_set_contents_1c], + [_m4_set_contents_1])([$1])_m4_set_contents_2($@)]) + +# m4_set_remove(SET, VALUE, [IF-PRESENT], [IF-ABSENT]) +# ---------------------------------------------------- +# If VALUE is an element of SET, delete it and expand IF-PRESENT. +# Otherwise expand IF-ABSENT. Deleting a single value is O(1), +# although it leaves memory occupied until the next O(n) traversal of +# the set which will compact the set. +# +# Optimize if the element being removed is the most recently added, +# since defining _m4_set_cleanup($1) slows down so many other macros. +# In particular, this plays well with m4_set_foreach and m4_set_map. +m4_define([m4_set_remove], +[m4_set_contains([$1], [$2], [_m4_set_size([$1], + [m4_decr])m4_if(_m4_defn([_m4_set([$1])]), [$2], + [_m4_popdef([_m4_set([$1],$2)], [_m4_set([$1])])], + [m4_define([_m4_set_cleanup($1)])m4_define( + [_m4_set([$1],$2)], [0])])$3], [$4])]) + +# m4_set_size(SET) +# ---------------- +# Expand to the number of elements currently in SET. This operation +# is O(1), and thus more efficient than m4_count(m4_set_list([SET])). +m4_define([m4_set_size], +[m4_ifdef([_m4_set_size($1)], [m4_indir([_m4_set_size($1)])], [0])]) + +# _m4_set_size(SET, ACTION) +# ------------------------- +# ACTION must be either m4_incr or m4_decr, and the size of SET is +# changed accordingly. If the set is empty, ACTION must not be +# m4_decr. +m4_define([_m4_set_size], +[m4_define([_m4_set_size($1)], + m4_ifdef([_m4_set_size($1)], [$2(m4_indir([_m4_set_size($1)]))], + [1]))]) + +# m4_set_union(SET1, SET2) +# ------------------------ +# Produce a LIST of double quoted elements that occur in either SET1 +# or SET2, without duplicates. Output a comma prior to any elements, +# to distinguish the empty string from no elements. This can be +# directly used as a series of arguments, such as for m4_join, or +# wrapped inside quotes for use in m4_foreach. Order of the output is +# not guaranteed. +# +# We can rely on the fact that m4_set_listc prunes SET1, so we don't +# need to check _m4_set([$1],element) for 0. Short-circuit the +# idempotence relation. +m4_define([m4_set_union], +[m4_set_listc([$1])m4_if([$1], [$2], [], + [m4_set_map_sep([$2], [_$0([$1],], [)])])]) + +m4_define([_m4_set_union], +[m4_ifdef([_m4_set([$1],$2)], [], [,[$2]])]) + + +## ------------------- ## +## 16. File handling. ## +## ------------------- ## + + +# It is a real pity that M4 comes with no macros to bind a diversion +# to a file. So we have to deal without, which makes us a lot more +# fragile than we should. + + +# m4_file_append(FILE-NAME, CONTENT) +# ---------------------------------- +m4_define([m4_file_append], +[m4_syscmd([cat >>$1 <<_m4eof +$2 +_m4eof +]) +m4_if(m4_sysval, [0], [], + [m4_fatal([$0: cannot write: $1])])]) + + + +## ------------------------ ## +## 17. Setting M4sugar up. ## +## ------------------------ ## + +# _m4_divert_diversion should be defined. +m4_divert_push([KILL]) + +# m4_init +# ------- +# Initialize the m4sugar language. +m4_define([m4_init], +[# All the M4sugar macros start with `m4_', except `dnl' kept as is +# for sake of simplicity. +m4_pattern_forbid([^_?m4_]) +m4_pattern_forbid([^dnl$]) + +# If __m4_version__ is defined, we assume that we are being run by M4 +# 1.6 or newer, thus $@ recursion is linear, and debugmode(+do) +# is available for faster checks of dereferencing undefined macros +# and forcing dumpdef to print to stderr regardless of debugfile. +# But if it is missing, we assume we are being run by M4 1.4.x, that +# $@ recursion is quadratic, and that we need foreach-based +# replacement macros. Also, m4 prior to 1.4.8 loses track of location +# during m4wrap text; __line__ should never be 0. +# +# Use the raw builtin to avoid tripping up include tracing. +# Meanwhile, avoid m4_copy, since it temporarily undefines m4_defn. +m4_ifdef([__m4_version__], +[m4_debugmode([+do]) +m4_define([m4_defn], _m4_defn([_m4_defn])) +m4_define([m4_dumpdef], _m4_defn([_m4_dumpdef])) +m4_define([m4_popdef], _m4_defn([_m4_popdef])) +m4_define([m4_undefine], _m4_defn([_m4_undefine]))], +[m4_builtin([include], [m4sugar/foreach.m4]) +m4_wrap_lifo([m4_if(__line__, [0], [m4_pushdef([m4_location], +]]m4_dquote(m4_dquote(m4_dquote(__file__:__line__)))[[)])])]) + +# Rewrite the first entry of the diversion stack. +m4_divert([KILL]) + +# Check the divert push/pop perfect balance. +# Some users are prone to also use m4_wrap to register last-minute +# m4_divert_text; so after our diversion cleanups, we restore +# KILL as the bottom of the diversion stack. +m4_wrap([m4_popdef([_m4_divert_diversion])m4_ifdef( + [_m4_divert_diversion], [m4_fatal([$0: unbalanced m4_divert_push: +]m4_divert_stack)])_m4_popdef([_m4_divert_stack])m4_divert_push([KILL])]) +]) diff --git a/gnuwin32/bin/data/stack.hh b/gnuwin32/bin/data/stack.hh new file mode 100644 index 00000000..aa64d63d --- /dev/null +++ b/gnuwin32/bin/data/stack.hh @@ -0,0 +1,154 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_pushdef([b4_copyright_years], + [2002-2013]) + +# b4_stack_define +# --------------- +m4_define([b4_stack_define], +[[ template > + class stack + { + public: + // Hide our reversed order. + typedef typename S::reverse_iterator iterator; + typedef typename S::const_reverse_iterator const_iterator; + + stack () + : seq_ () + { + } + + stack (unsigned int n) + : seq_ (n) + { + } + + inline + T& + operator[] (unsigned int i) + { + return seq_[seq_.size () - 1 - i]; + } + + inline + const T& + operator[] (unsigned int i) const + { + return seq_[seq_.size () - 1 - i]; + } + + /// Steal the contents of \a t. + /// + /// Close to move-semantics. + inline + void + push (T& t) + { + seq_.push_back (T()); + operator[](0).move (t); + } + + inline + void + pop (unsigned int n = 1) + { + for (; n; --n) + seq_.pop_back (); + } + + void + clear () + { + seq_.clear (); + } + + inline + typename S::size_type + size () const + { + return seq_.size (); + } + + inline + const_iterator + begin () const + { + return seq_.rbegin (); + } + + inline + const_iterator + end () const + { + return seq_.rend (); + } + + private: + stack (const stack&); + stack& operator= (const stack&); + /// The wrapped container. + S seq_; + }; + + /// Present a slice of the top of a stack. + template > + class slice + { + public: + slice (const S& stack, unsigned int range) + : stack_ (stack) + , range_ (range) + { + } + + inline + const T& + operator [] (unsigned int i) const + { + return stack_[range_ - i]; + } + + private: + const S& stack_; + unsigned int range_; + }; +]]) + +b4_defines_if( +[b4_output_begin([b4_dir_prefix[]stack.hh]) +b4_copyright([Stack handling for Bison parsers in C++])[ + +/** + ** \file ]b4_dir_prefix[stack.hh + ** Define the ]b4_namespace_ref[::stack class. + */ + +]b4_cpp_guard_open([b4_dir_prefix[]stack.hh])[ + +# include + +]b4_namespace_open[ +]b4_stack_define[ +]b4_namespace_close[ + +]b4_cpp_guard_close([b4_dir_prefix[]stack.hh]) +b4_output_end() +]) + +m4_popdef([b4_copyright_years]) diff --git a/gnuwin32/bin/data/variant.hh b/gnuwin32/bin/data/variant.hh new file mode 100644 index 00000000..ac4f7a78 --- /dev/null +++ b/gnuwin32/bin/data/variant.hh @@ -0,0 +1,362 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2013 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +## --------- ## +## variant. ## +## --------- ## + +# b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS]) +# ------------------------------------------------ +# Run some ACTION ("build", or "destroy") on YYVAL of symbol type +# YYTYPE. +m4_define([b4_symbol_variant], +[m4_pushdef([b4_dollar_dollar], + [$2.$3< $][3 > (m4_shift3($@))])dnl + switch ($1) + { +b4_type_foreach([b4_type_action_])[]dnl + default: + break; + } +m4_popdef([b4_dollar_dollar])dnl +]) + + +# _b4_char_sizeof_counter +# ----------------------- +# A counter used by _b4_char_sizeof_dummy to create fresh symbols. +m4_define([_b4_char_sizeof_counter], +[0]) + +# _b4_char_sizeof_dummy +# --------------------- +# At each call return a new C++ identifier. +m4_define([_b4_char_sizeof_dummy], +[m4_define([_b4_char_sizeof_counter], m4_incr(_b4_char_sizeof_counter))dnl +dummy[]_b4_char_sizeof_counter]) + + +# b4_char_sizeof(SYMBOL-NUMS) +# --------------------------- +# To be mapped on the list of type names to produce: +# +# char dummy1[sizeof(type_name_1)]; +# char dummy2[sizeof(type_name_2)]; +# +# for defined type names. +m4_define([b4_char_sizeof], +[b4_symbol_if([$1], [has_type], +[ +m4_map([ b4_symbol_tag_comment], [$@])dnl + char _b4_char_sizeof_dummy@{sizeof(b4_symbol([$1], [type]))@}; +])]) + + +# b4_variant_includes +# ------------------- +# The needed includes for variants support. +m4_define([b4_variant_includes], +[b4_parse_assert_if([[#include ]])[ +#ifndef YYASSERT +# include +# define YYASSERT assert +#endif +]]) + +# b4_variant_define +# ----------------- +# Define "variant". +m4_define([b4_variant_define], +[[ /// A char[S] buffer to store and retrieve objects. + /// + /// Sort of a variant, but does not keep track of the nature + /// of the stored data, since that knowledge is available + /// via the current state. + template + struct variant + { + /// Type of *this. + typedef variant self_type; + + /// Empty construction. + variant ()]b4_parse_assert_if([ + : yytname_ (YY_NULL)])[ + {} + + /// Construct and fill. + template + variant (const T& t)]b4_parse_assert_if([ + : yytname_ (typeid (T).name ())])[ + { + YYASSERT (sizeof (T) <= S); + new (yyas_ ()) T (t); + } + + /// Destruction, allowed only if empty. + ~variant () + {]b4_parse_assert_if([ + YYASSERT (!yytname_); + ])[} + + /// Instantiate an empty \a T in here. + template + T& + build () + {]b4_parse_assert_if([ + YYASSERT (!yytname_); + YYASSERT (sizeof (T) <= S); + yytname_ = typeid (T).name ();])[ + return *new (yyas_ ()) T; + } + + /// Instantiate a \a T in here from \a t. + template + T& + build (const T& t) + {]b4_parse_assert_if([ + YYASSERT (!yytname_); + YYASSERT (sizeof (T) <= S); + yytname_ = typeid (T).name ();])[ + return *new (yyas_ ()) T (t); + } + + /// Accessor to a built \a T. + template + T& + as () + {]b4_parse_assert_if([ + YYASSERT (yytname_ == typeid (T).name ()); + YYASSERT (sizeof (T) <= S);])[ + return *yyas_ (); + } + + /// Const accessor to a built \a T (for %printer). + template + const T& + as () const + {]b4_parse_assert_if([ + YYASSERT (yytname_ == typeid (T).name ()); + YYASSERT (sizeof (T) <= S);])[ + return *yyas_ (); + } + + /// Swap the content with \a other, of same type. + /// + /// Both variants must be built beforehand, because swapping the actual + /// data requires reading it (with as()), and this is not possible on + /// unconstructed variants: it would require some dynamic testing, which + /// should not be the variant's responsability. + /// Swapping between built and (possibly) non-built is done with + /// variant::move (). + template + void + swap (self_type& other) + {]b4_parse_assert_if([ + YYASSERT (yytname_); + YYASSERT (yytname_ == other.yytname_);])[ + std::swap (as (), other.as ()); + } + + /// Move the content of \a other to this. + /// + /// Destroys \a other. + template + void + move (self_type& other) + {]b4_parse_assert_if([ + YYASSERT (!yytname_);])[ + build (); + swap (other); + other.destroy (); + } + + /// Copy the content of \a other to this. + template + void + copy (const self_type& other) + { + build (other.as ()); + } + + /// Destroy the stored \a T. + template + void + destroy () + { + as ().~T ();]b4_parse_assert_if([ + yytname_ = YY_NULL;])[ + } + + private: + /// Prohibit blind copies. + self_type& operator=(const self_type&); + variant (const self_type&); + + /// Accessor to raw memory as \a T. + template + T* + yyas_ () + { + void *yyp = yybuffer_.yyraw; + return static_cast (yyp); + } + + /// Const accessor to raw memory as \a T. + template + const T* + yyas_ () const + { + const void *yyp = yybuffer_.yyraw; + return static_cast (yyp); + } + + union + { + /// Strongest alignment constraints. + long double yyalign_me; + /// A buffer large enough to store any of the semantic values. + char yyraw[S]; + } yybuffer_;]b4_parse_assert_if([ + + /// Whether the content is built: if defined, the name of the stored type. + const char *yytname_;])[ + }; +]]) + + +## -------------------------- ## +## Adjustments for variants. ## +## -------------------------- ## + + +# b4_value_type_declare +# --------------------- +# Declare semantic_type. +m4_define([b4_value_type_declare], +[[ /// An auxiliary type to compute the largest semantic type. + union union_type + {]b4_type_foreach([b4_char_sizeof])[}; + + /// Symbol semantic values. + typedef variant semantic_type;][]dnl +]) + + +# How the semantic value is extracted when using variants. + +# b4_symbol_value(VAL, [TYPE]) +# ---------------------------- +m4_define([b4_symbol_value], +[m4_ifval([$2], + [$1.as< $2 > ()], + [$1])]) + +# b4_symbol_value_template(VAL, [TYPE]) +# ------------------------------------- +# Same as b4_symbol_value, but used in a template method. +m4_define([b4_symbol_value_template], +[m4_ifval([$2], + [$1.template as< $2 > ()], + [$1])]) + + + +## ------------- ## +## make_SYMBOL. ## +## ------------- ## + + +# b4_symbol_constructor_declare_(SYMBOL-NUMBER) +# --------------------------------------------- +# Declare the overloaded version of make_symbol for the (common) type of +# these SYMBOL-NUMBERS. Use at class-level. +m4_define([b4_symbol_constructor_declare_], +[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id], +[ static inline + symbol_type + make_[]b4_symbol_([$1], [id]) (dnl +b4_join(b4_symbol_if([$1], [has_type], + [const b4_symbol([$1], [type])& v]), + b4_locations_if([const location_type& l]))); + +])])]) + + +# b4_symbol_constructor_declare +# ----------------------------- +# Declare symbol constructors for all the value types. +# Use at class-level. +m4_define([b4_symbol_constructor_declare], +[ // Symbol constructors declarations. +b4_symbol_foreach([b4_symbol_constructor_declare_])]) + + + +# b4_symbol_constructor_define_(SYMBOL-NUMBER) +# -------------------------------------------- +# Define symbol constructor for this SYMBOL-NUMBER. +m4_define([b4_symbol_constructor_define_], +[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id], +[ b4_parser_class_name::symbol_type + b4_parser_class_name::make_[]b4_symbol_([$1], [id]) (dnl +b4_join(b4_symbol_if([$1], [has_type], + [const b4_symbol([$1], [type])& v]), + b4_locations_if([const location_type& l]))) + { + return symbol_type (b4_join([token::b4_symbol([$1], [id])], + b4_symbol_if([$1], [has_type], [v]), + b4_locations_if([l]))); + + } + +])])]) + + +# b4_basic_symbol_constructor_declare +# ----------------------------------- +# Generate a constructor declaration for basic_symbol from given type. +m4_define([b4_basic_symbol_constructor_declare], +[[ + basic_symbol (]b4_join( + [typename Base::kind_type t], + b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]), + b4_locations_if([const location_type& l]))[); +]]) + +# b4_basic_symbol_constructor_define +# ---------------------------------- +# Generate a constructor implementation for basic_symbol from given type. +m4_define([b4_basic_symbol_constructor_define], +[[ + template + ]b4_parser_class_name[::basic_symbol::basic_symbol (]b4_join( + [typename Base::kind_type t], + b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]), + b4_locations_if([const location_type& l]))[) + : Base (t) + , value (]b4_symbol_if([$1], [has_type], [v])[)]b4_locations_if([ + , location (l)])[ + {} +]]) + +# b4_symbol_constructor_define +# ---------------------------- +# Define the overloaded versions of make_symbol for all the value types. +m4_define([b4_symbol_constructor_define], +[ // Implementation of make_symbol for each symbol type. +b4_symbol_foreach([b4_symbol_constructor_define_])]) diff --git a/gnuwin32/bin/data/xslt/bison.xsl b/gnuwin32/bin/data/xslt/bison.xsl new file mode 100644 index 00000000..10e3305b --- /dev/null +++ b/gnuwin32/bin/data/xslt/bison.xsl @@ -0,0 +1,105 @@ + + + + + + + + + + + + + + + + + + + + + + + + + s + + + r + + + + + + , + + + + + 0 + + + + + + + + + + + diff --git a/gnuwin32/bin/data/xslt/xml2dot.xsl b/gnuwin32/bin/data/xslt/xml2dot.xsl new file mode 100644 index 00000000..93bec599 --- /dev/null +++ b/gnuwin32/bin/data/xslt/xml2dot.xsl @@ -0,0 +1,397 @@ + + + + + + + + + + + + + + + // Generated by GNU Bison + + . + // Report bugs to < + + >. + // Home page: < + + >. + + + + + + + + digraph " + + + + " { + node [fontname = courier, shape = box, colorscheme = paired6] + edge [fontname = courier] + + + + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + label="[ + + + + + + , + + + ]", + + + + style=solid] + + + + + + + + + 3 + + + 5 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + : + + + + . + + + + + . + + + + + + + + + + + + + [ + + ] + + + + + + , + + + + + + + + + + + -> " + + R + + + d + + " [ + + + + + + + + " + + R + + + d + + " [label=" + + + Acc", fillcolor=1 + + + R + + ", fillcolor= + + + + , shape=diamond, style=filled] + + + + + + + + + + dotted + + + solid + + + dashed + + + + + + + + + + + + + + + + + [label=" + State + + \n + + + + \l"] + + + + + + + + + + -> + + [style= + + + label=" + + + + " + + ] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/gnuwin32/bin/data/xslt/xml2text.xsl b/gnuwin32/bin/data/xslt/xml2text.xsl new file mode 100644 index 00000000..2626f566 --- /dev/null +++ b/gnuwin32/bin/data/xslt/xml2text.xsl @@ -0,0 +1,569 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Nonterminals useless in grammar + + + + + + + + + + + + Terminals unused in grammar + + + + + + + + + + + + + + Rules useless in grammar + + + + + + + + + + + Rules useless in parser due to conflicts + + + + + + + + + Grammar + + + + + + + + + + + + + + + + + + + + + + + + + Terminals, with rules where they appear + + + + + + Nonterminals, with rules where they appear + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + on@left: + + + + + + + , + + on@right: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + State + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + : + + + + + + + . + + + + + + + + + . + + + + + + + + + + + + + + + + %empty + + + + [ + + ] + + + + + + , + + + + + + + + + + + + + shift, and go to state + + + + go to state + + + + + + + + + + + + + + error + ( + + ) + + + + + + + + + + + + [ + + + + accept + + + reduce using rule + + ( + + ) + + + + ] + + + + + + + + + + + + + Conflict between rule + + and token + + resolved as + + an + + + ( + + ). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/gnuwin32/bin/data/xslt/xml2xhtml.xsl b/gnuwin32/bin/data/xslt/xml2xhtml.xsl new file mode 100644 index 00000000..d2cfed4c --- /dev/null +++ b/gnuwin32/bin/data/xslt/xml2xhtml.xsl @@ -0,0 +1,745 @@ + + + + + + + + + + + + + + + <xsl:value-of select="bison-xml-report/filename"/> + <xsl:text> - GNU Bison XML Automaton Report</xsl:text> + + + + + + + + + + + + +

GNU Bison XML Automaton Report

+

+ input grammar: +

+ + +

Table of Contents

+ + + + + + + + + +

+ + Reductions +

+ + + + + + +

+ + Nonterminals useless in grammar +

+ + +

+ + + + + + +

+ + + + +

+ + Terminals unused in grammar +

+ + +

+ + + + + + + +

+ + + + +

+ + Rules useless in grammar +

+ + + +

+ + + + +

+ + + + + + +

+ + Rules useless in parser due to conflicts +

+ +

+ + + +

+ + + + + +

+ + Grammar +

+ +

+ + + +

+ + + + + + + + + + + + + + + + + + + + + +

+ + Conflicts +

+ + + + + +

+ + +

+ + + + + + + + + + + + + + + + + conflicts: + + + + + + + + + + + + + + +

+ + Terminals, with rules where they appear +

+ +

+ +

+ + + + +

+ + Nonterminals, with rules where they appear +

+ +

+ +

+ + + + + + + + + + + + + + + + + on left: + + + + + + + + + on right: + + + + + + + + + + + + + + + + + + +

+ + Automaton +

+ + + + + + + + +

+ + + + + + state + +

+ +

+ + + + + + + + + + + + +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + → + + + + + + + + . + + + + + + + + + + . + + + + + + + + + + + + + + + + + + + + + + + ε + + + + [ + + ] + + + + + + , + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + error + ( + + ) + + + + + + + + + + + + [ + + + + accept + + + + + + + + + ( + + ) + + + + ] + + + + + + + + + + + + + Conflict between + + + + + + + and token + + resolved as + + an + + + ( + + ). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + diff --git a/gnuwin32/bin/data/yacc.c b/gnuwin32/bin/data/yacc.c new file mode 100644 index 00000000..822656b8 --- /dev/null +++ b/gnuwin32/bin/data/yacc.c @@ -0,0 +1,1915 @@ + -*- C -*- +# Yacc compatible skeleton for Bison + +# Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, +# Inc. + +m4_pushdef([b4_copyright_years], + [1984, 1989-1990, 2000-2013]) + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# Check the value of %define api.push-pull. +b4_percent_define_default([[api.push-pull]], [[pull]]) +b4_percent_define_check_values([[[[api.push-pull]], + [[pull]], [[push]], [[both]]]]) +b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]]) +b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]]) +m4_case(b4_percent_define_get([[api.push-pull]]), + [pull], [m4_define([b4_push_flag], [[0]])], + [push], [m4_define([b4_pull_flag], [[0]])]) + +# Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing +# tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the +# behavior of Bison at all when push parsing is already requested. +b4_define_flag_if([use_push_for_pull]) +b4_use_push_for_pull_if([ + b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])], + [m4_define([b4_push_flag], [[1]])])]) + +# Check the value of %define parse.lac and friends, where LAC stands for +# lookahead correction. +b4_percent_define_default([[parse.lac]], [[none]]) +b4_percent_define_default([[parse.lac.es-capacity-initial]], [[20]]) +b4_percent_define_default([[parse.lac.memory-trace]], [[failures]]) +b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]], + [[[[parse.lac.memory-trace]], + [[failures]], [[full]]]]) +b4_define_flag_if([lac]) +m4_define([b4_lac_flag], + [m4_if(b4_percent_define_get([[parse.lac]]), + [none], [[0]], [[1]])]) + +m4_include(b4_pkgdatadir/[c.m4]) + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Stack parameters. +m4_define_default([b4_stack_depth_max], [10000]) +m4_define_default([b4_stack_depth_init], [200]) + + +## ------------------------ ## +## Pure/impure interfaces. ## +## ------------------------ ## + +b4_percent_define_default([[api.pure]], [[false]]) +b4_percent_define_check_values([[[[api.pure]], + [[false]], [[true]], [[]], [[full]]]]) + +m4_define([b4_pure_flag], [[0]]) +m4_case(b4_percent_define_get([[api.pure]]), + [false], [m4_define([b4_pure_flag], [[0]])], + [true], [m4_define([b4_pure_flag], [[1]])], + [], [m4_define([b4_pure_flag], [[1]])], + [full], [m4_define([b4_pure_flag], [[2]])]) + +m4_define([b4_pure_if], +[m4_case(b4_pure_flag, + [0], [$2], + [1], [$1], + [2], [$1])]) + [m4_fatal([invalid api.pure value: ]$1)])]) + +# b4_yyerror_arg_loc_if(ARG) +# -------------------------- +# Expand ARG iff yyerror is to be given a location as argument. +m4_define([b4_yyerror_arg_loc_if], +[b4_locations_if([m4_case(b4_pure_flag, + [1], [m4_ifset([b4_parse_param], [$1])], + [2], [$1])])]) + +# b4_yyerror_args +# --------------- +# Arguments passed to yyerror: user args plus yylloc. +m4_define([b4_yyerror_args], +[b4_yyerror_arg_loc_if([&yylloc, ])dnl +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])]) + + + +## ------------ ## +## Data Types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# MIN to MAX (included). Overwrite the version from c.m4, which +# uses only C89 types, so that the user can override the shorter +# types, and so that pre-C89 compilers are handled correctly. +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [0], [255]), [1], [yytype_uint8], + b4_ints_in($@, [-128], [127]), [1], [yytype_int8], + + b4_ints_in($@, [0], [65535]), [1], [yytype_uint16], + b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16], + + m4_eval([0 <= $1]), [1], [unsigned int], + + [int])]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_lhs_value([TYPE]) +# -------------------- +# Expansion of $$. +m4_define([b4_lhs_value], +[b4_symbol_value(yyval, [$1])]) + + +# b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) +# -------------------------------------- +# Expansion of $NUM, where the current rule has RULE-LENGTH +# symbols on RHS. +m4_define([b4_rhs_value], + [b4_symbol_value([yyvsp@{b4_subtract([$2], [$1])@}], [$3])]) + + +## ----------- ## +## Locations. ## +## ----------- ## + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], + [(yylsp@{b4_subtract([$2], [$1])@})]) + + +## -------------- ## +## Declarations. ## +## -------------- ## + +# b4_declare_scanner_communication_variables +# ------------------------------------------ +# Declare the variables that are global, or local to YYPARSE if +# pure-parser. +m4_define([b4_declare_scanner_communication_variables], [[ +/* The lookahead symbol. */ +int yychar; + +]b4_pure_if([[ +/* The semantic value of the lookahead symbol. */ +/* Default value used for initialization, for pacifying older GCCs + or non-GCC compilers. */ +YY_INITIAL_VALUE (static YYSTYPE yyval_default;) +YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);]b4_locations_if([[ + +/* Location data for the lookahead symbol. */ +static YYLTYPE yyloc_default]b4_yyloc_default[; +YYLTYPE yylloc = yyloc_default;]])], +[[/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval;]b4_locations_if([[ +/* Location data for the lookahead symbol. */ +YYLTYPE yylloc]b4_yyloc_default[;]])[ +/* Number of syntax errors so far. */ +int yynerrs;]])]) + + +# b4_declare_parser_state_variables +# --------------------------------- +# Declare all the variables that are needed to maintain the parser state +# between calls to yypush_parse. +m4_define([b4_declare_parser_state_variables], [b4_pure_if([[ + /* Number of syntax errors so far. */ + int yynerrs; +]])[ + int yystate; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + + /* The stacks and their tools: + 'yyss': related to states. + 'yyvs': related to semantic values.]b4_locations_if([[ + 'yyls': related to locations.]])[ + + Refer to the stacks through separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs; + YYSTYPE *yyvsp;]b4_locations_if([[ + + /* The location stack. */ + YYLTYPE yylsa[YYINITDEPTH]; + YYLTYPE *yyls; + YYLTYPE *yylsp; + + /* The locations where the error started and ended. */ + YYLTYPE yyerror_range[3];]])[ + + YYSIZE_T yystacksize;]b4_lac_if([[ + + yytype_int16 yyesa@{]b4_percent_define_get([[parse.lac.es-capacity-initial]])[@}; + yytype_int16 *yyes; + YYSIZE_T yyes_capacity;]])]) + + +# b4_declare_yyparse_push_ +# ------------------------ +# Declaration of yyparse (and dependencies) when using the push parser +# (including in pull mode). +m4_define([b4_declare_yyparse_push_], +[[#ifndef YYPUSH_MORE_DEFINED +# define YYPUSH_MORE_DEFINED +enum { YYPUSH_MORE = 4 }; +#endif + +typedef struct ]b4_prefix[pstate ]b4_prefix[pstate; + +]b4_pull_if([b4_function_declare([b4_prefix[parse]], [[int]], b4_parse_param) +])b4_function_declare([b4_prefix[push_parse]], [[int]], + [[b4_prefix[pstate *ps]], [[ps]]]b4_pure_if([, + [[[int pushed_char]], [[pushed_char]]], + [[b4_api_PREFIX[STYPE const *pushed_val]], [[pushed_val]]]b4_locations_if([, + [[b4_api_PREFIX[LTYPE *pushed_loc]], [[pushed_loc]]]])])m4_ifset([b4_parse_param], [, + b4_parse_param])) +b4_pull_if([b4_function_declare([b4_prefix[pull_parse]], [[int]], + [[b4_prefix[pstate *ps]], [[ps]]]m4_ifset([b4_parse_param], [, + b4_parse_param]))]) +b4_function_declare([b4_prefix[pstate_new]], [b4_prefix[pstate *]], + [[[void]], []]) +b4_function_declare([b4_prefix[pstate_delete]], [[void]], + [[b4_prefix[pstate *ps]], [[ps]]])dnl +]) + +# b4_declare_yyparse_ +# ------------------- +# When not the push parser. +m4_define([b4_declare_yyparse_], +[b4_function_declare(b4_prefix[parse], [int], b4_parse_param)]) + + +# b4_declare_yyparse +# ------------------ +m4_define([b4_declare_yyparse], +[b4_push_if([b4_declare_yyparse_push_], + [b4_declare_yyparse_])[]dnl +]) + + +# b4_shared_declarations +# ---------------------- +# Declaration that might either go into the header (if --defines) +# or open coded in the parser body. +m4_define([b4_shared_declarations], +[b4_cpp_guard_open([b4_spec_defines_file])[ +]b4_declare_yydebug[ +]b4_percent_code_get([[requires]])[ +]b4_token_enums_defines[ +]b4_declare_yylstype[ +]b4_declare_yyparse[ +]b4_percent_code_get([[provides]])[ +]b4_cpp_guard_close([b4_spec_defines_file])[]dnl +]) + +## -------------- ## +## Output files. ## +## -------------- ## + +b4_output_begin([b4_parser_file_name]) +b4_copyright([Bison implementation for Yacc-like parsers in C])[ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +]b4_identification +b4_percent_code_get([[top]])[]dnl +m4_if(b4_api_prefix, [yy], [], +[[/* Substitute the type names. */ +#define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[ +#define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[ +]m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */]b4_pull_if([[ +#define yyparse ]b4_prefix[parse]])b4_push_if([[ +#define yypush_parse ]b4_prefix[push_parse]b4_pull_if([[ +#define yypull_parse ]b4_prefix[pull_parse]])[ +#define yypstate_new ]b4_prefix[pstate_new +#define yypstate_delete ]b4_prefix[pstate_delete +#define yypstate ]b4_prefix[pstate]])[ +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yydebug ]b4_prefix[debug +#define yynerrs ]b4_prefix[nerrs +]]b4_pure_if([], [[ +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])]))[ + +/* Copy the first part of user declarations. */ +]b4_user_pre_prologue[ + +]b4_null_define[ + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[ +#endif + +]m4_ifval(m4_quote(b4_spec_defines_file), +[[/* In a future release of Bison, this section will be replaced + by #include "@basename(]b4_spec_defines_file[@)". */ +]])dnl +b4_shared_declarations[ + +/* Copy the second part of user declarations. */ +]b4_user_post_prologue +b4_percent_code_get[]dnl + +[#ifdef short +# undef short +#endif + +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#else +typedef signed char yytype_int8; +#endif + +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; +#else +typedef unsigned short int yytype_uint16; +#endif + +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif ! defined YYSIZE_T +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned int +# endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif + +]b4_attribute_define[ + +#if ]b4_lac_if([[1]], [[! defined yyoverflow || YYERROR_VERBOSE]])[ + +/* The parser invokes alloca or malloc; define the necessary symbols. */]dnl +b4_push_if([], [b4_lac_if([], [[ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS +# include /* INFRINGES ON USER NAME SPACE */ + /* Use EXIT_SUCCESS as a witness for stdlib.h. */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# endif +# endif +# endif]])])[ + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's 'empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined EXIT_SUCCESS +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif]b4_lac_if([[ +# define YYCOPY_NEEDED 1]])[ +#endif]b4_lac_if([], [[ /* ! defined yyoverflow || YYERROR_VERBOSE */]])[ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (]b4_locations_if([[defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL \ + && ]])[defined ]b4_api_PREFIX[STYPE_IS_TRIVIAL && ]b4_api_PREFIX[STYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss_alloc; + YYSTYPE yyvs_alloc;]b4_locations_if([ + YYLTYPE yyls_alloc;])[ +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +]b4_locations_if( +[# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + + 2 * YYSTACK_GAP_MAXIMUM)], +[# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM)])[ + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from SRC to DST. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(Dst, Src, Count) \ + __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) +# else +# define YYCOPY(Dst, Src, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (Dst)[yyi] = (Src)[yyi]; \ + } \ + while (0) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL ]b4_final_state_number[ +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST ]b4_last[ + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS ]b4_tokens_number[ +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS ]b4_nterms_number[ +/* YYNRULES -- Number of rules. */ +#define YYNRULES ]b4_rules_number[ +/* YYNSTATES -- Number of states. */ +#define YYNSTATES ]b4_states_number[ + +/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned + by yylex, with out-of-bounds checking. */ +#define YYUNDEFTOK ]b4_undef_token_number[ +#define YYMAXUTOK ]b4_user_token_number_max[ + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, without out-of-bounds checking. */ +static const ]b4_int_type_for([b4_translate])[ yytranslate[] = +{ + ]b4_translate[ +}; + +#if ]b4_api_PREFIX[DEBUG +]b4_integral_parser_table_define([rline], [b4_rline], + [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[ +#endif + +#if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[ +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + ]b4_tname[ +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[NUM] -- (External) token number corresponding to the + (internal) symbol number NUM (which must be that of a token). */ +static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = +{ + ]b4_toknum[ +}; +# endif + +#define YYPACT_NINF ]b4_pact_ninf[ + +#define yypact_value_is_default(Yystate) \ + ]b4_table_value_equals([[pact]], [[Yystate]], [b4_pact_ninf])[ + +#define YYTABLE_NINF ]b4_table_ninf[ + +#define yytable_value_is_error(Yytable_value) \ + ]b4_table_value_equals([[table]], [[Yytable_value]], [b4_table_ninf])[ + +]b4_parser_tables_define[ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \]b4_lac_if([[ + YY_LAC_DISCARD ("YYBACKUP"); \]])[ + goto yybackup; \ + } \ + else \ + { \ + yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (0) + +/* Error token number */ +#define YYTERROR 1 +#define YYERRCODE 256 + +]b4_locations_if([[ +]b4_yylloc_default_define[ +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +]])[ + +/* Enable debugging if requested. */ +#if ]b4_api_PREFIX[DEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + +]b4_yy_location_print_define[ + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value]b4_locations_if([, Location])[]b4_user_args[); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + +]b4_yy_symbol_print_define[ + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +]b4_function_define([yy_stack_print], [static void], + [[yytype_int16 *yybottom], [yybottom]], + [[yytype_int16 *yytop], [yytop]])[ +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +]b4_function_define([yy_reduce_print], [static void], + [[yytype_int16 *yyssp], [yyssp]], + [[YYSTYPE *yyvsp], [yyvsp]], + b4_locations_if([[[YYLTYPE *yylsp], [yylsp]], + ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [, + b4_parse_param]))[ +{ + unsigned long int yylno = yyrline[yyrule]; + int yynrhs = yyr2[yyrule]; + int yyi; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, + yystos[yyssp[yyi + 1 - yynrhs]], + &]b4_rhs_value(yynrhs, yyi + 1)[ + ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl + b4_user_args[); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !]b4_api_PREFIX[DEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !]b4_api_PREFIX[DEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH ]b4_stack_depth_init[ +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH ]b4_stack_depth_max[ +#endif]b4_lac_if([[ + +/* Given a state stack such that *YYBOTTOM is its bottom, such that + *YYTOP is either its top or is YYTOP_EMPTY to indicate an empty + stack, and such that *YYCAPACITY is the maximum number of elements it + can hold without a reallocation, make sure there is enough room to + store YYADD more elements. If not, allocate a new stack using + YYSTACK_ALLOC, copy the existing elements, and adjust *YYBOTTOM, + *YYTOP, and *YYCAPACITY to reflect the new capacity and memory + location. If *YYBOTTOM != YYBOTTOM_NO_FREE, then free the old stack + using YYSTACK_FREE. Return 0 if successful or if no reallocation is + required. Return 1 if memory is exhausted. */ +static int +yy_lac_stack_realloc (YYSIZE_T *yycapacity, YYSIZE_T yyadd, +#if ]b4_api_PREFIX[DEBUG + char const *yydebug_prefix, + char const *yydebug_suffix, +#endif + yytype_int16 **yybottom, + yytype_int16 *yybottom_no_free, + yytype_int16 **yytop, yytype_int16 *yytop_empty) +{ + YYSIZE_T yysize_old = + *yytop == yytop_empty ? 0 : *yytop - *yybottom + 1; + YYSIZE_T yysize_new = yysize_old + yyadd; + if (*yycapacity < yysize_new) + { + YYSIZE_T yyalloc = 2 * yysize_new; + yytype_int16 *yybottom_new; + /* Use YYMAXDEPTH for maximum stack size given that the stack + should never need to grow larger than the main state stack + needs to grow without LAC. */ + if (YYMAXDEPTH < yysize_new) + { + YYDPRINTF ((stderr, "%smax size exceeded%s", yydebug_prefix, + yydebug_suffix)); + return 1; + } + if (YYMAXDEPTH < yyalloc) + yyalloc = YYMAXDEPTH; + yybottom_new = + (yytype_int16*) YYSTACK_ALLOC (yyalloc * sizeof *yybottom_new); + if (!yybottom_new) + { + YYDPRINTF ((stderr, "%srealloc failed%s", yydebug_prefix, + yydebug_suffix)); + return 1; + } + if (*yytop != yytop_empty) + { + YYCOPY (yybottom_new, *yybottom, yysize_old); + *yytop = yybottom_new + (yysize_old - 1); + } + if (*yybottom != yybottom_no_free) + YYSTACK_FREE (*yybottom); + *yybottom = yybottom_new; + *yycapacity = yyalloc;]m4_if(b4_percent_define_get([[parse.lac.memory-trace]]), + [full], [[ + YYDPRINTF ((stderr, "%srealloc to %lu%s", yydebug_prefix, + (unsigned long int) yyalloc, yydebug_suffix));]])[ + } + return 0; +} + +/* Establish the initial context for the current lookahead if no initial + context is currently established. + + We define a context as a snapshot of the parser stacks. We define + the initial context for a lookahead as the context in which the + parser initially examines that lookahead in order to select a + syntactic action. Thus, if the lookahead eventually proves + syntactically unacceptable (possibly in a later context reached via a + series of reductions), the initial context can be used to determine + the exact set of tokens that would be syntactically acceptable in the + lookahead's place. Moreover, it is the context after which any + further semantic actions would be erroneous because they would be + determined by a syntactically unacceptable token. + + YY_LAC_ESTABLISH should be invoked when a reduction is about to be + performed in an inconsistent state (which, for the purposes of LAC, + includes consistent states that don't know they're consistent because + their default reductions have been disabled). Iff there is a + lookahead token, it should also be invoked before reporting a syntax + error. This latter case is for the sake of the debugging output. + + For parse.lac=full, the implementation of YY_LAC_ESTABLISH is as + follows. If no initial context is currently established for the + current lookahead, then check if that lookahead can eventually be + shifted if syntactic actions continue from the current context. + Report a syntax error if it cannot. */ +#define YY_LAC_ESTABLISH \ +do { \ + if (!yy_lac_established) \ + { \ + YYDPRINTF ((stderr, \ + "LAC: initial context established for %s\n", \ + yytname[yytoken])); \ + yy_lac_established = 1; \ + { \ + int yy_lac_status = \ + yy_lac (yyesa, &yyes, &yyes_capacity, yyssp, yytoken); \ + if (yy_lac_status == 2) \ + goto yyexhaustedlab; \ + if (yy_lac_status == 1) \ + goto yyerrlab; \ + } \ + } \ +} while (0) + +/* Discard any previous initial lookahead context because of Event, + which may be a lookahead change or an invalidation of the currently + established initial context for the current lookahead. + + The most common example of a lookahead change is a shift. An example + of both cases is syntax error recovery. That is, a syntax error + occurs when the lookahead is syntactically erroneous for the + currently established initial context, so error recovery manipulates + the parser stacks to try to find a new initial context in which the + current lookahead is syntactically acceptable. If it fails to find + such a context, it discards the lookahead. */ +#if ]b4_api_PREFIX[DEBUG +# define YY_LAC_DISCARD(Event) \ +do { \ + if (yy_lac_established) \ + { \ + if (yydebug) \ + YYFPRINTF (stderr, "LAC: initial context discarded due to " \ + Event "\n"); \ + yy_lac_established = 0; \ + } \ +} while (0) +#else +# define YY_LAC_DISCARD(Event) yy_lac_established = 0 +#endif + +/* Given the stack whose top is *YYSSP, return 0 iff YYTOKEN can + eventually (after perhaps some reductions) be shifted, return 1 if + not, or return 2 if memory is exhausted. As preconditions and + postconditions: *YYES_CAPACITY is the allocated size of the array to + which *YYES points, and either *YYES = YYESA or *YYES points to an + array allocated with YYSTACK_ALLOC. yy_lac may overwrite the + contents of either array, alter *YYES and *YYES_CAPACITY, and free + any old *YYES other than YYESA. */ +static int +yy_lac (yytype_int16 *yyesa, yytype_int16 **yyes, + YYSIZE_T *yyes_capacity, yytype_int16 *yyssp, int yytoken) +{ + yytype_int16 *yyes_prev = yyssp; + yytype_int16 *yyesp = yyes_prev; + YYDPRINTF ((stderr, "LAC: checking lookahead %s:", yytname[yytoken])); + if (yytoken == YYUNDEFTOK) + { + YYDPRINTF ((stderr, " Always Err\n")); + return 1; + } + while (1) + { + int yyrule = yypact[*yyesp]; + if (yypact_value_is_default (yyrule) + || (yyrule += yytoken) < 0 || YYLAST < yyrule + || yycheck[yyrule] != yytoken) + { + yyrule = yydefact[*yyesp]; + if (yyrule == 0) + { + YYDPRINTF ((stderr, " Err\n")); + return 1; + } + } + else + { + yyrule = yytable[yyrule]; + if (yytable_value_is_error (yyrule)) + { + YYDPRINTF ((stderr, " Err\n")); + return 1; + } + if (0 < yyrule) + { + YYDPRINTF ((stderr, " S%d\n", yyrule)); + return 0; + } + yyrule = -yyrule; + } + { + YYSIZE_T yylen = yyr2[yyrule]; + YYDPRINTF ((stderr, " R%d", yyrule - 1)); + if (yyesp != yyes_prev) + { + YYSIZE_T yysize = yyesp - *yyes + 1; + if (yylen < yysize) + { + yyesp -= yylen; + yylen = 0; + } + else + { + yylen -= yysize; + yyesp = yyes_prev; + } + } + if (yylen) + yyesp = yyes_prev -= yylen; + } + { + int yystate; + { + int yylhs = yyr1[yyrule] - YYNTOKENS; + yystate = yypgoto[yylhs] + *yyesp; + if (yystate < 0 || YYLAST < yystate + || yycheck[yystate] != *yyesp) + yystate = yydefgoto[yylhs]; + else + yystate = yytable[yystate]; + } + if (yyesp == yyes_prev) + { + yyesp = *yyes; + *yyesp = yystate; + } + else + { + if (yy_lac_stack_realloc (yyes_capacity, 1, +#if ]b4_api_PREFIX[DEBUG + " (", ")", +#endif + yyes, yyesa, &yyesp, yyes_prev)) + { + YYDPRINTF ((stderr, "\n")); + return 2; + } + *++yyesp = yystate; + } + YYDPRINTF ((stderr, " G%d", yystate)); + } + } +}]])[ + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +]b4_function_define([yystrlen], [static YYSIZE_T], + [[const char *yystr], [yystr]])[ +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +]b4_function_define([yystpcpy], [static char *], + [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[ +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP.]b4_lac_if([[ In order to see if a particular token T is a + valid looakhead, invoke yy_lac (YYESA, YYES, YYES_CAPACITY, YYSSP, T).]])[ + + Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return 2 if the + required number of bytes is too large to store]b4_lac_if([[ or if + yy_lac returned 2]])[. */ +static int +yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, + ]b4_lac_if([[yytype_int16 *yyesa, yytype_int16 **yyes, + YYSIZE_T *yyes_capacity, ]])[yytype_int16 *yyssp, int yytoken) +{ + YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]); + YYSIZE_T yysize = yysize0; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULL; + /* Arguments of yyformat. */ + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; + + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar.]b4_lac_if([[ + In the first two cases, it might appear that the current syntax + error should have been detected in the previous state when yy_lac + was invoked. However, at that time, there might have been a + different syntax error that discarded a different initial context + during error recovery, leaving behind the current lookahead.]], [[ + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state.]])[ + */ + if (yytoken != YYEMPTY) + { + int yyn = yypact[*yyssp];]b4_lac_if([[ + YYDPRINTF ((stderr, "Constructing syntax error message\n"));]])[ + yyarg[yycount++] = yytname[yytoken]; + if (!yypact_value_is_default (yyn)) + {]b4_lac_if([], [[ + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;]])[ + int yyx;]b4_lac_if([[ + + for (yyx = 0; yyx < YYNTOKENS; ++yyx) + if (yyx != YYTERROR && yyx != YYUNDEFTOK) + { + { + int yy_lac_status = yy_lac (yyesa, yyes, yyes_capacity, + yyssp, yyx); + if (yy_lac_status == 2) + return 2; + if (yy_lac_status == 1) + continue; + }]], [[ + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR + && !yytable_value_is_error (yytable[yyx + yyn])) + {]])[ + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + break; + } + yyarg[yycount++] = yytname[yyx]; + { + YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]); + if (! (yysize <= yysize1 + && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + } + }]b4_lac_if([[ +# if ]b4_api_PREFIX[DEBUG + else if (yydebug) + YYFPRINTF (stderr, "No expected tokens.\n"); +# endif]])[ + } + + switch (yycount) + { +# define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +# undef YYCASE_ + } + + { + YYSIZE_T yysize1 = yysize + yystrlen (yyformat); + if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return 1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } + } + return 0; +} +#endif /* YYERROR_VERBOSE */ + +]b4_yydestruct_define[ + +]b4_pure_if([], [ + +b4_declare_scanner_communication_variables])[]b4_push_if([[ + +struct yypstate + {]b4_declare_parser_state_variables[ + /* Used to determine if this is the first time this instance has + been used. */ + int yynew; + };]b4_pure_if([], [[ + +static char yypstate_allocated = 0;]])b4_pull_if([ + +b4_function_define([[yyparse]], [[int]], b4_parse_param)[ +{ + return yypull_parse (YY_NULL]m4_ifset([b4_parse_param], + [[, ]b4_args(b4_parse_param)])[); +} + +]b4_function_define([[yypull_parse]], [[int]], + [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, + b4_parse_param]))[ +{ + int yystatus; + yypstate *yyps_local;]b4_pure_if([[ + int yychar; + YYSTYPE yylval;]b4_locations_if([[ + static YYLTYPE yyloc_default][]b4_yyloc_default[; + YYLTYPE yylloc = yyloc_default;]])])[ + if (yyps) + yyps_local = yyps; + else + { + yyps_local = yypstate_new (); + if (!yyps_local) + {]b4_pure_if([[ + yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[ + if (!yypstate_allocated) + yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[ + return 2; + } + } + do { + yychar = ]b4_lex[; + yystatus = + yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_args(b4_parse_param)])[); + } while (yystatus == YYPUSH_MORE); + if (!yyps) + yypstate_delete (yyps_local); + return yystatus; +}]])[ + +/* Initialize the parser data structure. */ +]b4_function_define([[yypstate_new]], [[yypstate *]])[ +{ + yypstate *yyps;]b4_pure_if([], [[ + if (yypstate_allocated) + return YY_NULL;]])[ + yyps = (yypstate *) malloc (sizeof *yyps); + if (!yyps) + return YY_NULL; + yyps->yynew = 1;]b4_pure_if([], [[ + yypstate_allocated = 1;]])[ + return yyps; +} + +]b4_function_define([[yypstate_delete]], [[void]], + [[[yypstate *yyps]], [[yyps]]])[ +{ +#ifndef yyoverflow + /* If the stack was reallocated but the parse did not complete, then the + stack still needs to be freed. */ + if (!yyps->yynew && yyps->yyss != yyps->yyssa) + YYSTACK_FREE (yyps->yyss); +#endif]b4_lac_if([[ + if (!yyps->yynew && yyps->yyes != yyps->yyesa) + YYSTACK_FREE (yyps->yyes);]])[ + free (yyps);]b4_pure_if([], [[ + yypstate_allocated = 0;]])[ +} +]b4_pure_if([[ +#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs]])[ +#define yystate yyps->yystate +#define yyerrstatus yyps->yyerrstatus +#define yyssa yyps->yyssa +#define yyss yyps->yyss +#define yyssp yyps->yyssp +#define yyvsa yyps->yyvsa +#define yyvs yyps->yyvs +#define yyvsp yyps->yyvsp]b4_locations_if([[ +#define yylsa yyps->yylsa +#define yyls yyps->yyls +#define yylsp yyps->yylsp +#define yyerror_range yyps->yyerror_range]])[ +#define yystacksize yyps->yystacksize]b4_lac_if([[ +#define yyesa yyps->yyesa +#define yyes yyps->yyes +#define yyes_capacity yyps->yyes_capacity]])[ + + +/*---------------. +| yypush_parse. | +`---------------*/ + +]b4_function_define([[yypush_parse]], [[int]], + [[[yypstate *yyps]], [[yyps]]]b4_pure_if([, + [[[int yypushed_char]], [[yypushed_char]]], + [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([, + [[[YYLTYPE *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [, + b4_parse_param]))], [[ + + +/*----------. +| yyparse. | +`----------*/ + +]b4_function_define([yyparse], [int], b4_parse_param)])[ +{]b4_pure_if([b4_declare_scanner_communication_variables +])b4_push_if([b4_pure_if([], [[ + int yypushed_char = yychar; + YYSTYPE yypushed_val = yylval;]b4_locations_if([[ + YYLTYPE yypushed_loc = yylloc;]]) +])], + [b4_declare_parser_state_variables +])b4_lac_if([[ + int yy_lac_established = 0;]])[ + int yyn; + int yyresult; + /* Lookahead token as an internal (translated) token number. */ + int yytoken = 0; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ + +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0;]b4_push_if([[ + + if (!yyps->yynew) + { + yyn = yypact[yystate]; + goto yyread_pushed_token; + }]])[ + + yyssp = yyss = yyssa; + yyvsp = yyvs = yyvsa;]b4_locations_if([[ + yylsp = yyls = yylsa;]])[ + yystacksize = YYINITDEPTH;]b4_lac_if([[ + + yyes = yyesa; + yyes_capacity = sizeof yyesa / sizeof *yyes; + if (YYMAXDEPTH < yyes_capacity) + yyes_capacity = YYMAXDEPTH;]])[ + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([m4_define([b4_dollar_dollar_used])yylval], [], + [b4_push_if([b4_pure_if([*])yypushed_loc], [yylloc])])dnl +/* User initialization code. */ +b4_user_initial_action +b4_dollar_popdef[]dnl +m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval; +]])])dnl +b4_locations_if([[ yylsp[0] = ]b4_push_if([b4_pure_if([*])yypushed_loc], [yylloc])[; +]])dnl +[ goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss;]b4_locations_if([ + YYLTYPE *yyls1 = yyls;])[ + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([ + &yyls1, yysize * sizeof (*yylsp),])[ + &yystacksize); +]b4_locations_if([ + yyls = yyls1;])[ + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([ + YYSTACK_RELOCATE (yyls_alloc, yyls);])[ +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1;]b4_locations_if([ + yylsp = yyls + yysize - 1;])[ + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ + if (yychar == YYEMPTY) + {]b4_push_if([[ + if (!yyps->yynew) + {]b4_use_push_for_pull_if([], [[ + YYDPRINTF ((stderr, "Return for a new token:\n"));]])[ + yyresult = YYPUSH_MORE; + goto yypushreturn; + } + yyps->yynew = 0;]b4_pure_if([], [[ + /* Restoring the pushed token is only necessary for the first + yypush_parse invocation since subsequent invocations don't overwrite + it before jumping to yyread_pushed_token. */ + yychar = yypushed_char; + yylval = yypushed_val;]b4_locations_if([[ + yylloc = yypushed_loc;]])])[ +yyread_pushed_token:]])[ + YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[ + yychar = yypushed_char; + if (yypushed_val) + yylval = *yypushed_val;]b4_locations_if([[ + if (yypushed_loc) + yylloc = *yypushed_loc;]])])], [[ + yychar = ]b4_lex[;]])[ + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)]b4_lac_if([[ + { + YY_LAC_ESTABLISH; + goto yydefault; + }]], [[ + goto yydefault;]])[ + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab;]b4_lac_if([[ + YY_LAC_ESTABLISH;]])[ + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token. */ + yychar = YYEMPTY;]b4_lac_if([[ + YY_LAC_DISCARD ("shift");]])[ + + yystate = yyn; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END +]b4_locations_if([ *++yylsp = yylloc;])[ + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + '$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + +]b4_locations_if( +[[ /* Default location. */ + YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[ + YY_REDUCE_PRINT (yyn);]b4_lac_if([[ + { + int yychar_backup = yychar; + switch (yyn) + { + ]b4_user_actions[ + default: break; + } + if (yychar_backup != yychar) + YY_LAC_DISCARD ("yychar change"); + }]], [[ + switch (yyn) + { + ]b4_user_actions[ + default: break; + }]])[ + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval;]b4_locations_if([ + *++yylsp = yyloc;])[ + + /* Now 'shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*--------------------------------------. +| yyerrlab -- here on detecting error. | +`--------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); + + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + yyerror (]b4_yyerror_args[YY_("syntax error")); +#else +# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \]b4_lac_if([[ + yyesa, &yyes, &yyes_capacity, \]])[ + yyssp, yytoken) + { + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status;]b4_lac_if([[ + if (yychar != YYEMPTY) + YY_LAC_ESTABLISH;]])[ + yysyntax_error_status = YYSYNTAX_ERROR; + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == 1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); + if (!yymsg) + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = 2; + } + else + { + yysyntax_error_status = YYSYNTAX_ERROR; + yymsgp = yymsg; + } + } + yyerror (]b4_yyerror_args[yymsgp); + if (yysyntax_error_status == 2) + goto yyexhaustedlab; + } +# undef YYSYNTAX_ERROR +#endif + } + +]b4_locations_if([[ yyerror_range[1] = yylloc;]])[ + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + +]b4_locations_if([[ yyerror_range[1] = yylsp[1-yylen]; +]])[ /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + +]b4_locations_if([[ yyerror_range[1] = *yylsp;]])[ + yydestruct ("Error: popping", + yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + }]b4_lac_if([[ + + /* If the stack popping above didn't lose the initial context for the + current lookahead token, the shift below will for sure. */ + YY_LAC_DISCARD ("error recovery");]])[ + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END +]b4_locations_if([[ + yyerror_range[2] = yylloc; + /* Using YYLLOC is tempting, but would change the location of + the lookahead. YYLOC is available though. */ + YYLLOC_DEFAULT (yyloc, yyerror_range, 2); + *++yylsp = yyloc;]])[ + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#if ]b4_lac_if([[1]], [[!defined yyoverflow || YYERROR_VERBOSE]])[ +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror (]b4_yyerror_args[YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEMPTY) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); + } + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif]b4_lac_if([[ + if (yyes != yyesa) + YYSTACK_FREE (yyes);]])b4_push_if([[ + yyps->yynew = 1; + +yypushreturn:]])[ +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + return yyresult; +} +]b4_epilogue[]dnl +b4_output_end() + +b4_defines_if( +[b4_output_begin([b4_spec_defines_file])[ +]b4_copyright([Bison interface for Yacc-like parsers in C])[ + +]b4_shared_declarations[ +]b4_output_end() +])# b4_defines_if diff --git a/gnuwin32/bin/win_bison.exe b/gnuwin32/bin/win_bison.exe new file mode 100644 index 0000000000000000000000000000000000000000..035eb2a42e032699497afb79a599b17897c85e6a GIT binary patch literal 539648 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

d->PV~0L$ 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 z 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

8c1Hu&=e>3xpEjsNcEu72Cn4f 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 Rl~m5|Xo6qz`P{g#|37s3VGaNQ delta 233522 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

(XiA`75 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