From 3d7fe3b822615cf1d11eeff1b97d8a5927a6d5b3 Mon Sep 17 00:00:00 2001 From: Andrew Knight Date: Sun, 2 Aug 2015 10:03:20 +0300 Subject: gnuwin32: Remove old versions of bison/flex from the distribution The win_flex/win_bison tools are already in the repository and working with all projects, so the GnuWin32 versions can be removed and the winflexbison versions can take their place. Task-number: QTBUG-46852 Change-Id: I41bc541adab834ff83912d7a4f076a87fc174601 Reviewed-by: Lars Knoll Reviewed-by: Kai Koehne --- gnuwin32/share/bison/README | 70 - gnuwin32/share/bison/bison.m4 | 556 ------ gnuwin32/share/bison/c++-skel.m4 | 25 - gnuwin32/share/bison/c++.m4 | 170 -- gnuwin32/share/bison/c-skel.m4 | 25 - gnuwin32/share/bison/c.m4 | 477 ------ gnuwin32/share/bison/glr.c | 2653 ----------------------------- gnuwin32/share/bison/glr.cc | 377 ----- gnuwin32/share/bison/java-skel.m4 | 25 - gnuwin32/share/bison/java.m4 | 303 ---- gnuwin32/share/bison/lalr1.cc | 1157 ------------- gnuwin32/share/bison/lalr1.java | 880 ---------- gnuwin32/share/bison/location.cc | 275 --- gnuwin32/share/bison/m4sugar/foreach.m4 | 400 ----- gnuwin32/share/bison/m4sugar/m4sugar.m4 | 2789 ------------------------------- gnuwin32/share/bison/xslt/bison.xsl | 93 -- gnuwin32/share/bison/xslt/xml2dot.xsl | 206 --- gnuwin32/share/bison/xslt/xml2text.xsl | 581 ------- gnuwin32/share/bison/xslt/xml2xhtml.xsl | 745 --------- gnuwin32/share/bison/yacc.c | 1741 ------------------- 20 files changed, 13548 deletions(-) delete mode 100644 gnuwin32/share/bison/README delete mode 100644 gnuwin32/share/bison/bison.m4 delete mode 100644 gnuwin32/share/bison/c++-skel.m4 delete mode 100644 gnuwin32/share/bison/c++.m4 delete mode 100644 gnuwin32/share/bison/c-skel.m4 delete mode 100644 gnuwin32/share/bison/c.m4 delete mode 100644 gnuwin32/share/bison/glr.c delete mode 100644 gnuwin32/share/bison/glr.cc delete mode 100644 gnuwin32/share/bison/java-skel.m4 delete mode 100644 gnuwin32/share/bison/java.m4 delete mode 100644 gnuwin32/share/bison/lalr1.cc delete mode 100644 gnuwin32/share/bison/lalr1.java delete mode 100644 gnuwin32/share/bison/location.cc delete mode 100644 gnuwin32/share/bison/m4sugar/foreach.m4 delete mode 100644 gnuwin32/share/bison/m4sugar/m4sugar.m4 delete mode 100644 gnuwin32/share/bison/xslt/bison.xsl delete mode 100644 gnuwin32/share/bison/xslt/xml2dot.xsl delete mode 100644 gnuwin32/share/bison/xslt/xml2text.xsl delete mode 100644 gnuwin32/share/bison/xslt/xml2xhtml.xsl delete mode 100644 gnuwin32/share/bison/yacc.c (limited to 'gnuwin32/share') diff --git a/gnuwin32/share/bison/README b/gnuwin32/share/bison/README deleted file mode 100644 index 18e025c1..00000000 --- a/gnuwin32/share/bison/README +++ /dev/null @@ -1,70 +0,0 @@ --*- 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 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/share/bison/bison.m4 b/gnuwin32/share/bison/bison.m4 deleted file mode 100644 index bad62963..00000000 --- a/gnuwin32/share/bison/bison.m4 +++ /dev/null @@ -1,556 +0,0 @@ - -*- Autoconf -*- - -# Language-independent M4 Macros for Bison. -# Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008 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) -# -------------------------- -m4_define([b4_copyright], -[b4_comment([A Bison parser, made by GNU Bison b4_version.]) - -b4_comment([$1 - -m4_text_wrap([Copyright (C) $2 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.])]) - - -## ---------------- ## -## 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, FORMAT, [ARG1], [ARG2], ...) -# ------------------------------------------- -# Write @KIND(FORMAT@,ARG1@,ARG2@,...@) to stdout. -# -# For example: -# -# b4_error([[warn]], [[invalid value for `%s': %s]], [[foo]], [[3]]) -m4_define([b4_error], -[b4_cat([[@]$1[(]$2[]]dnl -[m4_if([$#], [2], [], - [m4_foreach([b4_arg], - m4_dquote(m4_shift(m4_shift($@))), - [[@,]b4_arg])])[@)]])]) - -# b4_error_at(KIND, START, END, FORMAT, [ARG1], [ARG2], ...) -# ---------------------------------------------------------- -# Write @KIND_at(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. -# -# For example: -# -# b4_error_at([[complain]], [[input.y:2.3]], [[input.y:5.4]], -# [[invalid %s]], [[foo]]) -m4_define([b4_error_at], -[b4_cat([[@]$1[_at(]$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([[[asdf), asdf]]], [[[fsa), fsa]]], [[[fdsa), fdsa]]]) -# b4_warn([[asdf), asdf]], [[fsa), fsa]], [[fdsa), fdsa]]) -# b4_warn() -# b4_warn(1) -# b4_warn(1, 2) -# -# Should produce this without newlines: -# -# @warn([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_at([[warn]], $@)]) - -# b4_complain(FORMAT, [ARG1], [ARG2], ...) -# ---------------------------------------- -# Write @complain(FORMAT@,ARG1@,ARG2@,...@) to stdout. -# -# 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_at([[complain]], $@)]) - -# b4_fatal(FORMAT, [ARG1], [ARG2], ...) -# ------------------------------------- -# Write @fatal(FORMAT@,ARG1@,ARG2@,...@) to stdout and exit. -# -# 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_at([[fatal]], $@)dnl -m4_exit(1)]) - - -## ---------------- ## -## 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]) - - -## ------------ ## -## 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])]) - - - -## ------------------ ## -## 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: ]$1)])]) - - -# 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) -# -------------------------------- -# This macro works around the impossibility to define macros -# inside macros, because issuing `[$1]' is not possible in M4 :(. -# This sucks hard, GNU M4 should really provide M5 like $$1. -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([error_verbose]) # Whether error are verbose. -b4_define_flag_if([glr]) # Whether a GLR parser is requested. -b4_define_flag_if([locations]) # Whether locations are tracked. -b4_define_flag_if([nondeterministic]) # Whether conflicts should be handled. -b4_define_flag_if([yacc]) # Whether POSIX Yacc is emulated. - - -## ------------------------- ## -## Assigning token numbers. ## -## ------------------------- ## - - -## ----------- ## -## 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_end([__line__], [b4_basename(m4_quote(__file__))]) -b4_sync_start([$1], [$2])])]) - -m4_define([b4_sync_end], [b4_comment([Line $1 of $2])]) -m4_define([b4_sync_start], [b4_comment([Line $1 of $2])]) - -# 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_stype -# ---------------------- -# 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([stype]) - - -# b4_check_user_names(WHAT, USER-LIST, BISON-NAMESPACE) -# -------------------------------------------------------- -# Warn 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 grammar 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_warn_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_get(VARIABLE) -# ------------------------------- -# Mimic muscle_percent_define_get in ../src/muscle_tab.h exactly. That is, if -# the %define variable VARIABLE is defined, emit its value. 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], -[m4_define([b4_percent_define_bison_variables(]$1[)])dnl -m4_ifdef([b4_percent_define(]$1[)], [m4_indir([b4_percent_define(]$1[)])])]) - -# 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([[undefined %%define variable `%s' passed to b4_percent_define_get_loc]], [$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([[undefined %%define variable `%s' passed to b4_percent_define_get_syncline]], [$1])])]) - -# 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], -[m4_ifdef([b4_percent_define(]$1[)], - [m4_define([b4_percent_define_bison_variables(]$1[)])$2], - [$3])]) - -# 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([[undefined %%define variable `%s' passed to b4_percent_define_flag_if]], [$1])])]) - -# b4_percent_define_default(VARIABLE, DEFAULT) -# -------------------------------------------- -# 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], -[m4_ifndef([b4_percent_define(]$1[)], - [m4_define([b4_percent_define(]$1[)], [$2])dnl - m4_define([b4_percent_define_loc(]$1[)], - [[[[[Bison:b4_percent_define_default]:1.0]], [[[Bison:b4_percent_define_default]:1.0]]]])dnl - m4_define([b4_percent_define_syncline(]$1[)], - [[]b4_syncline(1, [["[Bison:b4_percent_define_default]"]])[ -]])])]) - -# 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], -[m4_ifdef([b4_percent_define(]$1[)], - [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[)])))])dnl - m4_popdef([b4_good_value])], - [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_check_values]], [$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])]) - - -## ----------------------------------------------------------- ## -## 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]]) -]) diff --git a/gnuwin32/share/bison/c++-skel.m4 b/gnuwin32/share/bison/c++-skel.m4 deleted file mode 100644 index b8089ff8..00000000 --- a/gnuwin32/share/bison/c++-skel.m4 +++ /dev/null @@ -1,25 +0,0 @@ - -*- Autoconf -*- - -# C++ skeleton dispatching for Bison. -# Copyright (C) 2006, 2007 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/share/bison/c++.m4 b/gnuwin32/share/bison/c++.m4 deleted file mode 100644 index 593390d6..00000000 --- a/gnuwin32/share/bison/c++.m4 +++ /dev/null @@ -1,170 +0,0 @@ - -*- Autoconf -*- - -# C++ skeleton for Bison - -# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 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]) - -## ---------------- ## -## Default values. ## -## ---------------- ## - -# Default parser class name. -b4_percent_define_default([[parser_class_name]], [[parser]]) -b4_percent_define_default([[location_type]], [[location]]) -b4_percent_define_default([[filename_type]], [[std::string]]) -b4_percent_define_default([[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([[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([[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([[namespace]]), - [[namespace reference has consecutive "::"]])]) -m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*$]), [-1], [], -[b4_complain_at(b4_percent_define_get_loc([[namespace]]), - [[namespace reference has a trailing "::"]])]) - -m4_define([b4_namespace_open], -[b4_user_code([b4_percent_define_get_syncline([[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([[namespace]]) -m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref), - [^\(.\)[ ]*\(::\)?\([^][:]\|:[^][:]\)*], - [\1])), - [::\([^][:]\|:[^][:]\)*], [} ])[} // ]b4_namespace_ref])]) - - -# b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) -# ----------------------------------------------------- -# Output the definition of the tokens as enums. -m4_define([b4_token_enums], -[/* Tokens. */ - enum yytokentype { -m4_map_sep([ b4_token_enum], [, -], - [$@]) - }; -]) - - -## ----------------- ## -## Semantic Values. ## -## ----------------- ## - - -# b4_lhs_value([TYPE]) -# -------------------- -# Expansion of $$. -m4_define([b4_lhs_value], -[(yyval[]m4_ifval([$1], [.$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], -[(yysemantic_stack_@{($1) - ($2)@}m4_ifval([$3], [.$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;]) diff --git a/gnuwin32/share/bison/c-skel.m4 b/gnuwin32/share/bison/c-skel.m4 deleted file mode 100644 index 91f3c205..00000000 --- a/gnuwin32/share/bison/c-skel.m4 +++ /dev/null @@ -1,25 +0,0 @@ - -*- Autoconf -*- - -# C skeleton dispatching for Bison. -# Copyright (C) 2006, 2007 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/share/bison/c.m4 b/gnuwin32/share/bison/c.m4 deleted file mode 100644 index 1fe4bc56..00000000 --- a/gnuwin32/share/bison/c.m4 +++ /dev/null @@ -1,477 +0,0 @@ - -*- Autoconf -*- - -# C M4 Macros for Bison. -# Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008 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_comment(TEXT) -# ---------------- -m4_define([b4_comment], [/* m4_bpatsubst([$1], [ -], [ - ]) */]) - -# 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])[ - -/* Using locations. */ -#define YYLSP_NEEDED ]b4_locations_flag[ -]]) - - -## ---------------- ## -## Default values. ## -## ---------------- ## - -# If the %union is not named, its name is YYSTYPE. -m4_define_default([b4_union_name], [YYSTYPE]) - -# If the %name-prefix is not given, it is yy. -m4_define_default([b4_prefix], [yy]) - -## ------------------------ ## -## Pure/impure interfaces. ## -## ------------------------ ## - -# b4_user_args -# ------------ -m4_define([b4_user_args], -[m4_ifset([b4_parse_param], [, b4_c_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 -# ------------------ -# `YYUSE' all the parse-params. -m4_define([b4_parse_param_use], -[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)]) - - - -## ---------## -## Values. ## -## ---------## - -# b4_null ---------- -# Return a null pointer constant. NULL infringes on the user name -# space in C, so use 0 rather than NULL. -m4_define([b4_null], [0]) - - - - -## ------------------------- ## -## Assigning token numbers. ## -## ------------------------- ## - -# b4_token_define(TOKEN-NAME, TOKEN-NUMBER) -# ----------------------------------------- -# Output the definition of this token as #define. -m4_define([b4_token_define], -[#define $1 $2 -]) - - -# b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) -# ------------------------------------------------------- -# Output the definition of the tokens (if there are) as #defines. -m4_define([b4_token_defines], -[m4_if([$#$1], [1], [], -[/* Tokens. */ -m4_map([b4_token_define], [$@])]) -]) - - -# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER) -# --------------------------------------- -# Output the definition of this token as an enum. -m4_define([b4_token_enum], -[$1 = $2]) - - -# b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) -# ----------------------------------------------------- -# Output the definition of the tokens (if there are) as enums. -m4_define([b4_token_enums], -[m4_if([$#$1], [1], [], -[/* Tokens. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum yytokentype { -m4_map_sep([ b4_token_enum], [, -], - [$@]) - }; -#endif -])]) - - -# b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) -# ------------------------------------------------------------- -# 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($@)], []) -]) - - - -## --------------------------------------------- ## -## Defining C functions in both K&R and ANSI-C. ## -## --------------------------------------------- ## - - -# b4_modern_c -# ----------- -# A predicate useful in #if to determine whether C is ancient or modern. -# -# If __STDC__ is defined, the compiler is modern. IBM xlc 7.0 when run -# as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic -# reasons, but it defines __C99__FUNC__ so check that as well. -# Microsoft C normally doesn't define these macros, but it defines _MSC_VER. -# Consider a C++ compiler to be modern if it defines __cplusplus. -# -m4_define([b4_c_modern], - [[(defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER)]]) - -# b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) -# ---------------------------------------------------------- -# Declare the function NAME. -m4_define([b4_c_function_def], -[#if b4_c_modern -b4_c_ansi_function_def($@) -#else -$2 -$1 (b4_c_knr_formal_names(m4_shift2($@))) -b4_c_knr_formal_decls(m4_shift2($@)) -#endif[]dnl -]) - - -# b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) -# --------------------------------------------------------------- -# Declare the function NAME in ANSI. -m4_define([b4_c_ansi_function_def], -[$2 -$1 (b4_c_ansi_formals(m4_shift2($@)))[]dnl -]) - - -# b4_c_ansi_formals([DECL1, NAME1], ...) -# -------------------------------------- -# Output the arguments ANSI-C definition. -m4_define([b4_c_ansi_formals], -[m4_if([$#], [0], [void], - [$#$1], [1], [void], - [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])]) - -m4_define([b4_c_ansi_formal], -[$1]) - - -# b4_c_knr_formal_names([DECL1, NAME1], ...) -# ------------------------------------------ -# Output the argument names. -m4_define([b4_c_knr_formal_names], -[m4_map_sep([b4_c_knr_formal_name], [, ], [$@])]) - -m4_define([b4_c_knr_formal_name], -[$2]) - - -# b4_c_knr_formal_decls([DECL1, NAME1], ...) -# ------------------------------------------ -# Output the K&R argument declarations. -m4_define([b4_c_knr_formal_decls], -[m4_map_sep([b4_c_knr_formal_decl], - [ -], - [$@])]) - -m4_define([b4_c_knr_formal_decl], -[ $1;]) - - - -## ------------------------------------------------------------ ## -## Declaring (prototyping) C functions in both K&R and ANSI-C. ## -## ------------------------------------------------------------ ## - - -# b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) -# ----------------------------------------------------------- -# Declare the function NAME. -m4_define([b4_c_function_decl], -[#if defined __STDC__ || defined __cplusplus -b4_c_ansi_function_decl($@) -#else -$2 $1 (); -#endif[]dnl -]) - - -# b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) -# ---------------------------------------------------------------- -# Declare the function NAME. -m4_define([b4_c_ansi_function_decl], -[$2 $1 (b4_c_ansi_formals(m4_shift2($@)));[]dnl -]) - - - - -## --------------------- ## -## Calling C functions. ## -## --------------------- ## - - -# b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...) -# ----------------------------------------------------------- -# Call the function NAME with arguments NAME1, NAME2 etc. -m4_define([b4_c_function_call], -[$1 (b4_c_args(m4_shift2($@)))[]dnl -]) - - -# b4_c_args([DECL1, NAME1], ...) -# ------------------------------ -# Output the arguments NAME1, NAME2... -m4_define([b4_c_args], -[m4_map_sep([b4_c_arg], [, ], [$@])]) - -m4_define([b4_c_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 - break;]) - -# b4_symbol_actions(FILENAME, LINENO, -# SYMBOL-TAG, SYMBOL-NUM, -# SYMBOL-ACTION, SYMBOL-TYPENAME) -# ------------------------------------------------- -m4_define([b4_symbol_actions], -[m4_pushdef([b4_dollar_dollar], - [m4_ifval([$6], [(yyvaluep->$6)], [(*yyvaluep)])])dnl -m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl - case $4: /* $3 */ -b4_syncline([$2], [$1]) - $5; -b4_syncline([@oline@], [@ofile@]) - break; -m4_popdef([b4_at_dollar])dnl -m4_popdef([b4_dollar_dollar])dnl -]) - - -# b4_yydestruct_generate(FUNCTION-DECLARATOR) -# ------------------------------------------- -# Generate the "yydestruct" function, which declaration is issued using -# FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C -# or "b4_c_function_def" for K&R. -m4_define_default([b4_yydestruct_generate], -[[/*-----------------------------------------------. -| Release the memory associated to this symbol. | -`-----------------------------------------------*/ - -/*ARGSUSED*/ -]$1([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]))[ -{ - YYUSE (yyvaluep); -]b4_locations_if([ YYUSE (yylocationp); -])dnl -b4_parse_param_use[]dnl -[ - if (!yymsg) - yymsg = "Deleting"; - YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); - - switch (yytype) - { -]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ - default: - break; - } -}]dnl -]) - - -# b4_yy_symbol_print_generate(FUNCTION-DECLARATOR) -# ------------------------------------------------ -# Generate the "yy_symbol_print" function, which declaration is issued using -# FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C -# or "b4_c_function_def" for K&R. -m4_define_default([b4_yy_symbol_print_generate], -[[ -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -/*ARGSUSED*/ -]$1([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]))[ -{ - if (!yyvaluep) - return; -]b4_locations_if([ YYUSE (yylocationp); -])dnl -b4_parse_param_use[]dnl -[# ifdef YYPRINT - if (yytype < YYNTOKENS) - YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); -# else - YYUSE (yyoutput); -# endif - switch (yytype) - { -]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl -[ default: - break; - } -} - - -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -]$1([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]))[ -{ - if (yytype < YYNTOKENS) - YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); - else - YYFPRINTF (yyoutput, "nterm %s (", 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 -]) diff --git a/gnuwin32/share/bison/glr.c b/gnuwin32/share/bison/glr.c deleted file mode 100644 index 84637e0e..00000000 --- a/gnuwin32/share/bison/glr.c +++ /dev/null @@ -1,2653 +0,0 @@ - -*- C -*- - -# GLR skeleton for Bison -# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 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]) - -## ---------------- ## -## 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, don't -# change the value of b4_pure_flag, and don't 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_c_ansi_formals(b4_parse_param)])]) - - -# b4_lex_param -# ------------ -# Accumule in b4_lex_param all the yylex arguments. -# Yes, this is quite ugly... -m4_define([b4_lex_param], -m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl -b4_locations_if([, [[YYLTYPE *], [&yylloc]]])])dnl -m4_ifdef([b4_lex_param], [, ]b4_lex_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_c_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_c_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. -m4_define([b4_pure_formals], -[b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals]) - - -## ----------------- ## -## Semantic Values. ## -## ----------------- ## - - -# b4_lhs_value([TYPE]) -# -------------------- -# Expansion of $$. -m4_define([b4_lhs_value], -[((*yyvalp)[]m4_ifval([$1], [.$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], -[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$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], -[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yyloc)]) - - - -## -------------- ## -## Output files. ## -## -------------- ## - -# We do want M4 expansion after # for CPP macros. -m4_changecom() -m4_divert_push(0)dnl -@output(b4_parser_file_name@) -b4_copyright([Skeleton implementation for Bison GLR parsers in C], - [2002, 2003, 2004, 2005, 2006]) -[ -/* C GLR parser skeleton written by Paul Hilfinger. */ - -]b4_identification - -b4_percent_code_get([[top]])[]dnl -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 -#define yylloc b4_prefix[]lloc])[ - -/* Copy the first part of user declarations. */ -]b4_user_pre_prologue - -dnl # b4_shared_declarations -dnl # ---------------------- -dnl # Declaration that might either go into the header (if --defines) -dnl # or open coded in the parser body. -m4_define([b4_shared_declarations], -[b4_percent_code_get([[requires]])[]dnl - -b4_token_enums(b4_tokens) - -[#ifndef YYSTYPE -]m4_ifdef([b4_stype], -[[typedef union ]b4_union_name[ -{ -]b4_user_stype[ -} YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1]], -[m4_if(b4_tag_seen_flag, 0, -[[typedef int YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1]])])[ -#endif - -#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED -typedef struct YYLTYPE -{ -]b4_locations_if([ - int first_line; - int first_column; - int last_line; - int last_column; -],[ - char yydummy; -])[ -} YYLTYPE; -# define YYLTYPE_IS_DECLARED 1 -# define YYLTYPE_IS_TRIVIAL 1 -#endif - -]b4_percent_code_get([[provides]])[]dnl -]) - -b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]], - [b4_shared_declarations])[ - -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG ]b4_debug_flag[ -#endif - -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -# undef YYERROR_VERBOSE -# define YYERROR_VERBOSE 1 -#else -# define YYERROR_VERBOSE ]b4_error_verbose_flag[ -#endif - -/* Enabling the token table. */ -#ifndef YYTOKEN_TABLE -# define YYTOKEN_TABLE ]b4_token_table[ -#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; - -/* Copy the second part of user declarations. */ -]b4_user_post_prologue -b4_percent_code_get[]dnl - -[#include -#include -#include - -#ifndef YY_ -# if 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 - -/* Suppress unused-variable warnings by "using" E. */ -#if ! defined lint || defined __GNUC__ -# define YYUSE(e) ((void) (e)) -#else -# define YYUSE(e) /* empty */ -#endif - -/* Identity function, used to suppress warnings about constant conditions. */ -#ifndef lint -# define YYID(n) (n) -#else -]b4_c_function_def([YYID], [static int], [[int i], [i]])[ -{ - return i; -} -#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) -# define YYLONGJMP(env, val) longjmp (env, val) -#endif - -/*-----------------. -| GCC extensions. | -`-----------------*/ - -#ifndef __attribute__ -/* This feature is available in gcc versions 2.5 and later. */ -# if (! defined __GNUC__ || __GNUC__ < 2 \ - || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__) -# define __attribute__(Spec) /* empty */ -# endif -#endif - -]b4_locations_if([#define YYOPTIONAL_LOC(Name) Name],[ -#ifdef __cplusplus -# define YYOPTIONAL_LOC(Name) /* empty */ -#else -# define YYOPTIONAL_LOC(Name) Name __attribute__ ((__unused__)) -#endif])[ - -#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 YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = -{ - ]b4_prhs[ -}; - -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = -{ - ]b4_rhs[ -}; - -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const ]b4_int_type_for([b4_rline])[ yyrline[] = -{ - ]b4_rline[ -}; -#endif - -#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE -/* 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 - -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const ]b4_int_type_for([b4_r1])[ yyr1[] = -{ - ]b4_r1[ -}; - -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const ]b4_int_type_for([b4_r2])[ yyr2[] = -{ - ]b4_r2[ -}; - -/* 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[ -}; - -/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE - doesn't specify something else to do. Zero means the default is an - error. */ -static const ]b4_int_type_for([b4_defact])[ yydefact[] = -{ - ]b4_defact[ -}; - -/* YYPDEFGOTO[NTERM-NUM]. */ -static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = -{ - ]b4_defgoto[ -}; - -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF ]b4_pact_ninf[ -static const ]b4_int_type_for([b4_pact])[ yypact[] = -{ - ]b4_pact[ -}; - -/* YYPGOTO[NTERM-NUM]. */ -static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = -{ - ]b4_pgoto[ -}; - -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. - If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF ]b4_table_ninf[ -static const ]b4_int_type_for([b4_table])[ yytable[] = -{ - ]b4_table[ -}; - -/* 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, which type is "short int *". -dnl We probably ought to introduce a type for confl. -[static const short int yyconfl[] = -{ - ]b4_conflicting_rules[ -}; - -static const ]b4_int_type_for([b4_check])[ yycheck[] = -{ - ]b4_check[ -}; - -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const ]b4_int_type_for([b4_stos])[ yystos[] = -{ - ]b4_stos[ -}; - - -/* Prevent warning if -Wmissing-prototypes. */ -]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param)[ - -/* Error token number */ -#define YYTERROR 1 - -/* 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). */ - -]b4_locations_if([[ -#define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (YYID (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 (YYID (0)) - -/* 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. */ - -# define YY_LOCATION_PRINT(File, Loc) \ - fprintf (File, "%d.%d-%d.%d", \ - (Loc).first_line, (Loc).first_column, \ - (Loc).last_line, (Loc).last_column) -#endif -]],[ -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) ((void) 0) -#endif -])[ - -#ifndef YY_LOCATION_PRINT -# define YY_LOCATION_PRINT(File, Loc) ((void) 0) -#endif - - -/* YYLEX -- calling `yylex' with the right arguments. */ -#define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ - -]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; - -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 yyflag = YYE; if (yyflag != yyok) return yyflag; } \ - while (YYID (0)) - -#if YYDEBUG - -# ifndef YYFPRINTF -# define YYFPRINTF fprintf -# endif - -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (YYID (0)) - -]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[ - -# 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 (YYID (0)) - -/* Nonzero means print parse trace. It is left uninitialized so that - multiple parsers can coexist. */ -int yydebug; - -#else /* !YYDEBUG */ - -# define YYDPRINTF(Args) -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) - -#endif /* !YYDEBUG */ - -/* 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 -# if (! defined __cplusplus \ - || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ - && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)) -# define YYSTACKEXPANDABLE 1 -# else -# define YYSTACKEXPANDABLE 0 -# endif -#endif - -#if YYSTACKEXPANDABLE -# define YY_RESERVE_GLRSTACK(Yystack) \ - do { \ - if (Yystack->yyspaceLeft < YYHEADROOM) \ - yyexpandGLRStack (Yystack); \ - } while (YYID (0)) -#else -# define YY_RESERVE_GLRSTACK(Yystack) \ - do { \ - if (Yystack->yyspaceLeft < YYHEADROOM) \ - yyMemoryExhausted (Yystack); \ - } while (YYID (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 short 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 first 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; - /** 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; - 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; - 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 != 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 YYDEBUG || 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) -{ - yyGLRState* s; - int i; - s = yyvsp[yylow0].yystate.yypred; - for (i = yylow0-1; i >= yylow1; i -= 1) - { - YYASSERT (s->yyresolved); - yyvsp[i].yystate.yyresolved = yytrue; - yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval; - 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. */ -/*ARGSUSED*/ static YYRESULTTAG -yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, - YYSTYPE* yyvalp, - YYLTYPE* YYOPTIONAL_LOC (yylocp), - yyGLRStack* yystackp - ]b4_user_formals[) -{ - yybool yynormal __attribute__ ((__unused__)) = - (yystackp->yysplitPoint == NULL); - int yylow; -]b4_parse_param_use[]dnl -[# 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; - YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); -]b4_locations_if([[ 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 -} - - -/*ARGSUSED*/ 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_generate([b4_c_ansi_function_def])[ - -/** 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_locations_if([, &yys->yyloc])[]b4_user_args[); - else - { -#if YYDEBUG - if (yydebug) - { - if (yys->yysemantics.yyfirstVal) - YYFPRINTF (stderr, "%s unresolved ", yymsg); - else - YYFPRINTF (stderr, "%s incomplete ", yymsg); - yy_symbol_print (stderr, yystos[yys->yylrState], - NULL]b4_locations_if([, &yys->yyloc])[]b4_user_args[); - 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 #RULE. */ -static inline yySymbol -yylhsNonterm (yyRuleNum yyrule) -{ - return yyr1[yyrule]; -} - -#define yyis_pact_ninf(yystate) \ - ]m4_if(m4_eval(b4_pact_ninf < b4_pact_min), [1], - [0], - [((yystate) == YYPACT_NINF)])[ - -/** True iff LR state STATE has only a default reduction (regardless - * of token). */ -static inline yybool -yyisDefaultedState (yyStateNum yystate) -{ - return yyis_pact_ninf (yypact[yystate]); -} - -/** The default reduction for STATE, assuming it has one. */ -static inline yyRuleNum -yydefaultAction (yyStateNum yystate) -{ - return yydefact[yystate]; -} - -#define yyis_table_ninf(yytable_value) \ - ]m4_if(m4_eval(b4_table_ninf < b4_table_min), [1], - [YYID (0)], - [((yytable_value) == YYTABLE_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 *CONFLICTS to a pointer into yyconfl to 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 (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) - { - *yyaction = -yydefact[yystate]; - *yyconflicts = yyconfl; - } - else if (! yyis_table_ninf (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; - 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. 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 - * RULENUM on the semantic values in RHS to the list of - * alternative actions for STATE. Assumes that RHS comes from - * stack #K of *STACKP. */ -static void -yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate, - yyGLRState* rhs, yyRuleNum yyrule) -{ - yySemanticOption* yynewOption = - &yynewGLRStackItem (yystackp, yyfalse)->yyoption; - yynewOption->yystate = rhs; - yynewOption->yyrule = yyrule; - if (yystackp->yytops.yylookaheadNeeds[yyk]) - { - yynewOption->yyrawchar = yychar; - yynewOption->yyval = yylval; - yynewOption->yyloc = yylloc; - } - else - yynewOption->yyrawchar = YYEMPTY; - yynewOption->yynext = yystate->yysemantics.yyfirstVal; - yystate->yysemantics.yyfirstVal = yynewOption; - - YY_RESERVE_GLRSTACK (yystackp); -} - - /* GLRStacks */ - -/** Initialize SET 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] = 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 STACK to a single empty stack, with total maximum - * capacity for all stacks of SIZE. */ -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 = NULL; - yystackp->yylastDeleted = NULL; - return yyinitStateSet (&yystackp->yytops); -} - - -#if YYSTACKEXPANDABLE -# define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \ - &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE - -/** If STACK 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 yysize, yynewSize; - size_t yyn; - 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 != NULL) - yys1->yypred = - YYRELOC (yyp0, yyp1, yys0->yypred, yystate); - if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL) - yys1->yysemantics.yyfirstVal = - YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); - } - else - { - yySemanticOption* yyv0 = &yyp0->yyoption; - yySemanticOption* yyv1 = &yyp1->yyoption; - if (yyv0->yystate != NULL) - yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate); - if (yyv0->yynext != NULL) - yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption); - } - } - if (yystackp->yysplitPoint != NULL) - yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems, - yystackp->yysplitPoint, yystate); - - for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1) - if (yystackp->yytops.yystates[yyn] != 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 S is a GLRState somewhere on STACK, update the - * splitpoint of STACK, if needed, so that it is at least as deep as - * S. */ -static inline void -yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys) -{ - if (yystackp->yysplitPoint != NULL && yystackp->yysplitPoint > yys) - yystackp->yysplitPoint = yys; -} - -/** Invalidate stack #K in STACK. */ -static inline void -yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk) -{ - if (yystackp->yytops.yystates[yyk] != NULL) - yystackp->yylastDeleted = yystackp->yytops.yystates[yyk]; - yystackp->yytops.yystates[yyk] = NULL; -} - -/** Undelete the last stack 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 == 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 = NULL; -} - -static inline void -yyremoveDeletes (yyGLRStack* yystackp) -{ - size_t yyi, yyj; - yyi = yyj = 0; - while (yyj < yystackp->yytops.yysize) - { - if (yystackp->yytops.yystates[yyi] == 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 #K of STACK, corresponding to LR state - * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */ -static inline void -yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, - size_t yyposn, - YYSTYPE* yyvalp, 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; - yynewState->yyloc = *yylocp; - yystackp->yytops.yystates[yyk] = yynewState; - - YY_RESERVE_GLRSTACK (yystackp); -} - -/** Shift stack #K of YYSTACK, 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* rhs, 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 = NULL; - yystackp->yytops.yystates[yyk] = yynewState; - - /* Invokes YY_RESERVE_GLRSTACK. */ - yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule); -} - -/** Pop the symbols consumed by reduction #RULE from the top of stack - * #K of STACK, and perform the appropriate semantic action on their - * semantic values. Assumes that all ambiguities in semantic values - * have been previously resolved. Set *VALP to the resulting value, - * and *LOCP 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, YYLTYPE* yylocp]b4_user_formals[) -{ - int yynrhs = yyrhsLength (yyrule); - - if (yystackp->yysplitPoint == NULL) - { - /* Standard special case: single stack. */ - yyGLRStackItem* rhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; - YYASSERT (yyk == 0); - yystackp->yynextFree -= yynrhs; - yystackp->yyspaceLeft += yynrhs; - yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate; - return yyuserAction (yyrule, yynrhs, rhs, - yyvalp, yylocp, yystackp]b4_user_args[); - } - else - { - /* At present, doAction is never called in nondeterministic - * mode, so this branch is never taken. It is here in - * anticipation of a future feature that will allow immediate - * evaluation of selected actions in nondeterministic mode. */ - 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; - return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, - yyvalp, yylocp, yystackp]b4_user_args[); - } -} - -#if !YYDEBUG -# define YY_REDUCE_PRINT(Args) -#else -# define YY_REDUCE_PRINT(Args) \ -do { \ - if (yydebug) \ - yy_reduce_print Args; \ -} while (YYID (0)) - -/*----------------------------------------------------------. -| Report that the RULE is going to be reduced on stack #K. | -`----------------------------------------------------------*/ - -/*ARGSUSED*/ static inline void -yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, - YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) -{ - int yynrhs = yyrhsLength (yyrule); - yybool yynormal __attribute__ ((__unused__)) = - (yystackp->yysplitPoint == NULL); - yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; - int yylow = 1; - int yyi; - YYUSE (yyvalp); - YYUSE (yylocp); -]b4_parse_param_use[]dnl -[ YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n", - (unsigned long int) yyk, yyrule - 1, - (unsigned long int) yyrline[yyrule]); - /* The symbols being reduced. */ - for (yyi = 0; yyi < yynrhs; yyi++) - { - YYFPRINTF (stderr, " $%d = ", yyi + 1); - yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], - &]b4_rhs_value(yynrhs, yyi + 1)[ - ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl - b4_user_args[); - YYFPRINTF (stderr, "\n"); - } -} -#endif - -/** Pop items off stack #K of STACK according to grammar rule RULE, - * and push back on the resulting nonterminal symbol. Perform the - * semantic action associated with RULE and store its value with the - * newly pushed state, if FORCEEVAL or if STACK 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 #K from - * the STACK. In this case, the (necessarily deferred) 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 == NULL) - { - YYSTYPE yysval; - YYLTYPE yyloc; - - YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval, &yyloc]b4_user_args[)); - YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval, - &yyloc]b4_user_args[)); - YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc); - yyglrShift (yystackp, yyk, - yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, - yylhsNonterm (yyrule)), - yyposn, &yysval, &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] != NULL) - { - yyGLRState* yyp, *yysplit = yystackp->yysplitPoint; - 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 == NULL) - { - YYASSERT (yyk == 0); - yystackp->yysplitPoint = yystackp->yytops.yystates[yyk]; - } - if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity) - { - yyGLRState** yynewStates; - yybool* yynewLookaheadNeeds; - - yynewStates = 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 == NULL) - yyMemoryExhausted (yystackp); - yystackp->yytops.yystates = yynewStates; - - yynewLookaheadNeeds = - (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds, - (yystackp->yytops.yycapacity - * sizeof yynewLookaheadNeeds[0])); - if (yynewLookaheadNeeds == 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 Y0 and Y1 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 (Y0,Y1), destructively merge the - * alternative semantic values for the RHS-symbols of Y1 and Y0. */ -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; - yySemanticOption* yyz1; - yyz0p = &yys0->yysemantics.yyfirstVal; - yyz1 = yys1->yysemantics.yyfirstVal; - while (YYID (yytrue)) - { - if (yyz1 == *yyz0p || yyz1 == NULL) - break; - else if (*yyz0p == 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 N states starting at and including state S. 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 OPT, perform its user action, and return - * the semantic value and location. 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, YYLTYPE* yylocp]b4_user_formals[) -{ - yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; - int yynrhs; - int yychar_current; - YYSTYPE yylval_current; - YYLTYPE yylloc_current; - YYRESULTTAG yyflag; - - yynrhs = yyrhsLength (yyopt->yyrule); - 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;]])[ - yychar_current = yychar; - yylval_current = yylval; - yylloc_current = yylloc; - yychar = yyopt->yyrawchar; - yylval = yyopt->yyval; - yylloc = yyopt->yyloc; - yyflag = yyuserAction (yyopt->yyrule, yynrhs, - yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, - yyvalp, yylocp, yystackp]b4_user_args[); - yychar = yychar_current; - yylval = yylval_current; - yylloc = yylloc_current; - return yyflag; -} - -#if YYDEBUG -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 == 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 (yyrhs[yyprhs[yyx->yyrule]+yyi-1])); - else - YYFPRINTF (stderr, "%*s%s \n", yyindent+2, "", - yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]), - (unsigned long int) (yystates[yyi - 1]->yyposn + 1), - (unsigned long int) yystates[yyi]->yyposn); - } - else - yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2); - } -} -#endif - -/*ARGSUSED*/ static YYRESULTTAG -yyreportAmbiguity (yySemanticOption* yyx0, - yySemanticOption* yyx1]b4_pure_formals[) -{ - YYUSE (yyx0); - YYUSE (yyx1); - -#if YYDEBUG - 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; -} - -/** Starting at and including state S1, resolve the location for each of the - * previous N1 states that is unresolved. 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) - { - yySemanticOption *yyoption; - yyGLRStackItem yyrhsloc[1 + YYMAXRHS]; - int yynrhs; - int yychar_current; - YYSTYPE yylval_current; - YYLTYPE yylloc_current; - yyoption = yys1->yysemantics.yyfirstVal; - YYASSERT (yyoption != 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; - } - yychar_current = yychar; - yylval_current = yylval; - 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 S, perform the indicated - * actions, and set the semantic value of S. If result != yyok, the chain of - * semantic options in S has been cleared instead or it has been left - * unmodified except that redundant options may have been removed. Regardless - * of whether result = yyok, S 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; - yySemanticOption** yypp; - yybool yymerge; - YYSTYPE yysval; - YYRESULTTAG yyflag; - YYLTYPE *yylocp = &yys->yyloc; - - yybest = yyoptionList; - yymerge = yyfalse; - for (yypp = &yyoptionList->yynext; *yypp != NULL; ) - { - yySemanticOption* yyp = *yypp; - - if (yyidenticalOptions (yybest, yyp)) - { - yymergeOptionSets (yybest, yyp); - *yypp = yyp->yynext; - } - else - { - switch (yypreference (yybest, yyp)) - { - case 0: - 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, - yylocp]b4_user_args[); - if (yyflag == yyok) - for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext) - { - if (yyprec == yydprec[yyp->yyrule]) - { - YYSTYPE yysval_other; - YYLTYPE yydummy; - yyflag = yyresolveAction (yyp, yystackp, &yysval_other, - &yydummy]b4_user_args[); - if (yyflag != yyok) - { - yydestruct ("Cleanup: discarding incompletely merged value for", - yystos[yys->yylrState], - &yysval]b4_locations_if([, yylocp])[]b4_user_args[); - break; - } - yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other); - } - } - } - else - yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[); - - if (yyflag == yyok) - { - yys->yyresolved = yytrue; - yys->yysemantics.yysval = yysval; - } - else - yys->yysemantics.yyfirstVal = NULL; - return yyflag; -} - -static YYRESULTTAG -yyresolveStack (yyGLRStack* yystackp]b4_user_formals[) -{ - if (yystackp->yysplitPoint != 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 == NULL) - return; - - for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = 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 = NULL; - yystackp->yylastDeleted = NULL; - - while (yyr != 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[) -{ - int yyaction; - const short int* yyconflicts; - yyRuleNum yyrule; - - while (yystackp->yytops.yystates[yyk] != 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)) - { - yyrule = yydefaultAction (yystate); - if (yyrule == 0) - { - YYDPRINTF ((stderr, "Stack %lu dies.\n", - (unsigned long int) yyk)); - yymarkStackDeleted (yystackp, yyk); - return yyok; - } - YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[)); - } - else - { - yySymbol yytoken; - yystackp->yytops.yylookaheadNeeds[yyk] = yytrue; - if (yychar == YYEMPTY) - { - YYDPRINTF ((stderr, "Reading a token: ")); - yychar = YYLEX; - } - - 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) - { - size_t yynewStack = yysplitStack (yystackp, yyk); - YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n", - (unsigned long int) yynewStack, - (unsigned long int) yyk)); - YYCHK (yyglrReduce (yystackp, yynewStack, - *yyconflicts, yyfalse]b4_user_args[)); - YYCHK (yyprocessOneStack (yystackp, yynewStack, - yyposn]b4_pure_args[)); - 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 - YYCHK (yyglrReduce (yystackp, yyk, -yyaction, - yyfalse]b4_user_args[)); - } - } - return yyok; -} - -/*ARGSUSED*/ static void -yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) -{ - if (yystackp->yyerrState == 0) - { -#if YYERROR_VERBOSE - int yyn; - yyn = yypact[yystackp->yytops.yystates[0]->yylrState]; - if (YYPACT_NINF < yyn && yyn <= YYLAST) - { - yySymbol yytoken = YYTRANSLATE (yychar); - size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken)); - size_t yysize = yysize0; - size_t yysize1; - yybool yysize_overflow = yyfalse; - char* yymsg = NULL; - enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; - char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - int yyx; - char *yyfmt; - char const *yyf; - static char const yyunexpected[] = "syntax error, unexpected %s"; - static char const yyexpecting[] = ", expecting %s"; - static char const yyor[] = " or %s"; - char yyformat[sizeof yyunexpected - + sizeof yyexpecting - 1 - + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) - * (sizeof yyor - 1))]; - char const *yyprefix = yyexpecting; - - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - 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 yycount = 1; - - yyarg[0] = yytokenName (yytoken); - yyfmt = yystpcpy (yyformat, yyunexpected); - - for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) - { - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) - { - yycount = 1; - yysize = yysize0; - yyformat[sizeof yyunexpected - 1] = '\0'; - break; - } - yyarg[yycount++] = yytokenName (yyx); - yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx)); - yysize_overflow |= yysize1 < yysize; - yysize = yysize1; - yyfmt = yystpcpy (yyfmt, yyprefix); - yyprefix = yyor; - } - - yyf = YY_(yyformat); - yysize1 = yysize + strlen (yyf); - yysize_overflow |= yysize1 < yysize; - yysize = yysize1; - - if (!yysize_overflow) - yymsg = (char *) YYMALLOC (yysize); - - if (yymsg) - { - char *yyp = yymsg; - int yyi = 0; - while ((*yyp = *yyf)) - { - if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) - { - yyp += yytnamerr (yyp, yyarg[yyi++]); - yyf += 2; - } - else - { - yyp++; - yyf++; - } - } - yyerror (]b4_lyyerror_args[yymsg); - YYFREE (yymsg); - } - else - { - yyerror (]b4_lyyerror_args[YY_("syntax error")); - yyMemoryExhausted (yystackp); - } - } - else -#endif /* YYERROR_VERBOSE */ - yyerror (]b4_lyyerror_args[YY_("syntax error")); - 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. */ -/*ARGSUSED*/ 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 (YYID (yytrue)) - { - yySymbol yytoken; - if (yychar == YYEOF) - yyFail (yystackp][]b4_lpure_args[, 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_locations_if([, &yylloc])[]b4_user_args[); - } - YYDPRINTF ((stderr, "Reading a token: ")); - yychar = YYLEX; - 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 (yyis_pact_ninf (yyj)) - return; - yyj += yytoken; - if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken) - { - if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0) - return; - } - else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj])) - return; - } - - /* Reduce to one stack. */ - for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1) - if (yystackp->yytops.yystates[yyk] != NULL) - break; - if (yyk >= yystackp->yytops.yysize) - yyFail (yystackp][]b4_lpure_args[, 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] != NULL) - { - yyGLRState *yys = yystackp->yytops.yystates[0]; - yyj = yypact[yys->yylrState]; - if (! yyis_pact_ninf (yyj)) - { - yyj += YYTERROR; - if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR - && yyisShiftAction (yytable[yyj])) - { - /* Shift the error token having adjusted its location. */ - YYLTYPE yyerrloc;]b4_locations_if([[ - 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, &yyerrloc); - yys = yystackp->yytops.yystates[0]; - break; - } - } -]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ - if (yys->yypred != 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] == NULL) - yyFail (yystackp][]b4_lpure_args[, 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 (YYID (0)) - - -/*----------. -| yyparse. | -`----------*/ - -]b4_c_ansi_function_def([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([ -#if YYLTYPE_IS_TRIVIAL - yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[; - yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[; -#endif -]) -m4_ifdef([b4_initial_action], [ -m4_pushdef([b4_at_dollar], [yylloc])dnl -m4_pushdef([b4_dollar_dollar], [yylval])dnl - /* User initialization code. */ - b4_user_initial_action -m4_popdef([b4_dollar_dollar])dnl -m4_popdef([b4_at_dollar])])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, &yylloc); - yyposn = 0; - - while (YYID (yytrue)) - { - /* For efficiency, we have two loops, the first of which is - specialized to deterministic operation (single stack, no - potential ambiguity). */ - /* Standard mode */ - while (YYID (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 = YYLEX; - } - - 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, &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 (YYID (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, &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_locations_if([, &yylloc])[]b4_user_args[); - - /* 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 != NULL) - yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); - yystates[yyk] = yys->yypred; - yystack.yynextFree -= 1; - yystack.yyspaceLeft += 1; - } - break; - } - } - yyfreeGLRStack (&yystack); - } - - /* Make sure YYID is used. */ - return YYID (yyresult); -} - -/* DEBUGGING ONLY */ -#if YYDEBUG -static void yypstack (yyGLRStack* yystackp, size_t yyk) - __attribute__ ((__unused__)); -static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__)); - -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 == 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) == 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 -] - -b4_epilogue -dnl -dnl glr.cc produces its own header. -dnl -m4_if(b4_skeleton, ["glr.c"], -[b4_defines_if( -[@output(b4_spec_defines_file@) -b4_copyright([Skeleton interface for Bison GLR parsers in C], - [2002, 2003, 2004, 2005, 2006]) - -b4_shared_declarations - -b4_pure_if([], -[[extern YYSTYPE ]b4_prefix[lval;]]) - -b4_locations_if([b4_pure_if([], -[extern YYLTYPE ]b4_prefix[lloc;]) -]) -])]) -m4_divert_pop(0) diff --git a/gnuwin32/share/bison/glr.cc b/gnuwin32/share/bison/glr.cc deleted file mode 100644 index ea04b28d..00000000 --- a/gnuwin32/share/bison/glr.cc +++ /dev/null @@ -1,377 +0,0 @@ - -*- C -*- - -# C++ GLR skeleton for Bison -# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 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 easy: just let yyparser become 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 (C++) 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 using locations. -m4_define([b4_locations_flag], [1]) -m4_define([b4_pure_flag], [1]) - -# The header is mandatory. -b4_defines_if([], - [b4_fatal([b4_skeleton[: using %%defines is mandatory]])]) - -m4_include(b4_pkgdatadir/[c++.m4]) -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_yy_symbol_print_generate -# --------------------------- -# Bypass the default implementation to generate the "yy_symbol_print" -# and "yy_symbol_value_print" functions. -m4_define([b4_yy_symbol_print_generate], -[[ -/*--------------------. -| Print this symbol. | -`--------------------*/ - -]b4_c_ansi_function_def([yy_symbol_print], - [static void], - [[FILE *], []], - [[int yytype], [yytype]], - [[const b4_namespace_ref::b4_parser_class_name::semantic_type *yyvaluep], - [yyvaluep]], - [[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])[); -} -]]) - - -# Declare yyerror. -m4_append([b4_post_prologue], -[b4_syncline([@oline@], [@ofile@]) - -b4_c_ansi_function_decl([yyerror], - [static void], - [[b4_namespace_ref::b4_parser_class_name::location_type *yylocationp], [yylocationp]], - b4_parse_param, - [[const char* msg], [msg]])]) - - -# Define yyerror. -m4_append([b4_epilogue], -[b4_syncline([@oline@], [@ofile@])[ -/*------------------. -| Report an error. | -`------------------*/ - -]b4_c_ansi_function_def([yyerror], - [static void], - [[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 (*yylocationp, msg); -} - - -]b4_namespace_open[ -]dnl In this section, the parse param 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 YYDEBUG - ]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[ () - { - } - - int - ]b4_parser_class_name[::parse () - { - return ::yyparse (*this]b4_user_args[); - } - -#if YYDEBUG - /*--------------------. - | Print this symbol. | - `--------------------*/ - - inline void - ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, - const semantic_type* yyvaluep, const location_type* yylocationp) - { - /* Pacify ``unused variable'' warnings. */ - YYUSE (yyvaluep); - YYUSE (yylocationp); - switch (yytype) - { - ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl -[ default: - break; - } - } - - - void - ]b4_parser_class_name[::yy_symbol_print_ (int yytype, - const semantic_type* yyvaluep, const location_type* yylocationp) - { - *yycdebug_ << (yytype < YYNTOKENS ? "token" : "nterm") - << ' ' << yytname[yytype] << " (" - << *yylocationp << ": "; - yy_symbol_value_print_ (yytype, yyvaluep, 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) - { - yydebug_ = l; - } - -#endif -]m4_popdef([b4_parse_param])dnl -b4_namespace_close[ - -]]) - - -# Let glr.c believe that the user arguments include the parser itself. -m4_ifset([b4_parse_param], -[m4_pushdef([b4_parse_param], - m4_dquote([[[b4_namespace_ref::b4_parser_class_name& yyparser], [[yyparser]]],] -m4_defn([b4_parse_param])))], -[m4_pushdef([b4_parse_param], - [[[[b4_namespace_ref::b4_parser_class_name& yyparser], [[yyparser]]]]]) -]) -m4_include(b4_pkgdatadir/[glr.c]) -m4_popdef([b4_parse_param]) - -m4_divert_push(0) -@output(b4_spec_defines_file@) -b4_copyright([Skeleton interface for Bison GLR parsers in C++], - [2002, 2003, 2004, 2005, 2006])[ - -/* C++ GLR parser skeleton written by Akim Demaille. */ - -#ifndef PARSER_HEADER_H -# define PARSER_HEADER_H - -]b4_percent_code_get([[requires]])[ - -#include -#include - -/* Using locations. */ -#define YYLSP_NEEDED ]b4_locations_flag[ - -]b4_namespace_open[ - class position; - class location; -]b4_namespace_close[ - -#include "location.hh" - -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG ]b4_debug_flag[ -#endif - -/* 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*/ 0) -#endif - -]b4_namespace_open[ - /// A Bison parser. - class ]b4_parser_class_name[ - { - public: - /// Symbol semantic values. -#ifndef YYSTYPE -]m4_ifdef([b4_stype], -[ union semantic_type - { -b4_user_stype - };], -[m4_if(b4_tag_seen_flag, 0, -[[ typedef int semantic_type;]], -[[ typedef YYSTYPE semantic_type;]])])[ -#else - typedef YYSTYPE semantic_type; -#endif - /// Symbol locations. - typedef ]b4_percent_define_get([[location_type]])[ location_type; - /// Tokens. - struct token - { - ]b4_token_enums(b4_tokens)[ - }; - /// Token type. - typedef token::yytokentype token_type; - - /// 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); - - private: - - public: - /// Report a syntax error. - /// \param loc where the syntax error is found. - /// \param msg a description of the syntax error. - virtual void error (const location_type& loc, const std::string& msg); - private: - -#if YYDEBUG - public: - /// \brief Report a symbol value on the debug stream. - /// \param yytype The token type. - /// \param yyvaluep Its semantic value. - /// \param yylocationp Its location. - virtual void yy_symbol_value_print_ (int yytype, - const semantic_type* yyvaluep, - const location_type* yylocationp); - /// \brief Report a symbol on the debug stream. - /// \param yytype The token type. - /// \param yyvaluep Its semantic value. - /// \param yylocationp Its location. - virtual void yy_symbol_print_ (int yytype, - const semantic_type* yyvaluep, - const location_type* yylocationp); - private: - /* Debugging. */ - int yydebug_; - std::ostream* yycdebug_; -#endif - - - /// \brief Reclaim the memory associated to a symbol. - /// \param yymsg Why this token is reclaimed. - /// \param yytype The symbol type. - /// \param yyvaluep Its semantic value. - /// \param yylocationp Its location. - inline void yydestruct_ (const char* yymsg, - int yytype, - semantic_type* yyvaluep, - location_type* yylocationp); - -]b4_parse_param_vars[ - }; - -]dnl Redirections for glr.c. -b4_percent_define_flag_if([[global_tokens_and_yystype]], -[b4_token_defines(b4_tokens)]) -[ -#ifndef YYSTYPE -# define YYSTYPE ]b4_namespace_ref[::]b4_parser_class_name[::semantic_type -#endif -#ifndef YYLTYPE -# define YYLTYPE ]b4_namespace_ref[::]b4_parser_class_name[::location_type -#endif - -]b4_namespace_close[ - -]b4_percent_code_get([[provides]])[]dnl - -[#endif /* ! defined PARSER_HEADER_H */] -m4_divert_pop(0) diff --git a/gnuwin32/share/bison/java-skel.m4 b/gnuwin32/share/bison/java-skel.m4 deleted file mode 100644 index 7c4aa109..00000000 --- a/gnuwin32/share/bison/java-skel.m4 +++ /dev/null @@ -1,25 +0,0 @@ - -*- Autoconf -*- - -# Java skeleton dispatching for Bison. -# Copyright (C) 2007 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/share/bison/java.m4 b/gnuwin32/share/bison/java.m4 deleted file mode 100644 index b3dbd3b3..00000000 --- a/gnuwin32/share/bison/java.m4 +++ /dev/null @@ -1,303 +0,0 @@ - -*- Autoconf -*- - -# Java language support for Bison - -# Copyright (C) 2007, 2008 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) -# ---------------- -m4_define([b4_comment], [/* m4_bpatsubst([$1], [ -], [ - ]) */]) - - -# 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]) - - -## ------------------------- ## -## Assigning token numbers. ## -## ------------------------- ## - -# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER) -# --------------------------------------- -# Output the definition of this token as an enum. -m4_define([b4_token_enum], -[ /** Token number, to be returned by the scanner. */ - public static final int $1 = $2; -]) - - -# b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) -# ----------------------------------------------------- -# Output the definition of the tokens (if there are) as enums. -m4_define([b4_token_enums], -[m4_if([$#$1], [1], [], -[/* Tokens. */ -m4_map([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; - ]) - - -## ---------------- ## -## Default values. ## -## ---------------- ## - -m4_define([b4_yystype], [b4_percent_define_get([[stype]])]) -b4_percent_define_default([[stype]], [[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([[location_type]], [Location])]) -m4_define([b4_location_type], [b4_percent_define_get([[location_type]])]) - -b4_percent_define_default([[position_type]], [Position])]) -m4_define([b4_position_type], [b4_percent_define_get([[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/share/bison/lalr1.cc b/gnuwin32/share/bison/lalr1.cc deleted file mode 100644 index ca1dfccd..00000000 --- a/gnuwin32/share/bison/lalr1.cc +++ /dev/null @@ -1,1157 +0,0 @@ -# C++ skeleton for Bison - -# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 -# 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]) - -m4_define([b4_parser_class_name], - [b4_percent_define_get([[parser_class_name]])]) - -# The header is mandatory. -b4_defines_if([], - [b4_fatal([b4_skeleton[: using %%defines is mandatory]])]) - -# Backward compatibility. -m4_define([b4_location_constructors]) -m4_include(b4_pkgdatadir/[location.cc]) - -# We do want M4 expansion after # for CPP macros. -m4_changecom() -m4_divert_push(0)dnl -b4_defines_if( -[@output(b4_spec_defines_file@) -b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++], - [2002, 2003, 2004, 2005, 2006, 2007, 2008]) -dnl FIXME: This is wrong, we want computed header guards. -[ -/* C++ LALR(1) parser skeleton written by Akim Demaille. */ - -#ifndef PARSER_HEADER_H -# define PARSER_HEADER_H - -]b4_percent_code_get([[requires]])[ - -#include -#include -#include "stack.hh" - -]b4_namespace_open[ - class position; - class location; -]b4_namespace_close[ - -#include "location.hh" - -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG ]b4_debug_flag[ -#endif - -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -# undef YYERROR_VERBOSE -# define YYERROR_VERBOSE 1 -#else -# define YYERROR_VERBOSE ]b4_error_verbose_flag[ -#endif - -/* Enabling the token table. */ -#ifndef YYTOKEN_TABLE -# define YYTOKEN_TABLE ]b4_token_table[ -#endif - -/* 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 = (Rhs)[1].begin; \ - (Current).end = (Rhs)[N].end; \ - } \ - else \ - { \ - (Current).begin = (Current).end = (Rhs)[0].end; \ - } \ -} while (false) -#endif - -]b4_namespace_open[ - - /// A Bison parser. - class ]b4_parser_class_name[ - { - public: - /// Symbol semantic values. -#ifndef YYSTYPE -]m4_ifdef([b4_stype], -[ union semantic_type - { -b4_user_stype - };], -[m4_if(b4_tag_seen_flag, 0, -[[ typedef int semantic_type;]], -[[ typedef YYSTYPE semantic_type;]])])[ -#else - typedef YYSTYPE semantic_type; -#endif - /// Symbol locations. - typedef ]b4_percent_define_get([[location_type]])[ location_type; - /// Tokens. - struct token - { - ]b4_token_enums(b4_tokens)[ - }; - /// Token type. - typedef token::yytokentype token_type; - - /// 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 YYDEBUG - /// 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 - - private: - /// Report a syntax error. - /// \param loc where the syntax error is found. - /// \param msg a description of the syntax error. - virtual void error (const location_type& loc, const std::string& msg); - - /// Generate an error message. - /// \param state the state where the error occurred. - /// \param tok the lookahead token. - virtual std::string yysyntax_error_ (int yystate]dnl -b4_error_verbose_if([, int tok])[); - -#if YYDEBUG - /// \brief Report a symbol value on the debug stream. - /// \param yytype The token type. - /// \param yyvaluep Its semantic value. - /// \param yylocationp Its location. - virtual void yy_symbol_value_print_ (int yytype, - const semantic_type* yyvaluep, - const location_type* yylocationp); - /// \brief Report a symbol on the debug stream. - /// \param yytype The token type. - /// \param yyvaluep Its semantic value. - /// \param yylocationp Its location. - virtual void yy_symbol_print_ (int yytype, - const semantic_type* yyvaluep, - const location_type* yylocationp); -#endif - - - /// State numbers. - typedef int state_type; - /// State stack type. - typedef stack state_stack_type; - /// Semantic value stack type. - typedef stack semantic_stack_type; - /// location stack type. - typedef stack location_stack_type; - - /// The state stack. - state_stack_type yystate_stack_; - /// The semantic value stack. - semantic_stack_type yysemantic_stack_; - /// The location stack. - location_stack_type yylocation_stack_; - - /// Internal symbol numbers. - typedef ]b4_int_type_for([b4_translate])[ token_number_type; - /* Tables. */ - /// For a state, the index in \a yytable_ of its portion. - static const ]b4_int_type_for([b4_pact])[ yypact_[]; - static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_; - - /// For a state, default rule to reduce. - /// Unless\a yytable_ specifies something else to do. - /// Zero means the default is an error. - static const ]b4_int_type_for([b4_defact])[ yydefact_[]; - - static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[]; - static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[]; - - /// What to do in a state. - /// \a yytable_[yypact_[s]]: what to do in state \a s. - /// - if positive, shift that token. - /// - if negative, reduce the rule which number is the opposite. - /// - if zero, do what YYDEFACT says. - static const ]b4_int_type_for([b4_table])[ yytable_[]; - static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_; - - static const ]b4_int_type_for([b4_check])[ yycheck_[]; - - /// For a state, its accessing symbol. - static const ]b4_int_type_for([b4_stos])[ yystos_[]; - - /// For a rule, its LHS. - static const ]b4_int_type_for([b4_r1])[ yyr1_[]; - /// For a rule, its RHS length. - static const ]b4_int_type_for([b4_r2])[ yyr2_[]; - -#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE - /// For a symbol, its name in clear. - static const char* const yytname_[]; -#endif - -#if YYERROR_VERBOSE - /// Convert the symbol name \a n to a form suitable for a diagnostic. - virtual std::string yytnamerr_ (const char *n); -#endif - -#if YYDEBUG - /// A type to store symbol numbers and -1. - typedef ]b4_int_type_for([b4_rhs])[ rhs_number_type; - /// A `-1'-separated list of the rules' RHS. - static const rhs_number_type yyrhs_[]; - /// For each rule, the index of the first RHS symbol in \a yyrhs_. - static const ]b4_int_type_for([b4_prhs])[ yyprhs_[]; - /// For each rule, its source line number. - static const ]b4_int_type_for([b4_rline])[ yyrline_[]; - /// For each scanner token number, its symbol number. - static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[]; - /// 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_; -#endif - - /// Convert a scanner token number \a t to a symbol number. - token_number_type yytranslate_ (int t); - - /// \brief Reclaim the memory associated to a symbol. - /// \param yymsg Why this token is reclaimed. - /// \param yytype The symbol type. - /// \param yyvaluep Its semantic value. - /// \param yylocationp Its location. - inline void yydestruct_ (const char* yymsg, - int yytype, - semantic_type* yyvaluep, - location_type* yylocationp); - - /// Pop \a n symbols the three stacks. - inline void yypop_ (unsigned int n = 1); - - /* Constants. */ - static const int yyeof_; - /* LAST_ -- Last index in TABLE_. */ - static const int yylast_; - static const int yynnts_; - static const int yyempty_; - static const int yyfinal_; - static const int yyterror_; - static const int yyerrcode_; - static const int yyntokens_; - static const unsigned int yyuser_token_number_max_; - static const token_number_type yyundef_token_; -]b4_parse_param_vars[ - }; -]b4_namespace_close[ - -]b4_percent_define_flag_if([[global_tokens_and_yystype]], -[b4_token_defines(b4_tokens) - -#ifndef YYSTYPE - /* Redirection for backward compatibility. */ -# define YYSTYPE b4_namespace_ref::b4_parser_class_name::semantic_type -#endif -]) -b4_percent_code_get([[provides]])[]dnl - -[#endif /* ! defined PARSER_HEADER_H */] -])dnl -@output(b4_parser_file_name@) -b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++], - [2002, 2003, 2004, 2005, 2006, 2007, 2008]) -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_defines_if([[ -#include "@basename(]b4_spec_defines_file[@)"]])[ - -/* User implementation prologue. */ -]b4_user_post_prologue -b4_percent_code_get[]dnl - -[#ifndef YY_ -# if 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 - -/* Suppress unused-variable warnings by "using" E. */ -#define YYUSE(e) ((void) (e)) - -/* Enable debugging if requested. */ -#if YYDEBUG - -/* A pseudo ostream that takes yydebug_ into account. */ -# define YYCDEBUG if (yydebug_) (*yycdebug_) - -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ -do { \ - if (yydebug_) \ - { \ - *yycdebug_ << Title << ' '; \ - yy_symbol_print_ ((Type), (Value), (Location)); \ - *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 /* !YYDEBUG */ - -# define YYCDEBUG if (false) std::cerr -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) -# define YY_REDUCE_PRINT(Rule) -# define YY_STACK_PRINT() - -#endif /* !YYDEBUG */ - -#define yyerrok (yyerrstatus_ = 0) -#define yyclearin (yychar = yyempty_) - -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab -#define YYRECOVERING() (!!yyerrstatus_) - -]b4_namespace_open[ -#if YYERROR_VERBOSE - - /* 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; - } - -#endif - - /// Build a parser object. - ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ - :])[ -#if YYDEBUG - ]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[ () - { - } - -#if YYDEBUG - /*--------------------------------. - | Print this symbol on YYOUTPUT. | - `--------------------------------*/ - - inline void - ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, - const semantic_type* yyvaluep, const location_type* yylocationp) - { - YYUSE (yylocationp); - YYUSE (yyvaluep); - switch (yytype) - { - ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl -[ default: - break; - } - } - - - void - ]b4_parser_class_name[::yy_symbol_print_ (int yytype, - const semantic_type* yyvaluep, const location_type* yylocationp) - { - *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm") - << ' ' << yytname_[yytype] << " (" - << *yylocationp << ": "; - yy_symbol_value_print_ (yytype, yyvaluep, yylocationp); - *yycdebug_ << ')'; - } -#endif - - void - ]b4_parser_class_name[::yydestruct_ (const char* yymsg, - int yytype, semantic_type* yyvaluep, location_type* yylocationp) - { - YYUSE (yylocationp); - YYUSE (yymsg); - YYUSE (yyvaluep); - - YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); - - switch (yytype) - { - ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ - default: - break; - } - } - - void - ]b4_parser_class_name[::yypop_ (unsigned int n) - { - yystate_stack_.pop (n); - yysemantic_stack_.pop (n); - yylocation_stack_.pop (n); - } - -#if YYDEBUG - 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 - - int - ]b4_parser_class_name[::parse () - { - /// Lookahead and lookahead in internal form. - int yychar = yyempty_; - int yytoken = 0; - - /* State. */ - int yyn; - int yylen = 0; - int yystate = 0; - - /* Error handling. */ - int yynerrs_ = 0; - int yyerrstatus_ = 0; - - /// Semantic value of the lookahead. - semantic_type yylval; - /// Location of the lookahead. - location_type yylloc; - /// The locations where the error started and ended. - location_type yyerror_range[2]; - - /// $$. - semantic_type yyval; - /// @@$. - location_type yyloc; - - int yyresult; - - YYCDEBUG << "Starting parse" << std::endl; - -]m4_ifdef([b4_initial_action], [ -m4_pushdef([b4_at_dollar], [yylloc])dnl -m4_pushdef([b4_dollar_dollar], [yylval])dnl - /* User initialization code. */ - b4_user_initial_action -m4_popdef([b4_dollar_dollar])dnl -m4_popdef([b4_at_dollar])])dnl - - [ /* Initialize the stacks. The initial state will be pushed in - yynewstate, since the latter expects the semantical and the - location values to have been already stored, initialize these - stacks with a primary value. */ - yystate_stack_ = state_stack_type (0); - yysemantic_stack_ = semantic_stack_type (0); - yylocation_stack_ = location_stack_type (0); - yysemantic_stack_.push (yylval); - yylocation_stack_.push (yylloc); - - /* New state. */ - yynewstate: - yystate_stack_.push (yystate); - YYCDEBUG << "Entering state " << yystate << std::endl; - - /* Accept? */ - if (yystate == yyfinal_) - goto yyacceptlab; - - goto yybackup; - - /* Backup. */ - yybackup: - - /* Try to take a decision without lookahead. */ - yyn = yypact_[yystate]; - if (yyn == yypact_ninf_) - goto yydefault; - - /* Read a lookahead token. */ - if (yychar == yyempty_) - { - YYCDEBUG << "Reading a token: "; - yychar = ]b4_c_function_call([yylex], [int], - [[YYSTYPE*], [&yylval]][]dnl -b4_locations_if([, [[location*], [&yylloc]]])dnl -m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; - } - - - /* Convert token to internal form. */ - if (yychar <= yyeof_) - { - yychar = yytoken = yyeof_; - YYCDEBUG << "Now at end of input." << std::endl; - } - 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) - goto yydefault; - - /* Reduce or error. */ - yyn = yytable_[yyn]; - if (yyn <= 0) - { - if (yyn == 0 || yyn == yytable_ninf_) - goto yyerrlab; - yyn = -yyn; - goto yyreduce; - } - - /* Shift the lookahead token. */ - YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); - - /* Discard the token being shifted. */ - yychar = yyempty_; - - yysemantic_stack_.push (yylval); - yylocation_stack_.push (yylloc); - - /* Count tokens shifted since error; after three, turn off error - status. */ - if (yyerrstatus_) - --yyerrstatus_; - - yystate = yyn; - 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: - yylen = yyr2_[yyn]; - /* 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) - yyval = yysemantic_stack_[yylen - 1]; - else - yyval = yysemantic_stack_[0]; - - { - slice slice (yylocation_stack_, yylen); - YYLLOC_DEFAULT (yyloc, slice, yylen); - } - YY_REDUCE_PRINT (yyn); - switch (yyn) - { - ]b4_user_actions[ - default: - break; - } - YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc); - - yypop_ (yylen); - yylen = 0; - YY_STACK_PRINT (); - - yysemantic_stack_.push (yyval); - yylocation_stack_.push (yyloc); - - /* Shift the result of the reduction. */ - yyn = yyr1_[yyn]; - yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0]; - if (0 <= yystate && yystate <= yylast_ - && yycheck_[yystate] == yystate_stack_[0]) - yystate = yytable_[yystate]; - else - yystate = yydefgoto_[yyn - yyntokens_]; - goto yynewstate; - - /*------------------------------------. - | yyerrlab -- here on detecting error | - `------------------------------------*/ - yyerrlab: - /* If not already recovering from an error, report this error. */ - if (!yyerrstatus_) - { - ++yynerrs_; - error (yylloc, yysyntax_error_ (yystate]dnl -b4_error_verbose_if([, yytoken])[)); - } - - yyerror_range[0] = 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, &yylloc); - 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 (false) - goto yyerrorlab; - - yyerror_range[0] = yylocation_stack_[yylen - 1]; - /* Do not reclaim the symbols of the rule which action triggered - this YYERROR. */ - yypop_ (yylen); - yylen = 0; - yystate = yystate_stack_[0]; - 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 (yyn != yypact_ninf_) - { - 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 (yystate_stack_.height () == 1) - YYABORT; - - yyerror_range[0] = yylocation_stack_[0]; - yydestruct_ ("Error: popping", - yystos_[yystate], - &yysemantic_stack_[0], &yylocation_stack_[0]); - yypop_ (); - yystate = yystate_stack_[0]; - YY_STACK_PRINT (); - } - - yyerror_range[1] = yylloc; - // Using YYLLOC is tempting, but would change the location of - // the lookahead. YYLOC is available though. - YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); - yysemantic_stack_.push (yylval); - yylocation_stack_.push (yyloc); - - /* Shift the error token. */ - YY_SYMBOL_PRINT ("Shifting", yystos_[yyn], - &yysemantic_stack_[0], &yylocation_stack_[0]); - - yystate = yyn; - goto yynewstate; - - /* Accept. */ - yyacceptlab: - yyresult = 0; - goto yyreturn; - - /* Abort. */ - yyabortlab: - yyresult = 1; - goto yyreturn; - - yyreturn: - if (yychar != yyempty_) - yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc); - - /* Do not reclaim the symbols of the rule which action triggered - this YYABORT or YYACCEPT. */ - yypop_ (yylen); - while (yystate_stack_.height () != 1) - { - yydestruct_ ("Cleanup: popping", - yystos_[yystate_stack_[0]], - &yysemantic_stack_[0], - &yylocation_stack_[0]); - yypop_ (); - } - - return yyresult; - } - - // Generate an error message. - std::string - ]b4_parser_class_name[::yysyntax_error_ (int yystate]dnl -b4_error_verbose_if([, int tok])[) - { - std::string res; - YYUSE (yystate); -#if YYERROR_VERBOSE - int yyn = yypact_[yystate]; - if (yypact_ninf_ < yyn && yyn <= yylast_) - { - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - 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_) - ++count; - - // FIXME: This method of building the message is not compatible - // with internationalization. It should work like yacc.c does it. - // That is, first build a string that looks like this: - // "syntax error, unexpected %s or %s or %s" - // Then, invoke YY_ on this string. - // Finally, use the string as a format to output - // yytname_[tok], etc. - // Until this gets fixed, this message appears in English only. - res = "syntax error, unexpected "; - res += yytnamerr_ (yytname_[tok]); - if (count < 5) - { - count = 0; - for (int x = yyxbegin; x < yyxend; ++x) - if (yycheck_[x + yyn] == x && x != yyterror_) - { - res += (!count++) ? ", expecting " : " or "; - res += yytnamerr_ (yytname_[x]); - } - } - } - else -#endif - res = YY_("syntax error"); - return res; - } - - - /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ - const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[; - const ]b4_int_type_for([b4_pact])[ - ]b4_parser_class_name[::yypact_[] = - { - ]b4_pact[ - }; - - /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE - doesn't specify something else to do. Zero means the default is an - error. */ - const ]b4_int_type_for([b4_defact])[ - ]b4_parser_class_name[::yydefact_[] = - { - ]b4_defact[ - }; - - /* YYPGOTO[NTERM-NUM]. */ - const ]b4_int_type_for([b4_pgoto])[ - ]b4_parser_class_name[::yypgoto_[] = - { - ]b4_pgoto[ - }; - - /* YYDEFGOTO[NTERM-NUM]. */ - const ]b4_int_type_for([b4_defgoto])[ - ]b4_parser_class_name[::yydefgoto_[] = - { - ]b4_defgoto[ - }; - - /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. */ - const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[; - const ]b4_int_type_for([b4_table])[ - ]b4_parser_class_name[::yytable_[] = - { - ]b4_table[ - }; - - /* YYCHECK. */ - const ]b4_int_type_for([b4_check])[ - ]b4_parser_class_name[::yycheck_[] = - { - ]b4_check[ - }; - - /* STOS_[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ - const ]b4_int_type_for([b4_stos])[ - ]b4_parser_class_name[::yystos_[] = - { - ]b4_stos[ - }; - -#if YYDEBUG - /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding - to YYLEX-NUM. */ - const ]b4_int_type_for([b4_toknum])[ - ]b4_parser_class_name[::yytoken_number_[] = - { - ]b4_toknum[ - }; -#endif - - /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ - const ]b4_int_type_for([b4_r1])[ - ]b4_parser_class_name[::yyr1_[] = - { - ]b4_r1[ - }; - - /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ - const ]b4_int_type_for([b4_r2])[ - ]b4_parser_class_name[::yyr2_[] = - { - ]b4_r2[ - }; - -#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE - /* 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[ - }; -#endif - -#if YYDEBUG - /* YYRHS -- A `-1'-separated list of the rules' RHS. */ - const ]b4_parser_class_name[::rhs_number_type - ]b4_parser_class_name[::yyrhs_[] = - { - ]b4_rhs[ - }; - - /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ - const ]b4_int_type_for([b4_prhs])[ - ]b4_parser_class_name[::yyprhs_[] = - { - ]b4_prhs[ - }; - - /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ - const ]b4_int_type_for([b4_rline])[ - ]b4_parser_class_name[::yyrline_[] = - { - ]b4_rline[ - }; - - // Print the state stack on the debug stream. - void - ]b4_parser_class_name[::yystack_print_ () - { - *yycdebug_ << "Stack now"; - for (state_stack_type::const_iterator i = yystate_stack_.begin (); - i != yystate_stack_.end (); ++i) - *yycdebug_ << ' ' << *i; - *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 << " =", - yyrhs_[yyprhs_[yyrule] + yyi], - &]b4_rhs_value(yynrhs, yyi + 1)[, - &]b4_rhs_location(yynrhs, yyi + 1)[); - } -#endif // YYDEBUG - - /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ - ]b4_parser_class_name[::token_number_type - ]b4_parser_class_name[::yytranslate_ (int t) - { - static - const token_number_type - translate_table[] = - { - ]b4_translate[ - }; - if ((unsigned int) t <= yyuser_token_number_max_) - return translate_table[t]; - else - return yyundef_token_; - } - - const int ]b4_parser_class_name[::yyeof_ = 0; - const int ]b4_parser_class_name[::yylast_ = ]b4_last[; - const int ]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[; - const int ]b4_parser_class_name[::yyempty_ = -2; - const int ]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[; - const int ]b4_parser_class_name[::yyterror_ = 1; - const int ]b4_parser_class_name[::yyerrcode_ = 256; - const int ]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[; - - const unsigned int ]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[; - const ]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[; - -]b4_namespace_close[ - -]b4_epilogue -dnl -@output(b4_dir_prefix[]stack.hh@) -b4_copyright([Stack handling for Bison parsers in C++], - [2002, 2003, 2004, 2005, 2006, 2007, 2008])[ - -#ifndef BISON_STACK_HH -# define BISON_STACK_HH - -#include - -]b4_namespace_open[ - 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_[i]; - } - - inline - const T& - operator [] (unsigned int i) const - { - return seq_[i]; - } - - inline - void - push (const T& t) - { - seq_.push_front (t); - } - - inline - void - pop (unsigned int n = 1) - { - for (; n; --n) - seq_.pop_front (); - } - - inline - unsigned int - height () const - { - return seq_.size (); - } - - inline const_iterator begin () const { return seq_.rbegin (); } - inline const_iterator end () const { return seq_.rend (); } - - private: - - 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_namespace_close[ - -#endif // not BISON_STACK_HH[]dnl -] -m4_divert_pop(0) diff --git a/gnuwin32/share/bison/lalr1.java b/gnuwin32/share/bison/lalr1.java deleted file mode 100644 index 7e220d98..00000000 --- a/gnuwin32/share/bison/lalr1.java +++ /dev/null @@ -1,880 +0,0 @@ -# Java skeleton for Bison -*- autoconf -*- - -# Copyright (C) 2007, 2008 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])]) -m4_ifval(m4_defn([b4_symbol_destructors]), - [b4_fatal([%s: %%destructor does not make sense in Java], [b4_skeleton])], - []) - -m4_divert_push(0)dnl -@output(b4_parser_file_name@) -b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java], - [2007, 2008]) - -b4_percent_define_ifdef([package], [package b4_percent_define_get([package]); -])[/* First part of user declarations. */ -]b4_pre_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_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[ - - /** True if verbose error messages are enabled. */ - public boolean errorVerbose = ]b4_flag_value([error_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 (); - } - } - -]]) - -[ /** Token returned by the scanner to signal the end of its input. */ - public static final int EOF = 0;] - -b4_token_enums(b4_tokens) - - b4_locations_if([[ - private ]b4_location_type[ yylloc (YYStack rhs, int n) - { - if (n > 0) - return new ]b4_location_type[ (rhs.locationAt (1).begin, rhs.locationAt (n).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 { - ]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 s The string for the error message. */ - void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s);] - } - - 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])[) { - 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]])[) { - 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; } - - private final int yylex () ]b4_maybe_throws([b4_lex_throws]) [{ - return yylexer.yylex (); - } - protected final void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s) { - yylexer.yyerror (]b4_locations_if([loc, ])[s); - } - - ]b4_locations_if([ - protected final void yyerror (String s) { - yylexer.yyerror ((]b4_location_type[)null, s); - } - protected final void yyerror (]b4_position_type[ loc, String s) { - yylexer.yyerror (new ]b4_location_type[ (loc), s); - }]) - - [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 () { - height--; - } - - 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, null); - ]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height, 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; - - /** - * Returned by a Bison action in order to start error recovery without - * printing an error message. */ - public static final int YYERROR = 2; - - /** - * Returned by a Bison action in order to print an error message and start - * error recovery. */ - public static final int YYFAIL = 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; - - private int yyerrstatus_ = 0; - - /** - * 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; - } - - /* 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 ()) + ")"); - } - - /** - * 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])])[ - { - /// 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 (); - - /* Error handling. */ - int yynerrs_ = 0; - ]b4_locations_if([/// The location where the error started. - ]b4_location_type[ yyerrloc = null; - - /// ]b4_location_type[ of the lookahead. - ]b4_location_type[ yylloc = new ]b4_location_type[ (null, null); - - /// @@$. - ]b4_location_type[ yyloc;]) - - /// Semantic value of the lookahead. - b4_yystype[ yylval = null; - - int yyresult; - - yycdebug ("Starting parse\n"); - yyerrstatus_ = 0; - -]m4_ifdef([b4_initial_action], [ -m4_pushdef([b4_at_dollar], [yylloc])dnl -m4_pushdef([b4_dollar_dollar], [yylval])dnl - /* User initialization code. */ - b4_user_initial_action -m4_popdef([b4_dollar_dollar])dnl -m4_popdef([b4_at_dollar])])dnl - - [ /* Initialize the stack. */ - yystack.push (yystate, yylval]b4_locations_if([, yylloc])[); - - int label = YYNEWSTATE; - 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_) - return true; - - /* Take a decision. First try without lookahead. */ - yyn = yypact_[yystate]; - if (yyn == yypact_ninf_) - { - label = YYDEFAULT; - break; - } - - /* Read a lookahead token. */ - if (yychar == yyempty_) - { - yycdebug ("Reading a token: "); - yychar = yylex ();] - b4_locations_if([[ - yylloc = new ]b4_location_type[(yylexer.getStartPos (), - yylexer.getEndPos ());]]) - yylval = yylexer.getLVal ();[ - } - - /* Convert token to internal form. */ - if (yychar <= EOF) - { - yychar = yytoken = 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 (yyn == 0 || yyn == yytable_ninf_) - label = YYFAIL; - 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 = YYFAIL; - 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 YYFAIL: - /* If not already recovering from an error, report this error. */ - if (yyerrstatus_ == 0) - { - ++yynerrs_; - 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 <= EOF) - { - /* Return failure if at end of input. */ - if (yychar == EOF) - 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 (yyn != yypact_ninf_) - { - 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 == 1) - return false; - - ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[ - yystack.pop (); - yystate = yystack.stateAt (0); - if (yydebug > 0) - yystack.print (yyDebugStream); - } - - ]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: - return true; - - /* Abort. */ - case YYABORT: - return false; - } - } - - // Generate an error message. - private String yysyntax_error (int yystate, int tok) - { - if (errorVerbose) - { - int yyn = yypact_[yystate]; - if (yypact_ninf_ < yyn && yyn <= yylast_) - { - StringBuffer res; - - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - 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_) - ++count; - - // FIXME: This method of building the message is not compatible - // with internationalization. - res = new StringBuffer ("syntax error, unexpected "); - res.append (yytnamerr_ (yytname_[tok])); - if (count < 5) - { - count = 0; - for (int x = yyxbegin; x < yyxend; ++x) - if (yycheck_[x + yyn] == x && x != yyterror_) - { - res.append (count++ == 0 ? ", expecting " : " or "); - res.append (yytnamerr_ (yytname_[x])); - } - } - return res.toString (); - } - } - - return "syntax error"; - } - - - /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ - private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[; - private static final ]b4_int_type_for([b4_pact])[ yypact_[] = - { - ]b4_pact[ - }; - - /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE - doesn't specify something else to do. Zero means the default is an - error. */ - private static final ]b4_int_type_for([b4_defact])[ yydefact_[] = - { - ]b4_defact[ - }; - - /* YYPGOTO[NTERM-NUM]. */ - private static final ]b4_int_type_for([b4_pgoto])[ yypgoto_[] = - { - ]b4_pgoto[ - }; - - /* YYDEFGOTO[NTERM-NUM]. */ - private static final ]b4_int_type_for([b4_defgoto])[ - yydefgoto_[] = - { - ]b4_defgoto[ - }; - - /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. */ - private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[; - private static final ]b4_int_type_for([b4_table])[ - yytable_[] = - { - ]b4_table[ - }; - - /* YYCHECK. */ - private static final ]b4_int_type_for([b4_check])[ - yycheck_[] = - { - ]b4_check[ - }; - - /* STOS_[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ - private static final ]b4_int_type_for([b4_stos])[ - yystos_[] = - { - ]b4_stos[ - }; - - /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding - to YYLEX-NUM. */ - private static final ]b4_int_type_for([b4_toknum])[ - yytoken_number_[] = - { - ]b4_toknum[ - }; - - /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ - private static final ]b4_int_type_for([b4_r1])[ - yyr1_[] = - { - ]b4_r1[ - }; - - /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ - private static final ]b4_int_type_for([b4_r2])[ - yyr2_[] = - { - ]b4_r2[ - }; - - /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - First, the terminals, then, starting at \a yyntokens_, nonterminals. */ - private static final String yytname_[] = - { - ]b4_tname[ - }; - - /* YYRHS -- A `-1'-separated list of the rules' RHS. */ - private static final ]b4_int_type_for([b4_rhs])[ yyrhs_[] = - { - ]b4_rhs[ - }; - - /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ - private static final ]b4_int_type_for([b4_prhs])[ yyprhs_[] = - { - ]b4_prhs[ - }; - - /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ - private static final ]b4_int_type_for([b4_rline])[ yyrline_[] = - { - ]b4_rline[ - }; - - // 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) + " =", - yyrhs_[yyprhs_[yyrule] + yyi], - ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([, - b4_rhs_location(yynrhs, yyi + 1)])[); - } - - /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ - private static final ]b4_int_type_for([b4_translate])[ yytranslate_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 -m4_divert_pop(0)dnl diff --git a/gnuwin32/share/bison/location.cc b/gnuwin32/share/bison/location.cc deleted file mode 100644 index 4b79069f..00000000 --- a/gnuwin32/share/bison/location.cc +++ /dev/null @@ -1,275 +0,0 @@ -# C++ skeleton for Bison - -# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 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 . - -# We do want M4 expansion after # for CPP macros. -m4_changecom() -m4_divert_push(0)dnl -@output(b4_dir_prefix[]position.hh@) -b4_copyright([Positions for Bison parsers in C++], - [2002, 2003, 2004, 2005, 2006])[ - -/** - ** \file position.hh - ** Define the ]b4_namespace_ref[::position class. - */ - -#ifndef BISON_POSITION_HH -# define BISON_POSITION_HH - -# include -# include -# include - -]b4_namespace_open[ - /// Abstract a position. - class position - { - public: -]m4_ifdef([b4_location_constructors], [ - /// Construct a position. - position () - : filename (0), line (]b4_location_initial_line[), column (]b4_location_initial_column[) - { - } - -])[ - /// Initialization. - inline void initialize (]b4_percent_define_get([[filename_type]])[* fn) - { - filename = fn; - line = ]b4_location_initial_line[; - column = ]b4_location_initial_column[; - } - - /** \name Line and Column related manipulators - ** \{ */ - public: - /// (line related) Advance to the COUNT next lines. - inline void lines (int count = 1) - { - column = ]b4_location_initial_column[; - line += count; - } - - /// (column related) Advance to the COUNT next columns. - inline void columns (int count = 1) - { - column = std::max (]b4_location_initial_column[u, column + count); - } - /** \} */ - - public: - /// 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; - }; - - /// Add and assign a position. - inline const position& - operator+= (position& res, const int width) - { - res.columns (width); - return res; - } - - /// Add two position objects. - inline const position - operator+ (const position& begin, const int width) - { - position res = begin; - return res += width; - } - - /// Add and assign a position. - inline const position& - operator-= (position& res, const int width) - { - return res += -width; - } - - /// Add two position objects. - inline const position - operator- (const position& begin, const int width) - { - return begin + -width; - } -]b4_percent_define_flag_if([[define_location_comparison]], [[ - /// Compare two position objects. - inline bool - operator== (const position& pos1, const position& pos2) - { - return - (pos1.filename == pos2.filename - || pos1.filename && pos2.filename && *pos1.filename == *pos2.filename) - && pos1.line == pos2.line && pos1.column == pos2.column; - } - - /// 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 - */ - inline std::ostream& - operator<< (std::ostream& ostr, const position& pos) - { - if (pos.filename) - ostr << *pos.filename << ':'; - return ostr << pos.line << '.' << pos.column; - } - -]b4_namespace_close[ -#endif // not BISON_POSITION_HH] -@output(b4_dir_prefix[]location.hh@) -b4_copyright([Locations for Bison parsers in C++], - [2002, 2003, 2004, 2005, 2006])[ - -/** - ** \file location.hh - ** Define the ]b4_namespace_ref[::location class. - */ - -#ifndef BISON_LOCATION_HH -# define BISON_LOCATION_HH - -# include -# include -# include "position.hh" - -]b4_namespace_open[ - - /// Abstract a location. - class location - { - public: -]m4_ifdef([b4_location_constructors], [ - /// Construct a location. - location () - : begin (), end () - { - } - -])[ - /// Initialization. - inline void initialize (]b4_percent_define_get([[filename_type]])[* fn) - { - begin.initialize (fn); - end = begin; - } - - /** \name Line and Column related manipulators - ** \{ */ - public: - /// Reset initial location to final location. - inline void step () - { - begin = end; - } - - /// Extend the current location to the COUNT next columns. - inline void columns (unsigned int count = 1) - { - end += count; - } - - /// Extend the current location to the COUNT next lines. - inline void lines (unsigned 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 const location operator+ (const location& begin, const location& end) - { - location res = begin; - res.end = end.end; - return res; - } - - /// Add two location objects. - inline const location operator+ (const location& begin, unsigned int width) - { - location res = begin; - res.columns (width); - return res; - } - - /// Add and assign a location. - inline location& operator+= (location& res, unsigned int width) - { - res.columns (width); - return res; - } -]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. - */ - inline std::ostream& operator<< (std::ostream& ostr, const location& loc) - { - position last = loc.end - 1; - ostr << loc.begin; - if (last.filename - && (!loc.begin.filename - || *loc.begin.filename != *last.filename)) - ostr << '-' << last; - else if (loc.begin.line != last.line) - ostr << '-' << last.line << '.' << last.column; - else if (loc.begin.column != last.column) - ostr << '-' << last.column; - return ostr; - } - -]b4_namespace_close[ - -#endif // not BISON_LOCATION_HH] -m4_divert_pop(0) -m4_changecom([#]) diff --git a/gnuwin32/share/bison/m4sugar/foreach.m4 b/gnuwin32/share/bison/m4sugar/foreach.m4 deleted file mode 100644 index cd4d1fc8..00000000 --- a/gnuwin32/share/bison/m4sugar/foreach.m4 +++ /dev/null @@ -1,400 +0,0 @@ -# -*- 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 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 . - -# As a special exception, the Free Software Foundation gives unlimited -# permission to copy, distribute and modify the configure scripts that -# are the output of Autoconf. You need not follow the terms of the GNU -# General Public License when using or distributing such scripts, even -# though portions of the text of Autoconf appear in them. The GNU -# General Public License (GPL) does govern all other use of the material -# that constitutes the Autoconf program. -# -# Certain portions of the Autoconf source text are designed to be copied -# (in certain cases, depending on the input) into the output of -# Autoconf. We call these the "data" portions. The rest of the Autoconf -# source text consists of comments plus executable code that decides which -# of the data portions to output in any given case. We call these -# comments and executable code the "non-data" portions. Autoconf never -# copies any of the non-data portions into its output. -# -# This special exception to the GPL applies to versions of Autoconf -# released by the Free Software Foundation. When you make and -# distribute a modified version of Autoconf, you may extend this special -# exception to the GPL to apply to your modified version as well, *unless* -# your modified version has the potential to copy into its output some -# of the text that was the non-data portion of the version that you started -# with. (In other words, unless your change moves or copies text from -# the non-data portions to the data portions.) If your modification has -# such potential, you must delete any notice of this special exception -# to the GPL from your modified version. -# -# 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(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 version minimizes the number of times that $@ is evaluated by -# using m4_for to generate a boilerplate into VARIABLE 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]) defines i to be -# m4_define([$1],[$3])$2[]m4_define([$1],[$4])$2[]m4_popdef([i]) -# then calls i([i],[i],[1],[2]). -m4_define([m4_foreach], -[m4_if([$2], [], [], [_$0([$1], [$3], $2)])]) - -m4_define([_m4_foreach], -[m4_define([$1], m4_pushdef([$1])_m4_for([$1], [3], [$#], [1], - [$0_([1], [2], _m4_defn([$1]))])[m4_popdef([$1])])m4_indir([$1], $@)]) - -m4_define([_m4_foreach_], -[[m4_define([$$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([_m4_count], [2], m4_decr([$#]), [2], - [_$0_([1], _m4_count, m4_incr(_m4_count))])[_m4_popdef( - [_$0])]m4_dquote($m4_eval([($# + 1) & ~1]))[)])_$0($@)])]) - -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_define([_m4_b], m4_pushdef([_m4_b])[m4_define([_m4_b], - _m4_defn([_$0]))]_m4_for([_m4_b], [3], m4_eval([($# + 1) / 2 * 2 - 1]), - [2], [_$0_([1], m4_decr(_m4_b), _m4_b)])[_m4_b([], [],]m4_dquote( - [$]m4_incr(_m4_b))[_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_], -[[_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_define([_m4_c], m4_pushdef([_m4_c])[m4_define([_m4_c], - _m4_defn([m4_unquote]))]_m4_for([_m4_c], [2], m4_eval([$# / 3 * 3 - 1]), [3], - [$0_(m4_decr(_m4_c), _m4_c, m4_incr(_m4_c))])[_m4_c(]m4_dquote(m4_dquote( - [$]m4_eval([$# / 3 * 3 + 1])))[_m4_popdef([_m4_c]))])m4_unquote(_m4_c($@))]) - -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_define([_m4_p], m4_pushdef([_m4_p])[m4_define([_m4_p], - ]m4_dquote([$]1)[)]_m4_for([_m4_p], [3], [$#], [2], [$0_(m4_decr(_m4_p), - _m4_p)])[m4_unquote(_m4_defn([_m4_p])_m4_popdef([_m4_p]))])_m4_p($@)]) - -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_define([_m4_s], - m4_pushdef([_m4_s])_m4_for([_m4_s], m4_eval([$1 + 2]), [$#], [1], - [[,]m4_dquote([$]_m4_s)])[_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_define([_$0], m4_pushdef([_$0])_m4_for([_$0], [1], [$#], [1], - [$_$0[[]]])[_m4_popdef([_$0])])_$0($@)])]) - -# m4_dquote_elt(ARGS) -# ------------------- -# Return ARGS as an unquoted list of double-quoted arguments. -# -# m4_foreach to the rescue. It's easier to shift off the leading comma. -m4_define([m4_dquote_elt], -[m4_shift(m4_foreach([_m4_elt], [$@], [,m4_dquote(_m4_defn([_m4_elt]))]))]) - -# 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_define([_m4_r], m4_dquote([$$#])m4_pushdef([_m4_r])_m4_for([_m4_r], - m4_decr([$#]), [1], [-1], - [[, ]m4_dquote([$]_m4_r)])[_m4_popdef([_m4_r])])_m4_r($@)])]) - - -# m4_map(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. -# -# m4_map/m4_map_sep only execute once; the speedup comes in fixing -# _m4_map. The mismatch in () is intentional, since $1 supplies the -# opening `(' (but it sure looks odd!). Build the temporary _m4_m: -# $1, [$3])$1, [$4])...$1, [$m])_m4_popdef([_m4_m]) -m4_define([_m4_map], -[m4_if([$#], [2], [], - [m4_define([_m4_m], m4_pushdef([_m4_m])_m4_for([_m4_m], [3], [$#], [1], - [$0_([1], _m4_m)])[_m4_popdef([_m4_m])])_m4_m($@)])]) - -m4_define([_m4_map_], -[[$$1, [$$2])]]) - -# m4_transform(EXPRESSION, ARG...) -# -------------------------------- -# Expand EXPRESSION([ARG]) for each argument. More efficient than -# m4_foreach([var], [ARG...], [EXPRESSION(m4_defn([var]))]) -# -# Invoke the temporary macro _m4_transform, defined as: -# $1([$2])[]$1([$3])[]...$1([$m])[]_m4_popdef([_m4_transform]) -m4_define([m4_transform], -[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], - [$#], [1], [], - [m4_define([_$0], m4_pushdef([_$0])_m4_for([_$0], [2], [$#], [1], - [_$0_([1], _$0)])[_m4_popdef([_$0])])_$0($@)])]) - -m4_define([_m4_transform_], -[[$$1([$$2])[]]]) - -# m4_transform_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_transform_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_transform_pair]) -m4_define([m4_transform_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_define([_$0], m4_pushdef([_$0])_m4_for([_$0], [3], - m4_eval([$# / 2 * 2 - 1]), [2], [_$0_([1], _$0, m4_incr(_$0))])_$0_end( - [1], [2], [$#])[_m4_popdef([_$0])])_$0($@)])]) - -m4_define([_m4_transform_pair_], -[[$$1([$$2], [$$3])[]]]) - -m4_define([_m4_transform_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([_m4_arg], [m4_shift($@)], - [m4_ifset([_m4_arg], [_m4_sep([$1])_m4_defn([_m4_arg])])])]dnl -[_m4_popdef([_m4_sep])]) - -# 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([_m4_arg], [m4_shift2($@)], - [[$1]_m4_defn([_m4_arg])])])]) - -# 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], [_m4_size])) -# then calls _m4_cmp([1+0], [0], [1], [2+0]) -m4_define([_m4_list_cmp_raw], -[m4_if([$1], [$2], 0, [m4_pushdef( - [_m4_size])_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_size], m4_incr([$1]), [$2], [1], [,0])])]) - -m4_define([_m4_list_cmp], -[m4_define([_m4_size], m4_eval([$# >> 1]))]dnl -[m4_define([_m4_cmp], m4_pushdef([_m4_cmp])[m4_if(]_m4_for([_m4_cmp], - [1], _m4_size, [1], [$0_(_m4_cmp, m4_eval(_m4_cmp + _m4_size))])[ - [0]_m4_popdef([_m4_cmp], [_m4_size]))])_m4_cmp($@)]) - -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_arg], [m4_shift2($@)], - [m4_define([_m4_best], $1(_m4_best, _m4_defn([_m4_arg])))])]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_arg], [m4_shift($@)], - m4_ifdef([_m4_set_cleanup($1)], - [[m4_set_add([$1], _m4_defn([_m4_arg]))]], - [[m4_ifdef([_m4_set([$1],]_m4_defn([_m4_arg])[)], [], - [m4_define([_m4_set([$1],]_m4_defn([_m4_arg])[)], - [1])m4_pushdef([_m4_set([$1])], - _m4_defn([_m4_arg]))-])]])))))])]) diff --git a/gnuwin32/share/bison/m4sugar/m4sugar.m4 b/gnuwin32/share/bison/m4sugar/m4sugar.m4 deleted file mode 100644 index 6fbd3431..00000000 --- a/gnuwin32/share/bison/m4sugar/m4sugar.m4 +++ /dev/null @@ -1,2789 +0,0 @@ -divert(-1)# -*- Autoconf -*- -# This file is part of Autoconf. -# Base M4 layer. -# Requires GNU M4. -# -# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, -# 2008 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 . - -# As a special exception, the Free Software Foundation gives unlimited -# permission to copy, distribute and modify the configure scripts that -# are the output of Autoconf. You need not follow the terms of the GNU -# General Public License when using or distributing such scripts, even -# though portions of the text of Autoconf appear in them. The GNU -# General Public License (GPL) does govern all other use of the material -# that constitutes the Autoconf program. -# -# Certain portions of the Autoconf source text are designed to be copied -# (in certain cases, depending on the input) into the output of -# Autoconf. We call these the "data" portions. The rest of the Autoconf -# source text consists of comments plus executable code that decides which -# of the data portions to output in any given case. We call these -# comments and executable code the "non-data" portions. Autoconf never -# copies any of the non-data portions into its output. -# -# This special exception to the GPL applies to versions of Autoconf -# released by the Free Software Foundation. When you make and -# distribute a modified version of Autoconf, you may extend this special -# exception to the GPL to apply to your modified version as well, *unless* -# your modified version has the potential to copy into its output some -# of the text that was the non-data portion of the version that you started -# with. (In other words, unless your change moves or copies text from -# the non-data portions to the data portions.) If your modification has -# such potential, you must delete any notice of this special exception -# to the GPL from your modified version. -# -# 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'. -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_undefine([divert]) -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_undefine([undivert]) - - -## ------------------- ## -## 2. Error messages. ## -## ------------------- ## - - -# m4_location -# ----------- -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])dnl -m4_expansion_stack_dump()dnl -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. -# The STACK-TRACE is a \n-separated list of "LOCATION: MESSAGE". -# -# 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_defn([m4_expansion_stack]) -m4_location[: the top level]]))dnl -]) - - - -## ------------------- ## -## 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_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_car(LIST) -# m4_cdr(LIST) -# ------------ -# Manipulate m4 lists. -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(LIST) -# ------------- -# Like m4_cdr, except include a leading comma unless only one element -# 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_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) -# ---------------------- -# Returns EXP1 if non empty, otherwise EXP2. -# -# This macro 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_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_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_define([m4_defn], -[m4_if([$#], [0], [[$0]], - [$#], [1], [m4_ifdef([$1], [_m4_defn([$1])], - [m4_fatal([$0: undefined macro: $1])])], - [m4_foreach([_m4_macro], [$@], [$0(_m4_defn([_m4_macro]))])])]) - - -# _m4_dumpdefs_up(NAME) -# --------------------- -m4_define([_m4_dumpdefs_up], -[m4_ifdef([$1], - [m4_pushdef([_m4_dumpdefs], _m4_defn([$1]))dnl -m4_dumpdef([$1])dnl -_m4_popdef([$1])dnl -_m4_dumpdefs_up([$1])])]) - - -# _m4_dumpdefs_down(NAME) -# ----------------------- -m4_define([_m4_dumpdefs_down], -[m4_ifdef([_m4_dumpdefs], - [m4_pushdef([$1], _m4_defn([_m4_dumpdefs]))dnl -_m4_popdef([_m4_dumpdefs])dnl -_m4_dumpdefs_down([$1])])]) - - -# m4_dumpdefs(NAME) -# ----------------- -# Similar to `m4_dumpdef(NAME)', but if NAME was m4_pushdef'ed, display its -# value stack (most recent displayed first). -m4_define([m4_dumpdefs], -[_m4_dumpdefs_up([$1])dnl -_m4_dumpdefs_down([$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_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_define([m4_popdef], -[m4_if([$#], [0], [[$0]], - [$#], [1], [m4_ifdef([$1], [_m4_popdef([$1])], - [m4_fatal([$0: undefined macro: $1])])], - [m4_foreach([_m4_macro], [$@], [$0(_m4_defn([_m4_macro]))])])]) - - -# 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_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_define([m4_undefine], -[m4_if([$#], [0], [[$0]], - [$#], [1], [m4_ifdef([$1], [_m4_undefine([$1])], - [m4_fatal([$0: undefined macro: $1])])], - [m4_foreach([_m4_macro], [$@], [$0(_m4_defn([_m4_macro]))])])]) - -# _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_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) -# -------------- -# Return the expansion of ARG as a single string. Unlike m4_quote($1), this -# correctly preserves whitespace following single-quoted commas that appeared -# within ARG. -# -# 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). The input -# is not likely to have unbalanced -=<{(/)}>=- quotes, and it is possible -# to have unbalanced (), provided it was specified with proper [] quotes. -# -# Exploit that extra () will group unquoted commas and the following -# whitespace, then convert () to []. m4_bpatsubst can't handle newlines -# inside $1, and m4_substr strips quoting. So we (ab)use m4_changequote. -m4_define([m4_expand], [_$0(-=<{($1)}>=-)]) -m4_define([_m4_expand], -[m4_changequote([-=<{(], [)}>=-])$1m4_changequote([, ])]) - - -# 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. Amongst 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. -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([$4], - 1)))m4_assert(_m4_step > 0)_$0([$1], _m4_defn([$1]), - m4_eval((([$3]) - ([$2])) / _m4_step * _m4_step + ([$2])), - _m4_step, [$5])], - [m4_eval(([$3]) < ([$2]))], 1, - [m4_pushdef([_m4_step], m4_eval(m4_default([$4], - -1)))m4_assert(_m4_step < 0)_$0([$1], _m4_defn([$1]), - m4_eval((([$2]) - ([$3])) / -(_m4_step) * _m4_step + ([$2])), - _m4_step, [$5])], - [m4_pushdef([_m4_step])$5])[]]dnl -[m4_popdef([_m4_step], [$1])]) - - -# _m4_for(VARIABLE, COUNT, LAST, STEP, EXPRESSION) -# ------------------------------------------------ -# Core of the loop, no consistency checks, all arguments are plain -# numbers. Define VARIABLE to COUNT, expand EXPRESSION, then alter -# COUNT by STEP and iterate if COUNT is not LAST. -m4_define([_m4_for], -[m4_define([$1], [$2])$5[]m4_if([$2], [$3], [], - [$0([$1], m4_eval([$2 + $4]), [$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. -# -# Please keep foreach.m4 in sync with any adjustments made here. -m4_define([m4_foreach], -[m4_if([$2], [], [], - [m4_pushdef([$1])_$0([$1], [$3], [], $2)m4_popdef([$1])])]) - -m4_define([_m4_foreach], -[m4_if([$#], [3], [], - [m4_define([$1], [$4])$2[]$0([$1], [$2], m4_shift3($@))])]) - - -# m4_foreach_w(VARIABLE, LIST, EXPRESSION) -# ---------------------------------------- -# -# Like m4_foreach, but the list is whitespace separated. -# -# This macro is robust to active symbols: -# m4_foreach_w([Var], [ active -# b act\ -# ive ], [-Var-])end -# => -active--b--active-end -# -m4_define([m4_foreach_w], -[m4_foreach([$1], m4_split(m4_normalize([$2]), [ ]), [$3])]) - - -# 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, ignore the second argument, and use m4_shift2 to -# detect the end of recursion. The mismatch in () is intentional; see -# _m4_map. For m4_map, an empty list behaves like an empty sublist -# and gets ignored; for m4_mapall, we must special-case the empty -# list. -# -# Please keep foreach.m4 in sync with any adjustments made here. -m4_define([m4_map], -[_m4_map([_m4_apply([$1]], [], $2)]) - -m4_define([m4_mapall], -[m4_if([$2], [], [], - [_m4_map([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_map([_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_map([m4_apply([$2[]$1]], m4_shift2($@))]) - -# _m4_map(PREFIX, IGNORED, SUBLIST, ...) -# -------------------------------------- -# Common implementation for all four m4_map variants. The mismatch in -# the number of () is intentional. PREFIX must supply a form of -# m4_apply, the open `(', and the MACRO to be applied. Each iteration -# then appends `,', the current SUBLIST and the closing `)', then -# recurses to the next SUBLIST. IGNORED is an aid to ending recursion -# efficiently. -# -# Please keep foreach.m4 in sync with any adjustments made here. -m4_define([_m4_map], -[m4_if([$#], [2], [], - [$1, [$3])$0([$1], m4_shift2($@))])]) - -# m4_transform(EXPRESSION, ARG...) -# -------------------------------- -# Expand EXPRESSION([ARG]) for each argument. More efficient than -# m4_foreach([var], [ARG...], [EXPRESSION(m4_defn([var]))]) -# -# Please keep foreach.m4 in sync with any adjustments made here. -m4_define([m4_transform], -[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], - [$#], [1], [], - [$#], [2], [$1([$2])[]], - [$1([$2])[]$0([$1], m4_shift2($@))])]) - - -# m4_transform_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_transform_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_transform_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($@)))])]) - - -## --------------------------- ## -## 9. More diversion support. ## -## --------------------------- ## - - -# _m4_divert(DIVERSION-NAME or NUMBER) -# ------------------------------------ -# If DIVERSION-NAME is the name of a diversion, return its number, -# otherwise if it is a NUMBER return it. -m4_define([_m4_divert], -[m4_ifdef([_m4_divert($1)], - [m4_indir([_m4_divert($1)])], - [$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_n_stack -# ------------------ -# Print m4_divert_stack with newline prepended, if it's nonempty. -m4_define([_m4_divert_n_stack], -[m4_ifdef([m4_divert_stack], [ -_m4_defn([m4_divert_stack])])]) - - -# m4_divert(DIVERSION-NAME) -# ------------------------- -# Change the diversion stream to DIVERSION-NAME. -m4_define([m4_divert], -[m4_define([m4_divert_stack], m4_location[: $0: $1]_m4_divert_n_stack)]dnl -[m4_builtin([divert], _m4_divert([$1]))]) - - -# m4_divert_push(DIVERSION-NAME) -# ------------------------------ -# Change the diversion stream to DIVERSION-NAME, while stacking old values. -m4_define([m4_divert_push], -[m4_pushdef([m4_divert_stack], m4_location[: $0: $1]_m4_divert_n_stack)]dnl -[m4_pushdef([_m4_divert_diversion], [$1])]dnl -[m4_builtin([divert], _m4_divert([$1]))]) - - -# 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_ifndef([_m4_divert_diversion], - [m4_fatal([too many m4_divert_pop])])]dnl -[m4_if([$1], [], [], - [$1], _m4_defn([_m4_divert_diversion]), [], - [m4_fatal([$0($1): diversion mismatch: ]_m4_divert_n_stack)])]dnl -[_m4_popdef([m4_divert_stack], [_m4_divert_diversion])]dnl -[m4_builtin([divert], - m4_ifdef([_m4_divert_diversion], - [_m4_divert(_m4_defn([_m4_divert_diversion]))], - -1))]) - - -# 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_undivert(DIVERSION-NAME) -# --------------------------- -# Undivert DIVERSION-NAME. Unlike the M4 version, this only takes a single -# diversion identifier, and should not be used to undivert files. -m4_define([m4_undivert], -[m4_builtin([undivert], _m4_divert([$1]))]) - - -## --------------------------------------------- ## -## 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 AC_PROVIDE's the macro, 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 two ideas, (i) using diversions to -# prepare the expansion of the macro and its dependencies (by Franc,ois -# Pinard), and (ii) expand the most recently m4_require'd macros _after_ -# the previous macros (by Axel Thimm). -# -# -# 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...REQUIRE([TEST2])1]) -# | m4_defun([TEST2], [Test...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], [REQUIRE([TEST2a])REQUIRE([TEST2b])]) -# | m4_defun([TEST2a], []) -# | m4_defun([TEST2b], [REQUIRE([TEST3])]) -# | m4_defun([TEST3], [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 AC_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 evolved. 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 implements 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 |- -# Than 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 |- -# Than 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 |- -# -# -# 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. -# -# The scheme is simplistic: each time we enter an m4_defun'd macros, -# we prepend its name in m4_expansion_stack, and when we exit the -# macro, we remove it (thanks to pushdef/popdef). -# -# 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_push(TEXT) -# ----------------------------- -m4_define([m4_expansion_stack_push], -[m4_pushdef([m4_expansion_stack], - [$1]m4_ifdef([m4_expansion_stack], [ -_m4_defn([m4_expansion_stack])]))]) - - -# m4_expansion_stack_pop -# ---------------------- -m4_define([m4_expansion_stack_pop], -[m4_popdef([m4_expansion_stack])]) - - -# m4_expansion_stack_dump -# ----------------------- -# Dump the expansion stack. -m4_define([m4_expansion_stack_dump], -[m4_ifdef([m4_expansion_stack], - [m4_errprintn(_m4_defn([m4_expansion_stack]))])dnl -m4_errprintn(m4_location[: the top level])]) - - -# _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_do([[m4_ifdef([m4_expansion_stack], [], [_m4_defun_pro_outer[]])]], - [[m4_expansion_stack_push(_m4_defn( - [m4_location($1)])[: $1 is expanded from...])]], - [[m4_pushdef([_m4_expanding($1)])]])) - -m4_define([_m4_defun_pro_outer], -[m4_copy([_m4_divert_diversion], [_m4_divert_dump])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_do([[_m4_popdef([_m4_expanding($1)])]], - [[m4_expansion_stack_pop()]], - [[m4_ifdef([m4_expansion_stack], [], [_m4_defun_epi_outer[]])]], - [[m4_provide([$1])]])) - -m4_define([_m4_defun_epi_outer], -[_m4_undefine([_m4_divert_dump])m4_divert_pop([GROW])m4_undivert([GROW])]) - - -# m4_defun(NAME, EXPANSION) -# ------------------------- -# Define a macro which automatically provides itself. Add machinery -# so the macro automatically switches expansion to the diversion -# stack if it is not already using it. 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. -m4_define([m4_defun], -[m4_define([m4_location($1)], m4_location)dnl -m4_define([$1], - [_m4_defun_pro([$1])$2[]_m4_defun_epi([$1])])]) - - -# m4_defun_once(NAME, EXPANSION) -# ------------------------------ -# As m4_defun, but issues the EXPANSION only once, and warns if used -# several times. -m4_define([m4_defun_once], -[m4_define([m4_location($1)], m4_location)dnl -m4_define([$1], - [m4_provide_if([$1], - [m4_warn([syntax], [$1 invoked multiple times])], - [_m4_defun_pro([$1])$2[]_m4_defun_epi([$1])])])]) - - -# 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. 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(limits.h)], [AC_CHECK_HEADERS(limits.h)]) -# which is just the same as -# m4_require([AC_PROG_CC]) -# m4_require([AC_CHECK_HEADERS(limits.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_do([[m4_ifdef([_m4_expanding($1)], - [m4_fatal([$0: circular dependency of $1])])]], - [[m4_ifdef([_m4_divert_dump], [], - [m4_fatal([$0($1): cannot be used outside of an ]dnl -m4_bmatch([$0], [^AC_], [[AC_DEFUN]], [[m4_defun]])['d macro])])]], - [[m4_provide_if([$1], - [], - [_m4_require_call([$1], [$2])])]])) - - -# _m4_require_call(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK]) -# ----------------------------------------------------------------- -# If m4_require decides to expand the body, it calls this macro. -# -# 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_call], -m4_do([[m4_define([_m4_divert_grow], m4_decr(_m4_divert_grow))]], - [[m4_divert_push(_m4_divert_grow)]], - [[m4_default([$2], [$1]) -m4_provide_if([$1], - [], - [m4_warn([syntax], - [$1 is m4_require'd but not m4_defun'd])])]], - [[m4_divert(_m4_defn([_m4_divert_dump]))]], - [[m4_undivert(_m4_divert_grow)]], - [[m4_divert_pop(_m4_divert_grow)]], - [[m4_define([_m4_divert_grow], m4_incr(_m4_divert_grow))]])) - - -# _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_ifval([$2], [[$2]], [[$1]]), - [], - [m4_provide(m4_ifval([$2], [[$2]], [[$1]]))[]$1])]) - - -# m4_provide(MACRO-NAME) -# ---------------------- -m4_define([m4_provide], -[m4_define([m4_provide($1)])]) - - -# 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. -# -# 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 -# ---------- -# Expands to a newline. Exists for formatting reasons. -m4_define([m4_newline], [ -]) - - -# 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($@)])], - [$2], [], [_$0([$1], [[ ]+])], - [_$0($@)])]) - -m4_define([_m4_split], -[m4_changequote([-=<{(],[)}>=-])]dnl -[[m4_bpatsubst(-=<{(-=<{($1)}>=-)}>=-, -=<{($2)}>=-, - -=<{(], [)}>=-)]m4_changequote([, ])]) - - - -# 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 -# -# In order to have the correct number of SEPARATORs, we use a temporary -# variable that redefines itself after the first use. We must use defn -# rather than overquoting in case PREFIX or SUFFIX contains $1, but use -# _m4_defn for speed. Likewise, we compute the m4_shift3 only once, -# rather than in each iteration of the outer m4_foreach. -m4_define([m4_combine], -[m4_if(m4_eval([$# > 3]), [1], - [m4_pushdef([m4_Separator], [m4_define([m4_Separator], - _m4_defn([m4_echo]))])]]dnl -[[m4_foreach([m4_Prefix], [$2], - [m4_foreach([m4_Suffix], ]m4_dquote(m4_dquote(m4_shift3($@)))[, - [m4_Separator([$1])[]_m4_defn([m4_Prefix])[$3]_m4_defn( - [m4_Suffix])])])]]dnl -[[_m4_popdef([m4_Separator])])]) - - -# 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_foreach_w([m4_Word], [$2], - [_m4_append_uniq([$1], _m4_defn([m4_Word]), [ ])])]) - - -# 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. -# -# 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([$1], [$2], m4_if([$3], [], [[$2]], [[$3]]), - m4_if([$4], [], [79], [[$4]]))]) -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 curser 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_foreach_w([m4_Word], [$1], - [m4_define([m4_Cursor], - m4_eval(m4_Cursor + m4_qlen(_m4_defn([m4_Word])) - + 1))m4_if(m4_eval(m4_Cursor > ([$4])), - [1], [m4_define([m4_Cursor], - m4_eval(m4_Indent + m4_qlen(_m4_defn([m4_Word])) + 1)) -[$2]], - [m4_Separator[]])_m4_defn([m4_Word])])]], -dnl finally, clean up the local variabls -[[_m4_popdef([m4_Separator], [m4_Cursor], [m4_Indent])]])) - - -# m4_text_box(MESSAGE, [FRAME-CHARACTER = `-']) -# --------------------------------------------- -# Turn MESSAGE into: -# ## ------- ## -# ## MESSAGE ## -# ## ------- ## -# using FRAME-CHARACTER in the border. -m4_define([m4_text_box], -[m4_pushdef([m4_Border], - m4_translit(m4_format([%*s], m4_qlen(m4_expand([$1])), []), - [ ], m4_if([$2], [], [[-]], [[$2]])))dnl -@%:@@%:@ m4_Border @%:@@%:@ -@%:@@%:@ $1 @%:@@%:@ -@%:@@%:@ m4_Border @%:@@%:@_m4_popdef([m4_Border])dnl -]) - - -# m4_qlen(STRING) -# --------------- -# Expands to the length of STRING after autom4te converts all quadrigraphs. -# -# Avoid bpatsubsts for the common case of no quadrigraphs. -m4_define([m4_qlen], -[m4_if(m4_index([$1], [@]), [-1], [m4_len([$1])], - [m4_len(m4_bpatsubst([[$1]], - [@\(\(<:\|:>\|S|\|%:\|\{:\|:\}\)\(@\)\|&t@\)], - [\3]))])]) - - -# m4_qdelta(STRING) -# ----------------- -# Expands to the net change in the length of STRING from autom4te converting the -# quadrigraphs in STRING. This number is always negative or zero. -m4_define([m4_qdelta], -[m4_eval(m4_qlen([$1]) - m4_len([$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] -> [2.14+1.-1.[0r36:a]] -> 2.15.-1.10 -# [2.14b] -> [2.15+1.-1.[0r36:b]] -> 2.15.-1.11 -# [2.61aa.b] -> [2.61+1.-1.[0r36:aa],+1.-1.[0r36:b]] -> 2.62.-1.370.1.-1.11 -# -# 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] is less readable than 10, we provide a wrapper for -# human use. -m4_define([m4_version_unletter], -[m4_map_sep([m4_eval], [.], - m4_dquote(m4_dquote_elt(m4_unquote(_$0([$1])))))]) -m4_define([_m4_version_unletter], -[m4_bpatsubst(m4_translit([[[$1]]], [.-], [,,]),]dnl -m4_dquote(m4_dquote(m4_defn([m4_cr_Letters])))[[+], - [+1,-1,[0r36:\&]])]) - - -# 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_ifdef([_m4_set_cleanup($1)], [_$0_1c], [_$0_1])([$1])_$0_2([$1], - [_m4_defn([_m4_set_($1)])], [[$2]])]) - -# _m4_set_contents_1(SET) -# _m4_set_contents_1c(SET) -# _m4_set_contents_2(SET, SEP, PREP) -# ---------------------------------- -# Expand to a list of quoted elements currently in the set, separated -# by SEP, and moving PREP in front of SEP 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. SEP is expanded while -# _m4_set_($1) contains the current element, so a SEP containing -# _m4_defn([_m4_set_($1)]) can produce output in the order the set was -# created. Behavior is undefined if 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_ifdef([_m4_set([$1])], [m4_pushdef([_m4_set_($1)], - _m4_defn([_m4_set([$1])]))_m4_popdef([_m4_set([$1])])$0([$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_ifdef([_m4_set_($1)], [m4_pushdef([_m4_set([$1])], - _m4_defn([_m4_set_($1)]))$2[]_m4_popdef([_m4_set_($1)])$0([$1], [$3$2])])]) - -# 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. Use _m4_defn for speed. -m4_define([m4_set_difference], -[m4_if([$1], [$2], [], - [m4_set_foreach([$1], [_m4_element], - [m4_set_contains([$2], _m4_defn([_m4_element]), [], - [,_m4_defn([_m4_element])])])])]) - -# 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_ifdef([_m4_set_cleanup($1)], - [_m4_set_contents_1c], [_m4_set_contents_1])([$1])_m4_set_contents_2([$1], - [m4_define([$2], _m4_defn([_m4_set_($1)]))$3[]])m4_popdef([$2])]) - -# 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. Use _m4_defn for speed. -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_foreach([$1], [_m4_element], - [m4_set_contains([$2], _m4_defn([_m4_element]), - [,_m4_defn([_m4_element])])])])]) - -# 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_ifdef([_m4_set_cleanup($1)], [_m4_set_contents_1c], - [_m4_set_contents_1])([$1])_m4_set_contents_2([$1], - [_m4_defn([_m4_set_($1)])], [,])]) - -m4_define([m4_set_listc], -[m4_ifdef([_m4_set_cleanup($1)], [_m4_set_contents_1c], - [_m4_set_contents_1])([$1])_m4_set_contents_2([$1], - [,_m4_defn([_m4_set_($1)])])]) - -# 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. -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. Use _m4_defn for speed. -# Short-circuit the idempotence relation. -m4_define([m4_set_union], -[m4_set_listc([$1])m4_if([$1], [$2], [], [m4_set_foreach([$2], [_m4_element], - [m4_ifdef([_m4_set([$1],]_m4_defn([_m4_element])[)], [], - [,_m4_defn([_m4_element])])])])]) - - -## ------------------- ## -## 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_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, and thus that $@ recursion is linear and debugmode(d) -# is available for faster checks of dereferencing undefined macros. -# 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. Use the raw builtin to avoid tripping up -# include tracing. -m4_ifdef([__m4_version__], -[m4_debugmode([+d]) -m4_copy([_m4_defn], [m4_defn]) -m4_copy([_m4_popdef], [m4_popdef]) -m4_copy([_m4_undefine], [m4_undefine])], -[m4_builtin([include], [m4sugar/foreach.m4])]) - -# _m4_divert_diversion should be defined: -m4_divert_push([KILL]) - -# Check the divert push/pop perfect balance. -m4_wrap([m4_divert_pop([]) - m4_ifdef([_m4_divert_diversion], - [m4_fatal([$0: unbalanced m4_divert_push:]_m4_divert_n_stack)])[]]) -]) diff --git a/gnuwin32/share/bison/xslt/bison.xsl b/gnuwin32/share/bison/xslt/bison.xsl deleted file mode 100644 index 9a6ce8a4..00000000 --- a/gnuwin32/share/bison/xslt/bison.xsl +++ /dev/null @@ -1,93 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - s - - - r - - - - - - , - - - - diff --git a/gnuwin32/share/bison/xslt/xml2dot.xsl b/gnuwin32/share/bison/xslt/xml2dot.xsl deleted file mode 100644 index 130692e3..00000000 --- a/gnuwin32/share/bison/xslt/xml2dot.xsl +++ /dev/null @@ -1,206 +0,0 @@ - - - - - - - - - - - - - - - - - - - digraph Automaton { - - } - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -> - - . - - - - - . - - - - - - - - - - - - - [ - - ] - - - - - - , - - - - - - - - - - - dotted - - - solid - - - dashed - - - - - - - - - - - - - - - - - [label=" - - - - "] - - - - - - - - - - -> - - [style= - - - label=" - - - - " - - ] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/gnuwin32/share/bison/xslt/xml2text.xsl b/gnuwin32/share/bison/xslt/xml2text.xsl deleted file mode 100644 index a7835129..00000000 --- a/gnuwin32/share/bison/xslt/xml2text.xsl +++ /dev/null @@ -1,581 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 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 - - - ( - - ). - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/gnuwin32/share/bison/xslt/xml2xhtml.xsl b/gnuwin32/share/bison/xslt/xml2xhtml.xsl deleted file mode 100644 index 91dc6300..00000000 --- a/gnuwin32/share/bison/xslt/xml2xhtml.xsl +++ /dev/null @@ -1,745 +0,0 @@ - - - - - - - - - - - - - - - <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/share/bison/yacc.c b/gnuwin32/share/bison/yacc.c deleted file mode 100644 index 19f77a5f..00000000 --- a/gnuwin32/share/bison/yacc.c +++ /dev/null @@ -1,1741 +0,0 @@ - -*- C -*- - -# Yacc compatible skeleton for Bison - -# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, -# 2007, 2008 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 . - -# 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, don't let BISON_USE_PUSH_FOR_PULL modify Bison's -# behavior 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]])])]) - -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_define_flag_if([pure]) -m4_define([b4_pure_flag], - [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])]) - -# b4_yacc_pure_if(IF-TRUE, IF-FALSE) -# ---------------------------------- -# Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise. -m4_define([b4_yacc_pure_if], -[b4_pure_if([m4_ifset([b4_parse_param], - [$1], [$2])], - [$2])]) - - -# b4_yyerror_args -# --------------- -# Arguments passed to yyerror: user args plus yylloc. -m4_define([b4_yyerror_args], -[b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl -m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) - - -# b4_lex_param -# ------------ -# Accumulate in b4_lex_param all the yylex arguments. -# b4_lex_param arrives quoted twice, but we want to keep only one level. -m4_define([b4_lex_param], -m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl -b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl -m4_ifdef([b4_lex_param], b4_lex_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], -[(yyval[]m4_ifval([$1], [.$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], -[(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$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@{($2) - ($1)@})]) - - - -## --------------------------------------------------------- ## -## Defining symbol actions, e.g., printers and destructors. ## -## --------------------------------------------------------- ## - -# We do want M4 expansion after # for CPP macros. -m4_changecom() -m4_divert_push(0)dnl -@output(b4_parser_file_name@) -b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],dnl ' - [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006])[ - -/* 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_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 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]])])[ - -/* Copy the first part of user declarations. */ -]b4_user_pre_prologue[ - -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG ]b4_debug_flag[ -#endif - -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -# undef YYERROR_VERBOSE -# define YYERROR_VERBOSE 1 -#else -# define YYERROR_VERBOSE ]b4_error_verbose_flag[ -#endif - -/* Enabling the token table. */ -#ifndef YYTOKEN_TABLE -# define YYTOKEN_TABLE ]b4_token_table[ -#endif - -]b4_percent_code_get([[requires]])[]dnl - -b4_token_enums_defines(b4_tokens)[ - -#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED -]m4_ifdef([b4_stype], -[[typedef union ]b4_union_name[ -{ -]b4_user_stype[ -} YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1]], -[m4_if(b4_tag_seen_flag, 0, -[[typedef int YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1]])])[ -# define yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 -#endif]b4_locations_if([[ - -#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED -typedef struct YYLTYPE -{ - int first_line; - int first_column; - int last_line; - int last_column; -} YYLTYPE; -# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ -# define YYLTYPE_IS_DECLARED 1 -# define YYLTYPE_IS_TRIVIAL 1 -#endif]])b4_push_if([[ - -#ifndef YYPUSH_DECLS -# define YYPUSH_DECLS -struct yypstate; -typedef struct yypstate yypstate; -enum { YYPUSH_MORE = 4 }; - -]b4_pull_if([b4_c_function_decl([[yyparse]], [[int]], b4_parse_param) -])b4_c_function_decl([[yypush_parse]], [[int]], - [[[yypstate *yyps]], [[yyps]]]b4_pure_if([, - [[[int yypushed_char]], [[yypushed_char]]], - [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([, - [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [, - b4_parse_param])) -b4_pull_if([b4_c_function_decl([[yypull_parse]], [[int]], - [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, - b4_parse_param]))]) -b4_c_function_decl([[yypstate_new]], [[yypstate *]], [[[void]], []]) -b4_c_function_decl([[yypstate_delete]], [[void]], - [[[yypstate *yyps]], [[yyps]]])[ -#endif]]) - -b4_percent_code_get([[provides]])[]dnl - -[/* 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; -#elif ]b4_c_modern[ -typedef signed char yytype_int8; -#else -typedef short int 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 && ]b4_c_modern[ -# 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 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 - -/* Suppress unused-variable warnings by "using" E. */ -#if ! defined lint || defined __GNUC__ -# define YYUSE(e) ((void) (e)) -#else -# define YYUSE(e) /* empty */ -#endif - -/* Identity function, used to suppress warnings about constant conditions. */ -#ifndef lint -# define YYID(n) (n) -#else -]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[ -{ - return yyi; -} -#endif - -#if ! defined yyoverflow || YYERROR_VERBOSE - -]b4_push_if([], -[[/* The parser invokes alloca or malloc; define the necessary symbols. */ - -# 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 _STDLIB_H && ]b4_c_modern[ -# include /* INFRINGES ON USER NAME SPACE */ -# ifndef _STDLIB_H -# define _STDLIB_H 1 -# endif -# endif -# endif -# endif -# endif - -]])dnl -[# ifdef YYSTACK_ALLOC - /* Pacify GCC's `empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (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 _STDLIB_H \ - && ! ((defined YYMALLOC || defined malloc) \ - && (defined YYFREE || defined free))) -# include /* INFRINGES ON USER NAME SPACE */ -# ifndef _STDLIB_H -# define _STDLIB_H 1 -# endif -# endif -# ifndef YYMALLOC -# define YYMALLOC malloc -# if ! defined malloc && ! defined _STDLIB_H && ]b4_c_modern[ -void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ -# endif -# endif -# ifndef YYFREE -# define YYFREE free -# if ! defined free && ! defined _STDLIB_H && ]b4_c_modern[ -void free (void *); /* INFRINGES ON USER NAME SPACE */ -# endif -# endif -# endif -#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ - - -#if (! defined yyoverflow \ - && (! defined __cplusplus \ - || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ - && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_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)])[ - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if defined __GNUC__ && 1 < __GNUC__ -# define YYCOPY(To, From, Count) \ - __builtin_memcpy (To, From, (Count) * sizeof (*(From))) -# else -# define YYCOPY(To, From, Count) \ - do \ - { \ - YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } \ - while (YYID (0)) -# endif -# endif - -/* 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 (YYID (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[ - -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -#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 YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = -{ - ]b4_prhs[ -}; - -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = -{ - ]b4_rhs[ -}; - -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const ]b4_int_type_for([b4_rline])[ yyrline[] = -{ - ]b4_rline[ -}; -#endif - -#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE -/* 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[YYLEX-NUM] -- Internal token number corresponding to - token YYLEX-NUM. */ -static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = -{ - ]b4_toknum[ -}; -# endif - -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const ]b4_int_type_for([b4_r1])[ yyr1[] = -{ - ]b4_r1[ -}; - -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const ]b4_int_type_for([b4_r2])[ yyr2[] = -{ - ]b4_r2[ -}; - -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM when YYTABLE doesn't specify something else to do. Zero - means the default is an error. */ -static const ]b4_int_type_for([b4_defact])[ yydefact[] = -{ - ]b4_defact[ -}; - -/* YYDEFGOTO[NTERM-NUM]. */ -static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = -{ - ]b4_defgoto[ -}; - -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF ]b4_pact_ninf[ -static const ]b4_int_type_for([b4_pact])[ yypact[] = -{ - ]b4_pact[ -}; - -/* YYPGOTO[NTERM-NUM]. */ -static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = -{ - ]b4_pgoto[ -}; - -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. - If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF ]b4_table_ninf[ -static const ]b4_int_type_for([b4_table])[ yytable[] = -{ - ]b4_table[ -}; - -static const ]b4_int_type_for([b4_check])[ yycheck[] = -{ - ]b4_check[ -}; - -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const ]b4_int_type_for([b4_stos])[ yystos[] = -{ - ]b4_stos[ -}; - -#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 - - -/* Like YYERROR except do call yyerror. This remains here temporarily - to ease the transition to the new meaning of YYERROR, for GCC. - Once GCC version 2 has supplanted version 1, this can go. */ - -#define YYFAIL goto yyerrlab - -#define YYRECOVERING() (!!yyerrstatus) - -#define YYBACKUP(Token, Value) \ -do \ - if (yychar == YYEMPTY && yylen == 1) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - yytoken = YYTRANSLATE (yychar); \ - YYPOPSTACK (1); \ - goto yybackup; \ - } \ - else \ - { \ - yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ -while (YYID (0)) - - -#define YYTERROR 1 -#define YYERRCODE 256 - - -/* 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). */ - -#define YYRHSLOC(Rhs, K) ((Rhs)[K]) -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (YYID (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 (YYID (0)) -#endif - - -/* 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 YYLTYPE_IS_TRIVIAL -# define YY_LOCATION_PRINT(File, Loc) \ - fprintf (File, "%d.%d-%d.%d", \ - (Loc).first_line, (Loc).first_column, \ - (Loc).last_line, (Loc).last_column) -# else -# define YY_LOCATION_PRINT(File, Loc) ((void) 0) -# endif -#endif - - -/* YYLEX -- calling `yylex' with the right arguments. */ - -#ifdef YYLEX_PARAM -# define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM) -#else -# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ -#endif - -/* Enable debugging if requested. */ -#if YYDEBUG - -# ifndef YYFPRINTF -# include /* INFRINGES ON USER NAME SPACE */ -# define YYFPRINTF fprintf -# endif - -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (YYID (0)) - -# 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 (YYID (0)) - -]b4_yy_symbol_print_generate([b4_c_function_def])[ - -/*------------------------------------------------------------------. -| yy_stack_print -- Print the state stack from its BOTTOM up to its | -| TOP (included). | -`------------------------------------------------------------------*/ - -]b4_c_function_def([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 (YYID (0)) - - -/*------------------------------------------------. -| Report that the YYRULE is going to be reduced. | -`------------------------------------------------*/ - -]b4_c_function_def([yy_reduce_print], [static void], - [[YYSTYPE *yyvsp], [yyvsp]], - b4_locations_if([[[YYLTYPE *yylsp], [yylsp]], - ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [, - b4_parse_param]))[ -{ - int yynrhs = yyr2[yyrule]; - int yyi; - unsigned long int yylno = yyrline[yyrule]; - 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, yyrhs[yyprhs[yyrule] + yyi], - &]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 (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ -} while (YYID (0)) - -/* Nonzero means print parse trace. It is left uninitialized so that - multiple parsers can coexist. */ -int yydebug; -#else /* !YYDEBUG */ -# define YYDPRINTF(Args) -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) -# define YY_STACK_PRINT(Bottom, Top) -# define YY_REDUCE_PRINT(Rule) -#endif /* !YYDEBUG */ - - -/* 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 - - - -#if YYERROR_VERBOSE - -# ifndef yystrlen -# if defined __GLIBC__ && defined _STRING_H -# define yystrlen strlen -# else -/* Return the length of YYSTR. */ -]b4_c_function_def([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_c_function_def([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 YYRESULT an error message about the unexpected token - YYCHAR while in state YYSTATE. Return the number of bytes copied, - including the terminating null byte. If YYRESULT is null, do not - copy anything; just return the number of bytes that would be - copied. As a special case, return 0 if an ordinary "syntax error" - message will do. Return YYSIZE_MAXIMUM if overflow occurs during - size calculation. */ -static YYSIZE_T -yysyntax_error (char *yyresult, int yystate, int yychar) -{ - int yyn = yypact[yystate]; - - if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) - return 0; - else - { - int yytype = YYTRANSLATE (yychar); - YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); - YYSIZE_T yysize = yysize0; - YYSIZE_T yysize1; - int yysize_overflow = 0; - enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; - char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - int yyx; - -# if 0 - /* This is so xgettext sees the translatable formats that are - constructed on the fly. */ - YY_("syntax error, unexpected %s"); - YY_("syntax error, unexpected %s, expecting %s"); - YY_("syntax error, unexpected %s, expecting %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); -# endif - char *yyfmt; - char const *yyf; - static char const yyunexpected[] = "syntax error, unexpected %s"; - static char const yyexpecting[] = ", expecting %s"; - static char const yyor[] = " or %s"; - char yyformat[sizeof yyunexpected - + sizeof yyexpecting - 1 - + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) - * (sizeof yyor - 1))]; - char const *yyprefix = yyexpecting; - - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - 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 yycount = 1; - - yyarg[0] = yytname[yytype]; - yyfmt = yystpcpy (yyformat, yyunexpected); - - for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) - { - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) - { - yycount = 1; - yysize = yysize0; - yyformat[sizeof yyunexpected - 1] = '\0'; - break; - } - yyarg[yycount++] = yytname[yyx]; - yysize1 = yysize + yytnamerr (0, yytname[yyx]); - yysize_overflow |= (yysize1 < yysize); - yysize = yysize1; - yyfmt = yystpcpy (yyfmt, yyprefix); - yyprefix = yyor; - } - - yyf = YY_(yyformat); - yysize1 = yysize + yystrlen (yyf); - yysize_overflow |= (yysize1 < yysize); - yysize = yysize1; - - if (yysize_overflow) - return YYSIZE_MAXIMUM; - - if (yyresult) - { - /* 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 = yyresult; - int yyi = 0; - while ((*yyp = *yyf) != '\0') - { - if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) - { - yyp += yytnamerr (yyp, yyarg[yyi++]); - yyf += 2; - } - else - { - yyp++; - yyf++; - } - } - } - return yysize; - } -} -#endif /* YYERROR_VERBOSE */ - - -]b4_yydestruct_generate([b4_c_function_def])[ - -]b4_push_if([], -[[/* Prevent warnings from -Wmissing-prototypes. */ -#ifdef YYPARSE_PARAM -]b4_c_function_decl([yyparse], [int], - [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[ -#else /* ! YYPARSE_PARAM */ -]b4_c_function_decl([yyparse], [int], b4_parse_param)[ -#endif /* ! YYPARSE_PARAM */]]) - -m4_divert_push([KILL])# ======================== M4 code. -# 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; - -/* The semantic value of the lookahead symbol. */ -YYSTYPE yylval; -]b4_locations_if([[ -/* Location data for the lookahead symbol. */ -YYLTYPE yylloc; -]])b4_pure_if([], [[ -/* 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 thru 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[2]; -]])[ - YYSIZE_T yystacksize; -]]) - -m4_divert_pop([KILL])dnl# ====================== End of M4 code. - -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_c_function_def([[yyparse]], [[int]], b4_parse_param)[ -{ - return yypull_parse (0]m4_ifset([b4_parse_param], - [[, ]b4_c_args(b4_parse_param)])[); -} - -]b4_c_function_def([[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([[ - YYLTYPE yylloc;]])])[ - if (yyps == 0) - { - 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; - } - } - else - yyps_local = yyps; - do { - yychar = YYLEX; - yystatus = - yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[); - } while (yystatus == YYPUSH_MORE); - if (yyps == 0) - yypstate_delete (yyps_local); - return yystatus; -}]])[ - -/* Initialize the parser data structure. */ -]b4_c_function_def([[yypstate_new]], [[yypstate *]])[ -{ - yypstate *yyps;]b4_pure_if([], [[ - if (yypstate_allocated) - return 0;]])[ - yyps = (yypstate *) malloc (sizeof *yyps); - if (!yyps) - return 0; - yyps->yynew = 1;]b4_pure_if([], [[ - yypstate_allocated = 1;]])[ - return yyps; -} - -]b4_c_function_def([[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 - 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 -]])[ -/*-------------------------. -| yyparse or yypush_parse. | -`-------------------------*/ -]b4_push_if([ -b4_c_function_def([[yypush_parse]], [[int]], - [[[yypstate *yyps]], [[yyps]]]b4_pure_if([, - [[[int yypushed_char]], [[yypushed_char]]], - [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([, - [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [, - b4_parse_param]))], [ -#ifdef YYPARSE_PARAM -b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]]) -#else /* ! YYPARSE_PARAM */ -b4_c_function_def([yyparse], [int], b4_parse_param) -#endif])[ -{ -]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])[ - int yyn; - int yyresult; - /* Lookahead token as an internal (translated) token number. */ - int yytoken; - /* 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; - }]])[ - - yytoken = 0; - yyss = yyssa; - yyvs = yyvsa;]b4_locations_if([[ - yyls = yylsa;]])[ - yystacksize = YYINITDEPTH; - - YYDPRINTF ((stderr, "Starting parse\n")); - - yystate = 0; - yyerrstatus = 0; - yynerrs = 0; - yychar = YYEMPTY; /* Cause a token to be read. */ - - /* Initialize stack pointers. - Waste one element of value and location stack - so that they stay on the same level as the state stack. - The wasted elements are never initialized. */ - yyssp = yyss; - yyvsp = yyvs;]b4_locations_if([[ - yylsp = yyls; - -#if YYLTYPE_IS_TRIVIAL - /* Initialize the default location before parsing starts. */ - yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[; - yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[; -#endif]]) -m4_ifdef([b4_initial_action],[ -m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl -m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl -/* User initialization code. */ -b4_user_initial_action -m4_popdef([b4_dollar_dollar])dnl -m4_popdef([b4_at_dollar])])dnl -m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval; -]])dnl -m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc; -]])[ - 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 (yyn == YYPACT_NINF) - 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 = YYLEX;]])[ - } - - 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) - goto yydefault; - yyn = yytable[yyn]; - if (yyn <= 0) - { - if (yyn == 0 || yyn == YYTABLE_NINF) - goto yyerrlab; - 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; - - yystate = yyn; - *++yyvsp = yylval; -]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); - switch (yyn) - { - ]b4_user_actions[ - default: break; - } - 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: - /* If not already recovering from an error, report this error. */ - if (!yyerrstatus) - { - ++yynerrs; -#if ! YYERROR_VERBOSE - yyerror (]b4_yyerror_args[YY_("syntax error")); -#else - { - YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); - if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) - { - YYSIZE_T yyalloc = 2 * yysize; - if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) - yyalloc = YYSTACK_ALLOC_MAXIMUM; - if (yymsg != yymsgbuf) - YYSTACK_FREE (yymsg); - yymsg = (char *) YYSTACK_ALLOC (yyalloc); - if (yymsg) - yymsg_alloc = yyalloc; - else - { - yymsg = yymsgbuf; - yymsg_alloc = sizeof yymsgbuf; - } - } - - if (0 < yysize && yysize <= yymsg_alloc) - { - (void) yysyntax_error (yymsg, yystate, yychar); - yyerror (]b4_yyerror_args[yymsg); - } - else - { - yyerror (]b4_yyerror_args[YY_("syntax error")); - if (yysize != 0) - goto yyexhaustedlab; - } - } -#endif - } - -]b4_locations_if([[ yyerror_range[0] = 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[0] = yylsp[1-yylen]; -]])[ /* Do not reclaim the symbols of the rule which 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 (yyn != YYPACT_NINF) - { - 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[0] = *yylsp;]])[ - yydestruct ("Error: popping", - yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); - YYPOPSTACK (1); - yystate = *yyssp; - YY_STACK_PRINT (yyss, yyssp); - } - - *++yyvsp = yylval; -]b4_locations_if([[ - yyerror_range[1] = yylloc; - /* Using YYLLOC is tempting, but would change the location of - the lookahead. YYLOC is available though. */ - YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 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 !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) - yydestruct ("Cleanup: discarding lookahead", - yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); - /* Do not reclaim the symbols of the rule which 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_push_if([[ yyps->yynew = 1; - -yypushreturn: -]])[#if YYERROR_VERBOSE - if (yymsg != yymsgbuf) - YYSTACK_FREE (yymsg); -#endif - /* Make sure YYID is used. */ - return YYID (yyresult); -} - - -]b4_epilogue -b4_defines_if( -[@output(b4_spec_defines_file@) -b4_copyright([Skeleton interface for Bison's Yacc-like parsers in C],dnl ' - [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006]) - -b4_percent_code_get([[requires]])[]dnl - -b4_token_enums_defines(b4_tokens) - -[#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED -]m4_ifdef([b4_stype], -[[typedef union ]b4_union_name[ -{ -]b4_user_stype[ -} YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1]], -[m4_if(b4_tag_seen_flag, 0, -[[typedef int YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1]])])[ -# define yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 -#endif - -]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]]) - -b4_locations_if( -[#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED -typedef struct YYLTYPE -{ - int first_line; - int first_column; - int last_line; - int last_column; -} YYLTYPE; -# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ -# define YYLTYPE_IS_DECLARED 1 -# define YYLTYPE_IS_TRIVIAL 1 -#endif - -]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]]) -)dnl b4_locations_if -b4_push_if([[ -#ifndef YYPUSH_DECLS -# define YYPUSH_DECLS -struct ]b4_prefix[pstate; -typedef struct ]b4_prefix[pstate ]b4_prefix[pstate; -enum { YYPUSH_MORE = 4 }; -]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param) -])b4_c_function_decl([b4_prefix[push_parse]], [[int]], - [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([, - [[[int yypushed_char]], [[yypushed_char]]], - [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([, - [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [, - b4_parse_param])) -b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]], - [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, - b4_parse_param]))]) -b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]], - [[[void]], []]) -b4_c_function_decl([b4_prefix[pstate_delete]], [[void]], - [[b4_prefix[pstate *yyps]], [[yyps]]])[ -#endif -]]) -b4_percent_code_get([[provides]])[]dnl -])dnl b4_defines_if -m4_divert_pop(0) -- cgit v1.2.3