From f8d90f367b9be083b4d8023aacf77f62705ddf16 Mon Sep 17 00:00:00 2001 From: wsycarlos Date: Tue, 6 Jan 2026 11:11:33 +0800 Subject: [PATCH] Include Flex and Bison (required for compiler) --- compiler/win_flex_bison/FlexLexer.h | 220 + compiler/win_flex_bison/README.md | 34 + compiler/win_flex_bison/changelog.md | 166 + .../custom_build_rules/README.md | 173 + .../custom_build_rules/docs/1.png | Bin 0 -> 31654 bytes .../custom_build_rules/docs/2.png | Bin 0 -> 11445 bytes .../custom_build_rules/docs/3.png | Bin 0 -> 7316 bytes .../custom_build_rules/docs/4.png | Bin 0 -> 12213 bytes .../custom_build_rules/docs/5.png | Bin 0 -> 11534 bytes .../custom_build_rules/docs/6.png | Bin 0 -> 15611 bytes .../docs/BisonProperties.png | Bin 0 -> 27186 bytes .../docs/FlexProperties.png | Bin 0 -> 26767 bytes .../custom_build_rules/docs/Flex_debuging.png | Bin 0 -> 27219 bytes .../custom_build_rules/docs/Properties.png | Bin 0 -> 31446 bytes .../custom_build_rules/docs/Verbosity.png | Bin 0 -> 29722 bytes .../win_bison_custom_build.props | 23 + .../win_bison_custom_build.targets | 91 + .../win_bison_only/win_bison_custom_build.xml | 281 ++ .../win_flex_bison_custom_build.props | 43 + .../win_flex_bison_custom_build.targets | 178 + .../win_flex_bison_custom_build.xml | 521 +++ .../win_flex_only/win_flex_custom_build.props | 23 + .../win_flex_custom_build.targets | 94 + .../win_flex_only/win_flex_custom_build.xml | 243 ++ compiler/win_flex_bison/data/README.md | 227 ++ .../win_flex_bison/data/bison-default.css | 61 + compiler/win_flex_bison/data/local.mk | 58 + .../win_flex_bison/data/m4sugar/foreach.m4 | 362 ++ .../win_flex_bison/data/m4sugar/m4sugar.m4 | 3329 ++++++++++++++++ .../win_flex_bison/data/skeletons/bison.m4 | 1241 ++++++ .../win_flex_bison/data/skeletons/c++-skel.m4 | 27 + compiler/win_flex_bison/data/skeletons/c++.m4 | 778 ++++ .../win_flex_bison/data/skeletons/c-like.m4 | 72 + .../win_flex_bison/data/skeletons/c-skel.m4 | 27 + compiler/win_flex_bison/data/skeletons/c.m4 | 1125 ++++++ .../win_flex_bison/data/skeletons/d-skel.m4 | 26 + compiler/win_flex_bison/data/skeletons/d.m4 | 628 +++ compiler/win_flex_bison/data/skeletons/glr.c | 2763 +++++++++++++ compiler/win_flex_bison/data/skeletons/glr.cc | 397 ++ .../win_flex_bison/data/skeletons/glr2.cc | 3533 +++++++++++++++++ .../data/skeletons/java-skel.m4 | 27 + .../win_flex_bison/data/skeletons/java.m4 | 502 +++ .../win_flex_bison/data/skeletons/lalr1.cc | 1633 ++++++++ .../win_flex_bison/data/skeletons/lalr1.d | 1326 +++++++ .../win_flex_bison/data/skeletons/lalr1.java | 1303 ++++++ .../win_flex_bison/data/skeletons/location.cc | 380 ++ .../win_flex_bison/data/skeletons/stack.hh | 157 + .../win_flex_bison/data/skeletons/traceon.m4 | 2 + .../win_flex_bison/data/skeletons/variant.hh | 525 +++ compiler/win_flex_bison/data/skeletons/yacc.c | 2209 +++++++++++ compiler/win_flex_bison/data/xslt/bison.xsl | 105 + compiler/win_flex_bison/data/xslt/xml2dot.xsl | 401 ++ .../win_flex_bison/data/xslt/xml2text.xsl | 572 +++ .../win_flex_bison/data/xslt/xml2xhtml.xsl | 765 ++++ compiler/win_flex_bison/win_bison.exe | Bin 0 -> 677376 bytes compiler/win_flex_bison/win_flex.exe | Bin 0 -> 571392 bytes 56 files changed, 26651 insertions(+) create mode 100644 compiler/win_flex_bison/FlexLexer.h create mode 100644 compiler/win_flex_bison/README.md create mode 100644 compiler/win_flex_bison/changelog.md create mode 100644 compiler/win_flex_bison/custom_build_rules/README.md create mode 100644 compiler/win_flex_bison/custom_build_rules/docs/1.png create mode 100644 compiler/win_flex_bison/custom_build_rules/docs/2.png create mode 100644 compiler/win_flex_bison/custom_build_rules/docs/3.png create mode 100644 compiler/win_flex_bison/custom_build_rules/docs/4.png create mode 100644 compiler/win_flex_bison/custom_build_rules/docs/5.png create mode 100644 compiler/win_flex_bison/custom_build_rules/docs/6.png create mode 100644 compiler/win_flex_bison/custom_build_rules/docs/BisonProperties.png create mode 100644 compiler/win_flex_bison/custom_build_rules/docs/FlexProperties.png create mode 100644 compiler/win_flex_bison/custom_build_rules/docs/Flex_debuging.png create mode 100644 compiler/win_flex_bison/custom_build_rules/docs/Properties.png create mode 100644 compiler/win_flex_bison/custom_build_rules/docs/Verbosity.png create mode 100644 compiler/win_flex_bison/custom_build_rules/win_bison_only/win_bison_custom_build.props create mode 100644 compiler/win_flex_bison/custom_build_rules/win_bison_only/win_bison_custom_build.targets create mode 100644 compiler/win_flex_bison/custom_build_rules/win_bison_only/win_bison_custom_build.xml create mode 100644 compiler/win_flex_bison/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.props create mode 100644 compiler/win_flex_bison/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.targets create mode 100644 compiler/win_flex_bison/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.xml create mode 100644 compiler/win_flex_bison/custom_build_rules/win_flex_only/win_flex_custom_build.props create mode 100644 compiler/win_flex_bison/custom_build_rules/win_flex_only/win_flex_custom_build.targets create mode 100644 compiler/win_flex_bison/custom_build_rules/win_flex_only/win_flex_custom_build.xml create mode 100644 compiler/win_flex_bison/data/README.md create mode 100644 compiler/win_flex_bison/data/bison-default.css create mode 100644 compiler/win_flex_bison/data/local.mk create mode 100644 compiler/win_flex_bison/data/m4sugar/foreach.m4 create mode 100644 compiler/win_flex_bison/data/m4sugar/m4sugar.m4 create mode 100644 compiler/win_flex_bison/data/skeletons/bison.m4 create mode 100644 compiler/win_flex_bison/data/skeletons/c++-skel.m4 create mode 100644 compiler/win_flex_bison/data/skeletons/c++.m4 create mode 100644 compiler/win_flex_bison/data/skeletons/c-like.m4 create mode 100644 compiler/win_flex_bison/data/skeletons/c-skel.m4 create mode 100644 compiler/win_flex_bison/data/skeletons/c.m4 create mode 100644 compiler/win_flex_bison/data/skeletons/d-skel.m4 create mode 100644 compiler/win_flex_bison/data/skeletons/d.m4 create mode 100644 compiler/win_flex_bison/data/skeletons/glr.c create mode 100644 compiler/win_flex_bison/data/skeletons/glr.cc create mode 100644 compiler/win_flex_bison/data/skeletons/glr2.cc create mode 100644 compiler/win_flex_bison/data/skeletons/java-skel.m4 create mode 100644 compiler/win_flex_bison/data/skeletons/java.m4 create mode 100644 compiler/win_flex_bison/data/skeletons/lalr1.cc create mode 100644 compiler/win_flex_bison/data/skeletons/lalr1.d create mode 100644 compiler/win_flex_bison/data/skeletons/lalr1.java create mode 100644 compiler/win_flex_bison/data/skeletons/location.cc create mode 100644 compiler/win_flex_bison/data/skeletons/stack.hh create mode 100644 compiler/win_flex_bison/data/skeletons/traceon.m4 create mode 100644 compiler/win_flex_bison/data/skeletons/variant.hh create mode 100644 compiler/win_flex_bison/data/skeletons/yacc.c create mode 100644 compiler/win_flex_bison/data/xslt/bison.xsl create mode 100644 compiler/win_flex_bison/data/xslt/xml2dot.xsl create mode 100644 compiler/win_flex_bison/data/xslt/xml2text.xsl create mode 100644 compiler/win_flex_bison/data/xslt/xml2xhtml.xsl create mode 100644 compiler/win_flex_bison/win_bison.exe create mode 100644 compiler/win_flex_bison/win_flex.exe diff --git a/compiler/win_flex_bison/FlexLexer.h b/compiler/win_flex_bison/FlexLexer.h new file mode 100644 index 0000000..c4dad2b --- /dev/null +++ b/compiler/win_flex_bison/FlexLexer.h @@ -0,0 +1,220 @@ +// -*-C++-*- +// FlexLexer.h -- define interfaces for lexical analyzer classes generated +// by flex + +// Copyright (c) 1993 The Regents of the University of California. +// All rights reserved. +// +// This code is derived from software contributed to Berkeley by +// Kent Williams and Tom Epperly. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: + +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. + +// Neither the name of the University nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. + +// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR +// IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +// PURPOSE. + +// This file defines FlexLexer, an abstract class which specifies the +// external interface provided to flex C++ lexer objects, and yyFlexLexer, +// which defines a particular lexer class. +// +// If you want to create multiple lexer classes, you use the -P flag +// to rename each yyFlexLexer to some other xxFlexLexer. You then +// include in your other sources once per lexer class: +// +// #undef yyFlexLexer +// #define yyFlexLexer xxFlexLexer +// #include +// +// #undef yyFlexLexer +// #define yyFlexLexer zzFlexLexer +// #include +// ... + +#ifndef __FLEX_LEXER_H +// Never included before - need to define base class. +#define __FLEX_LEXER_H + +#include + +extern "C++" { + +struct yy_buffer_state; +typedef int yy_state_type; + +class FlexLexer +{ +public: + virtual ~FlexLexer() { } + + const char* YYText() const { return yytext; } + int YYLeng() const { return yyleng; } + + virtual void + yy_switch_to_buffer( yy_buffer_state* new_buffer ) = 0; + virtual yy_buffer_state* yy_create_buffer( std::istream* s, int size ) = 0; + virtual yy_buffer_state* yy_create_buffer( std::istream& s, int size ) = 0; + virtual void yy_delete_buffer( yy_buffer_state* b ) = 0; + virtual void yyrestart( std::istream* s ) = 0; + virtual void yyrestart( std::istream& s ) = 0; + + virtual int yylex() = 0; + + // Call yylex with new input/output sources. + int yylex( std::istream& new_in, std::ostream& new_out ) + { + switch_streams( new_in, new_out ); + return yylex(); + } + + int yylex( std::istream* new_in, std::ostream* new_out = 0) + { + switch_streams( new_in, new_out ); + return yylex(); + } + + // Switch to new input/output streams. A nil stream pointer + // indicates "keep the current one". + virtual void switch_streams( std::istream* new_in, + std::ostream* new_out ) = 0; + virtual void switch_streams( std::istream& new_in, + std::ostream& new_out ) = 0; + + int lineno() const { return yylineno; } + + int debug() const { return yy_flex_debug; } + void set_debug( int flag ) { yy_flex_debug = flag; } + +protected: + char* yytext; + int yyleng; + int yylineno; // only maintained if you use %option yylineno + int yy_flex_debug; // only has effect with -d or "%option debug" +}; + +} +#endif // FLEXLEXER_H + +#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce) +// Either this is the first time through (yyFlexLexerOnce not defined), +// or this is a repeated include to define a different flavor of +// yyFlexLexer, as discussed in the flex manual. +# define yyFlexLexerOnce + +extern "C++" { + +class yyFlexLexer : public FlexLexer { +public: + // arg_yyin and arg_yyout default to the cin and cout, but we + // only make that assignment when initializing in yylex(). + yyFlexLexer( std::istream& arg_yyin, std::ostream& arg_yyout ); + yyFlexLexer( std::istream* arg_yyin = 0, std::ostream* arg_yyout = 0 ); +private: + void ctor_common(); + +public: + + virtual ~yyFlexLexer(); + + void yy_switch_to_buffer( yy_buffer_state* new_buffer ); + yy_buffer_state* yy_create_buffer( std::istream* s, int size ); + yy_buffer_state* yy_create_buffer( std::istream& s, int size ); + void yy_delete_buffer( yy_buffer_state* b ); + void yyrestart( std::istream* s ); + void yyrestart( std::istream& s ); + + void yypush_buffer_state( yy_buffer_state* new_buffer ); + void yypop_buffer_state(); + + virtual int yylex(); + virtual void switch_streams( std::istream& new_in, std::ostream& new_out ); + virtual void switch_streams( std::istream* new_in = 0, std::ostream* new_out = 0 ); + virtual int yywrap(); + +protected: + virtual int LexerInput( char* buf, int max_size ); + virtual void LexerOutput( const char* buf, int size ); + virtual void LexerError( const char* msg ); + + void yyunput( int c, char* buf_ptr ); + int yyinput(); + + void yy_load_buffer_state(); + void yy_init_buffer( yy_buffer_state* b, std::istream& s ); + void yy_flush_buffer( yy_buffer_state* b ); + + int yy_start_stack_ptr; + int yy_start_stack_depth; + int* yy_start_stack; + + void yy_push_state( int new_state ); + void yy_pop_state(); + int yy_top_state(); + + yy_state_type yy_get_previous_state(); + yy_state_type yy_try_NUL_trans( yy_state_type current_state ); + int yy_get_next_buffer(); + + std::istream yyin; // input source for default LexerInput + std::ostream yyout; // output sink for default LexerOutput + + // yy_hold_char holds the character lost when yytext is formed. + char yy_hold_char; + + // Number of characters read into yy_ch_buf. + int yy_n_chars; + + // Points to current character in buffer. + char* yy_c_buf_p; + + int yy_init; // whether we need to initialize + int yy_start; // start state number + + // Flag which is used to allow yywrap()'s to do buffer switches + // instead of setting up a fresh yyin. A bit of a hack ... + int yy_did_buffer_switch_on_eof; + + + size_t yy_buffer_stack_top; /**< index of top of stack. */ + size_t yy_buffer_stack_max; /**< capacity of stack. */ + yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */ + void yyensure_buffer_stack(void); + + // The following are not always needed, but may be depending + // on use of certain flex features (like REJECT or yymore()). + + yy_state_type yy_last_accepting_state; + char* yy_last_accepting_cpos; + + yy_state_type* yy_state_buf; + yy_state_type* yy_state_ptr; + + char* yy_full_match; + int* yy_full_state; + int yy_full_lp; + + int yy_lp; + int yy_looking_for_trail_begin; + + int yy_more_flag; + int yy_more_len; + int yy_more_offset; + int yy_prev_more_offset; +}; + +} + +#endif // yyFlexLexer || ! yyFlexLexerOnce diff --git a/compiler/win_flex_bison/README.md b/compiler/win_flex_bison/README.md new file mode 100644 index 0000000..b4e96ec --- /dev/null +++ b/compiler/win_flex_bison/README.md @@ -0,0 +1,34 @@ +# WinFlexBison - Flex and Bison for Microsoft Windows + +WinFlexBison is a Windows port of [Flex (the fast lexical analyser)](https://github.com/westes/flex/) and [GNU Bison (parser generator)](https://www.gnu.org/software/bison/). +Both win_flex and win_bison are based on upstream sources but depend on system libraries only. + +**NOTE**: +* 2.4.x versions include GNU Bison version 2.7 +* 2.5.x versions include GNU Bison version 3.x.x + +## License +Flex uses a [BSD license](flex/src/COPYING), GNU Bison is [licensed under the GNU General Public License (GPLv3+)](bison/src/COPYING). +All build scripts in WinFlexBison are distributed under GPLv3+. See [COPYING](COPYING) for details. + +All documentation, especially those under custom_build_rules/doc, is distributed under the GNU Free Documentation License (FDL 1.3+). + +## Build status +Bison 3.x (master) [![Build status](https://ci.appveyor.com/api/projects/status/58lcjnr0mb9uc8c8/branch/master?svg=true)](https://ci.appveyor.com/project/lexxmark/winflexbison/branch/master) and, for compatibility reasons, Bison 2.7 (bison2.7) [![Build status](https://ci.appveyor.com/api/projects/status/58lcjnr0mb9uc8c8/branch/bison2.7?svg=true)](https://ci.appveyor.com/project/lexxmark/winflexbison/branch/bison2.7) + +## Downloads +https://github.com/lexxmark/winflexbison/releases provides stable versions. +To test non-released development versions see the artifacts provided by CI under "Build status". + +## Changelog +The release page includes the full Changelog but you may also see the [changelog.md](changelog.md) file. + +## Build requirements +* Visual Studio 2017 or newer +* optional: CMake (when building with CMake) + +## HowTo +You may use win_flex and win_bison directly on the command line or [use them via CustomBuildRules in VisualStudio](custom_build_rules/README.md). + +## Example flex/bison files +See https://github.com/meyerd/flex-bison-example diff --git a/compiler/win_flex_bison/changelog.md b/compiler/win_flex_bison/changelog.md new file mode 100644 index 0000000..5d80cec --- /dev/null +++ b/compiler/win_flex_bison/changelog.md @@ -0,0 +1,166 @@ +## Changelog + +**NOTE**: + * 2.4.x versions include bison version 2.7 + * 2.5.x versions include bison version 3.x + +### version 2.5.25 + * upgrade win_bison to version 3.8.2 + * upgrade m4 to version 1.4.19 + +### version 2.5.24 + * upgrade win_bison to version 3.7.4 + * upgrade m4 to version 1.4.18 + * upgrade gnulib + * removed VS2015 support + * fixed win_bison --update option (renaming opened file) + +### version 2.5.23 + * upgrade win_bison to version 3.7.1 + +### version 2.5.22 + * upgrade win_bison to version 3.5.0 + +### version 2.5.21 + * avoid _m4eof lines in generated bison code while printing warnings + +### version 2.5.20 + * recovered invoking win_bison from different folders + +### version 2.5.19 + * upgrade win_bison to version 3.4.1 + +### version 2.5.18 + * upgrade win_bison to version 3.3.2 + +### version 2.5.17 + * upgrade win_bison to version 3.3.1 + +### version 2.5.16 + * upgrade win_bison to version 3.1 + * write output flex/bison files in binary mode "wb" that means use '\n' EOL not '\r\n' + * documentation about how to use the custom build-rules is now included + +### versions 2.4.12/2.5.15 + * upgrade win_bison to version 3.0.5 + +### versions 2.4.12/2.5.14 + * revert to Visual Studio 2015 due to false positive virus alarms for win_flex.exe + +### versions 2.4.11/2.5.13 + * fixed VS 2017 compilation errors in location.cc + +### versions 2.4.11/2.5.12 + * migrate to Visual Studio 2017 + +### versions 2.4.10/2.5.11 + * upgrade win_flex to version 2.6.4 + * fixed compilation warnings + +### versions 2.4.9/2.5.10 + * data folder was up to dated for bison 3.0.4 + +### versions 2.4.9/2.5.9 + * recovered --header-file win_flex option + +### versions 2.4.8/2.5.8 + * fixed outdated FlexLexer.h file + +### versions 2.4.7/2.5.7 + * upgrade win_flex to version 2.6.3 + * fixed compilation warnings + +### versions 2.4.6/2.5.6 + * upgrade win_bison to version 3.0.4 + * win_bison v2.7 is unchanged + * add separate custom build rules + * for win_bison `custom_build_rules\win_bison_only` + * and win_flex `custom_build_rules\win_flex_only` + +### versions 2.4.5/2.5.5 + * fix missing Additional Options in custom build rules + * fix incorrect "----header-file" option in flex custom build rules + * add some extra flex options to Visual Studio property pages: + 1. Prefix (--prefix="...") + 2. C++ Class Name (--yyclass="...") + +###versions 2.4.4/2.5.4 + * fix silent errors in custom build rules + * add some flex/bison options to Visual Studio property pages: + * Bison: + 1. Output File Name (--output="...") + 2. Defines File Name (--defines="...") + 3. Debug (--debug) + 4. Verbose (--verbose) + 5. No lines (--no-lines) + 6. File Prefix (--file-prefix="...") + 7. Graph File (--graph="...") + 8. Warnings (--warnings="...") + 9. Report (--report="...") + 10. Report File Name (--report-file="...") + + * Flex: + 1. Output File Name (--outfile="...") + 2. Header File Name (--header-file="...") + 3. Windows compatibility mode (--wincompat) + 4. Case-insensitive mode (--case-insensitive) + 5. Lex-compatibility mode (--lex-compat) + 6. Start Condition Stacks (--stack) + 7. Bison Bridge Mode (--bison-bridge) + 8. No #line Directives (--noline) + 9. Generate Reentrant Scanner (--reentrant) + 10. Generate C++ Scanner (--c++) + 11. Debug Mode (--debug) + +### versions 2.4.3/2.5.3 + * fix incorrect #line directives in win_flex.exe +see https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=542482 + +### versions 2.4.2/2.5.2 + * backport parallel invocations of win_bison version 2.7 + * win_bison of version 3.0 is unchanged + +### versions 2.4.1/2.5.1 + * remove XSI extention syntax for fprintf function (not implemented in windows) + * this fixes Graphviz files generation for bison + +**NOTE**: + * 2.4.x versions will include bison version 2.7 + * 2.5.x versions will include bison version 3.0 + +### version 2.5 + * upgrade win_bison to version 3.0 and make temporary win_bison's files process unique (so parallel invocations of win_bison are possible) + +**NOTE**: Several deprecated features were removed in bison 3.0 so this version can break your projects. +Please see http://savannah.gnu.org/forum/forum.php?forum_id=7663 +For the reason of compatibility I don't change win_flex_bison-latest.zip to refer to win_flex_bison-2.5.zip file. +It still refer to win_flex_bison-2.4.zip + +### version 2.4 + * fix problem with "m4_syscmd is not implemented" message. + * Now win_bison should output correct diagnostic and error messages. + +### version 2.3 + * hide __attribute__ construction for non GCC compilers + +### version 2.2 + * added --wincompat option to win_flex (this option changes `` unix include with `` windows analog + also `isatty/fileno` functions changed to `_isatty/_fileno`) +fixed two "'<' : signed/unsigned mismatch" warnings in win_flex generated file + +### version 2.1 + * fixed crash when execute win_bison.exe under WindowsXP (argv[0] don't have full application path) + * added win_flex_bison-latest.zip package to freeze download link + +### version 2.0 + * upgrade win_bison to version 2.7 and win_flex to version 2.5.37 + +### version 1.2 + * fixed win_flex.exe #line directives (some #line directives in output file were with unescaped backslashes) + +### version 1.1 + * fixed win_flex.exe parallel invocations (now all temporary files are process specific) + * added FLEX_TMP_DIR environment variable support to redirect temporary files folder + * added '.exe' to program name in win_flex.exe --version output (CMake support) + * fixed win_bison.exe to use "/data" subfolder related to executable path rather than current working directory + * added BISON_PKGDATADIR environment variable to redirect "/data" subfolder to a different place diff --git a/compiler/win_flex_bison/custom_build_rules/README.md b/compiler/win_flex_bison/custom_build_rules/README.md new file mode 100644 index 0000000..181d7d8 --- /dev/null +++ b/compiler/win_flex_bison/custom_build_rules/README.md @@ -0,0 +1,173 @@ + +How to setup custom build rules for Visual Studio 2010 and up. +--------------- + +First of all you should have the necessary files. +Custom Build rules are separated into a file triplet of `.xml`, `.targets` and `.props`. + +You find the custom build rules for win_flex_bison in the **custom_build_rules** directory of the win_flex_bison archive. + +You may choose to install one of the following rule set + +* the combined rules - [alternative download][1]: + * [win_flex_bison_custom_build.props ](win_flex_bison/win_flex_bison_custom_build.props) + * [win_flex_bison_custom_build.targets](win_flex_bison/win_flex_bison_custom_build.targets) + * [win_flex_bison_custom_build.xml ](win_flex_bison/win_flex_bison_custom_build.xml) + +* flex only rules - [alternative download][2]: + * [win_flex_custom_build.props ](win_flex_only/win_flex_custom_build.props) + * [win_flex_custom_build.targets ](win_flex_only/win_flex_custom_build.targets) + * [win_flex_custom_build.xml ](win_flex_only/win_flex_custom_build.xml) + +* bison only rules - [alternative download][3]: + * [win_bison_custom_build.props ](win_bison_only/win_bison_custom_build.props) + * [win_bison_custom_build.targets](win_bison_only/win_bison_custom_build.targets) + * [win_bison_custom_build.xml ](win_bison_only/win_bison_custom_build.xml) + +This documentation uses the combined rule-set but can be used for all rule-sets. + +[1]: https://sourceforge.net/projects/winflexbison/files/win_flex_bison_custom_build_rules.zip/download "Combined build rules for Bison and Flex" +[2]: https://sourceforge.net/projects/winflexbison/files/win_flex_custom_build_rules.zip/download "Build rules for Flex only" +[3]: https://sourceforge.net/projects/winflexbison/files/win_bison_custom_build_rules.zip/download "Build rules for Bison only" + +---- + +Launch Visual Studio and open an VC/VC++ project. +Open context menu for project item in Solution Explorer panel and select "**Build Customizations...**" menu item. +(Note: newer VS versions have this below sub-menu "**Build Dependencies...**".) + +![Build Customizations in Solution Explorer](docs/1.png) + +---- + +In popup dialog "Visual C++ Build Customization Files" press "**Find Existing...**" button. + +![Customization Files](docs/2.png) + +---- + +In Open File dialog select "**win_flex_bison_custom_build.targets**" file and press "Open". +(Note: you may have to switch the file filter to "(*.*) all files".) + +---- + +You will see "Add Search Path?" message box, press "Yes". + +![Adding Search Path](docs/3.png) + +---- + +In "Visual C++ Build Customization Files" dialog check just added item **win_flex_bison_custom_build** and press "OK". + +![activate custom build rule](docs/4.png) + +---- + +Now you can add flex and bison files to the project... + +![project with flex and bison files added](docs/5.png) + +... and build. +In build output you should see something like this: + +~~~~ + +1>------ Rebuild All started: Project: ConsoleApplication1, Configuration: Debug Win32 ------ +1> Process sample bison file +1> Process sample flex file +1> stdafx.cpp +1> ConsoleApplication1.cpp +1> Generating Code... +1> ConsoleApplication1.vcxproj -> C:\Users\ConsoleApplication1\Debug\ConsoleApplication1.exe +========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ========== + +~~~~ + +----- + +For **sample.y** bison file there are two output files: **sample.tab.h** and **sample.tab.cpp**. +For **sample.l** flex file you'll got **sample.flex.cpp**. + +Now you can add them to the project and build. (*Don't forget to exclude cpp files from using precompiled headers*) + +![Include generated files into Solution](docs/6.png) + +~~~~ + +1>------ Build started: Project: ConsoleApplication1, Configuration: Debug Win32 ------ +1> Process sample bison file +1> Process sample flex file +1> sample.tab.cpp +1> sample.flex.cpp +1> Generating Code... +1> ConsoleApplication1.vcxproj -> C:\Users\ConsoleApplication1\Debug\ConsoleApplication1.exe +========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ========== + +~~~~ + +---- + +If your flex/bison file is incorrect and you've got an error. But you don't see actual error message, something like this: + +~~~~ + +1>------ Build started: Project: ConsoleApplication2, Configuration: Debug Win32 ------ +1> Process "grammar.y" bison file +1>C:...\custom_build_rules\win_flex_bison_custom_build.targets(55,5): error MSB3721: The command " +1>C:...\custom_build_rules\win_flex_bison_custom_build.targets(55,5): error MSB3721: start /B /WAIT /D "C:...\ConsoleApplication2\ConsoleApplication2\" win_bison.exe --output="grammar.tab.cpp" --defines="grammar.tab.h" --graph="1.dot" "grammar.y" +1>C:...\custom_build_rules\win_flex_bison_custom_build.targets(55,5): error MSB3721: exit /b %errorlevel%" exited with code 1. +========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ========== + +~~~~ + +You can change Build Output Verbosity from "Minimal" to "Normal" in "Options" dialog + +![Verbosity](docs/Verbosity.png) + +Then you will see more detailed output: + +~~~~ + +1>BisonTarget: +1> Process "grammar.y" bison file +1> grammar.y:51.1-4: error: invalid directive: '%sdw' +1>C:...\custom_build_rules\win_flex_bison_custom_build.targets(55,5): error MSB3721: The command " +1>C:...\custom_build_rules\win_flex_bison_custom_build.targets(55,5): error MSB3721: start /B /WAIT /D "C:...\ConsoleApplication2\" win_bison.exe --output="grammar.tab.cpp" --defines="grammar.tab.h" --graph="1.dot" "grammar.y" +1>C:...\custom_build_rules\win_flex_bison_custom_build.targets(55,5): error MSB3721: exit /b %errorlevel%" exited with code 1. +1> +1>Build FAILED. +1> +1>Time Elapsed 00:00:01.21 +========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ========== + +~~~~ + +---- + +Also you can tune some flex/bison options in files properties dialog: + +![Opening File Properties](docs/Properties.png) +![Property Page for Flex sources](docs/FlexProperties.png) +![Property Page for Bison sources](docs/BisonProperties.png) + +---- + + +To debug your scanner or parser you can set break points right into **sample.y** or **sample.l** code. + +![Debugging Flex source files](docs/Flex_debuging.png) + +---- + + +To use the Visual C++ Code editor for Flex/Bison files instead of the text editor adjust your editor settings as follows: + +* click **Options** on the **Tools** menu, expand the **Text Editor** node and select **File Extension** +* type extension **`l`** in the **Extension** field and choose **Microsoft Visual C++** in the **Editor** drop-down field, click **Add** +* do the same for the extension **`y`** + +You now have syntax highlighting, code-completion and show definition options in your Flex/Bison source. + +---- + +Enjoy! diff --git a/compiler/win_flex_bison/custom_build_rules/docs/1.png b/compiler/win_flex_bison/custom_build_rules/docs/1.png new file mode 100644 index 0000000000000000000000000000000000000000..e29510ecbc1ea268999bcea34e4251071b1fb81e GIT binary patch literal 31654 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

6gBN@G|Vx-zT`q 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 literal 0 HcmV?d00001 diff --git a/compiler/win_flex_bison/custom_build_rules/docs/4.png b/compiler/win_flex_bison/custom_build_rules/docs/4.png new file mode 100644 index 0000000000000000000000000000000000000000..288d79a2a5ae39861f0f81adeffd2bc814972b59 GIT binary patch literal 12213 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 literal 0 HcmV?d00001 diff --git a/compiler/win_flex_bison/custom_build_rules/docs/5.png b/compiler/win_flex_bison/custom_build_rules/docs/5.png new file mode 100644 index 0000000000000000000000000000000000000000..5b9e18f6d299232582980f37ab31551759623de2 GIT binary patch literal 11534 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 a_jto=Prr=RS)YTD4=Bp2%9KkR2mLRwDRyrF literal 0 HcmV?d00001 diff --git a/compiler/win_flex_bison/custom_build_rules/docs/6.png b/compiler/win_flex_bison/custom_build_rules/docs/6.png new file mode 100644 index 0000000000000000000000000000000000000000..5f51155ffb93e3e16ca6db013db5033f5a5b949b GIT binary patch literal 15611 zcmY*=1z1#3xAvhyq!FYC=@yXAkq*fbBostKIwhrs28E#%q+v*Dq)R%K?(Xhx{Ey!I z-}_yjXL!z>IWv3jwbowiUGG{uOhZip?*Zil008im6lJvl07V~s*TV%DJleFrMJNK>CWc(ti4>62Vj$JIK zhn;GWOLFoiYJ==qP_(6e=f!7l7Q0+Lo7_}+8+|*KeRrM%Q^$ud=56h#3*DUNIIS#g zD=hcgGhTEPgh-dpOGP5bl=X{#NLB7^@KYeNol~8WV;-l;SL!EWREU z8$OBQf`tta<;3)hy12`j9g`+R+9dDYKb!iw2|x*n{(YD(CQT@dK8FH_Jc;=A8U-Dy zO5aebd6m18_{x88M*(YJ9hb+3^vxt|!{Js6#mRWX(eslCJmv?MulUXQvVGX7vU_bl zw%JPR_A@;R^>!2|;a|Z>JsHK}vH94q{q=(dC0tPS{VVX=yAX-y6?5C$+%? z4*(jj^mq4JSyTUnOH0psc+SP1xkZ19Wuf7LvO}50x{AfiEJc8ZEOuQAGXR)9G`XOHi@J{nK<& zt0N(4!dUT*{F`%$%Hy;Fx^KKbc4&Twt@6X#kN|9RPrP;-z^{x4GJ-&d4o1@ap1=Ej zU}SVbA!pRM{+Y!-^&{81JM+5x(Ol()+1{4{@Z%n#rGT$*K8d{f_HuW?bfb<%(xd-K z_4mCO(88#Oh%f*BkE`&q2l-UrmoI8Eq(4#5YP>q{+dJ?Hqo z)SQ>Z;tyY@86I6n@OJU@c3GF6d>2B}3AEx5P|sHVab-@WN@0F04w!yka$axzMVBx5 zX-FQ6_`jrhTsb-CtH*z~dWNQTGI`bBi8UWSMZ-IHY7oA zPW{%;eBufWw)0_YnO+~1VENhbiu4h2YGioKYRv*Wi8)BeixwsutEsmf;apWvAq zTg&=(gg?%jd%JVi2&maBP{p0J(34DFPmeiVDvWXokKv~TVJt$DC;)IkEp~NX zcU{@#BL$FmMHXF~U3@ER`UTLb`ZyIGwtfH(*R9K3lJryaRV)`$bK0H9r7X}qK zjxWEt4~zELP3Ie=GL%Ma%lR~GNUMILfnb|RJ=n)JNfKj(>J z?NZ|3@7QmQJd>nJf;ss^UO8gH&7;~p9k28qgaakK&ViqiG-819uPIE1Duvb#xsS3t}JLz4#LzM5*@>(0E#Xn8va-GLo%4rNJQ4@Ie^ zN#X$p)pm1rA2_D$D|x@G<>qleq&EfE1u?8WzF%EswCoJLy1H`S=ueUI_1T-Qq`R4n zF)@Icn;IQ{_PxafJ|5gG@JDlS;6wdr#9YC}Djs9NXR%Or2KG3Eva6-1NTO}|Y3W01 zr2AP}5bw~KQ$zh(ZU$=DKu}Dq-uKUamO|9|#l=@7$y?ce zNB`s$#t}@6h088`!l?8^<=SMjm)U z{oM_nhpF{^W3b2IvpM6Z!s6nE*rO4TaICY?P>=BcP5`lfamYaM$m;1!+T~~=!kgF* z8U&Wu5eDD@juwO0YGB`(J%c-_f4OTR^?jPh3mpv?v&k?02wOy|Eof=!EdXg+1l4vu zrEX+tRabPAR+r{=U%RxlRAf;7;2SwZ^X(cH_)6;S{kX>AW>H!~D~7It#{{P^LY(lA zK!%z7UPcl<2;IfjDbkM@C~I4)F+X~OC5%oeStrW#o<~UQBm28~|6(2l!6VaGN5k1F z0s;bz+z49A-$OXi8 zcM`>;25ne-b9;MOqRw_kaAnteqWG@4S#0ELxMaZS-nb)X$LF|Dta;R(#4~Uh6a%OJ zkM}-4Zz2yXQ-b6o%4fUU{|bZYK(Eqjj79PYXDZGgKAa&{MBO*|p4HwWkn zgx&V3H_xut(3!aif4n0MCZqO@{rZr21HU$aB#h+6i|U?8=4fGF&;o6y_yRs9(m*wz z9-?A?7T0z$PX6^!-zYt$FaB(A5wx9tqx;2^>SDleV4-gLc8y@(qKwhzff1VmI?Uwjk3)(!5nJc9vGwr!7lYUS--ovxVW=UvtlIz1nuXO6=v%c z3D?)yFq4Gr@zGI(3aY|Yi`3@R&VtPPO^-2{b8!emZWeqc)iVPgsT3!rP#?ss^FWvw zR9qbPDkq9w*Xy_~|ICz&7%zUEWZNr^!WkDR2l^-p&(lrNs+|XYws_ohKPtqa{S ztq}!>glw#@|5fs0cZOT6iOy%5$5cX5ySSXMi|u_*lKwbtmH>m(H=;n{E2lXE zG^&dOs_qKDP_y5vTKAJ(UkVMX)!f3%dcGt#2N6TCBk%9;e~%!JWlyogS#mX`-+FzY zSDx@*CE;T|(J%U~&Z2Ys?7B-~cE{(ko!MjK&-7%Pvl$|p_so20+PcJ`(X-Or)h|ds zCKqE4OE)7oM;N{3sGGqcp2QqI!|#_l*&4sro1cf0BcF0+`(cD+Y%E3w0#C3bd?@c$ zvW(u`G}`_lSzwH#YPpT*yiG%h=(FyPjy6!*Mzb!;-kBKw7XR*ct`J35z^s@$={=9a zt;Ys&=Oub~cn^YSWba%{?s##X)0$PSwdT>HnIUAdvBD3=kr!+ubI75J4F>?j#%s-Z zH!?zW-Y{V$kE`SCwPGANBxvKCb@A0^)-Fd2w_ySU)nhOiK7sFp*c<=|2mikD=bugiL9^~SkZU_hp}d8ytlDYt=-U0yBX?p8T&E}7ccZX<7ME`RM7C6uIO z`RdWi^y(`ij^Ce74pBJ-{JIeTr)!nG`su-o(MW*RCggL2cJ00PNP z7g6;z$-7>TlG`nHUrHJpTU*<{mh@Dy1d6Q%tf;fIA}qhe=;#$7=nzYuG)K0h@%7B~ z*w;%$($xBM@No; z`(X=K^I;GV@Dp?eVO?~-w>Jxa?vGZwoSm^ey+2Lyk9^>;?sm1cwl4FA>M0kZo2z}2 zIkBw-0DguWg89r(+7DdgtqdfpsXv~$Lv84p%+1X)0ZK~BRSD29Vfbn1s;!x->mC?; zj|6+)j7EKerLzYQeA~Qt&+{S`{5ko!)?R=DFxHvP^|>@>)1)fnNDDWeaW=nb;sqw> zydB!!dHX0b4VF2Jk4n^)?|lit>VkMNrf<53b`*cC@N!vu*SB(W+Ar6_ z=c=bQZRI3&(=KD%HC>s%?42<3l^_o5_VsL>_d00Qjc1N^+4l4`>Qnr)zaJ1@?{VRN zGUENZ66lh-W8mL0u%5WN8NczL)njlgvM<8$+tTJp+u!*fpQK^*^_VtEQh55-#mH#y zNaLbOD5{#Bs>Uu1%ig1~#9D%PTuSR5^JJ?JU3yF>iwOX*p#g_Pp_aZ zpPS77U!)+yj9b2M;C-@ZicrxMIngnoE0fXeX0^x_x4U$S&m zv2^ANx!1vjUcH_fAJ>PJ`JH`zFS6p|A}>(bdz?5MS)}I&YSH|$P!e}>GE(1 zL>;I~^#v74Up4<(I7wRUdHHNK5wN2rd9FGutg86+M;+5Ou>2x14YQGZ%U zo+RRubE~SWFMK@dOS_rf&^ItBX}%J5!TUO4sj)@|`uFxs0uGc2FK_vGO1nLei#^Q)`s`qp)kV&yeWP$^)WRez&kRi}eGI_G5W>vr)h z-@dM|kg0gWP<2jpbbkEdjr#8&BY7obUzX%(NR9)I4Zp3e?KsqUd~sp8u$@4%CR`=KM%8v_ zeEn!H1Frr+I2BR%v`eO*V15~Dqye>=Z@B6gI{>p%Cm<_;`e%NlqM5OPsI;3O3Q8GYxY@FGWEIO2o?_WSDe+(2i(=rVcnl3%@btK3_Lx*Bt2HAuESqmc}p%3f8 z8?u}apIm>GjAd(Ea!`wh5+ak0UHl-Sia2x7xNObZK6Gs?xpWgT;( z^77Xd($R5hS6;8}yGf^eKRM&ZC(C%9*IGfgaxuy3S_5|69|XO1HDzhmju@`-%Me+tY#^blu^3S9Z2P<@wFnW)Ud%rDB8vg-8Rv5NH$l;o`; zOqDY}yI%VuJU>F|An(zkvK4p!GE95^XXq!3-g2KZvP7%+C33}uY*9VGYk6Ih0J`ItHA=%1^s(0gJ7fdj` zX!4|C+0xFKrC-h6J#{0%Wp>dK(#2_+P(?u#GaRiT6{p^v7(69Tnc+kvJtm@1I#Y?_7Soc%B`2ok-xqw+mPP^Q!Vz*3F`zOt>H4# z8r!l~8=o2^O%t{}=OiN|n{BzgyiAqwQq(8~8M5f;=#gCYi;D{*=RSe;hr(NgS8{BE z4-m=9ey66c!znJsQkwE&+&L-FFbMDx>9FcLzE$fjY%Y_!uPIsj{6*WttrVG+2spd&eavmw4==w_!H>#pz!$cuVRc+;4J1S^-j2pRm!ZfQC zjfxC3q6z1+k@#gt!tQK3^I1h|PV6Y@`))h?zoo6Hg?g^Mey_3N>Zq~HT{FE^cz)FAq7-sl4DD$M)xTK?-P zb!a4|#7OxhZ>N&mu%Yx&kGhlLX!#2kn((K^?JzzSc?%g5hk#yVA<^F2$GpW%L!~Oc z_>N^82*IBj_1Z6!$kI3(Nj<2AJQ%5kgg<{QMv|Qnylsmu_f)FPEqNjmKX^d@gv{vK zdSv}ucqVK43oMUmoJG?opB7YH>k<@M?*tu&Q=UCa7Y5ST$YFK_G}!KJU+|Ardw*o4 z6h3-)shAa)^0?F__8~0HBK`~+s>eo_9spf5Yzke5GKFvei&oz@GxCIaxu%BZ@>`Wc z;3RRc9)Qww6XV}J)8edoKg~3bJk-_F{!B)9O06_JwXj8z7Ux(r`ZdmC_S=YVY9Uns z8rokDRVd$0nwc$jpqWh!cgf+EfG-6L+s0>;H_~5H1erlu8|!|#UU${f{6cw#BnTuc zRl~*0bUVDiq01zeh?M#GmWx@W`RnI^h_I(3&#Z*n$ZI6Wf`a-%D(WT9 z7N?=lpMVZv@Hm!ft(X7~F?+YVglmdMF3j-XAUk?Fl9JlvwmkcE(iV!~(>jI9_Dh-a zG0~K_HJG96EL_otr7Y z0d8AT1{vhs+TBWA_r~G{X`DI}|6v|MYH`4v7yZha9ATJYCqAVey9*cJNglzu7U7M6 z%`|S(dF#+{e6mT~0+b5?M!g#XvjyAA_725so8rrz`qJCSW{I%7k8U7;s^^X>xv;%_k52%1nrwTs&q(WJ;sNx=plJ_lG z2K{X)eq2JY`Xe}13u^;-W>FXF36uq`!^FS5J9v-(tgTF}{RM9zvln;kZ#)fLfc)*v zucw%YZF{BB$fV#GZyP@;Bh^q?Iiwz!zC@`+1r}H9x4e4hr0_t=xYAnX{|LRF@p>yp;D9DR_Au(&nBk}Y+sPlg zOSpWd=zer|!PAzLKgb2~+J57ePGCW5ky-X_lX`$3&;4t5@4axC|{voFrJ!z`s?85 z$cNg6*>@ptNA!eUu|~BVc6Edu=2?$|qtM=a5mp{{P-!h)R7ACYp;~O3HVh#kRZV+g z8{6`S;!PnJJT78)2-^1I>EXp%7_KojzM(2^SXv{=8y_rbPr#hoP~#OSBNG5P{PtG< z$V1J4a>6dy!g@^oc;fzH`X&!T5o)IFmP>q;Kc5`VN2v<{)ZPXzO6YF}JoLoe(90Ch zH;uQG*DkO-S>FW~9*}z)VY-u6&C*K>TDbc;PNF;P;tR`%d8JZf4eoGBZL2hziydNq z>U(US?BCb+w1FaZ9$!6{v&}?(X>-PenD3*87l#dG;GD|%z!gBudq1<7&zEHnWlREX zN7$wot;!~t=Z$JMrPxDWc7Zt7e_9cRuk22pfUNQx#uEkF=HFK#tCot&u>D1FL#l>M zbC}1J?>D52Gvm@LQqXfyZg3m1b%@E#QH0#D5txYvLKG=jTNup@!~7ue&mF~Z!MYe- zS;bQ~j5B;fbRuYxEV|w%VUg^ozwd~YFCOKf@;-f zT>Sa-=h*j?-b58Wawt8>TR*7_*qf<7n5!2Oib}ukrCKVk7hjkyLn|M6uj(yK^ej!4 z8-JQ7B73Z*BW_XK%EPxDgkX(tjWE1V@z|cpxnOGOR*@4k-$c38oSrNK4-fC` z{Cs@{7kkI&yx4Vvj;=|sUYp-_(Hx#d`Y1i1;W|=HjS12p)`aGFj@WG?6RC)>bVCDb zB%VD~V`|xh;gi-qt{8I@7`NbzoRSkm`3Z*h-AyH+8=?A=Btf|*;k6y29G@~dn)x8w zA$foF2*Z<1pYpZgPovug+PzXeGXxOS`N4|v1V0guReZNB{%#FCorkZt@I)|guAPf*QeS4HHYl432I zJf>_-j2K)-%Cz7p^R~x$u3K}u%V+l!(X5s=YouVyy>4|mTx?0c!4AQvp`@duqoAN~ zN^fqKqQ)<|nX31-EHRRBiE&3SPkFnW4rlFS#76JI)@yY+8orVHgnvxI1KIO6H8lmx zC`$-p^Sf^5H0SAr9ZAdp90DXXI27?=!#=-xoh@%6_d`h*Y>6FB9 z(kNvoti0erh+N0`zO=x~&v42Zog~)kd`Xi|mb`2o=kj0m8+P%F~2ro=dLl6h_C=Yo|hoo~z7z3Z?}o!6+J zXs|?a+ZnUnD+nVxs%&RmkCr=jm7L9bhO@(cFML?8=rA507%gvb5A?lWH=12`DRvZ{ z5dPy~YPWwpyR+aVd06D@BYhov>vd<)kJWy6(ELo>dYhDG#q!6{=3tR(5yuOOt>yT&Fa%lWyf<=eQc zse3xj3y>)ZT6N=@s*C<6x2UdnMM*_tS3}BFYYe<`1~lFK!&Z1~@P%~Z) zLEpX0y1KyDvoAk9bnx|Ub{ZHR9R&+fXP%bv@E_o)iVxRdSYGe(^2ML$(8;@B@U$kev}FcsZ2)=A)|0kL%Kmj(IoGPiZEg(fKIbJ6hTm^g zV<_5)wr6eIU|#_29faD`v4175MH^GGaY26>ye%XbrI8WWO0yXF1q0PHP&pU5{C*R+ zfc7?wgL1}_snev)Nf!l5##-f!HB)Uru)uIRO!4?JtL&H)L$B8TEwd1nLHB|rJT%T_ zz9lAGr2;edf1^;T<4Whp-eG0-{n=W6x_}O(r{qYe4CbR3Y?)}^8B`k^8);~0uDY;G zKHiymc$u0a3wc}NK-VV@sti~PM!dpP*9Ra49CVBwXmoo!2EJa#KdBD}Gc#-(QUKDc zW$7DRD$br`l9m5Zt2FhCGz(n!E1*>jU^$L+?2pIc0ssqtQlICK%RC?LQ;hg9jk+?l zJ<~^Mxr5{5A*`=W}M~p;djoMvSuuC#vRQN zIgIuBl+iPDrw3)PY~H`mtFCstI$pbq15*Gx@6E2LZ_4^$UW;m}u6xAGRV;xC0OS=B zuBd)9GQYGG?FjJ7RsG}s28<(|wT+xuZ5(1$4bn%8!%^AqG>XRy>vWh%R0sd;4U)s2 zW&2d5i!o_36%j>rh>D7OdU?%EPb=&4gZ#p=$0tr%ruFpJm4Uysqo*;CVhD7A_$ z%aZ0;TW7AK%uGX?Y@?46w;}f~$G`&g4hM{}Ms}80b73S`H>e`qPpKfROkqFRm2yHu zq8OpS<-Fovyiq_`I-tq$snxGw@@{@#7#tXxZpFHxo3QGoc)|S3`F-#4#k3Y`fozQ8 z_ZU-5-4R&=xsI^-Q{bnxde2@48VXOx_IG}YBrY<&1(XcjJjvd|U}Wp6fpz_SXuO1X zdMl4)jF>67-#0dPm$9)skKhmS&B)PJw1W?y@SyLm;hS=DWeh;yT0)~wRG|%ixOiS4 z$bM@eEKA4SvR2HXPMtX^82p<}xj(FsTFa}M+$cXgqmcBIl@-Qes?{GdrnRzpezllK zC1ikIAUwENzE!30pMp`V>H_s>XyMn6tIz$psM&aNM`>Q6CNY&um!?o^L0NMsW0rP} z%dflNpFa&Jr$5iO$_i*0LpUXvJT^l! z^B;w;2Kd-1_anFs;(DKxMz?eO+ij%JF3VwOs*JgkVLSODyg&16$~;i=m!u1XSMy)`19=ZHdBtyrm_G9DYpRWB2L zXdi20jFVos3LcxSy-X}p>Dwx1$16yLp;jE8G=ku{^cS;Ef7JGI*a_nrxZ30gK~IE8 zkoiCdO3mZo;HQA!j5Ie}&((j1^1KWn7mRN?$7En`to5oJb)#Z~`=zr53Y1XgKl;Nq z|KVkjtqjHf$2tD1Q2i@cMQ=}yp)(fUP~%|R1Qu?SDwvwV!-gG}|%MZ#Ju@}D-i(FQ7QUF5rXY%gziBM{`UeC5BY&s`YSv@IT zIxWgiY8qLZoqL#mo2&|M$7&z0kx4pa8R%oN2x85(A%6@3#z&&c3fx8!B#;1MEhl!U z2}*b-s^Q0F({BRRA?xx=*iXM1PtPR|tH>e!!Lh^s>Pdkyn?ZE1}e?mfg@ESq((ZW zmJg#yvs)&KR6`()PZn>>-hxNR*&+j7He^!R#~mmCL4lrVWdiuj*GFBX@B4IL5+eDC zN-O*zxU|E1mpco8FGJD)S8rNxvoO)n&oF>jCN>r9v*|_ET%tZq;;=3i?zC3Nfe?o6^^b~F3)}w!#DgF)x!kc-{~=G@uqHEJsh|y zJd;IaY8DNFomRqIuRk@joPE@hh?=8MRdezQ4VxEW4*?1+DpH21Gd@8%2Hk`+dKFWIm~B+34vF>AB@PX*ALIb%Yy|a?HUj-R z>ga5gf}io@DhLb=43d(PoGVvB3u}}xR0-AjPT(P*tpvCr+)#!8f^98Qz=MX>I*WLT zA>Fc37p^8snw&0M;exQ36)ji%!k%0N3XIdH?&sBDhRn*!3IhW}JNfCwg@tlhY#b4z zI=I8#{&=>yM*0mdEYRVHD9FpZ?$73n$q+#ia8QluAJaSv-Nj7Nn2 zUOjH90xQz!Y$B+CEeQamOLsI(m^JWlpy3KkwP-Mz=ZH)bYq#`oj>h_UN^D}Va?ATX zmq3_!wlfw93CZWrpLLwKs;)S#6!Qnl&=^IyAM6uz-9WP$kmYPc8YUnv220i|+B)0L zyTBsS(hxNivd$VL7TRGlQ)OH4eq@5viwZb+Z3^pk=7DNwBhrbJ4lR%4WPsQ!==Bbi z`>?%ar=r4`qe;}9p3q?k@J45&lRMxfG;&z$eWX&msu`df5EOieA=IWI-2Bz#5v2t< zJIEBPoeLrf>>erP_@ewUfgB-D3(_T>hS z!}X-c?=j%`#|>|@s$=HB9NmZf)Yt-rO-wEsDbCA#G^(w>whp3Ne=ORkIx^RD2c7)p zkxs)af*|7yrkGj7MDT=+SMRVup>##k{1Wlf5kThW=TA-P-TmGV#t9FlL>Yvp%4aj6 z^ZFaFVDz^$JkF!v+ng=4a3E0Al1GTs<0e}SBv+S+0YKUSIey6JF$Cz66;r$Sf96C= z;|RK=v*A@mf=-(aMa$)ocKd(23;v_?x7~FgLKYEU{{Xw3uq-R)80;MQwM|5dn-Nj| zL(zV$f?2K@_c7y&Qh%Dko^yYKLN?Kjv6!2~)^IkM=88+8ZqO~?%6zF{5|LU<*^K-0 zcn{8y-P{s8YYfjJspa_uKz2m>tjpNM<0?M|{w3%&rI&Kqf4c4i0El`{F0jXyoFr^w zogO_GiHnO-XkE0nzkpsUW*5G98m3RR5ML|Cj1hu!%|XFE(N7DdAUB;JX94B+^%>D< z2p=n(qm5@ttF)*RPt3UHb7fkbfRc_a8_nwgR+X#Tyo6WmDsH)-%2hJCnS0rHWJ!%y z3U%+by#zZgY(Ev8Qukx9(YU%`0sjYE4#%@|aOTjnvmJ>KX-C^n2#YN(d885yJG!zy z0EXzK`jg_vQK`4=n zTnryOTWx~taD(_W#+;b+FM@nujE6~dVj5A7u)^2ZOCu{RaP zR~^RXjzwI?|1ryO4(wjC9f#x2&8|il!0y!HpcHbF8^L-V8alR`K}(LAB%vNGm3|m zP~{6Zm!2Nak#qcchS1!>$dbZN??W(AvpScc5i(={uPri6N%PmfmixbKVS~6zZ*wLautq`#zPuYCGilQKqGpsd znVK6#`nbi%p6r2~-Cnc)!Hw#M*)e;5%*&mZ&kK5KUOAz-tIGsOAkO&MNfyltnc3%Q z65LSSSH8)9$oN$9v@Y1H_1{jkovq=u=Hq_@9Q4DD=f%214tsT3tCEm5g~2~ex3rFV zwBf&;osXNBVT0^bYffcdTfah%A5cA1di+NfmL0&`&*v=#`Jd zb8taabIO{c{k{w$*2U?en5jim)Rp0L@1Nv+&`si96!f5VapR|P#*@-47j{J}MKGP{ zX~A7B4vv!(z=mZ?*gT7GDJ+PJyd`2i3mw%P9_E0(_;5`kNKDhaO&$*8j*$Yl5h&@o zlOJ!3<*(G14Gb zDnDa=t)y^#v+JHgwn?&?Mm=|y{3a!?THuL=G%CuPAhgy9Z-`HeyHJJem8%l2FVhfh zbx5!*0};2A*ZarG%J3PStpdrvG+pf&b1pIA1`?xB+KaU7bWrKwAMvNbgTkCCLytB@ zU(1~MU01amJS~6%PPgbw{pKOm0(d4&A}+P4`S6=Nm4-Ol*-JQ{eJNB4~%@;#1!e z+rYz~E*64u--nyn3ZbQwx;eO3EAleIj~7l;3g)hBDVnrK8jp9gwzVlTWrSO%m=PHL z{JH&Kq(n95NFHtDAgDDuu^&SwQR+X@0FrcMjJH=*?OoHi*wj^*#+UhNUJ^`e-c*A4c2q3NIhE z$7rs5|5{Nbpy}ruY(WPsc4Dw!^?R^sSg*EB!7!#ha86_s$~Ei1-E&w^!g73p9h%ZY zAT&v0P=hvjg8k2~7+@fXFEmBQZX^A}qdy}N<(XrWP$OeHa01fyTh`3pKQfKc1Q@kS zHETu9ZP|m6auY=9Jf)8Wov;E0)Xv~yD*F2RAJ8gzQ8i_>s))g4oZAc2&qaXoD^GTC zT!L~A3s@O-`M8X1^#P&%bKozuzbV0PqmxCjMB zu~L&hdy)KNHCUNF$n?MnofkuI@%C$C^Hetx;ivea)ftrw?slP9+4R;HcqJc$OvK!b ziQhG+O9TqNmrS5;?}#v*!am>OTn)(9C2&75N99?0F0;$2I#W`CAovn^ari=*K4hXA z_vASjI_RrddzNNsUy46X-H7|FEalzK_;LpywyE~^Y1&*>%7%$*Uu$Qxu^#Kbv`P+7 zT&G48horrpO3==q8TeKe$scuGYYjC7~Y+D^eP zQ<*TbOi{+-m!o=>uauVMy5X6kVz{-^qlo8P=>u5wV|t+|K^be`6ee#VW9a|bS@##{=v)-#(tWHL(- zOeRK2jmc28p309Er|0H_X@u#lDj_NifNwG2#6#W$a>4?woUv-Nv}Agfo1B!c<$tlh z351Mo;XgjkrZEPBW)ANTKmSox1+sY+)E~ecFSj)_0PN`S_xHES z*W!rkU;I}6_ISGh;HUgfJcaPDt7S<9M ze83!{AOG!^a@I7Id`Ae63whvxrT^Ol9RNZ3dyNvsUjH0sLUK}~%q;2`BZ**A+(8cu z7jr+fHu45v7;IXAUvxB)wn$c1@~?^K=J(%Wp`%XnmX>h^3c%px{1jucCAuG@P=fKa zM1C9PuNV(KtuU1dh2xu-Rw~$9KJ2mw(&wl-VHIz}Gg+-h+ah-SG7E)vNxTT9pZf~6 zsYrxF9TR^362t&!?FJQoJ=(sPQL8!Z6syn*sZDtJMTrb-twGMT4!W>Tw&Tn7v~Fmy z#)$?-JR+($-Vws(V|)flH~~{d;!KdsQpox=gC{G)*dK-)f%2ZfPrEE{s>3hO^M{I# zgb7wW+1%c5V}h?PBP<{XsWy+}RG4m|hb2Tpot+01>&V-vnAM;~WcUZh&UajT)gTQF zSvY%e2^mHHi$uV&=91hLAr5kYPj%!)W*f*OdXaphxTd?(w9uzfvHLbAUNww{D-f1*pyDKbMOrz2I2fRK7r7A=Po)q>J63MDTO2wqm zKq_~p`Yg;z-i{fJzu}pAw1-;_!VcB^+(n1^o#o4jkS`&`XgE1@c>Au*M2F5jqx3HL zp|4BNP%ZWfWtl)mz*GQ=U=QYWP)q$-&6f%0ddhx9e>=~VfxoAJkea*|#9$hT@{bZK zJIHGRTfV6RvXTUC^?zV{Q@}}yZ|cy1%kmjKd5eCqKkT!a3c-zu@+s2L2-}wZR zmx~1U&9B$>pD3OgziUJzra?BqA>F*-pw*-E%Z4k-X=yxe0z^p9(t0rshzB~owN9mQ zwEP(>SR&>AZ>~B$4dkk?C%#HOM<~memWf@0T_~h2{+mRwEF3!T(`dE+O$4hYqY|Da zEDC`1|FVEh^ z(f@}+-D6sGQesSQbMig(%p&%Dww$d(Wt?Oe7Me8S{L-{!02Fawa)6)g5}F&EoR+x^0^)710@{4gl>y=fDXhMMF#7Y)_{DD;zX>{} z3xztIZI7u=rMR%R)(~qe(Tp)@x63h|t%BsoIcrjr-WBMApYBr8AaV`>1RDCwWFT@> zHSn1hJnt_7@#B9AeCxm51YVqKz>;4n5unei1|E4amBB>2zh{#WA)l0$%tKj8Jufpt zs7*b~!L~%dfZwmkP#lE826k_s=4R|51wE@$USh3Z>GX;M&rk7lVk~wyv9Zay4S^T# ziy93UE{JE?a8m4>x`5hR5hx+`BB3lDL=>}!0aUUf$Yx=*H|;OpUY#slef4G2Ub4e% z{tV|7-xYHOp^YV?3xD?}6Qna@o=nzM_*p4pYnkls-~(d_LS*2iz7oaXi}uM08dwfk z6N_2QDSSZ{=fxX5&{`1>P@s@j&NahNe7u*gKQ1E$w zRWRq8Q;Jv$q4p20nMrJid{uP{z!~a-D0UbdxoKorDgHNQ=r<35dJtEt)dFc;7Yh=w z5*G#DVnr7#d0%KKfMiwq?5UymDF1PHcxPC?-i<4ntN>#pk!v@8q0oR(MKcp4 zH!w;<*3ckx41SQw7kD7|%hpSEzSnvYp(uC!2W7n%XVk0`VGJH>29)H~WQ(60!~Y+v Ck!u(L literal 0 HcmV?d00001 diff --git a/compiler/win_flex_bison/custom_build_rules/docs/BisonProperties.png b/compiler/win_flex_bison/custom_build_rules/docs/BisonProperties.png new file mode 100644 index 0000000000000000000000000000000000000000..309365884771fa0c6be1086bcf17ae0b9ec5dfc4 GIT binary patch literal 27186 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 literal 0 HcmV?d00001 diff --git a/compiler/win_flex_bison/custom_build_rules/docs/Properties.png b/compiler/win_flex_bison/custom_build_rules/docs/Properties.png new file mode 100644 index 0000000000000000000000000000000000000000..e636e764fe0d03d42a2c16ff0c6ec11efc560266 GIT binary patch literal 31446 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 literal 0 HcmV?d00001 diff --git a/compiler/win_flex_bison/custom_build_rules/docs/Verbosity.png b/compiler/win_flex_bison/custom_build_rules/docs/Verbosity.png new file mode 100644 index 0000000000000000000000000000000000000000..b2997ba70a49d96ef05f409364103e6a9ab91411 GIT binary patch literal 29722 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 Jg~Ix;{vS=7cLM+b literal 0 HcmV?d00001 diff --git a/compiler/win_flex_bison/custom_build_rules/win_bison_only/win_bison_custom_build.props b/compiler/win_flex_bison/custom_build_rules/win_bison_only/win_bison_custom_build.props new file mode 100644 index 0000000..d27b3a4 --- /dev/null +++ b/compiler/win_flex_bison/custom_build_rules/win_bison_only/win_bison_custom_build.props @@ -0,0 +1,23 @@ + + + + Midl + CustomBuild + + + _SelectedFiles;$(BisonDependsOn) + + + + %(Filename).tab.cpp + %(Filename).tab.h + +start /B /WAIT /D "%(RootDir)%(Directory)" win_bison.exe [AllOptions] [AdditionalOptions] "%(Filename)%(Extension)" +exit /b %errorlevel% + %(RootDir)%(Directory)%(OutputFile);%(RootDir)%(Directory)%(DefinesFile); + Process "%(Filename)%(Extension)" bison file + + + \ No newline at end of file diff --git a/compiler/win_flex_bison/custom_build_rules/win_bison_only/win_bison_custom_build.targets b/compiler/win_flex_bison/custom_build_rules/win_bison_only/win_bison_custom_build.targets new file mode 100644 index 0000000..feb0de2 --- /dev/null +++ b/compiler/win_flex_bison/custom_build_rules/win_bison_only/win_bison_custom_build.targets @@ -0,0 +1,91 @@ + + + + + + BisonTarget + + + + $(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml + + + + + + + + @(Bison, '|') + + + + + + + + + $(ComputeLinkInputsTargets); + ComputeBisonOutput; + + + $(ComputeLibInputsTargets); + ComputeBisonOutput; + + + + + + + + + + + + \ No newline at end of file diff --git a/compiler/win_flex_bison/custom_build_rules/win_bison_only/win_bison_custom_build.xml b/compiler/win_flex_bison/custom_build_rules/win_bison_only/win_bison_custom_build.xml new file mode 100644 index 0000000..1d51e62 --- /dev/null +++ b/compiler/win_flex_bison/custom_build_rules/win_bison_only/win_bison_custom_build.xml @@ -0,0 +1,281 @@ + + + + + + + + + + General + + + + + Bison Options + + + + + Command Line + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Execute Before + + + Specifies the targets for the build customization to run before. + + + + + + + + + + + Execute After + + + Specifies the targets for the build customization to run after. + + + + + + + + + + + + + + Additional Options + + + Additional Options + + + + + + + \ No newline at end of file diff --git a/compiler/win_flex_bison/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.props b/compiler/win_flex_bison/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.props new file mode 100644 index 0000000..17317d6 --- /dev/null +++ b/compiler/win_flex_bison/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.props @@ -0,0 +1,43 @@ + + + + Midl + CustomBuild + + + _SelectedFiles;$(BisonDependsOn) + + + + %(Filename).tab.cpp + %(Filename).tab.h + +start /B /WAIT /D "%(RootDir)%(Directory)" win_bison.exe [AllOptions] [AdditionalOptions] "%(Filename)%(Extension)" +exit /b %errorlevel% + %(RootDir)%(Directory)%(OutputFile);%(RootDir)%(Directory)%(DefinesFile); + Process "%(Filename)%(Extension)" bison file + + + + Midl + CustomBuild + + + _SelectedFiles;$(FlexDependsOn) + + + + %(Filename).flex.cpp + true + +start /B /WAIT /D "%(RootDir)%(Directory)" win_flex.exe [AllOptions] [AdditionalOptions] "%(Filename)%(Extension)" +exit /b %errorlevel% + %(RootDir)%(Directory)%(OutputFile); + Process "%(Filename)%(Extension)" flex file + + + \ No newline at end of file diff --git a/compiler/win_flex_bison/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.targets b/compiler/win_flex_bison/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.targets new file mode 100644 index 0000000..2fabf74 --- /dev/null +++ b/compiler/win_flex_bison/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.targets @@ -0,0 +1,178 @@ + + + + + + BisonTarget + + + FlexTarget + + + + $(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml + + + $(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml + + + + + + + + @(Bison, '|') + + + + + + + + + $(ComputeLinkInputsTargets); + ComputeBisonOutput; + + + $(ComputeLibInputsTargets); + ComputeBisonOutput; + + + + + + + + + + + + + + + + + + @(Flex, '|') + + + + + + + + + $(ComputeLinkInputsTargets); + ComputeFlexOutput; + + + $(ComputeLibInputsTargets); + ComputeFlexOutput; + + + + + + + + + + + + \ No newline at end of file diff --git a/compiler/win_flex_bison/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.xml b/compiler/win_flex_bison/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.xml new file mode 100644 index 0000000..20c429c --- /dev/null +++ b/compiler/win_flex_bison/custom_build_rules/win_flex_bison/win_flex_bison_custom_build.xml @@ -0,0 +1,521 @@ + + + + + + + + + + General + + + + + Bison Options + + + + + Command Line + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Execute Before + + + Specifies the targets for the build customization to run before. + + + + + + + + + + + Execute After + + + Specifies the targets for the build customization to run after. + + + + + + + + + + + + + + Additional Options + + + Additional Options + + + + + + + + + + + + + + General + + + + + Flex Options + + + + + Command Line + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Execute Before + + + Specifies the targets for the build customization to run before. + + + + + + + + + + + Execute After + + + Specifies the targets for the build customization to run after. + + + + + + + + + + + + + + Additional Options + + + Additional Options + + + + + + + \ No newline at end of file diff --git a/compiler/win_flex_bison/custom_build_rules/win_flex_only/win_flex_custom_build.props b/compiler/win_flex_bison/custom_build_rules/win_flex_only/win_flex_custom_build.props new file mode 100644 index 0000000..9203b4a --- /dev/null +++ b/compiler/win_flex_bison/custom_build_rules/win_flex_only/win_flex_custom_build.props @@ -0,0 +1,23 @@ + + + + Midl + CustomBuild + + + _SelectedFiles;$(FlexDependsOn) + + + + %(Filename).flex.cpp + true + +start /B /WAIT /D "%(RootDir)%(Directory)" win_flex.exe [AllOptions] [AdditionalOptions] "%(Filename)%(Extension)" +exit /b %errorlevel% + %(RootDir)%(Directory)%(OutputFile); + Process "%(Filename)%(Extension)" flex file + + + \ No newline at end of file diff --git a/compiler/win_flex_bison/custom_build_rules/win_flex_only/win_flex_custom_build.targets b/compiler/win_flex_bison/custom_build_rules/win_flex_only/win_flex_custom_build.targets new file mode 100644 index 0000000..2e81555 --- /dev/null +++ b/compiler/win_flex_bison/custom_build_rules/win_flex_only/win_flex_custom_build.targets @@ -0,0 +1,94 @@ + + + + + + FlexTarget + + + + $(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml + + + + + + + + @(Flex, '|') + + + + + + + + + $(ComputeLinkInputsTargets); + ComputeFlexOutput; + + + $(ComputeLibInputsTargets); + ComputeFlexOutput; + + + + + + + + + + + + \ No newline at end of file diff --git a/compiler/win_flex_bison/custom_build_rules/win_flex_only/win_flex_custom_build.xml b/compiler/win_flex_bison/custom_build_rules/win_flex_only/win_flex_custom_build.xml new file mode 100644 index 0000000..a471574 --- /dev/null +++ b/compiler/win_flex_bison/custom_build_rules/win_flex_only/win_flex_custom_build.xml @@ -0,0 +1,243 @@ + + + + + + + + + + General + + + + + Flex Options + + + + + Command Line + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Execute Before + + + Specifies the targets for the build customization to run before. + + + + + + + + + + + Execute After + + + Specifies the targets for the build customization to run after. + + + + + + + + + + + + + + Additional Options + + + Additional Options + + + + + + + \ No newline at end of file diff --git a/compiler/win_flex_bison/data/README.md b/compiler/win_flex_bison/data/README.md new file mode 100644 index 0000000..09886ea --- /dev/null +++ b/compiler/win_flex_bison/data/README.md @@ -0,0 +1,227 @@ +This directory contains data needed by Bison. + +# Directory Content +## 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. + +# Implementation Notes About the Skeletons + +"Skeleton" in Bison parlance means "backend": a skeleton is fed by the bison +executable with LR tables, facts about the symbols, etc. and they generate +the output (say parser.cc, parser.hh, location.hh, etc.). They are only in +charge of generating the parser and its auxiliary files, they do not +generate the XML output, the parser.output reports, nor the graphical +rendering. + +The bits of information passing from bison to the backend is named +"muscles". Muscles are passed to M4 via its standard input: it's a set of +m4 definitions. To see them, use `--trace=muscles`. + +Except for muscles, whose names are generated by bison, the skeletons have +no constraint at all on the macro names: there is no technical/theoretical +limitation, as long as you generate the output, you can do what you want. +However, of course, that would be a bad idea if, say, the C and C++ +skeletons used different approaches and had completely different +implementations. That would be a maintenance nightmare. + +Below, we document some of the macros that we use in several of the +skeletons. If you are to write a new skeleton, please, implement them for +your language. Overall, be sure to follow the same patterns as the existing +skeletons. + +## Vocabulary + +We use "formal arguments", or "formals" for short, to denote the declared +parameters of a function (e.g., `int argc, const char **argv`). Yes, this +is somewhat contradictory with `param` in the `%param` directives. + +We use "effective arguments", or "args" for short, to denote the values +passed in function calls (e.g., `argc, argv`). + +## Symbols + +### `b4_symbol(NUM, FIELD)` +In order to unify the handling of the various aspects of symbols (tag, type +name, whether terminal, etc.), bison.exe defines one macro per (token, +field), where field can `has_id`, `id`, etc.: see +`prepare_symbol_definitions()` in `src/output.c`. + +NUM can be: +- `empty` to denote the "empty" pseudo-symbol when it exists, +- `eof`, `error`, or `undef` +- a symbol number. + +FIELD can be: + +- `has_id`: 0 or 1 + Whether the symbol has an `id`. + +- `id`: string (e.g., `exp`, `NUM`, or `TOK_NUM` with api.token.prefix) + If `has_id`, the name of the token kind (prefixed by api.token.prefix if + defined), otherwise empty. Guaranteed to be usable as a C identifier. + This is used to define the token kind (i.e., the enum used by the return + value of yylex). Should be named `token_kind`. + +- `tag`: string + A human readable representation of the symbol. Can be `'foo'`, + `'foo.id'`, `'"foo"'` etc. + +- `code`: integer + The token code associated to the token kind `id`. + The external number as used by yylex. Can be ASCII code when a character, + some number chosen by bison, or some user number in the case of `%token + FOO `. Corresponds to `yychar` in `yacc.c`. + +- `is_token`: 0 or 1 + Whether this is a terminal symbol. + +- `kind_base`: string (e.g., `YYSYMBOL_exp`, `YYSYMBOL_NUM`) + The base of the symbol kind, i.e., the enumerator of this symbol (token or + nonterminal) which is mapped to its `number`. + +- `kind`: string + Same as `kind_base`, but possibly with a prefix in some languages. E.g., + EOF's `kind_base` and `kind` are `YYSYMBOL_YYEOF` in C, but are + `S_YYEMPTY` and `symbol_kind::S_YYEMPTY` in C++. + +- `number`: integer + The code associated to the `kind`. + The internal number (computed from the external number by yytranslate). + Corresponds to yytoken in yacc.c. This is the same number that serves as + key in b4_symbol(NUM, FIELD). + + In bison, symbols are first assigned increasing numbers in order of + appearance (but tokens first, then nterms). After grammar reduction, + unused nterms are then renumbered to appear last (i.e., first tokens, then + used nterms and finally unused nterms). This final number NUM is the one + contained in this field, and it is the one used as key in `b4_symbol(NUM, + FIELD)`. + + The code of the rule actions, however, is emitted before we know what + symbols are unused, so they use the original numbers. To avoid confusion, + they actually use "orig NUM" instead of just "NUM". bison also emits + definitions for `b4_symbol(orig NUM, number)` that map from original + numbers to the new ones. `b4_symbol` actually resolves `orig NUM` in the + other case, i.e., `b4_symbol(orig 42, tag)` would return the tag of the + symbols whose original number was 42. + +- `has_type`: 0, 1 + Whether has a semantic value. + +- `type_tag`: string + When api.value.type=union, the generated name for the union member. + yytype_INT etc. for symbols that has_id, otherwise yytype_1 etc. + +- `type`: string + If it has a semantic value, its type tag, or, if variant are used, + its type. + In the case of api.value.type=union, type is the real type (e.g. int). + +- `slot`: string + If it has a semantic value, the name of the union member (i.e., bounces to + either `type_tag` or `type`). It would be better to fix our mess and + always use `type` for the true type of the member, and `type_tag` for the + name of the union member. + +- `has_printer`: 0, 1 +- `printer`: string +- `printer_file`: string +- `printer_line`: integer +- `printer_loc`: location + If the symbol has a printer, everything about it. + +- `has_destructor`, `destructor`, `destructor_file`, `destructor_line`, `destructor_loc` + Likewise. + +### `b4_symbol_value(VAL, [SYMBOL-NUM], [TYPE-TAG])` +Expansion of $$, $1, $3, etc. + +The semantic value from a given VAL. +- `VAL`: some semantic value storage (typically a union). e.g., `yylval` +- `SYMBOL-NUM`: the symbol number from which we extract the type tag. +- `TYPE-TAG`, the user forced the ``. + +The result can be used safely, it is put in parens to avoid nasty precedence +issues. + +### `b4_lhs_value(SYMBOL-NUM, [TYPE])` +Expansion of `$$` or `$$`, for symbol `SYMBOL-NUM`. + +### `b4_rhs_data(RULE-LENGTH, POS)` +The data corresponding to the symbol `#POS`, where the current rule has +`RULE-LENGTH` symbols on RHS. + +### `b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE])` +Expansion of `$POS`, where the current rule has `RULE-LENGTH` symbols +on RHS. + + diff --git a/compiler/win_flex_bison/data/bison-default.css b/compiler/win_flex_bison/data/bison-default.css new file mode 100644 index 0000000..aadaba1 --- /dev/null +++ b/compiler/win_flex_bison/data/bison-default.css @@ -0,0 +1,61 @@ +/* Default styling rules for Bison when doing terminal output. + Copyright (C) 2019-2021 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 is an experimental feature. The class names may change in the + future. */ + +/* Diagnostics. */ +.warning { color: purple; } +.error { color: red; } +.note { color: cyan; } + +.fixit-insert { color: green; } + +/* Semantic values in Bison's own parser traces. */ +.value { color: green; } + +/* "Sections" in traces (--trace). */ +.trace0 { color: green; } + +/* Syntax error messages. */ +.expected { color: green; } +.unexpected { color: red; } + + +/* Counterexamples. */ + +/* Cex: point in rule. */ +.cex-dot { color: red; } + +/* Cex: coloring various rules. */ +.cex-0 { color: yellow; } +.cex-1 { color: green; } +.cex-2 { color: blue; } +.cex-3 { color: purple; } +.cex-4 { color: violet; } +.cex-5 { color: orange; } +.cex-6 { color: brown; } +.cex-7 { color: mauve; } +.cex-8 { color: #013220; } /* Dark green. */ +.cex-9 { color: #e75480; } /* Dark pink. */ +.cex-10 { color: cyan; } +.cex-11 { color: orange; } + +/* Cex: derivation rewriting steps. */ +.cex-step { font-style: italic; } + +/* Cex: leaves of a derivation. */ +.cex-leaf { font-weight: 600; } diff --git a/compiler/win_flex_bison/data/local.mk b/compiler/win_flex_bison/data/local.mk new file mode 100644 index 0000000..c51d287 --- /dev/null +++ b/compiler/win_flex_bison/data/local.mk @@ -0,0 +1,58 @@ +## Copyright (C) 2002, 2005-2015, 2018-2021 Free Software Foundation, +## Inc. + +## This program is free software: you can redistribute it and/or modify +## it under the terms of the GNU General Public License as published by +## the Free Software Foundation, either version 3 of the License, or +## (at your option) any later version. +## +## This program is distributed in the hope that it will be useful, +## but WITHOUT ANY WARRANTY; without even the implied warranty of +## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +## GNU General Public License for more details. +## +## You should have received a copy of the GNU General Public License +## along with this program. If not, see . + +dist_pkgdata_DATA = \ + data/README.md \ + data/bison-default.css + +skeletonsdir = $(pkgdatadir)/skeletons +dist_skeletons_DATA = \ + data/skeletons/bison.m4 \ + data/skeletons/c++-skel.m4 \ + data/skeletons/c++.m4 \ + data/skeletons/c-like.m4 \ + data/skeletons/c-skel.m4 \ + data/skeletons/c.m4 \ + data/skeletons/glr.c \ + data/skeletons/glr.cc \ + data/skeletons/glr2.cc \ + data/skeletons/java-skel.m4 \ + data/skeletons/java.m4 \ + data/skeletons/lalr1.cc \ + data/skeletons/lalr1.java \ + data/skeletons/location.cc \ + data/skeletons/stack.hh \ + data/skeletons/traceon.m4 \ + data/skeletons/variant.hh \ + data/skeletons/yacc.c + +# Experimental support for the D language. +dist_skeletons_DATA += \ + data/skeletons/d-skel.m4 \ + data/skeletons/d.m4 \ + data/skeletons/lalr1.d + +m4sugardir = $(pkgdatadir)/m4sugar +dist_m4sugar_DATA = \ + data/m4sugar/foreach.m4 \ + data/m4sugar/m4sugar.m4 + +xsltdir = $(pkgdatadir)/xslt +dist_xslt_DATA = \ + data/xslt/bison.xsl \ + data/xslt/xml2dot.xsl \ + data/xslt/xml2text.xsl \ + data/xslt/xml2xhtml.xsl diff --git a/compiler/win_flex_bison/data/m4sugar/foreach.m4 b/compiler/win_flex_bison/data/m4sugar/foreach.m4 new file mode 100644 index 0000000..2052d44 --- /dev/null +++ b/compiler/win_flex_bison/data/m4sugar/foreach.m4 @@ -0,0 +1,362 @@ +# -*- Autoconf -*- +# This file is part of Autoconf. +# foreach-based replacements for recursive functions. +# Speeds up GNU M4 1.4.x by avoiding quadratic $@ recursion, but penalizes +# GNU M4 1.6 by requiring more memory and macro expansions. +# +# Copyright (C) 2008-2017, 2020 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see . + +# Written by Eric Blake. + +# In M4 1.4.x, every byte of $@ is rescanned. This means that an +# algorithm on n arguments that recurses with one less argument each +# iteration will scan n * (n + 1) / 2 arguments, for O(n^2) time. In +# M4 1.6, this was fixed so that $@ is only scanned once, then +# back-references are made to information stored about the scan. +# Thus, n iterations need only scan n arguments, for O(n) time. +# Additionally, in M4 1.4.x, recursive algorithms did not clean up +# memory very well, requiring O(n^2) memory rather than O(n) for n +# iterations. +# +# This file is designed to overcome the quadratic nature of $@ +# recursion by writing a variant of m4_foreach that uses m4_for rather +# than $@ recursion to operate on the list. This involves more macro +# expansions, but avoids the need to rescan a quadratic number of +# arguments, making these replacements very attractive for M4 1.4.x. +# On the other hand, in any version of M4, expanding additional macros +# costs additional time; therefore, in M4 1.6, where $@ recursion uses +# fewer macros, these replacements actually pessimize performance. +# Additionally, the use of $10 to mean the tenth argument violates +# POSIX; although all versions of m4 1.4.x support this meaning, a +# future m4 version may switch to take it as the first argument +# concatenated with a literal 0, so the implementations in this file +# are not future-proof. Thus, this file is conditionally included as +# part of m4_init(), only when it is detected that M4 probably has +# quadratic behavior (ie. it lacks the macro __m4_version__). +# +# Please keep this file in sync with m4sugar.m4. + +# _m4_foreach(PRE, POST, IGNORED, ARG...) +# --------------------------------------- +# Form the common basis of the m4_foreach and m4_map macros. For each +# ARG, expand PRE[ARG]POST[]. The IGNORED argument makes recursion +# easier, and must be supplied rather than implicit. +# +# This version minimizes the number of times that $@ is evaluated by +# using m4_for to generate a boilerplate into _m4_f then passing $@ to +# that temporary macro. Thus, the recursion is done in m4_for without +# reparsing any user input, and is not quadratic. For an idea of how +# this works, note that m4_foreach(i,[1,2],[i]) calls +# _m4_foreach([m4_define([i],],[)i],[],[1],[2]) +# which defines _m4_f: +# $1[$4]$2[]$1[$5]$2[]_m4_popdef([_m4_f]) +# then calls _m4_f([m4_define([i],],[)i],[],[1],[2]) for a net result: +# m4_define([i],[1])i[]m4_define([i],[2])i[]_m4_popdef([_m4_f]). +m4_define([_m4_foreach], +[m4_if([$#], [3], [], + [m4_pushdef([_m4_f], _m4_for([4], [$#], [1], + [$0_([1], [2],], [)])[_m4_popdef([_m4_f])])_m4_f($@)])]) + +m4_define([_m4_foreach_], +[[$$1[$$3]$$2[]]]) + +# m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) +# ----------------------------------------------------------- +# Find the first VAL that SWITCH matches, and expand the corresponding +# IF-VAL. If there are no matches, expand DEFAULT. +# +# Use m4_for to create a temporary macro in terms of a boilerplate +# m4_if with final cleanup. If $# is even, we have DEFAULT; if it is +# odd, then rounding the last $# up in the temporary macro is +# harmless. For example, both m4_case(1,2,3,4,5) and +# m4_case(1,2,3,4,5,6) result in the intermediate _m4_case being +# m4_if([$1],[$2],[$3],[$1],[$4],[$5],_m4_popdef([_m4_case])[$6]) +m4_define([m4_case], +[m4_if(m4_eval([$# <= 2]), [1], [$2], +[m4_pushdef([_$0], [m4_if(]_m4_for([2], m4_eval([($# - 1) / 2 * 2]), [2], + [_$0_(], [)])[_m4_popdef( + [_$0])]m4_dquote($m4_eval([($# + 1) & ~1]))[)])_$0($@)])]) + +m4_define([_m4_case_], +[$0_([1], [$1], m4_incr([$1]))]) + +m4_define([_m4_case__], +[[[$$1],[$$2],[$$3],]]) + +# m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) +# ----------------------------------------------------- +# m4 equivalent of +# +# if (SWITCH =~ RE1) +# VAL1; +# elif (SWITCH =~ RE2) +# VAL2; +# elif ... +# ... +# else +# DEFAULT +# +# We build the temporary macro _m4_b: +# m4_define([_m4_b], _m4_defn([_m4_bmatch]))_m4_b([$1], [$2], [$3])... +# _m4_b([$1], [$m-1], [$m])_m4_b([], [], [$m+1]_m4_popdef([_m4_b])) +# then invoke m4_unquote(_m4_b($@)), for concatenation with later text. +m4_define([m4_bmatch], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [$2], + [m4_pushdef([_m4_b], [m4_define([_m4_b], + _m4_defn([_$0]))]_m4_for([3], m4_eval([($# + 1) / 2 * 2 - 1]), + [2], [_$0_(], [)])[_m4_b([], [],]m4_dquote([$]m4_eval( + [($# + 1) / 2 * 2]))[_m4_popdef([_m4_b]))])m4_unquote(_m4_b($@))])]) + +m4_define([_m4_bmatch], +[m4_if(m4_bregexp([$1], [$2]), [-1], [], [[$3]m4_define([$0])])]) + +m4_define([_m4_bmatch_], +[$0_([1], m4_decr([$1]), [$1])]) + +m4_define([_m4_bmatch__], +[[_m4_b([$$1], [$$2], [$$3])]]) + + +# m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT]) +# ------------------------------------------------------------------- +# Similar to m4_if, except that each TEST is expanded when encountered. +# If the expansion of TESTn matches the string VALn, the result is IF-VALn. +# The result is DEFAULT if no tests passed. This macro allows +# short-circuiting of expensive tests, where it pays to arrange quick +# filter tests to run first. +# +# m4_cond already guarantees either 3*n or 3*n + 1 arguments, 1 <= n. +# We only have to speed up _m4_cond, by building the temporary _m4_c: +# m4_define([_m4_c], _m4_defn([m4_unquote]))_m4_c([m4_if(($1), [($2)], +# [[$3]m4_define([_m4_c])])])_m4_c([m4_if(($4), [($5)], +# [[$6]m4_define([_m4_c])])])..._m4_c([m4_if(($m-2), [($m-1)], +# [[$m]m4_define([_m4_c])])])_m4_c([[$m+1]]_m4_popdef([_m4_c])) +# We invoke m4_unquote(_m4_c($@)), for concatenation with later text. +m4_define([_m4_cond], +[m4_pushdef([_m4_c], [m4_define([_m4_c], + _m4_defn([m4_unquote]))]_m4_for([2], m4_eval([$# / 3 * 3 - 1]), [3], + [$0_(], [)])[_m4_c(]m4_dquote(m4_dquote( + [$]m4_eval([$# / 3 * 3 + 1])))[_m4_popdef([_m4_c]))])m4_unquote(_m4_c($@))]) + +m4_define([_m4_cond_], +[$0_(m4_decr([$1]), [$1], m4_incr([$1]))]) + +m4_define([_m4_cond__], +[[_m4_c([m4_if(($$1), [($$2)], [[$$3]m4_define([_m4_c])])])]]) + +# m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) +# ---------------------------------------------------- +# m4 equivalent of +# +# $_ = STRING; +# s/RE1/SUBST1/g; +# s/RE2/SUBST2/g; +# ... +# +# m4_bpatsubsts already validated an odd number of arguments; we only +# need to speed up _m4_bpatsubsts. To avoid nesting, we build the +# temporary _m4_p: +# m4_define([_m4_p], [$1])m4_define([_m4_p], +# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$2], [$3]))m4_define([_m4_p], +# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$4], [$5]))m4_define([_m4_p],... +# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$m-1], [$m]))m4_unquote( +# _m4_defn([_m4_p])_m4_popdef([_m4_p])) +m4_define([_m4_bpatsubsts], +[m4_pushdef([_m4_p], [m4_define([_m4_p], + ]m4_dquote([$]1)[)]_m4_for([3], [$#], [2], [$0_(], + [)])[m4_unquote(_m4_defn([_m4_p])_m4_popdef([_m4_p]))])_m4_p($@)]) + +m4_define([_m4_bpatsubsts_], +[$0_(m4_decr([$1]), [$1])]) + +m4_define([_m4_bpatsubsts__], +[[m4_define([_m4_p], +m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$$1], [$$2]))]]) + +# m4_shiftn(N, ...) +# ----------------- +# Returns ... shifted N times. Useful for recursive "varargs" constructs. +# +# m4_shiftn already validated arguments; we only need to speed up +# _m4_shiftn. If N is 3, then we build the temporary _m4_s, defined as +# ,[$5],[$6],...,[$m]_m4_popdef([_m4_s]) +# before calling m4_shift(_m4_s($@)). +m4_define([_m4_shiftn], +[m4_if(m4_incr([$1]), [$#], [], [m4_pushdef([_m4_s], + _m4_for(m4_eval([$1 + 2]), [$#], [1], + [[,]m4_dquote($], [)])[_m4_popdef([_m4_s])])m4_shift(_m4_s($@))])]) + +# m4_do(STRING, ...) +# ------------------ +# This macro invokes all its arguments (in sequence, of course). It is +# useful for making your macros more structured and readable by dropping +# unnecessary dnl's and have the macros indented properly. +# +# Here, we use the temporary macro _m4_do, defined as +# $1[]$2[]...[]$n[]_m4_popdef([_m4_do]) +m4_define([m4_do], +[m4_if([$#], [0], [], + [m4_pushdef([_$0], _m4_for([1], [$#], [1], + [$], [[[]]])[_m4_popdef([_$0])])_$0($@)])]) + +# m4_dquote_elt(ARGS) +# ------------------- +# Return ARGS as an unquoted list of double-quoted arguments. +# +# _m4_foreach to the rescue. +m4_define([m4_dquote_elt], +[m4_if([$#], [0], [], [[[$1]]_m4_foreach([,m4_dquote(], [)], $@)])]) + +# m4_reverse(ARGS) +# ---------------- +# Output ARGS in reverse order. +# +# Invoke _m4_r($@) with the temporary _m4_r built as +# [$m], [$m-1], ..., [$2], [$1]_m4_popdef([_m4_r]) +m4_define([m4_reverse], +[m4_if([$#], [0], [], [$#], [1], [[$1]], +[m4_pushdef([_m4_r], [[$$#]]_m4_for(m4_decr([$#]), [1], [-1], + [[, ]m4_dquote($], [)])[_m4_popdef([_m4_r])])_m4_r($@)])]) + + +# m4_map_args_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...) +# ------------------------------------------------------------- +# Perform a pairwise grouping of consecutive ARGs, by expanding +# EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the +# final argument is expanded with END-EXPR([ARGn]). +# +# Build the temporary macro _m4_map_args_pair, with the $2([$m+1]) +# only output if $# is odd: +# $1([$3], [$4])[]$1([$5], [$6])[]...$1([$m-1], +# [$m])[]m4_default([$2], [$1])([$m+1])[]_m4_popdef([_m4_map_args_pair]) +m4_define([m4_map_args_pair], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [m4_fatal([$0: too few arguments: $#: $1])], + [$#], [2], [], + [$#], [3], [m4_default([$2], [$1])([$3])[]], + [m4_pushdef([_$0], _m4_for([3], + m4_eval([$# / 2 * 2 - 1]), [2], [_$0_(], [)])_$0_end( + [1], [2], [$#])[_m4_popdef([_$0])])_$0($@)])]) + +m4_define([_m4_map_args_pair_], +[$0_([1], [$1], m4_incr([$1]))]) + +m4_define([_m4_map_args_pair__], +[[$$1([$$2], [$$3])[]]]) + +m4_define([_m4_map_args_pair_end], +[m4_if(m4_eval([$3 & 1]), [1], [[m4_default([$$2], [$$1])([$$3])[]]])]) + +# m4_join(SEP, ARG1, ARG2...) +# --------------------------- +# Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG +# is the empty string. No expansion is performed on SEP or ARGs. +# +# Use a self-modifying separator, since we don't know how many +# arguments might be skipped before a separator is first printed, but +# be careful if the separator contains $. _m4_foreach to the rescue. +m4_define([m4_join], +[m4_pushdef([_m4_sep], [m4_define([_m4_sep], _m4_defn([m4_echo]))])]dnl +[_m4_foreach([_$0([$1],], [)], $@)_m4_popdef([_m4_sep])]) + +m4_define([_m4_join], +[m4_if([$2], [], [], [_m4_sep([$1])[$2]])]) + +# m4_joinall(SEP, ARG1, ARG2...) +# ------------------------------ +# Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP. +# No expansion is performed on SEP or ARGs. +# +# A bit easier than m4_join. _m4_foreach to the rescue. +m4_define([m4_joinall], +[[$2]m4_if(m4_eval([$# <= 2]), [1], [], + [_m4_foreach([$1], [], m4_shift($@))])]) + +# m4_list_cmp(A, B) +# ----------------- +# Compare the two lists of integer expressions A and B. +# +# m4_list_cmp takes care of any side effects; we only override +# _m4_list_cmp_raw, where we can safely expand lists multiple times. +# First, insert padding so that both lists are the same length; the +# trailing +0 is necessary to handle a missing list. Next, create a +# temporary macro to perform pairwise comparisons until an inequality +# is found. For example, m4_list_cmp([1], [1,2]) creates _m4_cmp as +# m4_if(m4_eval([($1) != ($3)]), [1], [m4_cmp([$1], [$3])], +# m4_eval([($2) != ($4)]), [1], [m4_cmp([$2], [$4])], +# [0]_m4_popdef([_m4_cmp])) +# then calls _m4_cmp([1+0], [0*2], [1], [2+0]) +m4_define([_m4_list_cmp_raw], +[m4_if([$1], [$2], 0, + [_m4_list_cmp($1+0_m4_list_pad(m4_count($1), m4_count($2)), + $2+0_m4_list_pad(m4_count($2), m4_count($1)))])]) + +m4_define([_m4_list_pad], +[m4_if(m4_eval($1 < $2), [1], + [_m4_for(m4_incr([$1]), [$2], [1], [,0*])])]) + +m4_define([_m4_list_cmp], +[m4_pushdef([_m4_cmp], [m4_if(]_m4_for( + [1], m4_eval([$# >> 1]), [1], [$0_(], [,]m4_eval([$# >> 1])[)])[ + [0]_m4_popdef([_m4_cmp]))])_m4_cmp($@)]) + +m4_define([_m4_list_cmp_], +[$0_([$1], m4_eval([$1 + $2]))]) + +m4_define([_m4_list_cmp__], +[[m4_eval([($$1) != ($$2)]), [1], [m4_cmp([$$1], [$$2])], +]]) + +# m4_max(EXPR, ...) +# m4_min(EXPR, ...) +# ----------------- +# Return the decimal value of the maximum (or minimum) in a series of +# integer expressions. +# +# _m4_foreach to the rescue; we only need to replace _m4_minmax. Here, +# we need a temporary macro to track the best answer so far, so that +# the foreach expression is tractable. +m4_define([_m4_minmax], +[m4_pushdef([_m4_best], m4_eval([$2]))_m4_foreach( + [m4_define([_m4_best], $1(_m4_best,], [))], m4_shift($@))]dnl +[_m4_best[]_m4_popdef([_m4_best])]) + +# m4_set_add_all(SET, VALUE...) +# ----------------------------- +# Add each VALUE into SET. This is O(n) in the number of VALUEs, and +# can be faster than calling m4_set_add for each VALUE. +# +# _m4_foreach to the rescue. If no deletions have occurred, then +# avoid the speed penalty of m4_set_add. +m4_define([m4_set_add_all], +[m4_if([$#], [0], [], [$#], [1], [], + [m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1]) + + m4_len(_m4_foreach(m4_ifdef([_m4_set_cleanup($1)], + [[m4_set_add]], [[_$0]])[([$1],], [)], $@))))])]) + +m4_define([_m4_set_add_all], +[m4_ifdef([_m4_set([$1],$2)], [], + [m4_define([_m4_set([$1],$2)], + [1])m4_pushdef([_m4_set([$1])], [$2])-])]) diff --git a/compiler/win_flex_bison/data/m4sugar/m4sugar.m4 b/compiler/win_flex_bison/data/m4sugar/m4sugar.m4 new file mode 100644 index 0000000..b42fc1a --- /dev/null +++ b/compiler/win_flex_bison/data/m4sugar/m4sugar.m4 @@ -0,0 +1,3329 @@ +divert(-1)# -*- Autoconf -*- +# This file is part of Autoconf. +# Base M4 layer. +# Requires GNU M4. +# +# Copyright (C) 1999-2017, 2020 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see . + +# Written by Akim Demaille. + +# Set the quotes, whatever the current quoting system. +changequote() +changequote([, ]) + +# Some old m4's don't support m4exit. But they provide +# equivalent functionality by core dumping because of the +# long macros we define. +ifdef([__gnu__], , +[errprint(M4sugar requires GNU M4. Install it before installing M4sugar or +set the M4 environment variable to its absolute file name.) +m4exit(2)]) + + +## ------------------------------- ## +## 1. Simulate --prefix-builtins. ## +## ------------------------------- ## + +# m4_define +# m4_defn +# m4_undefine +define([m4_define], defn([define])) +define([m4_defn], defn([defn])) +define([m4_undefine], defn([undefine])) + +m4_undefine([define]) +m4_undefine([defn]) +m4_undefine([undefine]) + + +# m4_copy(SRC, DST) +# ----------------- +# Define DST as the definition of SRC. +# What's the difference between: +# 1. m4_copy([from], [to]) +# 2. m4_define([to], [from($@)]) +# Well, obviously 1 is more expensive in space. Maybe 2 is more expensive +# in time, but because of the space cost of 1, it's not that obvious. +# Nevertheless, one huge difference is the handling of `$0'. If `from' +# uses `$0', then with 1, `to''s `$0' is `to', while it is `from' in 2. +# The user would certainly prefer to see `to'. +# +# This definition is in effect during m4sugar initialization, when +# there are no pushdef stacks; later on, we redefine it to something +# more powerful for all other clients to use. +m4_define([m4_copy], +[m4_define([$2], m4_defn([$1]))]) + + +# m4_rename(SRC, DST) +# ------------------- +# Rename the macro SRC to DST. +m4_define([m4_rename], +[m4_copy([$1], [$2])m4_undefine([$1])]) + + +# m4_rename_m4(MACRO-NAME) +# ------------------------ +# Rename MACRO-NAME to m4_MACRO-NAME. +m4_define([m4_rename_m4], +[m4_rename([$1], [m4_$1])]) + + +# m4_copy_unm4(m4_MACRO-NAME) +# --------------------------- +# Copy m4_MACRO-NAME to MACRO-NAME. +m4_define([m4_copy_unm4], +[m4_copy([$1], m4_bpatsubst([$1], [^m4_\(.*\)], [[\1]]))]) + + +# Some m4 internals have names colliding with tokens we might use. +# Rename them a` la `m4 --prefix-builtins'. Conditionals first, since +# some subsequent renames are conditional. +m4_rename_m4([ifdef]) +m4_rename([ifelse], [m4_if]) + +m4_rename_m4([builtin]) +m4_rename_m4([changecom]) +m4_rename_m4([changequote]) +m4_ifdef([changeword],dnl conditionally available in 1.4.x +[m4_undefine([changeword])]) +m4_rename_m4([debugfile]) +m4_rename_m4([debugmode]) +m4_rename_m4([decr]) +m4_rename_m4([divnum]) +m4_rename_m4([dumpdef]) +m4_rename_m4([errprint]) +m4_rename_m4([esyscmd]) +m4_rename_m4([eval]) +m4_rename_m4([format]) +m4_undefine([include]) +m4_rename_m4([incr]) +m4_rename_m4([index]) +m4_rename_m4([indir]) +m4_rename_m4([len]) +m4_rename([m4exit], [m4_exit]) +m4_undefine([m4wrap]) +m4_ifdef([mkstemp],dnl added in M4 1.4.8 +[m4_rename_m4([mkstemp]) +m4_copy([m4_mkstemp], [m4_maketemp]) +m4_undefine([maketemp])], +[m4_rename_m4([maketemp]) +m4_copy([m4_maketemp], [m4_mkstemp])]) +m4_rename([patsubst], [m4_bpatsubst]) +m4_rename_m4([popdef]) +m4_rename_m4([pushdef]) +m4_rename([regexp], [m4_bregexp]) +m4_rename_m4([shift]) +m4_undefine([sinclude]) +m4_rename_m4([substr]) +m4_ifdef([symbols],dnl present only in alpha-quality 1.4o +[m4_rename_m4([symbols])]) +m4_rename_m4([syscmd]) +m4_rename_m4([sysval]) +m4_rename_m4([traceoff]) +m4_rename_m4([traceon]) +m4_rename_m4([translit]) + +# _m4_defn(ARG) +# ------------- +# _m4_defn is for internal use only - it bypasses the wrapper, so it +# must only be used on one argument at a time, and only on macros +# known to be defined. Make sure this still works if the user renames +# m4_defn but not _m4_defn. +m4_copy([m4_defn], [_m4_defn]) + +# _m4_divert_raw(NUM) +# ------------------- +# _m4_divert_raw is for internal use only. Use this instead of +# m4_builtin([divert], NUM), so that tracing diversion flow is easier. +m4_rename([divert], [_m4_divert_raw]) + +# _m4_popdef(ARG...) +# ------------------ +# _m4_popdef is for internal use only - it bypasses the wrapper, so it +# must only be used on macros known to be defined. Make sure this +# still works if the user renames m4_popdef but not _m4_popdef. +m4_copy([m4_popdef], [_m4_popdef]) + +# _m4_undefine(ARG...) +# -------------------- +# _m4_undefine is for internal use only - it bypasses the wrapper, so +# it must only be used on macros known to be defined. Make sure this +# still works if the user renames m4_undefine but not _m4_undefine. +m4_copy([m4_undefine], [_m4_undefine]) + +# _m4_undivert(NUM...) +# -------------------- +# _m4_undivert is for internal use only, and should always be given +# arguments. Use this instead of m4_builtin([undivert], NUM...), so +# that tracing diversion flow is easier. +m4_rename([undivert], [_m4_undivert]) + + +## ------------------- ## +## 2. Error messages. ## +## ------------------- ## + + +# m4_location +# ----------- +# Output the current file, colon, and the current line number. +m4_define([m4_location], +[__file__:__line__]) + + +# m4_errprintn(MSG) +# ----------------- +# Same as `errprint', but with the missing end of line. +m4_define([m4_errprintn], +[m4_errprint([$1 +])]) + + +# m4_warning(MSG) +# --------------- +# Warn the user. +m4_define([m4_warning], +[m4_errprintn(m4_location[: warning: $1])]) + + +# m4_fatal(MSG, [EXIT-STATUS]) +# ---------------------------- +# Fatal the user. :) +m4_define([m4_fatal], +[m4_errprintn(m4_location[: error: $1] +m4_expansion_stack)m4_exit(m4_if([$2],, 1, [$2]))]) + + +# m4_assert(EXPRESSION, [EXIT-STATUS = 1]) +# ---------------------------------------- +# This macro ensures that EXPRESSION evaluates to true, and exits if +# EXPRESSION evaluates to false. +m4_define([m4_assert], +[m4_if(m4_eval([$1]), 0, + [m4_fatal([assert failed: $1], [$2])])]) + + + +## ------------- ## +## 3. Warnings. ## +## ------------- ## + + +# _m4_warn(CATEGORY, MESSAGE, [STACK-TRACE]) +# ------------------------------------------ +# Report a MESSAGE to the user if the CATEGORY of warnings is enabled. +# This is for traces only. +# If present, STACK-TRACE is a \n-separated list of "LOCATION: MESSAGE", +# where the last line (and no other) ends with "the top level". +# +# Within m4, the macro is a no-op. This macro really matters +# when autom4te post-processes the trace output. +m4_define([_m4_warn], []) + + +# m4_warn(CATEGORY, MESSAGE) +# -------------------------- +# Report a MESSAGE to the user if the CATEGORY of warnings is enabled. +m4_define([m4_warn], +[_m4_warn([$1], [$2], +m4_ifdef([_m4_expansion_stack], [m4_expansion_stack]))]) + + + +## ------------------- ## +## 4. File inclusion. ## +## ------------------- ## + + +# We also want to neutralize include (and sinclude for symmetry), +# but we want to extend them slightly: warn when a file is included +# several times. This is, in general, a dangerous operation, because +# too many people forget to quote the first argument of m4_define. +# +# For instance in the following case: +# m4_define(foo, [bar]) +# then a second reading will turn into +# m4_define(bar, [bar]) +# which is certainly not what was meant. + +# m4_include_unique(FILE) +# ----------------------- +# Declare that the FILE was loading; and warn if it has already +# been included. +m4_define([m4_include_unique], +[m4_ifdef([m4_include($1)], + [m4_warn([syntax], [file `$1' included several times])])dnl +m4_define([m4_include($1)])]) + + +# m4_include(FILE) +# ---------------- +# Like the builtin include, but warns against multiple inclusions. +m4_define([m4_include], +[m4_include_unique([$1])dnl +m4_builtin([include], [$1])]) + + +# m4_sinclude(FILE) +# ----------------- +# Like the builtin sinclude, but warns against multiple inclusions. +m4_define([m4_sinclude], +[m4_include_unique([$1])dnl +m4_builtin([sinclude], [$1])]) + + + +## ------------------------------------ ## +## 5. Additional branching constructs. ## +## ------------------------------------ ## + +# Both `m4_ifval' and `m4_ifset' tests against the empty string. The +# difference is that `m4_ifset' is specialized on macros. +# +# In case of arguments of macros, eg. $1, it makes little difference. +# In the case of a macro `FOO', you don't want to check `m4_ifval(FOO, +# TRUE)', because if `FOO' expands with commas, there is a shifting of +# the arguments. So you want to run `m4_ifval([FOO])', but then you just +# compare the *string* `FOO' against `', which, of course fails. +# +# So you want the variation `m4_ifset' that expects a macro name as $1. +# If this macro is both defined and defined to a non empty value, then +# it runs TRUE, etc. + + +# m4_ifblank(COND, [IF-BLANK], [IF-TEXT]) +# m4_ifnblank(COND, [IF-TEXT], [IF-BLANK]) +# ---------------------------------------- +# If COND is empty, or consists only of blanks (space, tab, newline), +# then expand IF-BLANK, otherwise expand IF-TEXT. This differs from +# m4_ifval only if COND has just whitespace, but it helps optimize in +# spite of users who mistakenly leave trailing space after what they +# thought was an empty argument: +# macro( +# [] +# ) +# +# Writing one macro in terms of the other causes extra overhead, so +# we inline both definitions. +m4_define([m4_ifblank], +[m4_if(m4_translit([[$1]], [ ][ ][ +]), [], [$2], [$3])]) + +m4_define([m4_ifnblank], +[m4_if(m4_translit([[$1]], [ ][ ][ +]), [], [$3], [$2])]) + + +# m4_ifval(COND, [IF-TRUE], [IF-FALSE]) +# ------------------------------------- +# If COND is not the empty string, expand IF-TRUE, otherwise IF-FALSE. +# Comparable to m4_ifdef. +m4_define([m4_ifval], +[m4_if([$1], [], [$3], [$2])]) + + +# m4_n(TEXT) +# ---------- +# If TEXT is not empty, return TEXT and a new line, otherwise nothing. +m4_define([m4_n], +[m4_if([$1], + [], [], + [$1 +])]) + + +# m4_ifvaln(COND, [IF-TRUE], [IF-FALSE]) +# -------------------------------------- +# Same as `m4_ifval', but add an extra newline to IF-TRUE or IF-FALSE +# unless that argument is empty. +m4_define([m4_ifvaln], +[m4_if([$1], + [], [m4_n([$3])], + [m4_n([$2])])]) + + +# m4_ifset(MACRO, [IF-TRUE], [IF-FALSE]) +# -------------------------------------- +# If MACRO has no definition, or of its definition is the empty string, +# expand IF-FALSE, otherwise IF-TRUE. +m4_define([m4_ifset], +[m4_ifdef([$1], + [m4_ifval(_m4_defn([$1]), [$2], [$3])], + [$3])]) + + +# m4_ifndef(NAME, [IF-NOT-DEFINED], [IF-DEFINED]) +# ----------------------------------------------- +m4_define([m4_ifndef], +[m4_ifdef([$1], [$3], [$2])]) + + +# m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) +# ----------------------------------------------------------- +# m4 equivalent of +# switch (SWITCH) +# { +# case VAL1: +# IF-VAL1; +# break; +# case VAL2: +# IF-VAL2; +# break; +# ... +# default: +# DEFAULT; +# break; +# }. +# All the values are optional, and the macro is robust to active +# symbols properly quoted. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_case], +[m4_if([$#], 0, [], + [$#], 1, [], + [$#], 2, [$2], + [$1], [$2], [$3], + [$0([$1], m4_shift3($@))])]) + + +# m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) +# ----------------------------------------------------- +# m4 equivalent of +# +# if (SWITCH =~ RE1) +# VAL1; +# elif (SWITCH =~ RE2) +# VAL2; +# elif ... +# ... +# else +# DEFAULT +# +# All the values are optional, and the macro is robust to active symbols +# properly quoted. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_bmatch], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [$2], + [m4_if(m4_bregexp([$1], [$2]), -1, [$0([$1], m4_shift3($@))], + [$3])])]) + +# m4_argn(N, ARGS...) +# ------------------- +# Extract argument N (greater than 0) from ARGS. Example: +# m4_define([b], [B]) +# m4_argn([2], [a], [b], [c]) => b +# +# Rather than using m4_car(m4_shiftn([$1], $@)), we exploit the fact that +# GNU m4 can directly reference any argument, through an indirect macro. +m4_define([m4_argn], +[m4_assert([0 < $1])]dnl +[m4_pushdef([_$0], [_m4_popdef([_$0])]m4_dquote([$]m4_incr([$1])))_$0($@)]) + + +# m4_car(ARGS...) +# m4_cdr(ARGS...) +# --------------- +# Manipulate m4 lists. m4_car returns the first argument. m4_cdr +# bundles all but the first argument into a quoted list. These two +# macros are generally used with list arguments, with quoting removed +# to break the list into multiple m4 ARGS. +m4_define([m4_car], [[$1]]) +m4_define([m4_cdr], +[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], + [$#], 1, [], + [m4_dquote(m4_shift($@))])]) + +# _m4_cdr(ARGS...) +# ---------------- +# Like m4_cdr, except include a leading comma unless only one argument +# remains. Why? Because comparing a large list against [] is more +# expensive in expansion time than comparing the number of arguments; so +# _m4_cdr can be used to reduce the number of arguments when it is time +# to end recursion. +m4_define([_m4_cdr], +[m4_if([$#], 1, [], + [, m4_dquote(m4_shift($@))])]) + + + +# m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT]) +# ------------------------------------------------------------------- +# Similar to m4_if, except that each TEST is expanded when encountered. +# If the expansion of TESTn matches the string VALn, the result is IF-VALn. +# The result is DEFAULT if no tests passed. This macro allows +# short-circuiting of expensive tests, where it pays to arrange quick +# filter tests to run first. +# +# For an example, consider a previous implementation of _AS_QUOTE_IFELSE: +# +# m4_if(m4_index([$1], [\]), [-1], [$2], +# m4_eval(m4_index([$1], [\\]) >= 0), [1], [$2], +# m4_eval(m4_index([$1], [\$]) >= 0), [1], [$2], +# m4_eval(m4_index([$1], [\`]) >= 0), [1], [$3], +# m4_eval(m4_index([$1], [\"]) >= 0), [1], [$3], +# [$2]) +# +# Here, m4_index is computed 5 times, and m4_eval 4, even if $1 contains +# no backslash. It is more efficient to do: +# +# m4_cond([m4_index([$1], [\])], [-1], [$2], +# [m4_eval(m4_index([$1], [\\]) >= 0)], [1], [$2], +# [m4_eval(m4_index([$1], [\$]) >= 0)], [1], [$2], +# [m4_eval(m4_index([$1], [\`]) >= 0)], [1], [$3], +# [m4_eval(m4_index([$1], [\"]) >= 0)], [1], [$3], +# [$2]) +# +# In the common case of $1 with no backslash, only one m4_index expansion +# occurs, and m4_eval is avoided altogether. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_cond], +[m4_if([$#], [0], [m4_fatal([$0: cannot be called without arguments])], + [$#], [1], [$1], + m4_eval([$# % 3]), [2], [m4_fatal([$0: missing an argument])], + [_$0($@)])]) + +m4_define([_m4_cond], +[m4_if(($1), [($2)], [$3], + [$#], [3], [], + [$#], [4], [$4], + [$0(m4_shift3($@))])]) + + +## ---------------------------------------- ## +## 6. Enhanced version of some primitives. ## +## ---------------------------------------- ## + +# m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) +# ---------------------------------------------------- +# m4 equivalent of +# +# $_ = STRING; +# s/RE1/SUBST1/g; +# s/RE2/SUBST2/g; +# ... +# +# All the values are optional, and the macro is robust to active symbols +# properly quoted. +# +# I would have liked to name this macro `m4_bpatsubst', unfortunately, +# due to quotation problems, I need to double quote $1 below, therefore +# the anchors are broken :( I can't let users be trapped by that. +# +# Recall that m4_shift3 always results in an argument. Hence, we need +# to distinguish between a final deletion vs. ending recursion. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_bpatsubsts], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [m4_unquote(m4_builtin([patsubst], [[$1]], [$2]))], + [$#], 3, [m4_unquote(m4_builtin([patsubst], [[$1]], [$2], [$3]))], + [_$0($@m4_if(m4_eval($# & 1), 0, [,]))])]) +m4_define([_m4_bpatsubsts], +[m4_if([$#], 2, [$1], + [$0(m4_builtin([patsubst], [[$1]], [$2], [$3]), + m4_shift3($@))])]) + + +# m4_copy(SRC, DST) +# ----------------- +# Define the pushdef stack DST as a copy of the pushdef stack SRC; +# give an error if DST is already defined. This is particularly nice +# for copying self-modifying pushdef stacks, where the top definition +# includes one-shot initialization that is later popped to the normal +# definition. This version intentionally does nothing if SRC is +# undefined. +# +# Some macros simply can't be renamed with this method: namely, anything +# involved in the implementation of m4_stack_foreach_sep. +m4_define([m4_copy], +[m4_ifdef([$2], [m4_fatal([$0: won't overwrite defined macro: $2])], + [m4_stack_foreach_sep([$1], [m4_pushdef([$2],], [)])])]dnl +[m4_ifdef([m4_location($1)], [m4_define([m4_location($2)], m4_location)])]) + + +# m4_copy_force(SRC, DST) +# m4_rename_force(SRC, DST) +# ------------------------- +# Like m4_copy/m4_rename, except blindly overwrite any existing DST. +# Note that m4_copy_force tolerates undefined SRC, while m4_rename_force +# does not. +m4_define([m4_copy_force], +[m4_ifdef([$2], [_m4_undefine([$2])])m4_copy($@)]) + +m4_define([m4_rename_force], +[m4_ifdef([$2], [_m4_undefine([$2])])m4_rename($@)]) + + +# m4_define_default(MACRO, VALUE) +# ------------------------------- +# If MACRO is undefined, set it to VALUE. +m4_define([m4_define_default], +[m4_ifndef([$1], [m4_define($@)])]) + + +# m4_default(EXP1, EXP2) +# m4_default_nblank(EXP1, EXP2) +# ----------------------------- +# Returns EXP1 if not empty/blank, otherwise EXP2. Expand the result. +# +# m4_default is called on hot paths, so inline the contents of m4_ifval, +# for one less round of expansion. +m4_define([m4_default], +[m4_if([$1], [], [$2], [$1])]) + +m4_define([m4_default_nblank], +[m4_ifblank([$1], [$2], [$1])]) + + +# m4_default_quoted(EXP1, EXP2) +# m4_default_nblank_quoted(EXP1, EXP2) +# ------------------------------------ +# Returns EXP1 if non empty/blank, otherwise EXP2. Leave the result quoted. +# +# For comparison: +# m4_define([active], [ACTIVE]) +# m4_default([active], [default]) => ACTIVE +# m4_default([], [active]) => ACTIVE +# -m4_default([ ], [active])- => - - +# -m4_default_nblank([ ], [active])- => -ACTIVE- +# m4_default_quoted([active], [default]) => active +# m4_default_quoted([], [active]) => active +# -m4_default_quoted([ ], [active])- => - - +# -m4_default_nblank_quoted([ ], [active])- => -active- +# +# m4_default macro is called on hot paths, so inline the contents of m4_ifval, +# for one less round of expansion. +m4_define([m4_default_quoted], +[m4_if([$1], [], [[$2]], [[$1]])]) + +m4_define([m4_default_nblank_quoted], +[m4_ifblank([$1], [[$2]], [[$1]])]) + + +# m4_defn(NAME) +# ------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). This replacement is not a full-featured +# replacement: if any of the defined macros contain unbalanced quoting, but +# when pasted together result in a well-quoted string, then only native m4 +# support is able to get it correct. But that's where quadrigraphs come in +# handy, if you really need unbalanced quotes inside your macros. +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_defn], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_defn([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + + +# m4_dumpdef(NAME...) +# ------------------- +# In m4 1.4.x, dumpdef writes to the current debugfile, rather than +# stderr. This in turn royally confuses autom4te; so we follow the +# lead of newer m4 and always dump to stderr. Unlike the original, +# this version requires an argument, since there is no convenient way +# in m4 1.4.x to grab the names of all defined macros. Newer m4 +# always dumps to stderr, regardless of the current debugfile; it also +# provides m4symbols as a way to grab all current macro names. But +# dumpdefs is not frequently called, so we don't need to worry about +# conditionally using these newer features. Also, this version +# doesn't sort multiple arguments. +# +# If we detect m4 1.6 or newer, then provide an alternate definition, +# installed during m4_init, that allows builtins through. +# Unfortunately, there is no nice way in m4 1.4.x to dump builtins. +m4_define([m4_dumpdef], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_ifdef([$1], [m4_errprintn( + [$1: ]m4_dquote(_m4_defn([$1])))], [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + +m4_define([_m4_dumpdef], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_builtin([dumpdef], [$1])], + [m4_map_args_sep([m4_builtin([dumpdef],], [)], [], $@)])]) + + +# m4_dumpdefs(NAME...) +# -------------------- +# Similar to `m4_dumpdef(NAME)', but if NAME was m4_pushdef'ed, display its +# value stack (most recent displayed first). Also, this version silently +# ignores undefined macros, rather than erroring out. +# +# This macro cheats, because it relies on the current definition of NAME +# while the second argument of m4_stack_foreach_lifo is evaluated (which +# would be undefined according to the API). +m4_define([m4_dumpdefs], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_stack_foreach_lifo([$1], [m4_dumpdef([$1])m4_ignore])], + [m4_map_args([$0], $@)])]) + +# m4_esyscmd_s(COMMAND) +# --------------------- +# Like m4_esyscmd, except strip any trailing newlines, thus behaving +# more like shell command substitution. +m4_define([m4_esyscmd_s], +[m4_chomp_all(m4_esyscmd([$1]))]) + + +# m4_popdef(NAME) +# --------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_popdef], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_popdef([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + + +# m4_shiftn(N, ...) +# ----------------- +# Returns ... shifted N times. Useful for recursive "varargs" constructs. +# +# Autoconf does not use this macro, because it is inherently slower than +# calling the common cases of m4_shift2 or m4_shift3 directly. But it +# might as well be fast for other clients, such as Libtool. One way to +# do this is to expand $@ only once in _m4_shiftn (otherwise, for long +# lists, the expansion of m4_if takes twice as much memory as what the +# list itself occupies, only to throw away the unused branch). The end +# result is strictly equivalent to +# m4_if([$1], 1, [m4_shift(,m4_shift(m4_shift($@)))], +# [_m4_shiftn(m4_decr([$1]), m4_shift(m4_shift($@)))]) +# but with the final `m4_shift(m4_shift($@)))' shared between the two +# paths. The first leg uses a no-op m4_shift(,$@) to balance out the (). +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_shiftn], +[m4_assert(0 < $1 && $1 < $#)_$0($@)]) + +m4_define([_m4_shiftn], +[m4_if([$1], 1, [m4_shift(], + [$0(m4_decr([$1])]), m4_shift(m4_shift($@)))]) + +# m4_shift2(...) +# m4_shift3(...) +# -------------- +# Returns ... shifted twice, and three times. Faster than m4_shiftn. +m4_define([m4_shift2], [m4_shift(m4_shift($@))]) +m4_define([m4_shift3], [m4_shift(m4_shift(m4_shift($@)))]) + +# _m4_shift2(...) +# _m4_shift3(...) +# --------------- +# Like m4_shift2 or m4_shift3, except include a leading comma unless shifting +# consumes all arguments. Why? Because in recursion, it is nice to +# distinguish between 1 element left and 0 elements left, based on how many +# arguments this shift expands to. +m4_define([_m4_shift2], +[m4_if([$#], [2], [], + [, m4_shift(m4_shift($@))])]) +m4_define([_m4_shift3], +[m4_if([$#], [3], [], + [, m4_shift(m4_shift(m4_shift($@)))])]) + + +# m4_undefine(NAME) +# ----------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_undefine], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_undefine([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + +# _m4_wrap(PRE, POST) +# ------------------- +# Helper macro for m4_wrap and m4_wrap_lifo. Allows nested calls to +# m4_wrap within wrapped text. Use _m4_defn and _m4_popdef for speed. +m4_define([_m4_wrap], +[m4_ifdef([$0_text], + [m4_define([$0_text], [$1]_m4_defn([$0_text])[$2])], + [m4_builtin([m4wrap], [m4_unquote( + _m4_defn([$0_text])_m4_popdef([$0_text]))])m4_define([$0_text], [$1$2])])]) + +# m4_wrap(TEXT) +# ------------- +# Append TEXT to the list of hooks to be executed at the end of input. +# Whereas the order of the original may be LIFO in the underlying m4, +# this version is always FIFO. +m4_define([m4_wrap], +[_m4_wrap([], [$1[]])]) + +# m4_wrap_lifo(TEXT) +# ------------------ +# Prepend TEXT to the list of hooks to be executed at the end of input. +# Whereas the order of m4_wrap may be FIFO in the underlying m4, this +# version is always LIFO. +m4_define([m4_wrap_lifo], +[_m4_wrap([$1[]])]) + +## ------------------------- ## +## 7. Quoting manipulation. ## +## ------------------------- ## + + +# m4_apply(MACRO, LIST) +# --------------------- +# Invoke MACRO, with arguments provided from the quoted list of +# comma-separated quoted arguments. If LIST is empty, invoke MACRO +# without arguments. The expansion will not be concatenated with +# subsequent text. +m4_define([m4_apply], +[m4_if([$2], [], [$1], [$1($2)])[]]) + +# _m4_apply(MACRO, LIST) +# ---------------------- +# Like m4_apply, except do nothing if LIST is empty. +m4_define([_m4_apply], +[m4_if([$2], [], [], [$1($2)[]])]) + + +# m4_count(ARGS) +# -------------- +# Return a count of how many ARGS are present. +m4_define([m4_count], [$#]) + + +# m4_curry(MACRO, ARG...) +# ----------------------- +# Perform argument currying. The expansion of this macro is another +# macro that takes exactly one argument, appends it to the end of the +# original ARG list, then invokes MACRO. For example: +# m4_curry([m4_curry], [m4_reverse], [1])([2])([3]) => 3, 2, 1 +# Not quite as practical as m4_incr, but you could also do: +# m4_define([add], [m4_eval(([$1]) + ([$2]))]) +# m4_define([add_one], [m4_curry([add], [1])]) +# add_one()([2]) => 3 +m4_define([m4_curry], [$1(m4_shift($@,)_$0]) +m4_define([_m4_curry], [[$1])]) + + +# m4_do(STRING, ...) +# ------------------ +# This macro invokes all its arguments (in sequence, of course). It is +# useful for making your macros more structured and readable by dropping +# unnecessary dnl's and have the macros indented properly. No concatenation +# occurs after a STRING; use m4_unquote(m4_join(,STRING)) for that. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_do], +[m4_if([$#], 0, [], + [$#], 1, [$1[]], + [$1[]$0(m4_shift($@))])]) + + +# m4_dquote(ARGS) +# --------------- +# Return ARGS as a quoted list of quoted arguments. +m4_define([m4_dquote], [[$@]]) + + +# m4_dquote_elt(ARGS) +# ------------------- +# Return ARGS as an unquoted list of double-quoted arguments. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_dquote_elt], +[m4_if([$#], [0], [], + [$#], [1], [[[$1]]], + [[[$1]],$0(m4_shift($@))])]) + + +# m4_echo(ARGS) +# ------------- +# Return the ARGS, with the same level of quoting. Whitespace after +# unquoted commas are consumed. +m4_define([m4_echo], [$@]) + + +# m4_expand(ARG) +# _m4_expand(ARG) +# --------------- +# Return the expansion of ARG as a single string. Unlike +# m4_quote($1), this preserves whitespace following single-quoted +# commas that appear within ARG. It also deals with shell case +# statements. +# +# m4_define([active], [ACT, IVE]) +# m4_define([active2], [[ACT, IVE]]) +# m4_quote(active, active2) +# => ACT,IVE,ACT, IVE +# m4_expand([active, active2]) +# => ACT, IVE, ACT, IVE +# +# Unfortunately, due to limitations in m4, ARG must expand to +# something with balanced quotes (use quadrigraphs to get around +# this), and should not contain the unlikely delimiters -=<{( or +# )}>=-. It is possible to have unbalanced quoted `(' or `)', as well +# as unbalanced unquoted `)'. m4_expand can handle unterminated +# comments or dnl on the final line, at the expense of speed; it also +# aids in detecting attempts to incorrectly change the current +# diversion inside ARG. Meanwhile, _m4_expand is faster but must be +# given a terminated expansion, and has no safety checks for +# mis-diverted text. +# +# Exploit that extra unquoted () will group unquoted commas and the +# following whitespace. m4_bpatsubst can't handle newlines inside $1, +# and m4_substr strips quoting. So we (ab)use m4_changequote, using +# temporary quotes to remove the delimiters that conveniently included +# the unquoted () that were added prior to the changequote. +# +# Thanks to shell case statements, too many people are prone to pass +# underquoted `)', so we try to detect that by passing a marker as a +# fourth argument; if the marker is not present, then we assume that +# we encountered an early `)', and re-expand the first argument, but +# this time with one more `(' in the second argument and in the +# open-quote delimiter. We must also ignore the slop from the +# previous try. The final macro is thus half line-noise, half art. +m4_define([m4_expand], +[m4_pushdef([m4_divert], _m4_defn([_m4_divert_unsafe]))]dnl +[m4_pushdef([m4_divert_push], _m4_defn([_m4_divert_unsafe]))]dnl +[m4_chomp(_$0([$1 +]))_m4_popdef([m4_divert], [m4_divert_push])]) + +m4_define([_m4_expand], [$0_([$1], [(], -=<{($1)}>=-, [}>=-])]) + +m4_define([_m4_expand_], +[m4_if([$4], [}>=-], + [m4_changequote([-=<{$2], [)}>=-])$3m4_changequote([, ])], + [$0([$1], [($2], -=<{($2$1)}>=-, [}>=-])m4_ignore$2])]) + + +# m4_ignore(ARGS) +# --------------- +# Expands to nothing. Useful for conditionally ignoring an arbitrary +# number of arguments (see _m4_list_cmp for an example). +m4_define([m4_ignore]) + + +# m4_make_list(ARGS) +# ------------------ +# Similar to m4_dquote, this creates a quoted list of quoted ARGS. This +# version is less efficient than m4_dquote, but separates each argument +# with a comma and newline, rather than just comma, for readability. +# When developing an m4sugar algorithm, you could temporarily use +# m4_pushdef([m4_dquote],m4_defn([m4_make_list])) +# around your code to make debugging easier. +m4_define([m4_make_list], [m4_join([, +], m4_dquote_elt($@))]) + + +# m4_noquote(STRING) +# ------------------ +# Return the result of ignoring all quotes in STRING and invoking the +# macros it contains. Among other things, this is useful for enabling +# macro invocations inside strings with [] blocks (for instance regexps +# and help-strings). On the other hand, since all quotes are disabled, +# any macro expanded during this time that relies on nested [] quoting +# will likely crash and burn. This macro is seldom useful; consider +# m4_unquote or m4_expand instead. +m4_define([m4_noquote], +[m4_changequote([-=<{(],[)}>=-])$1-=<{()}>=-m4_changequote([,])]) + + +# m4_quote(ARGS) +# -------------- +# Return ARGS as a single argument. Any whitespace after unquoted commas +# is stripped. There is always output, even when there were no arguments. +# +# It is important to realize the difference between `m4_quote(exp)' and +# `[exp]': in the first case you obtain the quoted *result* of the +# expansion of EXP, while in the latter you just obtain the string +# `exp'. +m4_define([m4_quote], [[$*]]) + + +# _m4_quote(ARGS) +# --------------- +# Like m4_quote, except that when there are no arguments, there is no +# output. For conditional scenarios (such as passing _m4_quote as the +# macro name in m4_mapall), this feature can be used to distinguish between +# one argument of the empty string vs. no arguments. However, in the +# normal case with arguments present, this is less efficient than m4_quote. +m4_define([_m4_quote], +[m4_if([$#], [0], [], [[$*]])]) + + +# m4_reverse(ARGS) +# ---------------- +# Output ARGS in reverse order. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_reverse], +[m4_if([$#], [0], [], [$#], [1], [[$1]], + [$0(m4_shift($@)), [$1]])]) + + +# m4_unquote(ARGS) +# ---------------- +# Remove one layer of quotes from each ARG, performing one level of +# expansion. For one argument, m4_unquote([arg]) is more efficient than +# m4_do([arg]), but for multiple arguments, the difference is that +# m4_unquote separates arguments with commas while m4_do concatenates. +# Follow this macro with [] if concatenation with subsequent text is +# undesired. +m4_define([m4_unquote], [$*]) + + +## -------------------------- ## +## 8. Implementing m4 loops. ## +## -------------------------- ## + + +# m4_for(VARIABLE, FIRST, LAST, [STEP = +/-1], EXPRESSION) +# -------------------------------------------------------- +# Expand EXPRESSION defining VARIABLE to FROM, FROM + 1, ..., TO with +# increments of STEP. Both limits are included, and bounds are +# checked for consistency. The algorithm is robust to indirect +# VARIABLE names. Changing VARIABLE inside EXPRESSION will not impact +# the number of iterations. +# +# Uses _m4_defn for speed, and avoid dnl in the macro body. Factor +# the _m4_for call so that EXPRESSION is only parsed once. +m4_define([m4_for], +[m4_pushdef([$1], m4_eval([$2]))]dnl +[m4_cond([m4_eval(([$3]) > ([$2]))], 1, + [m4_pushdef([_m4_step], m4_eval(m4_default_quoted([$4], + 1)))m4_assert(_m4_step > 0)_$0(_m4_defn([$1]), + m4_eval((([$3]) - ([$2])) / _m4_step * _m4_step + ([$2])), _m4_step,], + [m4_eval(([$3]) < ([$2]))], 1, + [m4_pushdef([_m4_step], m4_eval(m4_default_quoted([$4], + -1)))m4_assert(_m4_step < 0)_$0(_m4_defn([$1]), + m4_eval((([$2]) - ([$3])) / -(_m4_step) * _m4_step + ([$2])), _m4_step,], + [m4_pushdef([_m4_step])_$0(_m4_defn([$1]), _m4_defn([$1]), 0,])]dnl +[[m4_define([$1],], [)$5])m4_popdef([_m4_step], [$1])]) + +# _m4_for(COUNT, LAST, STEP, PRE, POST) +# ------------------------------------- +# Core of the loop, no consistency checks, all arguments are plain +# numbers. Expand PRE[COUNT]POST, then alter COUNT by STEP and +# iterate if COUNT is not LAST. +m4_define([_m4_for], +[$4[$1]$5[]m4_if([$1], [$2], [], + [$0(m4_eval([$1 + $3]), [$2], [$3], [$4], [$5])])]) + + +# Implementing `foreach' loops in m4 is much more tricky than it may +# seem. For example, the old M4 1.4.4 manual had an incorrect example, +# which looked like this (when translated to m4sugar): +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], +# | [m4_pushdef([$1])_foreach([$1], [$2], [$3])m4_popdef([$1])]) +# | m4_define([_arg1], [$1]) +# | m4_define([_foreach], +# | [m4_if([$2], [()], , +# | [m4_define([$1], _arg1$2)$3[]_foreach([$1], (m4_shift$2), [$3])])]) +# +# But then if you run +# +# | m4_define(a, 1) +# | m4_define(b, 2) +# | m4_define(c, 3) +# | foreach([f], [([a], [(b], [c)])], [echo f +# | ]) +# +# it gives +# +# => echo 1 +# => echo (2,3) +# +# which is not what is expected. +# +# Of course the problem is that many quotes are missing. So you add +# plenty of quotes at random places, until you reach the expected +# result. Alternatively, if you are a quoting wizard, you directly +# reach the following implementation (but if you really did, then +# apply to the maintenance of m4sugar!). +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) +# | m4_define([_arg1], [[$1]]) +# | m4_define([_foreach], +# | [m4_if($2, [()], , +# | [m4_define([$1], [_arg1$2])$3[]_foreach([$1], [(m4_shift$2)], [$3])])]) +# +# which this time answers +# +# => echo a +# => echo (b +# => echo c) +# +# Bingo! +# +# Well, not quite. +# +# With a better look, you realize that the parens are more a pain than +# a help: since anyway you need to quote properly the list, you end up +# with always using an outermost pair of parens and an outermost pair +# of quotes. Rejecting the parens both eases the implementation, and +# simplifies the use: +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) +# | m4_define([_arg1], [$1]) +# | m4_define([_foreach], +# | [m4_if($2, [], , +# | [m4_define([$1], [_arg1($2)])$3[]_foreach([$1], [m4_shift($2)], [$3])])]) +# +# +# Now, just replace the `$2' with `m4_quote($2)' in the outer `m4_if' +# to improve robustness, and you come up with a nice implementation +# that doesn't require extra parentheses in the user's LIST. +# +# But wait - now the algorithm is quadratic, because every recursion of +# the algorithm keeps the entire LIST and merely adds another m4_shift to +# the quoted text. If the user has a lot of elements in LIST, you can +# bring the system to its knees with the memory m4 then requires, or trip +# the m4 --nesting-limit recursion factor. The only way to avoid +# quadratic growth is ensure m4_shift is expanded prior to the recursion. +# Hence the design below. +# +# The M4 manual now includes a chapter devoted to this issue, with +# the lessons learned from m4sugar. And still, this design is only +# optimal for M4 1.6; see foreach.m4 for yet more comments on why +# M4 1.4.x uses yet another implementation. + + +# m4_foreach(VARIABLE, LIST, EXPRESSION) +# -------------------------------------- +# +# Expand EXPRESSION assigning each value of the LIST to VARIABLE. +# LIST should have the form `item_1, item_2, ..., item_n', i.e. the +# whole list must *quoted*. Quote members too if you don't want them +# to be expanded. +# +# This macro is robust to active symbols: +# | m4_define(active, [ACT, IVE]) +# | m4_foreach(Var, [active, active], [-Var-]) +# => -ACT--IVE--ACT--IVE- +# +# | m4_foreach(Var, [[active], [active]], [-Var-]) +# => -ACT, IVE--ACT, IVE- +# +# | m4_foreach(Var, [[[active]], [[active]]], [-Var-]) +# => -active--active- +# +# This macro is called frequently, so avoid extra expansions such as +# m4_ifval and dnl. Also, since $2 might be quite large, try to use it +# as little as possible in _m4_foreach; each extra use requires that much +# more memory for expansion. So, rather than directly compare $2 against +# [] and use m4_car/m4_cdr for recursion, we instead unbox the list (which +# requires swapping the argument order in the helper), insert an ignored +# third argument, and use m4_shift3 to detect when recursion is complete, +# at which point this looks very much like m4_map_args. +m4_define([m4_foreach], +[m4_if([$2], [], [], + [m4_pushdef([$1])_$0([m4_define([$1],], [)$3], [], + $2)m4_popdef([$1])])]) + +# _m4_foreach(PRE, POST, IGNORED, ARG...) +# --------------------------------------- +# Form the common basis of the m4_foreach and m4_map macros. For each +# ARG, expand PRE[ARG]POST[]. The IGNORED argument makes recursion +# easier, and must be supplied rather than implicit. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([_m4_foreach], +[m4_if([$#], [3], [], + [$1[$4]$2[]$0([$1], [$2], m4_shift3($@))])]) + + +# m4_foreach_w(VARIABLE, LIST, EXPRESSION) +# ---------------------------------------- +# Like m4_foreach, but the list is whitespace separated. Depending on +# EXPRESSION, it may be more efficient to use m4_map_args_w. +# +# This macro is robust to active symbols: +# m4_foreach_w([Var], [ active +# b act\ +# ive ], [-Var-])end +# => -active--b--active-end +# +# This used to use a slower implementation based on m4_foreach: +# m4_foreach([$1], m4_split(m4_normalize([$2]), [ ]), [$3]) +m4_define([m4_foreach_w], +[m4_pushdef([$1])m4_map_args_w([$2], + [m4_define([$1],], [)$3])m4_popdef([$1])]) + + +# m4_map(MACRO, LIST) +# m4_mapall(MACRO, LIST) +# ---------------------- +# Invoke MACRO($1), MACRO($2) etc. where $1, $2... are the elements of +# LIST. $1, $2... must in turn be lists, appropriate for m4_apply. +# If LIST contains an empty sublist, m4_map skips the expansion of +# MACRO, while m4_mapall expands MACRO with no arguments. +# +# Since LIST may be quite large, we want to minimize how often it +# appears in the expansion. Rather than use m4_car/m4_cdr iteration, +# we unbox the list, and use _m4_foreach for iteration. For m4_map, +# an empty list behaves like an empty sublist and gets ignored; for +# m4_mapall, we must special-case the empty list. +m4_define([m4_map], +[_m4_foreach([_m4_apply([$1],], [)], [], $2)]) + +m4_define([m4_mapall], +[m4_if([$2], [], [], + [_m4_foreach([m4_apply([$1],], [)], [], $2)])]) + + +# m4_map_sep(MACRO, [SEPARATOR], LIST) +# m4_mapall_sep(MACRO, [SEPARATOR], LIST) +# --------------------------------------- +# Invoke MACRO($1), SEPARATOR, MACRO($2), ..., MACRO($N) where $1, +# $2... $N are the elements of LIST, and are in turn lists appropriate +# for m4_apply. SEPARATOR is expanded, in order to allow the creation +# of a list of arguments by using a single-quoted comma as the +# separator. For each empty sublist, m4_map_sep skips the expansion +# of MACRO and SEPARATOR, while m4_mapall_sep expands MACRO with no +# arguments. +# +# For m4_mapall_sep, merely expand the first iteration without the +# separator, then include separator as part of subsequent recursion; +# but avoid extra expansion of LIST's side-effects via a helper macro. +# For m4_map_sep, things are trickier - we don't know if the first +# list element is an empty sublist, so we must define a self-modifying +# helper macro and use that as the separator instead. +m4_define([m4_map_sep], +[m4_pushdef([m4_Sep], [m4_define([m4_Sep], _m4_defn([m4_unquote]))])]dnl +[_m4_foreach([_m4_apply([m4_Sep([$2])[]$1],], [)], [], $3)m4_popdef([m4_Sep])]) + +m4_define([m4_mapall_sep], +[m4_if([$3], [], [], [_$0([$1], [$2], $3)])]) + +m4_define([_m4_mapall_sep], +[m4_apply([$1], [$3])_m4_foreach([m4_apply([$2[]$1],], [)], m4_shift2($@))]) + +# m4_map_args(EXPRESSION, ARG...) +# ------------------------------- +# Expand EXPRESSION([ARG]) for each argument. More efficient than +# m4_foreach([var], [ARG...], [EXPRESSION(m4_defn([var]))]) +# Shorthand for m4_map_args_sep([EXPRESSION(], [)], [], ARG...). +m4_define([m4_map_args], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [], + [$#], [2], [$1([$2])[]], + [_m4_foreach([$1(], [)], $@)])]) + + +# m4_map_args_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...) +# ------------------------------------------------------------- +# Perform a pairwise grouping of consecutive ARGs, by expanding +# EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the +# final argument is expanded with END-EXPR([ARGn]). +# +# For example: +# m4_define([show], [($*)m4_newline])dnl +# m4_map_args_pair([show], [], [a], [b], [c], [d], [e])dnl +# => (a,b) +# => (c,d) +# => (e) +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_map_args_pair], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [m4_fatal([$0: too few arguments: $#: $1])], + [$#], [2], [], + [$#], [3], [m4_default([$2], [$1])([$3])[]], + [$#], [4], [$1([$3], [$4])[]], + [$1([$3], [$4])[]$0([$1], [$2], m4_shift(m4_shift3($@)))])]) + + +# m4_map_args_sep([PRE], [POST], [SEP], ARG...) +# --------------------------------------------- +# Expand PRE[ARG]POST for each argument, with SEP between arguments. +m4_define([m4_map_args_sep], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [], + [$#], [2], [], + [$#], [3], [], + [$#], [4], [$1[$4]$2[]], + [$1[$4]$2[]_m4_foreach([$3[]$1], [$2], m4_shift3($@))])]) + + +# m4_map_args_w(STRING, [PRE], [POST], [SEP]) +# ------------------------------------------- +# Perform the expansion of PRE[word]POST[] for each word in STRING +# separated by whitespace. More efficient than: +# m4_foreach_w([var], [STRING], [PRE[]m4_defn([var])POST]) +# Additionally, expand SEP between words. +# +# As long as we have to use m4_bpatsubst to split the string, we might +# as well make it also apply PRE and POST; this avoids iteration +# altogether. But we must be careful of any \ in PRE or POST. +# _m4_strip returns a quoted string, but that's okay, since it also +# supplies an empty leading and trailing argument due to our +# intentional whitespace around STRING. We use m4_substr to strip the +# empty elements and remove the extra layer of quoting. +m4_define([m4_map_args_w], +[_$0(_m4_split([ ]m4_flatten([$1])[ ], [[ ]+], + m4_if(m4_index([$2$3$4], [\]), [-1], [[$3[]$4[]$2]], + [m4_bpatsubst([[$3[]$4[]$2]], [\\], [\\\\])])), + m4_len([[]$3[]$4]), m4_len([$4[]$2[]]))]) + +m4_define([_m4_map_args_w], +[m4_substr([$1], [$2], m4_eval(m4_len([$1]) - [$2] - [$3]))]) + + +# m4_stack_foreach(MACRO, FUNC) +# m4_stack_foreach_lifo(MACRO, FUNC) +# ---------------------------------- +# Pass each stacked definition of MACRO to the one-argument macro FUNC. +# m4_stack_foreach proceeds in FIFO order, while m4_stack_foreach_lifo +# processes the topmost definitions first. In addition, FUNC should +# not push or pop definitions of MACRO, and should not expect anything about +# the active definition of MACRO (it will not be the topmost, and may not +# be the one passed to FUNC either). +# +# Some macros simply can't be examined with this method: namely, +# anything involved in the implementation of _m4_stack_reverse. +m4_define([m4_stack_foreach], +[_m4_stack_reverse([$1], [m4_tmp-$1])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1], [$2(_m4_defn([m4_tmp-$1]))])]) + +m4_define([m4_stack_foreach_lifo], +[_m4_stack_reverse([$1], [m4_tmp-$1], [$2(_m4_defn([m4_tmp-$1]))])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1])]) + +# m4_stack_foreach_sep(MACRO, [PRE], [POST], [SEP]) +# m4_stack_foreach_sep_lifo(MACRO, [PRE], [POST], [SEP]) +# ------------------------------------------------------ +# Similar to m4_stack_foreach and m4_stack_foreach_lifo, in that every +# definition of a pushdef stack will be visited. But rather than +# passing the definition as a single argument to a macro, this variant +# expands the concatenation of PRE[]definition[]POST, and expands SEP +# between consecutive expansions. Note that m4_stack_foreach([a], [b]) +# is equivalent to m4_stack_foreach_sep([a], [b(], [)]). +m4_define([m4_stack_foreach_sep], +[_m4_stack_reverse([$1], [m4_tmp-$1])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1], [$2[]_m4_defn([m4_tmp-$1])$3], [$4[]])]) + +m4_define([m4_stack_foreach_sep_lifo], +[_m4_stack_reverse([$1], [m4_tmp-$1], [$2[]_m4_defn([m4_tmp-$1])$3], [$4[]])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1])]) + + +# _m4_stack_reverse(OLD, NEW, [ACTION], [SEP]) +# -------------------------------------------- +# A recursive worker for pushdef stack manipulation. Destructively +# copy the OLD stack into the NEW, and expanding ACTION for each +# iteration. After the first iteration, SEP is promoted to the front +# of ACTION (note that SEP should include a trailing [] if it is to +# avoid interfering with ACTION). The current definition is examined +# after the NEW has been pushed but before OLD has been popped; this +# order is important, as ACTION is permitted to operate on either +# _m4_defn([OLD]) or _m4_defn([NEW]). Since the operation is +# destructive, this macro is generally used twice, with a temporary +# macro name holding the swapped copy. +m4_define([_m4_stack_reverse], +[m4_ifdef([$1], [m4_pushdef([$2], + _m4_defn([$1]))$3[]_m4_popdef([$1])$0([$1], [$2], [$4$3])])]) + + + +## --------------------------- ## +## 9. More diversion support. ## +## --------------------------- ## + + +# m4_cleardivert(DIVERSION-NAME...) +# --------------------------------- +# Discard any text in DIVERSION-NAME. +# +# This works even inside m4_expand. +m4_define([m4_cleardivert], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [_m4_divert_raw([-1])m4_undivert($@)_m4_divert_raw( + _m4_divert(_m4_defn([_m4_divert_diversion]), [-]))])]) + + +# _m4_divert(DIVERSION-NAME or NUMBER, [NOWARN]) +# ---------------------------------------------- +# If DIVERSION-NAME is the name of a diversion, return its number, +# otherwise if it is a NUMBER return it. Issue a warning about +# the use of a number instead of a name, unless NOWARN is provided. +m4_define([_m4_divert], +[m4_ifdef([_m4_divert($1)], + [m4_indir([_m4_divert($1)])], + [m4_if([$2], [], [m4_warn([syntax], + [prefer named diversions])])$1])]) + +# KILL is only used to suppress output. +m4_define([_m4_divert(KILL)], -1) + +# The empty diversion name is a synonym for 0. +m4_define([_m4_divert()], 0) + + +# m4_divert_stack +# --------------- +# Print the diversion stack, if it's nonempty. The caller is +# responsible for any leading or trailing newline. +m4_define([m4_divert_stack], +[m4_stack_foreach_sep_lifo([_m4_divert_stack], [], [], [ +])]) + + +# m4_divert_stack_push(MACRO-NAME, DIVERSION-NAME) +# ------------------------------------------------ +# Form an entry of the diversion stack from caller MACRO-NAME and +# entering DIVERSION-NAME and push it. +m4_define([m4_divert_stack_push], +[m4_pushdef([_m4_divert_stack], m4_location[: $1: $2])]) + + +# m4_divert(DIVERSION-NAME) +# ------------------------- +# Change the diversion stream to DIVERSION-NAME. +m4_define([m4_divert], +[m4_popdef([_m4_divert_stack])]dnl +[m4_define([_m4_divert_diversion], [$1])]dnl +[m4_divert_stack_push([$0], [$1])]dnl +[_m4_divert_raw(_m4_divert([$1]))]) + + +# m4_divert_push(DIVERSION-NAME, [NOWARN]) +# ---------------------------------------- +# Change the diversion stream to DIVERSION-NAME, while stacking old values. +# For internal use only: if NOWARN is not empty, DIVERSION-NAME can be a +# number instead of a name. +m4_define([m4_divert_push], +[m4_divert_stack_push([$0], [$1])]dnl +[m4_pushdef([_m4_divert_diversion], [$1])]dnl +[_m4_divert_raw(_m4_divert([$1], [$2]))]) + + +# m4_divert_pop([DIVERSION-NAME]) +# ------------------------------- +# Change the diversion stream to its previous value, unstacking it. +# If specified, verify we left DIVERSION-NAME. +# When we pop the last value from the stack, we divert to -1. +m4_define([m4_divert_pop], +[m4_if([$1], [], [], + [$1], _m4_defn([_m4_divert_diversion]), [], + [m4_fatal([$0($1): diversion mismatch: +]m4_divert_stack)])]dnl +[_m4_popdef([_m4_divert_stack], [_m4_divert_diversion])]dnl +[m4_ifdef([_m4_divert_diversion], [], + [m4_fatal([too many m4_divert_pop])])]dnl +[_m4_divert_raw(_m4_divert(_m4_defn([_m4_divert_diversion]), [-]))]) + + +# m4_divert_text(DIVERSION-NAME, CONTENT) +# --------------------------------------- +# Output CONTENT into DIVERSION-NAME (which may be a number actually). +# An end of line is appended for free to CONTENT. +m4_define([m4_divert_text], +[m4_divert_push([$1])$2 +m4_divert_pop([$1])]) + + +# m4_divert_once(DIVERSION-NAME, CONTENT) +# --------------------------------------- +# Output CONTENT into DIVERSION-NAME once, if not already there. +# An end of line is appended for free to CONTENT. +m4_define([m4_divert_once], +[m4_expand_once([m4_divert_text([$1], [$2])])]) + + +# _m4_divert_unsafe(DIVERSION-NAME) +# --------------------------------- +# Issue a warning that the attempt to change the current diversion to +# DIVERSION-NAME is unsafe, because this macro is being expanded +# during argument collection of m4_expand. +m4_define([_m4_divert_unsafe], +[m4_fatal([$0: cannot change diversion to `$1' inside m4_expand])]) + + +# m4_undivert(DIVERSION-NAME...) +# ------------------------------ +# Undivert DIVERSION-NAME. Unlike the M4 version, this requires at +# least one DIVERSION-NAME; also, due to support for named diversions, +# this should not be used to undivert files. +m4_define([m4_undivert], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [_m4_undivert(_m4_divert([$1]))], + [m4_map_args([$0], $@)])]) + + +## --------------------------------------------- ## +## 10. Defining macros with bells and whistles. ## +## --------------------------------------------- ## + +# `m4_defun' is basically `m4_define' but it equips the macro with the +# needed machinery for `m4_require'. A macro must be m4_defun'd if +# either it is m4_require'd, or it m4_require's. +# +# Two things deserve attention and are detailed below: +# 1. Implementation of m4_require +# 2. Keeping track of the expansion stack +# +# 1. Implementation of m4_require +# =============================== +# +# Of course m4_defun calls m4_provide, so that a macro which has +# been expanded is not expanded again when m4_require'd, but the +# difficult part is the proper expansion of macros when they are +# m4_require'd. +# +# The implementation is based on three ideas, (i) using diversions to +# prepare the expansion of the macro and its dependencies (by Franc,ois +# Pinard), (ii) expand the most recently m4_require'd macros _after_ +# the previous macros (by Axel Thimm), and (iii) track instances of +# provide before require (by Eric Blake). +# +# +# The first idea: why use diversions? +# ----------------------------------- +# +# When a macro requires another, the other macro is expanded in new +# diversion, GROW. When the outer macro is fully expanded, we first +# undivert the most nested diversions (GROW - 1...), and finally +# undivert GROW. To understand why we need several diversions, +# consider the following example: +# +# | m4_defun([TEST1], [Test...m4_require([TEST2])1]) +# | m4_defun([TEST2], [Test...m4_require([TEST3])2]) +# | m4_defun([TEST3], [Test...3]) +# +# Because m4_require is not required to be first in the outer macros, we +# must keep the expansions of the various levels of m4_require separated. +# Right before executing the epilogue of TEST1, we have: +# +# GROW - 2: Test...3 +# GROW - 1: Test...2 +# GROW: Test...1 +# BODY: +# +# Finally the epilogue of TEST1 undiverts GROW - 2, GROW - 1, and +# GROW into the regular flow, BODY. +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: Test...3; Test...2; Test...1 +# +# (The semicolons are here for clarification, but of course are not +# emitted.) This is what Autoconf 2.0 (I think) to 2.13 (I'm sure) +# implement. +# +# +# The second idea: first required first out +# ----------------------------------------- +# +# The natural implementation of the idea above is buggy and produces +# very surprising results in some situations. Let's consider the +# following example to explain the bug: +# +# | m4_defun([TEST1], [m4_require([TEST2a])m4_require([TEST2b])]) +# | m4_defun([TEST2a], []) +# | m4_defun([TEST2b], [m4_require([TEST3])]) +# | m4_defun([TEST3], [m4_require([TEST2a])]) +# | +# | AC_INIT +# | TEST1 +# +# The dependencies between the macros are: +# +# 3 --- 2b +# / \ is m4_require'd by +# / \ left -------------------- right +# 2a ------------ 1 +# +# If you strictly apply the rules given in the previous section you get: +# +# GROW - 2: TEST3 +# GROW - 1: TEST2a; TEST2b +# GROW: TEST1 +# BODY: +# +# (TEST2a, although required by TEST3 is not expanded in GROW - 3 +# because is has already been expanded before in GROW - 1, so it has +# been AC_PROVIDE'd, so it is not expanded again) so when you undivert +# the stack of diversions, you get: +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: TEST3; TEST2a; TEST2b; TEST1 +# +# i.e., TEST2a is expanded after TEST3 although the latter required the +# former. +# +# Starting from 2.50, we use an implementation provided by Axel Thimm. +# The idea is simple: the order in which macros are emitted must be the +# same as the one in which macros are expanded. (The bug above can +# indeed be described as: a macro has been m4_provide'd before its +# dependent, but it is emitted after: the lack of correlation between +# emission and expansion order is guilty). +# +# How to do that? You keep the stack of diversions to elaborate the +# macros, but each time a macro is fully expanded, emit it immediately. +# +# In the example above, when TEST2a is expanded, but it's epilogue is +# not run yet, you have: +# +# GROW - 2: +# GROW - 1: TEST2a +# GROW: Elaboration of TEST1 +# BODY: +# +# The epilogue of TEST2a emits it immediately: +# +# GROW - 2: +# GROW - 1: +# GROW: Elaboration of TEST1 +# BODY: TEST2a +# +# TEST2b then requires TEST3, so right before the epilogue of TEST3, you +# have: +# +# GROW - 2: TEST3 +# GROW - 1: Elaboration of TEST2b +# GROW: Elaboration of TEST1 +# BODY: TEST2a +# +# The epilogue of TEST3 emits it: +# +# GROW - 2: +# GROW - 1: Elaboration of TEST2b +# GROW: Elaboration of TEST1 +# BODY: TEST2a; TEST3 +# +# TEST2b is now completely expanded, and emitted: +# +# GROW - 2: +# GROW - 1: +# GROW: Elaboration of TEST1 +# BODY: TEST2a; TEST3; TEST2b +# +# and finally, TEST1 is finished and emitted: +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: TEST2a; TEST3; TEST2b: TEST1 +# +# The idea is simple, but the implementation is a bit involved. If +# you are like me, you will want to see the actual functioning of this +# implementation to be convinced. The next section gives the full +# details. +# +# +# The Axel Thimm implementation at work +# ------------------------------------- +# +# We consider the macros above, and this configure.ac: +# +# AC_INIT +# TEST1 +# +# You should keep the definitions of _m4_defun_pro, _m4_defun_epi, and +# m4_require at hand to follow the steps. +# +# This implementation tries not to assume that the current diversion is +# BODY, so as soon as a macro (m4_defun'd) is expanded, we first +# record the current diversion under the name _m4_divert_dump (denoted +# DUMP below for short). This introduces an important difference with +# the previous versions of Autoconf: you cannot use m4_require if you +# are not inside an m4_defun'd macro, and especially, you cannot +# m4_require directly from the top level. +# +# We have not tried to simulate the old behavior (better yet, we +# diagnose it), because it is too dangerous: a macro m4_require'd from +# the top level is expanded before the body of `configure', i.e., before +# any other test was run. I let you imagine the result of requiring +# AC_STDC_HEADERS for instance, before AC_PROG_CC was actually run.... +# +# After AC_INIT was run, the current diversion is BODY. +# * AC_INIT was run +# DUMP: undefined +# diversion stack: BODY |- +# +# * TEST1 is expanded +# The prologue of TEST1 sets _m4_divert_dump, which is the diversion +# where the current elaboration will be dumped, to the current +# diversion. It also m4_divert_push to GROW, where the full +# expansion of TEST1 and its dependencies will be elaborated. +# DUMP: BODY +# BODY: empty +# diversions: GROW, BODY |- +# +# * TEST1 requires TEST2a +# _m4_require_call m4_divert_pushes another temporary diversion, +# GROW - 1, and expands TEST2a in there. +# DUMP: BODY +# BODY: empty +# GROW - 1: TEST2a +# diversions: GROW - 1, GROW, BODY |- +# Then the content of the temporary diversion is moved to DUMP and the +# temporary diversion is popped. +# DUMP: BODY +# BODY: TEST2a +# diversions: GROW, BODY |- +# +# * TEST1 requires TEST2b +# Again, _m4_require_call pushes GROW - 1 and heads to expand TEST2b. +# DUMP: BODY +# BODY: TEST2a +# diversions: GROW - 1, GROW, BODY |- +# +# * TEST2b requires TEST3 +# _m4_require_call pushes GROW - 2 and expands TEST3 here. +# (TEST3 requires TEST2a, but TEST2a has already been m4_provide'd, so +# nothing happens.) +# DUMP: BODY +# BODY: TEST2a +# GROW - 2: TEST3 +# diversions: GROW - 2, GROW - 1, GROW, BODY |- +# Then the diversion is appended to DUMP, and popped. +# DUMP: BODY +# BODY: TEST2a; TEST3 +# diversions: GROW - 1, GROW, BODY |- +# +# * TEST1 requires TEST2b (contd.) +# The content of TEST2b is expanded... +# DUMP: BODY +# BODY: TEST2a; TEST3 +# GROW - 1: TEST2b, +# diversions: GROW - 1, GROW, BODY |- +# ... and moved to DUMP. +# DUMP: BODY +# BODY: TEST2a; TEST3; TEST2b +# diversions: GROW, BODY |- +# +# * TEST1 is expanded: epilogue +# TEST1's own content is in GROW... +# DUMP: BODY +# BODY: TEST2a; TEST3; TEST2b +# GROW: TEST1 +# diversions: BODY |- +# ... and it's epilogue moves it to DUMP and then undefines DUMP. +# DUMP: undefined +# BODY: TEST2a; TEST3; TEST2b; TEST1 +# diversions: BODY |- +# +# +# The third idea: track macros provided before they were required +# --------------------------------------------------------------- +# +# Using just the first two ideas, Autoconf 2.50 through 2.63 still had +# a subtle bug for more than seven years. Let's consider the +# following example to explain the bug: +# +# | m4_defun([TEST1], [1]) +# | m4_defun([TEST2], [2[]m4_require([TEST1])]) +# | m4_defun([TEST3], [3 TEST1 m4_require([TEST2])]) +# | TEST3 +# +# After the prologue of TEST3, we are collecting text in GROW with the +# intent of dumping it in BODY during the epilogue. Next, we +# encounter the direct invocation of TEST1, which provides the macro +# in place in GROW. From there, we encounter a requirement for TEST2, +# which must be collected in a new diversion. While expanding TEST2, +# we encounter a requirement for TEST1, but since it has already been +# expanded, the Axel Thimm algorithm states that we can treat it as a +# no-op. But that would lead to an end result of `2 3 1', meaning +# that we have once again output a macro (TEST2) prior to its +# requirements (TEST1). +# +# The problem can only occur if a single defun'd macro first provides, +# then later indirectly requires, the same macro. Note that directly +# expanding then requiring a macro is okay: because the dependency was +# met, the require phase can be a no-op. For that matter, the outer +# macro can even require two helpers, where the first helper expands +# the macro, and the second helper indirectly requires the macro. +# Out-of-order expansion is only present if the inner macro is +# required by something that will be hoisted in front of where the +# direct expansion occurred. In other words, we must be careful not +# to warn on: +# +# | m4_defun([TEST4], [4]) +# | m4_defun([TEST5], [5 TEST4 m4_require([TEST4])]) +# | TEST5 => 5 4 +# +# or even the more complex: +# +# | m4_defun([TEST6], [6]) +# | m4_defun([TEST7], [7 TEST6]) +# | m4_defun([TEST8], [8 m4_require([TEST6])]) +# | m4_defun([TEST9], [9 m4_require([TEST8])]) +# | m4_defun([TEST10], [10 m4_require([TEST7]) m4_require([TEST9])]) +# | TEST10 => 7 6 8 9 10 +# +# So, to detect whether a require was direct or indirect, m4_defun and +# m4_require track the name of the macro that caused a diversion to be +# created (using the stack _m4_diverting, coupled with an O(1) lookup +# _m4_diverting([NAME])), and m4_provide stores the name associated +# with the diversion at which a macro was provided. A require call is +# direct if it occurs within the same diversion where the macro was +# provided, or if the diversion associated with the providing context +# has been collected. +# +# The implementation of the warning involves tracking the set of +# macros which have been provided since the start of the outermost +# defun'd macro (the set is named _m4_provide). When starting an +# outermost macro, the set is emptied; when a macro is provided, it is +# added to the set; when require expands the body of a macro, it is +# removed from the set; and when a macro is indirectly required, the +# set is checked. If a macro is in the set, then it has been provided +# before it was required, and we satisfy dependencies by expanding the +# macro as if it had never been provided; in the example given above, +# this means we now output `1 2 3 1'. Meanwhile, a warning is issued +# to inform the user that her macros trigger the bug in older autoconf +# versions, and that her output file now contains redundant contents +# (and possibly new problems, if the repeated macro was not +# idempotent). Meanwhile, macros defined by m4_defun_once instead of +# m4_defun are idempotent, avoiding any warning or duplicate output. +# +# +# 2. Keeping track of the expansion stack +# ======================================= +# +# When M4 expansion goes wrong it is often extremely hard to find the +# path amongst macros that drove to the failure. What is needed is +# the stack of macro `calls'. One could imagine that GNU M4 would +# maintain a stack of macro expansions, unfortunately it doesn't, so +# we do it by hand. This is of course extremely costly, but the help +# this stack provides is worth it. Nevertheless to limit the +# performance penalty this is implemented only for m4_defun'd macros, +# not for define'd macros. +# +# Each time we enter an m4_defun'd macros, we add a definition in +# _m4_expansion_stack, and when we exit the macro, we remove it (thanks +# to pushdef/popdef). m4_stack_foreach is used to print the expansion +# stack in the rare cases when it's needed. +# +# In addition, we want to detect circular m4_require dependencies. +# Each time we expand a macro FOO we define _m4_expanding(FOO); and +# m4_require(BAR) simply checks whether _m4_expanding(BAR) is defined. + + +# m4_expansion_stack +# ------------------ +# Expands to the entire contents of the expansion stack. The caller +# must supply a trailing newline. This macro always prints a +# location; check whether _m4_expansion_stack is defined to filter out +# the case when no defun'd macro is in force. +m4_define([m4_expansion_stack], +[m4_stack_foreach_sep_lifo([_$0], [_$0_entry(], [) +])m4_location[: the top level]]) + +# _m4_expansion_stack_entry(MACRO) +# -------------------------------- +# Format an entry for MACRO found on the expansion stack. +m4_define([_m4_expansion_stack_entry], +[_m4_defn([m4_location($1)])[: $1 is expanded from...]]) + +# m4_expansion_stack_push(MACRO) +# ------------------------------ +# Form an entry of the expansion stack on entry to MACRO and push it. +m4_define([m4_expansion_stack_push], +[m4_pushdef([_m4_expansion_stack], [$1])]) + + +# _m4_divert(GROW) +# ---------------- +# This diversion is used by the m4_defun/m4_require machinery. It is +# important to keep room before GROW because for each nested +# AC_REQUIRE we use an additional diversion (i.e., two m4_require's +# will use GROW - 2. More than 3 levels has never seemed to be +# needed.) +# +# ... +# - GROW - 2 +# m4_require'd code, 2 level deep +# - GROW - 1 +# m4_require'd code, 1 level deep +# - GROW +# m4_defun'd macros are elaborated here. + +m4_define([_m4_divert(GROW)], 10000) + + +# _m4_defun_pro(MACRO-NAME) +# ------------------------- +# The prologue for Autoconf macros. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and m4_defn overhead. +m4_define([_m4_defun_pro], +[m4_ifdef([_m4_expansion_stack], [], [_m4_defun_pro_outer([$1])])]dnl +[m4_expansion_stack_push([$1])m4_pushdef([_m4_expanding($1)])]) + +m4_define([_m4_defun_pro_outer], +[m4_set_delete([_m4_provide])]dnl +[m4_pushdef([_m4_diverting([$1])])m4_pushdef([_m4_diverting], [$1])]dnl +[m4_pushdef([_m4_divert_dump], m4_divnum)m4_divert_push([GROW])]) + +# _m4_defun_epi(MACRO-NAME) +# ------------------------- +# The Epilogue for Autoconf macros. MACRO-NAME only helps tracing +# the PRO/EPI pairs. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and m4_popdef overhead. +m4_define([_m4_defun_epi], +[_m4_popdef([_m4_expanding($1)], [_m4_expansion_stack])]dnl +[m4_ifdef([_m4_expansion_stack], [], [_m4_defun_epi_outer([$1])])]dnl +[m4_provide([$1])]) + +m4_define([_m4_defun_epi_outer], +[_m4_popdef([_m4_divert_dump], [_m4_diverting([$1])], [_m4_diverting])]dnl +[m4_divert_pop([GROW])m4_undivert([GROW])]) + + +# _m4_divert_dump +# --------------- +# If blank, we are outside of any defun'd macro. Otherwise, expands +# to the diversion number (not name) where require'd macros should be +# moved once completed. +m4_define([_m4_divert_dump]) + + +# m4_divert_require(DIVERSION, NAME-TO-CHECK, [BODY-TO-EXPAND]) +# ------------------------------------------------------------- +# Same as m4_require, but BODY-TO-EXPAND goes into the named DIVERSION; +# requirements still go in the current diversion though. +# +m4_define([m4_divert_require], +[m4_ifdef([_m4_expanding($2)], + [m4_fatal([$0: circular dependency of $2])])]dnl +[m4_if(_m4_divert_dump, [], + [m4_fatal([$0($2): cannot be used outside of an m4_defun'd macro])])]dnl +[m4_provide_if([$2], [], + [_m4_require_call([$2], [$3], _m4_divert([$1], [-]))])]) + + +# m4_defun(NAME, EXPANSION, [MACRO = m4_define]) +# ---------------------------------------------- +# Define a macro NAME which automatically provides itself. Add +# machinery so the macro automatically switches expansion to the +# diversion stack if it is not already using it, prior to EXPANSION. +# In this case, once finished, it will bring back all the code +# accumulated in the diversion stack. This, combined with m4_require, +# achieves the topological ordering of macros. We don't use this +# macro to define some frequently called macros that are not involved +# in ordering constraints, to save m4 processing. +# +# MACRO is an undocumented argument; when set to m4_pushdef, and NAME +# is already defined, the new definition is added to the pushdef +# stack, rather than overwriting the current definition. It can thus +# be used to write self-modifying macros, which pop themselves to a +# previously m4_define'd definition so that subsequent use of the +# macro is faster. +m4_define([m4_defun], +[m4_define([m4_location($1)], m4_location)]dnl +[m4_default([$3], [m4_define])([$1], + [_m4_defun_pro(]m4_dquote($[0])[)$2[]_m4_defun_epi(]m4_dquote($[0])[)])]) + + +# m4_defun_init(NAME, INIT, COMMON) +# --------------------------------- +# Like m4_defun, but split EXPANSION into two portions: INIT which is +# done only the first time NAME is invoked, and COMMON which is +# expanded every time. +# +# For now, the COMMON definition is always m4_define'd, giving an even +# lighter-weight definition. m4_defun allows self-providing, but once +# a macro is provided, m4_require no longer cares if it is m4_define'd +# or m4_defun'd. m4_defun also provides location tracking to identify +# dependency bugs, but once the INIT has been expanded, we know there +# are no dependency bugs. However, if a future use needs COMMON to be +# m4_defun'd, we can add a parameter, similar to the third parameter +# to m4_defun. +m4_define([m4_defun_init], +[m4_define([$1], [$3[]])m4_defun([$1], + [$2[]_m4_popdef(]m4_dquote($[0])[)m4_indir(]m4_dquote($[0])dnl +[m4_if(]m4_dquote($[#])[, [0], [], ]m4_dquote([,$]@)[))], [m4_pushdef])]) + + +# m4_defun_once(NAME, EXPANSION) +# ------------------------------ +# Like m4_defun, but guarantee that EXPANSION only happens once +# (thereafter, using NAME is a no-op). +# +# If _m4_divert_dump is empty, we are called at the top level; +# otherwise, we must ensure that we are required in front of the +# current defun'd macro. Use a helper macro so that EXPANSION need +# only occur once in the definition of NAME, since it might be large. +m4_define([m4_defun_once], +[m4_define([m4_location($1)], m4_location)]dnl +[m4_define([$1], [_m4_defun_once([$1], [$2], m4_if(_m4_divert_dump, [], + [[_m4_defun_pro([$1])m4_unquote(], [)_m4_defun_epi([$1])]], +m4_ifdef([_m4_diverting([$1])], [-]), [-], [[m4_unquote(], [)]], + [[_m4_require_call([$1],], [, _m4_divert_dump)]]))])]) + +m4_define([_m4_defun_once], +[m4_pushdef([$1])$3[$2[]m4_provide([$1])]$4]) + + +# m4_pattern_forbid(ERE, [WHY]) +# ----------------------------- +# Declare that no token matching the forbidden perl 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, by autom4te post-processing. +m4_define([m4_pattern_allow], []) + + +## --------------------------------- ## +## 11. Dependencies between macros. ## +## --------------------------------- ## + + +# m4_before(THIS-MACRO-NAME, CALLED-MACRO-NAME) +# --------------------------------------------- +# Issue a warning if CALLED-MACRO-NAME was called before THIS-MACRO-NAME. +m4_define([m4_before], +[m4_provide_if([$2], + [m4_warn([syntax], [$2 was called before $1])])]) + + +# m4_require(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK]) +# ----------------------------------------------------------- +# If NAME-TO-CHECK has never been expanded (actually, if it is not +# m4_provide'd), expand BODY-TO-EXPAND *before* the current macro +# expansion; follow the expansion with a newline. Once expanded, emit +# it in _m4_divert_dump. Keep track of the m4_require chain in +# _m4_expansion_stack. +# +# The normal cases are: +# +# - NAME-TO-CHECK == BODY-TO-EXPAND +# Which you can use for regular macros with or without arguments, e.g., +# m4_require([AC_PROG_CC], [AC_PROG_CC]) +# m4_require([AC_CHECK_HEADERS(threads.h)], [AC_CHECK_HEADERS(threads.h)]) +# which is just the same as +# m4_require([AC_PROG_CC]) +# m4_require([AC_CHECK_HEADERS(threads.h)]) +# +# - BODY-TO-EXPAND == m4_indir([NAME-TO-CHECK]) +# In the case of macros with irregular names. For instance: +# m4_require([AC_LANG_COMPILER(C)], [indir([AC_LANG_COMPILER(C)])]) +# which means `if the macro named `AC_LANG_COMPILER(C)' (the parens are +# part of the name, it is not an argument) has not been run, then +# call it.' +# Had you used +# m4_require([AC_LANG_COMPILER(C)], [AC_LANG_COMPILER(C)]) +# then m4_require would have tried to expand `AC_LANG_COMPILER(C)', i.e., +# call the macro `AC_LANG_COMPILER' with `C' as argument. +# +# You could argue that `AC_LANG_COMPILER', when it receives an argument +# such as `C' should dispatch the call to `AC_LANG_COMPILER(C)'. But this +# `extension' prevents `AC_LANG_COMPILER' from having actual arguments that +# it passes to `AC_LANG_COMPILER(C)'. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and other overhead on the common path. +m4_define([m4_require], +[m4_ifdef([_m4_expanding($1)], + [m4_fatal([$0: circular dependency of $1])])]dnl +[m4_if(_m4_divert_dump, [], + [m4_fatal([$0($1): cannot be used outside of an ]dnl +m4_if([$0], [m4_require], [[m4_defun]], [[AC_DEFUN]])['d macro])])]dnl +[m4_provide_if([$1], [m4_set_contains([_m4_provide], [$1], + [_m4_require_check([$1], _m4_defn([m4_provide($1)]), [$0])], [m4_ignore])], + [_m4_require_call])([$1], [$2], _m4_divert_dump)]) + + +# _m4_require_call(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK], +# DIVERSION-NUMBER) +# ----------------------------------------------------------------- +# If m4_require decides to expand the body, it calls this macro. The +# expansion is placed in DIVERSION-NUMBER. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and other overhead on the common path. +# The use of a witness macro protecting the warning allows aclocal +# to silence any warnings when probing for what macros are required +# and must therefore be located, when using the Autoconf-without-aclocal-m4 +# autom4te language. For more background, see: +# https://lists.gnu.org/archive/html/automake-patches/2012-11/msg00035.html +m4_define([_m4_require_call], +[m4_pushdef([_m4_divert_grow], m4_decr(_m4_divert_grow))]dnl +[m4_pushdef([_m4_diverting([$1])])m4_pushdef([_m4_diverting], [$1])]dnl +[m4_divert_push(_m4_divert_grow, [-])]dnl +[m4_if([$2], [], [$1], [$2]) +m4_provide_if([$1], [m4_set_remove([_m4_provide], [$1])], + [m4_ifndef([m4_require_silent_probe], + [m4_warn([syntax], [$1 is m4_require'd but not m4_defun'd])])])]dnl +[_m4_divert_raw($3)_m4_undivert(_m4_divert_grow)]dnl +[m4_divert_pop(_m4_divert_grow)_m4_popdef([_m4_divert_grow], +[_m4_diverting([$1])], [_m4_diverting])]) + + +# _m4_require_check(NAME-TO-CHECK, OWNER, CALLER) +# ----------------------------------------------- +# NAME-TO-CHECK has been identified as previously expanded in the +# diversion owned by OWNER. If this is a problem, warn on behalf of +# CALLER and return _m4_require_call; otherwise return m4_ignore. +m4_define([_m4_require_check], +[m4_if(_m4_defn([_m4_diverting]), [$2], [m4_ignore], + m4_ifdef([_m4_diverting([$2])], [-]), [-], [m4_warn([syntax], + [$3: `$1' was expanded before it was required +https://www.gnu.org/software/autoconf/manual/autoconf.html#Expanded-Before-Required])_m4_require_call], + [m4_ignore])]) + + +# _m4_divert_grow +# --------------- +# The counter for _m4_require_call. +m4_define([_m4_divert_grow], _m4_divert([GROW])) + + +# m4_expand_once(TEXT, [WITNESS = TEXT]) +# -------------------------------------- +# If TEXT has never been expanded, expand it *here*. Use WITNESS as +# as a memory that TEXT has already been expanded. +m4_define([m4_expand_once], +[m4_provide_if(m4_default_quoted([$2], [$1]), + [], + [m4_provide(m4_default_quoted([$2], [$1]))[]$1])]) + + +# m4_provide(MACRO-NAME) +# ---------------------- +m4_define([m4_provide], +[m4_ifdef([m4_provide($1)], [], +[m4_set_add([_m4_provide], [$1], [m4_define([m4_provide($1)], + m4_ifdef([_m4_diverting], [_m4_defn([_m4_diverting])]))])])]) + + +# m4_provide_if(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED) +# ------------------------------------------------------- +# If MACRO-NAME is provided do IF-PROVIDED, else IF-NOT-PROVIDED. +# The purpose of this macro is to provide the user with a means to +# check macros which are provided without letting her know how the +# information is coded. +m4_define([m4_provide_if], +[m4_ifdef([m4_provide($1)], + [$2], [$3])]) + + +## --------------------- ## +## 12. Text processing. ## +## --------------------- ## + + +# m4_cr_letters +# m4_cr_LETTERS +# m4_cr_Letters +# ------------- +m4_define([m4_cr_letters], [abcdefghijklmnopqrstuvwxyz]) +m4_define([m4_cr_LETTERS], [ABCDEFGHIJKLMNOPQRSTUVWXYZ]) +m4_define([m4_cr_Letters], +m4_defn([m4_cr_letters])dnl +m4_defn([m4_cr_LETTERS])dnl +) + + +# m4_cr_digits +# ------------ +m4_define([m4_cr_digits], [0123456789]) + + +# m4_cr_alnum +# ----------- +m4_define([m4_cr_alnum], +m4_defn([m4_cr_Letters])dnl +m4_defn([m4_cr_digits])dnl +) + + +# m4_cr_symbols1 +# m4_cr_symbols2 +# -------------- +m4_define([m4_cr_symbols1], +m4_defn([m4_cr_Letters])dnl +_) + +m4_define([m4_cr_symbols2], +m4_defn([m4_cr_symbols1])dnl +m4_defn([m4_cr_digits])dnl +) + +# m4_cr_all +# --------- +# The character range representing everything, with `-' as the last +# character, since it is special to m4_translit. Use with care, because +# it contains characters special to M4 (fortunately, both ASCII and EBCDIC +# have [] in order, so m4_defn([m4_cr_all]) remains a valid string). It +# also contains characters special to terminals, so it should never be +# displayed in an error message. Also, attempts to map [ and ] to other +# characters via m4_translit must deal with the fact that m4_translit does +# not add quotes to the output. +# +# In EBCDIC, $ is immediately followed by *, which leads to problems +# if m4_cr_all is inlined into a macro definition; so swap them. +# +# It is mainly useful in generating inverted character range maps, for use +# in places where m4_translit is faster than an equivalent m4_bpatsubst; +# the regex `[^a-z]' is equivalent to: +# m4_translit(m4_dquote(m4_defn([m4_cr_all])), [a-z]) +m4_define([m4_cr_all], +m4_translit(m4_dquote(m4_format(m4_dquote(m4_for( + ,1,255,,[[%c]]))m4_for([i],1,255,,[,i]))), [$*-], [*$])-) + + +# _m4_define_cr_not(CATEGORY) +# --------------------------- +# Define m4_cr_not_CATEGORY as the inverse of m4_cr_CATEGORY. +m4_define([_m4_define_cr_not], +[m4_define([m4_cr_not_$1], + m4_translit(m4_dquote(m4_defn([m4_cr_all])), + m4_defn([m4_cr_$1])))]) + + +# m4_cr_not_letters +# m4_cr_not_LETTERS +# m4_cr_not_Letters +# m4_cr_not_digits +# m4_cr_not_alnum +# m4_cr_not_symbols1 +# m4_cr_not_symbols2 +# ------------------ +# Inverse character sets +_m4_define_cr_not([letters]) +_m4_define_cr_not([LETTERS]) +_m4_define_cr_not([Letters]) +_m4_define_cr_not([digits]) +_m4_define_cr_not([alnum]) +_m4_define_cr_not([symbols1]) +_m4_define_cr_not([symbols2]) + + +# m4_newline([STRING]) +# -------------------- +# Expands to a newline, possibly followed by STRING. Exists mostly for +# formatting reasons. +m4_define([m4_newline], [ +$1]) + + +# m4_re_escape(STRING) +# -------------------- +# Escape RE active characters in STRING. +m4_define([m4_re_escape], +[m4_bpatsubst([$1], + [[][*+.?\^$]], [\\\&])]) + + +# m4_re_string +# ------------ +# Regexp for `[a-zA-Z_0-9]*' +# m4_dquote provides literal [] for the character class. +m4_define([m4_re_string], +m4_dquote(m4_defn([m4_cr_symbols2]))dnl +[*]dnl +) + + +# m4_re_word +# ---------- +# Regexp for `[a-zA-Z_][a-zA-Z_0-9]*' +m4_define([m4_re_word], +m4_dquote(m4_defn([m4_cr_symbols1]))dnl +m4_defn([m4_re_string])dnl +) + + +# m4_tolower(STRING) +# m4_toupper(STRING) +# ------------------ +# These macros convert STRING to lowercase or uppercase. +# +# Rather than expand the m4_defn each time, we inline them up front. +m4_define([m4_tolower], +[m4_translit([[$1]], ]m4_dquote(m4_defn([m4_cr_LETTERS]))[, + ]m4_dquote(m4_defn([m4_cr_letters]))[)]) +m4_define([m4_toupper], +[m4_translit([[$1]], ]m4_dquote(m4_defn([m4_cr_letters]))[, + ]m4_dquote(m4_defn([m4_cr_LETTERS]))[)]) + + +# m4_split(STRING, [REGEXP]) +# -------------------------- +# Split STRING into an m4 list of quoted elements. The elements are +# quoted with [ and ]. Beginning spaces and end spaces *are kept*. +# Use m4_strip to remove them. +# +# REGEXP specifies where to split. Default is [\t ]+. +# +# If STRING is empty, the result is an empty list. +# +# Pay attention to the m4_changequotes. When m4 reads the definition of +# m4_split, it still has quotes set to [ and ]. Luckily, these are matched +# in the macro body, so the definition is stored correctly. Use the same +# alternate quotes as m4_noquote; it must be unlikely to appear in $1. +# +# Also, notice that $1 is quoted twice, since we want the result to +# be quoted. Then you should understand that the argument of +# patsubst is -=<{(STRING)}>=- (i.e., with additional -=<{( and )}>=-). +# +# This macro is safe on active symbols, i.e.: +# m4_define(active, ACTIVE) +# m4_split([active active ])end +# => [active], [active], []end +# +# Optimize on regex of ` ' (space), since m4_foreach_w already guarantees +# that the list contains single space separators, and a common case is +# splitting a single-element list. This macro is called frequently, +# so avoid unnecessary dnl inside the definition. +m4_define([m4_split], +[m4_if([$1], [], [], + [$2], [ ], [m4_if(m4_index([$1], [ ]), [-1], [[[$1]]], + [_$0([$1], [$2], [, ])])], + [$2], [], [_$0([$1], [[ ]+], [, ])], + [_$0([$1], [$2], [, ])])]) + +m4_define([_m4_split], +[m4_changequote([-=<{(],[)}>=-])]dnl +[[m4_bpatsubst(-=<{(-=<{($1)}>=-)}>=-, -=<{($2)}>=-, + -=<{(]$3[)}>=-)]m4_changequote([, ])]) + + +# m4_chomp(STRING) +# m4_chomp_all(STRING) +# -------------------- +# Return STRING quoted, but without a trailing newline. m4_chomp +# removes at most one newline, while m4_chomp_all removes all +# consecutive trailing newlines. Embedded newlines are not touched, +# and a trailing backslash-newline leaves just a trailing backslash. +# +# m4_bregexp is slower than m4_index, and we don't always want to +# remove all newlines; hence the two variants. We massage characters +# to give a nicer pattern to match, particularly since m4_bregexp is +# line-oriented. Both versions must guarantee a match, to avoid bugs +# with precision -1 in m4_format in older m4. +m4_define([m4_chomp], +[m4_format([[%.*s]], m4_index(m4_translit([[$1]], [ +/.], [/ ])[./.], [/.]), [$1])]) + +m4_define([m4_chomp_all], +[m4_format([[%.*s]], m4_bregexp(m4_translit([[$1]], [ +/], [/ ]), [/*$]), [$1])]) + + +# m4_flatten(STRING) +# ------------------ +# If STRING contains end of lines, replace them with spaces. If there +# are backslashed end of lines, remove them. This macro is safe with +# active symbols. +# m4_define(active, ACTIVE) +# m4_flatten([active +# act\ +# ive])end +# => active activeend +# +# In m4, m4_bpatsubst is expensive, so first check for a newline. +m4_define([m4_flatten], +[m4_if(m4_index([$1], [ +]), [-1], [[$1]], + [m4_translit(m4_bpatsubst([[[$1]]], [\\ +]), [ +], [ ])])]) + + +# m4_strip(STRING) +# ---------------- +# Expands into STRING with tabs and spaces singled out into a single +# space, and removing leading and trailing spaces. +# +# This macro is robust to active symbols. +# m4_define(active, ACTIVE) +# m4_strip([ active active ])end +# => active activeend +# +# First, notice that we guarantee trailing space. Why? Because regular +# expressions are greedy, and `.* ?' would always group the space into the +# .* portion. The algorithm is simpler by avoiding `?' at the end. The +# algorithm correctly strips everything if STRING is just ` '. +# +# Then notice the second pattern: it is in charge of removing the +# leading/trailing spaces. Why not just `[^ ]'? Because they are +# applied to over-quoted strings, i.e. more or less [STRING], due +# to the limitations of m4_bpatsubsts. So the leading space in STRING +# is the *second* character; equally for the trailing space. +m4_define([m4_strip], +[m4_bpatsubsts([$1 ], + [[ ]+], [ ], + [^. ?\(.*\) .$], [[[\1]]])]) + + +# m4_normalize(STRING) +# -------------------- +# Apply m4_flatten and m4_strip to STRING. +# +# The argument is quoted, so that the macro is robust to active symbols: +# +# m4_define(active, ACTIVE) +# m4_normalize([ act\ +# ive +# active ])end +# => active activeend + +m4_define([m4_normalize], +[m4_strip(m4_flatten([$1]))]) + + +# m4_validate_w(STRING) +# --------------------- +# Expands into m4_normalize(m4_expand([STRING])), but if that is not +# the same as just m4_normalize([STRING]), issue a warning. +# +# This is used in several Autoconf macros that take a +# whitespace-separated list of symbols as an argument. Ideally that +# list would not be expanded before use, but several packages used +# `dnl' to put comments inside those lists, so they must be expanded +# for compatibility's sake. +m4_define([m4_validate_w], +[_m4_validate_w(m4_normalize([$1]), m4_normalize(m4_expand([$1])))]) + +m4_define([_m4_validate_w], +[m4_if([$1], [$2], [], + [m4_warn([obsolete], [whitespace-separated list contains macros; +in a future version of Autoconf they will not be expanded]dnl +m4_if(m4_bregexp([$1], [\bdn[l]\b]), -1, [], [ +note: `dn@&t@l' is a macro]))])dnl +[$2]]) + + +# m4_join(SEP, ARG1, ARG2...) +# --------------------------- +# Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG +# is the empty string. No expansion is performed on SEP or ARGs. +# +# Since the number of arguments to join can be arbitrarily long, we +# want to avoid having more than one $@ in the macro definition; +# otherwise, the expansion would require twice the memory of the already +# long list. Hence, m4_join merely looks for the first non-empty element, +# and outputs just that element; while _m4_join looks for all non-empty +# elements, and outputs them following a separator. The final trick to +# note is that we decide between recursing with $0 or _$0 based on the +# nested m4_if ending with `_'. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_join], +[m4_if([$#], [1], [], + [$#], [2], [[$2]], + [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift2($@))])]) +m4_define([_m4_join], +[m4_if([$#$2], [2], [], + [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift2($@))])]) + +# m4_joinall(SEP, ARG1, ARG2...) +# ------------------------------ +# Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP. +# No expansion is performed on SEP or ARGs. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_joinall], [[$2]_$0([$1], m4_shift($@))]) +m4_define([_m4_joinall], +[m4_if([$#], [2], [], [[$1$3]$0([$1], m4_shift2($@))])]) + +# m4_combine([SEPARATOR], PREFIX-LIST, [INFIX], SUFFIX...) +# -------------------------------------------------------- +# Produce the pairwise combination of every element in the quoted, +# comma-separated PREFIX-LIST with every element from the SUFFIX arguments. +# Each pair is joined with INFIX, and pairs are separated by SEPARATOR. +# No expansion occurs on SEPARATOR, INFIX, or elements of either list. +# +# For example: +# m4_combine([, ], [[a], [b], [c]], [-], [1], [2], [3]) +# => a-1, a-2, a-3, b-1, b-2, b-3, c-1, c-2, c-3 +# +# This definition is a bit hairy; the thing to realize is that we want +# to construct m4_map_args_sep([[prefix$3]], [], [[$1]], m4_shift3($@)) +# as the inner loop, using each prefix generated by the outer loop, +# and without recalculating m4_shift3 every outer iteration. +m4_define([m4_combine], +[m4_if([$2], [], [], m4_eval([$# > 3]), [1], +[m4_map_args_sep([m4_map_args_sep(m4_dquote(], [)[[$3]], [], [[$1]],]]]dnl +[m4_dquote(m4_dquote(m4_shift3($@)))[[)], [[$1]], $2)])]) + + +# m4_append(MACRO-NAME, STRING, [SEPARATOR]) +# ------------------------------------------ +# Redefine MACRO-NAME to hold its former content plus `SEPARATOR`'STRING' +# at the end. It is valid to use this macro with MACRO-NAME undefined, +# in which case no SEPARATOR is added. Be aware that the criterion is +# `not being defined', and not `not being empty'. +# +# Note that neither STRING nor SEPARATOR are expanded here; rather, when +# you expand MACRO-NAME, they will be expanded at that point in time. +# +# This macro is robust to active symbols. It can be used to grow +# strings. +# +# | m4_define(active, ACTIVE)dnl +# | m4_append([sentence], [This is an])dnl +# | m4_append([sentence], [ active ])dnl +# | m4_append([sentence], [symbol.])dnl +# | sentence +# | m4_undefine([active])dnl +# | sentence +# => This is an ACTIVE symbol. +# => This is an active symbol. +# +# It can be used to define hooks. +# +# | m4_define(active, ACTIVE)dnl +# | m4_append([hooks], [m4_define([act1], [act2])])dnl +# | m4_append([hooks], [m4_define([act2], [active])])dnl +# | m4_undefine([active])dnl +# | act1 +# | hooks +# | act1 +# => act1 +# => +# => active +# +# It can also be used to create lists, although this particular usage was +# broken prior to autoconf 2.62. +# | m4_append([list], [one], [, ])dnl +# | m4_append([list], [two], [, ])dnl +# | m4_append([list], [three], [, ])dnl +# | list +# | m4_dquote(list) +# => one, two, three +# => [one],[two],[three] +# +# Note that m4_append can benefit from amortized O(n) m4 behavior, if +# the underlying m4 implementation is smart enough to avoid copying existing +# contents when enlarging a macro's definition into any pre-allocated storage +# (m4 1.4.x unfortunately does not implement this optimization). We do +# not implement m4_prepend, since it is inherently O(n^2) (pre-allocated +# storage only occurs at the end of a macro, so the existing contents must +# always be moved). +# +# Use _m4_defn for speed. +m4_define([m4_append], +[m4_define([$1], m4_ifdef([$1], [_m4_defn([$1])[$3]])[$2])]) + + +# m4_append_uniq(MACRO-NAME, STRING, [SEPARATOR], [IF-UNIQ], [IF-DUP]) +# -------------------------------------------------------------------- +# Like `m4_append', but append only if not yet present. Additionally, +# expand IF-UNIQ if STRING was appended, or IF-DUP if STRING was already +# present. Also, warn if SEPARATOR is not empty and occurs within STRING, +# as the algorithm no longer guarantees uniqueness. +# +# Note that while m4_append can be O(n) (depending on the quality of the +# underlying M4 implementation), m4_append_uniq is inherently O(n^2) +# because each append operation searches the entire string. +m4_define([m4_append_uniq], +[m4_ifval([$3], [m4_if(m4_index([$2], [$3]), [-1], [], + [m4_warn([syntax], + [$0: `$2' contains `$3'])])])_$0($@)]) +m4_define([_m4_append_uniq], +[m4_ifdef([$1], + [m4_if(m4_index([$3]_m4_defn([$1])[$3], [$3$2$3]), [-1], + [m4_append([$1], [$2], [$3])$4], [$5])], + [m4_define([$1], [$2])$4])]) + +# m4_append_uniq_w(MACRO-NAME, STRINGS) +# ------------------------------------- +# For each of the words in the whitespace separated list STRINGS, append +# only the unique strings to the definition of MACRO-NAME. +# +# Use _m4_defn for speed. +m4_define([m4_append_uniq_w], +[m4_map_args_w([$2], [_m4_append_uniq([$1],], [, [ ])])]) + + +# m4_escape(STRING) +# ----------------- +# Output quoted STRING, but with embedded #, $, [ and ] turned into +# quadrigraphs. +# +# It is faster to check if STRING is already good using m4_translit +# than to blindly perform four m4_bpatsubst. +# +# Because the translit is stripping quotes, it must also neutralize +# anything that might be in a macro name, as well as comments, commas, +# and parentheses. All the problem characters are unified so that a +# single m4_index can scan the result. +# +# Rather than expand m4_defn every time m4_escape is expanded, we +# inline its expansion up front. +m4_define([m4_escape], +[m4_if(m4_index(m4_translit([$1], + [[]#,()]]m4_dquote(m4_defn([m4_cr_symbols2]))[, [$$$]), [$]), + [-1], [m4_echo], [_$0])([$1])]) + +m4_define([_m4_escape], +[m4_changequote([-=<{(],[)}>=-])]dnl +[m4_bpatsubst(m4_bpatsubst(m4_bpatsubst(m4_bpatsubst( + -=<{(-=<{(-=<{(-=<{(-=<{($1)}>=-)}>=-)}>=-)}>=-)}>=-, + -=<{(#)}>=-, -=<{(@%:@)}>=-), + -=<{(\[)}>=-, -=<{(@<:@)}>=-), + -=<{(\])}>=-, -=<{(@:>@)}>=-), + -=<{(\$)}>=-, -=<{(@S|@)}>=-)m4_changequote([,])]) + + +# m4_text_wrap(STRING, [PREFIX], [FIRST-PREFIX], [WIDTH]) +# ------------------------------------------------------- +# Expands into STRING wrapped to hold in WIDTH columns (default = 79). +# If PREFIX is given, each line is prefixed with it. If FIRST-PREFIX is +# specified, then the first line is prefixed with it. As a special case, +# if the length of FIRST-PREFIX is greater than that of PREFIX, then +# FIRST-PREFIX will be left alone on the first line. +# +# No expansion occurs on the contents STRING, PREFIX, or FIRST-PREFIX, +# although quadrigraphs are correctly recognized. More precisely, +# you may redefine m4_qlen to recognize whatever escape sequences that +# you will post-process. +# +# Typical outputs are: +# +# m4_text_wrap([Short string */], [ ], [/* ], 20) +# => /* Short string */ +# +# m4_text_wrap([Much longer string */], [ ], [/* ], 20) +# => /* Much longer +# => string */ +# +# m4_text_wrap([Short doc.], [ ], [ --short ], 30) +# => --short Short doc. +# +# m4_text_wrap([Short doc.], [ ], [ --too-wide ], 30) +# => --too-wide +# => Short doc. +# +# m4_text_wrap([Super long documentation.], [ ], [ --too-wide ], 30) +# => --too-wide +# => Super long +# => documentation. +# +# FIXME: there is no checking of a longer PREFIX than WIDTH, but do +# we really want to bother with people trying each single corner +# of a software? +# +# This macro does not leave a trailing space behind the last word of a line, +# which complicates it a bit. The algorithm is otherwise stupid and simple: +# all the words are preceded by m4_Separator which is defined to empty for +# the first word, and then ` ' (single space) for all the others. +# +# The algorithm uses a helper that uses $2 through $4 directly, rather than +# using local variables, to avoid m4_defn overhead, or expansion swallowing +# any $. It also bypasses m4_popdef overhead with _m4_popdef since no user +# macro expansion occurs in the meantime. Also, the definition is written +# with m4_do, to avoid time wasted on dnl during expansion (since this is +# already a time-consuming macro). +m4_define([m4_text_wrap], +[_$0(m4_escape([$1]), [$2], m4_default_quoted([$3], [$2]), + m4_default_quoted([$4], [79]))]) + +m4_define([_m4_text_wrap], +m4_do(dnl set up local variables, to avoid repeated calculations +[[m4_pushdef([m4_Indent], m4_qlen([$2]))]], +[[m4_pushdef([m4_Cursor], m4_qlen([$3]))]], +[[m4_pushdef([m4_Separator], [m4_define([m4_Separator], [ ])])]], +dnl expand the first prefix, then check its length vs. regular prefix +dnl same length: nothing special +dnl prefix1 longer: output on line by itself, and reset cursor +dnl prefix1 shorter: pad to length of prefix, and reset cursor +[[[$3]m4_cond([m4_Cursor], m4_Indent, [], + [m4_eval(m4_Cursor > m4_Indent)], [1], [ +[$2]m4_define([m4_Cursor], m4_Indent)], + [m4_format([%*s], m4_max([0], + m4_eval(m4_Indent - m4_Cursor)), [])m4_define([m4_Cursor], m4_Indent)])]], +dnl now, for each word, compute the cursor after the word is output, then +dnl check if the cursor would exceed the wrap column +dnl if so, reset cursor, and insert newline and prefix +dnl if not, insert the separator (usually a space) +dnl either way, insert the word +[[m4_map_args_w([$1], [$0_word(], [, [$2], [$4])])]], +dnl finally, clean up the local variables +[[_m4_popdef([m4_Separator], [m4_Cursor], [m4_Indent])]])) + +m4_define([_m4_text_wrap_word], +[m4_define([m4_Cursor], m4_eval(m4_Cursor + m4_qlen([$1]) + 1))]dnl +[m4_if(m4_eval(m4_Cursor > ([$3])), + [1], [m4_define([m4_Cursor], m4_eval(m4_Indent + m4_qlen([$1]) + 1)) +[$2]], + [m4_Separator[]])[$1]]) + +# m4_text_box(MESSAGE, [FRAME-CHARACTER = `-']) +# --------------------------------------------- +# Turn MESSAGE into: +# ## ------- ## +# ## MESSAGE ## +# ## ------- ## +# using FRAME-CHARACTER in the border. +# +# Quadrigraphs are correctly recognized. More precisely, you may +# redefine m4_qlen to recognize whatever escape sequences that you +# will post-process. +m4_define([m4_text_box], +[m4_pushdef([m4_Border], + m4_translit(m4_format([[[%*s]]], m4_decr(m4_qlen(_m4_expand([$1 +]))), []), [ ], m4_default_quoted([$2], [-])))]dnl +[[##] _m4_defn([m4_Border]) [##] +[##] $1 [##] +[##] _m4_defn([m4_Border]) [##]_m4_popdef([m4_Border])]) + + +# m4_qlen(STRING) +# --------------- +# Expands to the length of STRING after autom4te converts all quadrigraphs. +# +# If you use some other means of post-processing m4 output rather than +# autom4te, then you may redefine this macro to recognize whatever +# escape sequences your post-processor will handle. For that matter, +# m4_define([m4_qlen], m4_defn([m4_len])) is sufficient if you don't +# do any post-processing. +# +# Avoid bpatsubsts for the common case of no quadrigraphs. Cache +# results, as configure scripts tend to ask about lengths of common +# strings like `/*' and `*/' rather frequently. Minimize the number +# of times that $1 occurs in m4_qlen, so there is less text to parse +# on a cache hit. +m4_define([m4_qlen], +[m4_ifdef([$0-$1], [_m4_defn([$0-]], [_$0(])[$1])]) +m4_define([_m4_qlen], +[m4_define([m4_qlen-$1], +m4_if(m4_index([$1], [@]), [-1], [m4_len([$1])], + [m4_len(m4_bpatsubst([[$1]], + [@\(\(<:\|:>\|S|\|%:\|\{:\|:\}\)\(@\)\|&t@\)], + [\3]))]))_m4_defn([m4_qlen-$1])]) + +# m4_copyright_condense(TEXT) +# --------------------------- +# Condense the copyright notice in TEXT to only display the final +# year, wrapping the results to fit in 80 columns. +m4_define([m4_copyright_condense], +[m4_text_wrap(m4_bpatsubst(m4_flatten([[$1]]), +[(C)[- ,0-9]*\([1-9][0-9][0-9][0-9]\)], [(C) \1]))]) + +## ----------------------- ## +## 13. Number processing. ## +## ----------------------- ## + +# m4_cmp(A, B) +# ------------ +# Compare two integer expressions. +# A < B -> -1 +# A = B -> 0 +# A > B -> 1 +m4_define([m4_cmp], +[m4_eval((([$1]) > ([$2])) - (([$1]) < ([$2])))]) + + +# m4_list_cmp(A, B) +# ----------------- +# +# Compare the two lists of integer expressions A and B. For instance: +# m4_list_cmp([1, 0], [1]) -> 0 +# m4_list_cmp([1, 0], [1, 0]) -> 0 +# m4_list_cmp([1, 2], [1, 0]) -> 1 +# m4_list_cmp([1, 2, 3], [1, 2]) -> 1 +# m4_list_cmp([1, 2, -3], [1, 2]) -> -1 +# m4_list_cmp([1, 0], [1, 2]) -> -1 +# m4_list_cmp([1], [1, 2]) -> -1 +# m4_define([xa], [oops])dnl +# m4_list_cmp([[0xa]], [5+5]) -> 0 +# +# Rather than face the overhead of m4_case, we use a helper function whose +# expansion includes the name of the macro to invoke on the tail, either +# m4_ignore or m4_unquote. This is particularly useful when comparing +# long lists, since less text is being expanded for deciding when to end +# recursion. The recursion is between a pair of macros that alternate +# which list is trimmed by one element; this is more efficient than +# calling m4_cdr on both lists from a single macro. Guarantee exactly +# one expansion of both lists' side effects. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_list_cmp], +[_$0_raw(m4_dquote($1), m4_dquote($2))]) + +m4_define([_m4_list_cmp_raw], +[m4_if([$1], [$2], [0], [_m4_list_cmp_1([$1], $2)])]) + +m4_define([_m4_list_cmp], +[m4_if([$1], [], [0m4_ignore], [$2], [0], [m4_unquote], [$2m4_ignore])]) + +m4_define([_m4_list_cmp_1], +[_m4_list_cmp_2([$2], [m4_shift2($@)], $1)]) + +m4_define([_m4_list_cmp_2], +[_m4_list_cmp([$1$3], m4_cmp([$3+0], [$1+0]))( + [_m4_list_cmp_1(m4_dquote(m4_shift3($@)), $2)])]) + +# m4_max(EXPR, ...) +# m4_min(EXPR, ...) +# ----------------- +# Return the decimal value of the maximum (or minimum) in a series of +# integer expressions. +# +# M4 1.4.x doesn't provide ?:. Hence this huge m4_eval. Avoid m4_eval +# if both arguments are identical, but be aware of m4_max(0xa, 10) (hence +# the use of <=, not just <, in the second multiply). +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_max], +[m4_if([$#], [0], [m4_fatal([too few arguments to $0])], + [$#], [1], [m4_eval([$1])], + [$#$1], [2$2], [m4_eval([$1])], + [$#], [2], [_$0($@)], + [_m4_minmax([_$0], $@)])]) + +m4_define([_m4_max], +[m4_eval((([$1]) > ([$2])) * ([$1]) + (([$1]) <= ([$2])) * ([$2]))]) + +m4_define([m4_min], +[m4_if([$#], [0], [m4_fatal([too few arguments to $0])], + [$#], [1], [m4_eval([$1])], + [$#$1], [2$2], [m4_eval([$1])], + [$#], [2], [_$0($@)], + [_m4_minmax([_$0], $@)])]) + +m4_define([_m4_min], +[m4_eval((([$1]) < ([$2])) * ([$1]) + (([$1]) >= ([$2])) * ([$2]))]) + +# _m4_minmax(METHOD, ARG1, ARG2...) +# --------------------------------- +# Common recursion code for m4_max and m4_min. METHOD must be _m4_max +# or _m4_min, and there must be at least two arguments to combine. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([_m4_minmax], +[m4_if([$#], [3], [$1([$2], [$3])], + [$0([$1], $1([$2], [$3]), m4_shift3($@))])]) + + +# m4_sign(A) +# ---------- +# The sign of the integer expression A. +m4_define([m4_sign], +[m4_eval((([$1]) > 0) - (([$1]) < 0))]) + + + +## ------------------------ ## +## 14. Version processing. ## +## ------------------------ ## + + +# m4_version_unletter(VERSION) +# ---------------------------- +# Normalize beta version numbers with letters to numeric expressions, which +# can then be handed to m4_eval for the purpose of comparison. +# +# Nl -> (N+1).-1.(l#) +# +# for example: +# [2.14a] -> [0,2,14+1,-1,[0r36:a]] -> 2.15.-1.10 +# [2.14b] -> [0,2,15+1,-1,[0r36:b]] -> 2.15.-1.11 +# [2.61aa.b] -> [0,2.61,1,-1,[0r36:aa],+1,-1,[0r36:b]] -> 2.62.-1.370.1.-1.11 +# [08] -> [0,[0r10:0]8] -> 8 +# +# This macro expects reasonable version numbers, but can handle double +# letters and does not expand any macros. Original version strings can +# use both `.' and `-' separators. +# +# Inline constant expansions, to avoid m4_defn overhead. +# _m4_version_unletter is the real workhorse used by m4_version_compare, +# but since [0r36:a] and commas are less readable than 10 and dots, we +# provide a wrapper for human use. +m4_define([m4_version_unletter], +[m4_substr(m4_map_args([.m4_eval], m4_unquote(_$0([$1]))), [3])]) +m4_define([_m4_version_unletter], +[m4_bpatsubst(m4_bpatsubst(m4_translit([[[[0,$1]]]], [.-], [,,]),]dnl +m4_dquote(m4_dquote(m4_defn([m4_cr_Letters])))[[+], + [+1,-1,[0r36:\&]]), [,0], [,[0r10:0]])]) + + +# m4_version_compare(VERSION-1, VERSION-2) +# ---------------------------------------- +# Compare the two version numbers and expand into +# -1 if VERSION-1 < VERSION-2 +# 0 if = +# 1 if > +# +# Since _m4_version_unletter does not output side effects, we can +# safely bypass the overhead of m4_version_cmp. +m4_define([m4_version_compare], +[_m4_list_cmp_raw(_m4_version_unletter([$1]), _m4_version_unletter([$2]))]) + + +# m4_PACKAGE_NAME +# m4_PACKAGE_TARNAME +# m4_PACKAGE_VERSION +# m4_PACKAGE_STRING +# m4_PACKAGE_BUGREPORT +# -------------------- +# If m4sugar/version.m4 is present, then define version strings. This +# file is optional, provided by Autoconf but absent in Bison. +m4_sinclude([m4sugar/version.m4]) + + +# m4_version_prereq(VERSION, [IF-OK], [IF-NOT = FAIL]) +# ---------------------------------------------------- +# Check this Autoconf version against VERSION. +m4_define([m4_version_prereq], +m4_ifdef([m4_PACKAGE_VERSION], +[[m4_if(m4_version_compare(]m4_dquote(m4_defn([m4_PACKAGE_VERSION]))[, [$1]), + [-1], + [m4_default([$3], + [m4_fatal([Autoconf version $1 or higher is required], + [63])])], + [$2])]], +[[m4_fatal([m4sugar/version.m4 not found])]])) + + +## ------------------ ## +## 15. Set handling. ## +## ------------------ ## + +# Autoconf likes to create arbitrarily large sets; for example, as of +# this writing, the configure.ac for coreutils tracks a set of more +# than 400 AC_SUBST. How do we track all of these set members, +# without introducing duplicates? We could use m4_append_uniq, with +# the set NAME residing in the contents of the macro NAME. +# Unfortunately, m4_append_uniq is quadratic for set creation, because +# it costs O(n) to search the string for each of O(n) insertions; not +# to mention that with m4 1.4.x, even using m4_append is slow, costing +# O(n) rather than O(1) per insertion. Other set operations, not used +# by Autoconf but still possible by manipulation of the definition +# tracked in macro NAME, include O(n) deletion of one element and O(n) +# computation of set size. Because the set is exposed to the user via +# the definition of a single macro, we cannot cache any data about the +# set without risking the cache being invalidated by the user +# redefining NAME. +# +# Can we do better? Yes, because m4 gives us an O(1) search function +# for free: ifdef. Additionally, even m4 1.4.x gives us an O(1) +# insert operation for free: pushdef. But to use these, we must +# represent the set via a group of macros; to keep the set consistent, +# we must hide the set so that the user can only manipulate it through +# accessor macros. The contents of the set are maintained through two +# access points; _m4_set([name]) is a pushdef stack of values in the +# set, useful for O(n) traversal of the set contents; while the +# existence of _m4_set([name],value) with no particular value is +# useful for O(1) querying of set membership. And since the user +# cannot externally manipulate the set, we are free to add additional +# caching macros for other performance improvements. Deletion can be +# O(1) per element rather than O(n), by reworking the definition of +# _m4_set([name],value) to be 0 or 1 based on current membership, and +# adding _m4_set_cleanup(name) to defer the O(n) cleanup of +# _m4_set([name]) until we have another reason to do an O(n) +# traversal. The existence of _m4_set_cleanup(name) can then be used +# elsewhere to determine if we must dereference _m4_set([name],value), +# or assume that definition implies set membership. Finally, size can +# be tracked in an O(1) fashion with _m4_set_size(name). +# +# The quoting in _m4_set([name],value) is chosen so that there is no +# ambiguity with a set whose name contains a comma, and so that we can +# supply the value via _m4_defn([_m4_set([name])]) without needing any +# quote manipulation. + +# m4_set_add(SET, VALUE, [IF-UNIQ], [IF-DUP]) +# ------------------------------------------- +# Add VALUE as an element of SET. Expand IF-UNIQ on the first +# addition, and IF-DUP if it is already in the set. Addition of one +# element is O(1), such that overall set creation is O(n). +# +# We do not want to add a duplicate for a previously deleted but +# unpruned element, but it is just as easy to check existence directly +# as it is to query _m4_set_cleanup($1). +m4_define([m4_set_add], +[m4_ifdef([_m4_set([$1],$2)], + [m4_if(m4_indir([_m4_set([$1],$2)]), [0], + [m4_define([_m4_set([$1],$2)], + [1])_m4_set_size([$1], [m4_incr])$3], [$4])], + [m4_define([_m4_set([$1],$2)], + [1])m4_pushdef([_m4_set([$1])], + [$2])_m4_set_size([$1], [m4_incr])$3])]) + +# m4_set_add_all(SET, VALUE...) +# ----------------------------- +# Add each VALUE into SET. This is O(n) in the number of VALUEs, and +# can be faster than calling m4_set_add for each VALUE. +# +# Implement two recursion helpers; the check variant is slower but +# handles the case where an element has previously been removed but +# not pruned. The recursion helpers ignore their second argument, so +# that we can use the faster m4_shift2 and 2 arguments, rather than +# _m4_shift2 and one argument, as the signal to end recursion. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_set_add_all], +[m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1]) + + m4_len(m4_ifdef([_m4_set_cleanup($1)], [_$0_check], [_$0])([$1], $@))))]) + +m4_define([_m4_set_add_all], +[m4_if([$#], [2], [], + [m4_ifdef([_m4_set([$1],$3)], [], + [m4_define([_m4_set([$1],$3)], [1])m4_pushdef([_m4_set([$1])], + [$3])-])$0([$1], m4_shift2($@))])]) + +m4_define([_m4_set_add_all_check], +[m4_if([$#], [2], [], + [m4_set_add([$1], [$3])$0([$1], m4_shift2($@))])]) + +# m4_set_contains(SET, VALUE, [IF-PRESENT], [IF-ABSENT]) +# ------------------------------------------------------ +# Expand IF-PRESENT if SET contains VALUE, otherwise expand IF-ABSENT. +# This is always O(1). +m4_define([m4_set_contains], +[m4_ifdef([_m4_set_cleanup($1)], + [m4_if(m4_ifdef([_m4_set([$1],$2)], + [m4_indir([_m4_set([$1],$2)])], [0]), [1], [$3], [$4])], + [m4_ifdef([_m4_set([$1],$2)], [$3], [$4])])]) + +# m4_set_contents(SET, [SEP]) +# --------------------------- +# Expand to a single string containing all the elements in SET, +# separated by SEP, without modifying SET. No provision is made for +# disambiguating set elements that contain non-empty SEP as a +# sub-string, or for recognizing a set that contains only the empty +# string. Order of the output is not guaranteed. If any elements +# have been previously removed from the set, this action will prune +# the unused memory. This is O(n) in the size of the set before +# pruning. +# +# Use _m4_popdef for speed. The existence of _m4_set_cleanup($1) +# determines which version of _1 helper we use. +m4_define([m4_set_contents], +[m4_set_map_sep([$1], [], [], [[$2]])]) + +# _m4_set_contents_1(SET) +# _m4_set_contents_1c(SET) +# _m4_set_contents_2(SET, [PRE], [POST], [SEP]) +# --------------------------------------------- +# Expand to a list of quoted elements currently in the set, each +# surrounded by PRE and POST, and moving SEP in front of PRE on +# recursion. To avoid nesting limit restrictions, the algorithm must +# be broken into two parts; _1 destructively copies the stack in +# reverse into _m4_set_($1), producing no output; then _2 +# destructively copies _m4_set_($1) back into the stack in reverse. +# If no elements were deleted, then this visits the set in the order +# that elements were inserted. Behavior is undefined if PRE/POST/SEP +# tries to recursively list or modify SET in any way other than +# calling m4_set_remove on the current element. Use _1 if all entries +# in the stack are guaranteed to be in the set, and _1c to prune +# removed entries. Uses _m4_defn and _m4_popdef for speed. +m4_define([_m4_set_contents_1], +[_m4_stack_reverse([_m4_set([$1])], [_m4_set_($1)])]) + +m4_define([_m4_set_contents_1c], +[m4_ifdef([_m4_set([$1])], + [m4_set_contains([$1], _m4_defn([_m4_set([$1])]), + [m4_pushdef([_m4_set_($1)], _m4_defn([_m4_set([$1])]))], + [_m4_popdef([_m4_set([$1],]_m4_defn( + [_m4_set([$1])])[)])])_m4_popdef([_m4_set([$1])])$0([$1])], + [_m4_popdef([_m4_set_cleanup($1)])])]) + +m4_define([_m4_set_contents_2], +[_m4_stack_reverse([_m4_set_($1)], [_m4_set([$1])], + [$2[]_m4_defn([_m4_set_($1)])$3], [$4[]])]) + +# m4_set_delete(SET) +# ------------------ +# Delete all elements in SET, and reclaim any memory occupied by the +# set. This is O(n) in the set size. +# +# Use _m4_defn and _m4_popdef for speed. +m4_define([m4_set_delete], +[m4_ifdef([_m4_set([$1])], + [_m4_popdef([_m4_set([$1],]_m4_defn([_m4_set([$1])])[)], + [_m4_set([$1])])$0([$1])], + [m4_ifdef([_m4_set_cleanup($1)], + [_m4_popdef([_m4_set_cleanup($1)])])m4_ifdef( + [_m4_set_size($1)], + [_m4_popdef([_m4_set_size($1)])])])]) + +# m4_set_difference(SET1, SET2) +# ----------------------------- +# Produce a LIST of quoted elements that occur in SET1 but not SET2. +# Output a comma prior to any elements, to distinguish the empty +# string from no elements. This can be directly used as a series of +# arguments, such as for m4_join, or wrapped inside quotes for use in +# m4_foreach. Order of the output is not guaranteed. +# +# Short-circuit the idempotence relation. +m4_define([m4_set_difference], +[m4_if([$1], [$2], [], [m4_set_map_sep([$1], [_$0([$2],], [)])])]) + +m4_define([_m4_set_difference], +[m4_set_contains([$1], [$2], [], [,[$2]])]) + +# m4_set_dump(SET, [SEP]) +# ----------------------- +# Expand to a single string containing all the elements in SET, +# separated by SEP, then delete SET. In general, if you only need to +# list the contents once, this is faster than m4_set_contents. No +# provision is made for disambiguating set elements that contain +# non-empty SEP as a sub-string. Order of the output is not +# guaranteed. This is O(n) in the size of the set before pruning. +# +# Use _m4_popdef for speed. Use existence of _m4_set_cleanup($1) to +# decide if more expensive recursion is needed. +m4_define([m4_set_dump], +[m4_ifdef([_m4_set_size($1)], + [_m4_popdef([_m4_set_size($1)])])m4_ifdef([_m4_set_cleanup($1)], + [_$0_check], [_$0])([$1], [], [$2])]) + +# _m4_set_dump(SET, [SEP], [PREP]) +# _m4_set_dump_check(SET, [SEP], [PREP]) +# -------------------------------------- +# Print SEP and the current element, then delete the element and +# recurse with empty SEP changed to PREP. The check variant checks +# whether the element has been previously removed. Use _m4_defn and +# _m4_popdef for speed. +m4_define([_m4_set_dump], +[m4_ifdef([_m4_set([$1])], + [[$2]_m4_defn([_m4_set([$1])])_m4_popdef([_m4_set([$1],]_m4_defn( + [_m4_set([$1])])[)], [_m4_set([$1])])$0([$1], [$2$3])])]) + +m4_define([_m4_set_dump_check], +[m4_ifdef([_m4_set([$1])], + [m4_set_contains([$1], _m4_defn([_m4_set([$1])]), + [[$2]_m4_defn([_m4_set([$1])])])_m4_popdef( + [_m4_set([$1],]_m4_defn([_m4_set([$1])])[)], + [_m4_set([$1])])$0([$1], [$2$3])], + [_m4_popdef([_m4_set_cleanup($1)])])]) + +# m4_set_empty(SET, [IF-EMPTY], [IF-ELEMENTS]) +# -------------------------------------------- +# Expand IF-EMPTY if SET has no elements, otherwise IF-ELEMENTS. +m4_define([m4_set_empty], +[m4_ifdef([_m4_set_size($1)], + [m4_if(m4_indir([_m4_set_size($1)]), [0], [$2], [$3])], [$2])]) + +# m4_set_foreach(SET, VAR, ACTION) +# -------------------------------- +# For each element of SET, define VAR to the element and expand +# ACTION. ACTION should not recursively list SET's contents, add +# elements to SET, nor delete any element from SET except the one +# currently in VAR. The order that the elements are visited in is not +# guaranteed. This is faster than the corresponding m4_foreach([VAR], +# m4_indir([m4_dquote]m4_set_listc([SET])), [ACTION]) +m4_define([m4_set_foreach], +[m4_pushdef([$2])m4_set_map_sep([$1], +[m4_define([$2],], [)$3])m4_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. +m4_define([m4_set_intersection], +[m4_if([$1], [$2], [m4_set_listc([$1])], + m4_eval(m4_set_size([$2]) < m4_set_size([$1])), [1], [$0([$2], [$1])], + [m4_set_map_sep([$1], [_$0([$2],], [)])])]) + +m4_define([_m4_set_intersection], +[m4_set_contains([$1], [$2], [,[$2]])]) + +# m4_set_list(SET) +# m4_set_listc(SET) +# ----------------- +# Produce a LIST of quoted elements of SET. This can be directly used +# as a series of arguments, such as for m4_join or m4_set_add_all, or +# wrapped inside quotes for use in m4_foreach or m4_map. With +# m4_set_list, there is no way to distinguish an empty set from a set +# containing only the empty string; with m4_set_listc, a leading comma +# is output if there are any elements. +m4_define([m4_set_list], +[m4_set_map_sep([$1], [], [], [,])]) + +m4_define([m4_set_listc], +[m4_set_map_sep([$1], [,])]) + +# m4_set_map(SET, ACTION) +# ----------------------- +# For each element of SET, expand ACTION with a single argument of the +# current element. ACTION should not recursively list SET's contents, +# add elements to SET, nor delete any element from SET except the one +# passed as an argument. The order that the elements are visited in +# is not guaranteed. This is faster than either of the corresponding +# m4_map_args([ACTION]m4_set_listc([SET])) +# m4_set_foreach([SET], [VAR], [ACTION(m4_defn([VAR]))]) +m4_define([m4_set_map], +[m4_set_map_sep([$1], [$2(], [)])]) + +# m4_set_map_sep(SET, [PRE], [POST], [SEP]) +# ----------------------------------------- +# For each element of SET, expand PRE[value]POST[], and expand SEP +# between elements. +m4_define([m4_set_map_sep], +[m4_ifdef([_m4_set_cleanup($1)], [_m4_set_contents_1c], + [_m4_set_contents_1])([$1])_m4_set_contents_2($@)]) + +# m4_set_remove(SET, VALUE, [IF-PRESENT], [IF-ABSENT]) +# ---------------------------------------------------- +# If VALUE is an element of SET, delete it and expand IF-PRESENT. +# Otherwise expand IF-ABSENT. Deleting a single value is O(1), +# although it leaves memory occupied until the next O(n) traversal of +# the set which will compact the set. +# +# Optimize if the element being removed is the most recently added, +# since defining _m4_set_cleanup($1) slows down so many other macros. +# In particular, this plays well with m4_set_foreach and m4_set_map. +m4_define([m4_set_remove], +[m4_set_contains([$1], [$2], [_m4_set_size([$1], + [m4_decr])m4_if(_m4_defn([_m4_set([$1])]), [$2], + [_m4_popdef([_m4_set([$1],$2)], [_m4_set([$1])])], + [m4_define([_m4_set_cleanup($1)])m4_define( + [_m4_set([$1],$2)], [0])])$3], [$4])]) + +# m4_set_size(SET) +# ---------------- +# Expand to the number of elements currently in SET. This operation +# is O(1), and thus more efficient than m4_count(m4_set_list([SET])). +m4_define([m4_set_size], +[m4_ifdef([_m4_set_size($1)], [m4_indir([_m4_set_size($1)])], [0])]) + +# _m4_set_size(SET, ACTION) +# ------------------------- +# ACTION must be either m4_incr or m4_decr, and the size of SET is +# changed accordingly. If the set is empty, ACTION must not be +# m4_decr. +m4_define([_m4_set_size], +[m4_define([_m4_set_size($1)], + m4_ifdef([_m4_set_size($1)], [$2(m4_indir([_m4_set_size($1)]))], + [1]))]) + +# m4_set_union(SET1, SET2) +# ------------------------ +# Produce a LIST of double quoted elements that occur in either SET1 +# or SET2, without duplicates. Output a comma prior to any elements, +# to distinguish the empty string from no elements. This can be +# directly used as a series of arguments, such as for m4_join, or +# wrapped inside quotes for use in m4_foreach. Order of the output is +# not guaranteed. +# +# We can rely on the fact that m4_set_listc prunes SET1, so we don't +# need to check _m4_set([$1],element) for 0. Short-circuit the +# idempotence relation. +m4_define([m4_set_union], +[m4_set_listc([$1])m4_if([$1], [$2], [], + [m4_set_map_sep([$2], [_$0([$1],], [)])])]) + +m4_define([_m4_set_union], +[m4_ifdef([_m4_set([$1],$2)], [], [,[$2]])]) + + +## ------------------- ## +## 16. File handling. ## +## ------------------- ## + + +# It is a real pity that M4 comes with no macros to bind a diversion +# to a file. So we have to deal without, which makes us a lot more +# fragile than we should. + + +# m4_file_append(FILE-NAME, CONTENT) +# ---------------------------------- +m4_define([m4_file_append], +[m4_syscmd([cat >>$1 <<_m4eof +$2 +_m4eof +]) +m4_if(m4_sysval, [0], [], + [m4_fatal([$0: cannot write: $1])])]) + + + +## ------------------------ ## +## 17. Setting M4sugar up. ## +## ------------------------ ## + +# _m4_divert_diversion should be defined. +m4_divert_push([KILL]) + +# m4_init +# ------- +# Initialize the m4sugar language. +m4_define([m4_init], +[# All the M4sugar macros start with `m4_', except `dnl' kept as is +# for sake of simplicity. +m4_pattern_forbid([^_?m4_]) +m4_pattern_forbid([^dnl$]) + +# If __m4_version__ is defined, we assume that we are being run by M4 +# 1.6 or newer, thus $@ recursion is linear, and debugmode(+do) +# is available for faster checks of dereferencing undefined macros +# and forcing dumpdef to print to stderr regardless of debugfile. +# But if it is missing, we assume we are being run by M4 1.4.x, that +# $@ recursion is quadratic, and that we need foreach-based +# replacement macros. Also, m4 prior to 1.4.8 loses track of location +# during m4wrap text; __line__ should never be 0. +# +# Use the raw builtin to avoid tripping up include tracing. +# Meanwhile, avoid m4_copy, since it temporarily undefines m4_defn. +m4_ifdef([__m4_version__], +[m4_debugmode([+do]) +m4_define([m4_defn], _m4_defn([_m4_defn])) +m4_define([m4_dumpdef], _m4_defn([_m4_dumpdef])) +m4_define([m4_popdef], _m4_defn([_m4_popdef])) +m4_define([m4_undefine], _m4_defn([_m4_undefine]))], +[m4_builtin([include], [m4sugar/foreach.m4]) +m4_wrap_lifo([m4_if(__line__, [0], [m4_pushdef([m4_location], +]]m4_dquote(m4_dquote(m4_dquote(__file__:__line__)))[[)])])]) + +# Rewrite the first entry of the diversion stack. +m4_divert([KILL]) + +# Check the divert push/pop perfect balance. +# Some users are prone to also use m4_wrap to register last-minute +# m4_divert_text; so after our diversion cleanups, we restore +# KILL as the bottom of the diversion stack. +m4_wrap([m4_popdef([_m4_divert_diversion])m4_ifdef( + [_m4_divert_diversion], [m4_fatal([$0: unbalanced m4_divert_push: +]m4_divert_stack)])_m4_popdef([_m4_divert_stack])m4_divert_push([KILL])]) +]) diff --git a/compiler/win_flex_bison/data/skeletons/bison.m4 b/compiler/win_flex_bison/data/skeletons/bison.m4 new file mode 100644 index 0000000..b7bf5c5 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/bison.m4 @@ -0,0 +1,1241 @@ + -*- Autoconf -*- + +# Language-independent M4 Macros for Bison. + +# Copyright (C) 2002, 2004-2015, 2018-2021 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_gsub(STRING, RE1, SUBST1, RE2, SUBST2, ...) +# ---------------------------------------------- +# m4 equivalent of +# +# $_ = STRING; +# s/RE1/SUBST1/g; +# s/RE2/SUBST2/g; +# ... +# +# Really similar to m4_bpatsubsts, but behaves properly with quotes. +# See m4.at's "Generating Comments". Super inelegant, but so far, I +# did not find any better solution. +m4_define([b4_gsub], +[m4_bpatsubst(m4_bpatsubst(m4_bpatsubst([[[[$1]]]], + [$2], [$3]), + [$4], [$5]), + [$6], [$7])]) + +# m4_shift2 and m4_shift3 are provided by m4sugar. +m4_define([m4_shift4], [m4_shift(m4_shift(m4_shift(m4_shift($@))))]) + + +## ---------------- ## +## Identification. ## +## ---------------- ## + +# b4_generated_by +# --------------- +m4_define([b4_generated_by], +[b4_comment([A Bison parser, made by GNU Bison b4_version_string.]) +]) + +# b4_copyright(TITLE, [YEARS]) +# ---------------------------- +# If YEARS are not defined, use b4_copyright_years. +m4_define([b4_copyright], +[b4_generated_by +b4_comment([$1 + +]m4_dquote(m4_text_wrap([Copyright (C) +]m4_ifval([$2], [[$2]], [m4_defn([b4_copyright_years])])[ +Free Software Foundation, Inc.]))[ + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see .]) + +b4_comment([As a special exception, you may create a larger work that contains +part or all of the Bison parser skeleton and distribute that work +under terms of your choice, so long as that work isn't itself a +parser generator using the skeleton or a modified version thereof +as a parser skeleton. Alternatively, if you modify or redistribute +the parser skeleton itself, you may (at your option) remove this +special exception, which will cause the skeleton and the resulting +Bison output files to be licensed under the GNU General Public +License without this special exception. + +This special exception was added by the Free Software Foundation in +version 2.2 of Bison.]) +]) + + +# b4_disclaimer +# ------------- +# Issue a warning about private implementation details. +m4_define([b4_disclaimer], +[b4_comment([DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, +especially those whose name start with YY_ or yy_. They are +private implementation details that can be changed or removed.]) +]) + + + +# b4_required_version_if(VERSION, IF_NEWER, IF_OLDER) +# --------------------------------------------------- +# If the version %require'd by the user is VERSION (or newer) expand +# IF_NEWER, otherwise IF_OLDER. VERSION should be an integer, e.g., +# 302 for 3.2. +m4_define([b4_required_version_if], +[m4_if(m4_eval($1 <= b4_required_version), + [1], [$2], [$3])]) + + +## -------- ## +## Output. ## +## -------- ## + +# b4_output_begin(FILE1, FILE2) +# ----------------------------- +# Enable output, i.e., send to diversion 0, expand after "#", and +# generate the tag to output into FILE. Must be followed by EOL. +# FILE is FILE1 concatenated to FILE2. FILE2 can be empty, or be +# absolute: do the right thing. +m4_define([b4_output_begin], +[m4_changecom() +m4_divert_push(0)dnl +@output(m4_unquote([$1])@,m4_unquote([$2])@)@dnl +]) + + +# b4_output_end +# ------------- +# Output nothing, restore # as comment character (no expansions after #). +m4_define([b4_output_end], +[m4_divert_pop(0) +m4_changecom([#]) +]) + + +# b4_divert_kill(CODE) +# -------------------- +# Expand CODE for its side effects, discard its output. +m4_define([b4_divert_kill], +[m4_divert_text([KILL], [$1])]) + + +# b4_define_silent(MACRO, CODE) +# ----------------------------- +# Same as m4_define, but throw away the expansion of CODE. +m4_define([b4_define_silent], +[m4_define([$1], [b4_divert_kill([$2])])]) + + +## ---------------- ## +## Error handling. ## +## ---------------- ## + +# The following error handling macros print error directives that should not +# become arguments of other macro invocations since they would likely then be +# mangled. Thus, they print to stdout directly. + +# b4_cat(TEXT) +# ------------ +# Write TEXT to stdout. Precede the final newline with an @ so that it's +# escaped. For example: +# +# b4_cat([[@complain(invalid input@)]]) +m4_define([b4_cat], +[m4_syscmd([cat <<'_m4eof' +]m4_bpatsubst(m4_dquote($1), [_m4eof], [_m4@`eof])[@ +_m4eof +])dnl +m4_if(m4_sysval, [0], [], [m4_fatal([$0: cannot write to stdout])])]) + +# b4_error(KIND, START, END, FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------------------------- +# Write @KIND(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_error([[complain]], [[input.y:2.3]], [[input.y:5.4]], +# [[invalid %s]], [[foo]]) +m4_define([b4_error], +[b4_cat([[@complain][(]$1[@,]$2[@,]$3[@,]$4[]]dnl +[m4_if([$#], [4], [], + [m4_foreach([b4_arg], + m4_dquote(m4_shift4($@)), + [[@,]b4_arg])])[@)]])]) + +# b4_warn(FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------ +# Write @warn(FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_warn([[invalid value for '%s': %s]], [[foo]], [[3]]) +# +# As a simple test suite, this: +# +# m4_divert(-1) +# m4_define([asdf], [ASDF]) +# m4_define([fsa], [FSA]) +# m4_define([fdsa], [FDSA]) +# b4_warn_at([[[asdf), asdf]]], [[[fsa), fsa]]], [[[fdsa), fdsa]]]) +# b4_warn_at([[asdf), asdf]], [[fsa), fsa]], [[fdsa), fdsa]]) +# b4_warn_at() +# b4_warn_at(1) +# b4_warn_at(1, 2) +# +# Should produce this without newlines: +# +# @warn_at([asdf), asdf]@,@,@,[fsa), fsa]@,[fdsa), fdsa]@) +# @warn(asdf), asdf@,@,@,fsa), fsa@,fdsa), fdsa@) +# @warn(@) +# @warn(1@) +# @warn(1@,2@) +m4_define([b4_warn], +[b4_warn_at([], [], $@)]) + +# b4_warn_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# --------------------------------------------------- +# Write @warn(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_warn_at([[input.y:2.3]], [[input.y:5.4]], [[invalid %s]], [[foo]]) +m4_define([b4_warn_at], +[b4_error([[warn]], $@)]) + +# b4_complain(FORMAT, [ARG1], [ARG2], ...) +# ---------------------------------------- +# Bounce to b4_complain_at. +# +# See b4_warn example. +m4_define([b4_complain], +[b4_complain_at([], [], $@)]) + +# b4_complain_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------------------------- +# Write @complain(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# See b4_warn_at example. +m4_define([b4_complain_at], +[b4_error([[complain]], $@)]) + +# b4_fatal(FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------- +# Bounce to b4_fatal_at. +# +# See b4_warn example. +m4_define([b4_fatal], +[b4_fatal_at([], [], $@)]) + +# b4_fatal_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# ---------------------------------------------------- +# Write @fatal(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout and exit. +# +# See b4_warn_at example. +m4_define([b4_fatal_at], +[b4_error([[fatal]], $@)dnl +m4_exit(1)]) + +# b4_canary(MSG) +# -------------- +# Issue a warning on stderr and in the output. Used in the test suite +# to catch spurious m4 evaluations. +m4_define([b4_canary], +[m4_errprintn([dead canary: $1])DEAD CANARY($1)]) + + +## ------------ ## +## Data Types. ## +## ------------ ## + +# b4_ints_in(INT1, INT2, LOW, HIGH) +# --------------------------------- +# Return 1 iff both INT1 and INT2 are in [LOW, HIGH], 0 otherwise. +m4_define([b4_ints_in], +[m4_eval([$3 <= $1 && $1 <= $4 && $3 <= $2 && $2 <= $4])]) + + +# b4_subtract(LHS, RHS) +# --------------------- +# Evaluate LHS - RHS if they are integer literals, otherwise expand +# to (LHS) - (RHS). +m4_define([b4_subtract], +[m4_bmatch([$1$2], [^[0123456789]*$], + [m4_eval([$1 - $2])], + [($1) - ($2)])]) + +# b4_join(ARG1, ...) +# _b4_join(ARG1, ...) +# ------------------- +# Join with comma, skipping empty arguments. +# b4_join calls itself recursively until it sees the first non-empty +# argument, then calls _b4_join (i.e., `_$0`) which prepends each +# non-empty argument with a comma. +m4_define([b4_join], +[m4_if([$#$1], + [1], [], + [m4_ifval([$1], + [$1[]_$0(m4_shift($@))], + [$0(m4_shift($@))])])]) + +# _b4_join(ARGS1, ...) +# -------------------- +m4_define([_b4_join], +[m4_if([$#$1], + [1], [], + [m4_ifval([$1], [, $1])[]$0(m4_shift($@))])]) + + + + +# b4_integral_parser_tables_map(MACRO) +# ------------------------------------- +# Map MACRO on all the integral tables. MACRO is expected to have +# the signature MACRO(TABLE-NAME, CONTENT, COMMENT). +m4_define([b4_integral_parser_tables_map], +[$1([pact], [b4_pact], + [[YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing +STATE-NUM.]]) + +$1([defact], [b4_defact], + [[YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. +Performed when YYTABLE does not specify something else to do. Zero +means the default is an error.]]) + +$1([pgoto], [b4_pgoto], [[YYPGOTO[NTERM-NUM].]]) + +$1([defgoto], [b4_defgoto], [[YYDEFGOTO[NTERM-NUM].]]) + +$1([table], [b4_table], + [[YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If +positive, shift that token. If negative, reduce the rule whose +number is the opposite. If YYTABLE_NINF, syntax error.]]) + +$1([check], [b4_check]) + +$1([stos], [b4_stos], + [[YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of +state STATE-NUM.]]) + +$1([r1], [b4_r1], + [[YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.]]) + +$1([r2], [b4_r2], + [[YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.]]) +]) + + +# b4_parser_tables_declare +# b4_parser_tables_define +# ------------------------ +# Define/declare the (deterministic) parser tables. +m4_define([b4_parser_tables_declare], +[b4_integral_parser_tables_map([b4_integral_parser_table_declare])]) + +m4_define([b4_parser_tables_define], +[b4_integral_parser_tables_map([b4_integral_parser_table_define])]) + + + +## ------------------ ## +## Decoding options. ## +## ------------------ ## + +# b4_flag_if(FLAG, IF-TRUE, IF-FALSE) +# ----------------------------------- +# Run IF-TRUE if b4_FLAG_flag is 1, IF-FALSE if FLAG is 0, otherwise fail. +m4_define([b4_flag_if], +[m4_case(b4_$1_flag, + [0], [$3], + [1], [$2], + [m4_fatal([invalid $1 value: ]b4_$1_flag)])]) + + +# b4_define_flag_if(FLAG) +# ----------------------- +# Define "b4_FLAG_if(IF-TRUE, IF-FALSE)" that depends on the +# value of the Boolean FLAG. +m4_define([b4_define_flag_if], +[_b4_define_flag_if($[1], $[2], [$1])]) + +# _b4_define_flag_if($1, $2, FLAG) +# -------------------------------- +# Work around the impossibility to define macros inside macros, +# because issuing '[$1]' is not possible in M4. GNU M4 should provide +# $$1 a la M5/TeX. +m4_define([_b4_define_flag_if], +[m4_if([$1$2], $[1]$[2], [], + [m4_fatal([$0: Invalid arguments: $@])])dnl +m4_define([b4_$3_if], + [b4_flag_if([$3], [$1], [$2])])]) + + +# b4_FLAG_if(IF-TRUE, IF-FALSE) +# ----------------------------- +# Expand IF-TRUE, if FLAG is true, IF-FALSE otherwise. +b4_define_flag_if([glr]) # Whether a GLR parser is requested. +b4_define_flag_if([has_translations]) # Whether some tokens are internationalized. +b4_define_flag_if([header]) # Whether a header is requested. +b4_define_flag_if([nondeterministic]) # Whether conflicts should be handled. +b4_define_flag_if([token_table]) # Whether yytoken_table is demanded. +b4_define_flag_if([yacc]) # Whether POSIX Yacc is emulated. + + +# b4_glr_cc_if([IF-TRUE], [IF-FALSE]) +# ----------------------------------- +m4_define([b4_glr_cc_if], + [m4_if(b4_skeleton, ["glr.cc"], $@)]) + +# b4_glr2_cc_if([IF-TRUE], [IF-FALSE]) +# ------------------------------------ +m4_define([b4_glr2_cc_if], + [m4_if(b4_skeleton, ["glr2.cc"], $@)]) + +## --------- ## +## Symbols. ## +## --------- ## + +# For a description of the Symbol handling, see README.md. +# +# The following macros provide access to symbol related values. + +# __b4_symbol(NUM, FIELD) +# ----------------------- +# Fetch FIELD of symbol #NUM. Fail if undefined. +m4_define([__b4_symbol], +[m4_indir([b4_symbol($1, $2)])]) + + +# _b4_symbol(NUM, FIELD) +# ---------------------- +# Fetch FIELD of symbol #NUM (or "orig NUM", see README.md). +# Fail if undefined. +m4_define([_b4_symbol], +[m4_ifdef([b4_symbol($1, number)], + [__b4_symbol(m4_indir([b4_symbol($1, number)]), $2)], + [__b4_symbol([$1], [$2])])]) + + +# b4_symbol_token_kind(NUM) +# ------------------------- +# The token kind of this symbol. +m4_define([b4_symbol_token_kind], +[b4_percent_define_get([api.token.prefix])dnl +_b4_symbol([$1], [id])]) + + +# b4_symbol_kind_base(NUM) +# ------------------------ +# Build the name of the kind of this symbol. It must always exist, +# otherwise some symbols might not be represented in the enum, which +# might be compiled into too small a type to contain all the symbol +# numbers. +m4_define([b4_symbol_prefix], [b4_percent_define_get([api.symbol.prefix])]) +m4_define([b4_symbol_kind_base], +[b4_percent_define_get([api.symbol.prefix])dnl +m4_case([$1], + [-2], [[YYEMPTY]], + [0], [[YYEOF]], + [1], [[YYerror]], + [2], [[YYUNDEF]], + [m4_case(b4_symbol([$1], [tag]), + [$accept], [[YYACCEPT]], + [b4_symbol_if([$1], [has_id], _b4_symbol([$1], [id]), + [m4_bpatsubst([$1-][]_b4_symbol([$1], [tag]), [[^a-zA-Z_0-9]+], [_])])])])]) + + +# b4_symbol_kind(NUM) +# ------------------- +# Same as b4_symbol_kind, but possibly with a prefix in some +# languages. E.g., EOF's kind_base and kind are YYSYMBOL_YYEOF in C, +# but are S_YYEMPTY and symbol_kind::S_YYEMPTY in C++. +m4_copy([b4_symbol_kind_base], [b4_symbol_kind]) + + +# b4_symbol_slot(NUM) +# ------------------- +# The name of union member that contains the value of these symbols. +# Currently, we are messy, this should actually be type_tag, but type_tag +# has several meanings. +m4_define([b4_symbol_slot], +[m4_case(b4_percent_define_get([[api.value.type]]), + [union], [b4_symbol([$1], [type_tag])], + [variant], [b4_symbol([$1], [type_tag])], + [b4_symbol([$1], [type])])]) + + +# b4_symbol(NUM, FIELD) +# --------------------- +# Fetch FIELD of symbol #NUM (or "orig NUM", or "empty"). Fail if undefined. +# +# If FIELD = id, prepend the token prefix. +m4_define([b4_symbol], +[m4_if([$1], [empty], [b4_symbol([-2], [$2])], + [$1], [eof], [b4_symbol([0], [$2])], + [$1], [error], [b4_symbol([1], [$2])], + [$1], [undef], [b4_symbol([2], [$2])], + [m4_case([$2], + [id], [b4_symbol_token_kind([$1])], + [kind_base], [b4_symbol_kind_base([$1])], + [kind], [b4_symbol_kind([$1])], + [slot], [b4_symbol_slot([$1])], + [_b4_symbol($@)])])]) + + +# b4_symbol_if(NUM, FIELD, IF-TRUE, IF-FALSE) +# ------------------------------------------- +# If FIELD about symbol #NUM is 1 expand IF-TRUE, if is 0, expand IF-FALSE. +# Otherwise an error. +m4_define([b4_symbol_if], +[m4_case(b4_symbol([$1], [$2]), + [1], [$3], + [0], [$4], + [m4_fatal([$0: field $2 of $1 is not a Boolean:] b4_symbol([$1], [$2]))])]) + + +# b4_symbol_tag_comment(SYMBOL-NUM) +# --------------------------------- +# Issue a comment giving the tag of symbol NUM. +m4_define([b4_symbol_tag_comment], +[b4_comment([b4_symbol([$1], [tag])]) +]) + + +# b4_symbol_action(SYMBOL-NUM, ACTION) +# ------------------------------------ +# Run the action ACTION ("destructor" or "printer") for SYMBOL-NUM. +m4_define([b4_symbol_action], +[b4_symbol_if([$1], [has_$2], +[b4_dollar_pushdef([(*yyvaluep)], + [$1], + [], + [(*yylocationp)])dnl + _b4_symbol_case([$1])[]dnl +b4_syncline([b4_symbol([$1], [$2_line])], [b4_symbol([$1], [$2_file])])dnl +b4_symbol([$1], [$2]) +b4_syncline([@oline@], [@ofile@])dnl + break; + +b4_dollar_popdef[]dnl +])]) + + +# b4_symbol_destructor(SYMBOL-NUM) +# b4_symbol_printer(SYMBOL-NUM) +# -------------------------------- +m4_define([b4_symbol_destructor], [b4_symbol_action([$1], [destructor])]) +m4_define([b4_symbol_printer], [b4_symbol_action([$1], [printer])]) + + +# b4_symbol_actions(ACTION, [KIND = yykind]) +# ------------------------------------------ +# Emit the symbol actions for ACTION ("destructor" or "printer"). +# Dispatch on KIND. +m4_define([b4_symbol_actions], +[m4_pushdef([b4_actions_], m4_expand([b4_symbol_foreach([b4_symbol_$1])]))dnl +m4_ifval(m4_defn([b4_actions_]), +[switch (m4_default([$2], [yykind])) + { +m4_defn([b4_actions_])[]dnl + default: + break; + }dnl +], +[b4_use(m4_default([$2], [yykind]));])dnl +m4_popdef([b4_actions_])dnl +]) + +# _b4_symbol_case(SYMBOL-NUM) +# --------------------------- +# Issue a "case NUM" for SYMBOL-NUM. Ends with its EOL to make it +# easier to use with m4_map, but then, use []dnl to suppress the last +# one. +m4_define([_b4_symbol_case], +[case b4_symbol([$1], [kind]): b4_symbol_tag_comment([$1])]) +]) + + +# b4_symbol_foreach(MACRO) +# ------------------------ +# Invoke MACRO(SYMBOL-NUM) for each SYMBOL-NUM. +m4_define([b4_symbol_foreach], + [m4_map([$1], m4_defn([b4_symbol_numbers]))]) + +# b4_symbol_map(MACRO) +# -------------------- +# Return a list (possibly empty elements) of MACRO invoked for each +# SYMBOL-NUM. +m4_define([b4_symbol_map], +[m4_map_args_sep([$1(], [)], [,], b4_symbol_numbers)]) + + +# b4_token_visible_if(NUM, IF-TRUE, IF-FALSE) +# ------------------------------------------- +# Whether NUM denotes a token kind that has an exported definition +# (i.e., shows in enum yytokentype). +m4_define([b4_token_visible_if], +[b4_symbol_if([$1], [is_token], + [b4_symbol_if([$1], [has_id], [$2], [$3])], + [$3])]) + + +# b4_token_has_definition(NUM) +# ---------------------------- +# 1 if NUM is visible, nothing otherwise. +m4_define([b4_token_has_definition], +[b4_token_visible_if([$1], [1])]) + +# b4_any_token_visible_if([IF-TRUE], [IF-FALSE]) +# ---------------------------------------------- +# Whether there is a token that needs to be defined. +m4_define([b4_any_token_visible_if], +[m4_ifval(b4_symbol_foreach([b4_token_has_definition]), + [$1], [$2])]) + + +# b4_token_format(FORMAT, NUM) +# ---------------------------- +# If token NUM has a visible ID, format FORMAT with ID, USER_NUMBER. +m4_define([b4_token_format], +[b4_token_visible_if([$2], +[m4_format([[$1]], + b4_symbol([$2], [id]), + b4_symbol([$2], b4_api_token_raw_if([[number]], [[code]])))])]) + + +# b4_last_enum_token +# ------------------ +# The code of the last token visible token. +m4_define([_b4_last_enum_token], +[b4_token_visible_if([$1], + [m4_define([b4_last_enum_token], [$1])])]) +b4_symbol_foreach([_b4_last_enum_token]) + +# b4_last_symbol +# -------------- +# The code of the last symbol. +m4_define([b4_last_symbol], m4_eval(b4_tokens_number + b4_nterms_number - 1)) + +## ------- ## +## Types. ## +## ------- ## + +# _b4_type_action(NUMS) +# --------------------- +# Run actions for the symbol NUMS that all have the same type-name. +# Skip NUMS that have no type-name. +# +# To specify the action to run, define b4_dollar_dollar(SYMBOL-NUM, +# TAG, TYPE). +m4_define([_b4_type_action], +[b4_symbol_if([$1], [has_type], +[m4_map([ _b4_symbol_case], [$@])[]dnl + b4_dollar_dollar([b4_symbol([$1], [number])], + [b4_symbol([$1], [tag])], + [b4_symbol([$1], [type])]); + break; + +])]) + +# b4_type_foreach(MACRO, [SEP]) +# ----------------------------- +# Invoke MACRO(SYMBOL-NUMS) for each set of SYMBOL-NUMS for each type set. +m4_define([b4_type_foreach], + [m4_map_sep([$1], [$2], m4_defn([b4_type_names]))]) + + + +## ----------- ## +## Synclines. ## +## ----------- ## + +# b4_basename(NAME) +# ----------------- +# Similar to POSIX basename; the differences don't matter here. +# Beware that NAME is not evaluated. +m4_define([b4_basename], +[m4_bpatsubst([$1], [^.*/\([^/]+\)/*$], [\1])]) + + +# b4_syncline(LINE, FILE)dnl +# -------------------------- +# Should always be following by a dnl. +# +# Emit "#line LINE FILE /* __LINE__ __FILE__ */". +m4_define([b4_syncline], +[b4_flag_if([synclines], +[b4_sync_start([$1], [$2])[]dnl +b4_sync_end([__line__], [b4_basename(m4_quote(__file__))]) +])]) + +# b4_sync_start(LINE, FILE) +# ----------------------- +# Syncline for the new place. Typically a directive for the compiler. +m4_define([b4_sync_start], [b4_comment([$2:$1])]) + +# b4_sync_end(LINE, FILE) +# ----------------------- +# Syncline for the current place, which ends. Typically a comment +# left for the reader. +m4_define([b4_sync_end], [ b4_comment([$2:$1])] +) +# This generates dependencies on the Bison skeletons hence lots of +# useless 'git diff'. This location is useless for the regular +# user (who does not care about the skeletons) and is actually not +# useful for Bison developers too (I, Akim, never used this to locate +# the code in skeletons that generated output). So disable it +# completely. If someone thinks this was actually useful, a %define +# variable should be provided to control the level of verbosity of +# '#line', in replacement of --no-lines. +m4_define([b4_sync_end]) + + +# 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, COMMENT) +# ----------------------------------- +# From b4_MACRO, if defined, build b4_user_MACRO that includes the synclines. +m4_define([b4_define_user_code], +[m4_define([b4_user_$1], + [m4_ifdef([b4_$1], + [m4_ifval([$2], + [b4_comment([$2]) +])b4_user_code([b4_$1])])])]) + +# b4_user_actions +# b4_user_initial_action +# b4_user_post_prologue +# b4_user_pre_prologue +# b4_user_union_members +# ---------------------- +# Macros that issue user code, ending with synclines. +b4_define_user_code([actions]) +b4_define_user_code([initial_action], [User initialization code.]) +b4_define_user_code([post_prologue], [Second part of user prologue.]) +b4_define_user_code([pre_prologue], [First part of user prologue.]) +b4_define_user_code([union_members]) + + +# b4_check_user_names(WHAT, USER-LIST, BISON-NAMESPACE) +# ----------------------------------------------------- +# Complain if any name of type WHAT is used by the user (as recorded in +# USER-LIST) but is not used by Bison (as recorded by macros in the +# namespace BISON-NAMESPACE). +# +# USER-LIST must expand to a list specifying all user occurrences of all names +# of type WHAT. Each item in the list must be a triplet specifying one +# occurrence: name, start boundary, and end boundary. Empty string names are +# fine. An empty list is fine. +# +# For example, to define b4_foo_user_names to be used for USER-LIST with three +# name occurrences and with correct quoting: +# +# m4_define([b4_foo_user_names], +# [[[[[[bar]], [[parser.y:1.7]], [[parser.y:1.16]]]], +# [[[[bar]], [[parser.y:5.7]], [[parser.y:5.16]]]], +# [[[[baz]], [[parser.y:8.7]], [[parser.y:8.16]]]]]]) +# +# The macro BISON-NAMESPACE(bar) must be defined iff the name bar of type WHAT +# is used by Bison (in the front-end or in the skeleton). Empty string names +# are fine, but it would be ugly for Bison to actually use one. +# +# For example, to use b4_foo_bison_names for BISON-NAMESPACE and define that +# the names bar and baz are used by Bison: +# +# m4_define([b4_foo_bison_names(bar)]) +# m4_define([b4_foo_bison_names(baz)]) +# +# To invoke b4_check_user_names with TYPE foo, with USER-LIST +# b4_foo_user_names, with BISON-NAMESPACE b4_foo_bison_names, and with correct +# quoting: +# +# b4_check_user_names([[foo]], [b4_foo_user_names], +# [[b4_foo_bison_names]]) +m4_define([b4_check_user_names], +[m4_foreach([b4_occurrence], $2, +[m4_pushdef([b4_occurrence], b4_occurrence)dnl +m4_pushdef([b4_user_name], m4_car(b4_occurrence))dnl +m4_pushdef([b4_start], m4_car(m4_shift(b4_occurrence)))dnl +m4_pushdef([b4_end], m4_shift2(b4_occurrence))dnl +m4_ifndef($3[(]m4_quote(b4_user_name)[)], + [b4_complain_at([b4_start], [b4_end], + [[%s '%s' is not used]], + [$1], [b4_user_name])])[]dnl +m4_popdef([b4_occurrence])dnl +m4_popdef([b4_user_name])dnl +m4_popdef([b4_start])dnl +m4_popdef([b4_end])dnl +])]) + + + +## --------------------- ## +## b4_percent_define_*. ## +## --------------------- ## + + +# b4_percent_define_use(VARIABLE) +# ------------------------------- +# Declare that VARIABLE was used. +m4_define([b4_percent_define_use], +[m4_define([b4_percent_define_bison_variables(]$1[)])dnl +]) + +# b4_percent_define_get(VARIABLE, [DEFAULT]) +# ------------------------------------------ +# Mimic muscle_percent_define_get in ../src/muscle-tab.h. That is, if +# the %define variable VARIABLE is defined, emit its value. Contrary +# to its C counterpart, return DEFAULT otherwise. Also, record +# Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_get([[foo]]) +m4_define([b4_percent_define_get], +[b4_percent_define_use([$1])dnl +_b4_percent_define_ifdef([$1], + [m4_indir([b4_percent_define(]$1[)])], + [$2])]) + +# b4_percent_define_get_loc(VARIABLE) +# ----------------------------------- +# Mimic muscle_percent_define_get_loc in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is undefined, complain fatally since that's +# a Bison or skeleton error. Otherwise, return its definition location in a +# form appropriate for the first two arguments of b4_warn_at, b4_complain_at, or +# b4_fatal_at. Don't record this as a Bison usage of VARIABLE as there's no +# reason to suspect that the user-supplied value has yet influenced the output. +# +# For example: +# +# b4_complain_at(b4_percent_define_get_loc([[foo]]), [[invalid foo]]) +m4_define([b4_percent_define_get_loc], +[m4_ifdef([b4_percent_define_loc(]$1[)], + [m4_pushdef([b4_loc], m4_indir([b4_percent_define_loc(]$1[)]))dnl +b4_loc[]dnl +m4_popdef([b4_loc])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_define_get_kind(VARIABLE) +# ------------------------------------ +# Get the kind (code, keyword, string) of VARIABLE, i.e., how its +# value was defined (braces, not delimiters, quotes). +# +# If the %define variable VARIABLE is undefined, complain fatally +# since that's a Bison or skeleton error. Don't record this as a +# Bison usage of VARIABLE as there's no reason to suspect that the +# user-supplied value has yet influenced the output. +m4_define([b4_percent_define_get_kind], +[m4_ifdef([b4_percent_define_kind(]$1[)], + [m4_indir([b4_percent_define_kind(]$1[)])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_define_get_syncline(VARIABLE)dnl +# ------------------------------------------- +# Should always be following by a dnl. +# +# Mimic muscle_percent_define_get_syncline in ../src/muscle-tab.h exactly. +# That is, if the %define variable VARIABLE is undefined, complain fatally +# since that's a Bison or skeleton error. Otherwise, return its definition +# location as a b4_syncline invocation. Don't record this as a Bison usage of +# VARIABLE as there's no reason to suspect that the user-supplied value has yet +# influenced the output. +# +# For example: +# +# b4_percent_define_get_syncline([[foo]]) +m4_define([b4_percent_define_get_syncline], +[m4_ifdef([b4_percent_define_syncline(]$1[)], + [m4_indir([b4_percent_define_syncline(]$1[)])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + +# _b4_percent_define_ifdef(VARIABLE, IF-TRUE, [IF-FALSE]) +# ------------------------------------------------------ +# If the %define variable VARIABLE is defined, expand IF-TRUE, else expand +# IF-FALSE. Don't record usage of VARIABLE. +# +# For example: +# +# _b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]]) +m4_define([_b4_percent_define_ifdef], +[m4_ifdef([b4_percent_define(]$1[)], + [$2], + [$3])]) + +# b4_percent_define_ifdef(VARIABLE, IF-TRUE, [IF-FALSE]) +# ------------------------------------------------------ +# Mimic muscle_percent_define_ifdef in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is defined, expand IF-TRUE, else expand +# IF-FALSE. Also, record Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]]) +m4_define([b4_percent_define_ifdef], +[_b4_percent_define_ifdef([$1], + [b4_percent_define_use([$1])$2], + [$3])]) + + +# b4_percent_define_check_file_complain(VARIABLE) +# ----------------------------------------------- +# Warn about %define variable VARIABLE having an incorrect +# value. +m4_define([b4_percent_define_check_file_complain], +[b4_complain_at(b4_percent_define_get_loc([$1]), + [[%%define variable '%s' requires 'none' or '"..."' values]], + [$1])]) + + +# b4_percent_define_check_file(MACRO, VARIABLE, DEFAULT) +# ------------------------------------------------------ +# If the %define variable VARIABLE: +# - is undefined, then if DEFAULT is non-empty, define MACRO to DEFAULT +# - is a string, define MACRO to its value +# - is the keyword 'none', do nothing +# - otherwise, warn about the incorrect value. +m4_define([b4_percent_define_check_file], +[b4_percent_define_ifdef([$2], + [m4_case(b4_percent_define_get_kind([$2]), + [string], + [m4_define([$1], b4_percent_define_get([$2]))], + [keyword], + [m4_if(b4_percent_define_get([$2]), [none], [], + [b4_percent_define_check_file_complain([$2])])], + [b4_percent_define_check_file_complain([$2])]) + ], + [m4_ifval([$3], + [m4_define([$1], [$3])])]) +]) + + + +## --------- ## +## Options. ## +## --------- ## + + +# b4_percent_define_flag_if(VARIABLE, IF-TRUE, [IF-FALSE]) +# -------------------------------------------------------- +# Mimic muscle_percent_define_flag_if in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is defined to "" or "true", expand IF-TRUE. +# If it is defined to "false", expand IF-FALSE. Complain if it is undefined +# (a Bison or skeleton error since the default value should have been set +# already) or defined to any other value (possibly a user error). Also, record +# Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_flag_if([[foo]], [[it's true]], [[it's false]]) +m4_define([b4_percent_define_flag_if], +[b4_percent_define_ifdef([$1], + [m4_case(b4_percent_define_get([$1]), + [], [$2], [true], [$2], [false], [$3], + [m4_expand_once([b4_complain_at(b4_percent_define_get_loc([$1]), + [[invalid value for %%define Boolean variable '%s']], + [$1])], + [[b4_percent_define_flag_if($1)]])])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + + +# b4_percent_define_default(VARIABLE, DEFAULT, [KIND = keyword]) +# -------------------------------------------------------------- +# Mimic muscle_percent_define_default in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is undefined, set its value to DEFAULT. +# Don't record this as a Bison usage of VARIABLE as there's no reason to +# suspect that the value has yet influenced the output. +# +# For example: +# +# b4_percent_define_default([[foo]], [[default value]]) +m4_define([_b4_percent_define_define], +[m4_define([b4_percent_define(]$1[)], [$2])dnl +m4_define([b4_percent_define_kind(]$1[)], + [m4_default([$3], [keyword])])dnl +m4_define([b4_percent_define_loc(]$1[)], + [[[[:-1.-1]], + [[:-1.-1]]]])dnl +m4_define([b4_percent_define_syncline(]$1[)], [[]])]) + +m4_define([b4_percent_define_default], +[_b4_percent_define_ifdef([$1], [], + [_b4_percent_define_define($@)])]) + + +# b4_percent_define_if_define(NAME, [VARIABLE = NAME]) +# ---------------------------------------------------- +# Define b4_NAME_if that executes its $1 or $2 depending whether +# VARIABLE was %defined. The characters '.' and `-' in VARIABLE are mapped +# to '_'. +m4_define([_b4_percent_define_if_define], +[m4_define(m4_bpatsubst([b4_$1_if], [[-.]], [_]), + [b4_percent_define_default([m4_default([$2], [$1])], [[false]])dnl +b4_percent_define_flag_if(m4_default([$2], [$1]), + [$3], [$4])])]) + +m4_define([b4_percent_define_if_define], +[_b4_percent_define_if_define([$1], [$2], $[1], $[2])]) + + +# b4_percent_define_check_kind(VARIABLE, KIND, [DIAGNOSTIC = complain]) +# --------------------------------------------------------------------- +m4_define([b4_percent_define_check_kind], +[_b4_percent_define_ifdef([$1], + [m4_if(b4_percent_define_get_kind([$1]), [$2], [], + [b4_error([m4_default([$3], [complain])], + b4_percent_define_get_loc([$1]), + [m4_case([$2], + [code], [[%%define variable '%s' requires '{...}' values]], + [keyword], [[%%define variable '%s' requires keyword values]], + [string], [[%%define variable '%s' requires '"..."' values]])], + [$1])])])dnl +]) + + +# b4_percent_define_check_values(VALUES) +# -------------------------------------- +# Mimic muscle_percent_define_check_values in ../src/muscle-tab.h exactly +# except that the VALUES structure is more appropriate for M4. That is, VALUES +# is a list of sublists of strings. For each sublist, the first string is the +# name of a %define variable, and all remaining strings in that sublist are the +# valid values for that variable. Complain if such a variable is undefined (a +# Bison error since the default value should have been set already) or defined +# to any other value (possibly a user error). Don't record this as a Bison +# usage of the variable as there's no reason to suspect that the value has yet +# influenced the output. +# +# For example: +# +# b4_percent_define_check_values([[[[foo]], [[foo-value1]], [[foo-value2]]]], +# [[[[bar]], [[bar-value1]]]]) +m4_define([b4_percent_define_check_values], +[m4_foreach([b4_sublist], m4_quote($@), + [_b4_percent_define_check_values(b4_sublist)])]) + +m4_define([_b4_percent_define_check_values], +[_b4_percent_define_ifdef([$1], + [b4_percent_define_check_kind(]$1[, [keyword], [deprecated])dnl + m4_pushdef([b4_good_value], [0])dnl + m4_if($#, 1, [], + [m4_foreach([b4_value], m4_dquote(m4_shift($@)), + [m4_if(m4_indir([b4_percent_define(]$1[)]), b4_value, + [m4_define([b4_good_value], [1])])])])dnl + m4_if(b4_good_value, [0], + [b4_complain_at(b4_percent_define_get_loc([$1]), + [[invalid value for %%define variable '%s': '%s']], + [$1], + m4_dquote(m4_indir([b4_percent_define(]$1[)]))) + m4_foreach([b4_value], m4_dquote(m4_shift($@)), + [b4_error([[note]], b4_percent_define_get_loc([$1]), [] + [[accepted value: '%s']], + m4_dquote(b4_value))])])dnl + m4_popdef([b4_good_value])], + [b4_fatal([[$0: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_code_get([QUALIFIER]) +# -------------------------------- +# If any %code blocks for QUALIFIER are defined, emit them beginning with a +# comment and ending with synclines and a newline. If QUALIFIER is not +# specified or empty, do this for the unqualified %code blocks. Also, record +# Bison's usage of QUALIFIER (if specified) by defining +# b4_percent_code_bison_qualifiers(QUALIFIER). +# +# For example, to emit any unqualified %code blocks followed by any %code +# blocks for the qualifier foo: +# +# b4_percent_code_get +# b4_percent_code_get([[foo]]) +m4_define([b4_percent_code_get], +[m4_pushdef([b4_macro_name], [[b4_percent_code(]$1[)]])dnl +m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])dnl +m4_ifdef(b4_macro_name, +[b4_comment(m4_if([$#], [0], [[[Unqualified %code blocks.]]], + [[["%code ]$1[" blocks.]]])) +b4_user_code([m4_indir(b4_macro_name)])])dnl +m4_popdef([b4_macro_name])]) + +# b4_percent_code_ifdef(QUALIFIER, IF-TRUE, [IF-FALSE]) +# ----------------------------------------------------- +# If any %code blocks for QUALIFIER (or unqualified %code blocks if +# QUALIFIER is empty) are defined, expand IF-TRUE, else expand IF-FALSE. +# Also, record Bison's usage of QUALIFIER (if specified) by defining +# b4_percent_code_bison_qualifiers(QUALIFIER). +m4_define([b4_percent_code_ifdef], +[m4_ifdef([b4_percent_code(]$1[)], + [m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])$2], + [$3])]) + + +## ------------------ ## +## Common variables. ## +## ------------------ ## + + +# b4_parse_assert_if([IF-ASSERTIONS-ARE-USED], [IF-NOT]) +# b4_parse_trace_if([IF-DEBUG-TRACES-ARE-ENABLED], [IF-NOT]) +# b4_token_ctor_if([IF-YYLEX-RETURNS-A-TOKEN], [IF-NOT]) +# ---------------------------------------------------------- +b4_percent_define_if_define([api.token.raw]) +b4_percent_define_if_define([token_ctor], [api.token.constructor]) +b4_percent_define_if_define([locations]) # Whether locations are tracked. +b4_percent_define_if_define([parse.assert]) +b4_percent_define_if_define([parse.trace]) +b4_percent_define_if_define([posix]) + + +# b4_bison_locations_if([IF-TRUE]) +# -------------------------------- +# Expand IF-TRUE if using locations, and using the default location +# type. +m4_define([b4_bison_locations_if], +[b4_locations_if([b4_percent_define_ifdef([[api.location.type]], [], [$1])])]) + + + +# %define parse.error "(custom|detailed|simple|verbose)" +# ------------------------------------------------------ +b4_percent_define_default([[parse.error]], [[simple]]) +b4_percent_define_check_values([[[[parse.error]], + [[custom]], [[detailed]], [[simple]], [[verbose]]]]) + +# b4_parse_error_case(CASE1, THEN1, CASE2, THEN2, ..., ELSE) +# ---------------------------------------------------------- +m4_define([b4_parse_error_case], +[m4_case(b4_percent_define_get([[parse.error]]), $@)]) + +# b4_parse_error_bmatch(PATTERN1, THEN1, PATTERN2, THEN2, ..., ELSE) +# ------------------------------------------------------------------ +m4_define([b4_parse_error_bmatch], +[m4_bmatch(b4_percent_define_get([[parse.error]]), $@)]) + + + +# b4_union_if([IF-UNION-ARE-USED], [IF-NOT]) +# b4_variant_if([IF-VARIANT-ARE-USED], [IF-NOT]) +# ---------------------------------------------- +# Depend on whether api.value.type is union, or variant. +m4_define([b4_union_flag], [[0]]) +m4_define([b4_variant_flag], [[0]]) +b4_percent_define_ifdef([[api.value.type]], + [m4_case(b4_percent_define_get_kind([[api.value.type]]), [keyword], + [m4_case(b4_percent_define_get([[api.value.type]]), + [union], [m4_define([b4_union_flag], [[1]])], + [variant], [m4_define([b4_variant_flag], [[1]])])])]) +b4_define_flag_if([union]) +b4_define_flag_if([variant]) + + +## ----------------------------------------------------------- ## +## After processing the skeletons, check that all the user's ## +## %define variables and %code qualifiers were used by Bison. ## +## ----------------------------------------------------------- ## + +m4_define([b4_check_user_names_wrap], +[m4_ifdef([b4_percent_]$1[_user_]$2[s], + [b4_check_user_names([[%]$1 $2], + [b4_percent_]$1[_user_]$2[s], + [[b4_percent_]$1[_bison_]$2[s]])])]) + +m4_wrap_lifo([ +b4_check_user_names_wrap([[define]], [[variable]]) +b4_check_user_names_wrap([[code]], [[qualifier]]) +]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# m4_define_default([b4_lex_param], []) dnl breaks other skeletons +m4_define_default([b4_epilogue], []) +m4_define_default([b4_parse_param], []) + +# The initial column and line. +m4_define_default([b4_location_initial_column], [1]) +m4_define_default([b4_location_initial_line], [1]) + + +## --------------- ## +## Sanity checks. ## +## --------------- ## + +# api.location.type={...} (C, C++ and Java). +b4_percent_define_check_kind([api.location.type], [code], [deprecated]) + +# api.position.type={...} (Java). +b4_percent_define_check_kind([api.position.type], [code], [deprecated]) + +# api.prefix >< %name-prefix. +b4_percent_define_check_kind([api.prefix], [code], [deprecated]) +b4_percent_define_ifdef([api.prefix], +[m4_ifdef([b4_prefix], +[b4_complain_at(b4_percent_define_get_loc([api.prefix]), + [['%s' and '%s' cannot be used together]], + [%name-prefix], + [%define api.prefix])])]) + +# api.token.prefix={...} +# Make it a warning for those who used betas of Bison 3.0. +b4_percent_define_check_kind([api.token.prefix], [code], [deprecated]) + +# api.value.type >< %union. +b4_percent_define_ifdef([api.value.type], +[m4_ifdef([b4_union_members], +[b4_complain_at(b4_percent_define_get_loc([api.value.type]), + [['%s' and '%s' cannot be used together]], + [%union], + [%define api.value.type])])]) + +# api.value.type=union >< %yacc. +b4_percent_define_ifdef([api.value.type], +[m4_if(b4_percent_define_get([api.value.type]), [union], +[b4_yacc_if(dnl +[b4_complain_at(b4_percent_define_get_loc([api.value.type]), + [['%s' and '%s' cannot be used together]], + [%yacc], + [%define api.value.type "union"])])])]) + +# api.value.union.name. +b4_percent_define_check_kind([api.value.union.name], [keyword]) + +# parse.error (custom|detailed) >< token-table. +b4_token_table_if( +[b4_parse_error_bmatch([custom\|detailed], +[b4_complain_at(b4_percent_define_get_loc([parse.error]), + [['%s' and '%s' cannot be used together]], + [%token-table], + [%define parse.error (custom|detailed)])])]) diff --git a/compiler/win_flex_bison/data/skeletons/c++-skel.m4 b/compiler/win_flex_bison/data/skeletons/c++-skel.m4 new file mode 100644 index 0000000..f22002b --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/c++-skel.m4 @@ -0,0 +1,27 @@ + -*- Autoconf -*- + +# C++ skeleton dispatching for Bison. + +# Copyright (C) 2006-2007, 2009-2015, 2018-2021 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_skeletonsdir/[glr.cc]])]) +b4_nondeterministic_if([m4_define([b4_used_skeleton], [b4_skeletonsdir/[glr.cc]])]) + +m4_define_default([b4_used_skeleton], [b4_skeletonsdir/[lalr1.cc]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/compiler/win_flex_bison/data/skeletons/c++.m4 b/compiler/win_flex_bison/data/skeletons/c++.m4 new file mode 100644 index 0000000..2ae8423 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/c++.m4 @@ -0,0 +1,778 @@ + -*- Autoconf -*- + +# C++ skeleton for Bison + +# Copyright (C) 2002-2021 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 . + +# Sanity checks, before defaults installed by c.m4. +b4_percent_define_ifdef([[api.value.union.name]], + [b4_complain_at(b4_percent_define_get_loc([[api.value.union.name]]), + [named %union is invalid in C++])]) + +b4_percent_define_default([[api.symbol.prefix]], [[S_]]) + +m4_include(b4_skeletonsdir/[c.m4]) + +b4_percent_define_check_kind([api.namespace], [code], [deprecated]) +b4_percent_define_check_kind([api.parser.class], [code], [deprecated]) + + +## ----- ## +## C++. ## +## ----- ## + +# b4_comment(TEXT, [PREFIX]) +# -------------------------- +# Put TEXT in comment. Prefix all the output lines with PREFIX. +m4_define([b4_comment], +[_b4_comment([$1], [$2// ], [$2// ])]) + + +# b4_inline(hh|cc) +# ---------------- +# Expand to `inline\n ` if $1 is hh. +m4_define([b4_inline], +[m4_case([$1], + [cc], [], + [hh], [[inline + ]], + [m4_fatal([$0: invalid argument: $1])])]) + + +# b4_cxx_portability +# ------------------ +m4_define([b4_cxx_portability], +[#if defined __cplusplus +# define YY_CPLUSPLUS __cplusplus +#else +# define YY_CPLUSPLUS 199711L +#endif + +// Support move semantics when possible. +#if 201103L <= YY_CPLUSPLUS +# define YY_MOVE std::move +# define YY_MOVE_OR_COPY move +# define YY_MOVE_REF(Type) Type&& +# define YY_RVREF(Type) Type&& +# define YY_COPY(Type) Type +#else +# define YY_MOVE +# define YY_MOVE_OR_COPY copy +# define YY_MOVE_REF(Type) Type& +# define YY_RVREF(Type) const Type& +# define YY_COPY(Type) const Type& +#endif + +// Support noexcept when possible. +#if 201103L <= YY_CPLUSPLUS +# define YY_NOEXCEPT noexcept +# define YY_NOTHROW +#else +# define YY_NOEXCEPT +# define YY_NOTHROW throw () +#endif + +// Support constexpr when possible. +#if 201703 <= YY_CPLUSPLUS +# define YY_CONSTEXPR constexpr +#else +# define YY_CONSTEXPR +#endif[]dnl +]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +b4_percent_define_default([[api.parser.class]], [[parser]]) + +# Don't do that so that we remember whether we're using a user +# request, or the default value. +# +# b4_percent_define_default([[api.location.type]], [[location]]) + +b4_percent_define_default([[api.filename.type]], [[const std::string]]) +# Make it a warning for those who used betas of Bison 3.0. +b4_percent_define_default([[api.namespace]], m4_defn([b4_prefix])) + +b4_percent_define_default([[define_location_comparison]], + [m4_if(b4_percent_define_get([[filename_type]]), + [std::string], [[true]], [[false]])]) + + + +## ----------- ## +## Namespace. ## +## ----------- ## + +m4_define([b4_namespace_ref], [b4_percent_define_get([[api.namespace]])]) + + +# Don't permit an empty b4_namespace_ref. Any '::parser::foo' appended to it +# would compile as an absolute reference with 'parser' in the global namespace. +# b4_namespace_open would open an anonymous namespace and thus establish +# internal linkage. This would compile. However, it's cryptic, and internal +# linkage for the parser would be specified in all translation units that +# include the header, which is always generated. If we ever need to permit +# internal linkage somehow, surely we can find a cleaner approach. +m4_if(m4_bregexp(b4_namespace_ref, [^[ ]*$]), [-1], [], +[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]), + [[namespace reference is empty]])]) + +# Instead of assuming the C++ compiler will do it, Bison should reject any +# invalid b4_namespace_ref that would be converted to a valid +# b4_namespace_open. The problem is that Bison doesn't always output +# b4_namespace_ref to uncommented code but should reserve the ability to do so +# in future releases without risking breaking any existing user grammars. +# Specifically, don't allow empty names as b4_namespace_open would just convert +# those into anonymous namespaces, and that might tempt some users. +m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*::]), [-1], [], +[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]), + [[namespace reference has consecutive "::"]])]) +m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*$]), [-1], [], +[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]), + [[namespace reference has a trailing "::"]])]) + +m4_define([b4_namespace_open], +[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])dnl +[namespace ]m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref), + [^\(.\)[ ]*::], [\1])), + [::], [ { namespace ])[ {]])]) + +m4_define([b4_namespace_close], +[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])dnl +m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref[ ]), + [^\(.\)[ ]*\(::\)?\([^][:]\|:[^:]\)*], + [\1])), + [::\([^][:]\|:[^:]\)*], [} ])[} // ]b4_namespace_ref])]) + + +## ------------- ## +## Token kinds. ## +## ------------- ## + + +# b4_token_enums +# -------------- +# Output the definition of the token kinds. +m4_define([b4_token_enums], +[[enum token_kind_type + { + ]b4_symbol([-2], [id])[ = -2, +]b4_symbol_foreach([b4_token_enum])dnl +[ };]dnl +]) + + + +## -------------- ## +## Symbol kinds. ## +## -------------- ## + +# b4_declare_symbol_enum +# ---------------------- +# The definition of the symbol internal numbers as an enum. +# Defining YYEMPTY here is important: it forces the compiler +# to use a signed type, which matters for yytoken. +m4_define([b4_declare_symbol_enum], +[[enum symbol_kind_type + { + YYNTOKENS = ]b4_tokens_number[, ///< Number of tokens. + ]b4_symbol(empty, kind_base)[ = -2, +]b4_symbol_foreach([ b4_symbol_enum])dnl +[ };]]) + + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + + +# b4_value_type_declare +# --------------------- +# Declare value_type. +m4_define([b4_value_type_declare], +[b4_value_type_setup[]dnl +[ /// Symbol semantic values. +]m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), +[code], +[[ typedef ]b4_percent_define_get([[api.value.type]])[ value_type;]], +[m4_bmatch(b4_percent_define_get([[api.value.type]]), +[union\|union-directive], +[[ union value_type + { +]b4_user_union_members[ + };]])])dnl +]) + + +# b4_public_types_declare +# ----------------------- +# Define the public types: token, semantic value, location, and so forth. +# Depending on %define token_lex, may be output in the header or source file. +m4_define([b4_public_types_declare], +[b4_glr2_cc_if( +[b4_value_type_declare], +[[#ifdef ]b4_api_PREFIX[STYPE +# ifdef __GNUC__ +# pragma GCC message "bison: do not #define ]b4_api_PREFIX[STYPE in C++, use %define api.value.type" +# endif + typedef ]b4_api_PREFIX[STYPE value_type; +#else +]b4_value_type_declare[ +#endif + /// Backward compatibility (Bison 3.8). + typedef value_type semantic_type; +]])[]b4_locations_if([ + /// Symbol locations. + typedef b4_percent_define_get([[api.location.type]], + [[location]]) location_type;])[ + + /// Syntax errors thrown from user actions. + struct syntax_error : std::runtime_error + { + syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m) + : std::runtime_error (m)]b4_locations_if([ + , location (l)])[ + {} + + syntax_error (const syntax_error& s) + : std::runtime_error (s.what ())]b4_locations_if([ + , location (s.location)])[ + {} + + ~syntax_error () YY_NOEXCEPT YY_NOTHROW;]b4_locations_if([ + + location_type location;])[ + }; + + /// Token kinds. + struct token + { + ]b4_token_enums[]b4_glr2_cc_if([], [[ + /// Backward compatibility alias (Bison 3.6). + typedef token_kind_type yytokentype;]])[ + }; + + /// Token kind, as returned by yylex. + typedef token::token_kind_type token_kind_type;]b4_glr2_cc_if([], [[ + + /// Backward compatibility alias (Bison 3.6). + typedef token_kind_type token_type;]])[ + + /// Symbol kinds. + struct symbol_kind + { + ]b4_declare_symbol_enum[ + }; + + /// (Internal) symbol kind. + typedef symbol_kind::symbol_kind_type symbol_kind_type; + + /// The number of tokens. + static const symbol_kind_type YYNTOKENS = symbol_kind::YYNTOKENS; +]]) + + +# b4_symbol_type_define +# --------------------- +# Define symbol_type, the external type for symbols used for symbol +# constructors. +m4_define([b4_symbol_type_define], +[[ /// A complete symbol. + /// + /// Expects its Base type to provide access to the symbol kind + /// via kind (). + /// + /// Provide access to semantic value]b4_locations_if([ and location])[. + template + struct basic_symbol : Base + { + /// Alias to Base. + typedef Base super_type; + + /// Default constructor. + basic_symbol () YY_NOEXCEPT + : value ()]b4_locations_if([ + , location ()])[ + {} + +#if 201103L <= YY_CPLUSPLUS + /// Move constructor. + basic_symbol (basic_symbol&& that) + : Base (std::move (that)) + , value (]b4_variant_if([], [std::move (that.value)]))b4_locations_if([ + , location (std::move (that.location))])[ + {]b4_variant_if([ + b4_symbol_variant([this->kind ()], [value], [move], + [std::move (that.value)]) + ])[} +#endif + + /// Copy constructor. + basic_symbol (const basic_symbol& that);]b4_variant_if([[ + + /// Constructors for typed symbols. +]b4_type_foreach([b4_basic_symbol_constructor_define], [ +])], [[ + /// Constructor for valueless symbols. + basic_symbol (typename Base::kind_type t]b4_locations_if([, + YY_MOVE_REF (location_type) l])[); + + /// Constructor for symbols with semantic value. + basic_symbol (typename Base::kind_type t, + YY_RVREF (value_type) v]b4_locations_if([, + YY_RVREF (location_type) l])[); +]])[ + /// Destroy the symbol. + ~basic_symbol () + { + clear (); + } + +]b4_glr2_cc_if([[ + /// Copy assignment. + basic_symbol& operator= (const basic_symbol& that) + { + Base::operator= (that);]b4_variant_if([[ + ]b4_symbol_variant([this->kind ()], [value], [copy], + [that.value])], [[ + value = that.value]])[;]b4_locations_if([[ + location = that.location;]])[ + return *this; + } + + /// Move assignment. + basic_symbol& operator= (basic_symbol&& that) + { + Base::operator= (std::move (that));]b4_variant_if([[ + ]b4_symbol_variant([this->kind ()], [value], [move], + [std::move (that.value)])], [[ + value = std::move (that.value)]])[;]b4_locations_if([[ + location = std::move (that.location);]])[ + return *this; + } +]])[ + + /// Destroy contents, and record that is empty. + void clear () YY_NOEXCEPT + {]b4_variant_if([[ + // User destructor. + symbol_kind_type yykind = this->kind (); + basic_symbol& yysym = *this; + (void) yysym; + switch (yykind) + { +]b4_symbol_foreach([b4_symbol_destructor])dnl +[ default: + break; + } + + // Value type destructor. +]b4_symbol_variant([[yykind]], [[value]], [[template destroy]])])[ + Base::clear (); + } + +]b4_parse_error_bmatch( +[custom\|detailed], +[[ /// The user-facing name of this symbol. + const char *name () const YY_NOEXCEPT + { + return ]b4_parser_class[::symbol_name (this->kind ()); + }]], +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + /// The user-facing name of this symbol. + const char *name () const YY_NOEXCEPT + { + return ]b4_parser_class[::symbol_name (this->kind ()); + } +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[verbose], +[[ /// The user-facing name of this symbol. + std::string name () const YY_NOEXCEPT + { + return ]b4_parser_class[::symbol_name (this->kind ()); + }]])[]b4_glr2_cc_if([], [[ + + /// Backward compatibility (Bison 3.6). + symbol_kind_type type_get () const YY_NOEXCEPT;]])[ + + /// Whether empty. + bool empty () const YY_NOEXCEPT; + + /// Destructive move, \a s is emptied into this. + void move (basic_symbol& s); + + /// The semantic value. + value_type value;]b4_locations_if([ + + /// The location. + location_type location;])[ + + private: +#if YY_CPLUSPLUS < 201103L + /// Assignment operator. + basic_symbol& operator= (const basic_symbol& that); +#endif + }; + + /// Type access provider for token (enum) based symbols. + struct by_kind + { + /// The symbol kind as needed by the constructor. + typedef token_kind_type kind_type; + + /// Default constructor. + by_kind () YY_NOEXCEPT; + +#if 201103L <= YY_CPLUSPLUS + /// Move constructor. + by_kind (by_kind&& that) YY_NOEXCEPT; +#endif + + /// Copy constructor. + by_kind (const by_kind& that) YY_NOEXCEPT; + + /// Constructor from (external) token numbers. + by_kind (kind_type t) YY_NOEXCEPT; + +]b4_glr2_cc_if([[ + /// Copy assignment. + by_kind& operator= (const by_kind& that); + + /// Move assignment. + by_kind& operator= (by_kind&& that); +]])[ + + /// Record that this symbol is empty. + void clear () YY_NOEXCEPT; + + /// Steal the symbol kind from \a that. + void move (by_kind& that); + + /// The (internal) type number (corresponding to \a type). + /// \a empty when empty. + symbol_kind_type kind () const YY_NOEXCEPT;]b4_glr2_cc_if([], [[ + + /// Backward compatibility (Bison 3.6). + symbol_kind_type type_get () const YY_NOEXCEPT;]])[ + + /// The symbol kind. + /// \a ]b4_symbol_prefix[YYEMPTY when empty. + symbol_kind_type kind_; + };]b4_glr2_cc_if([], [[ + + /// Backward compatibility for a private implementation detail (Bison 3.6). + typedef by_kind by_type;]])[ + + /// "External" symbols: returned by the scanner. + struct symbol_type : basic_symbol + {]b4_variant_if([[ + /// Superclass. + typedef basic_symbol super_type; + + /// Empty symbol. + symbol_type () YY_NOEXCEPT {} + + /// Constructor for valueless symbols, and symbols from each type. +]b4_type_foreach([_b4_symbol_constructor_define])dnl + ])[}; +]]) + + +# b4_public_types_define(hh|cc) +# ----------------------------- +# Provide the implementation needed by the public types. +m4_define([b4_public_types_define], +[[ // basic_symbol. + template + ]b4_parser_class[::basic_symbol::basic_symbol (const basic_symbol& that) + : Base (that) + , value (]b4_variant_if([], [that.value]))b4_locations_if([ + , location (that.location)])[ + {]b4_variant_if([ + b4_symbol_variant([this->kind ()], [value], [copy], + [YY_MOVE (that.value)]) + ])[} + +]b4_variant_if([], [[ + /// Constructor for valueless symbols. + template + ]b4_parser_class[::basic_symbol::basic_symbol (]b4_join( + [typename Base::kind_type t], + b4_locations_if([YY_MOVE_REF (location_type) l]))[) + : Base (t) + , value ()]b4_locations_if([ + , location (l)])[ + {} + + template + ]b4_parser_class[::basic_symbol::basic_symbol (]b4_join( + [typename Base::kind_type t], + [YY_RVREF (value_type) v], + b4_locations_if([YY_RVREF (location_type) l]))[) + : Base (t) + , value (]b4_variant_if([], [YY_MOVE (v)])[)]b4_locations_if([ + , location (YY_MOVE (l))])[ + {]b4_variant_if([[ + (void) v; + ]b4_symbol_variant([this->kind ()], [value], [YY_MOVE_OR_COPY], [YY_MOVE (v)])])[}]])[ + +]b4_glr2_cc_if([], [[ + template + ]b4_parser_class[::symbol_kind_type + ]b4_parser_class[::basic_symbol::type_get () const YY_NOEXCEPT + { + return this->kind (); + } +]])[ + + template + bool + ]b4_parser_class[::basic_symbol::empty () const YY_NOEXCEPT + { + return this->kind () == ]b4_symbol(empty, kind)[; + } + + template + void + ]b4_parser_class[::basic_symbol::move (basic_symbol& s) + { + super_type::move (s); + ]b4_variant_if([b4_symbol_variant([this->kind ()], [value], [move], + [YY_MOVE (s.value)])], + [value = YY_MOVE (s.value);])[]b4_locations_if([ + location = YY_MOVE (s.location);])[ + } + + // by_kind. + ]b4_inline([$1])b4_parser_class[::by_kind::by_kind () YY_NOEXCEPT + : kind_ (]b4_symbol(empty, kind)[) + {} + +#if 201103L <= YY_CPLUSPLUS + ]b4_inline([$1])b4_parser_class[::by_kind::by_kind (by_kind&& that) YY_NOEXCEPT + : kind_ (that.kind_) + { + that.clear (); + } +#endif + + ]b4_inline([$1])b4_parser_class[::by_kind::by_kind (const by_kind& that) YY_NOEXCEPT + : kind_ (that.kind_) + {} + + ]b4_inline([$1])b4_parser_class[::by_kind::by_kind (token_kind_type t) YY_NOEXCEPT + : kind_ (yytranslate_ (t)) + {} + +]b4_glr2_cc_if([[ + ]b4_inline([$1])]b4_parser_class[::by_kind& + b4_parser_class[::by_kind::by_kind::operator= (const by_kind& that) + { + kind_ = that.kind_; + return *this; + } + + ]b4_inline([$1])]b4_parser_class[::by_kind& + b4_parser_class[::by_kind::by_kind::operator= (by_kind&& that) + { + kind_ = that.kind_; + that.clear (); + return *this; + } +]])[ + + ]b4_inline([$1])[void + ]b4_parser_class[::by_kind::clear () YY_NOEXCEPT + { + kind_ = ]b4_symbol(empty, kind)[; + } + + ]b4_inline([$1])[void + ]b4_parser_class[::by_kind::move (by_kind& that) + { + kind_ = that.kind_; + that.clear (); + } + + ]b4_inline([$1])[]b4_parser_class[::symbol_kind_type + ]b4_parser_class[::by_kind::kind () const YY_NOEXCEPT + { + return kind_; + } + +]b4_glr2_cc_if([], [[ + ]b4_inline([$1])[]b4_parser_class[::symbol_kind_type + ]b4_parser_class[::by_kind::type_get () const YY_NOEXCEPT + { + return this->kind (); + } +]])[ +]]) + + +# b4_token_constructor_define +# ---------------------------- +# Define make_FOO for all the token kinds. +# Use at class-level. Redefined in variant.hh. +m4_define([b4_token_constructor_define], []) + + +# b4_yytranslate_define(cc|hh) +# ---------------------------- +# Define yytranslate_. Sometimes used in the header file ($1=hh), +# sometimes in the cc file. +m4_define([b4_yytranslate_define], +[ b4_inline([$1])b4_parser_class[::symbol_kind_type + ]b4_parser_class[::yytranslate_ (int t) YY_NOEXCEPT + { +]b4_api_token_raw_if( +[[ return static_cast (t);]], +[[ // YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to + // TOKEN-NUM as returned by yylex. + static + const ]b4_int_type_for([b4_translate])[ + translate_table[] = + { + ]b4_translate[ + }; + // Last valid token kind. + const int code_max = ]b4_code_max[; + + if (t <= 0) + return symbol_kind::]b4_symbol_prefix[YYEOF; + else if (t <= code_max) + return static_cast (translate_table[t]); + else + return symbol_kind::]b4_symbol_prefix[YYUNDEF;]])[ + } +]]) + + +# b4_lhs_value([TYPE]) +# -------------------- +m4_define([b4_lhs_value], +[b4_symbol_value([yyval], [$1])]) + + +# b4_rhs_value(RULE-LENGTH, POS, [TYPE]) +# -------------------------------------- +# FIXME: Dead code. +m4_define([b4_rhs_value], +[b4_symbol_value([yysemantic_stack_@{($1) - ($2)@}], [$3])]) + + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, POS) +# --------------------------------- +# Expansion of @POS, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[(yylocation_stack_@{($1) - ($2)@})]) + + +# b4_parse_param_decl +# ------------------- +# Extra formal arguments of the constructor. +# Change the parameter names from "foo" into "foo_yyarg", so that +# there is no collision bw the user chosen attribute name, and the +# argument name in the constructor. +m4_define([b4_parse_param_decl], +[m4_ifset([b4_parse_param], + [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])]) + +m4_define([b4_parse_param_decl_1], +[$1_yyarg]) + + + +# b4_parse_param_cons +# ------------------- +# Extra initialisations of the constructor. +m4_define([b4_parse_param_cons], + [m4_ifset([b4_parse_param], + [ + b4_cc_constructor_calls(b4_parse_param)])]) +m4_define([b4_cc_constructor_calls], + [m4_map_sep([b4_cc_constructor_call], [, + ], [$@])]) +m4_define([b4_cc_constructor_call], + [$2 ($2_yyarg)]) + +# b4_parse_param_vars +# ------------------- +# Extra instance variables. +m4_define([b4_parse_param_vars], + [m4_ifset([b4_parse_param], + [ + // User arguments. +b4_cc_var_decls(b4_parse_param)])]) +m4_define([b4_cc_var_decls], + [m4_map_sep([b4_cc_var_decl], [ +], [$@])]) +m4_define([b4_cc_var_decl], + [ $1;]) + + +## ---------## +## Values. ## +## ---------## + +# b4_yylloc_default_define +# ------------------------ +# Define YYLLOC_DEFAULT. +m4_define([b4_yylloc_default_define], +[[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +# ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).begin = YYRHSLOC (Rhs, 1).begin; \ + (Current).end = YYRHSLOC (Rhs, N).end; \ + } \ + else \ + { \ + (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ + } \ + while (false) +# endif +]]) + +## -------- ## +## Checks. ## +## -------- ## + +b4_token_ctor_if([b4_variant_if([], + [b4_fatal_at(b4_percent_define_get_loc(api.token.constructor), + [cannot use '%s' without '%s'], + [%define api.token.constructor], + [%define api.value.type variant]))])]) diff --git a/compiler/win_flex_bison/data/skeletons/c-like.m4 b/compiler/win_flex_bison/data/skeletons/c-like.m4 new file mode 100644 index 0000000..a9bbc2e --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/c-like.m4 @@ -0,0 +1,72 @@ + -*- Autoconf -*- + +# Common code for C-like languages (C, C++, Java, etc.) + +# Copyright (C) 2012-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +# _b4_comment(TEXT, OPEN, CONTINUE, END) +# -------------------------------------- +# Put TEXT in comment. Avoid trailing spaces: don't indent empty lines. +# Avoid adding indentation to the first line, as the indentation comes +# from OPEN. That's why we don't patsubst([$1], [^\(.\)], [ \1]). +# Turn "*/" in TEXT into "* /" so that we don't unexpectedly close +# the comments before its end. +# +# Prefix all the output lines with PREFIX. +m4_define([_b4_comment], +[$2[]b4_gsub(m4_expand([$1]), + [[*]/], [*\\/], + [/[*]], [/\\*], + [ +\(.\)], [ +$3\1])$4]) + + +# b4_comment(TEXT, [PREFIX]) +# -------------------------- +# Put TEXT in comment. Prefix all the output lines with PREFIX. +m4_define([b4_comment], +[_b4_comment([$1], [$2/* ], [$2 ], [ */])]) + + + + +# _b4_dollar_dollar(VALUE, SYMBOL-NUM, FIELD, DEFAULT-FIELD) +# ---------------------------------------------------------- +# If FIELD (or DEFAULT-FIELD) is non-null, return "VALUE.FIELD", +# otherwise just VALUE. Be sure to pass "(VALUE)" if VALUE is a +# pointer. +m4_define([_b4_dollar_dollar], +[b4_symbol_value([$1], + [$2], + m4_if([$3], [[]], + [[$4]], [[$3]]))]) + +# b4_dollar_pushdef(VALUE-POINTER, SYMBOL-NUM, [TYPE_TAG], LOCATION) +# b4_dollar_popdef +# ------------------------------------------------------------------ +# Define b4_dollar_dollar for VALUE-POINTER and DEFAULT-FIELD, +# and b4_at_dollar for LOCATION. +m4_define([b4_dollar_pushdef], +[m4_pushdef([b4_dollar_dollar], + [_b4_dollar_dollar([$1], [$2], m4_dquote($][1), [$3])])dnl +m4_pushdef([b4_at_dollar], [$4])dnl +]) +m4_define([b4_dollar_popdef], +[m4_popdef([b4_at_dollar])dnl +m4_popdef([b4_dollar_dollar])dnl +]) diff --git a/compiler/win_flex_bison/data/skeletons/c-skel.m4 b/compiler/win_flex_bison/data/skeletons/c-skel.m4 new file mode 100644 index 0000000..ac6ddd6 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/c-skel.m4 @@ -0,0 +1,27 @@ + -*- Autoconf -*- + +# C skeleton dispatching for Bison. + +# Copyright (C) 2006-2007, 2009-2015, 2018-2021 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_skeletonsdir/[glr.c]])]) +b4_nondeterministic_if([m4_define([b4_used_skeleton], [b4_skeletonsdir/[glr.c]])]) + +m4_define_default([b4_used_skeleton], [b4_skeletonsdir/[yacc.c]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/compiler/win_flex_bison/data/skeletons/c.m4 b/compiler/win_flex_bison/data/skeletons/c.m4 new file mode 100644 index 0000000..2425b07 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/c.m4 @@ -0,0 +1,1125 @@ + -*- Autoconf -*- + +# C M4 Macros for Bison. + +# Copyright (C) 2002, 2004-2015, 2018-2021 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_skeletonsdir/[c-like.m4]) + +# b4_tocpp(STRING) +# ---------------- +# Convert STRING into a valid C macro name. +m4_define([b4_tocpp], +[m4_toupper(m4_bpatsubst(m4_quote($1), [[^a-zA-Z0-9]+], [_]))]) + + +# b4_cpp_guard(FILE) +# ------------------ +# A valid C macro name to use as a CPP header guard for FILE. +m4_define([b4_cpp_guard], +[[YY_]b4_tocpp(m4_defn([b4_prefix])/[$1])[_INCLUDED]]) + + +# b4_cpp_guard_open(FILE) +# b4_cpp_guard_close(FILE) +# ------------------------ +# If FILE does not expand to nothing, open/close CPP inclusion guards for FILE. +m4_define([b4_cpp_guard_open], +[m4_ifval(m4_quote($1), +[#ifndef b4_cpp_guard([$1]) +# define b4_cpp_guard([$1])])]) + +m4_define([b4_cpp_guard_close], +[m4_ifval(m4_quote($1), +[#endif b4_comment([!b4_cpp_guard([$1])])])]) + + +## ---------------- ## +## Identification. ## +## ---------------- ## + +# b4_identification +# ----------------- +# Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or +# b4_pull_flag if they use the values of the %define variables api.pure or +# api.push-pull. +m4_define([b4_identification], +[[/* Identify Bison output, and Bison version. */ +#define YYBISON ]b4_version[ + +/* Bison version string. */ +#define YYBISON_VERSION "]b4_version_string[" + +/* Skeleton name. */ +#define YYSKELETON_NAME ]b4_skeleton[]m4_ifdef([b4_pure_flag], [[ + +/* Pure parsers. */ +#define YYPURE ]b4_pure_flag])[]m4_ifdef([b4_push_flag], [[ + +/* Push parsers. */ +#define YYPUSH ]b4_push_flag])[]m4_ifdef([b4_pull_flag], [[ + +/* Pull parsers. */ +#define YYPULL ]b4_pull_flag])[ +]]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# b4_api_prefix, b4_api_PREFIX +# ---------------------------- +# Corresponds to %define api.prefix +b4_percent_define_default([[api.prefix]], [[yy]]) +m4_define([b4_api_prefix], +[b4_percent_define_get([[api.prefix]])]) +m4_define([b4_api_PREFIX], +[m4_toupper(b4_api_prefix)]) + + +# b4_prefix +# --------- +# If the %name-prefix is not given, it is api.prefix. +m4_define_default([b4_prefix], [b4_api_prefix]) + +# If the %union is not named, its name is YYSTYPE. +b4_percent_define_default([[api.value.union.name]], + [b4_api_PREFIX[][STYPE]]) + +b4_percent_define_default([[api.symbol.prefix]], [[YYSYMBOL_]]) + +## ------------------------ ## +## Pure/impure interfaces. ## +## ------------------------ ## + +# b4_yylex_formals +# ---------------- +# All the yylex formal arguments. +# b4_lex_param arrives quoted twice, but we want to keep only one level. +m4_define([b4_yylex_formals], +[b4_pure_if([[[b4_api_PREFIX[STYPE *yylvalp]], [[&yylval]]][]dnl +b4_locations_if([, [b4_api_PREFIX[LTYPE *yyllocp], [&yylloc]]])])dnl +m4_ifdef([b4_lex_param], [, ]b4_lex_param)]) + + +# b4_yylex +# -------- +# Call yylex. +m4_define([b4_yylex], +[b4_function_call([yylex], [int], b4_yylex_formals)]) + + +# b4_user_args +# ------------ +m4_define([b4_user_args], +[m4_ifset([b4_parse_param], [, b4_user_args_no_comma])]) + +# b4_user_args_no_comma +# --------------------- +m4_define([b4_user_args_no_comma], +[m4_ifset([b4_parse_param], [b4_args(b4_parse_param)])]) + + +# b4_user_formals +# --------------- +# The possible parse-params formal arguments preceded by a comma. +m4_define([b4_user_formals], +[m4_ifset([b4_parse_param], [, b4_formals(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_use(EXPR) +# ------------ +# Pacify the compiler about some maybe unused value. +m4_define([b4_use], +[YY_USE ($1)]) + +# b4_parse_param_use([VAL], [LOC]) +# -------------------------------- +# 'YY_USE' VAL, LOC if locations are enabled, and all the parse-params. +m4_define([b4_parse_param_use], +[m4_ifvaln([$1], [ b4_use([$1]);])dnl +b4_locations_if([m4_ifvaln([$2], [ b4_use([$2]);])])dnl +b4_parse_param_for([Decl], [Formal], [ b4_use(Formal); +])dnl +]) + + +## ------------ ## +## Data Types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# Return a narrow int type able to handle integers ranging from MIN +# to MAX (included) in portable C code. Assume MIN and MAX fall in +# 'int' range. +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [-127], [127]), [1], [signed char], + b4_ints_in($@, [0], [255]), [1], [unsigned char], + + b4_ints_in($@, [-32767], [32767]), [1], [short], + b4_ints_in($@, [0], [65535]), [1], [unsigned short], + + [int])]) + +# b4_c99_int_type(MIN, MAX) +# ------------------------- +# Like b4_int_type, but for C99. +# b4_c99_int_type_define replaces b4_int_type with this. +m4_define([b4_c99_int_type], +[m4_if(b4_ints_in($@, [-127], [127]), [1], [yytype_int8], + b4_ints_in($@, [0], [255]), [1], [yytype_uint8], + + b4_ints_in($@, [-32767], [32767]), [1], [yytype_int16], + b4_ints_in($@, [0], [65535]), [1], [yytype_uint16], + + [int])]) + +# b4_c99_int_type_define +# ---------------------- +# Define private types suitable for holding small integers in C99 or later. +m4_define([b4_c99_int_type_define], +[m4_copy_force([b4_c99_int_type], [b4_int_type])dnl +[#ifdef short +# undef short +#endif + +/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure + and (if available) are included + so that the code can choose integer types of a good width. */ + +#ifndef __PTRDIFF_MAX__ +# include /* INFRINGES ON USER NAME SPACE */ +# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_STDINT_H +# endif +#endif + +/* Narrow types that promote to a signed type and that can represent a + signed or unsigned integer of at least N bits. In tables they can + save space and decrease cache pressure. Promoting to a signed type + helps avoid bugs in integer arithmetic. */ + +#ifdef __INT_LEAST8_MAX__ +typedef __INT_LEAST8_TYPE__ yytype_int8; +#elif defined YY_STDINT_H +typedef int_least8_t yytype_int8; +#else +typedef signed char yytype_int8; +#endif + +#ifdef __INT_LEAST16_MAX__ +typedef __INT_LEAST16_TYPE__ yytype_int16; +#elif defined YY_STDINT_H +typedef int_least16_t yytype_int16; +#else +typedef short yytype_int16; +#endif + +/* Work around bug in HP-UX 11.23, which defines these macros + incorrectly for preprocessor constants. This workaround can likely + be removed in 2023, as HPE has promised support for HP-UX 11.23 + (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of + . */ +#ifdef __hpux +# undef UINT_LEAST8_MAX +# undef UINT_LEAST16_MAX +# define UINT_LEAST8_MAX 255 +# define UINT_LEAST16_MAX 65535 +#endif + +#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST8_TYPE__ yytype_uint8; +#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST8_MAX <= INT_MAX) +typedef uint_least8_t yytype_uint8; +#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX +typedef unsigned char yytype_uint8; +#else +typedef short yytype_uint8; +#endif + +#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST16_TYPE__ yytype_uint16; +#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST16_MAX <= INT_MAX) +typedef uint_least16_t yytype_uint16; +#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX +typedef unsigned short yytype_uint16; +#else +typedef int yytype_uint16; +#endif]]) + + +# b4_sizes_types_define +# --------------------- +# Define YYPTRDIFF_T/YYPTRDIFF_MAXIMUM, YYSIZE_T/YYSIZE_MAXIMUM, +# and YYSIZEOF. +m4_define([b4_sizes_types_define], +[[#ifndef YYPTRDIFF_T +# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ +# define YYPTRDIFF_T __PTRDIFF_TYPE__ +# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ +# elif defined PTRDIFF_MAX +# ifndef ptrdiff_t +# include /* INFRINGES ON USER NAME SPACE */ +# endif +# define YYPTRDIFF_T ptrdiff_t +# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX +# else +# define YYPTRDIFF_T long +# define YYPTRDIFF_MAXIMUM LONG_MAX +# endif +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned +# endif +#endif + +#define YYSIZE_MAXIMUM \ + YY_CAST (YYPTRDIFF_T, \ + (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ + ? YYPTRDIFF_MAXIMUM \ + : YY_CAST (YYSIZE_T, -1))) + +#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) +]]) + + +# b4_int_type_for(NAME) +# --------------------- +# Return a narrow int type able to handle numbers ranging from +# 'NAME_min' to 'NAME_max' (included). +m4_define([b4_int_type_for], +[b4_int_type($1_min, $1_max)]) + + +# b4_table_value_equals(TABLE, VALUE, LITERAL, SYMBOL) +# ---------------------------------------------------- +# Without inducing a comparison warning from the compiler, check if the +# literal value LITERAL equals VALUE from table TABLE, which must have +# TABLE_min and TABLE_max defined. SYMBOL denotes +m4_define([b4_table_value_equals], +[m4_if(m4_eval($3 < m4_indir([b4_]$1[_min]) + || m4_indir([b4_]$1[_max]) < $3), [1], + [[0]], + [(($2) == $4)])]) + + +## ----------------- ## +## Compiler issues. ## +## ----------------- ## + +# b4_attribute_define([noreturn]) +# ------------------------------- +# Provide portable compiler "attributes". If "noreturn" is passed, define +# _Noreturn. +m4_define([b4_attribute_define], +[[#ifndef YY_ATTRIBUTE_PURE +# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) +# else +# define YY_ATTRIBUTE_PURE +# endif +#endif + +#ifndef YY_ATTRIBUTE_UNUSED +# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +# else +# define YY_ATTRIBUTE_UNUSED +# endif +#endif + +]m4_bmatch([$1], [\bnoreturn\b], [[/* The _Noreturn keyword of C11. */ +]dnl This is close to lib/_Noreturn.h, except that we do enable +dnl the use of [[noreturn]], because _Noreturn is used in places +dnl where [[noreturn]] works in C++. We need this in particular +dnl because of glr.cc which compiles code from glr.c in C++. +dnl And the C++ compiler chokes on _Noreturn. Also, we do not +dnl use C' _Noreturn in C++, to avoid -Wc11-extensions warnings. +[#ifndef _Noreturn +# if (defined __cplusplus \ + && ((201103 <= __cplusplus && !(__GNUC__ == 4 && __GNUC_MINOR__ == 7)) \ + || (defined _MSC_VER && 1900 <= _MSC_VER))) +# define _Noreturn [[noreturn]] +# elif ((!defined __cplusplus || defined __clang__) \ + && (201112 <= (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) \ + || (!defined __STRICT_ANSI__ \ + && (4 < __GNUC__ + (7 <= __GNUC_MINOR__) \ + || (defined __apple_build_version__ \ + ? 6000000 <= __apple_build_version__ \ + : 3 < __clang_major__ + (5 <= __clang_minor__)))))) + /* _Noreturn works as-is. */ +# elif (2 < __GNUC__ + (8 <= __GNUC_MINOR__) || defined __clang__ \ + || 0x5110 <= __SUNPRO_C) +# define _Noreturn __attribute__ ((__noreturn__)) +# elif 1200 <= (defined _MSC_VER ? _MSC_VER : 0) +# define _Noreturn __declspec (noreturn) +# else +# define _Noreturn +# endif +#endif + +]])[/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YY_USE(E) ((void) (E)) +#else +# define YY_USE(E) /* empty */ +#endif + +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ +# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") +# else +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# endif +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_INITIAL_VALUE(Value) Value +#endif +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ +#endif + +#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_USELESS_CAST_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") +# define YY_IGNORE_USELESS_CAST_END \ + _Pragma ("GCC diagnostic pop") +#endif +#ifndef YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_END +#endif +]]) + + +# b4_cast_define +# -------------- +m4_define([b4_cast_define], +[# ifndef YY_CAST +# ifdef __cplusplus +# define YY_CAST(Type, Val) static_cast (Val) +# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) +# else +# define YY_CAST(Type, Val) ((Type) (Val)) +# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) +# endif +# endif[]dnl +]) + + +# b4_null_define +# -------------- +# Portability issues: define a YY_NULLPTR appropriate for the current +# language (C, C++98, or C++11). +# +# In C++ pre C++11 it is standard practice to use 0 (not NULL) for the +# null pointer. In C, prefer ((void*)0) to avoid having to include stdlib.h. +m4_define([b4_null_define], +[# ifndef YY_NULLPTR +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif +# else +# define YY_NULLPTR ((void*)0) +# endif +# endif[]dnl +]) + + +# b4_null +# ------- +# Return a null pointer constant. +m4_define([b4_null], [YY_NULLPTR]) + + + +## ---------## +## Values. ## +## ---------## + +# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) +# ------------------------------------------------------------- +# Define "yy" whose contents is CONTENT. +m4_define([b4_integral_parser_table_define], +[m4_ifvaln([$3], [b4_comment([$3])])dnl +static const b4_int_type_for([$2]) yy$1[[]] = +{ + $2 +};dnl +]) + + +## ------------- ## +## Token kinds. ## +## ------------- ## + +# Because C enums are not scoped, because tokens are exposed in the +# header, and because these tokens are common to all the parsers, we +# need to make sure their names don't collide: use the api.prefix. +# YYEOF is special, since the user may give it a different name. +m4_define([b4_symbol(-2, id)], [b4_api_PREFIX[][EMPTY]]) +m4_define([b4_symbol(-2, tag)], [[No symbol.]]) + +m4_if(b4_symbol(eof, id), [YYEOF], + [m4_define([b4_symbol(0, id)], [b4_api_PREFIX[][EOF]])]) +m4_define([b4_symbol(1, id)], [b4_api_PREFIX[][error]]) +m4_define([b4_symbol(2, id)], [b4_api_PREFIX[][UNDEF]]) + + +# b4_token_define(TOKEN-NUM) +# -------------------------- +# Output the definition of this token as #define. +m4_define([b4_token_define], +[b4_token_format([#define %s %s], [$1])]) + +# b4_token_defines +# ---------------- +# Output the definition of the tokens. +m4_define([b4_token_defines], +[[/* Token kinds. */ +#define ]b4_symbol(empty, [id])[ -2 +]m4_join([ +], b4_symbol_map([b4_token_define])) +]) + + +# b4_token_enum(TOKEN-NUM) +# ------------------------ +# Output the definition of this token as an enum. +m4_define([b4_token_enum], +[b4_token_visible_if([$1], + [m4_format([ %-30s %s], + m4_format([[%s = %s%s%s]], + b4_symbol([$1], [id]), + b4_symbol([$1], b4_api_token_raw_if([[number]], [[code]])), + m4_if([$1], b4_last_enum_token, [], [[,]])), + [b4_symbol_tag_comment([$1])])])]) + + +# b4_token_enums +# -------------- +# The definition of the token kinds. +m4_define([b4_token_enums], +[b4_any_token_visible_if([[/* Token kinds. */ +#ifndef ]b4_api_PREFIX[TOKENTYPE +# define ]b4_api_PREFIX[TOKENTYPE + enum ]b4_api_prefix[tokentype + { + ]b4_symbol(empty, [id])[ = -2, +]b4_symbol_foreach([b4_token_enum])dnl +[ }; + typedef enum ]b4_api_prefix[tokentype ]b4_api_prefix[token_kind_t; +#endif +]])]) + + +# b4_token_enums_defines +# ---------------------- +# 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])]) + + +# b4_symbol_translate(STRING) +# --------------------------- +# Used by "bison" in the array of symbol names to mark those that +# require translation. +m4_define([b4_symbol_translate], +[[N_($1)]]) + + + +## -------------- ## +## Symbol kinds. ## +## -------------- ## + +# b4_symbol_enum(SYMBOL-NUM) +# -------------------------- +# Output the definition of this symbol as an enum. +m4_define([b4_symbol_enum], +[m4_format([ %-40s %s], + m4_format([[%s = %s%s%s]], + b4_symbol([$1], [kind_base]), + [$1], + m4_if([$1], b4_last_symbol, [], [[,]])), + [b4_symbol_tag_comment([$1])])]) + + +# b4_declare_symbol_enum +# ---------------------- +# The definition of the symbol internal numbers as an enum. +# Defining YYEMPTY here is important: it forces the compiler +# to use a signed type, which matters for yytoken. +m4_define([b4_declare_symbol_enum], +[[/* Symbol kind. */ +enum yysymbol_kind_t +{ + ]b4_symbol(empty, [kind_base])[ = -2, +]b4_symbol_foreach([b4_symbol_enum])dnl +[}; +typedef enum yysymbol_kind_t yysymbol_kind_t; +]])]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_symbol_value(VAL, [SYMBOL-NUM], [TYPE-TAG]) +# ---------------------------------------------- +# See README. +m4_define([b4_symbol_value], +[m4_ifval([$3], + [($1.$3)], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [($1.b4_symbol([$2], [type]))], + [$1])], + [$1])])]) + + +## ---------------------- ## +## Defining C functions. ## +## ---------------------- ## + + +# b4_formals([DECL1, NAME1], ...) +# ------------------------------- +# The formal arguments of a C function definition. +m4_define([b4_formals], +[m4_if([$#], [0], [void], + [$#$1], [1], [void], + [m4_map_sep([b4_formal], [, ], [$@])])]) + +m4_define([b4_formal], +[$1]) + + +# b4_function_declare(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ------------------------------------------------------------ +# Declare the function NAME. +m4_define([b4_function_declare], +[$2 $1 (b4_formals(m4_shift2($@)));[]dnl +]) + + + +## --------------------- ## +## Calling C functions. ## +## --------------------- ## + + +# b4_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ----------------------------------------------------------- +# Call the function NAME with arguments NAME1, NAME2 etc. +m4_define([b4_function_call], +[$1 (b4_args(m4_shift2($@)))[]dnl +]) + + +# b4_args([DECL1, NAME1], ...) +# ---------------------------- +# Output the arguments NAME1, NAME2... +m4_define([b4_args], +[m4_map_sep([b4_arg], [, ], [$@])]) + +m4_define([b4_arg], +[$2]) + + +## ----------- ## +## Synclines. ## +## ----------- ## + +# b4_sync_start(LINE, FILE) +# ------------------------- +m4_define([b4_sync_start], [[#]line $1 $2]) + + +## -------------- ## +## User actions. ## +## -------------- ## + +# b4_case(LABEL, STATEMENTS, [COMMENTS]) +# -------------------------------------- +m4_define([b4_case], +[ case $1:m4_ifval([$3], [ b4_comment([$3])]) +$2 +b4_syncline([@oline@], [@ofile@])dnl + break;]) + + +# b4_predicate_case(LABEL, CONDITIONS) +# ------------------------------------ +m4_define([b4_predicate_case], +[ case $1: + if (! ( +$2)) YYERROR; +b4_syncline([@oline@], [@ofile@])dnl + break;]) + + +# b4_yydestruct_define +# -------------------- +# Define the "yydestruct" function. +m4_define_default([b4_yydestruct_define], +[[/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +yydestruct (const char *yymsg, + yysymbol_kind_t yykind, YYSTYPE *yyvaluep]b4_locations_if(dnl +[[, YYLTYPE *yylocationp]])[]b4_user_formals[) +{ +]b4_parse_param_use([yyvaluep], [yylocationp])dnl +[ if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + ]b4_symbol_actions([destructor])[ + YY_IGNORE_MAYBE_UNINITIALIZED_END +}]dnl +]) + + +# b4_yy_symbol_print_define +# ------------------------- +# Define the "yy_symbol_print" function. +m4_define_default([b4_yy_symbol_print_define], +[[ +/*-----------------------------------. +| Print this symbol's value on YYO. | +`-----------------------------------*/ + +static void +yy_symbol_value_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep]b4_locations_if(dnl +[[, YYLTYPE const * const yylocationp]])[]b4_user_formals[) +{ + FILE *yyoutput = yyo; +]b4_parse_param_use([yyoutput], [yylocationp])dnl +[ if (!yyvaluep) + return;] +b4_percent_code_get([[pre-printer]])dnl + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + b4_symbol_actions([printer]) + YY_IGNORE_MAYBE_UNINITIALIZED_END +b4_percent_code_get([[post-printer]])dnl +[} + + +/*---------------------------. +| Print this symbol on YYO. | +`---------------------------*/ + +static void +yy_symbol_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep]b4_locations_if(dnl +[[, YYLTYPE const * const yylocationp]])[]b4_user_formals[) +{ + YYFPRINTF (yyo, "%s %s (", + yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); + +]b4_locations_if([ YYLOCATION_PRINT (yyo, yylocationp); + YYFPRINTF (yyo, ": "); +])dnl +[ yy_symbol_value_print (yyo, yykind, yyvaluep]dnl +b4_locations_if([, yylocationp])[]b4_user_args[); + YYFPRINTF (yyo, ")"); +}]dnl +]) + + +## ---------------- ## +## api.value.type. ## +## ---------------- ## + + +# ---------------------- # +# api.value.type=union. # +# ---------------------- # + +# b4_symbol_type_register(SYMBOL-NUM) +# ----------------------------------- +# Symbol SYMBOL-NUM has a type (for variant) instead of a type-tag. +# Extend the definition of %union's body (b4_union_members) with a +# field of that type, and extend the symbol's "type" field to point to +# the field name, instead of the type name. +m4_define([b4_symbol_type_register], +[m4_define([b4_symbol($1, type_tag)], + [b4_symbol_if([$1], [has_id], + [b4_symbol([$1], [id])], + [yykind_[]b4_symbol([$1], [number])])])dnl +m4_append([b4_union_members], +m4_expand([m4_format([ %-40s %s], + m4_expand([b4_symbol([$1], [type]) b4_symbol([$1], [type_tag]);]), + [b4_symbol_tag_comment([$1])])])) +]) + + +# b4_type_define_tag(SYMBOL1-NUM, ...) +# ------------------------------------ +# For the batch of symbols SYMBOL1-NUM... (which all have the same +# type), enhance the %union definition for each of them, and set +# there "type" field to the field tag name, instead of the type name. +m4_define([b4_type_define_tag], +[b4_symbol_if([$1], [has_type], + [m4_map([b4_symbol_type_register], [$@])]) +]) + + +# b4_symbol_value_union(VAL, SYMBOL-NUM, [TYPE]) +# ---------------------------------------------- +# Same of b4_symbol_value, but when api.value.type=union. +m4_define([b4_symbol_value_union], +[m4_ifval([$3], + [(*($3*)(&$1))], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [($1.b4_symbol([$2], [type_tag]))], + [$1])], + [$1])])]) + + +# b4_value_type_setup_union +# ------------------------- +# Setup support for api.value.type=union. Symbols are defined with a +# type instead of a union member name: build the corresponding union, +# and give the symbols their tag. +m4_define([b4_value_type_setup_union], +[m4_define([b4_union_members]) +b4_type_foreach([b4_type_define_tag]) +m4_copy_force([b4_symbol_value_union], [b4_symbol_value]) +]) + + +# -------------------------- # +# api.value.type = variant. # +# -------------------------- # + +# b4_value_type_setup_variant +# --------------------------- +# Setup support for api.value.type=variant. By default, fail, specialized +# by other skeletons. +m4_define([b4_value_type_setup_variant], +[b4_complain_at(b4_percent_define_get_loc([[api.value.type]]), + [['%s' does not support '%s']], + [b4_skeleton], + [%define api.value.type variant])]) + + +# _b4_value_type_setup_keyword +# ---------------------------- +# api.value.type is defined with a keyword/string syntax. Check if +# that is properly defined, and prepare its use. +m4_define([_b4_value_type_setup_keyword], +[b4_percent_define_check_values([[[[api.value.type]], + [[none]], + [[union]], + [[union-directive]], + [[variant]], + [[yystype]]]])dnl +m4_case(b4_percent_define_get([[api.value.type]]), + [union], [b4_value_type_setup_union], + [variant], [b4_value_type_setup_variant])]) + + +# b4_value_type_setup +# ------------------- +# Check if api.value.type is properly defined, and possibly prepare +# its use. +b4_define_silent([b4_value_type_setup], +[# Define default value. +b4_percent_define_ifdef([[api.value.type]], [], +[# %union => api.value.type=union-directive +m4_ifdef([b4_union_members], +[m4_define([b4_percent_define_kind(api.value.type)], [keyword]) +m4_define([b4_percent_define(api.value.type)], [union-directive])], +[# no tag seen => api.value.type={int} +m4_if(b4_tag_seen_flag, 0, +[m4_define([b4_percent_define_kind(api.value.type)], [code]) +m4_define([b4_percent_define(api.value.type)], [int])], +[# otherwise api.value.type=yystype +m4_define([b4_percent_define_kind(api.value.type)], [keyword]) +m4_define([b4_percent_define(api.value.type)], [yystype])])])]) + +# Set up. +m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), + [keyword\|string], [_b4_value_type_setup_keyword]) +]) + + +## -------------- ## +## Declarations. ## +## -------------- ## + + +# b4_value_type_define +# -------------------- +m4_define([b4_value_type_define], +[b4_value_type_setup[]dnl +/* Value type. */ +m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), +[code], +[[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED +typedef ]b4_percent_define_get([[api.value.type]])[ ]b4_api_PREFIX[STYPE; +# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1 +# define ]b4_api_PREFIX[STYPE_IS_DECLARED 1 +#endif +]], +[m4_bmatch(b4_percent_define_get([[api.value.type]]), +[union\|union-directive], +[[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED +]b4_percent_define_get_syncline([[api.value.union.name]])dnl +[union ]b4_percent_define_get([[api.value.union.name]])[ +{ +]b4_user_union_members[ +}; +]b4_percent_define_get_syncline([[api.value.union.name]])dnl +[typedef union ]b4_percent_define_get([[api.value.union.name]])[ ]b4_api_PREFIX[STYPE; +# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1 +# define ]b4_api_PREFIX[STYPE_IS_DECLARED 1 +#endif +]])])]) + + +# b4_location_type_define +# ----------------------- +m4_define([b4_location_type_define], +[[/* Location type. */ +]b4_percent_define_ifdef([[api.location.type]], +[[typedef ]b4_percent_define_get([[api.location.type]])[ ]b4_api_PREFIX[LTYPE; +]], +[[#if ! defined ]b4_api_PREFIX[LTYPE && ! defined ]b4_api_PREFIX[LTYPE_IS_DECLARED +typedef struct ]b4_api_PREFIX[LTYPE ]b4_api_PREFIX[LTYPE; +struct ]b4_api_PREFIX[LTYPE +{ + int first_line; + int first_column; + int last_line; + int last_column; +}; +# define ]b4_api_PREFIX[LTYPE_IS_DECLARED 1 +# define ]b4_api_PREFIX[LTYPE_IS_TRIVIAL 1 +#endif +]])]) + + +# b4_declare_yylstype +# ------------------- +# Declarations that might either go into the header (if --header) or +# in the parser body. Declare YYSTYPE/YYLTYPE, and yylval/yylloc. +m4_define([b4_declare_yylstype], +[b4_value_type_define[]b4_locations_if([ +b4_location_type_define]) + +b4_pure_if([], [[extern ]b4_api_PREFIX[STYPE ]b4_prefix[lval; +]b4_locations_if([[extern ]b4_api_PREFIX[LTYPE ]b4_prefix[lloc;]])])[]dnl +]) + + +# b4_YYDEBUG_define +# ----------------- +m4_define([b4_YYDEBUG_define], +[[/* Debug traces. */ +]m4_if(b4_api_prefix, [yy], +[[#ifndef YYDEBUG +# define YYDEBUG ]b4_parse_trace_if([1], [0])[ +#endif]], +[[#ifndef ]b4_api_PREFIX[DEBUG +# if defined YYDEBUG +#if YYDEBUG +# define ]b4_api_PREFIX[DEBUG 1 +# else +# define ]b4_api_PREFIX[DEBUG 0 +# endif +# else /* ! defined YYDEBUG */ +# define ]b4_api_PREFIX[DEBUG ]b4_parse_trace_if([1], [0])[ +# endif /* ! defined YYDEBUG */ +#endif /* ! defined ]b4_api_PREFIX[DEBUG */]])[]dnl +]) + +# b4_declare_yydebug +# ------------------ +m4_define([b4_declare_yydebug], +[b4_YYDEBUG_define[ +#if ]b4_api_PREFIX[DEBUG +extern int ]b4_prefix[debug; +#endif][]dnl +]) + +# b4_yylloc_default_define +# ------------------------ +# Define YYLLOC_DEFAULT. +m4_define([b4_yylloc_default_define], +[[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (0) +#endif +]]) + +# b4_yylocation_print_define +# -------------------------- +# Define YYLOCATION_PRINT. +m4_define([b4_yylocation_print_define], +[b4_locations_if([[ +/* YYLOCATION_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 YYLOCATION_PRINT + +# if defined YY_LOCATION_PRINT + + /* Temporary convenience wrapper in case some people defined the + undocumented and private YY_LOCATION_PRINT macros. */ +# define YYLOCATION_PRINT(File, Loc) YY_LOCATION_PRINT(File, *(Loc)) + +# elif defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL + +/* Print *YYLOCP on YYO. Private, do not rely on its existence. */ + +YY_ATTRIBUTE_UNUSED +static int +yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp) +{ + int res = 0; + int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0; + if (0 <= yylocp->first_line) + { + res += YYFPRINTF (yyo, "%d", yylocp->first_line); + if (0 <= yylocp->first_column) + res += YYFPRINTF (yyo, ".%d", yylocp->first_column); + } + if (0 <= yylocp->last_line) + { + if (yylocp->first_line < yylocp->last_line) + { + res += YYFPRINTF (yyo, "-%d", yylocp->last_line); + if (0 <= end_col) + res += YYFPRINTF (yyo, ".%d", end_col); + } + else if (0 <= end_col && yylocp->first_column < end_col) + res += YYFPRINTF (yyo, "-%d", end_col); + } + return res; +} + +# define YYLOCATION_PRINT yy_location_print_ + + /* Temporary convenience wrapper in case some people defined the + undocumented and private YY_LOCATION_PRINT macros. */ +# define YY_LOCATION_PRINT(File, Loc) YYLOCATION_PRINT(File, &(Loc)) + +# else + +# define YYLOCATION_PRINT(File, Loc) ((void) 0) + /* Temporary convenience wrapper in case some people defined the + undocumented and private YY_LOCATION_PRINT macros. */ +# define YY_LOCATION_PRINT YYLOCATION_PRINT + +# endif +# endif /* !defined YYLOCATION_PRINT */]]) +]) + +# b4_yyloc_default +# ---------------- +# Expand to a possible default value for yylloc. +m4_define([b4_yyloc_default], +[[ +# if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL + = { ]m4_join([, ], + m4_defn([b4_location_initial_line]), + m4_defn([b4_location_initial_column]), + m4_defn([b4_location_initial_line]), + m4_defn([b4_location_initial_column]))[ } +# endif +]]) diff --git a/compiler/win_flex_bison/data/skeletons/d-skel.m4 b/compiler/win_flex_bison/data/skeletons/d-skel.m4 new file mode 100644 index 0000000..2a38f02 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/d-skel.m4 @@ -0,0 +1,26 @@ + -*- Autoconf -*- + +# D skeleton dispatching for Bison. + +# Copyright (C) 2018-2021 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 D])]) +b4_nondeterministic_if([b4_complain([%%nondeterministic-parser not supported for D])]) + +m4_define_default([b4_used_skeleton], [b4_skeletonsdir/[lalr1.d]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/compiler/win_flex_bison/data/skeletons/d.m4 b/compiler/win_flex_bison/data/skeletons/d.m4 new file mode 100644 index 0000000..c0632e4 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/d.m4 @@ -0,0 +1,628 @@ + -*- Autoconf -*- + +# D language support for Bison + +# Copyright (C) 2018-2021 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_skeletonsdir/[c-like.m4]) + + +# b4_symbol_action(SYMBOL-NUM, ACTION) +# ------------------------------------ +# Run the action ACTION ("destructor" or "printer") for SYMBOL-NUM. +m4_define([b4_symbol_action], +[b4_symbol_if([$1], [has_$2], +[b4_dollar_pushdef([yyval], + [$1], + [], + [yyloc])dnl + _b4_symbol_case([$1])[]dnl +b4_syncline([b4_symbol([$1], [$2_line])], [b4_symbol([$1], [$2_file])])dnl +b4_symbol([$1], [$2]) +b4_syncline([@oline@], [@ofile@])dnl + break; + +b4_dollar_popdef[]dnl +])]) + + +# b4_use(EXPR) +# ------------ +# Pacify the compiler about some maybe unused value. +m4_define([b4_use], +[]) + + +# b4_sync_start(LINE, FILE) +# ------------------------- +m4_define([b4_sync_start], [[#]line $1 $2]) + + +# 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_percent_define_if_get2(ARG1, ARG2, DEF, NOT) +# ----------------------------------------------- +# Expand to the value of DEF if ARG1 or ARG2 are %define'ed, +# otherwise NOT. +m4_define([b4_percent_define_if_get2], + [m4_ifval(m4_quote(b4_percent_define_get([$1])), + [$3], [m4_ifval(m4_quote(b4_percent_define_get([$2])), + [$3], [$4])])]) + +# b4_percent_define_class_before_interface(CLASS, INTERFACE) +# ---------------------------------------------------------- +# Expand to a ', ' if both a class and an interface have been %define'ed +m4_define([b4_percent_define_class_before_interface], + [m4_ifval(m4_quote(b4_percent_define_get([$1])), + [m4_ifval(m4_quote(b4_percent_define_get([$2])), + [, ])])]) + + +# b4_flag_value(BOOLEAN-FLAG) +# --------------------------- +m4_define([b4_flag_value], [b4_flag_if([$1], [true], [false])]) + + +# b4_parser_class_declaration +# --------------------------- +# The declaration of the parser class ("class YYParser"), with all its +# qualifiers/annotations. +b4_percent_define_default([[api.parser.abstract]], [[false]]) +b4_percent_define_default([[api.parser.final]], [[false]]) +b4_percent_define_default([[api.parser.public]], [[false]]) + +m4_define([b4_parser_class_declaration], +[b4_percent_define_get3([api.parser.annotations], [], [ ])dnl +b4_percent_define_flag_if([api.parser.public], [public ])dnl +b4_percent_define_flag_if([api.parser.abstract], [abstract ])dnl +b4_percent_define_flag_if([api.parser.final], [final ])dnl +[class ]b4_parser_class[]dnl +b4_percent_define_if_get2([api.parser.extends], [api.parser.implements], [ : ])dnl +b4_percent_define_get([api.parser.extends])dnl +b4_percent_define_class_before_interface([api.parser.extends], [api.parser.implements])dnl +b4_percent_define_get([api.parser.implements])]) + + +# b4_lexer_if(TRUE, FALSE) +# ------------------------ +m4_define([b4_lexer_if], +[b4_percent_code_ifdef([[lexer]], [$1], [$2])]) + + +# b4_position_type_if(TRUE, FALSE) +# -------------------------------- +m4_define([b4_position_type_if], +[b4_percent_define_ifdef([[position_type]], [$1], [$2])]) + + +# b4_location_type_if(TRUE, FALSE) +# -------------------------------- +m4_define([b4_location_type_if], +[b4_percent_define_ifdef([[location_type]], [$1], [$2])]) + + +# b4_identification +# ----------------- +m4_define([b4_identification], +[[/** Version number for the Bison executable that generated this parser. */ + public static immutable string yy_bison_version = "]b4_version_string["; + + /** Name of the skeleton that generated this parser. */ + public static immutable string yy_bison_skeleton = ]b4_skeleton[; +]]) + + +## ------------ ## +## Data types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# MIN to MAX (included). +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [-128], [127]), [1], [byte], + b4_ints_in($@, [-32768], [32767]), [1], [short], + [int])]) + +# b4_int_type_for(NAME) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# `NAME_min' to `NAME_max' (included). +m4_define([b4_int_type_for], +[b4_int_type($1_min, $1_max)]) + +# b4_null +# ------- +m4_define([b4_null], [null]) + + +# b4_integral_parser_table_define(NAME, DATA, COMMENT) +#----------------------------------------------------- +# Define "yy" whose contents is CONTENT. +m4_define([b4_integral_parser_table_define], +[m4_ifvaln([$3], [b4_comment([$3], [ ])])dnl +private static immutable b4_int_type_for([$2])[[]] yy$1_ = +@{ + $2 +@};dnl +]) + + +## ------------- ## +## Token kinds. ## +## ------------- ## + +m4_define([b4_symbol(-2, id)], [[YYEMPTY]]) +b4_percent_define_default([[api.token.raw]], [[true]]) + +# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER) +# --------------------------------------- +# Output the definition of this token as an enum. +m4_define([b4_token_enum], +[b4_token_format([ %s = %s, +], [$1])]) + +# b4_token_enums +# -------------- +# Output the definition of the tokens as enums. +m4_define([b4_token_enums], +[/* Token kinds. */ +public enum TokenKind { + ]b4_symbol(empty, id)[ = -2, +b4_symbol_foreach([b4_token_enum])dnl +} +]) + +# b4_symbol_translate(STRING) +# --------------------------- +# Used by "bison" in the array of symbol names to mark those that +# require translation. +m4_define([b4_symbol_translate], +[[_($1)]]) + + +# _b4_token_constructor_define(SYMBOL-NUM) +# ---------------------------------------- +# Define Symbol.FOO for SYMBOL-NUM. +m4_define([_b4_token_constructor_define], +[b4_token_visible_if([$1], +[[ + static auto ]b4_symbol([$1], [id])[(]b4_symbol_if([$1], [has_type], +[b4_union_if([b4_symbol([$1], [type]], +[[typeof(YYSemanticType.]b4_symbol([$1], [type])[]])) [val]])dnl +[]b4_locations_if([b4_symbol_if([$1], [has_type], [[, ]])[Location l]])[) + { + return Symbol(TokenKind.]b4_symbol([$1], [id])[]b4_symbol_if([$1], [has_type], + [[, val]])[]b4_locations_if([[, l]])[); + }]])]) + +# b4_token_constructor_define +# --------------------------- +# Define Symbol.FOO for each token kind FOO. +m4_define([b4_token_constructor_define], +[[ + /* Implementation of token constructors for each symbol type visible to + * the user. The code generates static methods that have the same names + * as the TokenKinds. + */]b4_symbol_foreach([_b4_token_constructor_define])dnl +]) + +## -------------- ## +## Symbol kinds. ## +## -------------- ## + +# b4_symbol_kind(NUM) +# ------------------- +m4_define([b4_symbol_kind], +[SymbolKind.b4_symbol_kind_base($@)]) + + +# b4_symbol_enum(SYMBOL-NUM) +# -------------------------- +# Output the definition of this symbol as an enum. +m4_define([b4_symbol_enum], +[m4_format([ %-30s %s], + m4_format([[%s = %s,]], + b4_symbol([$1], [kind_base]), + [$1]), + [b4_symbol_tag_comment([$1])])]) + + +# b4_declare_symbol_enum +# ---------------------- +# The definition of the symbol internal numbers as an enum. +# Defining YYEMPTY here is important: it forces the compiler +# to use a signed type, which matters for yytoken. +m4_define([b4_declare_symbol_enum], +[[ /* Symbol kinds. */ + struct SymbolKind + { + enum + { + ]b4_symbol(empty, kind_base)[ = -2, /* No symbol. */ +]b4_symbol_foreach([b4_symbol_enum])dnl +[ } + + private int yycode_; + alias yycode_ this; + + this(int code) + { + yycode_ = code; + } + + /* 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. */ + final void toString(W)(W sink) const + if (isOutputRange!(W, char)) + { + immutable string[] yy_sname = @{ + ]b4_symbol_names[ + @};]b4_has_translations_if([[ + /* YYTRANSLATABLE[SYMBOL-NUM] -- Whether YY_SNAME[SYMBOL-NUM] is + internationalizable. */ + immutable ]b4_int_type_for([b4_translatable])[[] yytranslatable = @{ + ]b4_translatable[ + @};]])[ + + put(sink, yy_sname[yycode_]); + } + } +]]) + + +# b4_case(ID, CODE, [COMMENTS]) +# ----------------------------- +m4_define([b4_case], [ case $1:m4_ifval([$3], [ b4_comment([$3])]) +$2 + break;]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +m4_define([b4_yystype], [b4_percent_define_get([[stype]])]) +b4_percent_define_default([[stype]], [[YYSemanticType]])]) + +# %name-prefix +m4_define_default([b4_prefix], [[YY]]) + +b4_percent_define_default([[api.parser.class]], [b4_prefix[]Parser])]) +m4_define([b4_parser_class], [b4_percent_define_get([[api.parser.class]])]) + +#b4_percent_define_default([[location_type]], [Location])]) +m4_define([b4_location_type], b4_percent_define_ifdef([[location_type]],[b4_percent_define_get([[location_type]])],[YYLocation])) + +#b4_percent_define_default([[position_type]], [Position])]) +m4_define([b4_position_type], b4_percent_define_ifdef([[position_type]],[b4_percent_define_get([[position_type]])],[YYPosition])) + + +## ---------------- ## +## api.value.type. ## +## ---------------- ## + + +# ---------------------- # +# api.value.type=union. # +# ---------------------- # + +# b4_symbol_type_register(SYMBOL-NUM) +# ----------------------------------- +# Symbol SYMBOL-NUM has a type (for union) instead of a type-tag. +# Extend the definition of %union's body (b4_union_members) with a +# field of that type, and extend the symbol's "type" field to point to +# the field name, instead of the type name. +m4_define([b4_symbol_type_register], +[m4_define([b4_symbol($1, type_tag)], + [b4_symbol_if([$1], [has_id], + [b4_symbol([$1], [id])], + [yykind_[]b4_symbol([$1], [number])])])dnl +m4_append([b4_union_members], +m4_expand([m4_format([ %-40s %s], + m4_expand([b4_symbol([$1], [type]) b4_symbol([$1], [type_tag]);]), + [b4_symbol_tag_comment([$1])])])) +]) + + +# b4_type_define_tag(SYMBOL1-NUM, ...) +# ------------------------------------ +# For the batch of symbols SYMBOL1-NUM... (which all have the same +# type), enhance the %union definition for each of them, and set +# there "type" field to the field tag name, instead of the type name. +m4_define([b4_type_define_tag], +[b4_symbol_if([$1], [has_type], + [m4_map([b4_symbol_type_register], [$@])]) +]) + + +# b4_symbol_value_union(VAL, SYMBOL-NUM, [TYPE]) +# ---------------------------------------------- +# Same of b4_symbol_value, but when api.value.type=union. +m4_define([b4_symbol_value_union], +[m4_ifval([$3], + [(*($3*)(&$1))], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [($1.b4_symbol([$2], [type_tag]))], + [$1])], + [$1])])]) + + +# b4_value_type_setup_union +# ------------------------- +# Setup support for api.value.type=union. Symbols are defined with a +# type instead of a union member name: build the corresponding union, +# and give the symbols their tag. +m4_define([b4_value_type_setup_union], +[m4_define([b4_union_members]) +b4_type_foreach([b4_type_define_tag]) +m4_copy_force([b4_symbol_value_union], [b4_symbol_value]) +]) + + +# _b4_value_type_setup_keyword +# ---------------------------- +# api.value.type is defined with a keyword/string syntax. Check if +# that is properly defined, and prepare its use. +m4_define([_b4_value_type_setup_keyword], +[b4_percent_define_check_values([[[[api.value.type]], + [[none]], + [[union]], + [[union-directive]], + [[yystype]]]])dnl +m4_case(b4_percent_define_get([[api.value.type]]), + [union], [b4_value_type_setup_union])]) + + +# b4_value_type_setup +# ------------------- +# Check if api.value.type is properly defined, and possibly prepare +# its use. +b4_define_silent([b4_value_type_setup], +[ +# Define default value. +b4_percent_define_ifdef([[api.value.type]], [], +[# %union => api.value.type=union-directive +m4_ifdef([b4_union_members], +[m4_define([b4_percent_define_kind(api.value.type)], [keyword]) +m4_define([b4_percent_define(api.value.type)], [union-directive])], +[# no tag seen => api.value.type={int} +m4_if(b4_tag_seen_flag, 0, +[m4_define([b4_percent_define_kind(api.value.type)], [code]) +m4_define([b4_percent_define(api.value.type)], [int])], +[# otherwise api.value.type=yystype +m4_define([b4_percent_define_kind(api.value.type)], [keyword]) +m4_define([b4_percent_define(api.value.type)], [yystype])])])]) + +# Set up. +m4_bmatch(b4_percent_define_get_kind([[api.value.type]]), + [keyword], [_b4_value_type_setup_keyword]) +]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_symbol_value(VAL, [SYMBOL-NUM], [TYPE-TAG]) +# ---------------------------------------------- +# See README. FIXME: factor in c-like? +m4_define([b4_symbol_value], +[m4_ifval([$3], + [($1.$3)], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [($1.b4_symbol([$2], [type]))], + [$1])], + [$1])])]) + +# b4_lhs_value(SYMBOL-NUM, [TYPE]) +# -------------------------------- +# See README. +m4_define([b4_lhs_value], +[b4_symbol_value([yyval], [$1], [$2])]) + + +# b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE]) +# -------------------------------------------------- +# See README. +# +# In this simple implementation, %token and %type have class names +# between the angle brackets. +m4_define([b4_rhs_value], +[b4_symbol_value([(yystack.valueAt (b4_subtract([$1], [$2])))], [$3], [$4])]) + + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, POS) +# --------------------------------- +# Expansion of @POS, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[yystack.locationAt (b4_subtract($@))]) + + +# 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 $1;]) + + +# b4_public_types_declare +# ----------------------- +# Define the public types: token, semantic value, location, and so forth. +# Depending on %define token_lex, may be output in the header or source file. +m4_define([b4_public_types_declare], +[[ +alias Symbol = ]b4_parser_class[.Symbol; +alias Value = ]b4_yystype[;]b4_locations_if([[ +alias Location = ]b4_location_type[; +alias Position = ]b4_position_type[;]b4_push_if([[ +alias PUSH_MORE = ]b4_parser_class[.YYPUSH_MORE; +alias ABORT = ]b4_parser_class[.YYABORT; +alias ACCEPT = ]b4_parser_class[.YYACCEPT;]])[]])[ +]]) + + +# b4_basic_symbol_constructor_define +# ---------------------------------- +# Create Symbol struct constructors for all the visible types. +m4_define([b4_basic_symbol_constructor_define], +[b4_token_visible_if([$1], +[[ this(TokenKind token]b4_symbol_if([$1], [has_type], +[[, ]b4_union_if([], [[typeof(YYSemanticType.]])b4_symbol([$1], [type])dnl +[]b4_union_if([], [[) ]])[ val]])[]b4_locations_if([[, Location loc]])[) + { + kind = yytranslate_(token);]b4_union_if([b4_symbol_if([$1], [has_type], [[ + static foreach (member; __traits(allMembers, YYSemanticType)) + { + static if (is(typeof(mixin("value_." ~ member)) == ]b4_symbol([$1], [type])[)) + { + mixin("value_." ~ member ~ " = val;"); + } + }]])], [b4_symbol_if([$1], [has_type], [[ + value_.]b4_symbol([$1], [type])[ = val;]])])[]b4_locations_if([ + location_ = loc;])[ + } +]])]) + + +# b4_symbol_type_define +# --------------------- +# Define symbol_type, the external type for symbols used for symbol +# constructors. +m4_define([b4_symbol_type_define], +[[ + /** + * A complete symbol + */ + struct Symbol + { + private SymbolKind kind; + private Value value_;]b4_locations_if([[ + private Location location_;]])[ + +]b4_type_foreach([b4_basic_symbol_constructor_define])[ + SymbolKind token() { return kind; } + Value value() { return value_; }]b4_locations_if([[ + Location location() { return location_; }]])[ +]b4_token_ctor_if([b4_token_constructor_define])[ + } +]]) diff --git a/compiler/win_flex_bison/data/skeletons/glr.c b/compiler/win_flex_bison/data/skeletons/glr.c new file mode 100644 index 0000000..fab3733 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/glr.c @@ -0,0 +1,2763 @@ +# -*- C -*- + +# GLR skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +# If we are loaded by glr.cc, do not override c++.m4 definitions by +# those of c.m4. +m4_if(b4_skeleton, ["glr.c"], + [m4_include(b4_skeletonsdir/[c.m4])]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Stack parameters. +m4_define_default([b4_stack_depth_max], [10000]) +m4_define_default([b4_stack_depth_init], [200]) + +# Included header. +b4_percent_define_default([[api.header.include]], + [["@basename(]b4_spec_header_file[@)"]]) + +## ------------------------ ## +## Pure/impure interfaces. ## +## ------------------------ ## + +b4_define_flag_if([pure]) +# If glr.cc is including this file and thus has already set b4_pure_flag, +# do not change the value of b4_pure_flag, and do not record a use of api.pure. +m4_ifndef([b4_pure_flag], +[b4_percent_define_default([[api.pure]], [[false]]) + m4_define([b4_pure_flag], + [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])]) + +# b4_yyerror_args +# --------------- +# Optional effective arguments passed to yyerror: user args plus yylloc, and +# a trailing comma. +m4_define([b4_yyerror_args], +[b4_pure_if([b4_locations_if([yylocp, ])])dnl +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])]) + + +# b4_lyyerror_args +# ---------------- +# Same as above, but on the lookahead, hence &yylloc instead of yylocp. +m4_define([b4_lyyerror_args], +[b4_pure_if([b4_locations_if([&yylloc, ])])dnl +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])]) + + +# b4_pure_args +# ------------ +# Same as b4_yyerror_args, but with a leading comma. +m4_define([b4_pure_args], +[b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args]) + + +# b4_lpure_args +# ------------- +# Same as above, but on the lookahead, hence &yylloc instead of yylocp. +m4_define([b4_lpure_args], +[b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args]) + + + +# b4_pure_formals +# --------------- +# Arguments passed to yyerror: user formals plus yylocp with leading comma. +m4_define([b4_pure_formals], +[b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals]) + + +# b4_locuser_formals(LOC = yylocp) +# -------------------------------- +# User formal arguments, possibly preceded by location argument. +m4_define([b4_locuser_formals], +[b4_locations_if([, YYLTYPE *m4_default([$1], [yylocp])])[]b4_user_formals]) + + +# b4_locuser_args(LOC = yylocp) +# ----------------------------- +m4_define([b4_locuser_args], +[b4_locations_if([, m4_default([$1], [yylocp])])[]b4_user_args]) + + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_lhs_value(SYMBOL-NUM, [TYPE]) +# -------------------------------- +# See README. +m4_define([b4_lhs_value], +[b4_symbol_value([(*yyvalp)], [$1], [$2])]) + + +# b4_rhs_data(RULE-LENGTH, POS) +# ----------------------------- +# See README. +m4_define([b4_rhs_data], +[YY_CAST (yyGLRStackItem const *, yyvsp)@{YYFILL (b4_subtract([$2], [$1]))@}.yystate]) + + +# b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE]) +# -------------------------------------------------- +# Expansion of $$ or $$, for symbol SYMBOL-NUM. +m4_define([b4_rhs_value], +[b4_symbol_value([b4_rhs_data([$1], [$2]).yysemantics.yyval], [$3], [$4])]) + + + +## ----------- ## +## Locations. ## +## ----------- ## + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(*yylocp)]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[(b4_rhs_data([$1], [$2]).yyloc)]) + + +# b4_call_merger(MERGER-NUM, MERGER-NAME, SYMBOL-SUM) +# --------------------------------------------------- +m4_define([b4_call_merger], +[b4_case([$1], + [ b4_symbol_if([$3], [has_type], + [yy0->b4_symbol($3, slot) = $2 (*yy0, *yy1);], + [*yy0 = $2 (*yy0, *yy1);])])]) + + +## -------------- ## +## Declarations. ## +## -------------- ## + +# b4_shared_declarations +# ---------------------- +# Declaration that might either go into the header (if --header) +# or open coded in the parser body. glr.cc has its own definition. +m4_if(b4_skeleton, ["glr.c"], +[m4_define([b4_shared_declarations], +[b4_declare_yydebug[ +]b4_percent_code_get([[requires]])[ +]b4_token_enums[ +]b4_declare_yylstype[ +int ]b4_prefix[parse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[); +]b4_percent_code_get([[provides]])[]dnl +]) +]) + +## -------------- ## +## Output files. ## +## -------------- ## + +# Unfortunately the order of generation between the header and the +# implementation file matters (for glr.c) because of the current +# implementation of api.value.type=union. In that case we still use a +# union for YYSTYPE, but we generate the contents of this union when +# setting up YYSTYPE. This is needed for other aspects, such as +# defining yy_symbol_value_print, since we need to now the name of the +# members of this union. +# +# To avoid this issue, just generate the header before the +# implementation file. But we should also make them more independent. + +# ----------------- # +# The header file. # +# ----------------- # + +# glr.cc produces its own header. +b4_glr_cc_if([], +[b4_header_if( +[b4_output_begin([b4_spec_header_file]) +b4_copyright([Skeleton interface for Bison GLR parsers in C], + [2002-2015, 2018-2021])[ +]b4_cpp_guard_open([b4_spec_mapped_header_file])[ +]b4_shared_declarations[ +]b4_cpp_guard_close([b4_spec_mapped_header_file])[ +]b4_output_end[ +]])]) + + +# ------------------------- # +# The implementation file. # +# ------------------------- # + +b4_output_begin([b4_parser_file_name]) +b4_copyright([Skeleton implementation for Bison GLR parsers in C], + [2002-2015, 2018-2021])[ +/* C GLR parser skeleton written by Paul Hilfinger. */ + +]b4_disclaimer[ +]b4_identification[ + +]b4_percent_code_get([[top]])[ +]m4_if(b4_api_prefix, [yy], [], +[[/* Substitute the type names. */ +#define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[ +#define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[ +]m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */ +#define ]b4_glr_cc_if([yy_parse_impl], [yyparse])[ ]b4_prefix[]b4_glr_cc_if([_parse_impl], [parse])[ +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yydebug ]b4_prefix[debug]]b4_pure_if([], [[ +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char +#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])]))[ + +]b4_user_pre_prologue[ +]b4_cast_define[ +]b4_null_define[ + +]b4_header_if([[#include ]b4_percent_define_get([[api.header.include]])], + [b4_shared_declarations])[ + +]b4_glr_cc_if([b4_glr_cc_setup], + [b4_declare_symbol_enum])[ + +/* Default (constant) value used for initialization for null + right-hand sides. Unlike the standard yacc.c template, here we set + the default value of $$ to a zeroed-out value. Since the default + value is undefined, this behavior is technically correct. */ +static YYSTYPE yyval_default;]b4_locations_if([[ +static YYLTYPE yyloc_default][]b4_yyloc_default;])[ + +]b4_user_post_prologue[ +]b4_percent_code_get[]dnl + +[#include +#include +#include +#include +#include + +]b4_c99_int_type_define[ +]b4_sizes_types_define[ + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif +]b4_has_translations_if([ +#ifndef N_ +# define N_(Msgid) Msgid +#endif +])[ + +#ifndef YYFREE +# define YYFREE free +#endif +#ifndef YYMALLOC +# define YYMALLOC malloc +#endif +#ifndef YYREALLOC +# define YYREALLOC realloc +#endif + +#ifdef __cplusplus + typedef bool yybool; +# define yytrue true +# define yyfalse false +#else + /* When we move to stdbool, get rid of the various casts to yybool. */ + typedef signed char yybool; +# define yytrue 1 +# define yyfalse 0 +#endif + +#ifndef YYSETJMP +# include +# define YYJMP_BUF jmp_buf +# define YYSETJMP(Env) setjmp (Env) +/* Pacify Clang and ICC. */ +# define YYLONGJMP(Env, Val) \ + do { \ + longjmp (Env, Val); \ + YY_ASSERT (0); \ + } while (yyfalse) +#endif + +]b4_attribute_define([noreturn])[ + +]b4_parse_assert_if([[#ifdef NDEBUG +# define YY_ASSERT(E) ((void) (0 && (E))) +#else +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_ASSERT(E) assert (E) +#endif +]], +[[#define YY_ASSERT(E) ((void) (0 && (E)))]])[ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL ]b4_final_state_number[ +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST ]b4_last[ + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS ]b4_tokens_number[ +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS ]b4_nterms_number[ +/* YYNRULES -- Number of rules. */ +#define YYNRULES ]b4_rules_number[ +/* YYNSTATES -- Number of states. */ +#define YYNSTATES ]b4_states_number[ +/* 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[ + +/* YYMAXUTOK -- Last valid token kind. */ +#define YYMAXUTOK ]b4_code_max[ + +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ +]b4_api_token_raw_if(dnl +[[#define YYTRANSLATE(YYX) YY_CAST (yysymbol_kind_t, YYX)]], +[[#define YYTRANSLATE(YYX) \ + (0 <= (YYX) && (YYX) <= YYMAXUTOK \ + ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ + : ]b4_symbol_prefix[YYUNDEF) + +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM + as returned by yylex. */ +static const ]b4_int_type_for([b4_translate])[ yytranslate[] = +{ + ]b4_translate[ +};]])[ + +#if ]b4_api_PREFIX[DEBUG +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const ]b4_int_type_for([b4_rline])[ yyrline[] = +{ + ]b4_rline[ +}; +#endif + +#define YYPACT_NINF (]b4_pact_ninf[) +#define YYTABLE_NINF (]b4_table_ninf[) + +]b4_parser_tables_define[ + +/* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ +static const ]b4_int_type_for([b4_dprec])[ yydprec[] = +{ + ]b4_dprec[ +}; + +/* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ +static const ]b4_int_type_for([b4_merger])[ yymerger[] = +{ + ]b4_merger[ +}; + +/* YYIMMEDIATE[RULE-NUM] -- True iff rule #RULE-NUM is not to be deferred, as + in the case of predicates. */ +static const yybool yyimmediate[] = +{ + ]b4_immediate[ +}; + +/* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of + list of conflicting reductions corresponding to action entry for + state STATE-NUM in yytable. 0 means no conflicts. The list in + yyconfl is terminated by a rule number of 0. */ +static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = +{ + ]b4_conflict_list_heads[ +}; + +/* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by + 0, pointed into by YYCONFLP. */ +]dnl Do not use b4_int_type_for here, since there are places where +dnl pointers onto yyconfl are taken, whose type is "short*". +dnl We probably ought to introduce a type for confl. +[static const short yyconfl[] = +{ + ]b4_conflicting_rules[ +}; + +]b4_locations_if([[ +]b4_yylloc_default_define[ +# define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) +]])[ + +]b4_pure_if( +[ +#undef yynerrs +#define yynerrs (yystackp->yyerrcnt) +#undef yychar +#define yychar (yystackp->yyrawchar) +#undef yylval +#define yylval (yystackp->yyval) +#undef yylloc +#define yylloc (yystackp->yyloc) +m4_if(b4_prefix[], [yy], [], +[#define b4_prefix[]nerrs yynerrs +#define b4_prefix[]char yychar +#define b4_prefix[]lval yylval +#define b4_prefix[]lloc yylloc])], +[YYSTYPE yylval;]b4_locations_if([[ +YYLTYPE yylloc;]])[ + +int yynerrs; +int yychar;])[ + +enum { YYENOMEM = -2 }; + +typedef enum { yyok, yyaccept, yyabort, yyerr, yynomem } YYRESULTTAG; + +#define YYCHK(YYE) \ + do { \ + YYRESULTTAG yychk_flag = YYE; \ + if (yychk_flag != yyok) \ + return yychk_flag; \ + } while (0) + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH ]b4_stack_depth_init[ +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH ]b4_stack_depth_max[ +#endif + +/* Minimum number of free items on the stack allowed after an + allocation. This is to allow allocation and initialization + to be completed by functions that call yyexpandGLRStack before the + stack is expanded, thus insuring that all necessary pointers get + properly redirected to new data. */ +#define YYHEADROOM 2 + +#ifndef YYSTACKEXPANDABLE +# define YYSTACKEXPANDABLE 1 +#endif + +#if YYSTACKEXPANDABLE +# define YY_RESERVE_GLRSTACK(Yystack) \ + do { \ + if (Yystack->yyspaceLeft < YYHEADROOM) \ + yyexpandGLRStack (Yystack); \ + } while (0) +#else +# define YY_RESERVE_GLRSTACK(Yystack) \ + do { \ + if (Yystack->yyspaceLeft < YYHEADROOM) \ + yyMemoryExhausted (Yystack); \ + } while (0) +#endif + +/** State numbers. */ +typedef int yy_state_t; + +/** Rule numbers. */ +typedef int yyRuleNum; + +/** Item references. */ +typedef short 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, yyval applies, otherwise + * yyfirstVal applies. */ + yybool yyresolved; + /** Number of corresponding LALR(1) machine state. */ + yy_state_t yylrState; + /** Preceding state in this stack */ + yyGLRState* yypred; + /** Source position of the last token produced by my symbol */ + YYPTRDIFF_T yyposn; + union { + /** First in a chain of alternative reductions producing the + * nonterminal corresponding to this state, threaded through + * yynext. */ + yySemanticOption* yyfirstVal; + /** Semantic value for this state. */ + YYSTYPE yyval; + } yysemantics;]b4_locations_if([[ + /** Source location for this state. */ + YYLTYPE yyloc;]])[ +}; + +struct yyGLRStateSet +{ + yyGLRState** yystates; + /** During nondeterministic operation, yylookaheadNeeds tracks which + * stacks have actually needed the current lookahead. During deterministic + * operation, yylookaheadNeeds[0] is not maintained since it would merely + * duplicate yychar != ]b4_symbol(empty, id)[. */ + yybool* yylookaheadNeeds; + YYPTRDIFF_T yysize; + YYPTRDIFF_T yycapacity; +}; + +struct yySemanticOption +{ + /** Type tag: always false. */ + yybool yyisState; + /** Rule number for this reduction */ + yyRuleNum yyrule; + /** The last RHS state in the list of states to be reduced. */ + yyGLRState* yystate; + /** The lookahead for this reduction. */ + int yyrawchar; + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ + /** Next sibling in chain of options. To facilitate merging, + * options are chained in decreasing order by address. */ + yySemanticOption* yynext; +}; + +/** Type of the items in the GLR stack. The yyisState field + * indicates which item of the union is valid. */ +union yyGLRStackItem { + yyGLRState yystate; + yySemanticOption yyoption; +}; + +struct yyGLRStack { + int yyerrState; +]b4_locations_if([[ /* To compute the location of the error token. */ + yyGLRStackItem yyerror_range[3];]])[ +]b4_pure_if( +[ + int yyerrcnt; + int yyrawchar; + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ +])[ + YYJMP_BUF yyexception_buffer; + yyGLRStackItem* yyitems; + yyGLRStackItem* yynextFree; + YYPTRDIFF_T yyspaceLeft; + yyGLRState* yysplitPoint; + yyGLRState* yylastDeleted; + yyGLRStateSet yytops; +}; + +#if YYSTACKEXPANDABLE +static void yyexpandGLRStack (yyGLRStack* yystackp); +#endif + +_Noreturn static void +yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) +{ + if (yymsg != YY_NULLPTR) + yyerror (]b4_yyerror_args[yymsg); + YYLONGJMP (yystackp->yyexception_buffer, 1); +} + +_Noreturn static void +yyMemoryExhausted (yyGLRStack* yystackp) +{ + YYLONGJMP (yystackp->yyexception_buffer, 2); +} + +/** Accessing symbol of state YYSTATE. */ +static inline yysymbol_kind_t +yy_accessing_symbol (yy_state_t yystate) +{ + return YY_CAST (yysymbol_kind_t, yystos[yystate]); +} + +#if ]b4_parse_error_case([simple], [b4_api_PREFIX[DEBUG || ]b4_token_table_flag], [[1]])[ +/* The user-facing name of the symbol whose (internal) number is + YYSYMBOL. No bounds checking. */ +static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; + +]b4_parse_error_bmatch([simple\|verbose], +[[/* 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[ +}; + +static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + return yytname[yysymbol]; +}]], +[[static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + static const char *const yy_sname[] = + { + ]b4_symbol_names[ + };]b4_has_translations_if([[ + /* YYTRANSLATABLE[SYMBOL-NUM] -- Whether YY_SNAME[SYMBOL-NUM] is + internationalizable. */ + static ]b4_int_type_for([b4_translatable])[ yytranslatable[] = + { + ]b4_translatable[ + }; + return (yysymbol < YYNTOKENS && yytranslatable[yysymbol] + ? _(yy_sname[yysymbol]) + : yy_sname[yysymbol]);]], [[ + return yy_sname[yysymbol];]])[ +}]])[ +#endif + +/** Left-hand-side symbol for rule #YYRULE. */ +static inline yysymbol_kind_t +yylhsNonterm (yyRuleNum yyrule) +{ + return YY_CAST (yysymbol_kind_t, yyr1[yyrule]); +} + +#if ]b4_api_PREFIX[DEBUG + +# ifndef YYFPRINTF +# define YYFPRINTF fprintf +# endif + +# define YY_FPRINTF \ + YY_IGNORE_USELESS_CAST_BEGIN YY_FPRINTF_ + +# define YY_FPRINTF_(Args) \ + do { \ + YYFPRINTF Args; \ + YY_IGNORE_USELESS_CAST_END \ + } while (0) + +# define YY_DPRINTF \ + YY_IGNORE_USELESS_CAST_BEGIN YY_DPRINTF_ + +# define YY_DPRINTF_(Args) \ + do { \ + if (yydebug) \ + YYFPRINTF Args; \ + YY_IGNORE_USELESS_CAST_END \ + } while (0) + +]b4_yylocation_print_define[ + +]b4_yy_symbol_print_define[ + +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ + do { \ + if (yydebug) \ + { \ + YY_FPRINTF ((stderr, "%s ", Title)); \ + yy_symbol_print (stderr, Kind, Value]b4_locuser_args([Location])[); \ + YY_FPRINTF ((stderr, "\n")); \ + } \ + } while (0) + +static inline void +yy_reduce_print (yybool yynormal, yyGLRStackItem* yyvsp, YYPTRDIFF_T yyk, + yyRuleNum yyrule]b4_user_formals[); + +# define YY_REDUCE_PRINT(Args) \ + do { \ + if (yydebug) \ + yy_reduce_print Args; \ + } while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; + +static void yypstack (yyGLRStack* yystackp, YYPTRDIFF_T yyk) + YY_ATTRIBUTE_UNUSED; +static void yypdumpstack (yyGLRStack* yystackp) + YY_ATTRIBUTE_UNUSED; + +#else /* !]b4_api_PREFIX[DEBUG */ + +# define YY_DPRINTF(Args) do {} while (yyfalse) +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) +# define YY_REDUCE_PRINT(Args) + +#endif /* !]b4_api_PREFIX[DEBUG */ + +]b4_parse_error_case( + [simple], +[[]], +[[#ifndef yystrlen +# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) +#endif + +]b4_parse_error_bmatch( + [detailed\|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]])[ + +]b4_parse_error_case( + [verbose], +[[#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 YYPTRDIFF_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYPTRDIFF_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; + else + goto append; + + append: + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (yyres) + return yystpcpy (yyres, yystr) - yyres; + else + return yystrlen (yystr); +} +#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) YY_ATTRIBUTE_UNUSED; +static void +yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1) +{ + int i; + yyGLRState *s = yyvsp[yylow0].yystate.yypred; + for (i = yylow0-1; i >= yylow1; i -= 1) + { +#if ]b4_api_PREFIX[DEBUG + yyvsp[i].yystate.yylrState = s->yylrState; +#endif + yyvsp[i].yystate.yyresolved = s->yyresolved; + if (s->yyresolved) + yyvsp[i].yystate.yysemantics.yyval = s->yysemantics.yyval; + else + /* The effect of using yyval or yyloc (in an immediate rule) is + * undefined. */ + yyvsp[i].yystate.yysemantics.yyfirstVal = YY_NULLPTR;]b4_locations_if([[ + yyvsp[i].yystate.yyloc = s->yyloc;]])[ + s = yyvsp[i].yystate.yypred = s->yypred; + } +} + +]m4_define([b4_yygetToken_call], + [[yygetToken (&yychar][]b4_pure_if([, yystackp])[]b4_user_args[)]])[ +/** If yychar is empty, fetch the next token. */ +static inline yysymbol_kind_t +yygetToken (int *yycharp][]b4_pure_if([, yyGLRStack* yystackp])[]b4_user_formals[) +{ + yysymbol_kind_t yytoken; +]b4_parse_param_use()dnl +[ if (*yycharp == ]b4_symbol(empty, id)[) + { + YY_DPRINTF ((stderr, "Reading a token\n"));]b4_glr_cc_if([[ +#if YY_EXCEPTIONS + try + { +#endif // YY_EXCEPTIONS + *yycharp = ]b4_yylex[; +#if YY_EXCEPTIONS + } + catch (const ]b4_namespace_ref[::]b4_parser_class[::syntax_error& yyexc) + { + YY_DPRINTF ((stderr, "Caught exception: %s\n", yyexc.what()));]b4_locations_if([ + yylloc = yyexc.location;])[ + yyerror (]b4_lyyerror_args[yyexc.what ()); + // Map errors caught in the scanner to the undefined token, + // so that error handling is started. However, record this + // with this special value of yychar. + *yycharp = ]b4_symbol(error, id)[; + } +#endif // YY_EXCEPTIONS]], [[ + *yycharp = ]b4_yylex[;]])[ + } + if (*yycharp <= ]b4_symbol(eof, [id])[) + { + *yycharp = ]b4_symbol(eof, [id])[; + yytoken = ]b4_symbol_prefix[YYEOF; + YY_DPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (*yycharp); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + return yytoken; +} + +/* 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) + YY_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, yynomem for YYNOMEM. */ +static YYRESULTTAG +yyuserAction (yyRuleNum yyrule, int yyrhslen, yyGLRStackItem* yyvsp, + yyGLRStack* yystackp, YYPTRDIFF_T yyk, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + const yybool yynormal YY_ATTRIBUTE_UNUSED = yystackp->yysplitPoint == YY_NULLPTR; + int yylow = 1; +]b4_parse_param_use([yyvalp], [yylocp])dnl +[ YY_USE (yyk); + YY_USE (yyrhslen); +# undef yyerrok +# define yyerrok (yystackp->yyerrState = 0) +# undef YYACCEPT +# define YYACCEPT return yyaccept +# undef YYABORT +# define YYABORT return yyabort +# undef YYNOMEM +# define YYNOMEM return yynomem +# undef YYERROR +# define YYERROR return yyerrok, yyerr +# undef YYRECOVERING +# define YYRECOVERING() (yystackp->yyerrState != 0) +# undef yyclearin +# define yyclearin (yychar = ]b4_symbol(empty, id)[) +# 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 + + if (yyrhslen == 0) + *yyvalp = yyval_default; + else + *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yyval;]b4_locations_if([[ + /* Default location. */ + YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); + yystackp->yyerror_range[1].yystate.yyloc = *yylocp;]])[ + /* If yyk == -1, we are running a deferred action on a temporary + stack. In that case, YY_REDUCE_PRINT must not play with YYFILL, + so pretend the stack is "normal". */ + YY_REDUCE_PRINT ((yynormal || yyk == -1, yyvsp, yyk, yyrule]b4_user_args[));]b4_glr_cc_if([[ +#if YY_EXCEPTIONS + typedef ]b4_namespace_ref[::]b4_parser_class[::syntax_error syntax_error; + try + { +#endif // YY_EXCEPTIONS]])[ + switch (yyrule) + { +]b4_user_actions[ + default: break; + }]b4_glr_cc_if([[ +#if YY_EXCEPTIONS + } + catch (const syntax_error& yyexc) + { + YY_DPRINTF ((stderr, "Caught exception: %s\n", yyexc.what()));]b4_locations_if([ + *yylocp = yyexc.location;])[ + yyerror (]b4_yyerror_args[yyexc.what ()); + YYERROR; + } +#endif // YY_EXCEPTIONS]])[ + YY_SYMBOL_PRINT ("-> $$ =", yylhsNonterm (yyrule), yyvalp, yylocp); + + return yyok; +# undef yyerrok +# undef YYABORT +# undef YYACCEPT +# undef YYNOMEM +# undef YYERROR +# undef YYBACKUP +# undef yyclearin +# undef YYRECOVERING +} + + +static void +yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) +{ + YY_USE (yy0); + YY_USE (yy1); + + switch (yyn) + { +]b4_mergers[ + default: break; + } +} + + /* Bison grammar-table manipulation. */ + +]b4_yydestruct_define[ + +/** Number of symbols composing the right hand side of rule #RULE. */ +static inline int +yyrhsLength (yyRuleNum yyrule) +{ + return yyr2[yyrule]; +} + +static void +yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[) +{ + if (yys->yyresolved) + yydestruct (yymsg, yy_accessing_symbol (yys->yylrState), + &yys->yysemantics.yyval]b4_locuser_args([&yys->yyloc])[); + else + { +#if ]b4_api_PREFIX[DEBUG + if (yydebug) + { + if (yys->yysemantics.yyfirstVal) + YY_FPRINTF ((stderr, "%s unresolved", yymsg)); + else + YY_FPRINTF ((stderr, "%s incomplete", yymsg)); + YY_SYMBOL_PRINT ("", yy_accessing_symbol (yys->yylrState), YY_NULLPTR, &yys->yyloc); + } +#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[); + } + } +} + +#define yypact_value_is_default(Yyn) \ + ]b4_table_value_equals([[pact]], [[Yyn]], [b4_pact_ninf], [YYPACT_NINF])[ + +/** True iff LR state YYSTATE has only a default reduction (regardless + * of token). */ +static inline yybool +yyisDefaultedState (yy_state_t yystate) +{ + return yypact_value_is_default (yypact[yystate]); +} + +/** The default reduction for YYSTATE, assuming it has one. */ +static inline yyRuleNum +yydefaultAction (yy_state_t yystate) +{ + return yydefact[yystate]; +} + +#define yytable_value_is_error(Yyn) \ + ]b4_table_value_equals([[table]], [[Yyn]], [b4_table_ninf], [YYTABLE_NINF])[ + +/** The action to take in YYSTATE on seeing YYTOKEN. + * Result R means + * R < 0: Reduce on rule -R. + * R = 0: Error. + * R > 0: Shift to state R. + * Set *YYCONFLICTS to a pointer into yyconfl to a 0-terminated list + * of conflicting reductions. + */ +static inline int +yygetLRActions (yy_state_t yystate, yysymbol_kind_t yytoken, const short** yyconflicts) +{ + int yyindex = yypact[yystate] + yytoken; + if (yytoken == ]b4_symbol(error, kind)[) + { + // This is the error token. + *yyconflicts = yyconfl; + return 0; + } + else if (yyisDefaultedState (yystate) + || yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) + { + *yyconflicts = yyconfl; + return -yydefact[yystate]; + } + else if (! yytable_value_is_error (yytable[yyindex])) + { + *yyconflicts = yyconfl + yyconflp[yyindex]; + return yytable[yyindex]; + } + else + { + *yyconflicts = yyconfl + yyconflp[yyindex]; + return 0; + } +} + +/** Compute post-reduction state. + * \param yystate the current state + * \param yysym the nonterminal to push on the stack + */ +static inline yy_state_t +yyLRgotoState (yy_state_t yystate, yysymbol_kind_t yysym) +{ + int yyr = yypgoto[yysym - YYNTOKENS] + yystate; + if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) + return yytable[yyr]; + else + return yydefgoto[yysym - YYNTOKENS]; +} + +static inline yybool +yyisShiftAction (int yyaction) +{ + return 0 < yyaction; +} + +static inline yybool +yyisErrorAction (int yyaction) +{ + return yyaction == 0; +} + + /* GLRStates */ + +/** Return a fresh GLRStackItem in YYSTACKP. The item is an LR state + * if YYISSTATE, and otherwise a semantic option. Callers should call + * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient + * headroom. */ + +static inline yyGLRStackItem* +yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState) +{ + yyGLRStackItem* yynewItem = yystackp->yynextFree; + yystackp->yyspaceLeft -= 1; + yystackp->yynextFree += 1; + yynewItem->yystate.yyisState = yyisState; + return yynewItem; +} + +/** Add a new semantic action that will execute the action for rule + * YYRULE on the semantic values in YYRHS to the list of + * alternative actions for YYSTATE. Assumes that YYRHS comes from + * stack #YYK of *YYSTACKP. */ +static void +yyaddDeferredAction (yyGLRStack* yystackp, YYPTRDIFF_T yyk, yyGLRState* yystate, + yyGLRState* yyrhs, yyRuleNum yyrule) +{ + yySemanticOption* yynewOption = + &yynewGLRStackItem (yystackp, yyfalse)->yyoption; + YY_ASSERT (!yynewOption->yyisState); + yynewOption->yystate = yyrhs; + yynewOption->yyrule = yyrule; + if (yystackp->yytops.yylookaheadNeeds[yyk]) + { + yynewOption->yyrawchar = yychar; + yynewOption->yyval = yylval;]b4_locations_if([ + yynewOption->yyloc = yylloc;])[ + } + else + yynewOption->yyrawchar = ]b4_symbol(empty, id)[; + yynewOption->yynext = yystate->yysemantics.yyfirstVal; + yystate->yysemantics.yyfirstVal = yynewOption; + + YY_RESERVE_GLRSTACK (yystackp); +} + + /* GLRStacks */ + +/** Initialize YYSET to a singleton set containing an empty stack. */ +static yybool +yyinitStateSet (yyGLRStateSet* yyset) +{ + yyset->yysize = 1; + yyset->yycapacity = 16; + yyset->yystates + = YY_CAST (yyGLRState**, + YYMALLOC (YY_CAST (YYSIZE_T, yyset->yycapacity) + * sizeof yyset->yystates[0])); + if (! yyset->yystates) + return yyfalse; + yyset->yystates[0] = YY_NULLPTR; + yyset->yylookaheadNeeds + = YY_CAST (yybool*, + YYMALLOC (YY_CAST (YYSIZE_T, yyset->yycapacity) + * sizeof yyset->yylookaheadNeeds[0])); + if (! yyset->yylookaheadNeeds) + { + YYFREE (yyset->yystates); + return yyfalse; + } + memset (yyset->yylookaheadNeeds, + 0, + YY_CAST (YYSIZE_T, yyset->yycapacity) * sizeof yyset->yylookaheadNeeds[0]); + return yytrue; +} + +static void yyfreeStateSet (yyGLRStateSet* yyset) +{ + YYFREE (yyset->yystates); + YYFREE (yyset->yylookaheadNeeds); +} + +/** Initialize *YYSTACKP to a single empty stack, with total maximum + * capacity for all stacks of YYSIZE. */ +static yybool +yyinitGLRStack (yyGLRStack* yystackp, YYPTRDIFF_T yysize) +{ + yystackp->yyerrState = 0; + yynerrs = 0; + yystackp->yyspaceLeft = yysize; + yystackp->yyitems + = YY_CAST (yyGLRStackItem*, + YYMALLOC (YY_CAST (YYSIZE_T, yysize) + * sizeof yystackp->yynextFree[0])); + if (!yystackp->yyitems) + return yyfalse; + yystackp->yynextFree = yystackp->yyitems; + yystackp->yysplitPoint = YY_NULLPTR; + yystackp->yylastDeleted = YY_NULLPTR; + return yyinitStateSet (&yystackp->yytops); +} + + +#if YYSTACKEXPANDABLE +# define YYRELOC(YYFROMITEMS, YYTOITEMS, YYX, YYTYPE) \ + &((YYTOITEMS) \ + - ((YYFROMITEMS) - YY_REINTERPRET_CAST (yyGLRStackItem*, (YYX))))->YYTYPE + +/** If *YYSTACKP is expandable, extend it. WARNING: Pointers into the + stack from outside should be considered invalid after this call. + We always expand when there are 1 or fewer items left AFTER an + allocation, so that we can avoid having external pointers exist + across an allocation. */ +static void +yyexpandGLRStack (yyGLRStack* yystackp) +{ + yyGLRStackItem* yynewItems; + yyGLRStackItem* yyp0, *yyp1; + YYPTRDIFF_T yynewSize; + YYPTRDIFF_T yyn; + YYPTRDIFF_T yysize = yystackp->yynextFree - yystackp->yyitems; + if (YYMAXDEPTH - YYHEADROOM < yysize) + yyMemoryExhausted (yystackp); + yynewSize = 2*yysize; + if (YYMAXDEPTH < yynewSize) + yynewSize = YYMAXDEPTH; + yynewItems + = YY_CAST (yyGLRStackItem*, + YYMALLOC (YY_CAST (YYSIZE_T, 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 (*YY_REINTERPRET_CAST (yybool *, yyp0)) + { + yyGLRState* yys0 = &yyp0->yystate; + yyGLRState* yys1 = &yyp1->yystate; + if (yys0->yypred != YY_NULLPTR) + yys1->yypred = + YYRELOC (yyp0, yyp1, yys0->yypred, yystate); + if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != YY_NULLPTR) + yys1->yysemantics.yyfirstVal = + YYRELOC (yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); + } + else + { + yySemanticOption* yyv0 = &yyp0->yyoption; + yySemanticOption* yyv1 = &yyp1->yyoption; + if (yyv0->yystate != YY_NULLPTR) + yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate); + if (yyv0->yynext != YY_NULLPTR) + yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption); + } + } + if (yystackp->yysplitPoint != YY_NULLPTR) + yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems, + yystackp->yysplitPoint, yystate); + + for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1) + if (yystackp->yytops.yystates[yyn] != YY_NULLPTR) + yystackp->yytops.yystates[yyn] = + YYRELOC (yystackp->yyitems, yynewItems, + yystackp->yytops.yystates[yyn], yystate); + YYFREE (yystackp->yyitems); + yystackp->yyitems = yynewItems; + yystackp->yynextFree = yynewItems + yysize; + yystackp->yyspaceLeft = yynewSize - yysize; +} +#endif + +static void +yyfreeGLRStack (yyGLRStack* yystackp) +{ + YYFREE (yystackp->yyitems); + yyfreeStateSet (&yystackp->yytops); +} + +/** Assuming that YYS is a GLRState somewhere on *YYSTACKP, update the + * splitpoint of *YYSTACKP, if needed, so that it is at least as deep as + * YYS. */ +static inline void +yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys) +{ + if (yystackp->yysplitPoint != YY_NULLPTR && yystackp->yysplitPoint > yys) + yystackp->yysplitPoint = yys; +} + +/** Invalidate stack #YYK in *YYSTACKP. */ +static inline void +yymarkStackDeleted (yyGLRStack* yystackp, YYPTRDIFF_T yyk) +{ + if (yystackp->yytops.yystates[yyk] != YY_NULLPTR) + yystackp->yylastDeleted = yystackp->yytops.yystates[yyk]; + yystackp->yytops.yystates[yyk] = YY_NULLPTR; +} + +/** Undelete the last stack in *YYSTACKP that was marked as deleted. Can + only be done once after a deletion, and only when all other stacks have + been deleted. */ +static void +yyundeleteLastStack (yyGLRStack* yystackp) +{ + if (yystackp->yylastDeleted == YY_NULLPTR || yystackp->yytops.yysize != 0) + return; + yystackp->yytops.yystates[0] = yystackp->yylastDeleted; + yystackp->yytops.yysize = 1; + YY_DPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n")); + yystackp->yylastDeleted = YY_NULLPTR; +} + +static inline void +yyremoveDeletes (yyGLRStack* yystackp) +{ + YYPTRDIFF_T yyi, yyj; + yyi = yyj = 0; + while (yyj < yystackp->yytops.yysize) + { + if (yystackp->yytops.yystates[yyi] == YY_NULLPTR) + { + if (yyi == yyj) + YY_DPRINTF ((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) + YY_DPRINTF ((stderr, "Rename stack %ld -> %ld.\n", + YY_CAST (long, yyi), YY_CAST (long, yyj))); + yyj += 1; + } + yyi += 1; + } +} + +/** Shift to a new state on stack #YYK of *YYSTACKP, corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with (resolved) semantic + * value *YYVALP and source location *YYLOCP. */ +static inline void +yyglrShift (yyGLRStack* yystackp, YYPTRDIFF_T yyk, yy_state_t yylrState, + YYPTRDIFF_T yyposn, + YYSTYPE* yyvalp]b4_locations_if([, YYLTYPE* yylocp])[) +{ + yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; + + yynewState->yylrState = yylrState; + yynewState->yyposn = yyposn; + yynewState->yyresolved = yytrue; + yynewState->yypred = yystackp->yytops.yystates[yyk]; + yynewState->yysemantics.yyval = *yyvalp;]b4_locations_if([ + yynewState->yyloc = *yylocp;])[ + yystackp->yytops.yystates[yyk] = yynewState; + + YY_RESERVE_GLRSTACK (yystackp); +} + +/** Shift stack #YYK of *YYSTACKP, to a new state corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with the (unresolved) + * semantic value of YYRHS under the action for YYRULE. */ +static inline void +yyglrShiftDefer (yyGLRStack* yystackp, YYPTRDIFF_T yyk, yy_state_t yylrState, + YYPTRDIFF_T yyposn, yyGLRState* yyrhs, yyRuleNum yyrule) +{ + yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; + YY_ASSERT (yynewState->yyisState); + + yynewState->yylrState = yylrState; + yynewState->yyposn = yyposn; + yynewState->yyresolved = yyfalse; + yynewState->yypred = yystackp->yytops.yystates[yyk]; + yynewState->yysemantics.yyfirstVal = YY_NULLPTR; + yystackp->yytops.yystates[yyk] = yynewState; + + /* Invokes YY_RESERVE_GLRSTACK. */ + yyaddDeferredAction (yystackp, yyk, yynewState, yyrhs, yyrule); +} + +#if ]b4_api_PREFIX[DEBUG + +/*----------------------------------------------------------------------. +| Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. | +`----------------------------------------------------------------------*/ + +static inline void +yy_reduce_print (yybool yynormal, yyGLRStackItem* yyvsp, YYPTRDIFF_T yyk, + yyRuleNum yyrule]b4_user_formals[) +{ + int yynrhs = yyrhsLength (yyrule);]b4_locations_if([ + int yylow = 1;])[ + int yyi; + YY_FPRINTF ((stderr, "Reducing stack %ld by rule %d (line %d):\n", + YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule])); + if (! yynormal) + yyfillin (yyvsp, 1, -yynrhs); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YY_FPRINTF ((stderr, " $%d = ", yyi + 1)); + yy_symbol_print (stderr, + yy_accessing_symbol (yyvsp[yyi - yynrhs + 1].yystate.yylrState), + &yyvsp[yyi - yynrhs + 1].yystate.yysemantics.yyval]b4_locations_if([, + &]b4_rhs_location(yynrhs, yyi + 1))[]dnl + b4_user_args[); + if (!yyvsp[yyi - yynrhs + 1].yystate.yyresolved) + YY_FPRINTF ((stderr, " (unresolved)")); + YY_FPRINTF ((stderr, "\n")); + } +} +#endif + +/** Pop the symbols consumed by reduction #YYRULE from the top of stack + * #YYK of *YYSTACKP, and perform the appropriate semantic action on their + * semantic values. Assumes that all ambiguities in semantic values + * have been previously resolved. Set *YYVALP to the resulting value, + * and *YYLOCP to the computed location (if any). Return value is as + * for userAction. */ +static inline YYRESULTTAG +yydoAction (yyGLRStack* yystackp, YYPTRDIFF_T yyk, yyRuleNum yyrule, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + int yynrhs = yyrhsLength (yyrule); + + if (yystackp->yysplitPoint == YY_NULLPTR) + { + /* Standard special case: single stack. */ + yyGLRStackItem* yyrhs + = YY_REINTERPRET_CAST (yyGLRStackItem*, yystackp->yytops.yystates[yyk]); + YY_ASSERT (yyk == 0); + yystackp->yynextFree -= yynrhs; + yystackp->yyspaceLeft += yynrhs; + yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate; + return yyuserAction (yyrule, yynrhs, yyrhs, yystackp, yyk, + yyvalp]b4_locuser_args[); + } + else + { + yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + yyGLRState* yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred + = yystackp->yytops.yystates[yyk]; + int yyi;]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; + YY_ASSERT (yys); + } + yyupdateSplit (yystackp, yys); + yystackp->yytops.yystates[yyk] = yys; + return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + yystackp, yyk, yyvalp]b4_locuser_args[); + } +} + +/** Pop items off stack #YYK of *YYSTACKP according to grammar rule YYRULE, + * and push back on the resulting nonterminal symbol. Perform the + * semantic action associated with YYRULE and store its value with the + * newly pushed state, if YYFORCEEVAL or if *YYSTACKP is currently + * unambiguous. Otherwise, store the deferred semantic action with + * the new state. If the new state would have an identical input + * position, LR state, and predecessor to an existing state on the stack, + * it is identified with that existing state, eliminating stack #YYK from + * *YYSTACKP. In this case, the semantic value is + * added to the options for the existing state's semantic value. + */ +static inline YYRESULTTAG +yyglrReduce (yyGLRStack* yystackp, YYPTRDIFF_T yyk, yyRuleNum yyrule, + yybool yyforceEval]b4_user_formals[) +{ + YYPTRDIFF_T yyposn = yystackp->yytops.yystates[yyk]->yyposn; + + if (yyforceEval || yystackp->yysplitPoint == YY_NULLPTR) + { + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ + + YYRESULTTAG yyflag = yydoAction (yystackp, yyk, yyrule, &yyval]b4_locuser_args([&yyloc])[); + if (yyflag == yyerr && yystackp->yysplitPoint != YY_NULLPTR) + YY_DPRINTF ((stderr, + "Parse on stack %ld rejected by rule %d (line %d).\n", + YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule])); + if (yyflag != yyok) + return yyflag; + yyglrShift (yystackp, yyk, + yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, + yylhsNonterm (yyrule)), + yyposn, &yyval]b4_locations_if([, &yyloc])[); + } + else + { + YYPTRDIFF_T yyi; + int yyn; + yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk]; + yy_state_t yynewLRState; + + for (yys = yystackp->yytops.yystates[yyk], yyn = yyrhsLength (yyrule); + 0 < yyn; yyn -= 1) + { + yys = yys->yypred; + YY_ASSERT (yys); + } + yyupdateSplit (yystackp, yys); + yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule)); + YY_DPRINTF ((stderr, + "Reduced stack %ld by rule %d (line %d); action deferred. " + "Now in state %d.\n", + YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule], + yynewLRState)); + for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) + if (yyi != yyk && yystackp->yytops.yystates[yyi] != YY_NULLPTR) + { + yyGLRState *yysplit = yystackp->yysplitPoint; + yyGLRState *yyp = yystackp->yytops.yystates[yyi]; + while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn) + { + if (yyp->yylrState == yynewLRState && yyp->yypred == yys) + { + yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule); + yymarkStackDeleted (yystackp, yyk); + YY_DPRINTF ((stderr, "Merging stack %ld into stack %ld.\n", + YY_CAST (long, yyk), YY_CAST (long, yyi))); + return yyok; + } + yyp = yyp->yypred; + } + } + yystackp->yytops.yystates[yyk] = yys; + yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule); + } + return yyok; +} + +static YYPTRDIFF_T +yysplitStack (yyGLRStack* yystackp, YYPTRDIFF_T yyk) +{ + if (yystackp->yysplitPoint == YY_NULLPTR) + { + YY_ASSERT (yyk == 0); + yystackp->yysplitPoint = yystackp->yytops.yystates[yyk]; + } + if (yystackp->yytops.yycapacity <= yystackp->yytops.yysize) + { + YYPTRDIFF_T state_size = YYSIZEOF (yystackp->yytops.yystates[0]); + YYPTRDIFF_T half_max_capacity = YYSIZE_MAXIMUM / 2 / state_size; + if (half_max_capacity < yystackp->yytops.yycapacity) + yyMemoryExhausted (yystackp); + yystackp->yytops.yycapacity *= 2; + + { + yyGLRState** yynewStates + = YY_CAST (yyGLRState**, + YYREALLOC (yystackp->yytops.yystates, + (YY_CAST (YYSIZE_T, yystackp->yytops.yycapacity) + * sizeof yynewStates[0]))); + if (yynewStates == YY_NULLPTR) + yyMemoryExhausted (yystackp); + yystackp->yytops.yystates = yynewStates; + } + + { + yybool* yynewLookaheadNeeds + = YY_CAST (yybool*, + YYREALLOC (yystackp->yytops.yylookaheadNeeds, + (YY_CAST (YYSIZE_T, yystackp->yytops.yycapacity) + * sizeof yynewLookaheadNeeds[0]))); + if (yynewLookaheadNeeds == YY_NULLPTR) + yyMemoryExhausted (yystackp); + yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds; + } + } + yystackp->yytops.yystates[yystackp->yytops.yysize] + = yystackp->yytops.yystates[yyk]; + yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize] + = yystackp->yytops.yylookaheadNeeds[yyk]; + yystackp->yytops.yysize += 1; + return yystackp->yytops.yysize - 1; +} + +/** True iff YYY0 and YYY1 represent identical options at the top level. + * That is, they represent the same rule applied to RHS symbols + * that produce the same terminal symbols. */ +static yybool +yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1) +{ + if (yyy0->yyrule == yyy1->yyrule) + { + yyGLRState *yys0, *yys1; + int yyn; + for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, + yyn = yyrhsLength (yyy0->yyrule); + yyn > 0; + yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) + if (yys0->yyposn != yys1->yyposn) + return yyfalse; + return yytrue; + } + else + return yyfalse; +} + +/** Assuming identicalOptions (YYY0,YYY1), destructively merge the + * alternative semantic values for the RHS-symbols of YYY1 and YYY0. */ +static void +yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1) +{ + yyGLRState *yys0, *yys1; + int yyn; + for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, + yyn = yyrhsLength (yyy0->yyrule); + 0 < yyn; + yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) + { + if (yys0 == yys1) + break; + else if (yys0->yyresolved) + { + yys1->yyresolved = yytrue; + yys1->yysemantics.yyval = yys0->yysemantics.yyval; + } + else if (yys1->yyresolved) + { + yys0->yyresolved = yytrue; + yys0->yysemantics.yyval = yys1->yysemantics.yyval; + } + else + { + yySemanticOption** yyz0p = &yys0->yysemantics.yyfirstVal; + yySemanticOption* yyz1 = yys1->yysemantics.yyfirstVal; + while (yytrue) + { + if (yyz1 == *yyz0p || yyz1 == YY_NULLPTR) + break; + else if (*yyz0p == YY_NULLPTR) + { + *yyz0p = yyz1; + break; + } + else if (*yyz0p < yyz1) + { + yySemanticOption* yyz = *yyz0p; + *yyz0p = yyz1; + yyz1 = yyz1->yynext; + (*yyz0p)->yynext = yyz; + } + yyz0p = &(*yyz0p)->yynext; + } + yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal; + } + } +} + +/** Y0 and Y1 represent two possible actions to take in a given + * parsing state; return 0 if no combination is possible, + * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */ +static int +yypreference (yySemanticOption* y0, yySemanticOption* y1) +{ + yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule; + int p0 = yydprec[r0], p1 = yydprec[r1]; + + if (p0 == p1) + { + if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1]) + return 0; + else + return 1; + } + if (p0 == 0 || p1 == 0) + return 0; + if (p0 < p1) + return 3; + if (p1 < p0) + return 2; + return 0; +} + +static YYRESULTTAG +yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[); + + +/** Resolve the previous YYN states starting at and including state YYS + * on *YYSTACKP. If result != yyok, some states may have been left + * unresolved possibly with empty semantic option chains. Regardless + * of whether result = yyok, each state has been left with consistent + * data so that yydestroyGLRState can be invoked if necessary. */ +static YYRESULTTAG +yyresolveStates (yyGLRState* yys, int yyn, + yyGLRStack* yystackp]b4_user_formals[) +{ + if (0 < yyn) + { + YY_ASSERT (yys->yypred); + YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[)); + if (! yys->yyresolved) + YYCHK (yyresolveValue (yys, yystackp]b4_user_args[)); + } + return yyok; +} + +/** Resolve the states for the RHS of YYOPT on *YYSTACKP, perform its + * user action, and return the semantic value and location in *YYVALP + * and *YYLOCP. Regardless of whether result = yyok, all RHS states + * have been destroyed (assuming the user action destroys all RHS + * semantic values if invoked). */ +static YYRESULTTAG +yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + int yynrhs = yyrhsLength (yyopt->yyrule); + YYRESULTTAG yyflag = + yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[); + if (yyflag != yyok) + { + yyGLRState *yys; + for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1) + yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); + return yyflag; + } + + yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[ + if (yynrhs == 0) + /* Set default location. */ + yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[ + { + int yychar_current = yychar; + YYSTYPE yylval_current = yylval;]b4_locations_if([ + YYLTYPE yylloc_current = yylloc;])[ + yychar = yyopt->yyrawchar; + yylval = yyopt->yyval;]b4_locations_if([ + yylloc = yyopt->yyloc;])[ + yyflag = yyuserAction (yyopt->yyrule, yynrhs, + yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + yystackp, -1, yyvalp]b4_locuser_args[); + yychar = yychar_current; + yylval = yylval_current;]b4_locations_if([ + yylloc = yylloc_current;])[ + } + return yyflag; +} + +#if ]b4_api_PREFIX[DEBUG +static void +yyreportTree (yySemanticOption* yyx, int yyindent) +{ + int yynrhs = yyrhsLength (yyx->yyrule); + int yyi; + yyGLRState* yys; + yyGLRState* yystates[1 + YYMAXRHS]; + yyGLRState yyleftmost_state; + + for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred) + yystates[yyi] = yys; + if (yys == YY_NULLPTR) + { + yyleftmost_state.yyposn = 0; + yystates[0] = &yyleftmost_state; + } + else + yystates[0] = yys; + + if (yyx->yystate->yyposn < yys->yyposn + 1) + YY_FPRINTF ((stderr, "%*s%s -> \n", + yyindent, "", yysymbol_name (yylhsNonterm (yyx->yyrule)), + yyx->yyrule - 1)); + else + YY_FPRINTF ((stderr, "%*s%s -> \n", + yyindent, "", yysymbol_name (yylhsNonterm (yyx->yyrule)), + yyx->yyrule - 1, YY_CAST (long, yys->yyposn + 1), + YY_CAST (long, yyx->yystate->yyposn))); + for (yyi = 1; yyi <= yynrhs; yyi += 1) + { + if (yystates[yyi]->yyresolved) + { + if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) + YY_FPRINTF ((stderr, "%*s%s \n", yyindent+2, "", + yysymbol_name (yy_accessing_symbol (yystates[yyi]->yylrState)))); + else + YY_FPRINTF ((stderr, "%*s%s \n", yyindent+2, "", + yysymbol_name (yy_accessing_symbol (yystates[yyi]->yylrState)), + YY_CAST (long, yystates[yyi-1]->yyposn + 1), + YY_CAST (long, yystates[yyi]->yyposn))); + } + else + yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2); + } +} +#endif + +static YYRESULTTAG +yyreportAmbiguity (yySemanticOption* yyx0, + yySemanticOption* yyx1]b4_pure_formals[) +{ + YY_USE (yyx0); + YY_USE (yyx1); + +#if ]b4_api_PREFIX[DEBUG + YY_FPRINTF ((stderr, "Ambiguity detected.\n")); + YY_FPRINTF ((stderr, "Option 1,\n")); + yyreportTree (yyx0, 2); + YY_FPRINTF ((stderr, "\nOption 2,\n")); + yyreportTree (yyx1, 2); + YY_FPRINTF ((stderr, "\n")); +#endif + + yyerror (]b4_yyerror_args[YY_("syntax is ambiguous")); + return yyabort; +}]b4_locations_if([[ + +/** Resolve the locations for each of the YYN1 states in *YYSTACKP, + * ending at YYS1. Has no effect on previously resolved states. + * The first semantic option of a state is always chosen. */ +static void +yyresolveLocations (yyGLRState *yys1, int yyn1, + yyGLRStack *yystackp]b4_user_formals[) +{ + if (0 < yyn1) + { + yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[); + if (!yys1->yyresolved) + { + yyGLRStackItem yyrhsloc[1 + YYMAXRHS]; + int yynrhs; + yySemanticOption *yyoption = yys1->yysemantics.yyfirstVal; + YY_ASSERT (yyoption); + yynrhs = yyrhsLength (yyoption->yyrule); + if (0 < yynrhs) + { + 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; + } + YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs); + } + } +}]])[ + +/** Resolve the ambiguity represented in state YYS in *YYSTACKP, + * perform the indicated actions, and set the semantic value of YYS. + * If result != yyok, the chain of semantic options in YYS has been + * cleared instead or it has been left unmodified except that + * redundant options may have been removed. Regardless of whether + * result = yyok, YYS has been left with consistent data so that + * yydestroyGLRState can be invoked if necessary. */ +static YYRESULTTAG +yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[) +{ + yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal; + yySemanticOption* yybest = yyoptionList; + yySemanticOption** yypp; + yybool yymerge = yyfalse; + YYSTYPE yyval; + YYRESULTTAG yyflag;]b4_locations_if([ + YYLTYPE *yylocp = &yys->yyloc;])[ + + for (yypp = &yyoptionList->yynext; *yypp != YY_NULLPTR; ) + { + yySemanticOption* yyp = *yypp; + + if (yyidenticalOptions (yybest, yyp)) + { + yymergeOptionSets (yybest, yyp); + *yypp = yyp->yynext; + } + else + { + switch (yypreference (yybest, yyp)) + { + case 0:]b4_locations_if([[ + yyresolveLocations (yys, 1, yystackp]b4_user_args[);]])[ + return yyreportAmbiguity (yybest, yyp]b4_pure_args[); + break; + case 1: + yymerge = yytrue; + break; + case 2: + break; + case 3: + yybest = yyp; + yymerge = yyfalse; + break; + default: + /* This cannot happen so it is not worth a YY_ASSERT (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, &yyval]b4_locuser_args[); + if (yyflag == yyok) + for (yyp = yybest->yynext; yyp != YY_NULLPTR; yyp = yyp->yynext) + { + if (yyprec == yydprec[yyp->yyrule]) + { + YYSTYPE yyval_other;]b4_locations_if([ + YYLTYPE yydummy;])[ + yyflag = yyresolveAction (yyp, yystackp, &yyval_other]b4_locuser_args([&yydummy])[); + if (yyflag != yyok) + { + yydestruct ("Cleanup: discarding incompletely merged value for", + yy_accessing_symbol (yys->yylrState), + &yyval]b4_locuser_args[); + break; + } + yyuserMerge (yymerger[yyp->yyrule], &yyval, &yyval_other); + } + } + } + else + yyflag = yyresolveAction (yybest, yystackp, &yyval]b4_locuser_args([yylocp])[); + + if (yyflag == yyok) + { + yys->yyresolved = yytrue; + yys->yysemantics.yyval = yyval; + } + else + yys->yysemantics.yyfirstVal = YY_NULLPTR; + return yyflag; +} + +static YYRESULTTAG +yyresolveStack (yyGLRStack* yystackp]b4_user_formals[) +{ + if (yystackp->yysplitPoint != YY_NULLPTR) + { + 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; +} + +/** Called when returning to deterministic operation to clean up the extra + * stacks. */ +static void +yycompressStack (yyGLRStack* yystackp) +{ + /* yyr is the state after the split point. */ + yyGLRState *yyr; + + if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == YY_NULLPTR) + return; + + { + yyGLRState *yyp, *yyq; + for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = YY_NULLPTR; + yyp != yystackp->yysplitPoint; + yyr = yyp, yyp = yyq, yyq = yyp->yypred) + yyp->yypred = yyr; + } + + yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems; + yystackp->yynextFree = YY_REINTERPRET_CAST (yyGLRStackItem*, yystackp->yysplitPoint) + 1; + yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems; + yystackp->yysplitPoint = YY_NULLPTR; + yystackp->yylastDeleted = YY_NULLPTR; + + while (yyr != YY_NULLPTR) + { + 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, YYPTRDIFF_T yyk, + YYPTRDIFF_T yyposn]b4_pure_formals[) +{ + while (yystackp->yytops.yystates[yyk] != YY_NULLPTR) + { + yy_state_t yystate = yystackp->yytops.yystates[yyk]->yylrState; + YY_DPRINTF ((stderr, "Stack %ld Entering state %d\n", + YY_CAST (long, yyk), yystate)); + + YY_ASSERT (yystate != YYFINAL); + + if (yyisDefaultedState (yystate)) + { + YYRESULTTAG yyflag; + yyRuleNum yyrule = yydefaultAction (yystate); + if (yyrule == 0) + { + YY_DPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yyk))); + yymarkStackDeleted (yystackp, yyk); + return yyok; + } + yyflag = yyglrReduce (yystackp, yyk, yyrule, yyimmediate[yyrule]]b4_user_args[); + if (yyflag == yyerr) + { + YY_DPRINTF ((stderr, + "Stack %ld dies " + "(predicate failure or explicit user error).\n", + YY_CAST (long, yyk))); + yymarkStackDeleted (yystackp, yyk); + return yyok; + } + if (yyflag != yyok) + return yyflag; + } + else + { + yysymbol_kind_t yytoken = ]b4_yygetToken_call[; + const short* yyconflicts; + const int yyaction = yygetLRActions (yystate, yytoken, &yyconflicts); + yystackp->yytops.yylookaheadNeeds[yyk] = yytrue; + + for (/* nothing */; *yyconflicts; yyconflicts += 1) + { + YYRESULTTAG yyflag; + YYPTRDIFF_T yynewStack = yysplitStack (yystackp, yyk); + YY_DPRINTF ((stderr, "Splitting off stack %ld from %ld.\n", + YY_CAST (long, yynewStack), YY_CAST (long, yyk))); + yyflag = yyglrReduce (yystackp, yynewStack, + *yyconflicts, + yyimmediate[*yyconflicts]]b4_user_args[); + if (yyflag == yyok) + YYCHK (yyprocessOneStack (yystackp, yynewStack, + yyposn]b4_pure_args[)); + else if (yyflag == yyerr) + { + YY_DPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yynewStack))); + yymarkStackDeleted (yystackp, yynewStack); + } + else + return yyflag; + } + + if (yyisShiftAction (yyaction)) + break; + else if (yyisErrorAction (yyaction)) + { + YY_DPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yyk))); + yymarkStackDeleted (yystackp, yyk); + break; + } + else + { + YYRESULTTAG yyflag = yyglrReduce (yystackp, yyk, -yyaction, + yyimmediate[-yyaction]]b4_user_args[); + if (yyflag == yyerr) + { + YY_DPRINTF ((stderr, + "Stack %ld dies " + "(predicate failure or explicit user error).\n", + YY_CAST (long, yyk))); + yymarkStackDeleted (yystackp, yyk); + break; + } + else if (yyflag != yyok) + return yyflag; + } + } + } + return yyok; +} + +]b4_parse_error_case([simple], [], +[[/* Put in YYARG at most YYARGN of the expected tokens given the + current YYSTACKP, and return the number of tokens stored in YYARG. If + YYARG is null, return the number of expected tokens (guaranteed to + be less than YYNTOKENS). */ +static int +yypcontext_expected_tokens (const yyGLRStack* yystackp, + yysymbol_kind_t yyarg[], int yyargn) +{ + /* Actual size of YYARG. */ + int yycount = 0; + int yyn = yypact[yystackp->yytops.yystates[0]->yylrState]; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != ]b4_symbol(error, kind)[ + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); + } + } + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = ]b4_symbol(empty, kind)[; + return yycount; +}]])[ + +]b4_parse_error_bmatch( + [custom], +[[/* User defined function to report a syntax error. */ +typedef yyGLRStack yypcontext_t; +static int +yyreport_syntax_error (const yyGLRStack* yystackp]b4_user_formals[); + +/* The kind of the lookahead of this context. */ +static yysymbol_kind_t +yypcontext_token (const yyGLRStack *yystackp) YY_ATTRIBUTE_UNUSED; + +static yysymbol_kind_t +yypcontext_token (const yyGLRStack *yystackp) +{ + YY_USE (yystackp); + yysymbol_kind_t yytoken = yychar == ]b4_symbol(empty, id)[ ? ]b4_symbol(empty, kind)[ : YYTRANSLATE (yychar); + return yytoken; +} + +]b4_locations_if([[/* The location of the lookahead of this context. */ +static const YYLTYPE * +yypcontext_location (const yyGLRStack *yystackp) YY_ATTRIBUTE_UNUSED; + +static const YYLTYPE * +yypcontext_location (const yyGLRStack *yystackp) +{ + YY_USE (yystackp); + return &yylloc; +}]])], + [detailed\|verbose], +[[static int +yy_syntax_error_arguments (const yyGLRStack* yystackp, + yysymbol_kind_t yyarg[], int yyargn) +{ + yysymbol_kind_t yytoken = yychar == ]b4_symbol(empty, id)[ ? ]b4_symbol(empty, kind)[ : YYTRANSLATE (yychar); + /* Actual size of YYARG. */ + int yycount = 0; + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yytoken != ]b4_symbol(empty, kind)[) + { + int yyn; + if (yyarg) + yyarg[yycount] = yytoken; + ++yycount; + yyn = yypcontext_expected_tokens (yystackp, + yyarg ? yyarg + 1 : yyarg, yyargn - 1); + if (yyn == YYENOMEM) + return YYENOMEM; + else + yycount += yyn; + } + return yycount; +} +]])[ + + +static void +yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) +{ + if (yystackp->yyerrState != 0) + return; +]b4_parse_error_case( + [custom], +[[ if (yyreport_syntax_error (yystackp]b4_user_args[)) + yyMemoryExhausted (yystackp);]], + [simple], +[[ yyerror (]b4_lyyerror_args[YY_("syntax error"));]], +[[ { + yybool yysize_overflow = yyfalse; + char* yymsg = YY_NULLPTR; + enum { YYARGS_MAX = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULLPTR; + /* Arguments of yyformat: reported tokens (one for the "unexpected", + one per "expected"). */ + yysymbol_kind_t yyarg[YYARGS_MAX]; + /* Cumulated lengths of YYARG. */ + YYPTRDIFF_T yysize = 0; + + /* Actual size of YYARG. */ + int yycount + = yy_syntax_error_arguments (yystackp, yyarg, YYARGS_MAX); + if (yycount == YYENOMEM) + yyMemoryExhausted (yystackp); + + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: /* Avoid compiler warnings. */ + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + /* Compute error message size. Don't count the "%s"s, but reserve + room for the terminator. */ + yysize = yystrlen (yyformat) - 2 * yycount + 1; + { + int yyi; + for (yyi = 0; yyi < yycount; ++yyi) + { + YYPTRDIFF_T yysz + = ]b4_parse_error_case( + [verbose], [[yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]])]], + [[yystrlen (yysymbol_name (yyarg[yyi]))]]);[ + if (YYSIZE_MAXIMUM - yysize < yysz) + yysize_overflow = yytrue; + else + yysize += yysz; + } + } + + if (!yysize_overflow) + yymsg = YY_CAST (char *, YYMALLOC (YY_CAST (YYSIZE_T, yysize))); + + if (yymsg) + { + char *yyp = yymsg; + int yyi = 0; + while ((*yyp = *yyformat)) + { + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + {]b4_parse_error_case([verbose], [[ + yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]);]], [[ + yyp = yystpcpy (yyp, yysymbol_name (yyarg[yyi++]));]])[ + yyformat += 2; + } + else + { + ++yyp; + ++yyformat; + } + } + yyerror (]b4_lyyerror_args[yymsg); + YYFREE (yymsg); + } + else + { + yyerror (]b4_lyyerror_args[YY_("syntax error")); + yyMemoryExhausted (yystackp); + } + }]])[ + yynerrs += 1; +} + +/* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP, + yylval, and yylloc are the syntactic category, semantic value, and location + of the lookahead. */ +static void +yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) +{ + if (yystackp->yyerrState == 3) + /* We just shifted the error token and (perhaps) took some + reductions. Skip tokens until we can proceed. */ + while (yytrue) + { + yysymbol_kind_t yytoken; + int yyj; + if (yychar == ]b4_symbol(eof, [id])[) + yyFail (yystackp][]b4_lpure_args[, YY_NULLPTR); + if (yychar != ]b4_symbol(empty, id)[) + {]b4_locations_if([[ + /* We throw away the lookahead, but the error range + of the shifted error token must take it into account. */ + yyGLRState *yys = yystackp->yytops.yystates[0]; + yyGLRStackItem yyerror_range[3]; + yyerror_range[1].yystate.yyloc = yys->yyloc; + yyerror_range[2].yystate.yyloc = yylloc; + YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Error: discarding", + yytoken, &yylval]b4_locuser_args([&yylloc])[); + yychar = ]b4_symbol(empty, id)[; + } + yytoken = ]b4_yygetToken_call[; + yyj = yypact[yystackp->yytops.yystates[0]->yylrState]; + if (yypact_value_is_default (yyj)) + return; + yyj += yytoken; + if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken) + { + if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0) + return; + } + else if (! yytable_value_is_error (yytable[yyj])) + return; + } + + /* Reduce to one stack. */ + { + YYPTRDIFF_T yyk; + for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1) + if (yystackp->yytops.yystates[yyk] != YY_NULLPTR) + break; + if (yyk >= yystackp->yytops.yysize) + yyFail (yystackp][]b4_lpure_args[, YY_NULLPTR); + for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1) + yymarkStackDeleted (yystackp, yyk); + yyremoveDeletes (yystackp); + yycompressStack (yystackp); + } + + /* Pop stack until we find a state that shifts the error token. */ + yystackp->yyerrState = 3; + while (yystackp->yytops.yystates[0] != YY_NULLPTR) + { + yyGLRState *yys = yystackp->yytops.yystates[0]; + int yyj = yypact[yys->yylrState]; + if (! yypact_value_is_default (yyj)) + { + yyj += ]b4_symbol(error, kind)[; + if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == ]b4_symbol(error, kind)[ + && yyisShiftAction (yytable[yyj])) + { + /* Shift the error token. */ + int yyaction = yytable[yyj];]b4_locations_if([[ + /* First adjust its location.*/ + YYLTYPE yyerrloc; + yystackp->yyerror_range[2].yystate.yyloc = yylloc; + YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[ + YY_SYMBOL_PRINT ("Shifting", yy_accessing_symbol (yyaction), + &yylval, &yyerrloc); + yyglrShift (yystackp, 0, yyaction, + yys->yyposn, &yylval]b4_locations_if([, &yyerrloc])[); + yys = yystackp->yytops.yystates[0]; + break; + } + }]b4_locations_if([[ + yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ + if (yys->yypred != YY_NULLPTR) + yydestroyGLRState ("Error: popping", yys]b4_user_args[); + yystackp->yytops.yystates[0] = yys->yypred; + yystackp->yynextFree -= 1; + yystackp->yyspaceLeft += 1; + } + if (yystackp->yytops.yystates[0] == YY_NULLPTR) + yyFail (yystackp][]b4_lpure_args[, YY_NULLPTR); +} + +#define YYCHK1(YYE) \ + do { \ + switch (YYE) { \ + case yyok: break; \ + case yyabort: goto yyabortlab; \ + case yyaccept: goto yyacceptlab; \ + case yyerr: goto yyuser_error; \ + case yynomem: goto yyexhaustedlab; \ + default: goto yybuglab; \ + } \ + } while (0) + +/*----------. +| yyparse. | +`----------*/ + +int +]b4_glr_cc_if([yy_parse_impl], [yyparse])[ (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[) +{ + int yyresult; + yyGLRStack yystack; + yyGLRStack* const yystackp = &yystack; + YYPTRDIFF_T yyposn; + + YY_DPRINTF ((stderr, "Starting parse\n")); + + yychar = ]b4_symbol(empty, id)[; + yylval = yyval_default;]b4_locations_if([ + yylloc = yyloc_default;])[ +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [], [yylloc])dnl + b4_user_initial_action +b4_dollar_popdef])[]dnl +[ + if (! yyinitGLRStack (yystackp, YYINITDEPTH)) + goto yyexhaustedlab; + switch (YYSETJMP (yystack.yyexception_buffer)) + { + case 0: break; + case 1: goto yyabortlab; + case 2: goto yyexhaustedlab; + default: goto yybuglab; + } + yyglrShift (&yystack, 0, 0, 0, &yylval]b4_locations_if([, &yylloc])[); + yyposn = 0; + + while (yytrue) + { + /* For efficiency, we have two loops, the first of which is + specialized to deterministic operation (single stack, no + potential ambiguity). */ + /* Standard mode. */ + while (yytrue) + { + yy_state_t yystate = yystack.yytops.yystates[0]->yylrState; + YY_DPRINTF ((stderr, "Entering state %d\n", yystate)); + if (yystate == YYFINAL) + goto yyacceptlab; + if (yyisDefaultedState (yystate)) + { + yyRuleNum 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_kind_t yytoken = ]b4_yygetToken_call;[ + const short* yyconflicts; + int yyaction = yygetLRActions (yystate, yytoken, &yyconflicts); + if (*yyconflicts) + /* Enter nondeterministic mode. */ + break; + if (yyisShiftAction (yyaction)) + { + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + yychar = ]b4_symbol(empty, id)[; + yyposn += 1; + yyglrShift (&yystack, 0, yyaction, yyposn, &yylval]b4_locations_if([, &yylloc])[); + if (0 < yystack.yyerrState) + yystack.yyerrState -= 1; + } + else if (yyisErrorAction (yyaction)) + {]b4_locations_if([[ + yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + /* Issue an error message unless the scanner already + did. */ + if (yychar != ]b4_symbol(error, id)[) + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + else + YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[)); + } + } + + /* Nondeterministic mode. */ + while (yytrue) + { + yysymbol_kind_t yytoken_to_shift; + YYPTRDIFF_T yys; + + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + yystackp->yytops.yylookaheadNeeds[yys] = yychar != ]b4_symbol(empty, id)[; + + /* 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[)); + YY_DPRINTF ((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 ]b4_symbol(empty, id)[ + before the loop to make sure the user destructor for yylval isn't + called twice. */ + yytoken_to_shift = YYTRANSLATE (yychar); + yychar = ]b4_symbol(empty, id)[; + yyposn += 1; + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + { + yy_state_t yystate = yystack.yytops.yystates[yys]->yylrState; + const short* yyconflicts; + int yyaction = yygetLRActions (yystate, yytoken_to_shift, + &yyconflicts); + /* Note that yyconflicts were handled by yyprocessOneStack. */ + YY_DPRINTF ((stderr, "On stack %ld, ", YY_CAST (long, yys))); + YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc); + yyglrShift (&yystack, yys, yyaction, yyposn, + &yylval]b4_locations_if([, &yylloc])[); + YY_DPRINTF ((stderr, "Stack %ld now in state %d\n", + YY_CAST (long, yys), + yystack.yytops.yystates[yys]->yylrState)); + } + + if (yystack.yytops.yysize == 1) + { + YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); + YY_DPRINTF ((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 yyreturnlab; + + yybuglab: + YY_ASSERT (yyfalse); + goto yyabortlab; + + yyabortlab: + yyresult = 1; + goto yyreturnlab; + + yyexhaustedlab: + yyerror (]b4_lyyerror_args[YY_("memory exhausted")); + yyresult = 2; + goto yyreturnlab; + + yyreturnlab: + if (yychar != ]b4_symbol(empty, id)[) + yydestruct ("Cleanup: discarding lookahead", + YYTRANSLATE (yychar), &yylval]b4_locuser_args([&yylloc])[); + + /* If the stack is well-formed, pop the stack until it is empty, + destroying its entries as we go. But free the stack regardless + of whether it is well-formed. */ + if (yystack.yyitems) + { + yyGLRState** yystates = yystack.yytops.yystates; + if (yystates) + { + YYPTRDIFF_T yysize = yystack.yytops.yysize; + YYPTRDIFF_T yyk; + for (yyk = 0; yyk < yysize; yyk += 1) + if (yystates[yyk]) + { + while (yystates[yyk]) + { + yyGLRState *yys = yystates[yyk];]b4_locations_if([[ + yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ + if (yys->yypred != YY_NULLPTR) + yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); + yystates[yyk] = yys->yypred; + yystack.yynextFree -= 1; + yystack.yyspaceLeft += 1; + } + break; + } + } + yyfreeGLRStack (&yystack); + } + + return yyresult; +} + +/* DEBUGGING ONLY */ +#if ]b4_api_PREFIX[DEBUG +/* Print *YYS and its predecessors. */ +static void +yy_yypstack (yyGLRState* yys) +{ + if (yys->yypred) + { + yy_yypstack (yys->yypred); + YY_FPRINTF ((stderr, " -> ")); + } + YY_FPRINTF ((stderr, "%d@@%ld", yys->yylrState, YY_CAST (long, yys->yyposn))); +} + +/* Print YYS (possibly NULL) and its predecessors. */ +static void +yypstates (yyGLRState* yys) +{ + if (yys == YY_NULLPTR) + YY_FPRINTF ((stderr, "")); + else + yy_yypstack (yys); + YY_FPRINTF ((stderr, "\n")); +} + +/* Print the stack #YYK. */ +static void +yypstack (yyGLRStack* yystackp, YYPTRDIFF_T yyk) +{ + yypstates (yystackp->yytops.yystates[yyk]); +} + +/* Print all the stacks. */ +static void +yypdumpstack (yyGLRStack* yystackp) +{ +#define YYINDEX(YYX) \ + YY_CAST (long, \ + ((YYX) \ + ? YY_REINTERPRET_CAST (yyGLRStackItem*, (YYX)) - yystackp->yyitems \ + : -1)) + + yyGLRStackItem* yyp; + for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1) + { + YY_FPRINTF ((stderr, "%3ld. ", + YY_CAST (long, yyp - yystackp->yyitems))); + if (*YY_REINTERPRET_CAST (yybool *, yyp)) + { + YY_ASSERT (yyp->yystate.yyisState); + YY_ASSERT (yyp->yyoption.yyisState); + YY_FPRINTF ((stderr, "Res: %d, LR State: %d, posn: %ld, pred: %ld", + yyp->yystate.yyresolved, yyp->yystate.yylrState, + YY_CAST (long, yyp->yystate.yyposn), + YYINDEX (yyp->yystate.yypred))); + if (! yyp->yystate.yyresolved) + YY_FPRINTF ((stderr, ", firstVal: %ld", + YYINDEX (yyp->yystate.yysemantics.yyfirstVal))); + } + else + { + YY_ASSERT (!yyp->yystate.yyisState); + YY_ASSERT (!yyp->yyoption.yyisState); + YY_FPRINTF ((stderr, "Option. rule: %d, state: %ld, next: %ld", + yyp->yyoption.yyrule - 1, + YYINDEX (yyp->yyoption.yystate), + YYINDEX (yyp->yyoption.yynext))); + } + YY_FPRINTF ((stderr, "\n")); + } + + YY_FPRINTF ((stderr, "Tops:")); + { + YYPTRDIFF_T yyi; + for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) + YY_FPRINTF ((stderr, "%ld: %ld; ", YY_CAST (long, yyi), + YYINDEX (yystackp->yytops.yystates[yyi]))); + YY_FPRINTF ((stderr, "\n")); + } +#undef YYINDEX +} +#endif + +#undef yylval +#undef yychar +#undef yynerrs]b4_locations_if([ +#undef yylloc]) + +m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */ +#define yyparse ]b4_prefix[parse +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char +#define yydebug ]b4_prefix[debug +#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])])[ + +]b4_glr_cc_if([b4_glr_cc_pre_epilogue +b4_glr_cc_cleanup])[ +]b4_percent_code_get([[epilogue]])[]dnl +b4_epilogue[]dnl +b4_output_end diff --git a/compiler/win_flex_bison/data/skeletons/glr.cc b/compiler/win_flex_bison/data/skeletons/glr.cc new file mode 100644 index 0000000..7181402 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/glr.cc @@ -0,0 +1,397 @@ +# C++ GLR skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +# This skeleton produces a C++ class that encapsulates a C glr parser. +# This is in order to reduce the maintenance burden. The glr.c +# skeleton is clean and pure enough so that there are no real +# problems. The C++ interface is the same as that of lalr1.cc. In +# fact, glr.c can replace yacc.c without the user noticing any +# difference, and similarly for glr.cc replacing lalr1.cc. +# +# The passing of parse-params +# +# The additional arguments are stored as members of the parser +# object, yyparser. The C routines need to carry yyparser +# throughout the C parser; that's easy: make yyparser an +# additional parse-param. But because the C++ skeleton needs to +# know the "real" original parse-param, we save them +# (b4_parse_param_orig). Note that b4_parse_param is overquoted +# (and c.m4 strips one level of quotes). This is a PITA, and +# explains why there are so many levels of quotes. +# +# The locations +# +# We use location.cc just like lalr1.cc, but because glr.c stores +# the locations in a union, the position and location classes +# must not have a constructor. Therefore, contrary to lalr1.cc, we +# must not define "b4_location_constructors". As a consequence the +# user must initialize the first positions (in particular the +# filename member). + +# We require a pure interface. +m4_define([b4_pure_flag], [1]) + +m4_include(b4_skeletonsdir/[c++.m4]) +b4_bison_locations_if([m4_include(b4_skeletonsdir/[location.cc])]) + +m4_define([b4_parser_class], + [b4_percent_define_get([[api.parser.class]])]) + +# Save the parse parameters. +m4_define([b4_parse_param_orig], m4_defn([b4_parse_param])) + +# b4_parse_param_wrap +# ------------------- +# New ones. +m4_ifset([b4_parse_param], +[m4_define([b4_parse_param_wrap], + [[b4_namespace_ref::b4_parser_class[& yyparser], [[yyparser]]],] +m4_defn([b4_parse_param]))], +[m4_define([b4_parse_param_wrap], + [[b4_namespace_ref::b4_parser_class[& yyparser], [[yyparser]]]]) +]) + + +# b4_yy_symbol_print_define +# ------------------------- +# Bypass the default implementation to generate the "yy_symbol_print" +# and "yy_symbol_value_print" functions. +m4_define([b4_yy_symbol_print_define], +[[/*--------------------. +| Print this symbol. | +`--------------------*/ + +static void +yy_symbol_print (FILE *, ]b4_namespace_ref::b4_parser_class[::symbol_kind_type yytoken, + const ]b4_namespace_ref::b4_parser_class[::value_type *yyvaluep]b4_locations_if([[, + const ]b4_namespace_ref::b4_parser_class[::location_type *yylocationp]])[]b4_user_formals[) +{ +]b4_parse_param_use[]dnl +[ yyparser.yy_symbol_print_ (yytoken, yyvaluep]b4_locations_if([, yylocationp])[); +} +]])[ + +# Hijack the initial action to initialize the locations. +]b4_bison_locations_if([m4_define([b4_initial_action], +[yylloc.initialize ();]m4_ifdef([b4_initial_action], [ +m4_defn([b4_initial_action])]))])[ + +# Hijack the post prologue to declare yyerror. +]m4_append([b4_post_prologue], +[b4_syncline([@oline@], [@ofile@])dnl +[static void +yyerror (]b4_locations_if([[const ]b4_namespace_ref::b4_parser_class[::location_type *yylocationp, + ]])[]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param), + ])[const char* msg);]])[ + +# Inserted before the epilogue to define implementations (yyerror, parser member +# functions etc.). +]m4_define([b4_glr_cc_pre_epilogue], +[b4_syncline([@oline@], [@ofile@])dnl +[ +/*------------------. +| Report an error. | +`------------------*/ + +static void +yyerror (]b4_locations_if([[const ]b4_namespace_ref::b4_parser_class[::location_type *yylocationp, + ]])[]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param), + ])[const char* msg) +{ +]b4_parse_param_use[]dnl +[ yyparser.error (]b4_locations_if([[*yylocationp, ]])[msg); +} + + +]b4_namespace_open[ +]dnl In this section, the parse params are the original parse_params. +m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl +[ /// Build a parser object. + ]b4_parser_class::b4_parser_class[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ + :])[ +#if ]b4_api_PREFIX[DEBUG + ]m4_ifset([b4_parse_param], [ ], [ :])[yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ +#endif]b4_parse_param_cons[ + {} + + ]b4_parser_class::~b4_parser_class[ () + {} + + ]b4_parser_class[::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW + {} + + int + ]b4_parser_class[::operator() () + { + return parse (); + } + + int + ]b4_parser_class[::parse () + { + return ::yy_parse_impl (*this]b4_user_args[); + } + +#if ]b4_api_PREFIX[DEBUG + /*--------------------. + | Print this symbol. | + `--------------------*/ + + void + ]b4_parser_class[::yy_symbol_value_print_ (symbol_kind_type yykind, + const value_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) const + {]b4_locations_if([[ + YY_USE (yylocationp);]])[ + YY_USE (yyvaluep); + std::ostream& yyo = debug_stream (); + std::ostream& yyoutput = yyo; + YY_USE (yyoutput); + ]b4_symbol_actions([printer])[ + } + + + void + ]b4_parser_class[::yy_symbol_print_ (symbol_kind_type yykind, + const value_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) const + { + *yycdebug_ << (yykind < YYNTOKENS ? "token" : "nterm") + << ' ' << yysymbol_name (yykind) << " ("]b4_locations_if([[ + << *yylocationp << ": "]])[; + yy_symbol_value_print_ (yykind, yyvaluep]b4_locations_if([[, yylocationp]])[); + *yycdebug_ << ')'; + } + + std::ostream& + ]b4_parser_class[::debug_stream () const + { + return *yycdebug_; + } + + void + ]b4_parser_class[::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + ]b4_parser_class[::debug_level_type + ]b4_parser_class[::debug_level () const + { + return yydebug; + } + + void + ]b4_parser_class[::set_debug_level (debug_level_type l) + { + // Actually, it is yydebug which is really used. + yydebug = l; + } + +#endif +]m4_popdef([b4_parse_param])dnl +b4_namespace_close[]dnl +]) + + +m4_define([b4_define_symbol_kind], +[m4_format([#define %-15s %s], + b4_symbol($][1, kind_base), + b4_namespace_ref[::]b4_parser_class[::symbol_kind::]b4_symbol($1, kind_base)) +]) + +# b4_glr_cc_setup +# --------------- +# Setup redirections for glr.c: Map the names used in c.m4 to the ones used +# in c++.m4. +m4_define([b4_glr_cc_setup], +[[]b4_attribute_define[ +]b4_null_define[ + +// This skeleton is based on C, yet compiles it as C++. +// So expect warnings about C style casts. +#if defined __clang__ && 306 <= __clang_major__ * 100 + __clang_minor__ +# pragma clang diagnostic ignored "-Wold-style-cast" +#elif defined __GNUC__ && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ +# pragma GCC diagnostic ignored "-Wold-style-cast" +#endif + +// On MacOS, PTRDIFF_MAX is defined as long long, which Clang's +// -pedantic reports as being a C++11 extension. +#if defined __APPLE__ && YY_CPLUSPLUS < 201103L \ + && defined __clang__ && 4 <= __clang_major__ +# pragma clang diagnostic ignored "-Wc++11-long-long" +#endif + +#undef ]b4_symbol(empty, [id])[ +#define ]b4_symbol(empty, [id])[ ]b4_namespace_ref[::]b4_parser_class[::token::]b4_symbol(empty, [id])[ +#undef ]b4_symbol(eof, [id])[ +#define ]b4_symbol(eof, [id])[ ]b4_namespace_ref[::]b4_parser_class[::token::]b4_symbol(eof, [id])[ +#undef ]b4_symbol(error, [id])[ +#define ]b4_symbol(error, [id])[ ]b4_namespace_ref[::]b4_parser_class[::token::]b4_symbol(error, [id])[ + +#ifndef ]b4_api_PREFIX[STYPE +# define ]b4_api_PREFIX[STYPE ]b4_namespace_ref[::]b4_parser_class[::value_type +#endif +#ifndef ]b4_api_PREFIX[LTYPE +# define ]b4_api_PREFIX[LTYPE ]b4_namespace_ref[::]b4_parser_class[::location_type +#endif + +typedef ]b4_namespace_ref[::]b4_parser_class[::symbol_kind_type yysymbol_kind_t; + +// Expose C++ symbol kinds to C. +]b4_define_symbol_kind(-2)dnl +b4_symbol_foreach([b4_define_symbol_kind])])[ +]]) + + +m4_define([b4_undef_symbol_kind], +[[#undef ]b4_symbol($1, kind_base)[ +]]) + + +# b4_glr_cc_cleanup +# ----------------- +# Remove redirections for glr.c. +m4_define([b4_glr_cc_cleanup], +[[#undef ]b4_symbol(empty, [id])[ +#undef ]b4_symbol(eof, [id])[ +#undef ]b4_symbol(error, [id])[ + +]b4_undef_symbol_kind(-2)dnl +b4_symbol_foreach([b4_undef_symbol_kind])dnl +]) + + +# b4_shared_declarations(hh|cc) +# ----------------------------- +# Declaration that might either go into the header (if --header, $1 = hh) +# or in the implementation file. +m4_define([b4_shared_declarations], +[m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl +b4_percent_code_get([[requires]])[ +#include +#include +#include + +]b4_cxx_portability[ +]m4_ifdef([b4_location_include], + [[# include ]b4_location_include])[ +]b4_variant_if([b4_variant_includes])[ + +// Whether we are compiled with exception support. +#ifndef YY_EXCEPTIONS +# if defined __GNUC__ && !defined __EXCEPTIONS +# define YY_EXCEPTIONS 0 +# else +# define YY_EXCEPTIONS 1 +# endif +#endif + +]b4_YYDEBUG_define[ + +]b4_namespace_open[ + +]b4_bison_locations_if([m4_ifndef([b4_location_file], + [b4_location_define])])[ + + /// A Bison parser. + class ]b4_parser_class[ + { + public: +]b4_public_types_declare[ + + /// Build a parser object. + ]b4_parser_class[ (]b4_parse_param_decl[); + virtual ~]b4_parser_class[ (); + + /// Parse. An alias for parse (). + /// \returns 0 iff parsing succeeded. + int operator() (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + virtual int parse (); + +#if ]b4_api_PREFIX[DEBUG + /// The current debugging stream. + std::ostream& debug_stream () const; + /// Set the current debugging stream. + void set_debug_stream (std::ostream &); + + /// Type for debugging levels. + typedef int debug_level_type; + /// The current debugging level. + debug_level_type debug_level () const; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); +#endif + + /// Report a syntax error.]b4_locations_if([[ + /// \param loc where the syntax error is found.]])[ + /// \param msg a description of the syntax error. + virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); + +# if ]b4_api_PREFIX[DEBUG + public: + /// \brief Report a symbol value on the debug stream. + /// \param yykind The symbol kind. + /// \param yyvaluep Its semantic value.]b4_locations_if([[ + /// \param yylocationp Its location.]])[ + virtual void yy_symbol_value_print_ (symbol_kind_type yykind, + const value_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) const; + /// \brief Report a symbol on the debug stream. + /// \param yykind The symbol kind. + /// \param yyvaluep Its semantic value.]b4_locations_if([[ + /// \param yylocationp Its location.]])[ + virtual void yy_symbol_print_ (symbol_kind_type yykind, + const value_type* yyvaluep]b4_locations_if([[, + const location_type* yylocationp]])[) const; + private: + /// Debug stream. + std::ostream* yycdebug_; +#endif + +]b4_parse_param_vars[ + }; + +]b4_namespace_close[ + +]b4_percent_code_get([[provides]])[ +]m4_popdef([b4_parse_param])dnl +])[ + +]b4_header_if( +[b4_output_begin([b4_spec_header_file]) +b4_copyright([Skeleton interface for Bison GLR parsers in C++], + [2002-2015, 2018-2021])[ +// C++ GLR parser skeleton written by Akim Demaille. + +]b4_disclaimer[ +]b4_cpp_guard_open([b4_spec_mapped_header_file])[ +]b4_shared_declarations[ +]b4_cpp_guard_close([b4_spec_mapped_header_file])[ +]b4_output_end]) + +# Let glr.c (and b4_shared_declarations) believe that the user +# arguments include the parser itself. +m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_wrap])) +m4_include(b4_skeletonsdir/[glr.c]) +m4_popdef([b4_parse_param]) diff --git a/compiler/win_flex_bison/data/skeletons/glr2.cc b/compiler/win_flex_bison/data/skeletons/glr2.cc new file mode 100644 index 0000000..757d68d --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/glr2.cc @@ -0,0 +1,3533 @@ +# C++ GLR skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 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_skeletonsdir/[c++.m4]) + +# api.value.type=variant is valid. +m4_define([b4_value_type_setup_variant]) + +# b4_tname_if(TNAME-NEEDED, TNAME-NOT-NEEDED) +# ------------------------------------------- +m4_define([b4_tname_if], +[m4_case(b4_percent_define_get([[parse.error]]), + [verbose], [$1], + [b4_token_table_if([$1], + [$2])])]) + +b4_bison_locations_if([ + m4_define([b4_location_constructors]) + m4_include(b4_skeletonsdir/[location.cc])]) +b4_variant_if([m4_include(b4_skeletonsdir/[variant.hh])]) + +m4_define([b4_parser_class], + [b4_percent_define_get([[api.parser.class]])]) + +]m4_define([b4_define_symbol_kind], +[m4_format([#define %-15s %s], + b4_symbol($][1, kind_base), + b4_namespace_ref[::]b4_parser_class[::symbol_kind::]b4_symbol($1, kind_base)) +]) + + +# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) +# ------------------------------------------------------------- +# Define "yy" whose contents is CONTENT. Does not use "static", +# should be in unnamed namespace. +m4_define([b4_integral_parser_table_define], +[m4_ifvaln([$3], [ b4_comment([$3])])dnl + const b4_int_type_for([$2]) yy$1[[]] = + { + $2 + };dnl +]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Stack parameters. +m4_define_default([b4_stack_depth_max], [10000]) +m4_define_default([b4_stack_depth_init], [200]) + + + +## ------------ ## +## Interfaces. ## +## ------------ ## + +# b4_user_formals +# --------------- +# The possible parse-params formal arguments preceded by a comma. +# +# This is not shared with yacc.c in c.m4 because GLR relies on ISO C +# formal argument declarations. +m4_define([b4_user_formals], +[m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])]) + + +# b4_symbol_kind(NUM) +# ------------------- +m4_define([b4_symbol_kind], +[symbol_kind::b4_symbol_kind_base($@)]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_lhs_value(SYMBOL-NUM, [TYPE]) +# -------------------------------- +# See README. +m4_define([b4_lhs_value], +[b4_symbol_value([(*yyvalp)], [$1], [$2])]) + + +# b4_rhs_data(RULE-LENGTH, POS) +# ----------------------------- +# See README. +m4_define([b4_rhs_data], +[(static_cast(yyvsp))@{YYFILL (b4_subtract([$2], [$1]))@}.getState()]) + + +# b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE]) +# -------------------------------------------------- +# Expansion of $$ or $$, for symbol SYMBOL-NUM. +m4_define([b4_rhs_value], +[b4_symbol_value([b4_rhs_data([$1], [$2]).value ()], [$3], [$4])]) + + + +## ----------- ## +## Locations. ## +## ----------- ## + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(*yylocp)]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[(b4_rhs_data([$1], [$2]).yyloc)]) + + +# b4_symbol_action(SYMBOL-NUM, KIND) +# ---------------------------------- +# Run the action KIND (destructor or printer) for SYMBOL-NUM. +# Same as in C, but using references instead of pointers. +# +# Currently we need two different b4_symbol_action: once for the +# self-contained symbols, and another time for yy_destroy_ and +# yy_symbol_value_print_, which don't use genuine symbols yet. +m4_define([b4_symbol_action], +[b4_symbol_if([$1], [has_$2], +[m4_pushdef([b4_symbol_value], m4_defn([b4_symbol_value_template]))[]dnl +b4_dollar_pushdef([yysym.value], + [$1], + [], + [yysym.location])dnl + _b4_symbol_case([$1])[]dnl +b4_syncline([b4_symbol([$1], [$2_line])], [b4_symbol([$1], [$2_file])])dnl + b4_symbol([$1], [$2]) +b4_syncline([@oline@], [@ofile@])dnl + break; + +m4_popdef([b4_symbol_value])[]dnl +b4_dollar_popdef[]dnl +])]) + + +# b4_symbol_action_for_yyval(SYMBOL-NUM, KIND) +# -------------------------------------------- +# Run the action KIND (destructor or printer) for SYMBOL-NUM. +# Same as in C, but using references instead of pointers. +m4_define([b4_symbol_action_for_yyval], +[b4_symbol_if([$1], [has_$2], +[b4_dollar_pushdef([yyval], + [$1], + [], + [yyloc])dnl + _b4_symbol_case([$1])[]dnl +b4_syncline([b4_symbol([$1], [$2_line])], [b4_symbol([$1], [$2_file])])dnl + b4_symbol([$1], [$2]) +b4_syncline([@oline@], [@ofile@])dnl + break; + +b4_dollar_popdef[]dnl +])]) + + +# b4_call_merger(MERGER-NUM, MERGER-NAME, SYMBOL-SUM) +# --------------------------------------------------- +m4_define([b4_call_merger], +[b4_case([$1], + [ b4_symbol_if([$3], [has_type], + [b4_variant_if([yy0.as< b4_symbol($3, type) > () = $2 (yy0.as< b4_symbol($3, type) >(), yy1.as< b4_symbol($3, type) >());], + [yy0.b4_symbol($3, slot) = $2 (yy0, yy1);])], + [yy0 = $2 (yy0, yy1);])])]) + +# b4_yylex +# -------- +# Call yylex. +m4_define([b4_yylex], +[b4_token_ctor_if( +[b4_function_call([yylex], + [symbol_type], m4_ifdef([b4_lex_param], b4_lex_param))], +[b4_function_call([yylex], [int], + [[value_type *], [&this->yyla.value]][]dnl +b4_locations_if([, [[location_type *], [&this->yyla.location]]])dnl +m4_ifdef([b4_lex_param], [, ]b4_lex_param))])]) + + +# b4_shared_declarations(hh|cc) +# ----------------------------- +# Declaration that might either go into the header (if --header, $1 = hh) +# or in the implementation file. +m4_define([b4_shared_declarations], +[b4_percent_code_get([[requires]])[ +#include +#include // ptrdiff_t +#include // memcpy +#include +#include +#include +#include +#include +#include +#include + +]b4_cxx_portability[ +]m4_ifdef([b4_location_include], + [[# include ]b4_location_include])[ +]b4_variant_if([b4_variant_includes])[ + +]b4_YYDEBUG_define[ + +]b4_namespace_open[ + +]b4_bison_locations_if([m4_ifndef([b4_location_file], + [b4_location_define])])[ + + /// A Bison parser. + class ]b4_parser_class[ + { + public: +]b4_public_types_declare[ +]b4_symbol_type_define[ + + // FIXME: should be private eventually. + class glr_stack; + class glr_state; + + /// Build a parser object. + ]b4_parser_class[ (]b4_parse_param_decl[); + ~]b4_parser_class[ (); + + /// Parse. An alias for parse (). + /// \returns 0 iff parsing succeeded. + int operator() (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + int parse (); + +#if ]b4_api_PREFIX[DEBUG + /// The current debugging stream. + std::ostream& debug_stream () const; + /// Set the current debugging stream. + void set_debug_stream (std::ostream &); + + /// Type for debugging levels. + using debug_level_type = int; + /// The current debugging level. + debug_level_type debug_level () const; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); +#endif + + /// Report a syntax error.]b4_locations_if([[ + /// \param loc where the syntax error is found.]])[ + /// \param msg a description of the syntax error. + void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); + +]b4_parse_error_bmatch( +[custom\|detailed], +[[ /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static const char *symbol_name (symbol_kind_type yysymbol);]], +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static const char *symbol_name (symbol_kind_type yysymbol); +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[verbose], +[[ /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static std::string symbol_name (symbol_kind_type yysymbol);]])[ + +]b4_token_constructor_define[ +]b4_parse_error_bmatch([custom\|detailed\|verbose], [[ + class context + { + public: + context (glr_stack& yystack, const symbol_type& yyla); + const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; } + symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); }]b4_locations_if([[ + const location_type& location () const YY_NOEXCEPT { return yyla_.location; } +]])[ + /// Put in YYARG at most YYARGN of the expected tokens, and return the + /// number of tokens stored in YYARG. If YYARG is null, return the + /// number of expected tokens (guaranteed to be less than YYNTOKENS). + int expected_tokens (symbol_kind_type yyarg[], int yyargn) const; + + private: + glr_stack& yystack_; + const symbol_type& yyla_; + }; +]])[ +# if ]b4_api_PREFIX[DEBUG + public: + /// \brief Report a symbol value on the debug stream. + /// \param yykind The symbol kind. + /// \param yyval Its semantic value.]b4_locations_if([[ + /// \param yyloc Its location.]])[ + void yy_symbol_value_print_ (symbol_kind_type yykind, + const value_type& yyval]b4_locations_if([[, + const location_type& yyloc]])[) const; + /// \brief Report a symbol on the debug stream. + /// \param yykind The symbol kind. + /// \param yyval Its semantic value.]b4_locations_if([[ + /// \param yyloc Its location.]])[ + void yy_symbol_print_ (symbol_kind_type yykind, + const value_type& yyval]b4_locations_if([[, + const location_type& yyloc]])[) const; + private: + /// Debug stream. + std::ostream* yycdebug_; +#endif + +]b4_parse_error_bmatch( +[custom], [[ + private: + /// Report a syntax error + /// \param yyctx the context in which the error occurred. + void report_syntax_error (const context& yyctx) const;]], +[detailed\|verbose], [[ + private: + /// The arguments of the error message. + int yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const; + + /// Generate an error message. + /// \param yyctx the context in which the error occurred. + virtual std::string yysyntax_error_ (const context& yyctx) const;]])[ + + /// Convert a scanner token kind \a t to a symbol kind. + /// In theory \a t should be a token_kind_type, but character literals + /// are valid, yet not members of the token_kind_type enum. + static symbol_kind_type yytranslate_ (int t) YY_NOEXCEPT; + +]b4_parse_error_bmatch( +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + /// For a symbol, its name in clear. + static const char* const yytname_[]; +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[verbose], +[[ /// Convert the symbol name \a n to a form suitable for a diagnostic. + static std::string yytnamerr_ (const char *yystr); + + /// For a symbol, its name in clear. + static const char* const yytname_[]; +]])[ + + /// \brief Reclaim the memory associated to a symbol. + /// \param yymsg Why this token is reclaimed. + /// If null, print nothing. + /// \param yykind The symbol kind. + void yy_destroy_ (const char* yymsg, symbol_kind_type yykind, + value_type& yyval]b4_locations_if([[, + location_type& yyloc]])[); + +]b4_parse_param_vars[ + // Needs access to yy_destroy_, report_syntax_error, etc. + friend glr_stack; + }; + +]b4_token_ctor_if([b4_yytranslate_define([$1])[ +]b4_public_types_define([$1])])[ +]b4_namespace_close[ + +]b4_percent_code_get([[provides]])[ +]])[ + + +## -------------- ## +## Output files. ## +## -------------- ## + + +# ------------- # +# Header file. # +# ------------- # + +]b4_header_if([[ +]b4_output_begin([b4_spec_header_file])[ +]b4_copyright([Skeleton interface for Bison GLR parsers in C++], + [2002-2015, 2018-2021])[ +// C++ GLR parser skeleton written by Valentin Tolmer. + +]b4_disclaimer[ +]b4_cpp_guard_open([b4_spec_mapped_header_file])[ +]b4_shared_declarations([hh])[ +]b4_cpp_guard_close([b4_spec_mapped_header_file])[ +]b4_output_end])[ + + +# --------------------- # +# Implementation file. # +# --------------------- # + +]b4_output_begin([b4_parser_file_name])[ +]b4_copyright([Skeleton implementation for Bison GLR parsers in C], + [2002-2015, 2018-2021])[ +// C++ GLR parser skeleton written by Valentin Tolmer. + +]b4_disclaimer[ +]b4_identification[ + +]b4_percent_code_get([[top]])[ +]m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */ +#define yyparse ]b4_prefix[parse +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yydebug ]b4_prefix[debug]])[ + +]b4_user_pre_prologue[ + +]b4_null_define[ + +]b4_header_if([[#include "@basename(]b4_spec_header_file[@)"]], + [b4_shared_declarations([cc])])[ + +namespace +{ + /* 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. */ + ]b4_namespace_ref[::]b4_parser_class[::value_type yyval_default; +} + +]b4_user_post_prologue[ +]b4_percent_code_get[ + +#include +#include + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif + +// Whether we are compiled with exception support. +#ifndef YY_EXCEPTIONS +# if defined __GNUC__ && !defined __EXCEPTIONS +# define YY_EXCEPTIONS 0 +# else +# define YY_EXCEPTIONS 1 +# endif +#endif + +#ifndef YYFREE +# define YYFREE free +#endif +#ifndef YYMALLOC +# define YYMALLOC malloc +#endif + +#ifndef YYSETJMP +# include +# define YYJMP_BUF jmp_buf +# define YYSETJMP(Env) setjmp (Env) +/* Pacify Clang and ICC. */ +# define YYLONGJMP(Env, Val) \ + do { \ + longjmp (Env, Val); \ + YYASSERT (0); \ + } while (false) +#endif + +]b4_attribute_define([noreturn])[ + +#if defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_NULL_DEREFERENCE_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wnull-dereference\"") +# define YY_IGNORE_NULL_DEREFERENCE_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_IGNORE_NULL_DEREFERENCE_BEGIN +# define YY_IGNORE_NULL_DEREFERENCE_END +#endif + +]b4_null_define[ +]b4_cast_define[ + +// FIXME: Use the same conventions as lalr1.cc. +]b4_parse_assert_if[ +#ifndef YYASSERT +# define YYASSERT(Condition) ((void) ((Condition) || (abort (), 0))) +#endif + +#ifdef YYDEBUG +# define YYDASSERT(Condition) YYASSERT(Condition) +#else +# define YYDASSERT(Condition) +#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[ +/* YYNSTATES -- 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[ + +namespace +{ +#if ]b4_api_PREFIX[DEBUG + /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ + const ]b4_int_type_for([b4_rline])[ yyrline[] = + { + ]b4_rline[ + }; +#endif + +#define YYPACT_NINF ]b4_pact_ninf[ +#define YYTABLE_NINF ]b4_table_ninf[ + +]b4_parser_tables_define[ + + /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ + const ]b4_int_type_for([b4_dprec])[ yydprec[] = + { + ]b4_dprec[ + }; + + /* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ + const ]b4_int_type_for([b4_merger])[ yymerger[] = + { + ]b4_merger[ + }; + + /* YYIMMEDIATE[RULE-NUM] -- True iff rule #RULE-NUM is not to be deferred, as + in the case of predicates. */ + const bool yyimmediate[] = + { + ]b4_immediate[ + }; + + /* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of + list of conflicting reductions corresponding to action entry for + state STATE-NUM in yytable. 0 means no conflicts. The list in + yyconfl is terminated by a rule number of 0. */ + const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = + { + ]b4_conflict_list_heads[ + }; + + /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by + 0, pointed into by YYCONFLP. */ + ]dnl Do not use b4_int_type_for here, since there are places where + dnl pointers onto yyconfl are taken, whose type is "short*". + dnl We probably ought to introduce a type for confl. + [const short yyconfl[] = + { + ]b4_conflicting_rules[ + }; +} // namespace + + +/* Error token number */ +#define YYTERROR 1 + +]b4_locations_if([[ +]b4_yylloc_default_define[ +# define YYRHSLOC(Rhs, K) ((Rhs)[K].getState().yyloc) +]])[ + +enum YYRESULTTAG { yyok, yyaccept, yyabort, yyerr }; + +#define YYCHK(YYE) \ + do { \ + YYRESULTTAG yychk_flag = YYE; \ + if (yychk_flag != yyok) \ + return yychk_flag; \ + } while (false) + +#if ]b4_api_PREFIX[DEBUG + +#define YYCDEBUG if (!yydebug) {} else std::cerr + +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ + do { \ + if (yydebug) \ + { \ + std::cerr << Title << ' '; \ + yyparser.yy_symbol_print_ (Kind, Value]b4_locations_if([, Location])[); \ + std::cerr << '\n'; \ + } \ + } while (false) + +# define YY_REDUCE_PRINT(Args) \ + do { \ + if (yydebug) \ + yystateStack.yy_reduce_print Args; \ + } while (false) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; + +namespace +{ + using glr_stack = ]b4_namespace_ref[::]b4_parser_class[::glr_stack; + using glr_state = ]b4_namespace_ref[::]b4_parser_class[::glr_state; + + void yypstack (const glr_stack& yystack, size_t yyk) + YY_ATTRIBUTE_UNUSED; + void yypdumpstack (const glr_stack& yystack) + YY_ATTRIBUTE_UNUSED; +} + +#else /* !]b4_api_PREFIX[DEBUG */ + +# define YYCDEBUG if (true) {} else std::cerr +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) {} +# define YY_REDUCE_PRINT(Args) {} + +#endif /* !]b4_api_PREFIX[DEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH ]b4_stack_depth_init[ +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH ]b4_stack_depth_max[ +#endif + +/* Minimum number of free items on the stack allowed after an + allocation. This is to allow allocation and initialization + to be completed by functions that call yyexpandGLRStack before the + stack is expanded, thus insuring that all necessary pointers get + properly redirected to new data. */ +#define YYHEADROOM 2 + +#ifndef YYSTACKEXPANDABLE +# define YYSTACKEXPANDABLE 1 +#endif + +namespace +{ + template + class strong_index_alias + { + public: + static strong_index_alias create (std::ptrdiff_t value) + { + strong_index_alias result; + result.value_ = value; + return result; + } + + std::ptrdiff_t const& get () const { return value_; } + + size_t uget () const { return static_cast (value_); } + + strong_index_alias operator+ (std::ptrdiff_t other) const + { + return strong_index_alias (get () + other); + } + + void operator+= (std::ptrdiff_t other) + { + value_ += other; + } + + strong_index_alias operator- (std::ptrdiff_t other) + { + return strong_index_alias (get () - other); + } + + void operator-= (std::ptrdiff_t other) + { + value_ -= other; + } + + size_t operator- (strong_index_alias other) + { + return strong_index_alias (get () - other.get ()); + } + + strong_index_alias& operator++ () + { + ++value_; + return *this; + } + + bool isValid () const + { + return value_ != INVALID_INDEX; + } + + void setInvalid() + { + value_ = INVALID_INDEX; + } + + bool operator== (strong_index_alias other) + { + return get () == other.get (); + } + + bool operator!= (strong_index_alias other) + { + return get () != other.get (); + } + + bool operator< (strong_index_alias other) + { + return get () < other.get (); + } + + private: + static const std::ptrdiff_t INVALID_INDEX; + + // WARNING: 0-initialized. + std::ptrdiff_t value_; + }; // class strong_index_alias + + template + const std::ptrdiff_t strong_index_alias::INVALID_INDEX = + std::numeric_limits::max (); + + using state_set_index = strong_index_alias; + + state_set_index create_state_set_index (std::ptrdiff_t value) + { + return state_set_index::create (value); + } + + /** State numbers, as in LALR(1) machine */ + using state_num = int; + + /** Rule numbers, as in LALR(1) machine */ + using rule_num = int; + + using parser_type = ]b4_namespace_ref[::]b4_parser_class[; + using glr_state = parser_type::glr_state; + using symbol_kind = parser_type::symbol_kind; + using symbol_kind_type = parser_type::symbol_kind_type; + using symbol_type = parser_type::symbol_type; + using value_type = parser_type::value_type;]b4_locations_if([[ + using location_type = parser_type::location_type;]])[ + + // Forward declarations. + class glr_stack_item; + class semantic_option; +} // namespace + +namespace +{ + /** Accessing symbol of state YYSTATE. */ + inline symbol_kind_type + yy_accessing_symbol (state_num yystate) + { + return YY_CAST (symbol_kind_type, yystos[yystate]); + } + + /** Left-hand-side symbol for rule #YYRULE. */ + inline symbol_kind_type + yylhsNonterm (rule_num yyrule) + { + return static_cast(yyr1[yyrule]); + } + + /** Number of symbols composing the right hand side of rule #RULE. */ + inline int + yyrhsLength (rule_num yyrule) + { + return yyr2[yyrule]; + } +} + +namespace ]b4_namespace_ref[ +{ + class ]b4_parser_class[::glr_state + { + public: + glr_state () + : yyresolved (false) + , yylrState (0) + , yyposn (0) + , yypred (0) + , yyfirstVal (0)]b4_locations_if([[ + , yyloc ()]])[]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {} + + /// Build with a semantic value. + glr_state (state_num lrState, size_t posn, const value_type& val]b4_locations_if([[, const location_type& loc]])[) + : yyresolved (true) + , yylrState (lrState) + , yyposn (posn) + , yypred (0) + , yyval (]b4_variant_if([], [[val]])[)]b4_locations_if([[ + , yyloc (loc)]])[]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {]b4_variant_if([[ + ]b4_symbol_variant([yy_accessing_symbol (lrState)], + [yyval], [copy], [val])])[} + + /// Build with a semantic option. + glr_state (state_num lrState, size_t posn) + : yyresolved (false) + , yylrState (lrState) + , yyposn (posn) + , yypred (0) + , yyfirstVal (0)]b4_locations_if([[ + , yyloc ()]])[]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {} + + glr_state (const glr_state& other) + : yyresolved (other.yyresolved) + , yylrState (other.yylrState) + , yyposn (other.yyposn) + , yypred (0)]b4_locations_if([[ + , yyloc (other.yyloc)]])[]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + { + setPred (other.pred ()); + if (other.yyresolved)]b4_variant_if([[ + { + new (&yyval) value_type (); + ]b4_symbol_variant([yy_accessing_symbol (other.yylrState)], + [yyval], [copy], [other.value ()])[ + }]], [[ + new (&yyval) value_type (other.value ());]])[ + else + { + yyfirstVal = 0; + setFirstVal (other.firstVal ()); + }]b4_parse_assert_if([[ + check_();]])[ + } + + ~glr_state () + {]b4_parse_assert_if([[ + check_ ();]])[ + if (yyresolved) + {]b4_variant_if([[ + symbol_kind_type yykind = yy_accessing_symbol (yylrState); + // FIXME: User destructors. + // Value type destructor. + ]b4_symbol_variant([[yykind]], [[yyval]], [[template destroy]])])[ + yyval.~value_type (); + }]b4_parse_assert_if([[ + magic_ = 0;]])[ + } + + glr_state& operator= (const glr_state& other) + {]b4_parse_assert_if([[ + check_ (); + other.check_ ();]])[ + if (!yyresolved && other.yyresolved) + new (&yyval) value_type; + yyresolved = other.yyresolved; + yylrState = other.yylrState; + yyposn = other.yyposn; + setPred (other.pred ()); + if (other.yyresolved)]b4_variant_if([[ + ]b4_symbol_variant([yy_accessing_symbol (other.yylrState)], + [yyval], [copy], [other.value ()])], [[ + value () = other.value ();]])[ + else + setFirstVal (other.firstVal ());]b4_locations_if([[ + yyloc = other.yyloc;]])[ + return *this; + } + + /** Type tag for the semantic value. If true, yyval applies, otherwise + * yyfirstVal applies. */ + bool yyresolved; + /** Number of corresponding LALR(1) machine state. */ + state_num yylrState; + /** Source position of the last token produced by my symbol */ + size_t yyposn; + + /// Only call pred() and setPred() on objects in yyitems, not temporaries. + glr_state* pred (); + const glr_state* pred () const; + void setPred (const glr_state* state); + + /// Only call firstVal() and setFirstVal() on objects in yyitems, not + /// temporaries. + semantic_option* firstVal (); + const semantic_option* firstVal () const; + void setFirstVal (const semantic_option* option); + + value_type& value () + {]b4_parse_assert_if([[ + check_ ();]])[ + return yyval; + } + + const value_type& value () const + {]b4_parse_assert_if([[ + check_ ();]])[ + return yyval; + } + + void + destroy (char const *yymsg, ]b4_namespace_ref[::]b4_parser_class[& yyparser); + + /* DEBUGGING ONLY */ + #if ]b4_api_PREFIX[DEBUG + void yy_yypstack () const + {]b4_parse_assert_if([[ + check_ ();]])[ + if (pred () != YY_NULLPTR) + { + pred ()->yy_yypstack (); + std::cerr << " -> "; + } + std::cerr << yylrState << "@@" << yyposn; + } + #endif + + std::ptrdiff_t indexIn (const glr_stack_item* array) const YY_ATTRIBUTE_UNUSED; + + glr_stack_item* asItem () + {]b4_parse_assert_if([[ + check_ ();]])[ + return asItem(this); + } + + const glr_stack_item* asItem () const + {]b4_parse_assert_if([[ + check_ ();]])[ + return asItem (this); + } + + private: + template + static const glr_stack_item* asItem (const T* state) + { + return reinterpret_cast(state); + } + template + static glr_stack_item* asItem (T* state) + { + return reinterpret_cast (state); + } + static const char *as_pointer_ (const glr_state *state) + { + return reinterpret_cast (state); + } + static char *as_pointer_ (glr_state *state) + { + return reinterpret_cast (state); + } + /** Preceding state in this stack */ + std::ptrdiff_t yypred; + union { + /** First in a chain of alternative reductions producing the + * nonterminal corresponding to this state, threaded through + * yyfirstVal. Value "0" means empty. */ + std::ptrdiff_t yyfirstVal; + /** Semantic value for this state. */ + value_type yyval; + };]b4_locations_if([[ + // FIXME: Why public? + public: + /** Source location for this state. */ + location_type yyloc;]])[ + +]b4_parse_assert_if([[ + public: + // Check invariants. + void check_ () const + { + YY_IGNORE_NULL_DEREFERENCE_BEGIN + YYASSERT (this->magic_ == MAGIC); + YY_IGNORE_NULL_DEREFERENCE_END + } + + // A magic number to check our pointer arithmetic is sane. + enum { MAGIC = 713705 }; + unsigned int magic_;]])[ + }; // class ]b4_parser_class[::glr_state +} // namespace ]b4_namespace_ref[ + + +namespace +{ + /** A stack of GLRState representing the different heads during + * nondeterministic evaluation. */ + class glr_state_set + { + public: + /** Initialize YYSET to a singleton set containing an empty stack. */ + glr_state_set () + : yylastDeleted (YY_NULLPTR) + { + yystates.push_back (YY_NULLPTR); + yylookaheadNeeds.push_back (false); + } + + // Behave like a vector of states. + glr_state*& operator[] (state_set_index index) + { + return yystates[index.uget()]; + } + + glr_state* operator[] (state_set_index index) const + { + return yystates[index.uget()]; + } + + size_t size () const + { + return yystates.size (); + } + + std::vector::iterator begin () + { + return yystates.begin (); + } + + std::vector::iterator end () + { + return yystates.end (); + } + + bool lookaheadNeeds (state_set_index index) const + { + return yylookaheadNeeds[index.uget ()]; + } + + bool setLookaheadNeeds (state_set_index index, bool value) + { + return yylookaheadNeeds[index.uget ()] = value; + } + + /** Invalidate stack #YYK. */ + void + yymarkStackDeleted (state_set_index yyk) + { + size_t k = yyk.uget (); + if (yystates[k] != YY_NULLPTR) + yylastDeleted = yystates[k]; + yystates[k] = YY_NULLPTR; + } + + /** Undelete the last stack in *this that was marked as deleted. Can + only be done once after a deletion, and only when all other stacks have + been deleted. */ + void + yyundeleteLastStack () + { + if (yylastDeleted == YY_NULLPTR || !yystates.empty ()) + return; + yystates.push_back (yylastDeleted); + YYCDEBUG << "Restoring last deleted stack as stack #0.\n"; + clearLastDeleted (); + } + + /** Remove the dead stacks (yystates[i] == YY_NULLPTR) and shift the later + * ones. */ + void + yyremoveDeletes () + { + size_t newsize = yystates.size (); + /* j is the number of live stacks we have seen. */ + for (size_t i = 0, j = 0; j < newsize; ++i) + { + if (yystates[i] == YY_NULLPTR) + { + if (i == j) + { + YYCDEBUG << "Removing dead stacks.\n"; + } + newsize -= 1; + } + else + { + yystates[j] = yystates[i]; + /* In the current implementation, it's unnecessary to copy + yylookaheadNeeds[i] 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. */ + yylookaheadNeeds[j] = yylookaheadNeeds[i]; + if (j != i) + { + YYCDEBUG << "Rename stack " << i << " -> " << j << ".\n"; + } + j += 1; + } + } + yystates.resize (newsize); + yylookaheadNeeds.resize (newsize); + } + + + state_set_index + yysplitStack (state_set_index yyk) + { + const size_t k = yyk.uget (); + yystates.push_back (yystates[k]); + yylookaheadNeeds.push_back (yylookaheadNeeds[k]); + return create_state_set_index (static_cast (yystates.size () - 1)); + } + + void clearLastDeleted () + { + yylastDeleted = YY_NULLPTR; + } + + private: + + std::vector 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 !yyla.empty (). */ + std::vector yylookaheadNeeds; + + /** The last stack we invalidated. */ + glr_state* yylastDeleted; + }; // class glr_state_set +} // namespace + +namespace +{ + class semantic_option + { + public: + semantic_option () + : yyrule (0) + , yystate (0) + , yynext (0) + , yyla ()]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {} + + semantic_option (rule_num rule) + : yyrule (rule) + , yystate (0) + , yynext (0) + , yyla ()]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {} + + semantic_option (const semantic_option& that) + : yyrule (that.yyrule) + , yystate (that.yystate) + , yynext (that.yynext) + , yyla (that.yyla)]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {]b4_parse_assert_if([[ + that.check_ ();]])[ + } + + // Needed for the assignment in yynewSemanticOption. + semantic_option& operator= (const semantic_option& that) + {]b4_parse_assert_if([[ + check_ (); + that.check_ ();]])[ + yyrule = that.yyrule; + yystate = that.yystate; + yynext = that.yynext; + yyla = that.yyla; + return *this; + } + + /// Only call state() and setState() on objects in yyitems, not temporaries. + glr_state* state(); + const glr_state* state() const; + void setState(const glr_state* s); + + const semantic_option* next () const YY_ATTRIBUTE_UNUSED; + semantic_option* next (); + void setNext (const semantic_option* s); + + std::ptrdiff_t indexIn (const glr_stack_item* array) const YY_ATTRIBUTE_UNUSED; + + /** True iff YYY0 and YYY1 represent identical options at the top level. + * That is, they represent the same rule applied to RHS symbols + * that produce the same terminal symbols. */ + bool + isIdenticalTo (const semantic_option& yyy1) const + {]b4_parse_assert_if([[ + check_ (); + yyy1.check_ ();]])[ + if (this->yyrule == yyy1.yyrule) + { + const glr_state *yys0, *yys1; + int yyn; + for (yys0 = this->state(), + yys1 = yyy1.state(), + yyn = yyrhsLength (this->yyrule); + yyn > 0; + yys0 = yys0->pred(), + yys1 = yys1->pred(), yyn -= 1) + if (yys0->yyposn != yys1->yyposn) + return false; + return true; + } + else + return false; + } + + /** Assuming identicalOptions (YYY0,YYY1), destructively merge the + * alternative semantic values for the RHS-symbols of YYY1 and YYY0. */ + void + mergeWith (semantic_option& yyy1) + {]b4_parse_assert_if([[ + check_ (); + yyy1.check_ ();]])[ + glr_state *yys0 = this->state (); + glr_state *yys1 = yyy1.state (); + for (int yyn = yyrhsLength (this->yyrule); + yyn > 0; + yyn -= 1, yys0 = yys0->pred (), yys1 = yys1->pred ()) + { + if (yys0 == yys1) + break; + else if (yys0->yyresolved) + { + yys1->yyresolved = true;]b4_variant_if([[ + YYASSERT (yys1->yylrState == yys0->yylrState); + ]b4_symbol_variant([yy_accessing_symbol (yys0->yylrState)], + [yys1->value ()], [copy], [yys0->value ()])], [[ + yys1->value () = yys0->value ();]])[ + } + else if (yys1->yyresolved) + { + yys0->yyresolved = true;]b4_variant_if([[ + YYASSERT (yys0->yylrState == yys1->yylrState); + ]b4_symbol_variant([yy_accessing_symbol (yys1->yylrState)], + [yys0->value ()], [copy], [yys1->value ()])], [[ + yys0->value () = yys1->value ();]])[ + } + else + { + semantic_option* yyz0prev = YY_NULLPTR; + semantic_option* yyz0 = yys0->firstVal(); + semantic_option* yyz1 = yys1->firstVal(); + while (true) + { + if (yyz1 == yyz0 || yyz1 == YY_NULLPTR) + break; + else if (yyz0 == YY_NULLPTR) + { + if (yyz0prev != YY_NULLPTR) + yyz0prev->setNext (yyz1); + else + yys0->setFirstVal (yyz1); + break; + } + else if (yyz0 < yyz1) + { + semantic_option* yyz = yyz0; + if (yyz0prev != YY_NULLPTR) + yyz0prev->setNext(yyz1); + else + yys0->setFirstVal(yyz1); + yyz1 = yyz1->next(); + yyz0->setNext(yyz); + } + yyz0prev = yyz0; + yyz0 = yyz0->next(); + } + yys1->setFirstVal(yys0->firstVal()); + } + } + } + +#if ]b4_api_PREFIX[DEBUG + void yyreportTree (size_t yyindent = 2) const + {]b4_parse_assert_if([[ + check_ ();]])[ + int yynrhs = yyrhsLength (this->yyrule); + const glr_state* yystates[1 + YYMAXRHS]; + glr_state yyleftmost_state; + + { + const glr_state* yys = this->state(); + for (int yyi = yynrhs; 0 < yyi; yyi -= 1) + { + yystates[yyi] = yys; + yys = yys->pred(); + } + if (yys == YY_NULLPTR) + { + yyleftmost_state.yyposn = 0; + yystates[0] = &yyleftmost_state; + } + else + yystates[0] = yys; + } + + std::string yylhs = ]b4_namespace_ref[::]b4_parser_class[::symbol_name (yylhsNonterm (this->yyrule)); + YYASSERT(this->state()); + if (this->state()->yyposn < yystates[0]->yyposn + 1) + std::cerr << std::string(yyindent, ' ') << yylhs << " -> yyrule - 1 << ", empty>\n"; + else + std::cerr << std::string(yyindent, ' ') << yylhs << " -> yyrule - 1 << ", tokens " + << yystates[0]->yyposn + 1 << " .. " + << this->state()->yyposn << ">\n"; + for (int yyi = 1; yyi <= yynrhs; yyi += 1) + { + if (yystates[yyi]->yyresolved) + { + std::string yysym = ]b4_namespace_ref[::]b4_parser_class[::symbol_name (yy_accessing_symbol (yystates[yyi]->yylrState)); + if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) + std::cerr << std::string(yyindent + 2, ' ') << yysym + << " \n"; + else + std::cerr << std::string(yyindent + 2, ' ') << yysym + << " yyposn + 1 + << " .. " << yystates[yyi]->yyposn << ">\n"; + } + else + yystates[yyi]->firstVal ()->yyreportTree (yyindent+2); + } + } +#endif + + /** Rule number for this reduction */ + rule_num yyrule; + + private: + template + static const glr_stack_item* asItem(const T* state) + { + return reinterpret_cast(state); + } + template + static glr_stack_item* asItem(T* state) + { + return reinterpret_cast(state); + } + /** The last RHS state in the list of states to be reduced. */ + std::ptrdiff_t yystate; + /** Next sibling in chain of options. To facilitate merging, + * options are chained in decreasing order by address. */ + std::ptrdiff_t yynext; + + public: + /** The lookahead for this reduction. */ + symbol_type yyla; + +]b4_parse_assert_if([[ + public: + // Check invariants. + void check_ () const + { + YY_IGNORE_NULL_DEREFERENCE_BEGIN + YYASSERT (this->magic_ == MAGIC); + YY_IGNORE_NULL_DEREFERENCE_END + } + + // A magic number to check our pointer arithmetic is sane. + enum { MAGIC = 0xeff1cace }; + unsigned int magic_;]])[ + }; // class semantic_option +} // namespace + +namespace +{ + /** Type of the items in the GLR stack. + * It can be either a glr_state or a semantic_option. The is_state_ field + * indicates which item of the union is valid. */ + class glr_stack_item + { + public: + glr_stack_item (bool state = true) + : is_state_ (state)]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + { + if (is_state_) + new (&raw_) glr_state; + else + new (&raw_) semantic_option; + } + + glr_stack_item (const glr_stack_item& other) YY_NOEXCEPT YY_NOTHROW + : is_state_ (other.is_state_)]b4_parse_assert_if([[ + , magic_ (MAGIC)]])[ + {]b4_parse_assert_if([[ + other.check_ ();]])[ + std::memcpy (raw_, other.raw_, union_size); + } + + glr_stack_item& operator= (glr_stack_item other) + {]b4_parse_assert_if([[ + check_ (); + other.check_ ();]])[ + std::swap (is_state_, other.is_state_); + std::swap (raw_, other.raw_); + return *this; + } + + ~glr_stack_item () + {]b4_parse_assert_if([[ + check_ ();]])[ + if (is_state ()) + getState ().~glr_state (); + else + getOption ().~semantic_option (); + } + + void setState (const glr_state &state) + {]b4_parse_assert_if([[ + check_ (); + state.check_ ();]])[ + if (this != state.asItem ()) + { + if (is_state_) + getState ().~glr_state (); + else + getOption ().~semantic_option (); + new (&raw_) glr_state (state); + is_state_ = true; + } + } + + glr_state& getState () + {]b4_parse_assert_if([[ + check_ ();]])[ + YYDASSERT (is_state ()); + void *yyp = raw_; + glr_state& res = *static_cast (yyp);]b4_parse_assert_if([[ + res.check_ ();]])[ + return res; + } + + const glr_state& getState () const + {]b4_parse_assert_if([[ + check_ ();]])[ + YYDASSERT (is_state ()); + const void *yyp = raw_; + const glr_state& res = *static_cast (yyp);]b4_parse_assert_if([[ + res.check_ ();]])[ + return res; + } + + semantic_option& getOption () + {]b4_parse_assert_if([[ + check_ ();]])[ + YYDASSERT (!is_state ()); + void *yyp = raw_; + return *static_cast (yyp); + } + const semantic_option& getOption () const + {]b4_parse_assert_if([[ + check_ ();]])[ + YYDASSERT (!is_state ()); + const void *yyp = raw_; + return *static_cast (yyp); + } + bool is_state () const + {]b4_parse_assert_if([[ + check_ ();]])[ + return is_state_; + } + + private: + /// The possible contents of raw_. Since they have constructors, they cannot + /// be directly included in the union. + union contents + { + char yystate[sizeof (glr_state)]; + char yyoption[sizeof (semantic_option)]; + }; + enum { union_size = sizeof (contents) }; + union { + /// Strongest alignment constraints. + long double yyalign_me; + /// A buffer large enough to store the contents. + char raw_[union_size]; + }; + /** Type tag for the union. */ + bool is_state_; +]b4_parse_assert_if([[ + public: + // Check invariants. + void check_ () const + { + YYASSERT (this->magic_ == MAGIC); + YYASSERT (this->is_state_ == false || this->is_state_ == true); + } + // A magic number to check our pointer arithmetic is sane. + enum { MAGIC = 0xDEAD1ACC }; // 3735886540. + const unsigned int magic_;]])[ + }; // class glr_stack_item +} // namespace + +glr_state* glr_state::pred () +{]b4_parse_assert_if([[ + check_ ();]])[ + YY_IGNORE_NULL_DEREFERENCE_BEGIN + return yypred ? &asItem (as_pointer_ (this) - yypred)->getState () : YY_NULLPTR; + YY_IGNORE_NULL_DEREFERENCE_END +} + +const glr_state* glr_state::pred () const +{]b4_parse_assert_if([[ + check_ ();]])[ + YY_IGNORE_NULL_DEREFERENCE_BEGIN + return yypred ? &asItem (as_pointer_ (this) - yypred)->getState () : YY_NULLPTR; + YY_IGNORE_NULL_DEREFERENCE_END +} + +void glr_state::setPred (const glr_state* state) +{]b4_parse_assert_if([[ + check_ (); + if (state) + state->check_ ();]])[ + yypred = state ? as_pointer_ (this) - as_pointer_ (state) : 0; +} + +semantic_option* glr_state::firstVal () +{]b4_parse_assert_if([[ + check_ ();]])[ + return yyfirstVal ? &(asItem(this) - yyfirstVal)->getOption() : YY_NULLPTR; +} + +const semantic_option* glr_state::firstVal () const +{]b4_parse_assert_if([[ + check_ ();]])[ + return yyfirstVal ? &(asItem(this) - yyfirstVal)->getOption() : YY_NULLPTR; +} + +void glr_state::setFirstVal (const semantic_option* option) +{]b4_parse_assert_if([[ + check_ ();]])[ + yyfirstVal = option ? asItem(this) - asItem(option) : 0; +} + +std::ptrdiff_t glr_state::indexIn (const glr_stack_item* array) const +{]b4_parse_assert_if([[ + check_ ();]])[ + return asItem(this) - array; +} + +std::ptrdiff_t semantic_option::indexIn (const glr_stack_item* array) const +{ + return asItem(this) - array; +} + +glr_state* semantic_option::state () +{ + YY_IGNORE_NULL_DEREFERENCE_BEGIN + return yystate ? &(asItem(this) - yystate)->getState() : YY_NULLPTR; + YY_IGNORE_NULL_DEREFERENCE_END +} + +const glr_state* semantic_option::state () const +{ + return yystate ? &(asItem(this) - yystate)->getState() : YY_NULLPTR; +} + +void semantic_option::setState (const glr_state* s) +{ + yystate = s ? asItem(this) - asItem(s) : 0; +} + +const semantic_option* semantic_option::next () const +{ + return yynext ? &(asItem(this) - yynext)->getOption() : YY_NULLPTR; +} + +semantic_option* semantic_option::next () +{ + return yynext ? &(asItem(this) - yynext)->getOption() : YY_NULLPTR; +} + +void semantic_option::setNext (const semantic_option* s) +{ + yynext = s ? asItem(this) - asItem(s) : 0; +} + +void glr_state::destroy (char const* yymsg, ]b4_namespace_ref[::]b4_parser_class[& yyparser) +{]b4_parse_assert_if([[ + check_ ();]])[ + if (yyresolved) + yyparser.yy_destroy_ (yymsg, yy_accessing_symbol(yylrState), + value ()]b4_locations_if([, yyloc])[); + else + { +#if ]b4_api_PREFIX[DEBUG + YYCDEBUG << yymsg + << (firstVal() ? " unresolved " : " incomplete ") + << (yy_accessing_symbol (yylrState) < YYNTOKENS ? "token" : "nterm") + << ' ' << yyparser.symbol_name (yy_accessing_symbol (yylrState)) + << " ("]b4_locations_if([[ + << yyloc << ": "]])[ + << ")\n"; +#endif + if (firstVal() != YY_NULLPTR) + { + semantic_option& yyoption = *firstVal (); + glr_state *yyrh = yyoption.state (); + for (int yyn = yyrhsLength (yyoption.yyrule); yyn > 0; yyn -= 1) + { + yyrh->destroy (yymsg, yyparser); + yyrh = yyrh->pred(); + } + } + } +} + + +#undef YYFILL +#define YYFILL(N) yyfill (yyvsp, yylow, (N), yynormal) + +namespace +{ + class state_stack + { + public: + using parser_type = ]b4_namespace_ref[::]b4_parser_class[; + using symbol_kind = parser_type::symbol_kind; + using value_type = parser_type::value_type;]b4_locations_if([[ + using location_type = parser_type::location_type;]])[ + + /** Initialize to a single empty stack, with total maximum + * capacity for all stacks of YYSIZE. */ + state_stack (size_t yysize) + : yysplitPoint (YY_NULLPTR) + { + yyitems.reserve (yysize); + } + +#if YYSTACKEXPANDABLE + /** Returns false if it tried to expand but could not. */ + bool + yyexpandGLRStackIfNeeded () + { + return YYHEADROOM <= spaceLeft () || yyexpandGLRStack (); + } + + private: + /** If *this 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. */ + bool + yyexpandGLRStack () + { + const size_t oldsize = yyitems.size(); + if (YYMAXDEPTH - YYHEADROOM < oldsize) + return false; + const size_t yynewSize = YYMAXDEPTH < 2 * oldsize ? YYMAXDEPTH : 2 * oldsize; + const glr_stack_item *oldbase = &yyitems[0]; + + yyitems.reserve (yynewSize); + const glr_stack_item *newbase = &yyitems[0]; + + // Adjust the pointers. Perform raw pointer arithmetic, as there + // is no reason for objects to be aligned on their size. + const ptrdiff_t disp + = reinterpret_cast (newbase) - reinterpret_cast (oldbase); + if (yysplitPoint) + const_cast (yysplitPoint) + = reinterpret_cast (reinterpret_cast (const_cast (yysplitPoint)) + disp); + + for (std::vector::iterator + i = yytops.begin (), + yyend = yytops.end (); + i != yyend; ++i) + if (glr_state_not_null (*i)) + *i = reinterpret_cast(reinterpret_cast(*i) + disp); + + return true; + } + + public: +#else + bool yyexpandGLRStackIfNeeded () + { + return YYHEADROOM <= spaceLeft (); + } +#endif +#undef YYSTACKEXPANDABLE + + static bool glr_state_not_null (glr_state* s) + { + return s != YY_NULLPTR; + } + + bool + reduceToOneStack () + { + using iterator = std::vector::iterator; + const iterator yybegin = yytops.begin(); + const iterator yyend = yytops.end(); + const iterator yyit = std::find_if(yybegin, yyend, glr_state_not_null); + if (yyit == yyend) + return false; + for (state_set_index yyk = create_state_set_index(yyit + 1 - yybegin); + yyk.uget() != numTops(); ++yyk) + yytops.yymarkStackDeleted (yyk); + yytops.yyremoveDeletes (); + yycompressStack (); + return true; + } + + /** Called when returning to deterministic operation to clean up the extra + * stacks. */ + void + yycompressStack () + { + if (yytops.size() != 1 || !isSplit()) + return; + + // yyr is the state after the split point. + glr_state* yyr = YY_NULLPTR; + for (glr_state *yyp = firstTop(), *yyq = yyp->pred(); + yyp != yysplitPoint; + yyr = yyp, yyp = yyq, yyq = yyp->pred()) + yyp->setPred(yyr); + + // This const_cast is okay, since anyway we have access to the mutable + // yyitems into which yysplitPoint points. + glr_stack_item* nextFreeItem + = const_cast (yysplitPoint)->asItem () + 1; + yysplitPoint = YY_NULLPTR; + yytops.clearLastDeleted (); + + while (yyr != YY_NULLPTR) + { + nextFreeItem->setState (*yyr); + glr_state& nextFreeState = nextFreeItem->getState(); + yyr = yyr->pred(); + nextFreeState.setPred(&(nextFreeItem - 1)->getState()); + setFirstTop (&nextFreeState); + ++nextFreeItem; + } + yyitems.resize(static_cast(nextFreeItem - yyitems.data())); + } + + bool isSplit() const { + return yysplitPoint != YY_NULLPTR; + } + + // Present the interface of a vector of glr_stack_item. + std::vector::const_iterator begin () const + { + return yyitems.begin (); + } + + std::vector::const_iterator end () const + { + return yyitems.end (); + } + + size_t size() const + { + return yyitems.size (); + } + + glr_stack_item& operator[] (size_t i) + { + return yyitems[i]; + } + + glr_stack_item& stackItemAt (size_t index) + { + return yyitems[index]; + } + + size_t numTops () const + { + return yytops.size (); + } + + glr_state* firstTop () const + { + return yytops[create_state_set_index (0)]; + } + + glr_state* topAt (state_set_index i) const + { + return yytops[i]; + } + + void setFirstTop (glr_state* value) + { + yytops[create_state_set_index (0)] = value; + } + + void setTopAt (state_set_index i, glr_state* value) + { + yytops[i] = value; + } + + void pop_back () + { + yyitems.pop_back (); + } + + void pop_back (size_t n) + { + yyitems.resize (yyitems.size () - n); + } + + state_set_index + yysplitStack (state_set_index yyk) + { + if (!isSplit ()) + { + YYASSERT (yyk.get () == 0); + yysplitPoint = topAt (yyk); + } + return yytops.yysplitStack (yyk); + } + + /** Assuming that YYS is a GLRState somewhere on *this, update the + * splitpoint of *this, if needed, so that it is at least as deep as + * YYS. */ + void + yyupdateSplit (glr_state& yys) + { + if (isSplit() && &yys < yysplitPoint) + yysplitPoint = &yys; + } + + /** Return a fresh GLRState. + * Callers should call yyreserveStack afterwards to make sure there is + * sufficient headroom. */ + glr_state& yynewGLRState (const glr_state& newState) + { + glr_state& state = yyitems[yynewGLRStackItem (true)].getState (); +#if false && 201103L <= YY_CPLUSPLUS + state = std::move (newState); +#else + state = newState; +#endif + return state; + } + + /** Return a fresh SemanticOption. + * Callers should call yyreserveStack afterwards to make sure there is + * sufficient headroom. */ + semantic_option& yynewSemanticOption (semantic_option newOption) + { + semantic_option& option = yyitems[yynewGLRStackItem (false)].getOption (); + option = std::move (newOption); + return option; + } + + /* 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. */ + int + yyfill (glr_stack_item *yyvsp, int &yylow, int yylow1, bool yynormal) + { + if (!yynormal && yylow1 < yylow) + { + yyfillin (yyvsp, yylow, yylow1); + yylow = yylow1; + } + return yylow1; + } + + /** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting + * at YYVSP[YYLOW0].getState().pred(). Leaves YYVSP[YYLOW1].getState().pred() + * containing the pointer to the next state in the chain. */ + void + yyfillin (glr_stack_item *yyvsp, int yylow0, int yylow1) + { + glr_state* s = yyvsp[yylow0].getState().pred(); + YYASSERT(s != YY_NULLPTR); + for (int i = yylow0-1; i >= yylow1; i -= 1, s = s->pred()) + { + glr_state& yys = yyvsp[i].getState(); +#if ]b4_api_PREFIX[DEBUG + yys.yylrState = s->yylrState; +#endif + yys.yyresolved = s->yyresolved; + if (s->yyresolved) + {]b4_variant_if([[ + new (&yys.value ()) value_type (); + ]b4_symbol_variant([yy_accessing_symbol (s->yylrState)], + [yys.value ()], [copy], [s->value ()])], [[ + new (&yys.value ()) value_type (s->value ());]])[ + } + else + /* The effect of using yyval or yyloc (in an immediate + * rule) is undefined. */ + yys.setFirstVal (YY_NULLPTR);]b4_locations_if([[ + yys.yyloc = s->yyloc;]])[ + yys.setPred(s->pred()); + } + } + +#if ]b4_api_PREFIX[DEBUG + + /*----------------------------------------------------------------------. + | Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. | + `----------------------------------------------------------------------*/ + + void + yy_reduce_print (bool yynormal, glr_stack_item* yyvsp, state_set_index yyk, + rule_num yyrule, parser_type& yyparser) + { + int yynrhs = yyrhsLength (yyrule);]b4_locations_if([ + int yylow = 1;])[ + int yyi; + std::cerr << "Reducing stack " << yyk.get() << " by rule " << yyrule - 1 + << " (line " << int (yyrline[yyrule]) << "):\n"; + if (! yynormal) + yyfillin (yyvsp, 1, -yynrhs); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + std::cerr << " $" << yyi + 1 << " = "; + yyparser.yy_symbol_print_ + (yy_accessing_symbol (yyvsp[yyi - yynrhs + 1].getState().yylrState), + yyvsp[yyi - yynrhs + 1].getState().value ()]b4_locations_if([[, + ]b4_rhs_location(yynrhs, yyi + 1)])[); + if (!yyvsp[yyi - yynrhs + 1].getState().yyresolved) + std::cerr << " (unresolved)"; + std::cerr << '\n'; + } + } + + +#define YYINDEX(YYX) \ + ((YYX) == YY_NULLPTR ? -1 : (YYX)->indexIn (yyitems.data ())) + + void + dumpStack () const + { + for (size_t yyi = 0; yyi < size(); ++yyi) + { + const glr_stack_item& item = yyitems[yyi]; + std::cerr << std::setw(3) << yyi << ". "; + if (item.is_state()) + { + std::cerr << "Res: " << item.getState().yyresolved + << ", LR State: " << item.getState().yylrState + << ", posn: " << item.getState().yyposn + << ", pred: " << YYINDEX(item.getState().pred()); + if (! item.getState().yyresolved) + std::cerr << ", firstVal: " + << YYINDEX(item.getState().firstVal()); + } + else + { + std::cerr << "Option. rule: " << item.getOption().yyrule - 1 + << ", state: " << YYINDEX(item.getOption().state()) + << ", next: " << YYINDEX(item.getOption().next()); + } + std::cerr << '\n'; + } + std::cerr << "Tops:"; + for (state_set_index yyi = create_state_set_index(0); yyi.uget() < numTops(); ++yyi) { + std::cerr << yyi.get() << ": " << YYINDEX(topAt(yyi)) << "; "; + } + std::cerr << '\n'; + } + +#undef YYINDEX +#endif + + YYRESULTTAG + yyreportAmbiguity (const semantic_option& yyx0, + const semantic_option& yyx1, parser_type& yyparser]b4_locations_if([, const location_type& yyloc])[) + { + YY_USE (yyx0); + YY_USE (yyx1); + +#if ]b4_api_PREFIX[DEBUG + std::cerr << "Ambiguity detected.\n" + "Option 1,\n"; + yyx0.yyreportTree (); + std::cerr << "\nOption 2,\n"; + yyx1.yyreportTree (); + std::cerr << '\n'; +#endif + + yyparser.error (]b4_locations_if([yyloc, ])[YY_("syntax is ambiguous")); + return yyabort; + } + +#if ]b4_api_PREFIX[DEBUG + /* Print YYS (possibly NULL) and its predecessors. */ + void + yypstates (const glr_state* yys) const + { + if (yys != YY_NULLPTR) + yys->yy_yypstack(); + else + std::cerr << ""; + std::cerr << '\n'; + } +#endif + + private: + size_t spaceLeft() const + { + return yyitems.capacity() - yyitems.size(); + } + + /** Return a fresh GLRStackItem in this. The item is an LR state + * if YYIS_STATE, and otherwise a semantic option. Callers should call + * yyreserveStack afterwards to make sure there is sufficient + * headroom. */ + size_t + yynewGLRStackItem (bool yyis_state) + { + YYDASSERT(yyitems.size() < yyitems.capacity()); + yyitems.push_back(glr_stack_item(yyis_state)); + return yyitems.size() - 1; + } + + + public: + std::vector yyitems; + // Where the stack splits. Anything below this address is deterministic. + const glr_state* yysplitPoint; + glr_state_set yytops; + }; // class state_stack +} // namespace + +#undef YYFILL +#define YYFILL(N) yystateStack.yyfill (yyvsp, yylow, (N), yynormal) + +namespace ]b4_namespace_ref[ +{ + class ]b4_parser_class[::glr_stack + { + public: +]b4_parse_error_bmatch([custom\|detailed\|verbose], [[ + // Needs access to yypact_value_is_default, etc. + friend context; +]])[ + + glr_stack (size_t yysize, parser_type& yyparser_yyarg]m4_ifset([b4_parse_param], [, b4_parse_param_decl])[) + : yyerrState (0) + , yystateStack (yysize) + , yyerrcnt (0) + , yyla () + , yyparser (yyparser_yyarg)]m4_ifset([b4_parse_param], [,b4_parse_param_cons])[ + {} + + ~glr_stack () + { + if (!this->yyla.empty ()) + yyparser.yy_destroy_ ("Cleanup: discarding lookahead", + this->yyla.kind (), this->yyla.value]b4_locations_if([, this->yyla.location])[); + popall_ (); + } + + int yyerrState; +]b4_locations_if([[ /* To compute the location of the error token. */ + glr_stack_item yyerror_range[3];]])[ + state_stack yystateStack; + int yyerrcnt; + symbol_type yyla; + YYJMP_BUF yyexception_buffer; + parser_type& yyparser; + + #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 (false) + + int + parse () + { + int yyresult; + size_t yyposn; + + YYCDEBUG << "Starting parse\n"; + + this->yyla.clear (); +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yyla.value], [], [], [yyla.location])dnl + b4_user_initial_action +b4_dollar_popdef])[]dnl +[ + switch (YYSETJMP (this->yyexception_buffer)) + { + case 0: break; + case 1: goto yyabortlab; + case 2: goto yyexhaustedlab; + default: goto yybuglab; + } + this->yyglrShift (create_state_set_index(0), 0, 0, this->yyla.value]b4_locations_if([, this->yyla.location])[); + yyposn = 0; + + while (true) + { + /* For efficiency, we have two loops, the first of which is + specialized to deterministic operation (single stack, no + potential ambiguity). */ + /* Standard mode */ + while (true) + { + const state_num yystate = this->firstTopState()->yylrState; + YYCDEBUG << "Entering state " << yystate << '\n'; + if (yystate == YYFINAL) + goto yyacceptlab; + if (yy_is_defaulted_state (yystate)) + { + const rule_num yyrule = yy_default_action (yystate); + if (yyrule == 0) + {]b4_locations_if([[ + this->yyerror_range[1].getState().yyloc = this->yyla.location;]])[ + this->yyreportSyntaxError (); + goto yyuser_error; + } + YYCHK1 (this->yyglrReduce (create_state_set_index(0), yyrule, true)); + } + else + { + yyget_token (); + const short* yyconflicts; + const int yyaction = yygetLRActions (yystate, this->yyla.kind (), yyconflicts); + if (*yyconflicts != 0) + break; + if (yy_is_shift_action (yyaction)) + { + YY_SYMBOL_PRINT ("Shifting", this->yyla.kind (), this->yyla.value, this->yyla.location); + yyposn += 1; + // FIXME: we should move yylval. + this->yyglrShift (create_state_set_index(0), yyaction, yyposn, this->yyla.value]b4_locations_if([, this->yyla.location])[); + yyla.clear (); + if (0 < this->yyerrState) + this->yyerrState -= 1; + } + else if (yy_is_error_action (yyaction)) + {]b4_locations_if([[ + this->yyerror_range[1].getState().yyloc = this->yyla.location;]])[ + /* Don't issue an error message again for exceptions + thrown from the scanner. */ + if (this->yyla.kind () != ]b4_symbol(error, kind)[) + this->yyreportSyntaxError (); + goto yyuser_error; + } + else + YYCHK1 (this->yyglrReduce (create_state_set_index(0), -yyaction, true)); + } + } + + while (true) + { + for (state_set_index yys = create_state_set_index(0); yys.uget() < this->yystateStack.numTops(); ++yys) + this->yystateStack.yytops.setLookaheadNeeds(yys, !this->yyla.empty ()); + + /* 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 + (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 (state_set_index yys = create_state_set_index (0); yys.uget () < this->yystateStack.numTops (); ++yys) + YYCHK1 (this->yyprocessOneStack (yys, yyposn]b4_locations_if([, &this->yyla.location])[)); + this->yystateStack.yytops.yyremoveDeletes (); + if (this->yystateStack.yytops.size() == 0) + { + this->yystateStack.yytops.yyundeleteLastStack (); + if (this->yystateStack.yytops.size() == 0) + this->yyFail (]b4_locations_if([&this->yyla.location, ])[YY_("syntax error")); + YYCHK1 (this->yyresolveStack ()); + YYCDEBUG << "Returning to deterministic operation.\n";]b4_locations_if([[ + this->yyerror_range[1].getState ().yyloc = this->yyla.location;]])[ + this->yyreportSyntaxError (); + 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, yyla is emptied + before the loop to make sure the user destructor for yylval isn't + called twice. */ + symbol_kind_type yytoken_to_shift = this->yyla.kind (); + this->yyla.kind_ = ]b4_symbol(empty, kind)[; + yyposn += 1; + for (state_set_index yys = create_state_set_index (0); yys.uget () < this->yystateStack.numTops (); ++yys) + { + const state_num yystate = this->topState (yys)->yylrState; + const short* yyconflicts; + const int yyaction = yygetLRActions (yystate, yytoken_to_shift, yyconflicts); + /* Note that yyconflicts were handled by yyprocessOneStack. */ + YYCDEBUG << "On stack " << yys.get() << ", "; + YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, this->yyla.value, this->yyla.location); + this->yyglrShift (yys, yyaction, yyposn, this->yyla.value]b4_locations_if([, this->yyla.location])[); + YYCDEBUG << "Stack " << yys.get() << " now in state " + << this->topState(yys)->yylrState << '\n'; + } +]b4_variant_if([[ + // FIXME: User destructors. + // Value type destructor. + ]b4_symbol_variant([[yytoken_to_shift]], [[this->yyla.value]], [[template destroy]])])[ + + if (this->yystateStack.yytops.size () == 1) + { + YYCHK1 (this->yyresolveStack ()); + YYCDEBUG << "Returning to deterministic operation.\n"; + this->yystateStack.yycompressStack (); + break; + } + } + continue; + yyuser_error: + this->yyrecoverSyntaxError (]b4_locations_if([&this->yyla.location])[); + yyposn = this->firstTopState()->yyposn; + } + + yyacceptlab: + yyresult = 0; + goto yyreturn; + + yybuglab: + YYASSERT (false); + goto yyabortlab; + + yyabortlab: + yyresult = 1; + goto yyreturn; + + yyexhaustedlab: + yyparser.error (]b4_locations_if([this->yyla.location, ])[YY_("memory exhausted")); + yyresult = 2; + goto yyreturn; + + yyreturn: + return yyresult; + } + #undef YYCHK1 + + void yyreserveGlrStack () + { + if (!yystateStack.yyexpandGLRStackIfNeeded ()) + yyMemoryExhausted (); + } + + _Noreturn void + yyMemoryExhausted () + { + YYLONGJMP (yyexception_buffer, 2); + } + + _Noreturn void + yyFail (]b4_locations_if([location_type* yylocp, ])[const char* yymsg) + { + if (yymsg != YY_NULLPTR) + yyparser.error (]b4_locations_if([*yylocp, ])[yymsg); + YYLONGJMP (yyexception_buffer, 1); + } + + /* GLRStates */ + + + /** Add a new semantic action that will execute the action for rule + * YYRULE on the semantic values in YYRHS to the list of + * alternative actions for YYSTATE. Assumes that YYRHS comes from + * stack #YYK of *this. */ + void + yyaddDeferredAction (state_set_index yyk, glr_state* yystate, + glr_state* yyrhs, rule_num yyrule) + { + semantic_option& yyopt = yystateStack.yynewSemanticOption (semantic_option (yyrule)); + yyopt.setState (yyrhs); + yyopt.setNext (yystate->firstVal ()); + if (yystateStack.yytops.lookaheadNeeds (yyk)) + yyopt.yyla = this->yyla; + yystate->setFirstVal (&yyopt); + + yyreserveGlrStack (); + } + + #if ]b4_api_PREFIX[DEBUG + void yypdumpstack () const + { + yystateStack.dumpStack(); + } + #endif + + void + yyreportSyntaxError () + { + if (yyerrState != 0) + return; +]b4_parse_error_case( +[simple], [[ + std::string msg = YY_("syntax error"); + yyparser.error (]b4_join(b4_locations_if([yyla.location]), [[YY_MOVE (msg)]])[);]], +[custom], [[ + context yyctx (*this, yyla); + yyparser.report_syntax_error (yyctx);]], +[[ + context yyctx (*this, yyla); + std::string msg = yyparser.yysyntax_error_ (yyctx); + yyparser.error (]b4_join(b4_locations_if([yyla.location]), [[YY_MOVE (msg)]])[);]])[ + yyerrcnt += 1; + } + + /* Recover from a syntax error on this, assuming that yytoken, + yylval, and yylloc are the syntactic category, semantic value, and location + of the lookahead. */ + void + yyrecoverSyntaxError (]b4_locations_if([location_type* yylocp])[) + { + if (yyerrState == 3) + /* We just shifted the error token and (perhaps) took some + reductions. Skip tokens until we can proceed. */ + while (true) + { + if (this->yyla.kind () == ]b4_symbol(eof, kind)[) + yyFail (]b4_locations_if([yylocp, ])[YY_NULLPTR); + if (this->yyla.kind () != ]b4_symbol(empty, kind)[) + {]b4_locations_if([[ + /* We throw away the lookahead, but the error range + of the shifted error token must take it into account. */ + glr_state *yys = firstTopState(); + yyerror_range[1].getState().yyloc = yys->yyloc; + yyerror_range[2].getState().yyloc = this->yyla.location; + YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ + yyparser.yy_destroy_ ("Error: discarding", + this->yyla.kind (), this->yyla.value]b4_locations_if([, this->yyla.location])[);]b4_variant_if([[ + // Value type destructor. + ]b4_symbol_variant([[this->yyla.kind ()]], [[this->yyla.value]], [[template destroy]])])[ + this->yyla.kind_ = ]b4_symbol(empty, kind)[; + } + yyget_token (); + int yyj = yypact[firstTopState()->yylrState]; + if (yypact_value_is_default (yyj)) + return; + yyj += this->yyla.kind (); + if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != this->yyla.kind ()) + { + if (yydefact[firstTopState()->yylrState] != 0) + return; + } + else if (! yytable_value_is_error (yytable[yyj])) + return; + } + + if (!yystateStack.reduceToOneStack()) + yyFail (]b4_locations_if([yylocp, ])[YY_NULLPTR); + + /* Now pop stack until we find a state that shifts the error token. */ + yyerrState = 3; + while (firstTopState () != YY_NULLPTR) + { + glr_state *yys = firstTopState (); + int yyj = yypact[yys->yylrState]; + if (! yypact_value_is_default (yyj)) + { + yyj += YYTERROR; + if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR + && yy_is_shift_action (yytable[yyj])) + { + /* Shift the error token. */]b4_locations_if([[ + /* First adjust its location.*/ + location_type yyerrloc; + yyerror_range[2].getState().yyloc = this->yyla.location; + YYLLOC_DEFAULT (yyerrloc, (yyerror_range), 2);]])[ + YY_SYMBOL_PRINT ("Shifting", yy_accessing_symbol (yytable[yyj]), + this->yyla.value, yyerrloc); + yyglrShift (create_state_set_index(0), yytable[yyj], + yys->yyposn, yyla.value]b4_locations_if([, yyerrloc])[); + yys = firstTopState(); + break; + } + }]b4_locations_if([[ + yyerror_range[1].getState().yyloc = yys->yyloc;]])[ + if (yys->pred() != YY_NULLPTR) + yys->destroy ("Error: popping", yyparser); + yystateStack.setFirstTop(yys->pred()); + yystateStack.pop_back(); + } + if (firstTopState() == YY_NULLPTR) + yyFail (]b4_locations_if([yylocp, ])[YY_NULLPTR); + } + + YYRESULTTAG + yyprocessOneStack (state_set_index yyk, + size_t yyposn]b4_locations_if([, location_type* yylocp])[) + { + while (yystateStack.topAt(yyk) != YY_NULLPTR) + { + const state_num yystate = topState(yyk)->yylrState; + YYCDEBUG << "Stack " << yyk.get() + << " Entering state " << yystate << '\n'; + + YYASSERT (yystate != YYFINAL); + + if (yy_is_defaulted_state (yystate)) + { + const rule_num yyrule = yy_default_action (yystate); + if (yyrule == 0) + { + YYCDEBUG << "Stack " << yyk.get() << " dies.\n"; + yystateStack.yytops.yymarkStackDeleted (yyk); + return yyok; + } + const YYRESULTTAG yyflag + = yyglrReduce (yyk, yyrule, yyimmediate[yyrule]); + if (yyflag == yyerr) + { + YYCDEBUG << "Stack " << yyk.get() << " dies" + " (predicate failure or explicit user error).\n"; + yystateStack.yytops.yymarkStackDeleted (yyk); + return yyok; + } + if (yyflag != yyok) + return yyflag; + } + else + { + yystateStack.yytops.setLookaheadNeeds(yyk, true); + yyget_token (); + const short* yyconflicts; + const int yyaction = yygetLRActions (yystate, this->yyla.kind (), yyconflicts); + + for (; *yyconflicts != 0; ++yyconflicts) + { + state_set_index yynewStack = yystateStack.yysplitStack (yyk); + YYCDEBUG << "Splitting off stack " << yynewStack.get() + << " from " << yyk.get() << ".\n"; + YYRESULTTAG yyflag = + yyglrReduce (yynewStack, *yyconflicts, yyimmediate[*yyconflicts]); + if (yyflag == yyok) + YYCHK (yyprocessOneStack (yynewStack, + yyposn]b4_locations_if([, yylocp])[)); + else if (yyflag == yyerr) + { + YYCDEBUG << "Stack " << yynewStack.get() << " dies.\n"; + yystateStack.yytops.yymarkStackDeleted (yynewStack); + } + else + return yyflag; + } + + if (yy_is_shift_action (yyaction)) + break; + else if (yy_is_error_action (yyaction)) + { + YYCDEBUG << "Stack " << yyk.get() << " dies.\n"; + yystateStack.yytops.yymarkStackDeleted (yyk); + break; + } + else + { + YYRESULTTAG yyflag + = yyglrReduce (yyk, -yyaction, yyimmediate[-yyaction]); + if (yyflag == yyerr) + { + YYCDEBUG << "Stack " << yyk.get() << " dies" + " (predicate failure or explicit user error).\n"; + yystateStack.yytops.yymarkStackDeleted (yyk); + break; + } + else if (yyflag != yyok) + return yyflag; + } + } + } + return yyok; + } + + /** Perform user action for rule number YYN, with RHS length YYRHSLEN, + * and top stack item YYVSP. YYVALP 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. */ + YYRESULTTAG + yyuserAction (rule_num yyrule, int yyrhslen, glr_stack_item* yyvsp, state_set_index yyk, + value_type* yyvalp]b4_locations_if([, location_type* yylocp])[) + { + bool yynormal YY_ATTRIBUTE_UNUSED = !yystateStack.isSplit(); + int yylow = 1; +]b4_parse_param_use([yyvalp], [yylocp])dnl +[ YY_USE (yyk); + YY_USE (yyrhslen); + # undef yyerrok + # define yyerrok (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() (yyerrState != 0) + # undef yytoken + # define yytoken this->yyla.kind_ + # undef yyclearin + # define yyclearin (yytoken = ]b4_symbol(empty, kind)[) + # undef YYBACKUP + # define YYBACKUP(Token, Value) \ + return yyparser.error (]b4_locations_if([*yylocp, ])[YY_("syntax error: cannot back up")), \ + yyerrok, yyerr + +]b4_variant_if([[ + /* Variants are always initialized to an empty instance of the + correct type. The default '$$ = $1' action is NOT applied + when using variants. */ + // However we really need to prepare yyvsp now if we want to get + // correct locations, so invoke YYFILL for $1 anyway. + (void) YYFILL (1-yyrhslen); + ]b4_symbol_variant([[yylhsNonterm (yyrule)]], [(*yyvalp)], [emplace])], [[ + if (yyrhslen == 0) + *yyvalp = yyval_default; + else + *yyvalp = yyvsp[YYFILL (1-yyrhslen)].getState().value ();]])[]b4_locations_if([[ + /* Default location. */ + YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); + yyerror_range[1].getState().yyloc = *yylocp; +]])[ + /* If yyk == -1, we are running a deferred action on a temporary + stack. In that case, YY_REDUCE_PRINT must not play with YYFILL, + so pretend the stack is "normal". */ + YY_REDUCE_PRINT ((yynormal || yyk == create_state_set_index (-1), yyvsp, yyk, yyrule, yyparser)); + #if YY_EXCEPTIONS + try + { + #endif // YY_EXCEPTIONS + switch (yyrule) + { + ]b4_user_actions[ + default: break; + } + #if YY_EXCEPTIONS + } + catch (const syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what() << '\n';]b4_locations_if([ + *yylocp = yyexc.location;])[ + yyparser.error (]b4_locations_if([*yylocp, ])[yyexc.what ()); + YYERROR; + } + #endif // YY_EXCEPTIONS + YY_SYMBOL_PRINT ("-> $$ =", yylhsNonterm (yyrule), *yyvalp, *yylocp); + + return yyok; + # undef yyerrok + # undef YYABORT + # undef YYACCEPT + # undef YYERROR + # undef YYBACKUP + # undef yytoken + # undef yyclearin + # undef YYRECOVERING + } + + YYRESULTTAG + yyresolveStack () + { + if (yystateStack.isSplit ()) + { + int yyn = 0; + for (glr_state* yys = firstTopState (); + yys != yystateStack.yysplitPoint; + yys = yys->pred ()) + yyn += 1; + YYCHK (yyresolveStates (*firstTopState (), yyn)); + } + return yyok; + } + + /** Pop the symbols consumed by reduction #YYRULE from the top of stack + * #YYK of *YYSTACKP, and perform the appropriate semantic action on their + * semantic values. Assumes that all ambiguities in semantic values + * have been previously resolved. Set *YYVALP to the resulting value, + * and *YYLOCP to the computed location (if any). Return value is as + * for userAction. */ + YYRESULTTAG + yydoAction (state_set_index yyk, rule_num yyrule, + value_type* yyvalp]b4_locations_if([, location_type* yylocp])[) + { + const int yynrhs = yyrhsLength (yyrule); + + if (!yystateStack.isSplit()) + { + /* Standard special case: single stack. */ + YYASSERT (yyk.get() == 0); + glr_stack_item* yyrhs = yystateStack.firstTop()->asItem(); + const YYRESULTTAG res + = yyuserAction (yyrule, yynrhs, yyrhs, yyk, yyvalp]b4_locations_if([, yylocp])[); + yystateStack.pop_back(static_cast(yynrhs)); + yystateStack.setFirstTop(&yystateStack[yystateStack.size() - 1].getState()); + return res; + } + else + { + glr_stack_item yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + glr_state* yys = yystateStack.topAt(yyk); + yyrhsVals[YYMAXRHS + YYMAXLEFT].getState().setPred(yys);]b4_locations_if([[ + if (yynrhs == 0) + /* Set default location. */ + yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].getState().yyloc = yys->yyloc;]])[ + for (int yyi = 0; yyi < yynrhs; yyi += 1) + { + yys = yys->pred(); + YYASSERT (yys != YY_NULLPTR); + } + yystateStack.yyupdateSplit (*yys); + yystateStack.setTopAt(yyk, yys); + return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + yyk, + yyvalp]b4_locations_if([, yylocp])[); + } + } + + /** Pop items off stack #YYK of *YYSTACKP according to grammar rule YYRULE, + * and push back on the resulting nonterminal symbol. Perform the + * semantic action associated with YYRULE and store its value with the + * newly pushed state, if YYFORCEEVAL or if *YYSTACKP is currently + * unambiguous. Otherwise, store the deferred semantic action with + * the new state. If the new state would have an identical input + * position, LR state, and predecessor to an existing state on the stack, + * it is identified with that existing state, eliminating stack #YYK from + * *YYSTACKP. In this case, the semantic value is + * added to the options for the existing state's semantic value. + */ + YYRESULTTAG + yyglrReduce (state_set_index yyk, rule_num yyrule, bool yyforceEval) + { + size_t yyposn = topState(yyk)->yyposn; + + if (yyforceEval || !yystateStack.isSplit()) + { + value_type val;]b4_locations_if([[ + location_type loc;]])[ + + YYRESULTTAG yyflag = yydoAction (yyk, yyrule, &val]b4_locations_if([, &loc])[); + if (yyflag == yyerr && yystateStack.isSplit()) + {]b4_parse_trace_if([[ + YYCDEBUG << "Parse on stack " << yyk.get () + << " rejected by rule " << yyrule - 1 + << " (line " << int (yyrline[yyrule]) << ").\n"; + ]])[} + if (yyflag != yyok) + return yyflag; + yyglrShift (yyk, + yyLRgotoState (topState(yyk)->yylrState, + yylhsNonterm (yyrule)), + yyposn, val]b4_locations_if([, loc])[);]b4_variant_if([[ + // FIXME: User destructors. + // Value type destructor. + ]b4_symbol_variant([[yylhsNonterm (yyrule)]], [[val]], [[template destroy]])])[ + } + else + { + glr_state *yys = yystateStack.topAt(yyk); + glr_state *yys0 = yys; + for (int yyn = yyrhsLength (yyrule); 0 < yyn; yyn -= 1) + { + yys = yys->pred(); + YYASSERT (yys != YY_NULLPTR); + } + yystateStack.yyupdateSplit (*yys); + state_num yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));]b4_parse_trace_if([[ + YYCDEBUG << "Reduced stack " << yyk.get () + << " by rule " << yyrule - 1 << " (line " << int (yyrline[yyrule]) + << "); action deferred. Now in state " << yynewLRState + << ".\n";]])[ + for (state_set_index yyi = create_state_set_index(0); yyi.uget() < yystateStack.numTops(); ++yyi) + if (yyi != yyk && yystateStack.topAt(yyi) != YY_NULLPTR) + { + const glr_state* yysplit = yystateStack.yysplitPoint; + glr_state* yyp = yystateStack.topAt(yyi); + while (yyp != yys && yyp != yysplit + && yyp->yyposn >= yyposn) + { + if (yyp->yylrState == yynewLRState + && yyp->pred() == yys) + { + yyaddDeferredAction (yyk, yyp, yys0, yyrule); + yystateStack.yytops.yymarkStackDeleted (yyk); + YYCDEBUG << "Merging stack " << yyk.get () + << " into stack " << yyi.get () << ".\n"; + return yyok; + } + yyp = yyp->pred(); + } + } + yystateStack.setTopAt(yyk, yys); + yyglrShiftDefer (yyk, yynewLRState, yyposn, yys0, yyrule); + } + return yyok; + } + + /** Shift stack #YYK of *YYSTACKP, to a new state corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with the (unresolved) + * semantic value of YYRHS under the action for YYRULE. */ + void + yyglrShiftDefer (state_set_index yyk, state_num yylrState, + size_t yyposn, glr_state* yyrhs, rule_num yyrule) + { + glr_state& yynewState = yystateStack.yynewGLRState ( + glr_state (yylrState, yyposn)); + yynewState.setPred (yystateStack.topAt (yyk)); + yystateStack.setTopAt (yyk, &yynewState); + + /* Invokes yyreserveStack. */ + yyaddDeferredAction (yyk, &yynewState, yyrhs, yyrule); + } + + /** Shift to a new state on stack #YYK of *YYSTACKP, corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with (resolved) semantic + * value YYVAL_ARG and source location YYLOC_ARG. */ + void + yyglrShift (state_set_index yyk, state_num yylrState, + size_t yyposn, + const value_type& yyval_arg]b4_locations_if([, const location_type& yyloc_arg])[) + { + glr_state& yynewState = yystateStack.yynewGLRState ( + glr_state (yylrState, yyposn, yyval_arg]b4_locations_if([, yyloc_arg])[)); + yynewState.setPred (yystateStack.topAt(yyk)); + yystateStack.setTopAt (yyk, &yynewState); + yyreserveGlrStack (); + } + +#if ]b4_api_PREFIX[DEBUG + void + yypstack (state_set_index yyk) const + { + yystateStack.yypstates (yystateStack.topAt (yyk)); + } +#endif + + glr_state* topState(state_set_index i) { + return yystateStack.topAt(i); + } + + glr_state* firstTopState() { + return yystateStack.firstTop(); + } + + private: + + void popall_ () + { + /* 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. */ + for (state_set_index k = create_state_set_index(0); k.uget() < yystateStack.numTops(); k += 1) + if (yystateStack.topAt(k) != YY_NULLPTR) + { + while (yystateStack.topAt(k) != YY_NULLPTR) + { + glr_state* state = topState(k);]b4_locations_if([[ + yyerror_range[1].getState().yyloc = state->yyloc;]])[ + if (state->pred() != YY_NULLPTR) + state->destroy ("Cleanup: popping", yyparser); + yystateStack.setTopAt(k, state->pred()); + yystateStack.pop_back(); + } + break; + } + } + + /** Resolve the previous YYN states starting at and including state YYS + * on *YYSTACKP. If result != yyok, some states may have been left + * unresolved possibly with empty semantic option chains. Regardless + * of whether result = yyok, each state has been left with consistent + * data so that destroy can be invoked if necessary. */ + YYRESULTTAG + yyresolveStates (glr_state& yys, int yyn) + { + if (0 < yyn) + { + YYASSERT (yys.pred() != YY_NULLPTR); + YYCHK (yyresolveStates (*yys.pred(), yyn-1)); + if (! yys.yyresolved) + YYCHK (yyresolveValue (yys)); + } + return yyok; + } + + static void + yyuserMerge (int yyn, value_type& yy0, value_type& yy1) + { + YY_USE (yy0); + YY_USE (yy1); + + switch (yyn) + { +]b4_mergers[ + default: break; + } + } + + /** Resolve the ambiguity represented in state YYS in *YYSTACKP, + * perform the indicated actions, and set the semantic value of YYS. + * If result != yyok, the chain of semantic options in YYS has been + * cleared instead or it has been left unmodified except that + * redundant options may have been removed. Regardless of whether + * result = yyok, YYS has been left with consistent data so that + * destroy can be invoked if necessary. */ + YYRESULTTAG + yyresolveValue (glr_state& yys) + { + semantic_option* yybest = yys.firstVal(); + YYASSERT(yybest != YY_NULLPTR); + bool yymerge = false; + YYRESULTTAG yyflag;]b4_locations_if([ + location_type *yylocp = &yys.yyloc;])[ + + semantic_option* yypPrev = yybest; + for (semantic_option* yyp = yybest->next(); + yyp != YY_NULLPTR; ) + { + if (yybest->isIdenticalTo (*yyp)) + { + yybest->mergeWith (*yyp); + yypPrev->setNext(yyp->next()); + yyp = yypPrev->next(); + } + else + { + switch (yypreference (*yybest, *yyp)) + { + case 0:]b4_locations_if([[ + yyresolveLocations (yys, 1);]])[ + return yystateStack.yyreportAmbiguity (*yybest, *yyp, yyparser]b4_locations_if([, *yylocp])[); + break; + case 1: + yymerge = true; + break; + case 2: + break; + case 3: + yybest = yyp; + yymerge = false; + break; + default: + /* This cannot happen so it is not worth a YYASSERT (false), + but some compilers complain if the default case is + omitted. */ + break; + } + yypPrev = yyp; + yyp = yyp->next(); + } + } + + value_type val; + if (yymerge) + { + int yyprec = yydprec[yybest->yyrule]; + yyflag = yyresolveAction (*yybest, &val]b4_locations_if([, yylocp])[); + if (yyflag == yyok) + for (semantic_option* yyp = yybest->next(); + yyp != YY_NULLPTR; + yyp = yyp->next()) + { + if (yyprec == yydprec[yyp->yyrule]) + { + value_type yyval_other;]b4_locations_if([ + location_type yydummy;])[ + yyflag = yyresolveAction (*yyp, &yyval_other]b4_locations_if([, &yydummy])[); + if (yyflag != yyok) + { + yyparser.yy_destroy_ ("Cleanup: discarding incompletely merged value for", + yy_accessing_symbol (yys.yylrState), + this->yyla.value]b4_locations_if([, *yylocp])[); + break; + } + yyuserMerge (yymerger[yyp->yyrule], val, yyval_other);]b4_variant_if([[ + // FIXME: User destructors. + // Value type destructor. + ]b4_symbol_variant([[yy_accessing_symbol (yys.yylrState)]], [[yyval_other]], [[template destroy]])])[ + } + } + } + else + yyflag = yyresolveAction (*yybest, &val]b4_locations_if([, yylocp])[); + + if (yyflag == yyok) + { + yys.yyresolved = true; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN]b4_variant_if([[ + new (&yys.value ()) value_type (); + ]b4_symbol_variant([yy_accessing_symbol (yys.yylrState)], + [yys.value ()], [copy], [val])], [[ + new (&yys.value ()) value_type (val);]])[ + + YY_IGNORE_MAYBE_UNINITIALIZED_END + } + else + yys.setFirstVal(YY_NULLPTR); +]b4_variant_if([[ + // FIXME: User destructors. + // Value type destructor. + ]b4_symbol_variant([[yy_accessing_symbol (yys.yylrState)]], [[val]], [[template destroy]])])[ + return yyflag; + } + + /** Resolve the states for the RHS of YYOPT on *YYSTACKP, perform its + * user action, and return the semantic value and location in *YYVALP + * and *YYLOCP. Regardless of whether result = yyok, all RHS states + * have been destroyed (assuming the user action destroys all RHS + * semantic values if invoked). */ + YYRESULTTAG + yyresolveAction (semantic_option& yyopt, value_type* yyvalp]b4_locations_if([, location_type* yylocp])[) + { + glr_state* yyoptState = yyopt.state(); + YYASSERT(yyoptState != YY_NULLPTR); + int yynrhs = yyrhsLength (yyopt.yyrule); + YYRESULTTAG yyflag = yyresolveStates (*yyoptState, yynrhs); + if (yyflag != yyok) + { + for (glr_state *yys = yyoptState; yynrhs > 0; yys = yys->pred(), yynrhs -= 1) + yys->destroy ("Cleanup: popping", yyparser); + return yyflag; + } + + glr_stack_item yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + yyrhsVals[YYMAXRHS + YYMAXLEFT].getState().setPred(yyopt.state());]b4_locations_if([[ + if (yynrhs == 0) + /* Set default location. */ + yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].getState().yyloc = yyoptState->yyloc;]])[ + { + symbol_type yyla_current = std::move (this->yyla); + this->yyla = std::move (yyopt.yyla); + yyflag = yyuserAction (yyopt.yyrule, yynrhs, + yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + create_state_set_index (-1), + yyvalp]b4_locations_if([, yylocp])[); + this->yyla = std::move (yyla_current); + } + return yyflag; + }]b4_locations_if([[ + + /** Resolve the locations for each of the YYN1 states in *YYSTACKP, + * ending at YYS1. Has no effect on previously resolved states. + * The first semantic option of a state is always chosen. */ + void + yyresolveLocations (glr_state &yys1, int yyn1) + { + if (0 < yyn1) + { + yyresolveLocations (*yys1.pred(), yyn1 - 1); + if (!yys1.yyresolved) + { + glr_stack_item yyrhsloc[1 + YYMAXRHS]; + YYASSERT (yys1.firstVal() != YY_NULLPTR); + semantic_option& yyoption = *yys1.firstVal(); + const int yynrhs = yyrhsLength (yyoption.yyrule); + if (0 < yynrhs) + { + yyresolveLocations (*yyoption.state(), yynrhs); + const glr_state *yys = yyoption.state(); + for (int yyn = yynrhs; yyn > 0; yyn -= 1) + { + yyrhsloc[yyn].getState().yyloc = yys->yyloc; + yys = yys->pred(); + } + } + 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. */ + YY_IGNORE_NULL_DEREFERENCE_BEGIN + yyrhsloc[0].getState().yyloc = yyoption.state()->yyloc; + YY_IGNORE_NULL_DEREFERENCE_END + } + YYLLOC_DEFAULT ((yys1.yyloc), yyrhsloc, yynrhs); + } + } + }]])[ + + /** If yytoken is empty, fetch the next token. */ + void + yyget_token () + { +]b4_parse_param_use()dnl +[ if (this->yyla.empty ()) + { + YYCDEBUG << "Reading a token\n"; +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + {]b4_token_ctor_if([[ + symbol_type yylookahead (]b4_yylex[); + yyla.move (yylookahead);]], [[ + yyla.kind_ = yyparser.yytranslate_ (]b4_yylex[);]])[ + } +#if YY_EXCEPTIONS + catch (const parser_type::syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what () << '\n';]b4_locations_if([ + this->yyla.location = yyexc.location;])[ + yyparser.error (]b4_locations_if([this->yyla.location, ])[yyexc.what ()); + // Map errors caught in the scanner to the error token, so that error + // handling is started. + this->yyla.kind_ = ]b4_symbol(error, kind)[; + } + } +#endif // YY_EXCEPTIONS + if (this->yyla.kind () == ]b4_symbol(eof, kind)[) + YYCDEBUG << "Now at end of input.\n"; + else + YY_SYMBOL_PRINT ("Next token is", this->yyla.kind (), this->yyla.value, this->yyla.location); + } + + + /* Bison grammar-table manipulation. */ + + /** The action to take in YYSTATE on seeing YYTOKEN. + * Result R means + * R < 0: Reduce on rule -R. + * R = 0: Error. + * R > 0: Shift to state R. + * Set *YYCONFLICTS to a pointer into yyconfl to a 0-terminated list + * of conflicting reductions. + */ + static int + yygetLRActions (state_num yystate, symbol_kind_type yytoken, const short*& yyconflicts) + { + int yyindex = yypact[yystate] + yytoken; + if (yytoken == ]b4_symbol(error, kind)[) + { + // This is the error token. + yyconflicts = yyconfl; + return 0; + } + else if (yy_is_defaulted_state (yystate) + || yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) + { + yyconflicts = yyconfl; + return -yydefact[yystate]; + } + else if (! yytable_value_is_error (yytable[yyindex])) + { + yyconflicts = yyconfl + yyconflp[yyindex]; + return yytable[yyindex]; + } + else + { + yyconflicts = yyconfl + yyconflp[yyindex]; + return 0; + } + } + + /** Compute post-reduction state. + * \param yystate the current state + * \param yysym the nonterminal to push on the stack + */ + static state_num + yyLRgotoState (state_num yystate, symbol_kind_type yysym) + { + const int yyr = yypgoto[yysym - YYNTOKENS] + yystate; + if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) + return yytable[yyr]; + else + return yydefgoto[yysym - YYNTOKENS]; + } + + static bool + yypact_value_is_default (state_num yystate) + { + return ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf], [YYPACT_NINF])[; + } + + static bool + yytable_value_is_error (int yytable_value YY_ATTRIBUTE_UNUSED) + { + return ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf], [YYTABLE_NINF])[; + } + + static bool + yy_is_shift_action (int yyaction) YY_NOEXCEPT + { + return 0 < yyaction; + } + + static bool + yy_is_error_action (int yyaction) YY_NOEXCEPT + { + return yyaction == 0; + } + + /** Whether LR state YYSTATE has only a default reduction + * (regardless of token). */ + static bool + yy_is_defaulted_state (state_num yystate) + { + return yypact_value_is_default (yypact[yystate]); + } + + /** The default reduction for YYSTATE, assuming it has one. */ + static rule_num + yy_default_action (state_num yystate) + { + return yydefact[yystate]; + } + + /* GLRStacks */ + + /** 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 (const semantic_option& y0, const semantic_option& y1) + { + const rule_num r0 = y0.yyrule, r1 = y1.yyrule; + const int p0 = yydprec[r0], p1 = yydprec[r1]; + + if (p0 == p1) + { + if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1]) + return 0; + else + return 1; + } + else if (p0 == 0 || p1 == 0) + return 0; + else if (p0 < p1) + return 3; + else if (p1 < p0) + return 2; + else + return 0; + } + +]b4_parse_param_vars[ + }; // class ]b4_parser_class[::glr_stack +} // namespace ]b4_namespace_ref[ + + +#if ]b4_api_PREFIX[DEBUG +namespace +{ + void + yypstack (const glr_stack& yystack, size_t yyk) + { + yystack.yypstack (create_state_set_index (static_cast (yyk))); + } + + void + yypdumpstack (const glr_stack& yystack) + { + yystack.yypdumpstack (); + } +} +#endif + +]b4_namespace_open[ + /// Build a parser object. + ]b4_parser_class::b4_parser_class[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ + :])[ +#if ]b4_api_PREFIX[DEBUG + ]m4_ifset([b4_parse_param], [ ], [ :])[yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ +#endif]b4_parse_param_cons[ + {} + + ]b4_parser_class::~b4_parser_class[ () + {} + + ]b4_parser_class[::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW + {} + + int + ]b4_parser_class[::operator() () + { + return parse (); + } + + int + ]b4_parser_class[::parse () + { + glr_stack yystack(YYINITDEPTH, *this]b4_user_args[); + return yystack.parse (); + } + +]b4_parse_error_bmatch([custom\|detailed], +[[ const char * + ]b4_parser_class[::symbol_name (symbol_kind_type yysymbol) + { + static const char *const yy_sname[] = + { + ]b4_symbol_names[ + };]b4_has_translations_if([[ + /* YYTRANSLATABLE[SYMBOL-NUM] -- Whether YY_SNAME[SYMBOL-NUM] is + internationalizable. */ + static ]b4_int_type_for([b4_translatable])[ yytranslatable[] = + { + ]b4_translatable[ + }; + return (yysymbol < YYNTOKENS && yytranslatable[yysymbol] + ? _(yy_sname[yysymbol]) + : yy_sname[yysymbol]);]], [[ + return yy_sname[yysymbol];]])[ + } +]], +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + const char * + ]b4_parser_class[::symbol_name (symbol_kind_type yysymbol) + { + return yytname_[yysymbol]; + } +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[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[::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; + else + goto append; + + append: + default: + yyr += *yyp; + break; + + case '"': + return yyr; + } + do_not_strip_quotes: ; + } + + return yystr; + } + + std::string + ]b4_parser_class[::symbol_name (symbol_kind_type yysymbol) + { + return yytnamerr_ (yytname_[yysymbol]); + } +]])[ + +]b4_parse_error_bmatch([simple\|verbose], +[[#if ]b4_api_PREFIX[DEBUG]b4_tname_if([[ || 1]])[ + // 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[::yytname_[] = + { + ]b4_tname[ + }; +#endif +]])[ + +]b4_parse_error_bmatch([custom\|detailed\|verbose], [[ + // ]b4_parser_class[::context. + ]b4_parser_class[::context::context (glr_stack& yystack, const symbol_type& yyla) + : yystack_ (yystack) + , yyla_ (yyla) + {} + + int + ]b4_parser_class[::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const + { + // Actual number of expected tokens + int yycount = 0; + const int yyn = yypact[yystack_.firstTopState()->yylrState]; + if (!yystack_.yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for this + state because they are default actions. */ + const int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + const int yychecklim = YYLAST - yyn + 1; + const int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != ]b4_symbol(error, kind)[ + && !yystack_.yytable_value_is_error (yytable[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (symbol_kind_type, yyx); + } + } + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = ]b4_symbol(empty, kind)[; + return yycount; + } + +]])[ + +]b4_parse_error_bmatch([detailed\|verbose], [[ + int + ]b4_parser_class[::yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const + { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yyla) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is + a consistent state with a default action. There might have + been a previous inconsistent state, consistent state with a + non-default action, or user semantic action that manipulated + yyla. (However, yyla is currently not documented for users.) + */ + + if (!yyctx.lookahead ().empty ()) + { + if (yyarg) + yyarg[0] = yyctx.token (); + int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1); + return yyn + 1; + } + return 0; + } + + // Generate an error message. + std::string + ]b4_parser_class[::yysyntax_error_ (const context& yyctx) const + { + // Its maximum. + enum { YYARGS_MAX = 5 }; + // Arguments of yyformat. + symbol_kind_type yyarg[YYARGS_MAX]; + int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX); + + char const* yyformat = YY_NULLPTR; + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: // Avoid compiler warnings. + YYCASE_ (0, YY_("syntax error")); + YYCASE_ (1, YY_("syntax error, unexpected %s")); + YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + std::string yyres; + // Argument number. + std::ptrdiff_t yyi = 0; + for (char const* yyp = yyformat; *yyp; ++yyp) + if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) + { + yyres += symbol_name (yyarg[yyi++]); + ++yyp; + } + else + yyres += *yyp; + return yyres; + }]])[ + + void + ]b4_parser_class[::yy_destroy_ (const char* yymsg, symbol_kind_type yykind, + value_type& yyval]b4_locations_if([[, + location_type& yyloc]])[) + { + YY_USE (yyval);]b4_locations_if([[ + YY_USE (yyloc);]])[ + if (!yymsg) + yymsg = "Deleting"; + ]b4_parser_class[& yyparser = *this; + YY_USE (yyparser); + YY_SYMBOL_PRINT (yymsg, yykind, yyval, yyloc); + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + ]m4_do([m4_pushdef([b4_symbol_action], m4_defn([b4_symbol_action_for_yyval]))], + [b4_symbol_actions([destructor])], + [m4_popdef([b4_symbol_action])])[ + YY_IGNORE_MAYBE_UNINITIALIZED_END + } + +#if ]b4_api_PREFIX[DEBUG + /*--------------------. + | Print this symbol. | + `--------------------*/ + + void + ]b4_parser_class[::yy_symbol_value_print_ (symbol_kind_type yykind, + const value_type& yyval]b4_locations_if([[, + const location_type& yyloc]])[) const + {]b4_locations_if([[ + YY_USE (yyloc);]])[ + YY_USE (yyval); + std::ostream& yyo = debug_stream (); + YY_USE (yyo); + ]m4_do([m4_pushdef([b4_symbol_action], m4_defn([b4_symbol_action_for_yyval]))], + [b4_symbol_actions([printer])], + [m4_popdef([b4_symbol_action])])[ + } + + void + ]b4_parser_class[::yy_symbol_print_ (symbol_kind_type yykind, + const value_type& yyval]b4_locations_if([[, + const location_type& yyloc]])[) const + { + *yycdebug_ << (yykind < YYNTOKENS ? "token" : "nterm") + << ' ' << symbol_name (yykind) << " ("]b4_locations_if([[ + << yyloc << ": "]])[; + yy_symbol_value_print_ (yykind, yyval]b4_locations_if([[, yyloc]])[); + *yycdebug_ << ')'; + } + + std::ostream& + ]b4_parser_class[::debug_stream () const + { + return *yycdebug_; + } + + void + ]b4_parser_class[::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + ]b4_parser_class[::debug_level_type + ]b4_parser_class[::debug_level () const + { + return yydebug; + } + + void + ]b4_parser_class[::set_debug_level (debug_level_type l) + { + // Actually, it is yydebug which is really used. + yydebug = l; + } +#endif // ]b4_api_PREFIX[DEBUG + +]b4_token_ctor_if([], [b4_yytranslate_define([cc])])[ + +]b4_token_ctor_if([], [[ + /*---------. + | symbol. | + `---------*/ +]b4_public_types_define([cc])])[ +]b4_namespace_close[]dnl +b4_epilogue[]dnl +b4_output_end diff --git a/compiler/win_flex_bison/data/skeletons/java-skel.m4 b/compiler/win_flex_bison/data/skeletons/java-skel.m4 new file mode 100644 index 0000000..11cbc49 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/java-skel.m4 @@ -0,0 +1,27 @@ + -*- Autoconf -*- + +# Java skeleton dispatching for Bison. + +# Copyright (C) 2007, 2009-2015, 2018-2021 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_skeletonsdir/[lalr1.java]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/compiler/win_flex_bison/data/skeletons/java.m4 b/compiler/win_flex_bison/data/skeletons/java.m4 new file mode 100644 index 0000000..8b0828b --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/java.m4 @@ -0,0 +1,502 @@ + -*- Autoconf -*- + +# Java language support for Bison + +# Copyright (C) 2007-2015, 2018-2021 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_skeletonsdir/[c-like.m4]) + + +# b4_list2(LIST1, LIST2) +# ---------------------- +# Join two lists with a comma if necessary. +m4_define([b4_list2], + [$1[]m4_ifval(m4_quote($1), [m4_ifval(m4_quote($2), [[, ]])])[]$2]) + + +# b4_percent_define_get3(DEF, PRE, POST, NOT) +# ------------------------------------------- +# Expand to the value of DEF surrounded by PRE and POST if it's %define'ed, +# otherwise NOT. +m4_define([b4_percent_define_get3], + [m4_ifval(m4_quote(b4_percent_define_get([$1])), + [$2[]b4_percent_define_get([$1])[]$3], [$4])]) + + + +# b4_flag_value(BOOLEAN-FLAG) +# --------------------------- +m4_define([b4_flag_value], [b4_flag_if([$1], [true], [false])]) + + +# b4_parser_class_declaration +# --------------------------- +# The declaration of the parser class ("class YYParser"), with all its +# qualifiers/annotations. +b4_percent_define_default([[api.parser.abstract]], [[false]]) +b4_percent_define_default([[api.parser.final]], [[false]]) +b4_percent_define_default([[api.parser.public]], [[false]]) +b4_percent_define_default([[api.parser.strictfp]], [[false]]) + +m4_define([b4_parser_class_declaration], +[b4_percent_define_get3([api.parser.annotations], [], [ ])dnl +b4_percent_define_flag_if([api.parser.public], [public ])dnl +b4_percent_define_flag_if([api.parser.abstract], [abstract ])dnl +b4_percent_define_flag_if([api.parser.final], [final ])dnl +b4_percent_define_flag_if([api.parser.strictfp], [strictfp ])dnl +[class ]b4_parser_class[]dnl +b4_percent_define_get3([api.parser.extends], [ extends ])dnl +b4_percent_define_get3([api.parser.implements], [ implements ])]) + + +# 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_string["; + + /** Name of the skeleton that generated this parser. */ + public static final String bisonSkeleton = ]b4_skeleton[; +]]) + + +## ------------ ## +## Data types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# MIN to MAX (included). +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [-128], [127]), [1], [byte], + b4_ints_in($@, [-32768], [32767]), [1], [short], + [int])]) + +# b4_int_type_for(NAME) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# 'NAME_min' to 'NAME_max' (included). +m4_define([b4_int_type_for], +[b4_int_type($1_min, $1_max)]) + +# b4_null +# ------- +m4_define([b4_null], [null]) + + +# b4_typed_parser_table_define(TYPE, NAME, DATA, COMMENT) +# ------------------------------------------------------- +# We use intermediate functions (e.g., yypact_init) to work around the +# 64KB limit for JVM methods. See +# https://lists.gnu.org/r/help-bison/2008-11/msg00004.html. +m4_define([b4_typed_parser_table_define], +[m4_ifval([$4], [b4_comment([$4]) + ])dnl +[private static final ]$1[[] yy$2_ = yy$2_init(); + private static final ]$1[[] yy$2_init() + { + return new ]$1[[] + { + ]$3[ + }; + }]]) + + +# b4_integral_parser_table_define(NAME, DATA, COMMENT) +#----------------------------------------------------- +m4_define([b4_integral_parser_table_define], +[b4_typed_parser_table_define([b4_int_type_for([$2])], [$1], [$2], [$3])]) + + +## ------------- ## +## Token kinds. ## +## ------------- ## + + +# b4_token_enum(TOKEN-NUM) +# ------------------------ +# Output the definition of this token as an enum. +m4_define([b4_token_enum], +[b4_token_visible_if([$1], + [m4_format([[ /** Token %s, to be returned by the scanner. */ + static final int %s = %s%s; +]], + b4_symbol([$1], [tag]), + b4_symbol([$1], [id]), + b4_symbol([$1], b4_api_token_raw_if([[number]], [[code]])))])]) + + +# b4_token_enums +# -------------- +# Output the definition of the tokens (if there are) as enums. +m4_define([b4_token_enums], +[b4_any_token_visible_if([ /* Token kinds. */ +b4_symbol_foreach([b4_token_enum])])]) + + + +## -------------- ## +## Symbol kinds. ## +## -------------- ## + + +# b4_symbol_kind(NUM) +# ------------------- +m4_define([b4_symbol_kind], +[SymbolKind.b4_symbol_kind_base($@)]) + + +# b4_symbol_enum(SYMBOL-NUM) +# -------------------------- +# Output the definition of this symbol as an enum. +m4_define([b4_symbol_enum], +[m4_format([ %-30s %s], + m4_format([[%s(%s)%s]], + b4_symbol([$1], [kind_base]), + [$1], + m4_if([$1], b4_last_symbol, [[;]], [[,]])), + [b4_symbol_tag_comment([$1])])]) + + +# b4_declare_symbol_enum +# ---------------------- +# The definition of the symbol internal numbers as an enum. +m4_define([b4_declare_symbol_enum], +[[ public enum SymbolKind + { +]b4_symbol_foreach([b4_symbol_enum])[ + + private final int yycode_; + + SymbolKind (int n) { + this.yycode_ = n; + } + + private static final SymbolKind[] values_ = { + ]m4_map_args_sep([b4_symbol_kind(], [)], [, + ], b4_symbol_numbers)[ + }; + + static final SymbolKind get(int code) { + return values_[code]; + } + + public final int getCode() { + return this.yycode_; + } + +]b4_parse_error_bmatch( +[simple\|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. */ + private static 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(); + } + } + return yystr; + } + + /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at \a YYNTOKENS_, nonterminals. */ + ]b4_typed_parser_table_define([String], [tname], [b4_tname])[ + + /* The user-facing name of this symbol. */ + public final String getName() { + return yytnamerr_(yytname_[yycode_]); + } +]], +[custom\|detailed], +[[ /* YYNAMES_[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at \a YYNTOKENS_, nonterminals. */ + ]b4_typed_parser_table_define([String], [names], [b4_symbol_names])[ + + /* The user-facing name of this symbol. */ + public final String getName() { + return yynames_[yycode_]; + }]])[ + }; +]])]) + + + +# b4_case(ID, CODE, [COMMENTS]) +# ----------------------------- +# We need to fool Java's stupid unreachable code detection. +m4_define([b4_case], +[ case $1:m4_ifval([$3], [ b4_comment([$3])]) + if (yyn == $1) + $2; + break; +]) + + +# b4_predicate_case(LABEL, CONDITIONS) +# ------------------------------------ +m4_define([b4_predicate_case], +[ case $1: + if (! ($2)) YYERROR; + break; +]) + + +## -------- ## +## Checks. ## +## -------- ## + +b4_percent_define_check_kind([[api.value.type]], [code], [deprecated]) + +b4_percent_define_check_kind([[annotations]], [code], [deprecated]) +b4_percent_define_check_kind([[extends]], [code], [deprecated]) +b4_percent_define_check_kind([[implements]], [code], [deprecated]) +b4_percent_define_check_kind([[init_throws]], [code], [deprecated]) +b4_percent_define_check_kind([[lex_throws]], [code], [deprecated]) +b4_percent_define_check_kind([[api.parser.class]], [code], [deprecated]) +b4_percent_define_check_kind([[throws]], [code], [deprecated]) + + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +m4_define([b4_yystype], [b4_percent_define_get([[api.value.type]])]) +b4_percent_define_default([[api.value.type]], [[Object]]) +b4_percent_define_default([[api.symbol.prefix]], [[S_]]) + +# b4_api_prefix, b4_api_PREFIX +# ---------------------------- +# Corresponds to %define api.prefix +b4_percent_define_default([[api.prefix]], [[YY]]) +m4_define([b4_api_prefix], +[b4_percent_define_get([[api.prefix]])]) +m4_define([b4_api_PREFIX], +[m4_toupper(b4_api_prefix)]) + +# b4_prefix +# --------- +# If the %name-prefix is not given, it is api.prefix. +m4_define_default([b4_prefix], [b4_api_prefix]) + +b4_percent_define_default([[api.parser.class]], [b4_prefix[]Parser]) +m4_define([b4_parser_class], [b4_percent_define_get([[api.parser.class]])]) + +b4_percent_define_default([[lex_throws]], [[java.io.IOException]]) +m4_define([b4_lex_throws], [b4_percent_define_get([[lex_throws]])]) + +b4_percent_define_default([[throws]], []) +m4_define([b4_throws], [b4_percent_define_get([[throws]])]) + +b4_percent_define_default([[init_throws]], []) +m4_define([b4_init_throws], [b4_percent_define_get([[init_throws]])]) + +b4_percent_define_default([[api.location.type]], [Location]) +m4_define([b4_location_type], [b4_percent_define_get([[api.location.type]])]) + +b4_percent_define_default([[api.position.type]], [Position]) +m4_define([b4_position_type], [b4_percent_define_get([[api.position.type]])]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_symbol_translate(STRING) +# --------------------------- +# Used by "bison" in the array of symbol names to mark those that +# require translation. +m4_define([b4_symbol_translate], +[[i18n($1)]]) + + +# b4_trans(STRING) +# ---------------- +# Translate a string if i18n is enabled. Avoid collision with b4_translate. +m4_define([b4_trans], +[b4_has_translations_if([i18n($1)], [$1])]) + + + +# b4_symbol_value(VAL, [SYMBOL-NUM], [TYPE-TAG]) +# ---------------------------------------------- +# See README. +m4_define([b4_symbol_value], +[m4_ifval([$3], + [(($3)($1))], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [((b4_symbol([$2], [type]))($1))], + [$1])], + [$1])])]) + + +# b4_lhs_value([SYMBOL-NUM], [TYPE]) +# ---------------------------------- +# See README. +m4_define([b4_lhs_value], [yyval]) + + +# b4_rhs_data(RULE-LENGTH, POS) +# ----------------------------- +# See README. +m4_define([b4_rhs_data], +[yystack.valueAt (b4_subtract($@))]) + +# b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE]) +# -------------------------------------------------- +# See README. +# +# In this simple implementation, %token and %type have class names +# between the angle brackets. +m4_define([b4_rhs_value], +[b4_symbol_value([b4_rhs_data([$1], [$2])], [$3], [$4])]) + + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, POS) +# --------------------------------- +# Expansion of @POS, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[yystack.locationAt (b4_subtract($@))]) + + +# 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/compiler/win_flex_bison/data/skeletons/lalr1.cc b/compiler/win_flex_bison/data/skeletons/lalr1.cc new file mode 100644 index 0000000..7cb69d3 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/lalr1.cc @@ -0,0 +1,1633 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 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_skeletonsdir/[c++.m4]) + +# api.value.type=variant is valid. +m4_define([b4_value_type_setup_variant]) + +# parse.lac +b4_percent_define_default([[parse.lac]], [[none]]) +b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]]) +b4_define_flag_if([lac]) +m4_define([b4_lac_flag], + [m4_if(b4_percent_define_get([[parse.lac]]), + [none], [[0]], [[1]])]) + + +# b4_tname_if(TNAME-NEEDED, TNAME-NOT-NEEDED) +# ------------------------------------------- +m4_define([b4_tname_if], +[m4_case(b4_percent_define_get([[parse.error]]), + [verbose], [$1], + [b4_token_table_if([$1], + [$2])])]) + + +# b4_integral_parser_table_declare(TABLE-NAME, CONTENT, COMMENT) +# -------------------------------------------------------------- +# Declare "parser::yy_" whose contents is CONTENT. +m4_define([b4_integral_parser_table_declare], +[m4_ifval([$3], [b4_comment([$3], [ ]) +])dnl + static const b4_int_type_for([$2]) yy$1_[[]];dnl +]) + +# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) +# ------------------------------------------------------------- +# Define "parser::yy_" whose contents is CONTENT. +m4_define([b4_integral_parser_table_define], +[ const b4_int_type_for([$2]) + b4_parser_class::yy$1_[[]] = + { + $2 + };dnl +]) + + +# b4_symbol_kind(NUM) +# ------------------- +m4_define([b4_symbol_kind], +[symbol_kind::b4_symbol_kind_base($@)]) + + +# b4_symbol_value_template(VAL, SYMBOL-NUM, [TYPE]) +# ------------------------------------------------- +# Same as b4_symbol_value, but used in a template method. It makes +# a difference when using variants. Note that b4_value_type_setup_union +# overrides b4_symbol_value, so we must override it again. +m4_copy([b4_symbol_value], [b4_symbol_value_template]) +m4_append([b4_value_type_setup_union], +[m4_copy_force([b4_symbol_value_union], [b4_symbol_value_template])]) + +# b4_lhs_value(SYMBOL-NUM, [TYPE]) +# -------------------------------- +# See README. +m4_define([b4_lhs_value], +[b4_symbol_value([yylhs.value], [$1], [$2])]) + + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[yylhs.location]) + + +# b4_rhs_data(RULE-LENGTH, POS) +# ----------------------------- +# See README. +m4_define([b4_rhs_data], +[yystack_@{b4_subtract($@)@}]) + + +# b4_rhs_state(RULE-LENGTH, POS) +# ------------------------------ +# The state corresponding to the symbol #POS, where the current +# rule has RULE-LENGTH symbols on RHS. +m4_define([b4_rhs_state], +[b4_rhs_data([$1], [$2]).state]) + + +# b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE]) +# -------------------------------------------------- +# See README. +m4_define([_b4_rhs_value], +[b4_symbol_value([b4_rhs_data([$1], [$2]).value], [$3], [$4])]) + +m4_define([b4_rhs_value], +[b4_percent_define_ifdef([api.value.automove], + [YY_MOVE (_b4_rhs_value($@))], + [_b4_rhs_value($@)])]) + + +# b4_rhs_location(RULE-LENGTH, POS) +# --------------------------------- +# Expansion of @POS, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[b4_rhs_data([$1], [$2]).location]) + + +# b4_symbol_action(SYMBOL-NUM, KIND) +# ---------------------------------- +# Run the action KIND (destructor or printer) for SYMBOL-NUM. +# Same as in C, but using references instead of pointers. +m4_define([b4_symbol_action], +[b4_symbol_if([$1], [has_$2], +[m4_pushdef([b4_symbol_value], m4_defn([b4_symbol_value_template]))[]dnl +b4_dollar_pushdef([yysym.value], + [$1], + [], + [yysym.location])dnl + _b4_symbol_case([$1])[]dnl +b4_syncline([b4_symbol([$1], [$2_line])], [b4_symbol([$1], [$2_file])])dnl + b4_symbol([$1], [$2]) +b4_syncline([@oline@], [@ofile@])dnl + break; + +m4_popdef([b4_symbol_value])[]dnl +b4_dollar_popdef[]dnl +])]) + + +# b4_yylex +# -------- +# Call yylex. +m4_define([b4_yylex], +[b4_token_ctor_if( +[b4_function_call([yylex], + [symbol_type], m4_ifdef([b4_lex_param], b4_lex_param))], +[b4_function_call([yylex], [int], + [[value_type *], [&yyla.value]][]dnl +b4_locations_if([, [[location_type *], [&yyla.location]]])dnl +m4_ifdef([b4_lex_param], [, ]b4_lex_param))])]) + + +m4_pushdef([b4_copyright_years], + [2002-2015, 2018-2021]) + +m4_define([b4_parser_class], + [b4_percent_define_get([[api.parser.class]])]) + +b4_bison_locations_if([# Backward compatibility. + m4_define([b4_location_constructors]) + m4_include(b4_skeletonsdir/[location.cc])]) +m4_include(b4_skeletonsdir/[stack.hh]) +b4_variant_if([m4_include(b4_skeletonsdir/[variant.hh])]) + + +# b4_shared_declarations(hh|cc) +# ----------------------------- +# Declaration that might either go into the header (if --header, $1 = hh) +# or in the implementation file. +m4_define([b4_shared_declarations], +[b4_percent_code_get([[requires]])[ +]b4_parse_assert_if([# include ])[ +# include // std::abort +# include +# include +# include +# include + +]b4_cxx_portability[ +]m4_ifdef([b4_location_include], + [[# include ]b4_location_include])[ +]b4_variant_if([b4_variant_includes])[ + +]b4_attribute_define[ +]b4_cast_define[ +]b4_null_define[ + +]b4_YYDEBUG_define[ + +]b4_namespace_open[ + +]b4_bison_locations_if([m4_ifndef([b4_location_file], + [b4_location_define])])[ + + /// A Bison parser. + class ]b4_parser_class[ + { + public: +]b4_public_types_declare[ +]b4_symbol_type_define[ + /// Build a parser object. + ]b4_parser_class[ (]b4_parse_param_decl[); + virtual ~]b4_parser_class[ (); + +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + ]b4_parser_class[ (const ]b4_parser_class[&) = delete; + /// Non copyable. + ]b4_parser_class[& operator= (const ]b4_parser_class[&) = delete; +#endif + + /// Parse. An alias for parse (). + /// \returns 0 iff parsing succeeded. + int operator() (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + virtual int parse (); + +#if ]b4_api_PREFIX[DEBUG + /// The current debugging stream. + std::ostream& debug_stream () const YY_ATTRIBUTE_PURE; + /// 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 YY_ATTRIBUTE_PURE; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); +#endif + + /// Report a syntax error.]b4_locations_if([[ + /// \param loc where the syntax error is found.]])[ + /// \param msg a description of the syntax error. + virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); + + /// Report a syntax error. + void error (const syntax_error& err); + +]b4_parse_error_bmatch( +[custom\|detailed], +[[ /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static const char *symbol_name (symbol_kind_type yysymbol);]], +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static const char *symbol_name (symbol_kind_type yysymbol); +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[verbose], +[[ /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static std::string symbol_name (symbol_kind_type yysymbol);]])[ + +]b4_token_constructor_define[ +]b4_parse_error_bmatch([custom\|detailed\|verbose], [[ + class context + { + public: + context (const ]b4_parser_class[& yyparser, const symbol_type& yyla); + const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; } + symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); }]b4_locations_if([[ + const location_type& location () const YY_NOEXCEPT { return yyla_.location; } +]])[ + /// Put in YYARG at most YYARGN of the expected tokens, and return the + /// number of tokens stored in YYARG. If YYARG is null, return the + /// number of expected tokens (guaranteed to be less than YYNTOKENS). + int expected_tokens (symbol_kind_type yyarg[], int yyargn) const; + + private: + const ]b4_parser_class[& yyparser_; + const symbol_type& yyla_; + }; +]])[ + private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. + ]b4_parser_class[ (const ]b4_parser_class[&); + /// Non copyable. + ]b4_parser_class[& operator= (const ]b4_parser_class[&); +#endif +]b4_lac_if([[ + /// Check the lookahead yytoken. + /// \returns true iff the token will be eventually shifted. + bool yy_lac_check_ (symbol_kind_type yytoken) const; + /// Establish the initial context if no initial context currently exists. + /// \returns true iff the token will be eventually shifted. + bool yy_lac_establish_ (symbol_kind_type yytoken); + /// Discard any previous initial lookahead context because of event. + /// \param event the event which caused the lookahead to be discarded. + /// Only used for debbuging output. + void yy_lac_discard_ (const char* event);]])[ + + /// Stored state numbers (used for stacks). + typedef ]b4_int_type(0, m4_eval(b4_states_number - 1))[ state_type; +]b4_parse_error_bmatch( +[custom], [[ + /// Report a syntax error + /// \param yyctx the context in which the error occurred. + void report_syntax_error (const context& yyctx) const;]], +[detailed\|verbose], [[ + /// The arguments of the error message. + int yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const; + + /// Generate an error message. + /// \param yyctx the context in which the error occurred. + virtual std::string yysyntax_error_ (const context& yyctx) const;]])[ + /// Compute post-reduction state. + /// \param yystate the current state + /// \param yysym the nonterminal to push on the stack + static state_type yy_lr_goto_state_ (state_type yystate, int yysym); + + /// Whether the given \c yypact_ value indicates a defaulted state. + /// \param yyvalue the value to check + static bool yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT; + + /// Whether the given \c yytable_ value indicates a syntax error. + /// \param yyvalue the value to check + static bool yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT; + + static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_; + static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_; + + /// Convert a scanner token kind \a t to a symbol kind. + /// In theory \a t should be a token_kind_type, but character literals + /// are valid, yet not members of the token_kind_type enum. + static symbol_kind_type yytranslate_ (int t) YY_NOEXCEPT; + +]b4_parse_error_bmatch( +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + /// For a symbol, its name in clear. + static const char* const yytname_[]; +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[verbose], +[[ /// Convert the symbol name \a n to a form suitable for a diagnostic. + static std::string yytnamerr_ (const char *yystr); + + /// For a symbol, its name in clear. + static const char* const yytname_[]; +]])[ + + // Tables. +]b4_parser_tables_declare[ + +#if ]b4_api_PREFIX[DEBUG +]b4_integral_parser_table_declare([rline], [b4_rline], + [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[ + /// Report on the debug stream that the rule \a r is going to be reduced. + virtual void yy_reduce_print_ (int r) const; + /// Print the state stack on the debug stream. + virtual void yy_stack_print_ () const; + + /// Debugging level. + int yydebug_; + /// Debug stream. + std::ostream* yycdebug_; + + /// \brief Display a symbol kind, value and location. + /// \param yyo The output stream. + /// \param yysym The symbol. + template + void yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const; +#endif + + /// \brief Reclaim the memory associated to a symbol. + /// \param yymsg Why this token is reclaimed. + /// If null, print nothing. + /// \param yysym The symbol. + template + void yy_destroy_ (const char* yymsg, basic_symbol& yysym) const; + + private: + /// Type access provider for state based symbols. + struct by_state + { + /// Default constructor. + by_state () YY_NOEXCEPT; + + /// The symbol kind as needed by the constructor. + typedef state_type kind_type; + + /// Constructor. + by_state (kind_type s) YY_NOEXCEPT; + + /// Copy constructor. + by_state (const by_state& that) YY_NOEXCEPT; + + /// Record that this symbol is empty. + void clear () YY_NOEXCEPT; + + /// Steal the symbol kind from \a that. + void move (by_state& that); + + /// The symbol kind (corresponding to \a state). + /// \a ]b4_symbol(empty, kind)[ when empty. + symbol_kind_type kind () const YY_NOEXCEPT; + + /// The state number used to denote an empty symbol. + /// We use the initial state, as it does not have a value. + enum { empty_state = 0 }; + + /// The state. + /// \a empty when empty. + state_type state; + }; + + /// "Internal" symbol: element of the stack. + struct stack_symbol_type : basic_symbol + { + /// Superclass. + typedef basic_symbol super_type; + /// Construct an empty symbol. + stack_symbol_type (); + /// Move or copy construction. + stack_symbol_type (YY_RVREF (stack_symbol_type) that); + /// Steal the contents from \a sym to build this. + stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym); +#if YY_CPLUSPLUS < 201103L + /// Assignment, needed by push_back by some old implementations. + /// Moves the contents of that. + stack_symbol_type& operator= (stack_symbol_type& that); + + /// Assignment, needed by push_back by other implementations. + /// Needed by some other old implementations. + stack_symbol_type& operator= (const stack_symbol_type& that); +#endif + }; + +]b4_stack_define[ + + /// Stack type. + typedef stack stack_type; + + /// The stack. + stack_type yystack_;]b4_lac_if([[ + /// The stack for LAC. + /// Logically, the yy_lac_stack's lifetime is confined to the function + /// yy_lac_check_. We just store it as a member of this class to hold + /// on to the memory and to avoid frequent reallocations. + /// Since yy_lac_check_ is const, this member must be mutable. + mutable std::vector yylac_stack_; + /// Whether an initial LAC context was established. + bool yy_lac_established_; +]])[ + + /// Push a new state on the stack. + /// \param m a debug message to display + /// if null, no trace is output. + /// \param sym the symbol + /// \warning the contents of \a s.value is stolen. + void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym); + + /// Push a new look ahead token on the state on the stack. + /// \param m a debug message to display + /// if null, no trace is output. + /// \param s the state + /// \param sym the symbol (for its value and location). + /// \warning the contents of \a sym.value is stolen. + void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym); + + /// Pop \a n symbols from the stack. + void yypop_ (int n = 1) YY_NOEXCEPT; + + /// Constants. + enum + { + yylast_ = ]b4_last[, ///< Last index in yytable_. + yynnts_ = ]b4_nterms_number[, ///< Number of nonterminal symbols. + yyfinal_ = ]b4_final_state_number[ ///< Termination state number. + }; + +]b4_parse_param_vars[ +]b4_percent_code_get([[yy_bison_internal_hook]])[ + }; + +]b4_token_ctor_if([b4_yytranslate_define([$1])[ +]b4_public_types_define([$1])])[ +]b4_namespace_close[ + +]b4_percent_code_get([[provides]])[ +]])[ + + +## -------------- ## +## Output files. ## +## -------------- ## + +# ------------- # +# Header file. # +# ------------- # + +]b4_header_if([[ +]b4_output_begin([b4_spec_header_file])[ +]b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++])[ + +/** + ** \file ]b4_spec_mapped_header_file[ + ** Define the ]b4_namespace_ref[::parser class. + */ + +// C++ LALR(1) parser skeleton written by Akim Demaille. + +]b4_disclaimer[ +]b4_cpp_guard_open([b4_spec_mapped_header_file])[ +]b4_shared_declarations(hh)[ +]b4_cpp_guard_close([b4_spec_mapped_header_file])[ +]b4_output_end[ +]])[ + + +# --------------------- # +# Implementation file. # +# --------------------- # + +]b4_output_begin([b4_parser_file_name])[ +]b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++])[ +]b4_disclaimer[ +]b4_percent_code_get([[top]])[]dnl +m4_if(b4_prefix, [yy], [], +[ +// Take the name prefix into account. +[#]define yylex b4_prefix[]lex])[ + +]b4_user_pre_prologue[ + +]b4_header_if([[#include "@basename(]b4_spec_header_file[@)"]], + [b4_shared_declarations([cc])])[ + +]b4_user_post_prologue[ +]b4_percent_code_get[ + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include // FIXME: INFRINGES ON USER NAME SPACE. +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif +]b4_has_translations_if([ +#ifndef N_ +# define N_(Msgid) Msgid +#endif +])[ + +// Whether we are compiled with exception support. +#ifndef YY_EXCEPTIONS +# if defined __GNUC__ && !defined __EXCEPTIONS +# define YY_EXCEPTIONS 0 +# else +# define YY_EXCEPTIONS 1 +# endif +#endif + +]b4_locations_if([dnl +[#define YYRHSLOC(Rhs, K) ((Rhs)[K].location) +]b4_yylloc_default_define])[ + +// Enable debugging if requested. +#if ]b4_api_PREFIX[DEBUG + +// A pseudo ostream that takes yydebug_ into account. +# define YYCDEBUG if (yydebug_) (*yycdebug_) + +# define YY_SYMBOL_PRINT(Title, Symbol) \ + do { \ + if (yydebug_) \ + { \ + *yycdebug_ << Title << ' '; \ + yy_print_ (*yycdebug_, Symbol); \ + *yycdebug_ << '\n'; \ + } \ + } while (false) + +# define YY_REDUCE_PRINT(Rule) \ + do { \ + if (yydebug_) \ + yy_reduce_print_ (Rule); \ + } while (false) + +# define YY_STACK_PRINT() \ + do { \ + if (yydebug_) \ + yy_stack_print_ (); \ + } while (false) + +#else // !]b4_api_PREFIX[DEBUG + +# define YYCDEBUG if (false) std::cerr +# define YY_SYMBOL_PRINT(Title, Symbol) YY_USE (Symbol) +# define YY_REDUCE_PRINT(Rule) static_cast (0) +# define YY_STACK_PRINT() static_cast (0) + +#endif // !]b4_api_PREFIX[DEBUG + +#define yyerrok (yyerrstatus_ = 0) +#define yyclearin (yyla.clear ()) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYRECOVERING() (!!yyerrstatus_) + +]b4_namespace_open[ + /// Build a parser object. + ]b4_parser_class::b4_parser_class[ (]b4_parse_param_decl[) +#if ]b4_api_PREFIX[DEBUG + : yydebug_ (false), + yycdebug_ (&std::cerr)]b4_lac_if([,], [m4_ifset([b4_parse_param], [,])])[ +#else +]b4_lac_if([ :], [m4_ifset([b4_parse_param], [ :])])[ +#endif]b4_lac_if([[ + yy_lac_established_ (false)]m4_ifset([b4_parse_param], [,])])[]b4_parse_param_cons[ + {} + + ]b4_parser_class::~b4_parser_class[ () + {} + + ]b4_parser_class[::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW + {} + + /*---------. + | symbol. | + `---------*/ + +]b4_token_ctor_if([], [b4_public_types_define([cc])])[ + + // by_state. + ]b4_parser_class[::by_state::by_state () YY_NOEXCEPT + : state (empty_state) + {} + + ]b4_parser_class[::by_state::by_state (const by_state& that) YY_NOEXCEPT + : state (that.state) + {} + + void + ]b4_parser_class[::by_state::clear () YY_NOEXCEPT + { + state = empty_state; + } + + void + ]b4_parser_class[::by_state::move (by_state& that) + { + state = that.state; + that.clear (); + } + + ]b4_parser_class[::by_state::by_state (state_type s) YY_NOEXCEPT + : state (s) + {} + + ]b4_parser_class[::symbol_kind_type + ]b4_parser_class[::by_state::kind () const YY_NOEXCEPT + { + if (state == empty_state) + return ]b4_symbol(empty, kind)[; + else + return YY_CAST (symbol_kind_type, yystos_[+state]); + } + + ]b4_parser_class[::stack_symbol_type::stack_symbol_type () + {} + + ]b4_parser_class[::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that) + : super_type (YY_MOVE (that.state)]b4_variant_if([], [, YY_MOVE (that.value)])b4_locations_if([, YY_MOVE (that.location)])[) + {]b4_variant_if([ + b4_symbol_variant([that.kind ()], + [value], [YY_MOVE_OR_COPY], [YY_MOVE (that.value)])])[ +#if 201103L <= YY_CPLUSPLUS + // that is emptied. + that.state = empty_state; +#endif + } + + ]b4_parser_class[::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that) + : super_type (s]b4_variant_if([], [, YY_MOVE (that.value)])[]b4_locations_if([, YY_MOVE (that.location)])[) + {]b4_variant_if([ + b4_symbol_variant([that.kind ()], + [value], [move], [YY_MOVE (that.value)])])[ + // that is emptied. + that.kind_ = ]b4_symbol(empty, kind)[; + } + +#if YY_CPLUSPLUS < 201103L + ]b4_parser_class[::stack_symbol_type& + ]b4_parser_class[::stack_symbol_type::operator= (const stack_symbol_type& that) + { + state = that.state; + ]b4_variant_if([b4_symbol_variant([that.kind ()], + [value], [copy], [that.value])], + [[value = that.value;]])[]b4_locations_if([ + location = that.location;])[ + return *this; + } + + ]b4_parser_class[::stack_symbol_type& + ]b4_parser_class[::stack_symbol_type::operator= (stack_symbol_type& that) + { + state = that.state; + ]b4_variant_if([b4_symbol_variant([that.kind ()], + [value], [move], [that.value])], + [[value = that.value;]])[]b4_locations_if([ + location = that.location;])[ + // that is emptied. + that.state = empty_state; + return *this; + } +#endif + + template + void + ]b4_parser_class[::yy_destroy_ (const char* yymsg, basic_symbol& yysym) const + { + if (yymsg) + YY_SYMBOL_PRINT (yymsg, yysym);]b4_variant_if([], [ + + // User destructor. + b4_symbol_actions([destructor], [yysym.kind ()])])[ + } + +#if ]b4_api_PREFIX[DEBUG + template + void + ]b4_parser_class[::yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const + { + std::ostream& yyoutput = yyo; + YY_USE (yyoutput); + if (yysym.empty ()) + yyo << "empty symbol"; + else + { + symbol_kind_type yykind = yysym.kind (); + yyo << (yykind < YYNTOKENS ? "token" : "nterm") + << ' ' << yysym.name () << " ("]b4_locations_if([ + << yysym.location << ": "])[; + ]b4_symbol_actions([printer])[ + yyo << ')'; + } + } +#endif + + void + ]b4_parser_class[::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym) + { + if (m) + YY_SYMBOL_PRINT (m, sym); + yystack_.push (YY_MOVE (sym)); + } + + void + ]b4_parser_class[::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym) + { +#if 201103L <= YY_CPLUSPLUS + yypush_ (m, stack_symbol_type (s, std::move (sym))); +#else + stack_symbol_type ss (s, sym); + yypush_ (m, ss); +#endif + } + + void + ]b4_parser_class[::yypop_ (int n) YY_NOEXCEPT + { + yystack_.pop (n); + } + +#if ]b4_api_PREFIX[DEBUG + std::ostream& + ]b4_parser_class[::debug_stream () const + { + return *yycdebug_; + } + + void + ]b4_parser_class[::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + ]b4_parser_class[::debug_level_type + ]b4_parser_class[::debug_level () const + { + return yydebug_; + } + + void + ]b4_parser_class[::set_debug_level (debug_level_type l) + { + yydebug_ = l; + } +#endif // ]b4_api_PREFIX[DEBUG + + ]b4_parser_class[::state_type + ]b4_parser_class[::yy_lr_goto_state_ (state_type yystate, int yysym) + { + int yyr = yypgoto_[yysym - YYNTOKENS] + yystate; + if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) + return yytable_[yyr]; + else + return yydefgoto_[yysym - YYNTOKENS]; + } + + bool + ]b4_parser_class[::yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT + { + return yyvalue == yypact_ninf_; + } + + bool + ]b4_parser_class[::yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT + { + return yyvalue == yytable_ninf_; + } + + int + ]b4_parser_class[::operator() () + { + return parse (); + } + + int + ]b4_parser_class[::parse () + { + int yyn; + /// Length of the RHS of the rule being reduced. + int yylen = 0; + + // Error handling. + int yynerrs_ = 0; + int yyerrstatus_ = 0; + + /// The lookahead symbol. + symbol_type yyla;]b4_locations_if([[ + + /// The locations where the error started and ended. + stack_symbol_type yyerror_range[3];]])[ + + /// The return value of parse (). + int yyresult;]b4_lac_if([[ + + // Discard the LAC context in case there still is one left from a + // previous invocation. + yy_lac_discard_ ("init");]])[ + +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + YYCDEBUG << "Starting parse\n"; + +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yyla.value], [], [], [yyla.location])dnl + b4_user_initial_action +b4_dollar_popdef])[]dnl + + [ /* Initialize the stack. The initial state will be set in + yynewstate, since the latter expects the semantical and the + location values to have been already stored, initialize these + stacks with a primary value. */ + yystack_.clear (); + yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla)); + + /*-----------------------------------------------. + | yynewstate -- push a new symbol on the stack. | + `-----------------------------------------------*/ + yynewstate: + YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n'; + YY_STACK_PRINT (); + + // Accept? + if (yystack_[0].state == yyfinal_) + YYACCEPT; + + goto yybackup; + + + /*-----------. + | yybackup. | + `-----------*/ + yybackup: + // Try to take a decision without lookahead. + yyn = yypact_[+yystack_[0].state]; + if (yy_pact_value_is_default_ (yyn)) + goto yydefault; + + // Read a lookahead token. + if (yyla.empty ()) + { + YYCDEBUG << "Reading a token\n"; +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + {]b4_token_ctor_if([[ + symbol_type yylookahead (]b4_yylex[); + yyla.move (yylookahead);]], [[ + yyla.kind_ = yytranslate_ (]b4_yylex[);]])[ + } +#if YY_EXCEPTIONS + catch (const syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; + error (yyexc); + goto yyerrlab1; + } +#endif // YY_EXCEPTIONS + } + YY_SYMBOL_PRINT ("Next token is", yyla); + + if (yyla.kind () == ]b4_symbol(error, kind)[) + { + // The scanner already issued an error message, process directly + // to error recovery. But do not keep the error token as + // lookahead, it is too special and may lead us to an endless + // loop in error recovery. */ + yyla.kind_ = ]b4_symbol(undef, kind)[; + goto yyerrlab1; + } + + /* If the proper action on seeing token YYLA.TYPE is to reduce or + to detect an error, take that action. */ + yyn += yyla.kind (); + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ()) + {]b4_lac_if([[ + if (!yy_lac_establish_ (yyla.kind ())) + goto yyerrlab;]])[ + goto yydefault; + } + + // Reduce or error. + yyn = yytable_[yyn]; + if (yyn <= 0) + { + if (yy_table_value_is_error_ (yyn)) + goto yyerrlab;]b4_lac_if([[ + if (!yy_lac_establish_ (yyla.kind ())) + goto yyerrlab; +]])[ + yyn = -yyn; + goto yyreduce; + } + + // Count tokens shifted since error; after three, turn off error status. + if (yyerrstatus_) + --yyerrstatus_; + + // Shift the lookahead token. + yypush_ ("Shifting", state_type (yyn), YY_MOVE (yyla));]b4_lac_if([[ + yy_lac_discard_ ("shift");]])[ + goto yynewstate; + + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + yydefault: + yyn = yydefact_[+yystack_[0].state]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + + /*-----------------------------. + | yyreduce -- do a reduction. | + `-----------------------------*/ + yyreduce: + yylen = yyr2_[yyn]; + { + stack_symbol_type yylhs; + yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]);]b4_variant_if([[ + /* Variants are always initialized to an empty instance of the + correct type. The default '$$ = $1' action is NOT applied + when using variants. */ + ]b4_symbol_variant([[yyr1_@{yyn@}]], [yylhs.value], [emplace])], [[ + /* If YYLEN is nonzero, implement the default value of the + action: '$$ = $1'. Otherwise, use the top of the stack. + + Otherwise, the following line sets YYLHS.VALUE to garbage. + This behavior is undocumented and Bison users should not rely + upon it. */ + if (yylen) + yylhs.value = yystack_@{yylen - 1@}.value; + else + yylhs.value = yystack_@{0@}.value;]])[ +]b4_locations_if([dnl +[ + // Default location. + { + stack_type::slice range (yystack_, yylen); + YYLLOC_DEFAULT (yylhs.location, range, yylen); + yyerror_range[1].location = yylhs.location; + }]])[ + + // Perform the reduction. + YY_REDUCE_PRINT (yyn); +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + switch (yyn) + { +]b4_user_actions[ + default: + break; + } + } +#if YY_EXCEPTIONS + catch (const syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; + error (yyexc); + YYERROR; + } +#endif // YY_EXCEPTIONS + YY_SYMBOL_PRINT ("-> $$ =", yylhs); + yypop_ (yylen); + yylen = 0; + + // Shift the result of the reduction. + yypush_ (YY_NULLPTR, YY_MOVE (yylhs)); + } + goto yynewstate; + + + /*--------------------------------------. + | yyerrlab -- here on detecting error. | + `--------------------------------------*/ + yyerrlab: + // If not already recovering from an error, report this error. + if (!yyerrstatus_) + { + ++yynerrs_;]b4_parse_error_case( + [simple], [[ + std::string msg = YY_("syntax error"); + error (]b4_join(b4_locations_if([yyla.location]), [[YY_MOVE (msg)]])[);]], + [custom], [[ + context yyctx (*this, yyla); + report_syntax_error (yyctx);]], + [[ + context yyctx (*this, yyla); + std::string msg = yysyntax_error_ (yyctx); + error (]b4_join(b4_locations_if([yyla.location]), [[YY_MOVE (msg)]])[);]])[ + } + +]b4_locations_if([[ + yyerror_range[1].location = yyla.location;]])[ + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + // Return failure if at end of input. + if (yyla.kind () == ]b4_symbol(eof, kind)[) + YYABORT; + else if (!yyla.empty ()) + { + yy_destroy_ ("Error: discarding", yyla); + yyla.clear (); + } + } + + // Else will try to reuse lookahead token after shifting the error token. + goto yyerrlab1; + + + /*---------------------------------------------------. + | yyerrorlab -- error raised explicitly by YYERROR. | + `---------------------------------------------------*/ + yyerrorlab: + /* Pacify compilers when the user code never invokes YYERROR and + the label yyerrorlab therefore never appears in user code. */ + if (false) + YYERROR; + + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + yypop_ (yylen); + yylen = 0; + YY_STACK_PRINT (); + goto yyerrlab1; + + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + yyerrlab1: + yyerrstatus_ = 3; // Each real token shifted decrements this. + // Pop stack until we find a state that shifts the error token. + for (;;) + { + yyn = yypact_[+yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += ]b4_symbol(error, kind)[; + if (0 <= yyn && yyn <= yylast_ + && yycheck_[yyn] == ]b4_symbol(error, kind)[) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + // Pop the current state because it cannot handle the error token. + if (yystack_.size () == 1) + YYABORT; +]b4_locations_if([[ + yyerror_range[1].location = yystack_[0].location;]])[ + yy_destroy_ ("Error: popping", yystack_[0]); + yypop_ (); + YY_STACK_PRINT (); + } + { + stack_symbol_type error_token; +]b4_locations_if([[ + yyerror_range[2].location = yyla.location; + YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);]])[ + + // Shift the error token.]b4_lac_if([[ + yy_lac_discard_ ("error recovery");]])[ + error_token.state = state_type (yyn); + yypush_ ("Shifting", YY_MOVE (error_token)); + } + goto yynewstate; + + + /*-------------------------------------. + | yyacceptlab -- YYACCEPT comes here. | + `-------------------------------------*/ + yyacceptlab: + yyresult = 0; + goto yyreturn; + + + /*-----------------------------------. + | yyabortlab -- YYABORT comes here. | + `-----------------------------------*/ + yyabortlab: + yyresult = 1; + goto yyreturn; + + + /*-----------------------------------------------------. + | yyreturn -- parsing is finished, return the result. | + `-----------------------------------------------------*/ + yyreturn: + if (!yyla.empty ()) + yy_destroy_ ("Cleanup: discarding lookahead", yyla); + + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + yypop_ (yylen); + YY_STACK_PRINT (); + while (1 < yystack_.size ()) + { + yy_destroy_ ("Cleanup: popping", yystack_[0]); + yypop_ (); + } + + return yyresult; + } +#if YY_EXCEPTIONS + catch (...) + { + YYCDEBUG << "Exception caught: cleaning lookahead and stack\n"; + // Do not try to display the values of the reclaimed symbols, + // as their printers might throw an exception. + if (!yyla.empty ()) + yy_destroy_ (YY_NULLPTR, yyla); + + while (1 < yystack_.size ()) + { + yy_destroy_ (YY_NULLPTR, yystack_[0]); + yypop_ (); + } + throw; + } +#endif // YY_EXCEPTIONS + } + + void + ]b4_parser_class[::error (const syntax_error& yyexc) + { + error (]b4_join(b4_locations_if([yyexc.location]), + [[yyexc.what ()]])[); + } + +]b4_parse_error_bmatch([custom\|detailed], +[[ const char * + ]b4_parser_class[::symbol_name (symbol_kind_type yysymbol) + { + static const char *const yy_sname[] = + { + ]b4_symbol_names[ + };]b4_has_translations_if([[ + /* YYTRANSLATABLE[SYMBOL-NUM] -- Whether YY_SNAME[SYMBOL-NUM] is + internationalizable. */ + static ]b4_int_type_for([b4_translatable])[ yytranslatable[] = + { + ]b4_translatable[ + }; + return (yysymbol < YYNTOKENS && yytranslatable[yysymbol] + ? _(yy_sname[yysymbol]) + : yy_sname[yysymbol]);]], [[ + return yy_sname[yysymbol];]])[ + } +]], +[simple], +[[#if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ + const char * + ]b4_parser_class[::symbol_name (symbol_kind_type yysymbol) + { + return yytname_[yysymbol]; + } +#endif // #if ]b4_api_PREFIX[DEBUG || ]b4_token_table_flag[ +]], +[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[::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; + else + goto append; + + append: + default: + yyr += *yyp; + break; + + case '"': + return yyr; + } + do_not_strip_quotes: ; + } + + return yystr; + } + + std::string + ]b4_parser_class[::symbol_name (symbol_kind_type yysymbol) + { + return yytnamerr_ (yytname_[yysymbol]); + } +]])[ + +]b4_parse_error_bmatch([custom\|detailed\|verbose], [[ + // ]b4_parser_class[::context. + ]b4_parser_class[::context::context (const ]b4_parser_class[& yyparser, const symbol_type& yyla) + : yyparser_ (yyparser) + , yyla_ (yyla) + {} + + int + ]b4_parser_class[::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const + { + // Actual number of expected tokens + int yycount = 0; +]b4_lac_if([[ +#if ]b4_api_PREFIX[DEBUG + // Execute LAC once. We don't care if it is successful, we + // only do it for the sake of debugging output. + if (!yyparser_.yy_lac_established_) + yyparser_.yy_lac_check_ (yyla_.kind ()); +#endif + + for (int yyx = 0; yyx < YYNTOKENS; ++yyx) + { + symbol_kind_type yysym = YY_CAST (symbol_kind_type, yyx); + if (yysym != ]b4_symbol(error, kind)[ + && yysym != ]b4_symbol(undef, kind)[ + && yyparser_.yy_lac_check_ (yysym)) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = yysym; + } + }]], [[ + const int yyn = yypact_[+yyparser_.yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + const int yyxbegin = yyn < 0 ? -yyn : 0; + // Stay within bounds of both yycheck and yytname. + const int yychecklim = yylast_ - yyn + 1; + const int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != ]b4_symbol(error, kind)[ + && !yy_table_value_is_error_ (yytable_[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (symbol_kind_type, yyx); + } + } +]])[ + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = ]b4_symbol(empty, kind)[; + return yycount; + } + +]])[ + +]b4_lac_if([[ + bool + ]b4_parser_class[::yy_lac_check_ (symbol_kind_type yytoken) const + { + // Logically, the yylac_stack's lifetime is confined to this function. + // Clear it, to get rid of potential left-overs from previous call. + yylac_stack_.clear (); + // Reduce until we encounter a shift and thereby accept the token. +#if ]b4_api_PREFIX[DEBUG + YYCDEBUG << "LAC: checking lookahead " << symbol_name (yytoken) << ':'; +#endif + std::ptrdiff_t lac_top = 0; + while (true) + { + state_type top_state = (yylac_stack_.empty () + ? yystack_[lac_top].state + : yylac_stack_.back ()); + int yyrule = yypact_[+top_state]; + if (yy_pact_value_is_default_ (yyrule) + || (yyrule += yytoken) < 0 || yylast_ < yyrule + || yycheck_[yyrule] != yytoken) + { + // Use the default action. + yyrule = yydefact_[+top_state]; + if (yyrule == 0) + { + YYCDEBUG << " Err\n"; + return false; + } + } + else + { + // Use the action from yytable. + yyrule = yytable_[yyrule]; + if (yy_table_value_is_error_ (yyrule)) + { + YYCDEBUG << " Err\n"; + return false; + } + if (0 < yyrule) + { + YYCDEBUG << " S" << yyrule << '\n'; + return true; + } + yyrule = -yyrule; + } + // By now we know we have to simulate a reduce. + YYCDEBUG << " R" << yyrule - 1; + // Pop the corresponding number of values from the stack. + { + std::ptrdiff_t yylen = yyr2_[yyrule]; + // First pop from the LAC stack as many tokens as possible. + std::ptrdiff_t lac_size = std::ptrdiff_t (yylac_stack_.size ()); + if (yylen < lac_size) + { + yylac_stack_.resize (std::size_t (lac_size - yylen)); + yylen = 0; + } + else if (lac_size) + { + yylac_stack_.clear (); + yylen -= lac_size; + } + // Only afterwards look at the main stack. + // We simulate popping elements by incrementing lac_top. + lac_top += yylen; + } + // Keep top_state in sync with the updated stack. + top_state = (yylac_stack_.empty () + ? yystack_[lac_top].state + : yylac_stack_.back ()); + // Push the resulting state of the reduction. + state_type state = yy_lr_goto_state_ (top_state, yyr1_[yyrule]); + YYCDEBUG << " G" << int (state); + yylac_stack_.push_back (state); + } + } + + // Establish the initial context if no initial context currently exists. + bool + ]b4_parser_class[::yy_lac_establish_ (symbol_kind_type yytoken) + { + /* Establish the initial context for the current lookahead if no initial + context is currently established. + + We define a context as a snapshot of the parser stacks. We define + the initial context for a lookahead as the context in which the + parser initially examines that lookahead in order to select a + syntactic action. Thus, if the lookahead eventually proves + syntactically unacceptable (possibly in a later context reached via a + series of reductions), the initial context can be used to determine + the exact set of tokens that would be syntactically acceptable in the + lookahead's place. Moreover, it is the context after which any + further semantic actions would be erroneous because they would be + determined by a syntactically unacceptable token. + + yy_lac_establish_ should be invoked when a reduction is about to be + performed in an inconsistent state (which, for the purposes of LAC, + includes consistent states that don't know they're consistent because + their default reductions have been disabled). + + For parse.lac=full, the implementation of yy_lac_establish_ is as + follows. If no initial context is currently established for the + current lookahead, then check if that lookahead can eventually be + shifted if syntactic actions continue from the current context. */ + if (yy_lac_established_) + return true; + else + { +#if ]b4_api_PREFIX[DEBUG + YYCDEBUG << "LAC: initial context established for " + << symbol_name (yytoken) << '\n'; +#endif + yy_lac_established_ = true; + return yy_lac_check_ (yytoken); + } + } + + // Discard any previous initial lookahead context. + void + ]b4_parser_class[::yy_lac_discard_ (const char* event) + { + /* Discard any previous initial lookahead context because of Event, + which may be a lookahead change or an invalidation of the currently + established initial context for the current lookahead. + + The most common example of a lookahead change is a shift. An example + of both cases is syntax error recovery. That is, a syntax error + occurs when the lookahead is syntactically erroneous for the + currently established initial context, so error recovery manipulates + the parser stacks to try to find a new initial context in which the + current lookahead is syntactically acceptable. If it fails to find + such a context, it discards the lookahead. */ + if (yy_lac_established_) + { + YYCDEBUG << "LAC: initial context discarded due to " + << event << '\n'; + yy_lac_established_ = false; + } + }]])[ + +]b4_parse_error_bmatch([detailed\|verbose], [[ + int + ]b4_parser_class[::yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const + { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yyla) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is + a consistent state with a default action. There might have + been a previous inconsistent state, consistent state with a + non-default action, or user semantic action that manipulated + yyla. (However, yyla is currently not documented for users.)]b4_lac_if([[ + In the first two cases, it might appear that the current syntax + error should have been detected in the previous state when + yy_lac_check was invoked. However, at that time, there might + have been a different syntax error that discarded a different + initial context during error recovery, leaving behind the + current lookahead.]], [[ + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state.]])[ + */ + + if (!yyctx.lookahead ().empty ()) + { + if (yyarg) + yyarg[0] = yyctx.token (); + int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1); + return yyn + 1; + } + return 0; + } + + // Generate an error message. + std::string + ]b4_parser_class[::yysyntax_error_ (const context& yyctx) const + { + // Its maximum. + enum { YYARGS_MAX = 5 }; + // Arguments of yyformat. + symbol_kind_type yyarg[YYARGS_MAX]; + int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX); + + char const* yyformat = YY_NULLPTR; + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: // Avoid compiler warnings. + YYCASE_ (0, YY_("syntax error")); + YYCASE_ (1, YY_("syntax error, unexpected %s")); + YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + std::string yyres; + // Argument number. + std::ptrdiff_t yyi = 0; + for (char const* yyp = yyformat; *yyp; ++yyp) + if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) + { + yyres += symbol_name (yyarg[yyi++]); + ++yyp; + } + else + yyres += *yyp; + return yyres; + }]])[ + + + const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class::yypact_ninf_ = b4_pact_ninf[; + + const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class::yytable_ninf_ = b4_table_ninf[; + +]b4_parser_tables_define[ + +]b4_parse_error_bmatch([simple\|verbose], +[[#if ]b4_api_PREFIX[DEBUG]b4_tname_if([[ || 1]])[ + // 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[::yytname_[] = + { + ]b4_tname[ + }; +#endif +]])[ + +#if ]b4_api_PREFIX[DEBUG][ +]b4_integral_parser_table_define([rline], [b4_rline])[ + + void + ]b4_parser_class[::yy_stack_print_ () const + { + *yycdebug_ << "Stack now"; + for (stack_type::const_iterator + i = yystack_.begin (), + i_end = yystack_.end (); + i != i_end; ++i) + *yycdebug_ << ' ' << int (i->state); + *yycdebug_ << '\n'; + } + + void + ]b4_parser_class[::yy_reduce_print_ (int yyrule) const + { + 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 << "):\n"; + // The symbols being reduced. + for (int yyi = 0; yyi < yynrhs; yyi++) + YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", + ]b4_rhs_data(yynrhs, yyi + 1)[); + } +#endif // ]b4_api_PREFIX[DEBUG + +]b4_token_ctor_if([], [b4_yytranslate_define([cc])])[ +]b4_namespace_close[ +]b4_epilogue[]dnl +b4_output_end + + +m4_popdef([b4_copyright_years])dnl diff --git a/compiler/win_flex_bison/data/skeletons/lalr1.d b/compiler/win_flex_bison/data/skeletons/lalr1.d new file mode 100644 index 0000000..9730377 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/lalr1.d @@ -0,0 +1,1326 @@ +# D skeleton for Bison -*- autoconf -*- + +# Copyright (C) 2007-2012, 2019-2021 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_skeletonsdir/[d.m4]) + +b4_header_if([b4_complain([%header/%defines does not make sense in D])]) + +# parse.lac +b4_percent_define_default([[parse.lac]], [[none]]) +b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]]) +b4_define_flag_if([lac]) +m4_define([b4_lac_flag], + [m4_if(b4_percent_define_get([[parse.lac]]), + [none], [[0]], [[1]])]) + + +## --------------- ## +## api.push-pull. ## +## --------------- ## + +b4_percent_define_default([[api.push-pull]], [[pull]]) +b4_percent_define_check_values([[[[api.push-pull]], + [[pull]], [[push]], [[both]]]]) + +# Define m4 conditional macros that encode the value +# of the api.push-pull flag. +b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]]) +b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]]) +m4_case(b4_percent_define_get([[api.push-pull]]), + [pull], [m4_define([b4_push_flag], [[0]])], + [push], [m4_define([b4_pull_flag], [[0]])]) + +# Define a macro to be true when api.push-pull has the value "both". +m4_define([b4_both_if],[b4_push_if([b4_pull_if([$1],[$2])],[$2])]) + +# Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing +# tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the +# behavior of Bison at all when push parsing is already requested. +b4_define_flag_if([use_push_for_pull]) +b4_use_push_for_pull_if([ + b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])], + [m4_define([b4_push_flag], [[1]])])]) + + +# Define a macro to encapsulate the parse state variables. This +# allows them to be defined either in parse() when doing pull parsing, +# or as class instance variable when doing push parsing. +b4_output_begin([b4_parser_file_name]) +b4_copyright([Skeleton implementation for Bison LALR(1) parsers in D], + [2007-2012, 2019-2021])[ +]b4_disclaimer[ +]b4_percent_define_ifdef([package], [module b4_percent_define_get([package]); +])[ +version(D_Version2) { +} else { + static assert(false, "need compiler for D Version 2"); +} + +]b4_user_pre_prologue[ +]b4_user_post_prologue[ +]b4_percent_code_get([[imports]])[ +import std.format; +import std.conv; + +/** + * Handle error message internationalisation. + */ +static if (!is(typeof(YY_))) { + version(YYENABLE_NLS) + { + version(ENABLE_NLS) + { + extern(C) char* dgettext(const char*, const char*); + string YY_(const char* s) + { + return to!string(dgettext("bison-runtime", s)); + } + } + } + static if (!is(typeof(YY_))) + { + pragma(inline, true) + string YY_(string msg) { return msg; } + } +} + +/** + * A Bison parser, automatically generated from ]m4_bpatsubst(b4_file_name, [^"\(.*\)"$], [\1])[. + * + * @@author LALR (1) parser skeleton written by Paolo Bonzini. + * Port to D language was done by Oliver Mangold. + */ + +/** + * Communication interface between the scanner and the Bison-generated + * parser ]b4_parser_class[. + */ +public interface Lexer +{ + /** + * 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. */ + Symbol yylex (); + + /** + * 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([[const Location loc, ]])[string s); +]b4_parse_error_bmatch([custom], [[ + /** + * Build and emit a "syntax error" message in a user-defined way. + * + * @@param ctx The context of the error. + */ + void reportSyntaxError(]b4_parser_class[.Context ctx); +]])[ +} + +]b4_public_types_declare[ + +]b4_locations_if([b4_position_type_if([[ +static assert(__traits(compiles, + (new Position[1])[0]=(new Position[1])[0]), + "struct/class Position must be default-constructible " + "and assignable"); +static assert(__traits(compiles, (new string[1])[0]=(new Position).toString()), + "error: struct/class Position must have toString method"); +]], [[ + /** + * A struct denoting a point in the input.*/ +public struct ]b4_position_type[ { + + /** The column index within the line of input. */ + public int column = 1; + /** The line number within an input file. */ + public int line = 1; + /** The name of the input file. */ + public string filename = null; + + /** + * A string representation of the position. */ + public string toString() const { + if (filename) + return format("%s:%d.%d", filename, line, column); + else + return format("%d.%d", line, column); + } +} +]])b4_location_type_if([[ +static assert(__traits(compiles, (new Location((new Position[1])[0]))) && + __traits(compiles, (new Location((new Position[1])[0], (new Position[1])[0]))), + "error: struct/class Location must have " + "default constructor and constructors this(Position) and this(Position, Position)."); +static assert(__traits(compiles, (new Location[1])[0].begin=(new Location[1])[0].begin) && + __traits(compiles, (new Location[1])[0].begin=(new Location[1])[0].end) && + __traits(compiles, (new Location[1])[0].end=(new Location[1])[0].begin) && + __traits(compiles, (new Location[1])[0].end=(new Location[1])[0].end), + "error: struct/class Location must have assignment-compatible " + "members/properties 'begin' and 'end'."); +static assert(__traits(compiles, (new string[1])[0]=(new Location[1])[0].toString()), + "error: struct/class Location must have toString method."); + +private immutable bool yy_location_is_class = !__traits(compiles, *(new Location((new Position[1])[0])));]], [[ +/** + * A struct defining a pair of positions. Positions, defined by the + * Position struct, denote a point in the input. + * Locations represent a part of the input through the beginning + * and ending positions. */ +public struct ]b4_location_type[ +{ + /** The first, inclusive, position in the range. */ + public Position begin; + + /** The first position beyond the range. */ + public Position end; + + /** + * Create a Location denoting an empty range located at + * a given point. + * @@param loc The position at which the range is anchored. */ + public this(Position loc) + { + this.begin = this.end = loc; + } + + /** + * Create a Location from the endpoints of the range. + * @@param begin The first position included in the range. + * @@param end The first position beyond the range. */ + public this(Position begin, Position end) + { + this.begin = begin; + this.end = end; + } + + /** + * Reset initial location to final location. + */ + public void step() + { + this.begin = this.end; + } + + /** + * A representation of the location. + */ + public string toString() const + { + auto end_col = 0 < end.column ? end.column - 1 : 0; + auto res = begin.toString (); + if (end.filename && begin.filename != end.filename) + res ~= "-" ~ format("%s:%d.%d", end.filename, end.line, end_col); + else if (begin.line < end.line) + res ~= "-" ~ format("%d.%d", end.line, end_col); + else if (begin.column < end_col) + res ~= "-" ~ format("%d", end_col); + return res; + } +} + +private immutable bool yy_location_is_class = false; + +]])])[]b4_value_type_setup[]m4_ifdef([b4_user_union_members], [private union YYSemanticType +{ +b4_user_union_members +};], +[m4_if(b4_tag_seen_flag, 0, +[[private alias int YYSemanticType;]])])[ +]b4_token_enums[ +]b4_parser_class_declaration[ +{ + ]b4_identification[ + +]b4_declare_symbol_enum[ + +]b4_locations_if([[ + private final Location yylloc_from_stack (ref YYStack rhs, int n) + { + static if (yy_location_is_class) { + if (n > 0) + return new Location (rhs.locationAt (n-1).begin, rhs.locationAt (0).end); + else + return new Location (rhs.locationAt (0).end); + } else { + if (n > 0) + return Location (rhs.locationAt (n-1).begin, rhs.locationAt (0).end); + else + return Location (rhs.locationAt (0).end); + } + }]])[ + +]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([[ + /** + * Instantiate the Bison-generated parser. + */ + public this] (b4_parse_param_decl([b4_lex_param_decl])[) { +]b4_percent_code_get([[init]])[]b4_lac_if([[ + this.yylacStack = new int[]; + this.yylacEstablished = false;]])[ + this (new YYLexer(]b4_lex_param_call[)); + } +]])[ + + /** + * Instantiate the Bison-generated parser. + * @@param yylexer The scanner that will supply tokens to the parser. + */ + ]b4_lexer_if([[protected]], [[public]]) [this (]b4_parse_param_decl([[Lexer yylexer]])[) { + this.yylexer = yylexer;]b4_parse_trace_if([[ + this.yyDebugStream = stderr;]])[ +]b4_parse_param_cons[ + } +]b4_parse_trace_if([[ + import std.stdio; + private File yyDebugStream; + + /** + * The File on which the debugging output is + * printed. + */ + public File getDebugStream () { return yyDebugStream; } + + /** + * Set the std.File on which the debug output is printed. + * @@param s The stream that is used for debugging output. + */ + public final void setDebugStream(File 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; } + + protected final void yycdebug (string s) { + if (0 < yydebug) + yyDebugStream.write (s); + } + + protected final void yycdebugln (string s) { + if (0 < yydebug) + yyDebugStream.writeln (s); + } +]])[ + private final ]b4_parser_class[.Symbol yylex () { + return yylexer.yylex (); + } + + protected final void yyerror (]b4_locations_if([[const Location loc, ]])[string s) { + yylexer.yyerror (]b4_locations_if([loc, ])[s); + } + + /** + * The number of syntax errors so far. + */ + public int numberOfErrors() const { return yynerrs_; } + private int yynerrs_ = 0; + + /** + * Returned by a Bison action in order to stop the parsing process and + * return success (true). */ + public static immutable int YYACCEPT = 0; + + /** + * Returned by a Bison action in order to stop the parsing process and + * return failure (false). */ + public static immutable int YYABORT = 1; +]b4_push_if([ + /** + * Returned by a Bison action in order to request a new token. + */ + public static immutable int YYPUSH_MORE = 4;])[ + + /** + * Returned by a Bison action in order to start error recovery without + * printing an error message. */ + public static immutable int YYERROR = 2; + + // Internal return codes that are not supported for user semantic + // actions. + private static immutable int YYERRLAB = 3; + private static immutable int YYNEWSTATE = 4; + private static immutable int YYDEFAULT = 5; + private static immutable int YYREDUCE = 6; + private static immutable int YYERRLAB1 = 7; + private static immutable int YYRETURN = 8; +]b4_push_if([[ private static immutable int YYGETTOKEN = 9; /* Signify that a new token is expected when doing push-parsing. */]])[ + +]b4_locations_if([ + private static immutable YYSemanticType yy_semantic_null;])[ + private int yyerrstatus_ = 0; + + private void yyerrok() + { + yyerrstatus_ = 0; + } + + // Lookahead symbol kind. + SymbolKind yytoken = ]b4_symbol(empty, kind)[; + + /* State. */ + int yyn = 0; + int yylen = 0; + int yystate = 0; + + YYStack yystack; + + int label = YYNEWSTATE; + + /* Error handling. */ +]b4_locations_if([[ + /// The location where the error started. + Location yyerrloc; + + /// Location of the lookahead. + Location yylloc; + + /// @@$. + Location yyloc;]])[ + + /// Semantic value of the lookahead. + Value yylval; + + /** + * 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 bool recovering () + { + return yyerrstatus_ == 0; + } + + /** Compute post-reduction state. + * @@param yystate the current state + * @@param yysym the nonterminal to push on the stack + */ + private int yyLRGotoState(int yystate, int yysym) { + int yyr = yypgoto_[yysym - yyntokens_] + yystate; + if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) + return yytable_[yyr]; + else + return yydefgoto_[yysym - yyntokens_]; + } + + private int yyaction (int yyn, ref YYStack yystack, int yylen) + { + Value yyval;]b4_locations_if([[ + Location yyloc = yylloc_from_stack (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); + +]b4_parse_trace_if([[ + yy_reduce_print (yyn, yystack);]])[ + + switch (yyn) + { +]b4_user_actions[ + default: break; + } + +]b4_parse_trace_if([[ + yy_symbol_print ("-> $$ =", to!SymbolKind (yyr1_[yyn]), yyval]b4_locations_if([, yyloc])[);]])[ + + yystack.pop (yylen); + yylen = 0; + + /* Shift the result of the reduction. */ + int yystate = yyLRGotoState(yystack.stateAt(0), yyr1_[yyn]); + yystack.push (yystate, yyval]b4_locations_if([, yyloc])[); + return YYNEWSTATE; + } + +]b4_parse_trace_if([[ + /*--------------------------------. + | Print this symbol on YYOUTPUT. | + `--------------------------------*/ + + private final void yy_symbol_print (string s, SymbolKind yykind, + ref Value yyval]b4_locations_if([, ref Location yyloc])[) + { + if (0 < yydebug) + { + File yyo = yyDebugStream; + yyo.write(s); + yyo.write(yykind < yyntokens_ ? " token " : " nterm "); + yyo.write(format("%s", yykind)); + yyo.write(" ("]b4_locations_if([ ~ yyloc.toString() ~ ": "])[); + ]b4_symbol_actions([printer])[ + yyo.write(")\n"); + } + } +]])[ +]b4_symbol_type_define[ +]b4_push_if([[ + /** + * Push Parse input from external lexer + * + * @@param yyla current Symbol + * + * @@return YYACCEPT, YYABORT, YYPUSH_MORE + */ + public int pushParse(Symbol yyla)]], [[ + /** + * 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 bool parse()]])[ + {]b4_push_if([[ + if (!this.pushParseInitialized) + { + pushParseInitialize(); + yyerrstatus_ = 0; + } + else + label = YYGETTOKEN; + + bool push_token_consumed = true; +]], [[ bool yyresult;]b4_lac_if([[ + // Discard the LAC context in case there still is one left from a + // previous invocation. + yylacDiscard("init");]])[]b4_parse_trace_if([[ + + yycdebugln ("Starting parse");]])[ + 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])[); + + label = YYNEWSTATE;]])[ + for (;;) + final switch (label) + { + /* New state. Unlike in the C/C++ skeletons, the state is already + pushed when we come here. */ + case YYNEWSTATE:]b4_parse_trace_if([[ + yycdebugln (format("Entering state %d", yystate)); + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + + /* Accept? */ + if (yystate == yyfinal_)]b4_push_if([[ + { + label = YYACCEPT; + break; + }]], [[ + return true;]])[ + + /* Take a decision. First try without lookahead. */ + yyn = yypact_[yystate]; + if (yyPactValueIsDefault(yyn)) + { + label = YYDEFAULT; + break; + }]b4_push_if([[ + goto case; + + case YYGETTOKEN:]])[ + + /* Read a lookahead token. */ + if (yytoken == ]b4_symbol(empty, kind)[) + {]b4_push_if([[ + if (!push_token_consumed) + return YYPUSH_MORE;]])[]b4_parse_trace_if([[ + yycdebugln ("Reading a token");]])[]b4_push_if([[ + yytoken = yyla.token; + yylval = yyla.value;]b4_locations_if([[ + yylloc = yyla.location;]])[ + push_token_consumed = false;]], [[ + Symbol yysymbol = yylex(); + yytoken = yysymbol.token(); + yylval = yysymbol.value();]b4_locations_if([[ + yylloc = yysymbol.location();]])[]])[ + } + + /* Token already converted to internal form. */]b4_parse_trace_if([[ + yy_symbol_print ("Next token is", yytoken, yylval]b4_locations_if([, yylloc])[);]])[ + + if (yytoken == ]b4_symbol(error, kind)[) + { + // The scanner already issued an error message, process directly + // to error recovery. But do not keep the error token as + // lookahead, it is too special and may lead us to an endless + // loop in error recovery. */ + yytoken = ]b4_symbol(undef, kind)[;]b4_locations_if([[ + yyerrloc = yylloc;]])[ + label = YYERRLAB1; + } + else + { + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) {]b4_lac_if([[ + if (!yylacEstablish(yystack, yytoken)) + label = YYERRLAB; + else]])[ + label = YYDEFAULT; + } + /* <= 0 means reduce or error. */ + else if ((yyn = yytable_[yyn]) <= 0) + { + if (yyTableValueIsError(yyn)) + label = YYERRLAB;]b4_lac_if([[ + else if (!yylacEstablish(yystack, yytoken)) + label = YYERRLAB;]])[ + else + { + yyn = -yyn; + label = YYREDUCE; + } + } + else + { + /* Shift the lookahead token. */]b4_parse_trace_if([[ + yy_symbol_print ("Shifting", yytoken, yylval]b4_locations_if([, yylloc])[);]])[ + + /* Discard the token being shifted. */ + yytoken = ]b4_symbol(empty, kind)[; + + /* 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])[);]b4_lac_if([[ + yylacDiscard("shift");]])[ + label = YYNEWSTATE; + } + } + break; + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + case YYDEFAULT: + yyn = yydefact_[yystate]; + if (yyn == 0) + label = YYERRLAB; + else + label = YYREDUCE; + break; + + /*-----------------------------. + | yyreduce -- Do a reduction. | + `-----------------------------*/ + case YYREDUCE: + yylen = yyr2_[yyn]; + label = yyaction (yyn, yystack, yylen); + yystate = yystack.stateAt (0); + break; + + /*--------------------------------------. + | yyerrlab -- here on detecting error. | + `--------------------------------------*/ + case YYERRLAB: + /* If not already recovering from an error, report this error. */ + if (yyerrstatus_ == 0) + { + ++yynerrs_; + yyreportSyntaxError(new Context(]b4_lac_if([[this, ]])[yystack, yytoken]b4_locations_if([[, yylloc]])[)); + } +]b4_locations_if([ + yyerrloc = yylloc;])[ + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + * error, discard it. */ + + /* Return failure if at end of input. */ + if (yytoken == ]b4_symbol(eof, [kind])[)]b4_push_if([[ + { + label = YYABORT; + break; + }]], [[ + return false;]])[ + else + yytoken = ]b4_symbol(empty, kind)[; + } + + /* 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. */ + + // Pop stack until we find a state that shifts the error token. + for (;;) + { + yyn = yypact_[yystate]; + if (!yyPactValueIsDefault(yyn)) + { + yyn += ]b4_symbol(error, kind)[; + if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == ]b4_symbol(error, kind)[) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yystack.height == 1)]b4_push_if([[ + { + label = YYABORT; + break; + }]],[[ + return false;]])[ + +]b4_locations_if([ yyerrloc = yystack.locationAt (0);])[ + yystack.pop (); + yystate = yystack.stateAt (0);]b4_parse_trace_if([[ + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + }]b4_push_if([[ + if (label == YYABORT) + /* Leave the switch. */ + break; +]])[ +]b4_locations_if([ + /* Muck with the stack to setup for yylloc. */ + yystack.push (0, yy_semantic_null, yylloc); + yystack.push (0, yy_semantic_null, yyerrloc); + yyloc = yylloc_from_stack (yystack, 2); + yystack.pop (2);])[ + + /* Shift the error token. */]b4_lac_if([[ + yylacDiscard("error recovery");]])[]b4_parse_trace_if([[ + yy_symbol_print ("Shifting", to!SymbolKind (yystos_[yyn]), yylval]b4_locations_if([, yyloc])[);]])[ + yystate = yyn; + yystack.push (yyn, yylval]b4_locations_if([, yyloc])[); + label = YYNEWSTATE; + break; + + /* Accept. */ + case YYACCEPT:]b4_push_if([[ + this.pushParseInitialized = false;]b4_parse_trace_if([[ + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + return YYACCEPT;]], [[ + yyresult = true; + label = YYRETURN; + break;]])[ + + /* Abort. */ + case YYABORT:]b4_push_if([[ + this.pushParseInitialized = false;]b4_parse_trace_if([[ + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + return YYABORT;]], [[ + yyresult = false; + label = YYRETURN; + break;]])[ +]b4_push_if([[]], [[ ][case YYRETURN:]b4_parse_trace_if([[ + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + return yyresult;]])[ + } + assert(0); + } + +]b4_push_if([[ + bool pushParseInitialized = false; + + /** + * (Re-)Initialize the state of the push parser. + */ + public void pushParseInitialize() + { + + /* Lookahead and lookahead in internal form. */ + this.yytoken = ]b4_symbol(empty, kind)[; + + /* State. */ + this.yyn = 0; + this.yylen = 0; + this.yystate = 0; + destroy(this.yystack); + this.label = YYNEWSTATE; +]b4_lac_if([[ + destroy(this.yylacStack); + this.yylacEstablished = false;]])[ + + /* Error handling. */ + this.yynerrs_ = 0; +]b4_locations_if([ + /* The location where the error started. */ + this.yyerrloc = Location(Position(), Position()); + this.yylloc = Location(Position(), Position());])[ + + /* Semantic value of the lookahead. */ + //destroy(this.yylval); + + /* Initialize the stack. */ + yystack.push(this.yystate, this.yylval]b4_locations_if([, this.yylloc])[); + + this.pushParseInitialized = true; + }]])[]b4_both_if([[ + /** + * Parse input from the scanner that was specified at object construction + * time. Return whether the end of the input was reached successfully. + * This version of parse() is defined only when api.push-push=both. + * + * @@return true if the parsing succeeds. Note that this does not + * imply that there were no syntax errors. + */ + bool parse() + { + int status = 0; + do { + status = this.pushParse(yylex()); + } while (status == YYPUSH_MORE); + return status == YYACCEPT; + }]])[ + + // Generate an error message. + private final void yyreportSyntaxError(Context yyctx) + {]b4_parse_error_bmatch( +[custom], [[ + yylexer.reportSyntaxError(yyctx);]], +[detailed], [[ + if (yyctx.getToken() != ]b4_symbol(empty, kind)[) + { + // FIXME: This method of building the message is not compatible + // with internationalization. + immutable int argmax = 5; + SymbolKind[] yyarg = new SymbolKind[argmax]; + int yycount = yysyntaxErrorArguments(yyctx, yyarg, argmax); + string res, yyformat; + switch (yycount) + { + case 1: + yyformat = YY_("syntax error, unexpected %s"); + res = format(yyformat, yyarg[0]); + break; + case 2: + yyformat = YY_("syntax error, unexpected %s, expecting %s"); + res = format(yyformat, yyarg[0], yyarg[1]); + break; + case 3: + yyformat = YY_("syntax error, unexpected %s, expecting %s or %s"); + res = format(yyformat, yyarg[0], yyarg[1], yyarg[2]); + break; + case 4: + yyformat = YY_("syntax error, unexpected %s, expecting %s or %s or %s"); + res = format(yyformat, yyarg[0], yyarg[1], yyarg[2], yyarg[3]); + break; + case 5: + yyformat = YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); + res = format(yyformat, yyarg[0], yyarg[1], yyarg[2], yyarg[3], yyarg[4]); + break; + default: + res = YY_("syntax error"); + break; + } + yyerror(]b4_locations_if([yyctx.getLocation(), ])[res); + }]], +[[simple]], [[ + yyerror(]b4_locations_if([yyctx.getLocation(), ])[YY_("syntax error"));]])[ + } + +]b4_parse_error_bmatch( +[detailed], [[ + private int yysyntaxErrorArguments(Context yyctx, SymbolKind[] yyarg, int yyargn) { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, + then the only way this function was invoked is if the + default action is an error action. In that case, don't + check for expected tokens because there are none. + - The only way there can be no lookahead present (in tok) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this + state is a consistent state with a default action. There + might have been a previous inconsistent state, consistent + state with a non-default action, or user semantic action + that manipulated yychar. (However, yychar is currently out + of scope during semantic actions.) + - Of course, the expected token list depends on states to + have correct lookahead information, and it depends on the + parser not to perform extra reductions after fetching a + lookahead from the scanner and before detecting a syntax + error. Thus, state merging (from LALR or IELR) and default + reductions corrupt the expected token list. However, the + list is correct for canonical LR with one exception: it + will still contain any token that will not be accepted due + to an error action in a later state. + */ + int yycount = 0; + if (yyctx.getToken() != ]b4_symbol(empty, kind)[) + { + if (yyarg !is null) + yyarg[yycount] = yyctx.getToken(); + yycount += 1; + yycount += yyctx.getExpectedTokens(yyarg, 1, yyargn); + } + return yycount; + } +]])[ + + + /** + * Information needed to get the list of expected tokens and to forge + * a syntax error diagnostic. + */ + public static final class Context + {]b4_lac_if([[ + private ]b4_parser_class[ yyparser;]])[ + private const(YYStack) yystack; + private SymbolKind yytoken;]b4_locations_if([[ + private const(Location) yylocation;]])[ + + this(]b4_lac_if([[]b4_parser_class[ parser, ]])[YYStack stack, SymbolKind kind]b4_locations_if([[, Location loc]])[) + {]b4_lac_if([[ + yyparser = parser;]])[ + yystack = stack; + yytoken = kind;]b4_locations_if([[ + yylocation = loc;]])[ + } + + final SymbolKind getToken() const + { + return yytoken; + }]b4_locations_if([[ + + final const(Location) getLocation() const + { + return yylocation; + }]])[ + /** + * Put in YYARG at most YYARGN of the expected tokens given the + * current YYCTX, and return the number of tokens stored in YYARG. If + * YYARG is null, return the number of expected tokens (guaranteed to + * be less than YYNTOKENS). + */ + int getExpectedTokens(SymbolKind[] yyarg, int yyargn)]b4_lac_if([[]], [[ const]])[ + { + return getExpectedTokens(yyarg, 0, yyargn); + } + + int getExpectedTokens(SymbolKind[] yyarg, int yyoffset, int yyargn)]b4_lac_if([[]], [[ const]])[ + { + int yycount = yyoffset;]b4_lac_if([b4_parse_trace_if([[ + // Execute LAC once. We don't care if it is successful, we + // only do it for the sake of debugging output. + + if (!yyparser.yylacEstablished) + yyparser.yylacCheck(yystack, yytoken); +]])[ + for (int yyx = 0; yyx < yyntokens_; ++yyx) + { + SymbolKind yysym = SymbolKind(yyx); + if (yysym != ]b4_symbol(error, kind)[ + && yysym != ]b4_symbol(undef, kind)[ + && yyparser.yylacCheck(yystack, yysym)) + { + if (yyarg == null) + yycount += 1; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = yysym; + } + }]], [[ + int yyn = yypact_[this.yystack.stateAt(0)]; + if (!yyPactValueIsDefault(yyn)) + { + /* Start YYX at -YYN if negative to avoid negative + indexes in YYCHECK. In other words, skip the first + -YYN actions for this state because they are default + actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = yylast_ - yyn + 1; + int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != ]b4_symbol(error, kind)[ + && !yyTableValueIsError(yytable_[yyx + yyn])) + { + if (yyarg is null) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = SymbolKind(yyx); + } + }]])[ + if (yyarg !is null && yycount == yyoffset && yyoffset < yyargn) + yyarg[yyoffset] = ]b4_symbol(empty, kind)[; + return yycount - yyoffset; + } + } + +]b4_lac_if([[ + /** Check the lookahead yytoken. + * \returns true iff the token will be eventually shifted. + */ + bool yylacCheck(const YYStack yystack, SymbolKind yytoken) + { + // Logically, the yylacStack's lifetime is confined to this function. + // Clear it, to get rid of potential left-overs from previous call. + destroy(yylacStack); + // Reduce until we encounter a shift and thereby accept the token. +]b4_parse_trace_if([[ + yycdebug("LAC: checking lookahead " ~ format("%s", yytoken) ~ ":");]])[ + int lacTop = 0; + while (true) + { + int topState = (yylacStack.length == 0 + ? yystack.stateAt(lacTop) + : yylacStack[$ - 1]); + int yyrule = yypact_[topState]; + if (yyPactValueIsDefault(yyrule) + || (yyrule += yytoken) < 0 || yylast_ < yyrule + || yycheck_[yyrule] != yytoken) + { + // Use the default action. + yyrule = yydefact_[+topState]; + if (yyrule == 0) + {]b4_parse_trace_if([[ + yycdebugln(" Err");]])[ + return false; + } + } + else + { + // Use the action from yytable. + yyrule = yytable_[yyrule]; + if (yyTableValueIsError(yyrule)) + {]b4_parse_trace_if([[ + yycdebugln(" Err");]])[ + return false; + } + if (0 < yyrule) + {]b4_parse_trace_if([[ + yycdebugln(" S" ~ to!string(yyrule));]])[ + return true; + } + yyrule = -yyrule; + } + // By now we know we have to simulate a reduce. +]b4_parse_trace_if([[ + yycdebug(" R" ~ to!string(yyrule - 1));]])[ + // Pop the corresponding number of values from the stack. + { + int yylen = yyr2_[yyrule]; + // First pop from the LAC stack as many tokens as possible. + int lacSize = cast (int) yylacStack.length; + if (yylen < lacSize) + { + yylacStack.length -= yylen; + yylen = 0; + } + else if (lacSize != 0) + { + destroy(yylacStack); + yylen -= lacSize; + } + // Only afterwards look at the main stack. + // We simulate popping elements by incrementing lacTop. + lacTop += yylen; + } + // Keep topState in sync with the updated stack. + topState = (yylacStack.length == 0 + ? yystack.stateAt(lacTop) + : yylacStack[$ - 1]); + // Push the resulting state of the reduction. + int state = yyLRGotoState(topState, yyr1_[yyrule]);]b4_parse_trace_if([[ + yycdebug(" G" ~ to!string(state));]])[ + yylacStack.length++; + yylacStack[$ - 1] = state; + } + } + + /** Establish the initial context if no initial context currently exists. + * \returns true iff the token will be eventually shifted. + */ + bool yylacEstablish(YYStack yystack, SymbolKind yytoken) + { + /* Establish the initial context for the current lookahead if no initial + context is currently established. + + We define a context as a snapshot of the parser stacks. We define + the initial context for a lookahead as the context in which the + parser initially examines that lookahead in order to select a + syntactic action. Thus, if the lookahead eventually proves + syntactically unacceptable (possibly in a later context reached via a + series of reductions), the initial context can be used to determine + the exact set of tokens that would be syntactically acceptable in the + lookahead's place. Moreover, it is the context after which any + further semantic actions would be erroneous because they would be + determined by a syntactically unacceptable token. + + yylacEstablish should be invoked when a reduction is about to be + performed in an inconsistent state (which, for the purposes of LAC, + includes consistent states that don't know they're consistent because + their default reductions have been disabled). + + For parse.lac=full, the implementation of yylacEstablish is as + follows. If no initial context is currently established for the + current lookahead, then check if that lookahead can eventually be + shifted if syntactic actions continue from the current context. */ + if (yylacEstablished) + return true; + else + {]b4_parse_trace_if([[ + yycdebugln("LAC: initial context established for " ~ format("%s", yytoken));]])[ + yylacEstablished = true; + return yylacCheck(yystack, yytoken); + } + } + + /** Discard any previous initial lookahead context because of event. + * \param event the event which caused the lookahead to be discarded. + * Only used for debbuging output. */ + void yylacDiscard(string event) + { + /* Discard any previous initial lookahead context because of Event, + which may be a lookahead change or an invalidation of the currently + established initial context for the current lookahead. + + The most common example of a lookahead change is a shift. An example + of both cases is syntax error recovery. That is, a syntax error + occurs when the lookahead is syntactically erroneous for the + currently established initial context, so error recovery manipulates + the parser stacks to try to find a new initial context in which the + current lookahead is syntactically acceptable. If it fails to find + such a context, it discards the lookahead. */ + if (yylacEstablished) + {]b4_parse_trace_if([[ + yycdebugln("LAC: initial context discarded due to " ~ event);]])[ + yylacEstablished = false; + } + } + + /** The stack for LAC. + * Logically, the yylacStack's lifetime is confined to the function + * yylacCheck. We just store it as a member of this class to hold + * on to the memory and to avoid frequent reallocations. + */ + int[] yylacStack; + /** Whether an initial LAC context was established. */ + bool yylacEstablished; +]])[ + + /** + * Whether the given yypact_ value indicates a defaulted state. + * @@param yyvalue the value to check + */ + private static bool yyPactValueIsDefault(int yyvalue) + { + return yyvalue == yypact_ninf_; + } + + /** + * Whether the given yytable_ value indicates a syntax error. + * @@param yyvalue the value to check + */ + private static bool yyTableValueIsError(int yyvalue) + { + return yyvalue == yytable_ninf_; + } + + /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ + private static immutable ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[; + + /* 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 YYTABLE_NINF_, syntax error. */ + private static immutable ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[; + + ]b4_parser_tables_define[ + +]b4_parse_trace_if([[ + /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ + private static immutable ]b4_int_type_for([b4_rline])[[] yyrline_ = + @{ + ]b4_rline[ + @}; + + // Report on the debug stream that the rule yyrule is going to be reduced. + private final void yy_reduce_print (int yyrule, ref YYStack yystack) + { + if (yydebug == 0) + return; + + int yylno = yyrline_[yyrule]; + int yynrhs = yyr2_[yyrule]; + /* Print the symbols being reduced, and their result. */ + yycdebugln (format("Reducing stack by rule %d (line %d):", + yyrule - 1, yylno)); + + /* The symbols being reduced. */ + for (int yyi = 0; yyi < yynrhs; yyi++) + yy_symbol_print (format(" $%d =", yyi + 1), + to!SymbolKind (yystos_[yystack.stateAt(yynrhs - (yyi + 1))]), + ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([, + b4_rhs_location(yynrhs, yyi + 1)])[); + } +]])[ + + private static auto yytranslate_ (int t) + { +]b4_api_token_raw_if( +[[ return SymbolKind(t);]], +[[ /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ + immutable ]b4_int_type_for([b4_translate])[[] translate_table = + @{ + ]b4_translate[ + @}; + + // Last valid token kind. + immutable int code_max = ]b4_code_max[; + + if (t <= 0) + return ]b4_symbol(eof, kind)[; + else if (t <= code_max) + return SymbolKind(translate_table[t]); + else + return ]b4_symbol(undef, kind)[;]])[ + } + + private static immutable int yylast_ = ]b4_last[; + private static immutable int yynnts_ = ]b4_nterms_number[; + private static immutable int yyfinal_ = ]b4_final_state_number[; + private static immutable int yyntokens_ = ]b4_tokens_number[; + + private final struct YYStackElement { + int state; + Value value;]b4_locations_if( + b4_location_type[[] location;])[ + } + + private final struct YYStack { + private YYStackElement[] stack = []; + + public final ulong height() + { + return stack.length; + } + + public final void push (int state, Value value]dnl + b4_locations_if([, ref Location loc])[) + { + stack ~= YYStackElement(state, value]b4_locations_if([, loc])[); + } + + public final void pop () + { + pop (1); + } + + public final void pop (int num) + { + stack.length -= num; + } + + public final int stateAt (int i) const + { + return stack[$-i-1].state; + } + +]b4_locations_if([[ + public final ref Location locationAt (int i) + { + return stack[$-i-1].location; + }]])[ + + public final ref Value valueAt (int i) + { + return stack[$-i-1].value; + } +]b4_parse_trace_if([[ + // Print the state stack on the debug stream. + public final void print (File stream) + { + stream.write ("Stack now"); + for (int i = 0; i < stack.length; i++) + stream.write (" ", stack[i].state); + stream.writeln (); + }]])[ + } +]b4_percent_code_get[ +} +]b4_percent_code_get([[epilogue]])[]dnl +b4_epilogue[]dnl +b4_output_end diff --git a/compiler/win_flex_bison/data/skeletons/lalr1.java b/compiler/win_flex_bison/data/skeletons/lalr1.java new file mode 100644 index 0000000..1bbecca --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/lalr1.java @@ -0,0 +1,1303 @@ +# Java skeleton for Bison -*- java -*- + +# Copyright (C) 2007-2015, 2018-2021 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_skeletonsdir/[java.m4]) + +b4_header_if([b4_complain([%header/%defines does not make sense in Java])]) + +m4_define([b4_symbol_no_destructor_assert], +[b4_symbol_if([$1], [has_destructor], + [b4_complain_at(m4_unquote(b4_symbol([$1], [destructor_loc])), + [%destructor does not make sense in Java])])]) +b4_symbol_foreach([b4_symbol_no_destructor_assert]) + +## --------------- ## +## api.push-pull. ## +## --------------- ## + +b4_percent_define_default([[api.push-pull]], [[pull]]) +b4_percent_define_check_values([[[[api.push-pull]], + [[pull]], [[push]], [[both]]]]) + +# Define m4 conditional macros that encode the value +# of the api.push-pull flag. +b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]]) +b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]]) +m4_case(b4_percent_define_get([[api.push-pull]]), + [pull], [m4_define([b4_push_flag], [[0]])], + [push], [m4_define([b4_pull_flag], [[0]])]) + +# Define a macro to be true when api.push-pull has the value "both". +m4_define([b4_both_if],[b4_push_if([b4_pull_if([$1],[$2])],[$2])]) + +# Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing +# tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the +# behavior of Bison at all when push parsing is already requested. +b4_define_flag_if([use_push_for_pull]) +b4_use_push_for_pull_if([ + b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])], + [m4_define([b4_push_flag], [[1]])])]) + +# Define a macro to encapsulate the parse state variables. This +# allows them to be defined either in parse() when doing pull parsing, +# or as class instance variable when doing push parsing. +m4_define([b4_define_state], +[[ + /* Lookahead token kind. */ + int yychar = YYEMPTY_; + /* Lookahead symbol kind. */ + SymbolKind yytoken = null; + + /* State. */ + int yyn = 0; + int yylen = 0; + int yystate = 0; + YYStack yystack = new YYStack (); + int label = YYNEWSTATE; + +]b4_locations_if([[ + /* The location where the error started. */ + ]b4_location_type[ yyerrloc = null; + + /* Location. */ + ]b4_location_type[ yylloc = new ]b4_location_type[ (null, null);]])[ + + /* Semantic value of the lookahead. */ + ]b4_yystype[ yylval = null; +]]) + +# parse.lac +b4_percent_define_default([[parse.lac]], [[none]]) +b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]]) +b4_define_flag_if([lac]) +m4_define([b4_lac_flag], + [m4_if(b4_percent_define_get([[parse.lac]]), + [none], [[0]], [[1]])]) + + +## ------------- ## +## Parser File. ## +## ------------- ## + +b4_output_begin([b4_parser_file_name])[ +]b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java], + [2007-2015, 2018-2021])[ +]b4_disclaimer[ +]b4_percent_define_ifdef([api.package], [package b4_percent_define_get([api.package]);[ +]])[ +]b4_user_pre_prologue[ +]b4_user_post_prologue[ +import java.text.MessageFormat; +import java.util.ArrayList; +]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_parser_class_declaration[ +{ +]b4_identification[ +][ +]b4_parse_error_bmatch( + [detailed\|verbose], [[ + /** + * True if verbose error messages are enabled. + */ + private boolean yyErrorVerbose = true; + + /** + * Whether verbose error messages are enabled. + */ + public final boolean getErrorVerbose() { return yyErrorVerbose; } + + /** + * Set the verbosity of error messages. + * @@param verbose True to request verbose error messages. + */ + public final void setErrorVerbose(boolean verbose) + { yyErrorVerbose = verbose; } +]])[ + +]b4_locations_if([[ + /** + * A class defining a pair of positions. Positions, defined by the + * ]b4_position_type[ class, denote a point in the input. + * Locations represent a part of the input through the beginning + * and ending positions. + */ + public static 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(); + } + } + + private ]b4_location_type[ yylloc(YYStack rhs, int n) + { + if (0 < n) + return new ]b4_location_type[(rhs.locationAt(n-1).begin, rhs.locationAt(0).end); + else + return new ]b4_location_type[(rhs.locationAt(0).end); + }]])[ + +]b4_declare_symbol_enum[ + + /** + * Communication interface between the scanner and the Bison-generated + * parser ]b4_parser_class[. + */ + public interface Lexer { +]b4_token_enums[ + /** Deprecated, use ]b4_symbol(eof, id)[ instead. */ + public static final int EOF = ]b4_symbol(eof, id)[; +]b4_pull_if([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])[; +]])[ + /** + * Emit an error]b4_locations_if([ referring to the given location])[in a user-defined way. + * + *]b4_locations_if([[ @@param loc The location of the element to which the + * error message is related.]])[ + * @@param msg The string for the error message. + */ + void yyerror(]b4_locations_if([b4_location_type[ loc, ]])[String msg); + +]b4_parse_error_bmatch( + [custom], [[ + /** + * Build and emit a "syntax error" message in a user-defined way. + * + * @@param ctx The context of the error. + */ + void reportSyntaxError(Context ctx); +]])[ + } + +]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[(]b4_parse_param_decl([b4_lex_param_decl])[)]b4_maybe_throws([b4_init_throws])[ + { +]b4_percent_code_get([[init]])[]b4_lac_if([[ + this.yylacStack = new ArrayList(); + this.yylacEstablished = false;]])[ + 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[(]b4_parse_param_decl([[Lexer yylexer]])[)]b4_maybe_throws([b4_init_throws])[ + { +]b4_percent_code_get([[init]])[]b4_lac_if([[ + this.yylacStack = new ArrayList(); + this.yylacEstablished = false;]])[ + this.yylexer = yylexer; +]b4_parse_param_cons[ + } + +]b4_parse_trace_if([[ + private java.io.PrintStream yyDebugStream = System.err; + + /** + * 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 int yynerrs = 0; + + /** + * The number of syntax errors so far. + */ + public final int getNumberOfErrors() { return yynerrs; } + + /** + * Print an error message via the lexer. + *]b4_locations_if([[ Use a null location.]])[ + * @@param msg The error message. + */ + public final void yyerror(String msg) { + yylexer.yyerror(]b4_locations_if([[(]b4_location_type[)null, ]])[msg); + } +]b4_locations_if([[ + /** + * Print an error message via the lexer. + * @@param loc The location associated with the message. + * @@param msg The error message. + */ + public final void yyerror(]b4_location_type[ loc, String msg) { + yylexer.yyerror(loc, msg); + } + + /** + * Print an error message via the lexer. + * @@param pos The position associated with the message. + * @@param msg The error message. + */ + public final void yyerror(]b4_position_type[ pos, String msg) { + yylexer.yyerror(new ]b4_location_type[ (pos), msg); + }]])[ +]b4_parse_trace_if([[ + protected final void yycdebugNnl(String s) { + if (0 < yydebug) + yyDebugStream.print(s); + } + + protected final void yycdebug(String s) { + if (0 < yydebug) + 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]b4_locations_if([, ]b4_location_type[ loc])[) { + height++; + if (size == height) { + int[] newStateStack = new int[size * 2]; + System.arraycopy(stateStack, 0, newStateStack, 0, height); + stateStack = newStateStack;]b4_locations_if([[ + ]b4_location_type[[] newLocStack = new ]b4_location_type[[size * 2]; + System.arraycopy(locStack, 0, newLocStack, 0, height); + locStack = newLocStack;]]) + + b4_yystype[[] newValueStack = new ]b4_yystype[[size * 2]; + System.arraycopy(valueStack, 0, newValueStack, 0, height); + valueStack = newValueStack; + + size *= 2; + } + + stateStack[height] = state;]b4_locations_if([[ + locStack[height] = loc;]])[ + valueStack[height] = value; + } + + public final void pop() { + pop(1); + } + + public final void pop(int num) { + // Avoid memory leaks... garbage collection is a white lie! + if (0 < num) { + java.util.Arrays.fill(valueStack, height - num + 1, height + 1, null);]b4_locations_if([[ + java.util.Arrays.fill(locStack, height - num + 1, height + 1, null);]])[ + } + height -= num; + } + + public final int stateAt(int i) { + return stateStack[height - i]; + } +]b4_locations_if([[ + + public final ]b4_location_type[ locationAt(int i) { + return locStack[height - i]; + } +]])[ + public final ]b4_yystype[ valueAt(int i) { + return valueStack[height - i]; + } + + // Print the state stack on the debug stream. + public void print(java.io.PrintStream out) { + out.print ("Stack now"); + + for (int i = 0; i <= height; i++) { + out.print(' '); + out.print(stateStack[i]); + } + out.println(); + } + } + + /** + * Returned by a Bison action in order to stop the parsing process and + * return success (true). + */ + public static final int YYACCEPT = 0; + + /** + * Returned by a Bison action in order to stop the parsing process and + * return failure (false). + */ + public static final int YYABORT = 1; + +]b4_push_if([ + /** + * Returned by a Bison action in order to request a new token. + */ + public static final int YYPUSH_MORE = 4;])[ + + /** + * Returned by a Bison action in order to start error recovery without + * printing an error message. + */ + public static final int YYERROR = 2; + + /** + * Internal return codes that are not supported for user semantic + * actions. + */ + private static final int YYERRLAB = 3; + private static final int YYNEWSTATE = 4; + private static final int YYDEFAULT = 5; + private static final int YYREDUCE = 6; + private static final int YYERRLAB1 = 7; + private static final int YYRETURN = 8; +]b4_push_if([[ private static final int YYGETTOKEN = 9; /* Signify that a new token is expected when doing push-parsing. */]])[ + + private int yyerrstatus_ = 0; + +]b4_push_if([b4_define_state])[ + /** + * 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; + } + + /** Compute post-reduction state. + * @@param yystate the current state + * @@param yysym the nonterminal to push on the stack + */ + private int yyLRGotoState(int yystate, int yysym) { + int yyr = yypgoto_[yysym - YYNTOKENS_] + yystate; + if (0 <= yyr && yyr <= YYLAST_ && yycheck_[yyr] == yystate) + return yytable_[yyr]; + else + return yydefgoto_[yysym - YYNTOKENS_]; + } + + private int yyaction(int yyn, YYStack yystack, int yylen)]b4_maybe_throws([b4_throws])[ + { + /* 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. */ + ]b4_yystype[ yyval = (0 < yylen) ? yystack.valueAt(yylen - 1) : yystack.valueAt(0);]b4_locations_if([[ + ]b4_location_type[ yyloc = yylloc(yystack, yylen);]])[]b4_parse_trace_if([[ + + yyReducePrint(yyn, yystack);]])[ + + switch (yyn) + { + ]b4_user_actions[ + default: break; + }]b4_parse_trace_if([[ + + yySymbolPrint("-> $$ =", SymbolKind.get(yyr1_[yyn]), yyval]b4_locations_if([, yyloc])[);]])[ + + yystack.pop(yylen); + yylen = 0; + /* Shift the result of the reduction. */ + int yystate = yyLRGotoState(yystack.stateAt(0), yyr1_[yyn]); + yystack.push(yystate, yyval]b4_locations_if([, yyloc])[); + return YYNEWSTATE; + } + +]b4_parse_trace_if([[ + /*--------------------------------. + | Print this symbol on YYOUTPUT. | + `--------------------------------*/ + + private void yySymbolPrint(String s, SymbolKind yykind, + ]b4_yystype[ yyvalue]b4_locations_if([, ]b4_location_type[ yylocation])[) { + if (0 < yydebug) { + yycdebug(s + + (yykind.getCode() < YYNTOKENS_ ? " token " : " nterm ") + + yykind.getName() + " ("]b4_locations_if([ + + yylocation + ": "])[ + + (yyvalue == null ? "(null)" : yyvalue.toString()) + ")"); + } + }]])[ + +]b4_push_if([],[[ + /** + * Parse input from the scanner that was specified at object construction + * time. Return whether the end of the input was reached successfully. + * + * @@return true if the parsing succeeds. Note that this does not + * imply that there were no syntax errors. + */ + public boolean parse()]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[]])[ +]b4_push_if([ + /** + * Push Parse input from external lexer + * + * @@param yylextoken current token + * @@param yylexval current lval]b4_locations_if([[ + * @@param yylexloc current position]])[ + * + * @@return YYACCEPT, YYABORT, YYPUSH_MORE + */ + public int push_parse(int yylextoken, b4_yystype yylexval[]b4_locations_if([, b4_location_type yylexloc]))b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])])[ + {]b4_locations_if([[ + /* @@$. */ + ]b4_location_type[ yyloc;]])[ +]b4_push_if([],[[ +]b4_define_state[ +]b4_lac_if([[ + // Discard the LAC context in case there still is one left from a + // previous invocation. + yylacDiscard("init");]])[ +]b4_parse_trace_if([[ + yycdebug ("Starting parse");]])[ + yyerrstatus_ = 0; + yynerrs = 0; + + /* Initialize the stack. */ + yystack.push (yystate, yylval]b4_locations_if([, yylloc])[); +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [], [yylloc])dnl + b4_user_initial_action +b4_dollar_popdef[]dnl +])[ +]])[ +]b4_push_if([[ + if (!this.push_parse_initialized) + { + push_parse_initialize (); +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [], [yylloc])dnl + b4_user_initial_action +b4_dollar_popdef[]dnl +])[]b4_parse_trace_if([[ + yycdebug ("Starting parse");]])[ + yyerrstatus_ = 0; + } else + label = YYGETTOKEN; + + boolean push_token_consumed = true; +]])[ + for (;;) + switch (label) + { + /* New state. Unlike in the C/C++ skeletons, the state is already + pushed when we come here. */ + case YYNEWSTATE:]b4_parse_trace_if([[ + yycdebug ("Entering state " + yystate); + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + + /* Accept? */ + if (yystate == YYFINAL_) + ]b4_push_if([{label = YYACCEPT; break;}], + [return true;])[ + + /* Take a decision. First try without lookahead. */ + yyn = yypact_[yystate]; + if (yyPactValueIsDefault (yyn)) + { + label = YYDEFAULT; + break; + } +]b4_push_if([ /* Fall Through */ + + case YYGETTOKEN:])[ + /* Read a lookahead token. */ + if (yychar == YYEMPTY_) + { +]b4_push_if([[ + if (!push_token_consumed) + return YYPUSH_MORE;]b4_parse_trace_if([[ + yycdebug ("Reading a token");]])[ + yychar = yylextoken; + yylval = yylexval;]b4_locations_if([ + yylloc = yylexloc;])[ + push_token_consumed = false;]], [b4_parse_trace_if([[ + yycdebug ("Reading a token");]])[ + yychar = yylexer.yylex (); + yylval = yylexer.getLVal();]b4_locations_if([[ + yylloc = new ]b4_location_type[(yylexer.getStartPos(), + yylexer.getEndPos());]])[ +]])[ + } + + /* Convert token to internal form. */ + yytoken = yytranslate_ (yychar);]b4_parse_trace_if([[ + yySymbolPrint("Next token is", yytoken, + yylval]b4_locations_if([, yylloc])[);]])[ + + if (yytoken == ]b4_symbol(error, kind)[) + { + // The scanner already issued an error message, process directly + // to error recovery. But do not keep the error token as + // lookahead, it is too special and may lead us to an endless + // loop in error recovery. */ + yychar = Lexer.]b4_symbol(undef, id)[; + yytoken = ]b4_symbol(undef, kind)[;]b4_locations_if([[ + yyerrloc = yylloc;]])[ + label = YYERRLAB1; + } + else + { + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken.getCode(); + if (yyn < 0 || YYLAST_ < yyn || yycheck_[yyn] != yytoken.getCode()) {]b4_lac_if([[ + if (!yylacEstablish(yystack, yytoken)) { + label = YYERRLAB; + } else]])[ + label = YYDEFAULT; + } + + /* <= 0 means reduce or error. */ + else if ((yyn = yytable_[yyn]) <= 0) + { + if (yyTableValueIsError(yyn)) { + label = YYERRLAB; + }]b4_lac_if([[ else if (!yylacEstablish(yystack, yytoken)) { + label = YYERRLAB; + }]])[ else { + yyn = -yyn; + label = YYREDUCE; + } + } + + else + { + /* Shift the lookahead token. */]b4_parse_trace_if([[ + yySymbolPrint("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])[);]b4_lac_if([[ + yylacDiscard("shift");]])[ + label = YYNEWSTATE; + } + } + break; + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + case YYDEFAULT: + yyn = yydefact_[yystate]; + if (yyn == 0) + label = YYERRLAB; + else + label = YYREDUCE; + break; + + /*-----------------------------. + | yyreduce -- Do a reduction. | + `-----------------------------*/ + case YYREDUCE: + yylen = yyr2_[yyn]; + label = yyaction(yyn, yystack, yylen); + yystate = yystack.stateAt(0); + break; + + /*------------------------------------. + | yyerrlab -- here on detecting error | + `------------------------------------*/ + case YYERRLAB: + /* If not already recovering from an error, report this error. */ + if (yyerrstatus_ == 0) + { + ++yynerrs; + if (yychar == YYEMPTY_) + yytoken = null; + yyreportSyntaxError(new Context(this, yystack, yytoken]b4_locations_if([[, yylloc]])[)); + } +]b4_locations_if([[ + yyerrloc = yylloc;]])[ + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= Lexer.]b4_symbol(eof, id)[) + { + /* Return failure if at end of input. */ + if (yychar == Lexer.]b4_symbol(eof, id)[) + ]b4_push_if([{label = YYABORT; break;}], [return false;])[ + } + else + yychar = YYEMPTY_; + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + label = YYERRLAB1; + break; + + /*-------------------------------------------------. + | errorlab -- error raised explicitly by YYERROR. | + `-------------------------------------------------*/ + case YYERROR:]b4_locations_if([[ + yyerrloc = yystack.locationAt (yylen - 1);]])[ + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + yystack.pop (yylen); + yylen = 0; + yystate = yystack.stateAt(0); + label = YYERRLAB1; + break; + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + case YYERRLAB1: + yyerrstatus_ = 3; /* Each real token shifted decrements this. */ + + // Pop stack until we find a state that shifts the error token. + for (;;) + { + yyn = yypact_[yystate]; + if (!yyPactValueIsDefault (yyn)) + { + yyn += ]b4_symbol(error, kind)[.getCode(); + if (0 <= yyn && yyn <= YYLAST_ + && yycheck_[yyn] == ]b4_symbol(error, kind)[.getCode()) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the + * error token. */ + if (yystack.height == 0) + ]b4_push_if([{label = YYABORT; break;}],[return false;])[ + +]b4_locations_if([[ + yyerrloc = yystack.locationAt (0);]])[ + yystack.pop (); + yystate = yystack.stateAt(0);]b4_parse_trace_if([[ + if (0 < yydebug) + yystack.print (yyDebugStream);]])[ + } + + if (label == YYABORT) + /* Leave the switch. */ + break; + +]b4_locations_if([[ + /* Muck with the stack to setup for yylloc. */ + yystack.push (0, null, yylloc); + yystack.push (0, null, yyerrloc); + yyloc = yylloc (yystack, 2); + yystack.pop (2);]])[ + + /* Shift the error token. */]b4_lac_if([[ + yylacDiscard("error recovery");]])[]b4_parse_trace_if([[ + yySymbolPrint("Shifting", SymbolKind.get(yystos_[yyn]), + yylval]b4_locations_if([, yyloc])[);]])[ + + yystate = yyn; + yystack.push (yyn, yylval]b4_locations_if([, yyloc])[); + label = YYNEWSTATE; + break; + + /* Accept. */ + case YYACCEPT: + ]b4_push_if([this.push_parse_initialized = false; return YYACCEPT;], + [return true;])[ + + /* Abort. */ + case YYABORT: + ]b4_push_if([this.push_parse_initialized = false; return YYABORT;], + [return false;])[ + } +} +]b4_push_if([[ + boolean push_parse_initialized = false; + + /** + * (Re-)Initialize the state of the push parser. + */ + public void push_parse_initialize () + { + /* Lookahead and lookahead in internal form. */ + this.yychar = YYEMPTY_; + this.yytoken = null; + + /* State. */ + this.yyn = 0; + this.yylen = 0; + this.yystate = 0; + this.yystack = new YYStack();]b4_lac_if([[ + this.yylacStack = new ArrayList(); + this.yylacEstablished = false;]])[ + this.label = YYNEWSTATE; + + /* Error handling. */ + this.yynerrs = 0;]b4_locations_if([[ + /* The location where the error started. */ + this.yyerrloc = null; + this.yylloc = new ]b4_location_type[ (null, null);]])[ + + /* Semantic value of the lookahead. */ + this.yylval = null; + + yystack.push (this.yystate, this.yylval]b4_locations_if([, this.yylloc])[); + + this.push_parse_initialized = true; + + } +]b4_locations_if([[ + /** + * Push parse given input from an external lexer. + * + * @@param yylextoken current token + * @@param yylexval current lval + * @@param yyylexpos current position + * + * @@return YYACCEPT, YYABORT, YYPUSH_MORE + */ + public int push_parse(int yylextoken, ]b4_yystype[ yylexval, ]b4_position_type[ yylexpos)]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[ { + return push_parse(yylextoken, yylexval, new ]b4_location_type[(yylexpos)); + } +]])])[ + +]b4_both_if([[ + /** + * Parse input from the scanner that was specified at object construction + * time. Return whether the end of the input was reached successfully. + * This version of parse() is defined only when api.push-push=both. + * + * @@return true if the parsing succeeds. Note that this does not + * imply that there were no syntax errors. + */ + public boolean parse()]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[ { + if (yylexer == null) + throw new NullPointerException("Null Lexer"); + int status; + do { + int token = yylexer.yylex(); + ]b4_yystype[ lval = yylexer.getLVal();]b4_locations_if([[ + ]b4_location_type[ yyloc = new ]b4_location_type[(yylexer.getStartPos(), yylexer.getEndPos()); + status = push_parse(token, lval, yyloc);]], [[ + status = push_parse(token, lval);]])[ + } while (status == YYPUSH_MORE); + return status == YYACCEPT; + } +]])[ + + /** + * Information needed to get the list of expected tokens and to forge + * a syntax error diagnostic. + */ + public static final class Context { + Context(]b4_parser_class[ parser, YYStack stack, SymbolKind token]b4_locations_if([[, ]b4_location_type[ loc]])[) { + yyparser = parser; + yystack = stack; + yytoken = token;]b4_locations_if([[ + yylocation = loc;]])[ + } + + private ]b4_parser_class[ yyparser; + private YYStack yystack; + + + /** + * The symbol kind of the lookahead token. + */ + public final SymbolKind getToken() { + return yytoken; + } + + private SymbolKind yytoken;]b4_locations_if([[ + + /** + * The location of the lookahead. + */ + public final ]b4_location_type[ getLocation() { + return yylocation; + } + + private ]b4_location_type[ yylocation;]])[ + static final int NTOKENS = ]b4_parser_class[.YYNTOKENS_; + + /** + * Put in YYARG at most YYARGN of the expected tokens given the + * current YYCTX, and return the number of tokens stored in YYARG. If + * YYARG is null, return the number of expected tokens (guaranteed to + * be less than YYNTOKENS). + */ + int getExpectedTokens(SymbolKind yyarg[], int yyargn) { + return getExpectedTokens (yyarg, 0, yyargn); + } + + int getExpectedTokens(SymbolKind yyarg[], int yyoffset, int yyargn) { + int yycount = yyoffset;]b4_lac_if([b4_parse_trace_if([[ + // Execute LAC once. We don't care if it is successful, we + // only do it for the sake of debugging output. + if (!yyparser.yylacEstablished) + yyparser.yylacCheck(yystack, yytoken); +]])[ + for (int yyx = 0; yyx < YYNTOKENS_; ++yyx) + { + SymbolKind yysym = SymbolKind.get(yyx); + if (yysym != ]b4_symbol(error, kind)[ + && yysym != ]b4_symbol(undef, kind)[ + && yyparser.yylacCheck(yystack, yysym)) + { + if (yyarg == null) + yycount += 1; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = yysym; + } + }]], [[ + int yyn = yypact_[this.yystack.stateAt(0)]; + if (!yyPactValueIsDefault(yyn)) + { + /* Start YYX at -YYN if negative to avoid negative + indexes in YYCHECK. In other words, skip the first + -YYN actions for this state because they are default + actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST_ - yyn + 1; + int yyxend = yychecklim < NTOKENS ? yychecklim : NTOKENS; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != ]b4_symbol(error, kind)[.getCode() + && !yyTableValueIsError(yytable_[yyx + yyn])) + { + if (yyarg == null) + yycount += 1; + else if (yycount == yyargn) + return 0; // FIXME: this is incorrect. + else + yyarg[yycount++] = SymbolKind.get(yyx); + } + }]])[ + if (yyarg != null && yycount == yyoffset && yyoffset < yyargn) + yyarg[yycount] = null; + return yycount - yyoffset; + } + } + +]b4_lac_if([[ + /** Check the lookahead yytoken. + * \returns true iff the token will be eventually shifted. + */ + boolean yylacCheck(YYStack yystack, SymbolKind yytoken) + { + // Logically, the yylacStack's lifetime is confined to this function. + // Clear it, to get rid of potential left-overs from previous call. + yylacStack.clear(); + // Reduce until we encounter a shift and thereby accept the token. + yycdebugNnl("LAC: checking lookahead " + yytoken.getName() + ":"); + int lacTop = 0; + while (true) + { + int topState = (yylacStack.isEmpty() + ? yystack.stateAt(lacTop) + : yylacStack.get(yylacStack.size() - 1)); + int yyrule = yypact_[topState]; + if (yyPactValueIsDefault(yyrule) + || (yyrule += yytoken.getCode()) < 0 || YYLAST_ < yyrule + || yycheck_[yyrule] != yytoken.getCode()) + { + // Use the default action. + yyrule = yydefact_[+topState]; + if (yyrule == 0) { + yycdebug(" Err"); + return false; + } + } + else + { + // Use the action from yytable. + yyrule = yytable_[yyrule]; + if (yyTableValueIsError(yyrule)) { + yycdebug(" Err"); + return false; + } + if (0 < yyrule) { + yycdebug(" S" + yyrule); + return true; + } + yyrule = -yyrule; + } + // By now we know we have to simulate a reduce. + yycdebugNnl(" R" + (yyrule - 1)); + // Pop the corresponding number of values from the stack. + { + int yylen = yyr2_[yyrule]; + // First pop from the LAC stack as many tokens as possible. + int lacSize = yylacStack.size(); + if (yylen < lacSize) { + // yylacStack.setSize(lacSize - yylen); + for (/* Nothing */; 0 < yylen; yylen -= 1) { + yylacStack.remove(yylacStack.size() - 1); + } + yylen = 0; + } else if (lacSize != 0) { + yylacStack.clear(); + yylen -= lacSize; + } + // Only afterwards look at the main stack. + // We simulate popping elements by incrementing lacTop. + lacTop += yylen; + } + // Keep topState in sync with the updated stack. + topState = (yylacStack.isEmpty() + ? yystack.stateAt(lacTop) + : yylacStack.get(yylacStack.size() - 1)); + // Push the resulting state of the reduction. + int state = yyLRGotoState(topState, yyr1_[yyrule]); + yycdebugNnl(" G" + state); + yylacStack.add(state); + } + } + + /** Establish the initial context if no initial context currently exists. + * \returns true iff the token will be eventually shifted. + */ + boolean yylacEstablish(YYStack yystack, SymbolKind yytoken) { + /* Establish the initial context for the current lookahead if no initial + context is currently established. + + We define a context as a snapshot of the parser stacks. We define + the initial context for a lookahead as the context in which the + parser initially examines that lookahead in order to select a + syntactic action. Thus, if the lookahead eventually proves + syntactically unacceptable (possibly in a later context reached via a + series of reductions), the initial context can be used to determine + the exact set of tokens that would be syntactically acceptable in the + lookahead's place. Moreover, it is the context after which any + further semantic actions would be erroneous because they would be + determined by a syntactically unacceptable token. + + yylacEstablish should be invoked when a reduction is about to be + performed in an inconsistent state (which, for the purposes of LAC, + includes consistent states that don't know they're consistent because + their default reductions have been disabled). + + For parse.lac=full, the implementation of yylacEstablish is as + follows. If no initial context is currently established for the + current lookahead, then check if that lookahead can eventually be + shifted if syntactic actions continue from the current context. */ + if (yylacEstablished) { + return true; + } else { + yycdebug("LAC: initial context established for " + yytoken.getName()); + yylacEstablished = true; + return yylacCheck(yystack, yytoken); + } + } + + /** Discard any previous initial lookahead context because of event. + * \param event the event which caused the lookahead to be discarded. + * Only used for debbuging output. */ + void yylacDiscard(String event) { + /* Discard any previous initial lookahead context because of Event, + which may be a lookahead change or an invalidation of the currently + established initial context for the current lookahead. + + The most common example of a lookahead change is a shift. An example + of both cases is syntax error recovery. That is, a syntax error + occurs when the lookahead is syntactically erroneous for the + currently established initial context, so error recovery manipulates + the parser stacks to try to find a new initial context in which the + current lookahead is syntactically acceptable. If it fails to find + such a context, it discards the lookahead. */ + if (yylacEstablished) { + yycdebug("LAC: initial context discarded due to " + event); + yylacEstablished = false; + } + } + + /** The stack for LAC. + * Logically, the yylacStack's lifetime is confined to the function + * yylacCheck. We just store it as a member of this class to hold + * on to the memory and to avoid frequent reallocations. + */ + ArrayList yylacStack; + /** Whether an initial LAC context was established. */ + boolean yylacEstablished; +]])[ + +]b4_parse_error_bmatch( +[detailed\|verbose], [[ + private int yysyntaxErrorArguments(Context yyctx, SymbolKind[] yyarg, int yyargn) { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, + then the only way this function was invoked is if the + default action is an error action. In that case, don't + check for expected tokens because there are none. + - The only way there can be no lookahead present (in tok) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this + state is a consistent state with a default action. There + might have been a previous inconsistent state, consistent + state with a non-default action, or user semantic action + that manipulated yychar. (However, yychar is currently out + of scope during semantic actions.) + - Of course, the expected token list depends on states to + have correct lookahead information, and it depends on the + parser not to perform extra reductions after fetching a + lookahead from the scanner and before detecting a syntax + error. Thus, state merging (from LALR or IELR) and default + reductions corrupt the expected token list. However, the + list is correct for canonical LR with one exception: it + will still contain any token that will not be accepted due + to an error action in a later state. + */ + int yycount = 0; + if (yyctx.getToken() != null) + { + if (yyarg != null) + yyarg[yycount] = yyctx.getToken(); + yycount += 1; + yycount += yyctx.getExpectedTokens(yyarg, 1, yyargn); + } + return yycount; + } +]])[ + + /** + * Build and emit a "syntax error" message in a user-defined way. + * + * @@param ctx The context of the error. + */ + private void yyreportSyntaxError(Context yyctx) {]b4_parse_error_bmatch( +[custom], [[ + yylexer.reportSyntaxError(yyctx);]], +[detailed\|verbose], [[ + if (yyErrorVerbose) { + final int argmax = 5; + SymbolKind[] yyarg = new SymbolKind[argmax]; + int yycount = yysyntaxErrorArguments(yyctx, yyarg, argmax); + String[] yystr = new String[yycount]; + for (int yyi = 0; yyi < yycount; ++yyi) { + yystr[yyi] = yyarg[yyi].getName(); + } + String yyformat; + switch (yycount) { + default: + case 0: yyformat = ]b4_trans(["syntax error"])[; break; + case 1: yyformat = ]b4_trans(["syntax error, unexpected {0}"])[; break; + case 2: yyformat = ]b4_trans(["syntax error, unexpected {0}, expecting {1}"])[; break; + case 3: yyformat = ]b4_trans(["syntax error, unexpected {0}, expecting {1} or {2}"])[; break; + case 4: yyformat = ]b4_trans(["syntax error, unexpected {0}, expecting {1} or {2} or {3}"])[; break; + case 5: yyformat = ]b4_trans(["syntax error, unexpected {0}, expecting {1} or {2} or {3} or {4}"])[; break; + } + yyerror(]b4_locations_if([[yyctx.yylocation, ]])[new MessageFormat(yyformat).format(yystr)); + } else { + yyerror(]b4_locations_if([[yyctx.yylocation, ]])[]b4_trans(["syntax error"])[); + }]], +[simple], [[ + yyerror(]b4_locations_if([[yyctx.yylocation, ]])[]b4_trans(["syntax error"])[);]])[ + } + + /** + * Whether the given yypact_ value indicates a defaulted state. + * @@param yyvalue the value to check + */ + private static boolean yyPactValueIsDefault(int yyvalue) { + return yyvalue == yypact_ninf_; + } + + /** + * Whether the given yytable_ + * value indicates a syntax error. + * @@param yyvalue the value to check + */ + private static boolean yyTableValueIsError(int yyvalue) { + return yyvalue == yytable_ninf_; + } + + private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[; + private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[; + +]b4_parser_tables_define[ + +]b4_parse_trace_if([[ + ]b4_integral_parser_table_define([rline], [b4_rline], + [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[ + + + // Report on the debug stream that the rule yyrule is going to be reduced. + private void yyReducePrint (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++) + yySymbolPrint(" $" + (yyi + 1) + " =", + SymbolKind.get(yystos_[yystack.stateAt(yynrhs - (yyi + 1))]), + ]b4_rhs_data(yynrhs, yyi + 1)b4_locations_if([, + b4_rhs_location(yynrhs, yyi + 1)])[); + }]])[ + + /* YYTRANSLATE_(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ + private static final SymbolKind yytranslate_(int t) +]b4_api_token_raw_if(dnl +[[ { + return SymbolKind.get(t); + } +]], +[[ { + // Last valid token kind. + int code_max = ]b4_code_max[; + if (t <= 0) + return ]b4_symbol(eof, kind)[; + else if (t <= code_max) + return SymbolKind.get(yytranslate_table_[t]); + else + return ]b4_symbol(undef, kind)[; + } + ]b4_integral_parser_table_define([translate_table], [b4_translate])[ +]])[ + + private static final int YYLAST_ = ]b4_last[; + private static final int YYEMPTY_ = -2; + private static final int YYFINAL_ = ]b4_final_state_number[; + private static final int YYNTOKENS_ = ]b4_tokens_number[; + +]b4_percent_code_get[ +} +]b4_percent_code_get([[epilogue]])[]dnl +b4_epilogue[]dnl +b4_output_end diff --git a/compiler/win_flex_bison/data/skeletons/location.cc b/compiler/win_flex_bison/data/skeletons/location.cc new file mode 100644 index 0000000..3870b2b --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/location.cc @@ -0,0 +1,380 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_pushdef([b4_copyright_years], + [2002-2015, 2018-2021]) + + +# b4_location_file +# ---------------- +# Name of the file containing the position/location class, +# if we want this file. +b4_percent_define_check_file([b4_location_file], + [[api.location.file]], + b4_header_if([[location.hh]])) + +# b4_location_include +# ------------------- +# If location.hh is to be generated, the name under which should it be +# included. +# +# b4_location_path +# ---------------- +# The path to use for the CPP guard. +m4_ifdef([b4_location_file], +[m4_define([b4_location_include], + [b4_percent_define_get([[api.location.include]], + ["b4_location_file"])]) + m4_define([b4_location_path], + b4_percent_define_get([[api.location.include]], + ["b4_mapped_dir_prefix[]b4_location_file"])) + m4_define([b4_location_path], + m4_substr(m4_defn([b4_location_path]), 1, m4_eval(m4_len(m4_defn([b4_location_path])) - 2))) + ]) + + +# b4_position_file +# ---------------- +# Name of the file containing the position class, if we want this file. +b4_header_if( + [b4_required_version_if( + [30200], [], + [m4_ifdef([b4_location_file], + [m4_define([b4_position_file], [position.hh])])])]) + + + +# b4_location_define +# ------------------ +# Define the position and location classes. +m4_define([b4_location_define], +[[ /// A point in a source file. + class position + { + public: + /// Type for file name. + typedef ]b4_percent_define_get([[api.filename.type]])[ filename_type; + /// Type for line and column numbers. + typedef int counter_type; +]m4_ifdef([b4_location_constructors], [[ + /// Construct a position. + explicit position (filename_type* f = YY_NULLPTR, + counter_type l = ]b4_location_initial_line[, + counter_type c = ]b4_location_initial_column[) + : filename (f) + , line (l) + , column (c) + {} + +]])[ + /// Initialization. + void initialize (filename_type* fn = YY_NULLPTR, + counter_type l = ]b4_location_initial_line[, + counter_type c = ]b4_location_initial_column[) + { + filename = fn; + line = l; + column = c; + } + + /** \name Line and Column related manipulators + ** \{ */ + /// (line related) Advance to the COUNT next lines. + void lines (counter_type count = 1) + { + if (count) + { + column = ]b4_location_initial_column[; + line = add_ (line, count, ]b4_location_initial_line[); + } + } + + /// (column related) Advance to the COUNT next columns. + void columns (counter_type count = 1) + { + column = add_ (column, count, ]b4_location_initial_column[); + } + /** \} */ + + /// File name to which this position refers. + filename_type* filename; + /// Current line number. + counter_type line; + /// Current column number. + counter_type column; + + private: + /// Compute max (min, lhs+rhs). + static counter_type add_ (counter_type lhs, counter_type rhs, counter_type min) + { + return lhs + rhs < min ? min : lhs + rhs; + } + }; + + /// Add \a width columns, in place. + inline position& + operator+= (position& res, position::counter_type width) + { + res.columns (width); + return res; + } + + /// Add \a width columns. + inline position + operator+ (position res, position::counter_type width) + { + return res += width; + } + + /// Subtract \a width columns, in place. + inline position& + operator-= (position& res, position::counter_type width) + { + return res += -width; + } + + /// Subtract \a width columns. + inline position + operator- (position res, position::counter_type width) + { + return res -= width; + } +]b4_percent_define_flag_if([[define_location_comparison]], [[ + /// Compare two position objects. + inline bool + operator== (const position& pos1, const position& pos2) + { + return (pos1.line == pos2.line + && pos1.column == pos2.column + && (pos1.filename == pos2.filename + || (pos1.filename && pos2.filename + && *pos1.filename == *pos2.filename))); + } + + /// Compare two position objects. + inline bool + operator!= (const position& pos1, const position& pos2) + { + return !(pos1 == pos2); + } +]])[ + /** \brief Intercept output stream redirection. + ** \param ostr the destination output stream + ** \param pos a reference to the position to redirect + */ + template + std::basic_ostream& + operator<< (std::basic_ostream& ostr, const position& pos) + { + if (pos.filename) + ostr << *pos.filename << ':'; + return ostr << pos.line << '.' << pos.column; + } + + /// Two points in a source file. + class location + { + public: + /// Type for file name. + typedef position::filename_type filename_type; + /// Type for line and column numbers. + typedef position::counter_type counter_type; +]m4_ifdef([b4_location_constructors], [ + /// Construct a location from \a b to \a e. + location (const position& b, const position& e) + : begin (b) + , end (e) + {} + + /// Construct a 0-width location in \a p. + explicit location (const position& p = position ()) + : begin (p) + , end (p) + {} + + /// Construct a 0-width location in \a f, \a l, \a c. + explicit location (filename_type* f, + counter_type l = ]b4_location_initial_line[, + counter_type c = ]b4_location_initial_column[) + : begin (f, l, c) + , end (f, l, c) + {} + +])[ + /// Initialization. + void initialize (filename_type* f = YY_NULLPTR, + counter_type l = ]b4_location_initial_line[, + counter_type c = ]b4_location_initial_column[) + { + begin.initialize (f, l, c); + end = begin; + } + + /** \name Line and Column related manipulators + ** \{ */ + public: + /// Reset initial location to final location. + void step () + { + begin = end; + } + + /// Extend the current location to the COUNT next columns. + void columns (counter_type count = 1) + { + end += count; + } + + /// Extend the current location to the COUNT next lines. + void lines (counter_type count = 1) + { + end.lines (count); + } + /** \} */ + + + public: + /// Beginning of the located region. + position begin; + /// End of the located region. + position end; + }; + + /// Join two locations, in place. + inline location& + operator+= (location& res, const location& end) + { + res.end = end.end; + return res; + } + + /// Join two locations. + inline location + operator+ (location res, const location& end) + { + return res += end; + } + + /// Add \a width columns to the end position, in place. + inline location& + operator+= (location& res, location::counter_type width) + { + res.columns (width); + return res; + } + + /// Add \a width columns to the end position. + inline location + operator+ (location res, location::counter_type width) + { + return res += width; + } + + /// Subtract \a width columns to the end position, in place. + inline location& + operator-= (location& res, location::counter_type width) + { + return res += -width; + } + + /// Subtract \a width columns to the end position. + inline location + operator- (location res, location::counter_type width) + { + return res -= width; + } +]b4_percent_define_flag_if([[define_location_comparison]], [[ + /// Compare two location objects. + inline bool + operator== (const location& loc1, const location& loc2) + { + return loc1.begin == loc2.begin && loc1.end == loc2.end; + } + + /// Compare two location objects. + inline bool + operator!= (const location& loc1, const location& loc2) + { + return !(loc1 == loc2); + } +]])[ + /** \brief Intercept output stream redirection. + ** \param ostr the destination output stream + ** \param loc a reference to the location to redirect + ** + ** Avoid duplicate information. + */ + template + std::basic_ostream& + operator<< (std::basic_ostream& ostr, const location& loc) + { + location::counter_type end_col + = 0 < loc.end.column ? loc.end.column - 1 : 0; + ostr << loc.begin; + if (loc.end.filename + && (!loc.begin.filename + || *loc.begin.filename != *loc.end.filename)) + ostr << '-' << loc.end.filename << ':' << loc.end.line << '.' << end_col; + else if (loc.begin.line < loc.end.line) + ostr << '-' << loc.end.line << '.' << end_col; + else if (loc.begin.column < end_col) + ostr << '-' << end_col; + return ostr; + } +]]) + + +m4_ifdef([b4_position_file], [[ +]b4_output_begin([b4_dir_prefix], [b4_position_file])[ +]b4_generated_by[ +// Starting with Bison 3.2, this file is useless: the structure it +// used to define is now defined in "]b4_location_file[". +// +// To get rid of this file: +// 1. add '%require "3.2"' (or newer) to your grammar file +// 2. remove references to this file from your build system +// 3. if you used to include it, include "]b4_location_file[" instead. + +#include ]b4_location_include[ +]b4_output_end[ +]]) + + +m4_ifdef([b4_location_file], [[ +]b4_output_begin([b4_dir_prefix], [b4_location_file])[ +]b4_copyright([Locations for Bison parsers in C++])[ +/** + ** \file ]b4_location_path[ + ** Define the ]b4_namespace_ref[::location class. + */ + +]b4_cpp_guard_open([b4_location_path])[ + +# include +# include + +]b4_null_define[ + +]b4_namespace_open[ +]b4_location_define[ +]b4_namespace_close[ +]b4_cpp_guard_close([b4_location_path])[ +]b4_output_end[ +]]) + + +m4_popdef([b4_copyright_years]) diff --git a/compiler/win_flex_bison/data/skeletons/stack.hh b/compiler/win_flex_bison/data/skeletons/stack.hh new file mode 100644 index 0000000..9891325 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/stack.hh @@ -0,0 +1,157 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 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_stack_file +# ------------- +# Name of the file containing the stack class, if we want this file. +b4_header_if([b4_required_version_if([30200], [], + [m4_define([b4_stack_file], [stack.hh])])]) + + +# b4_stack_define +# --------------- +m4_define([b4_stack_define], +[[ /// A stack with random access from its top. + template > + class stack + { + public: + // Hide our reversed order. + typedef typename S::iterator iterator; + typedef typename S::const_iterator const_iterator; + typedef typename S::size_type size_type; + typedef typename std::ptrdiff_t index_type; + + stack (size_type n = 200) YY_NOEXCEPT + : seq_ (n) + {} + +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + stack (const stack&) = delete; + /// Non copyable. + stack& operator= (const stack&) = delete; +#endif + + /// Random access. + /// + /// Index 0 returns the topmost element. + const T& + operator[] (index_type i) const + { + return seq_[size_type (size () - 1 - i)]; + } + + /// Random access. + /// + /// Index 0 returns the topmost element. + T& + operator[] (index_type i) + { + return seq_[size_type (size () - 1 - i)]; + } + + /// Steal the contents of \a t. + /// + /// Close to move-semantics. + void + push (YY_MOVE_REF (T) t) + { + seq_.push_back (T ()); + operator[] (0).move (t); + } + + /// Pop elements from the stack. + void + pop (std::ptrdiff_t n = 1) YY_NOEXCEPT + { + for (; 0 < n; --n) + seq_.pop_back (); + } + + /// Pop all elements from the stack. + void + clear () YY_NOEXCEPT + { + seq_.clear (); + } + + /// Number of elements on the stack. + index_type + size () const YY_NOEXCEPT + { + return index_type (seq_.size ()); + } + + /// Iterator on top of the stack (going downwards). + const_iterator + begin () const YY_NOEXCEPT + { + return seq_.begin (); + } + + /// Bottom of the stack. + const_iterator + end () const YY_NOEXCEPT + { + return seq_.end (); + } + + /// Present a slice of the top of a stack. + class slice + { + public: + slice (const stack& stack, index_type range) YY_NOEXCEPT + : stack_ (stack) + , range_ (range) + {} + + const T& + operator[] (index_type i) const + { + return stack_[range_ - i]; + } + + private: + const stack& stack_; + index_type range_; + }; + + private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. + stack (const stack&); + /// Non copyable. + stack& operator= (const stack&); +#endif + /// The wrapped container. + S seq_; + }; +]]) + +m4_ifdef([b4_stack_file], +[b4_output_begin([b4_dir_prefix], [b4_stack_file])[ +]b4_generated_by[ +// Starting with Bison 3.2, this file is useless: the structure it +// used to define is now defined with the parser itself. +// +// To get rid of this file: +// 1. add '%require "3.2"' (or newer) to your grammar file +// 2. remove references to this file from your build system. +]b4_output_end[ +]]) diff --git a/compiler/win_flex_bison/data/skeletons/traceon.m4 b/compiler/win_flex_bison/data/skeletons/traceon.m4 new file mode 100644 index 0000000..344d7d1 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/traceon.m4 @@ -0,0 +1,2 @@ +dnl GNU M4 treats -dV in a position-independent manner. +m4_debugmode(V)m4_traceon()dnl diff --git a/compiler/win_flex_bison/data/skeletons/variant.hh b/compiler/win_flex_bison/data/skeletons/variant.hh new file mode 100644 index 0000000..2a490e8 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/variant.hh @@ -0,0 +1,525 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +## --------- ## +## variant. ## +## --------- ## + +# b4_assert +# --------- +# The name of YY_ASSERT. +m4_define([b4_assert], + [b4_api_PREFIX[]_ASSERT]) + + +# b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS]) +# ------------------------------------------------ +# Run some ACTION ("build", or "destroy") on YYVAL of symbol type +# YYTYPE. +m4_define([b4_symbol_variant], +[m4_pushdef([b4_dollar_dollar], + [$2.$3< $][3 > (m4_shift3($@))])dnl +switch ($1) + { +b4_type_foreach([_b4_type_action])[]dnl + default: + break; + } +m4_popdef([b4_dollar_dollar])dnl +]) + + +# _b4_char_sizeof_counter +# ----------------------- +# A counter used by _b4_char_sizeof_dummy to create fresh symbols. +m4_define([_b4_char_sizeof_counter], +[0]) + +# _b4_char_sizeof_dummy +# --------------------- +# At each call return a new C++ identifier. +m4_define([_b4_char_sizeof_dummy], +[m4_define([_b4_char_sizeof_counter], m4_incr(_b4_char_sizeof_counter))dnl +dummy[]_b4_char_sizeof_counter]) + + +# b4_char_sizeof(SYMBOL-NUMS) +# --------------------------- +# To be mapped on the list of type names to produce: +# +# char dummy1[sizeof (type_name_1)]; +# char dummy2[sizeof (type_name_2)]; +# +# for defined type names. +m4_define([b4_char_sizeof], +[b4_symbol_if([$1], [has_type], +[ +m4_map([ b4_symbol_tag_comment], [$@])dnl + char _b4_char_sizeof_dummy@{sizeof (b4_symbol([$1], [type]))@}; +])]) + + +# b4_variant_includes +# ------------------- +# The needed includes for variants support. +m4_define([b4_variant_includes], +[b4_parse_assert_if([[#include +#ifndef ]b4_assert[ +# include +# define ]b4_assert[ assert +#endif +]])]) + + + +## -------------------------- ## +## Adjustments for variants. ## +## -------------------------- ## + + +# b4_value_type_declare +# --------------------- +# Define value_type. +m4_define([b4_value_type_declare], +[[ /// A buffer to store and retrieve objects. + /// + /// Sort of a variant, but does not keep track of the nature + /// of the stored data, since that knowledge is available + /// via the current parser state. + class value_type + { + public: + /// Type of *this. + typedef value_type self_type; + + /// Empty construction. + value_type () YY_NOEXCEPT + : yyraw_ ()]b4_parse_assert_if([ + , yytypeid_ (YY_NULLPTR)])[ + {} + + /// Construct and fill. + template + value_type (YY_RVREF (T) t)]b4_parse_assert_if([ + : yytypeid_ (&typeid (T))])[ + {]b4_parse_assert_if([[ + ]b4_assert[ (sizeof (T) <= size);]])[ + new (yyas_ ()) T (YY_MOVE (t)); + } + +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + value_type (const self_type&) = delete; + /// Non copyable. + self_type& operator= (const self_type&) = delete; +#endif + + /// Destruction, allowed only if empty. + ~value_type () YY_NOEXCEPT + {]b4_parse_assert_if([ + ]b4_assert[ (!yytypeid_); + ])[} + +# if 201103L <= YY_CPLUSPLUS + /// Instantiate a \a T in here from \a t. + template + T& + emplace (U&&... u) + {]b4_parse_assert_if([[ + ]b4_assert[ (!yytypeid_); + ]b4_assert[ (sizeof (T) <= size); + yytypeid_ = & typeid (T);]])[ + return *new (yyas_ ()) T (std::forward (u)...); + } +# else + /// Instantiate an empty \a T in here. + template + T& + emplace () + {]b4_parse_assert_if([[ + ]b4_assert[ (!yytypeid_); + ]b4_assert[ (sizeof (T) <= size); + yytypeid_ = & typeid (T);]])[ + return *new (yyas_ ()) T (); + } + + /// Instantiate a \a T in here from \a t. + template + T& + emplace (const T& t) + {]b4_parse_assert_if([[ + ]b4_assert[ (!yytypeid_); + ]b4_assert[ (sizeof (T) <= size); + yytypeid_ = & typeid (T);]])[ + return *new (yyas_ ()) T (t); + } +# endif + + /// Instantiate an empty \a T in here. + /// Obsolete, use emplace. + template + T& + build () + { + return emplace (); + } + + /// Instantiate a \a T in here from \a t. + /// Obsolete, use emplace. + template + T& + build (const T& t) + { + return emplace (t); + } + + /// Accessor to a built \a T. + template + T& + as () YY_NOEXCEPT + {]b4_parse_assert_if([[ + ]b4_assert[ (yytypeid_); + ]b4_assert[ (*yytypeid_ == typeid (T)); + ]b4_assert[ (sizeof (T) <= size);]])[ + return *yyas_ (); + } + + /// Const accessor to a built \a T (for %printer). + template + const T& + as () const YY_NOEXCEPT + {]b4_parse_assert_if([[ + ]b4_assert[ (yytypeid_); + ]b4_assert[ (*yytypeid_ == typeid (T)); + ]b4_assert[ (sizeof (T) <= size);]])[ + return *yyas_ (); + } + + /// Swap the content with \a that, of same type. + /// + /// Both variants must be built beforehand, because swapping the actual + /// data requires reading it (with as()), and this is not possible on + /// unconstructed variants: it would require some dynamic testing, which + /// should not be the variant's responsibility. + /// Swapping between built and (possibly) non-built is done with + /// self_type::move (). + template + void + swap (self_type& that) YY_NOEXCEPT + {]b4_parse_assert_if([[ + ]b4_assert[ (yytypeid_); + ]b4_assert[ (*yytypeid_ == *that.yytypeid_);]])[ + std::swap (as (), that.as ()); + } + + /// Move the content of \a that to this. + /// + /// Destroys \a that. + template + void + move (self_type& that) + { +# if 201103L <= YY_CPLUSPLUS + emplace (std::move (that.as ())); +# else + emplace (); + swap (that); +# endif + that.destroy (); + } + +# if 201103L <= YY_CPLUSPLUS + /// Move the content of \a that to this. + template + void + move (self_type&& that) + { + emplace (std::move (that.as ())); + that.destroy (); + } +#endif + + /// Copy the content of \a that to this. + template + void + copy (const self_type& that) + { + emplace (that.as ()); + } + + /// Destroy the stored \a T. + template + void + destroy () + { + as ().~T ();]b4_parse_assert_if([ + yytypeid_ = YY_NULLPTR;])[ + } + + private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. + value_type (const self_type&); + /// Non copyable. + self_type& operator= (const self_type&); +#endif + + /// Accessor to raw memory as \a T. + template + T* + yyas_ () YY_NOEXCEPT + { + void *yyp = yyraw_; + return static_cast (yyp); + } + + /// Const accessor to raw memory as \a T. + template + const T* + yyas_ () const YY_NOEXCEPT + { + const void *yyp = yyraw_; + return static_cast (yyp); + } + + /// An auxiliary type to compute the largest semantic type. + union union_type + {]b4_type_foreach([b4_char_sizeof])[ }; + + /// The size of the largest semantic type. + enum { size = sizeof (union_type) }; + + /// A buffer to store semantic values. + union + { + /// Strongest alignment constraints. + long double yyalign_me_; + /// A buffer large enough to store any of the semantic values. + char yyraw_[size]; + };]b4_parse_assert_if([ + + /// Whether the content is built: if defined, the name of the stored type. + const std::type_info *yytypeid_;])[ + }; +]]) + + +# How the semantic value is extracted when using variants. + +# b4_symbol_value(VAL, SYMBOL-NUM, [TYPE]) +# ---------------------------------------- +# See README. +m4_define([b4_symbol_value], +[m4_ifval([$3], + [$1.as< $3 > ()], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [$1.as < b4_symbol([$2], [type]) > ()], + [$1])], + [$1])])]) + +# b4_symbol_value_template(VAL, SYMBOL-NUM, [TYPE]) +# ------------------------------------------------- +# Same as b4_symbol_value, but used in a template method. +m4_define([b4_symbol_value_template], +[m4_ifval([$3], + [$1.template as< $3 > ()], + [m4_ifval([$2], + [b4_symbol_if([$2], [has_type], + [$1.template as < b4_symbol([$2], [type]) > ()], + [$1])], + [$1])])]) + + + +## ------------- ## +## make_SYMBOL. ## +## ------------- ## + + +# _b4_includes_tokens(SYMBOL-NUM...) +# ---------------------------------- +# Expands to non-empty iff one of the SYMBOL-NUM denotes +# a token. +m4_define([_b4_is_token], + [b4_symbol_if([$1], [is_token], [1])]) +m4_define([_b4_includes_tokens], + [m4_map([_b4_is_token], [$@])]) + + +# _b4_token_maker_define(SYMBOL-NUM) +# ---------------------------------- +# Declare make_SYMBOL for SYMBOL-NUM. Use at class-level. +m4_define([_b4_token_maker_define], +[b4_token_visible_if([$1], +[#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_[]_b4_symbol([$1], [id]) (b4_join( + b4_symbol_if([$1], [has_type], + [b4_symbol([$1], [type]) v]), + b4_locations_if([location_type l]))) + { + return symbol_type (b4_join([token::b4_symbol([$1], [id])], + b4_symbol_if([$1], [has_type], [std::move (v)]), + b4_locations_if([std::move (l)]))); + } +#else + static + symbol_type + make_[]_b4_symbol([$1], [id]) (b4_join( + b4_symbol_if([$1], [has_type], + [const b4_symbol([$1], [type])& v]), + b4_locations_if([const location_type& l]))) + { + return symbol_type (b4_join([token::b4_symbol([$1], [id])], + b4_symbol_if([$1], [has_type], [v]), + b4_locations_if([l]))); + } +#endif +])]) + + +# b4_token_kind(SYMBOL-NUM) +# ------------------------- +# Some tokens don't have an ID. +m4_define([b4_token_kind], +[b4_symbol_if([$1], [has_id], + [token::b4_symbol([$1], [id])], + [b4_symbol([$1], [code])])]) + + +# _b4_tok_in(SYMBOL-NUM, ...) +# --------------------------- +# See b4_tok_in below. The SYMBOL-NUMs... are tokens only. +# +# We iterate over the tokens to group them by "range" of token numbers (not +# symbols numbers!). +# +# b4_fst is the start of that range. +# b4_prev is the previous value. +# b4_val is the current value. +# If b4_val is the successor of b4_prev in token numbers, update the latter, +# otherwise emit the code for range b4_fst .. b4_prev. +# $1 is also used as a terminator in the foreach, but it will not be printed. +# +m4_define([_b4_tok_in], +[m4_pushdef([b4_prev], [$1])dnl +m4_pushdef([b4_fst], [$1])dnl +m4_pushdef([b4_sep], [])dnl +m4_foreach([b4_val], m4_dquote(m4_shift($@, $1)), + [m4_if(b4_symbol(b4_val, [code]), m4_eval(b4_symbol(b4_prev, [code]) + 1), [], + [b4_sep[]m4_if(b4_fst, b4_prev, + [tok == b4_token_kind(b4_fst)], + [(b4_token_kind(b4_fst) <= tok && tok <= b4_token_kind(b4_prev))])[]dnl +m4_define([b4_fst], b4_val)dnl +m4_define([b4_sep], [ + || ])])dnl +m4_define([b4_prev], b4_val)])dnl +m4_popdef([b4_sep])dnl +m4_popdef([b4_fst])dnl +m4_popdef([b4_prev])dnl +]) + + +# _b4_filter_tokens(SYMBOL-NUM, ...) +# ---------------------------------- +# Expand as the list of tokens amongst SYMBOL-NUM. +m4_define([_b4_filter_tokens], +[m4_pushdef([b4_sep])dnl +m4_foreach([b4_val], [$@], + [b4_symbol_if(b4_val, [is_token], [b4_sep[]b4_val[]m4_define([b4_sep], [,])])])dnl +m4_popdef([b4_sep])dnl +]) + + +# b4_tok_in(SYMBOL-NUM, ...) +# --------------------------- +# A C++ conditional that checks that `tok` is a member of this list of symbol +# numbers. +m4_define([b4_tok_in], + [_$0(_b4_filter_tokens($@))]) + + + + +# _b4_symbol_constructor_define(SYMBOL-NUM...) +# -------------------------------------------- +# Define a symbol_type constructor common to all the SYMBOL-NUM (they +# have the same type). Use at class-level. +m4_define([_b4_symbol_constructor_define], +[m4_ifval(_b4_includes_tokens($@), +[[#if 201103L <= YY_CPLUSPLUS + symbol_type (]b4_join( + [int tok], + b4_symbol_if([$1], [has_type], + [b4_symbol([$1], [type]) v]), + b4_locations_if([location_type l]))[) + : super_type (]b4_join([token_kind_type (tok)], + b4_symbol_if([$1], [has_type], [std::move (v)]), + b4_locations_if([std::move (l)]))[) +#else + symbol_type (]b4_join( + [int tok], + b4_symbol_if([$1], [has_type], + [const b4_symbol([$1], [type])& v]), + b4_locations_if([const location_type& l]))[) + : super_type (]b4_join([token_kind_type (tok)], + b4_symbol_if([$1], [has_type], [v]), + b4_locations_if([l]))[) +#endif + {]b4_parse_assert_if([[ +#if !defined _MSC_VER || defined __clang__ + ]b4_assert[ (]b4_tok_in($@)[); +#endif + ]])[} +]])]) + + +# b4_basic_symbol_constructor_define(SYMBOL-NUM) +# ---------------------------------------------- +# Generate a constructor for basic_symbol from given type. +m4_define([b4_basic_symbol_constructor_define], +[[#if 201103L <= YY_CPLUSPLUS + basic_symbol (]b4_join( + [typename Base::kind_type t], + b4_symbol_if([$1], [has_type], [b4_symbol([$1], [type])&& v]), + b4_locations_if([location_type&& l]))[) + : Base (t)]b4_symbol_if([$1], [has_type], [ + , value (std::move (v))])[]b4_locations_if([ + , location (std::move (l))])[ + {} +#else + basic_symbol (]b4_join( + [typename Base::kind_type t], + b4_symbol_if([$1], [has_type], [const b4_symbol([$1], [type])& v]), + b4_locations_if([const location_type& l]))[) + : Base (t)]b4_symbol_if([$1], [has_type], [ + , value (v)])[]b4_locations_if([ + , location (l)])[ + {} +#endif +]]) + + +# b4_token_constructor_define +# --------------------------- +# Define the overloaded versions of make_FOO for all the token kinds. +m4_define([b4_token_constructor_define], +[ // Implementation of make_symbol for each token kind. +b4_symbol_foreach([_b4_token_maker_define])]) diff --git a/compiler/win_flex_bison/data/skeletons/yacc.c b/compiler/win_flex_bison/data/skeletons/yacc.c new file mode 100644 index 0000000..64b9ac6 --- /dev/null +++ b/compiler/win_flex_bison/data/skeletons/yacc.c @@ -0,0 +1,2209 @@ +# -*- C -*- +# Yacc compatible skeleton for Bison + +# Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software +# Foundation, Inc. + +m4_pushdef([b4_copyright_years], + [1984, 1989-1990, 2000-2015, 2018-2021]) + +# 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_skeletonsdir/[c.m4]) + + +## ---------- ## +## api.pure. ## +## ---------- ## + +b4_percent_define_default([[api.pure]], [[false]]) +b4_percent_define_check_values([[[[api.pure]], + [[false]], [[true]], [[]], [[full]]]]) + +m4_define([b4_pure_flag], [[0]]) +m4_case(b4_percent_define_get([[api.pure]]), + [false], [m4_define([b4_pure_flag], [[0]])], + [true], [m4_define([b4_pure_flag], [[1]])], + [], [m4_define([b4_pure_flag], [[1]])], + [full], [m4_define([b4_pure_flag], [[2]])]) + +m4_define([b4_pure_if], +[m4_case(b4_pure_flag, + [0], [$2], + [1], [$1], + [2], [$1])]) + [m4_fatal([invalid api.pure value: ]$1)])]) + +## --------------- ## +## api.push-pull. ## +## --------------- ## + +# b4_pull_if, b4_push_if +# ---------------------- +# Whether the pull/push APIs are needed. Both can be enabled. + +b4_percent_define_default([[api.push-pull]], [[pull]]) +b4_percent_define_check_values([[[[api.push-pull]], + [[pull]], [[push]], [[both]]]]) +b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]]) +b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]]) +m4_case(b4_percent_define_get([[api.push-pull]]), + [pull], [m4_define([b4_push_flag], [[0]])], + [push], [m4_define([b4_pull_flag], [[0]])]) + +# Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing +# tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the +# behavior of Bison at all when push parsing is already requested. +b4_define_flag_if([use_push_for_pull]) +b4_use_push_for_pull_if([ + b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])], + [m4_define([b4_push_flag], [[1]])])]) + +## ----------- ## +## parse.lac. ## +## ----------- ## + +b4_percent_define_default([[parse.lac]], [[none]]) +b4_percent_define_default([[parse.lac.es-capacity-initial]], [[20]]) +b4_percent_define_default([[parse.lac.memory-trace]], [[failures]]) +b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]], + [[[[parse.lac.memory-trace]], + [[failures]], [[full]]]]) +b4_define_flag_if([lac]) +m4_define([b4_lac_flag], + [m4_if(b4_percent_define_get([[parse.lac]]), + [none], [[0]], [[1]])]) + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Stack parameters. +m4_define_default([b4_stack_depth_max], [10000]) +m4_define_default([b4_stack_depth_init], [200]) + + +# b4_yyerror_arg_loc_if(ARG) +# -------------------------- +# Expand ARG iff yyerror is to be given a location as argument. +m4_define([b4_yyerror_arg_loc_if], +[b4_locations_if([m4_case(b4_pure_flag, + [1], [m4_ifset([b4_parse_param], [$1])], + [2], [$1])])]) + +# b4_yyerror_formals +# ------------------ +m4_define([b4_yyerror_formals], +[b4_pure_if([b4_locations_if([, [[const ]b4_api_PREFIX[LTYPE *yyllocp], [&yylloc]]])[]dnl +m4_ifdef([b4_parse_param], [, b4_parse_param])[]dnl +,])dnl +[[const char *msg], [msg]]]) + + + +# b4_yyerror_args +# --------------- +# Arguments passed to yyerror: user args plus yylloc. +m4_define([b4_yyerror_args], +[b4_yyerror_arg_loc_if([&yylloc, ])dnl +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])]) + + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_accept([SYMBOL-NUM]) +# ----------------------- +# Used in actions of the rules of accept, the initial symbol, to call +# YYACCEPT. If SYMBOL-NUM is specified, run "yyvalue->SLOT = $2;" +# before, using the slot of SYMBOL-NUM. +m4_define([b4_accept], +[m4_ifval([$1], + [b4_symbol_value(yyimpl->yyvalue, [$1]) = b4_rhs_value(2, 1, [$1]); ]) YYACCEPT]) + + +# b4_lhs_value(SYMBOL-NUM, [TYPE]) +# -------------------------------- +# See README. +m4_define([b4_lhs_value], +[b4_symbol_value(yyval, [$1], [$2])]) + + +# b4_rhs_value(RULE-LENGTH, POS, [SYMBOL-NUM], [TYPE]) +# ---------------------------------------------------- +# See README. +m4_define([b4_rhs_value], +[b4_symbol_value([yyvsp@{b4_subtract([$2], [$1])@}], [$3], [$4])]) + + +## ----------- ## +## Locations. ## +## ----------- ## + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +# Overparenthetized to avoid obscure problems with "foo$$bar = foo$1bar". +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, POS) +# --------------------------------- +# Expansion of @POS, where the current rule has RULE-LENGTH symbols +# on RHS. +# Overparenthetized to avoid obscure problems with "foo$$bar = foo$1bar". +m4_define([b4_rhs_location], +[(yylsp@{b4_subtract([$2], [$1])@})]) + + +## -------------- ## +## Declarations. ## +## -------------- ## + +# _b4_declare_sub_yyparse(START-SYMBOL-NUM, SWITCHING-TOKEN-SYMBOL-NUM) +# --------------------------------------------------------------------- +# Define the return type of the parsing function for SYMBOL-NUM, and +# declare its parsing function. +m4_define([_b4_declare_sub_yyparse], +[[ +// Return type when parsing one ]_b4_symbol($1, tag)[. +typedef struct +{]b4_symbol_if([$1], [has_type], [[ + ]_b4_symbol($1, type)[ yyvalue;]])[ + int yystatus; + int yynerrs; +} ]b4_prefix[parse_]_b4_symbol($1, id)[_t; + +// Parse one ]_b4_symbol($1, tag)[. +]b4_prefix[parse_]_b4_symbol($1, id)[_t ]b4_prefix[parse_]_b4_symbol($1, id)[ (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[); +]]) + + +# _b4_first_switching_token +# ------------------------- +m4_define([b4_first], [$1]) +m4_define([b4_second], [$2]) +m4_define([_b4_first_switching_token], +[b4_second(b4_first(b4_start_symbols))]) + + +# _b4_define_sub_yyparse(START-SYMBOL-NUM, SWITCHING-TOKEN-SYMBOL-NUM) +# -------------------------------------------------------------------- +# Define the parsing function for START-SYMBOL-NUM. +m4_define([_b4_define_sub_yyparse], +[[ +]b4_prefix[parse_]_b4_symbol($1, id)[_t +]b4_prefix[parse_]_b4_symbol($1, id)[ (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[) +{ + ]b4_prefix[parse_]_b4_symbol($1, id)[_t yyres; + yy_parse_impl_t yyimpl; + yyres.yystatus = yy_parse_impl (]b4_symbol($2, id)[, &yyimpl]m4_ifset([b4_parse_param], + [[, ]b4_args(b4_parse_param)])[);]b4_symbol_if([$1], [has_type], [[ + yyres.yyvalue = yyimpl.yyvalue.]b4_symbol($1, slot)[;]])[ + yyres.yynerrs = yyimpl.yynerrs; + return yyres; +} +]]) + + +# 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], [[ +]m4_ifdef([b4_start_symbols], [], +[[/* Lookahead token kind. */ +int yychar; +]])[ +]b4_pure_if([[ +/* The semantic value of the lookahead symbol. */ +/* Default value used for initialization, for pacifying older GCCs + or non-GCC compilers. */ +YY_INITIAL_VALUE (static YYSTYPE yyval_default;) +YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);]b4_locations_if([[ + +/* Location data for the lookahead symbol. */ +static YYLTYPE yyloc_default]b4_yyloc_default[; +YYLTYPE yylloc = yyloc_default;]])], +[[/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval;]b4_locations_if([[ +/* Location data for the lookahead symbol. */ +YYLTYPE yylloc]b4_yyloc_default[;]])[ +/* Number of syntax errors so far. */ +int yynerrs;]])]) + + +# b4_declare_parser_state_variables([INIT]) +# ----------------------------------------- +# Declare all the variables that are needed to maintain the parser state +# between calls to yypush_parse. +# If INIT is non-null, initialize these variables. +m4_define([b4_declare_parser_state_variables], +[b4_pure_if([[ + /* Number of syntax errors so far. */ + int yynerrs]m4_ifval([$1], [ = 0])[; +]])[ + yy_state_fast_t yystate]m4_ifval([$1], [ = 0])[; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus]m4_ifval([$1], [ = 0])[; + + /* Refer to the stacks through separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* Their size. */ + YYPTRDIFF_T yystacksize]m4_ifval([$1], [ = YYINITDEPTH])[; + + /* The state stack: array, bottom, top. */ + yy_state_t yyssa[YYINITDEPTH]; + yy_state_t *yyss]m4_ifval([$1], [ = yyssa])[; + yy_state_t *yyssp]m4_ifval([$1], [ = yyss])[; + + /* The semantic value stack: array, bottom, top. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs]m4_ifval([$1], [ = yyvsa])[; + YYSTYPE *yyvsp]m4_ifval([$1], [ = yyvs])[;]b4_locations_if([[ + + /* The location stack: array, bottom, top. */ + YYLTYPE yylsa[YYINITDEPTH]; + YYLTYPE *yyls]m4_ifval([$1], [ = yylsa])[; + YYLTYPE *yylsp]m4_ifval([$1], [ = yyls])[;]])[]b4_lac_if([[ + + yy_state_t yyesa@{]b4_percent_define_get([[parse.lac.es-capacity-initial]])[@}; + yy_state_t *yyes]m4_ifval([$1], [ = yyesa])[; + YYPTRDIFF_T yyes_capacity][]m4_ifval([$1], + [m4_do([ = b4_percent_define_get([[parse.lac.es-capacity-initial]]) < YYMAXDEPTH], + [ ? b4_percent_define_get([[parse.lac.es-capacity-initial]])], + [ : YYMAXDEPTH])])[;]])]) + + +m4_define([b4_macro_define], +[[#]define $1 $2]) + +m4_define([b4_macro_undef], +[[#]undef $1]) + +m4_define([b4_pstate_macro_define], +[b4_macro_define([$1], [yyps->$1])]) + +# b4_parse_state_variable_macros(b4_macro_define|b4_macro_undef) +# -------------------------------------------------------------- +m4_define([b4_parse_state_variable_macros], +[b4_pure_if([$1([b4_prefix[]nerrs])]) +$1([yystate]) +$1([yyerrstatus]) +$1([yyssa]) +$1([yyss]) +$1([yyssp]) +$1([yyvsa]) +$1([yyvs]) +$1([yyvsp])[]b4_locations_if([ +$1([yylsa]) +$1([yyls]) +$1([yylsp])]) +$1([yystacksize])[]b4_lac_if([ +$1([yyesa]) +$1([yyes]) +$1([yyes_capacity])])]) + + + + +# _b4_declare_yyparse_push +# ------------------------ +# Declaration of yyparse (and dependencies) when using the push parser +# (including in pull mode). +m4_define([_b4_declare_yyparse_push], +[[#ifndef YYPUSH_MORE_DEFINED +# define YYPUSH_MORE_DEFINED +enum { YYPUSH_MORE = 4 }; +#endif + +typedef struct ]b4_prefix[pstate ]b4_prefix[pstate; + +]b4_pull_if([[ +int ]b4_prefix[parse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[);]])[ +int ]b4_prefix[push_parse (]b4_prefix[pstate *ps]b4_pure_if([[, + int pushed_char, ]b4_api_PREFIX[STYPE const *pushed_val]b4_locations_if([[, ]b4_api_PREFIX[LTYPE *pushed_loc]])])b4_user_formals[); +]b4_pull_if([[int ]b4_prefix[pull_parse (]b4_prefix[pstate *ps]b4_user_formals[);]])[ +]b4_prefix[pstate *]b4_prefix[pstate_new (void); +void ]b4_prefix[pstate_delete (]b4_prefix[pstate *ps); +]]) + + +# _b4_declare_yyparse +# ------------------- +# When not the push parser. +m4_define([_b4_declare_yyparse], +[[int ]b4_prefix[parse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[); +]m4_ifdef([b4_start_symbols], + [m4_map([_b4_declare_sub_yyparse], m4_defn([b4_start_symbols]))])]) + + +# b4_declare_yyparse +# ------------------ +m4_define([b4_declare_yyparse], +[b4_push_if([_b4_declare_yyparse_push], + [_b4_declare_yyparse])[]dnl +]) + + +# b4_declare_yyerror_and_yylex +# ---------------------------- +# Comply with POSIX Yacc. +# +m4_define([b4_declare_yyerror_and_yylex], +[b4_posix_if([[#if !defined ]b4_prefix[error && !defined ]b4_api_PREFIX[ERROR_IS_DECLARED +]b4_function_declare([b4_prefix[error]], void, b4_yyerror_formals)[ +#endif +#if !defined ]b4_prefix[lex && !defined ]b4_api_PREFIX[LEX_IS_DECLARED +]b4_function_declare([b4_prefix[lex]], int, b4_yylex_formals)[ +#endif +]])dnl +]) + + +# b4_shared_declarations +# ---------------------- +# Declarations that might either go into the header (if --header) +# or into the implementation file. +m4_define([b4_shared_declarations], +[b4_cpp_guard_open([b4_spec_mapped_header_file])[ +]b4_declare_yydebug[ +]b4_percent_code_get([[requires]])[ +]b4_token_enums_defines[ +]b4_declare_yylstype[ +]b4_declare_yyerror_and_yylex[ +]b4_declare_yyparse[ +]b4_percent_code_get([[provides]])[ +]b4_cpp_guard_close([b4_spec_mapped_header_file])[]dnl +]) + + +# b4_header_include_if(IF-TRUE, IF-FALSE) +# --------------------------------------- +# Run IF-TRUE if we generate an output file and api.header.include +# is defined. +m4_define([b4_header_include_if], +[m4_ifval(m4_quote(b4_spec_header_file), + [b4_percent_define_ifdef([[api.header.include]], + [$1], + [$2])], + [$2])]) + +m4_if(b4_spec_header_file, [y.tab.h], [], + [b4_percent_define_default([[api.header.include]], + [["@basename(]b4_spec_header_file[@)"]])]) + + + + +## -------------- ## +## Output files. ## +## -------------- ## + + +b4_header_if([[ +]b4_output_begin([b4_spec_header_file])[ +]b4_copyright([Bison interface for Yacc-like parsers in C])[ +]b4_disclaimer[ +]b4_shared_declarations[ +]b4_output_end[ +]])# b4_header_if + +b4_output_begin([b4_parser_file_name])[ +]b4_copyright([Bison implementation for Yacc-like parsers in C])[ +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +]b4_disclaimer[ +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +]b4_identification[ +]b4_percent_code_get([[top]])[]dnl +m4_if(b4_api_prefix, [yy], [], +[[/* Substitute the type names. */ +#define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[ +#define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[ +]m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */]b4_pull_if([[ +#define yyparse ]b4_prefix[parse]])b4_push_if([[ +#define yypush_parse ]b4_prefix[push_parse]b4_pull_if([[ +#define yypull_parse ]b4_prefix[pull_parse]])[ +#define yypstate_new ]b4_prefix[pstate_new +#define yypstate_clear ]b4_prefix[pstate_clear +#define yypstate_delete ]b4_prefix[pstate_delete +#define yypstate ]b4_prefix[pstate]])[ +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yydebug ]b4_prefix[debug +#define yynerrs ]b4_prefix[nerrs]]b4_pure_if([], [[ +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])]))[ + +]b4_user_pre_prologue[ +]b4_cast_define[ +]b4_null_define[ + +]b4_header_include_if([[#include ]b4_percent_define_get([[api.header.include]])], + [m4_ifval(m4_quote(b4_spec_header_file), + [/* Use api.header.include to #include this header + instead of duplicating it here. */ +])b4_shared_declarations])[ +]b4_declare_symbol_enum[ + +]b4_user_post_prologue[ +]b4_percent_code_get[ +]b4_c99_int_type_define[ + +]b4_sizes_types_define[ + +/* Stored state numbers (used for stacks). */ +typedef ]b4_int_type(0, m4_eval(b4_states_number - 1))[ yy_state_t; + +/* State numbers in computations. */ +typedef int yy_state_fast_t; + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif +]b4_has_translations_if([ +#ifndef N_ +# define N_(Msgid) Msgid +#endif +])[ + +]b4_attribute_define[ + +]b4_parse_assert_if([[#ifdef NDEBUG +# define YY_ASSERT(E) ((void) (0 && (E))) +#else +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_ASSERT(E) assert (E) +#endif +]], +[[#define YY_ASSERT(E) ((void) (0 && (E)))]])[ + +#if ]b4_lac_if([[1]], [b4_parse_error_case([simple], [[!defined yyoverflow]], [[1]])])[ + +/* The parser invokes alloca or malloc; define the necessary symbols. */]dnl +b4_push_if([], [b4_lac_if([], [[ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS +# include /* INFRINGES ON USER NAME SPACE */ + /* Use EXIT_SUCCESS as a witness for stdlib.h. */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# endif +# endif +# endif]])])[ + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's 'empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined EXIT_SUCCESS +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif]b4_lac_if([[ +# define YYCOPY_NEEDED 1]])[ +#endif /* ]b4_lac_if([[1]], [b4_parse_error_case([simple], [[!defined yyoverflow]], [[1]])])[ */ + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (]b4_locations_if([[defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL \ + && ]])[defined ]b4_api_PREFIX[STYPE_IS_TRIVIAL && ]b4_api_PREFIX[STYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yy_state_t 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 (YYSIZEOF (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) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \ + + YYSIZEOF (YYLTYPE)) \ + + 2 * YYSTACK_GAP_MAXIMUM)], +[# define YYSTACK_BYTES(N) \ + ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM)])[ + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYPTRDIFF_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / YYSIZEOF (*yyptr); \ + } \ + while (0) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from SRC to DST. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(Dst, Src, Count) \ + __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) +# else +# define YYCOPY(Dst, Src, Count) \ + do \ + { \ + YYPTRDIFF_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (Dst)[yyi] = (Src)[yyi]; \ + } \ + while (0) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL ]b4_final_state_number[ +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST ]b4_last[ + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS ]b4_tokens_number[ +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS ]b4_nterms_number[ +/* YYNRULES -- Number of rules. */ +#define YYNRULES ]b4_rules_number[ +/* YYNSTATES -- Number of states. */ +#define YYNSTATES ]b4_states_number[ + +/* YYMAXUTOK -- Last valid token kind. */ +#define YYMAXUTOK ]b4_code_max[ + + +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ +]b4_api_token_raw_if(dnl +[[#define YYTRANSLATE(YYX) YY_CAST (yysymbol_kind_t, YYX)]], +[[#define YYTRANSLATE(YYX) \ + (0 <= (YYX) && (YYX) <= YYMAXUTOK \ + ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ + : ]b4_symbol_prefix[YYUNDEF) + +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM + as returned by yylex. */ +static const ]b4_int_type_for([b4_translate])[ yytranslate[] = +{ + ]b4_translate[ +};]])[ + +#if ]b4_api_PREFIX[DEBUG +]b4_integral_parser_table_define([rline], [b4_rline], + [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[ +#endif + +/** Accessing symbol of state STATE. */ +#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) + +#if ]b4_parse_error_case([simple], [b4_api_PREFIX[DEBUG || ]b4_token_table_flag], [[1]])[ +/* The user-facing name of the symbol whose (internal) number is + YYSYMBOL. No bounds checking. */ +static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; + +]b4_parse_error_bmatch([simple\|verbose], +[[/* 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[ +}; + +static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + return yytname[yysymbol]; +}]], +[[static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + static const char *const yy_sname[] = + { + ]b4_symbol_names[ + };]b4_has_translations_if([[ + /* YYTRANSLATABLE[SYMBOL-NUM] -- Whether YY_SNAME[SYMBOL-NUM] is + internationalizable. */ + static ]b4_int_type_for([b4_translatable])[ yytranslatable[] = + { + ]b4_translatable[ + }; + return (yysymbol < YYNTOKENS && yytranslatable[yysymbol] + ? _(yy_sname[yysymbol]) + : yy_sname[yysymbol]);]], [[ + return yy_sname[yysymbol];]])[ +}]])[ +#endif + +#define YYPACT_NINF (]b4_pact_ninf[) + +#define yypact_value_is_default(Yyn) \ + ]b4_table_value_equals([[pact]], [[Yyn]], [b4_pact_ninf], [YYPACT_NINF])[ + +#define YYTABLE_NINF (]b4_table_ninf[) + +#define yytable_value_is_error(Yyn) \ + ]b4_table_value_equals([[table]], [[Yyn]], [b4_table_ninf], [YYTABLE_NINF])[ + +]b4_parser_tables_define[ + +enum { YYENOMEM = -2 }; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = ]b4_symbol(empty, id)[) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYNOMEM goto yyexhaustedlab + + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ + do \ + if (yychar == ]b4_symbol(empty, id)[) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \]b4_lac_if([[ + YY_LAC_DISCARD ("YYBACKUP"); \]])[ + goto yybackup; \ + } \ + else \ + { \ + yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + while (0) + +/* Backward compatibility with an undocumented macro. + Use ]b4_symbol(error, id)[ or ]b4_symbol(undef, id)[. */ +#define YYERRCODE ]b4_symbol(undef, id)[ +]b4_locations_if([[ +]b4_yylloc_default_define[ +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +]])[ + +/* Enable debugging if requested. */ +#if ]b4_api_PREFIX[DEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + +]b4_yylocation_print_define[ + +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Kind, Value]b4_locations_if([, Location])[]b4_user_args[); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + +]b4_yy_symbol_print_define[ + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +static void +yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +static void +yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,]b4_locations_if([[ YYLTYPE *yylsp,]])[ + int yyrule]b4_user_formals[) +{ + int yylno = yyrline[yyrule]; + int yynrhs = yyr2[yyrule]; + int yyi; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, + YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), + &]b4_rhs_value(yynrhs, yyi + 1)[]b4_locations_if([, + &]b4_rhs_location(yynrhs, yyi + 1))[]b4_user_args[); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !]b4_api_PREFIX[DEBUG */ +# define YYDPRINTF(Args) ((void) 0) +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !]b4_api_PREFIX[DEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH ]b4_stack_depth_init[ +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH ]b4_stack_depth_max[ +#endif]b4_push_if([[ +/* Parser data structure. */ +struct yypstate + {]b4_declare_parser_state_variables[ + /* Whether this instance has not started parsing yet. + * If 2, it corresponds to a finished parsing. */ + int yynew; + };]b4_pure_if([], [[ + +/* Whether the only allowed instance of yypstate is allocated. */ +static char yypstate_allocated = 0;]])])[ +]b4_lac_if([[ + +/* Given a state stack such that *YYBOTTOM is its bottom, such that + *YYTOP is either its top or is YYTOP_EMPTY to indicate an empty + stack, and such that *YYCAPACITY is the maximum number of elements it + can hold without a reallocation, make sure there is enough room to + store YYADD more elements. If not, allocate a new stack using + YYSTACK_ALLOC, copy the existing elements, and adjust *YYBOTTOM, + *YYTOP, and *YYCAPACITY to reflect the new capacity and memory + location. If *YYBOTTOM != YYBOTTOM_NO_FREE, then free the old stack + using YYSTACK_FREE. Return 0 if successful or if no reallocation is + required. Return YYENOMEM if memory is exhausted. */ +static int +yy_lac_stack_realloc (YYPTRDIFF_T *yycapacity, YYPTRDIFF_T yyadd, +#if ]b4_api_PREFIX[DEBUG + char const *yydebug_prefix, + char const *yydebug_suffix, +#endif + yy_state_t **yybottom, + yy_state_t *yybottom_no_free, + yy_state_t **yytop, yy_state_t *yytop_empty) +{ + YYPTRDIFF_T yysize_old = + *yytop == yytop_empty ? 0 : *yytop - *yybottom + 1; + YYPTRDIFF_T yysize_new = yysize_old + yyadd; + if (*yycapacity < yysize_new) + { + YYPTRDIFF_T yyalloc = 2 * yysize_new; + yy_state_t *yybottom_new; + /* Use YYMAXDEPTH for maximum stack size given that the stack + should never need to grow larger than the main state stack + needs to grow without LAC. */ + if (YYMAXDEPTH < yysize_new) + { + YYDPRINTF ((stderr, "%smax size exceeded%s", yydebug_prefix, + yydebug_suffix)); + return YYENOMEM; + } + if (YYMAXDEPTH < yyalloc) + yyalloc = YYMAXDEPTH; + yybottom_new = + YY_CAST (yy_state_t *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, + yyalloc * YYSIZEOF (*yybottom_new)))); + if (!yybottom_new) + { + YYDPRINTF ((stderr, "%srealloc failed%s", yydebug_prefix, + yydebug_suffix)); + return YYENOMEM; + } + if (*yytop != yytop_empty) + { + YYCOPY (yybottom_new, *yybottom, yysize_old); + *yytop = yybottom_new + (yysize_old - 1); + } + if (*yybottom != yybottom_no_free) + YYSTACK_FREE (*yybottom); + *yybottom = yybottom_new; + *yycapacity = yyalloc;]m4_if(b4_percent_define_get([[parse.lac.memory-trace]]), + [full], [[ + YY_IGNORE_USELESS_CAST_BEGIN + YYDPRINTF ((stderr, "%srealloc to %ld%s", yydebug_prefix, + YY_CAST (long, yyalloc), yydebug_suffix)); + YY_IGNORE_USELESS_CAST_END]])[ + } + return 0; +} + +/* Establish the initial context for the current lookahead if no initial + context is currently established. + + We define a context as a snapshot of the parser stacks. We define + the initial context for a lookahead as the context in which the + parser initially examines that lookahead in order to select a + syntactic action. Thus, if the lookahead eventually proves + syntactically unacceptable (possibly in a later context reached via a + series of reductions), the initial context can be used to determine + the exact set of tokens that would be syntactically acceptable in the + lookahead's place. Moreover, it is the context after which any + further semantic actions would be erroneous because they would be + determined by a syntactically unacceptable token. + + YY_LAC_ESTABLISH should be invoked when a reduction is about to be + performed in an inconsistent state (which, for the purposes of LAC, + includes consistent states that don't know they're consistent because + their default reductions have been disabled). Iff there is a + lookahead token, it should also be invoked before reporting a syntax + error. This latter case is for the sake of the debugging output. + + For parse.lac=full, the implementation of YY_LAC_ESTABLISH is as + follows. If no initial context is currently established for the + current lookahead, then check if that lookahead can eventually be + shifted if syntactic actions continue from the current context. + Report a syntax error if it cannot. */ +#define YY_LAC_ESTABLISH \ +do { \ + if (!yy_lac_established) \ + { \ + YYDPRINTF ((stderr, \ + "LAC: initial context established for %s\n", \ + yysymbol_name (yytoken))); \ + yy_lac_established = 1; \ + switch (yy_lac (yyesa, &yyes, &yyes_capacity, yyssp, yytoken)) \ + { \ + case YYENOMEM: \ + YYNOMEM; \ + case 1: \ + goto yyerrlab; \ + } \ + } \ +} while (0) + +/* Discard any previous initial lookahead context because of Event, + which may be a lookahead change or an invalidation of the currently + established initial context for the current lookahead. + + The most common example of a lookahead change is a shift. An example + of both cases is syntax error recovery. That is, a syntax error + occurs when the lookahead is syntactically erroneous for the + currently established initial context, so error recovery manipulates + the parser stacks to try to find a new initial context in which the + current lookahead is syntactically acceptable. If it fails to find + such a context, it discards the lookahead. */ +#if ]b4_api_PREFIX[DEBUG +# define YY_LAC_DISCARD(Event) \ +do { \ + if (yy_lac_established) \ + { \ + YYDPRINTF ((stderr, "LAC: initial context discarded due to " \ + Event "\n")); \ + yy_lac_established = 0; \ + } \ +} while (0) +#else +# define YY_LAC_DISCARD(Event) yy_lac_established = 0 +#endif + +/* Given the stack whose top is *YYSSP, return 0 iff YYTOKEN can + eventually (after perhaps some reductions) be shifted, return 1 if + not, or return YYENOMEM if memory is exhausted. As preconditions and + postconditions: *YYES_CAPACITY is the allocated size of the array to + which *YYES points, and either *YYES = YYESA or *YYES points to an + array allocated with YYSTACK_ALLOC. yy_lac may overwrite the + contents of either array, alter *YYES and *YYES_CAPACITY, and free + any old *YYES other than YYESA. */ +static int +yy_lac (yy_state_t *yyesa, yy_state_t **yyes, + YYPTRDIFF_T *yyes_capacity, yy_state_t *yyssp, yysymbol_kind_t yytoken) +{ + yy_state_t *yyes_prev = yyssp; + yy_state_t *yyesp = yyes_prev; + /* Reduce until we encounter a shift and thereby accept the token. */ + YYDPRINTF ((stderr, "LAC: checking lookahead %s:", yysymbol_name (yytoken))); + if (yytoken == ]b4_symbol_prefix[YYUNDEF) + { + YYDPRINTF ((stderr, " Always Err\n")); + return 1; + } + while (1) + { + int yyrule = yypact[+*yyesp]; + if (yypact_value_is_default (yyrule) + || (yyrule += yytoken) < 0 || YYLAST < yyrule + || yycheck[yyrule] != yytoken) + { + /* Use the default action. */ + yyrule = yydefact[+*yyesp]; + if (yyrule == 0) + { + YYDPRINTF ((stderr, " Err\n")); + return 1; + } + } + else + { + /* Use the action from yytable. */ + yyrule = yytable[yyrule]; + if (yytable_value_is_error (yyrule)) + { + YYDPRINTF ((stderr, " Err\n")); + return 1; + } + if (0 < yyrule) + { + YYDPRINTF ((stderr, " S%d\n", yyrule)); + return 0; + } + yyrule = -yyrule; + } + /* By now we know we have to simulate a reduce. */ + YYDPRINTF ((stderr, " R%d", yyrule - 1)); + { + /* Pop the corresponding number of values from the stack. */ + YYPTRDIFF_T yylen = yyr2[yyrule]; + /* First pop from the LAC stack as many tokens as possible. */ + if (yyesp != yyes_prev) + { + YYPTRDIFF_T yysize = yyesp - *yyes + 1; + if (yylen < yysize) + { + yyesp -= yylen; + yylen = 0; + } + else + { + yyesp = yyes_prev; + yylen -= yysize; + } + } + /* Only afterwards look at the main stack. */ + if (yylen) + yyesp = yyes_prev -= yylen; + } + /* Push the resulting state of the reduction. */ + { + yy_state_fast_t yystate; + { + const int yylhs = yyr1[yyrule] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyesp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyesp + ? yytable[yyi] + : yydefgoto[yylhs]); + } + if (yyesp == yyes_prev) + { + yyesp = *yyes; + YY_IGNORE_USELESS_CAST_BEGIN + *yyesp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END + } + else + { + if (yy_lac_stack_realloc (yyes_capacity, 1, +#if ]b4_api_PREFIX[DEBUG + " (", ")", +#endif + yyes, yyesa, &yyesp, yyes_prev)) + { + YYDPRINTF ((stderr, "\n")); + return YYENOMEM; + } + YY_IGNORE_USELESS_CAST_BEGIN + *++yyesp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END + } + YYDPRINTF ((stderr, " G%d", yystate)); + } + } +}]])[ + +]b4_parse_error_case([simple], [], +[[/* Context of a parse error. */ +typedef struct +{]b4_push_if([[ + yypstate* yyps;]], [[ + yy_state_t *yyssp;]b4_lac_if([[ + yy_state_t *yyesa; + yy_state_t **yyes; + YYPTRDIFF_T *yyes_capacity;]])])[ + yysymbol_kind_t yytoken;]b4_locations_if([[ + YYLTYPE *yylloc;]])[ +} yypcontext_t; + +/* Put in YYARG at most YYARGN of the expected tokens given the + current YYCTX, and return the number of tokens stored in YYARG. If + YYARG is null, return the number of expected tokens (guaranteed to + be less than YYNTOKENS). Return YYENOMEM on memory exhaustion. + Return 0 if there are more than YYARGN expected tokens, yet fill + YYARG up to YYARGN. */]b4_push_if([[ +static int +yypstate_expected_tokens (yypstate *yyps, + yysymbol_kind_t yyarg[], int yyargn)]], [[ +static int +yypcontext_expected_tokens (const yypcontext_t *yyctx, + yysymbol_kind_t yyarg[], int yyargn)]])[ +{ + /* Actual size of YYARG. */ + int yycount = 0; +]b4_lac_if([[ + int yyx; + for (yyx = 0; yyx < YYNTOKENS; ++yyx) + { + yysymbol_kind_t yysym = YY_CAST (yysymbol_kind_t, yyx); + if (yysym != ]b4_symbol(error, kind)[ && yysym != ]b4_symbol_prefix[YYUNDEF) + switch (yy_lac (]b4_push_if([[yyps->yyesa, &yyps->yyes, &yyps->yyes_capacity, yyps->yyssp, yysym]], + [[yyctx->yyesa, yyctx->yyes, yyctx->yyes_capacity, yyctx->yyssp, yysym]])[)) + { + case YYENOMEM: + return YYENOMEM; + case 1: + continue; + default: + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = yysym; + } + }]], +[[ int yyn = yypact@{+*]b4_push_if([yyps], [yyctx])[->yyssp@}; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != ]b4_symbol(error, kind)[ + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); + } + }]])[ + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = ]b4_symbol(empty, kind)[; + return yycount; +} + +]b4_push_if([[ +/* Similar to the previous function. */ +static int +yypcontext_expected_tokens (const yypcontext_t *yyctx, + yysymbol_kind_t yyarg[], int yyargn) +{ + return yypstate_expected_tokens (yyctx->yyps, yyarg, yyargn); +}]])[ +]])[ + +]b4_parse_error_bmatch( + [custom], +[[/* The kind of the lookahead of this context. */ +static yysymbol_kind_t +yypcontext_token (const yypcontext_t *yyctx) YY_ATTRIBUTE_UNUSED; + +static yysymbol_kind_t +yypcontext_token (const yypcontext_t *yyctx) +{ + return yyctx->yytoken; +} + +]b4_locations_if([[/* The location of the lookahead of this context. */ +static YYLTYPE * +yypcontext_location (const yypcontext_t *yyctx) YY_ATTRIBUTE_UNUSED; + +static YYLTYPE * +yypcontext_location (const yypcontext_t *yyctx) +{ + return yyctx->yylloc; +}]])[ + +/* User defined function to report a syntax error. */ +static int +yyreport_syntax_error (const yypcontext_t *yyctx]b4_user_formals[);]], + [detailed\|verbose], +[[#ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) +# else +/* Return the length of YYSTR. */ +static YYPTRDIFF_T +yystrlen (const char *yystr) +{ + YYPTRDIFF_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. */ +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 + +]b4_parse_error_case( + [verbose], +[[#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 YYPTRDIFF_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYPTRDIFF_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; + else + goto append; + + append: + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (yyres) + return yystpcpy (yyres, yystr) - yyres; + else + return yystrlen (yystr); +} +#endif +]])[ + +static int +yy_syntax_error_arguments (const yypcontext_t *yyctx, + yysymbol_kind_t yyarg[], int yyargn) +{ + /* Actual size of YYARG. */ + int yycount = 0; + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar.]b4_lac_if([[ + In the first two cases, it might appear that the current syntax + error should have been detected in the previous state when yy_lac + was invoked. However, at that time, there might have been a + different syntax error that discarded a different initial context + during error recovery, leaving behind the current lookahead.]], [[ + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state.]])[ + */ + if (yyctx->yytoken != ]b4_symbol(empty, kind)[) + { + int yyn;]b4_lac_if([[ + YYDPRINTF ((stderr, "Constructing syntax error message\n"));]])[ + if (yyarg) + yyarg[yycount] = yyctx->yytoken; + ++yycount; + yyn = yypcontext_expected_tokens (yyctx, + yyarg ? yyarg + 1 : yyarg, yyargn - 1); + if (yyn == YYENOMEM) + return YYENOMEM;]b4_lac_if([[ + else if (yyn == 0) + YYDPRINTF ((stderr, "No expected tokens.\n"));]])[ + else + yycount += yyn; + } + return yycount; +} + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP.]b4_lac_if([[ In order to see if a particular token T is a + valid looakhead, invoke yy_lac (YYESA, YYES, YYES_CAPACITY, YYSSP, T).]])[ + + Return 0 if *YYMSG was successfully written. Return -1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return YYENOMEM if the + required number of bytes is too large to store]b4_lac_if([[ or if + yy_lac returned YYENOMEM]])[. */ +static int +yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg, + const yypcontext_t *yyctx) +{ + enum { YYARGS_MAX = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULLPTR; + /* Arguments of yyformat: reported tokens (one for the "unexpected", + one per "expected"). */ + yysymbol_kind_t yyarg[YYARGS_MAX]; + /* Cumulated lengths of YYARG. */ + YYPTRDIFF_T yysize = 0; + + /* Actual size of YYARG. */ + int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX); + if (yycount == YYENOMEM) + return YYENOMEM; + + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: /* Avoid compiler warnings. */ + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + /* Compute error message size. Don't count the "%s"s, but reserve + room for the terminator. */ + yysize = yystrlen (yyformat) - 2 * yycount + 1; + { + int yyi; + for (yyi = 0; yyi < yycount; ++yyi) + { + YYPTRDIFF_T yysize1 + = yysize + ]b4_parse_error_case( + [verbose], [[yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]])]], + [[yystrlen (yysymbol_name (yyarg[yyi]))]]);[ + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else + return YYENOMEM; + } + } + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return -1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + {]b4_parse_error_case([verbose], [[ + yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]);]], [[ + yyp = yystpcpy (yyp, yysymbol_name (yyarg[yyi++]));]])[ + yyformat += 2; + } + else + { + ++yyp; + ++yyformat; + } + } + return 0; +} +]])[ + +]b4_yydestruct_define[ + +]b4_pure_if([], [b4_declare_scanner_communication_variables])[ + +]b4_push_if([b4_pull_if([[ + +int +yyparse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[) +{ + yypstate *yyps = yypstate_new (); + if (!yyps) + {]b4_pure_if([b4_locations_if([[ + static YYLTYPE yyloc_default][]b4_yyloc_default[; + YYLTYPE yylloc = yyloc_default;]])[ + yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[ + if (!yypstate_allocated) + yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[ + return 2; + } + int yystatus = yypull_parse (yyps]b4_user_args[); + yypstate_delete (yyps); + return yystatus; +} + +int +yypull_parse (yypstate *yyps]b4_user_formals[) +{ + YY_ASSERT (yyps);]b4_pure_if([b4_locations_if([[ + static YYLTYPE yyloc_default][]b4_yyloc_default[; + YYLTYPE yylloc = yyloc_default;]])])[ + int yystatus; + do { +]b4_pure_if([[ YYSTYPE yylval; + int ]])[yychar = ]b4_yylex[; + yystatus = yypush_parse (yyps]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_args(b4_parse_param)])[); + } while (yystatus == YYPUSH_MORE); + return yystatus; +}]])[ + +]b4_parse_state_variable_macros([b4_pstate_macro_define])[ + +/* Initialize the parser data structure. */ +static void +yypstate_clear (yypstate *yyps) +{ + yynerrs = 0; + yystate = 0; + yyerrstatus = 0; + + yyssp = yyss; + yyvsp = yyvs;]b4_locations_if([[ + yylsp = yyls;]])[ + + /* Initialize the state stack, in case yypcontext_expected_tokens is + called before the first call to yyparse. */ + *yyssp = 0; + yyps->yynew = 1; +} + +/* Initialize the parser data structure. */ +yypstate * +yypstate_new (void) +{ + yypstate *yyps;]b4_pure_if([], [[ + if (yypstate_allocated) + return YY_NULLPTR;]])[ + yyps = YY_CAST (yypstate *, YYMALLOC (sizeof *yyps)); + if (!yyps) + return YY_NULLPTR;]b4_pure_if([], [[ + yypstate_allocated = 1;]])[ + yystacksize = YYINITDEPTH; + yyss = yyssa; + yyvs = yyvsa;]b4_locations_if([[ + yyls = yylsa;]])[]b4_lac_if([[ + yyes = yyesa; + yyes_capacity = ]b4_percent_define_get([[parse.lac.es-capacity-initial]])[; + if (YYMAXDEPTH < yyes_capacity) + yyes_capacity = YYMAXDEPTH;]])[ + yypstate_clear (yyps); + return yyps; +} + +void +yypstate_delete (yypstate *yyps) +{ + if (yyps) + { +#ifndef yyoverflow + /* If the stack was reallocated but the parse did not complete, then the + stack still needs to be freed. */ + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif]b4_lac_if([[ + if (yyes != yyesa) + YYSTACK_FREE (yyes);]])[ + YYFREE (yyps);]b4_pure_if([], [[ + yypstate_allocated = 0;]])[ + } +} +]])[ + +]b4_push_if([[ +/*---------------. +| yypush_parse. | +`---------------*/ + +int +yypush_parse (yypstate *yyps]b4_pure_if([[, + int yypushed_char, YYSTYPE const *yypushed_val]b4_locations_if([[, YYLTYPE *yypushed_loc]])])b4_user_formals[)]], +[[ +/*----------. +| yyparse. | +`----------*/ + +]m4_ifdef([b4_start_symbols], +[[// Extract data from the parser. +typedef struct +{ + YYSTYPE yyvalue; + int yynerrs; +} yy_parse_impl_t; + +// Run a full parse, using YYCHAR as switching token. +static int +yy_parse_impl (int yychar, yy_parse_impl_t *yyimpl]m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])[); + +]m4_map([_b4_define_sub_yyparse], m4_defn([b4_start_symbols]))[ + +int +yyparse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[) +{ + return yy_parse_impl (]b4_symbol(_b4_first_switching_token, id)[, YY_NULLPTR]m4_ifset([b4_parse_param], + [[, ]b4_args(b4_parse_param)])[); +} + +static int +yy_parse_impl (int yychar, yy_parse_impl_t *yyimpl]m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])[)]], +[[int +yyparse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[)]])])[ +{]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([init]) +])b4_lac_if([[ + /* Whether LAC context is established. A Boolean. */ + int yy_lac_established = 0;]])[ + int yyn; + /* The return value of yyparse. */ + int yyresult; + /* Lookahead symbol kind. */ + yysymbol_kind_t yytoken = ]b4_symbol(empty, kind)[; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc; + + /* The locations where the error started and ended. */ + YYLTYPE yyerror_range[3];]])[ + +]b4_parse_error_bmatch([detailed\|verbose], +[[ /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;]])[ + +#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([[ + + switch (yyps->yynew) + { + case 0: + yyn = yypact[yystate]; + goto yyread_pushed_token; + + case 2: + yypstate_clear (yyps); + break; + + default: + break; + }]])[ + + YYDPRINTF ((stderr, "Starting parse\n")); + +]m4_ifdef([b4_start_symbols], [], +[[ yychar = ]b4_symbol(empty, id)[; /* Cause a token to be read. */ +]])[ +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([m4_define([b4_dollar_dollar_used])yylval], [], [], + [b4_push_if([b4_pure_if([*])yypushed_loc], [yylloc])])dnl +b4_user_initial_action +b4_dollar_popdef[]dnl +m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval; +]])])dnl +b4_locations_if([[ yylsp[0] = ]b4_push_if([b4_pure_if([*])yypushed_loc], [yylloc])[; +]])dnl +[ goto yysetstate; + + +/*------------------------------------------------------------. +| yynewstate -- push a new state, which is found in yystate. | +`------------------------------------------------------------*/ +yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + +/*--------------------------------------------------------------------. +| yysetstate -- set current state (the top of the stack) to yystate. | +`--------------------------------------------------------------------*/ +yysetstate: + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + YY_ASSERT (0 <= yystate && yystate < YYNSTATES); + YY_IGNORE_USELESS_CAST_BEGIN + *yyssp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END + YY_STACK_PRINT (yyss, yyssp); + + if (yyss + yystacksize - 1 <= yyssp) +#if !defined yyoverflow && !defined YYSTACK_RELOCATE + YYNOMEM; +#else + { + /* Get the current used size of the three stacks, in elements. */ + YYPTRDIFF_T yysize = yyssp - yyss + 1; + +# if defined 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. */ + yy_state_t *yyss1 = yyss; + YYSTYPE *yyvs1 = yyvs;]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 * YYSIZEOF (*yyssp), + &yyvs1, yysize * YYSIZEOF (*yyvsp),]b4_locations_if([ + &yyls1, yysize * YYSIZEOF (*yylsp),])[ + &yystacksize); + yyss = yyss1; + yyvs = yyvs1;]b4_locations_if([ + yyls = yyls1;])[ + } +# else /* defined YYSTACK_RELOCATE */ + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + YYNOMEM; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yy_state_t *yyss1 = yyss; + union yyalloc *yyptr = + YY_CAST (union yyalloc *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); + if (! yyptr) + YYNOMEM; + 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 + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1;]b4_locations_if([ + yylsp = yyls + yysize - 1;])[ + + YY_IGNORE_USELESS_CAST_BEGIN + YYDPRINTF ((stderr, "Stack size increased to %ld\n", + YY_CAST (long, yystacksize))); + YY_IGNORE_USELESS_CAST_END + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } +#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ + +]m4_ifdef([b4_start_symbols], [], [[ + if (yystate == YYFINAL) + YYACCEPT;]])[ + + goto yybackup; + + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ + if (yychar == ]b4_symbol(empty, id)[) + {]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\n"));]b4_push_if([b4_pure_if([[ + yychar = yypushed_char; + if (yypushed_val) + yylval = *yypushed_val;]b4_locations_if([[ + if (yypushed_loc) + yylloc = *yypushed_loc;]])])], [[ + yychar = ]b4_yylex[;]])[ + } + + if (yychar <= ]b4_symbol(eof, [id])[) + { + yychar = ]b4_symbol(eof, [id])[; + yytoken = ]b4_symbol(eof, [kind])[; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else if (yychar == ]b4_symbol(error, [id])[) + { + /* The scanner already issued an error message, process directly + to error recovery. But do not keep the error token as + lookahead, it is too special and may lead us to an endless + loop in error recovery. */ + yychar = ]b4_symbol(undef, [id])[; + yytoken = ]b4_symbol(error, [kind])[;]b4_locations_if([[ + yyerror_range[1] = yylloc;]])[ + goto yyerrlab1; + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)]b4_lac_if([[ + { + YY_LAC_ESTABLISH; + goto yydefault; + }]], [[ + goto yydefault;]])[ + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab; + yyn = -yyn;]b4_lac_if([[ + YY_LAC_ESTABLISH;]])[ + 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); + yystate = yyn; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END]b4_locations_if([ + *++yylsp = yylloc;])[ + + /* Discard the shifted token. */ + yychar = ]b4_symbol(empty, id)[;]b4_lac_if([[ + YY_LAC_DISCARD ("shift");]])[ + 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); + yyerror_range[1] = yyloc;]])[ + YY_REDUCE_PRINT (yyn);]b4_lac_if([[ + { + int yychar_backup = yychar; + switch (yyn) + { +]b4_user_actions[ + default: break; + } + if (yychar_backup != yychar) + YY_LAC_DISCARD ("yychar change"); + }]], [[ + switch (yyn) + { +]b4_user_actions[ + default: break; + }]])[ + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + + *++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. */ + { + const int yylhs = yyr1[yyn] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyssp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp + ? yytable[yyi] + : yydefgoto[yylhs]); + } + + goto yynewstate; + + +/*--------------------------------------. +| yyerrlab -- here on detecting error. | +`--------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == ]b4_symbol(empty, id)[ ? ]b4_symbol(empty, kind)[ : YYTRANSLATE (yychar); + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +]b4_parse_error_case( + [custom], +[[ { + yypcontext_t yyctx + = {]b4_push_if([[yyps]], [[yyssp]b4_lac_if([[, yyesa, &yyes, &yyes_capacity]])])[, yytoken]b4_locations_if([[, &yylloc]])[};]b4_lac_if([[ + if (yychar != ]b4_symbol(empty, id)[) + YY_LAC_ESTABLISH;]])[ + if (yyreport_syntax_error (&yyctx]m4_ifset([b4_parse_param], + [[, ]b4_args(b4_parse_param)])[) == 2) + YYNOMEM; + }]], + [simple], +[[ yyerror (]b4_yyerror_args[YY_("syntax error"));]], +[[ { + yypcontext_t yyctx + = {]b4_push_if([[yyps]], [[yyssp]b4_lac_if([[, yyesa, &yyes, &yyes_capacity]])])[, yytoken]b4_locations_if([[, &yylloc]])[}; + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status;]b4_lac_if([[ + if (yychar != ]b4_symbol(empty, id)[) + YY_LAC_ESTABLISH;]])[ + yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == -1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = YY_CAST (char *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); + if (yymsg) + { + yysyntax_error_status + = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); + yymsgp = yymsg; + } + else + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = YYENOMEM; + } + } + yyerror (]b4_yyerror_args[yymsgp); + if (yysyntax_error_status == YYENOMEM) + YYNOMEM; + }]])[ + } +]b4_locations_if([[ + yyerror_range[1] = yylloc;]])[ + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= ]b4_symbol(eof, [id])[) + { + /* Return failure if at end of input. */ + if (yychar == ]b4_symbol(eof, [id])[) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); + yychar = ]b4_symbol(empty, id)[; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + /* Pacify compilers when the user code never invokes YYERROR and the + label yyerrorlab therefore never appears in user code. */ + if (0) + YYERROR; + ++yynerrs; + + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + /* Pop stack until we find a state that shifts the error token. */ + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += ]b4_symbol(error, kind)[; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == ]b4_symbol(error, kind)[) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + +]b4_locations_if([[ yyerror_range[1] = *yylsp;]])[ + yydestruct ("Error: popping", + YY_ACCESSING_SYMBOL (yystate), yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + }]b4_lac_if([[ + + /* If the stack popping above didn't lose the initial context for the + current lookahead token, the shift below will for sure. */ + YY_LAC_DISCARD ("error recovery");]])[ + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END +]b4_locations_if([[ + yyerror_range[2] = yylloc; + ++yylsp; + YYLLOC_DEFAULT (*yylsp, yyerror_range, 2);]])[ + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturnlab; + + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturnlab; + + +/*-----------------------------------------------------------. +| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | +`-----------------------------------------------------------*/ +yyexhaustedlab: + yyerror (]b4_yyerror_args[YY_("memory exhausted")); + yyresult = 2; + goto yyreturnlab; + + +/*----------------------------------------------------------. +| yyreturnlab -- parsing is finished, clean up and return. | +`----------------------------------------------------------*/ +yyreturnlab: + if (yychar != ]b4_symbol(empty, id)[) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); + } + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + YY_ACCESSING_SYMBOL (+*yyssp), yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); + YYPOPSTACK (1); + }]b4_push_if([[ + yyps->yynew = 2; + goto yypushreturn; + + +/*-------------------------. +| yypushreturn -- return. | +`-------------------------*/ +yypushreturn:]], [[ +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif]b4_lac_if([[ + if (yyes != yyesa) + YYSTACK_FREE (yyes);]])])[ +]b4_parse_error_bmatch([detailed\|verbose], +[[ if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg);]])[]m4_ifdef([b4_start_symbols], [[ + if (yyimpl) + yyimpl->yynerrs = yynerrs;]])[ + return yyresult; +} +]b4_push_if([b4_parse_state_variable_macros([b4_macro_undef])])[ +]b4_percent_code_get([[epilogue]])[]dnl +b4_epilogue[]dnl +b4_output_end diff --git a/compiler/win_flex_bison/data/xslt/bison.xsl b/compiler/win_flex_bison/data/xslt/bison.xsl new file mode 100644 index 0000000..989a343 --- /dev/null +++ b/compiler/win_flex_bison/data/xslt/bison.xsl @@ -0,0 +1,105 @@ + + + + + + + + + + + + + + + + + + + + + + + + + s + + + r + + + + + + , + + + + + 0 + + + + + + + + + + + diff --git a/compiler/win_flex_bison/data/xslt/xml2dot.xsl b/compiler/win_flex_bison/data/xslt/xml2dot.xsl new file mode 100644 index 0000000..7715d1a --- /dev/null +++ b/compiler/win_flex_bison/data/xslt/xml2dot.xsl @@ -0,0 +1,401 @@ + + + + + + + + + + + + + + + // Generated by GNU Bison + + . + // Report bugs to < + + >. + // Home page: < + + >. + + + + + + + + digraph " + + + + " { + node [fontname = courier, shape = box, colorscheme = paired6] + edge [fontname = courier] + + + + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + label="[ + + + + + + , + + + ]", + + + + style=solid] + + + + + + + + + 3 + + + 5 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + : + + + + . + + + + + + + . + + + + + + + + + + + %empty + + + + [ + + ] + + + + + + , + + + + + + + + + + + -> " + + R + + + d + + " [ + + + + + + + + " + + R + + + d + + " [label=" + + + Acc", fillcolor=1 + + + R + + ", fillcolor= + + + + , shape=diamond, style=filled] + + + + + + + + + + dotted + + + solid + + + dashed + + + + + + + + + + + + + + + + + [label=" + State + + \n + + + + \l"] + + + + + + + + + + -> + + [style= + + + label=" + + + + " + + ] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/compiler/win_flex_bison/data/xslt/xml2text.xsl b/compiler/win_flex_bison/data/xslt/xml2text.xsl new file mode 100644 index 0000000..1fc5731 --- /dev/null +++ b/compiler/win_flex_bison/data/xslt/xml2text.xsl @@ -0,0 +1,572 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Nonterminals useless in grammar + + + + + + + + + + + + Terminals unused in grammar + + + + + + + + + + + + + + Rules useless in grammar + + + + + + + + + + + Rules useless in parser due to conflicts + + + + + + + + + Grammar + + + + + + + + + + + + + + + + + + + + + + + + + Terminals, with rules where they appear + + + + + + Nonterminals, with rules where they appear + + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + on@left: + + + + + + + + + on@right: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + State + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + : + + + + + + + • + + + + • + + + + + + + + + + + + + + + + %empty + + + + [ + + ] + + + + + + , + + + + + + + + + + + + + shift, and go to state + + + + go to state + + + + + + + + + + + + + + error + ( + + ) + + + + + + + + + + + + [ + + + + accept + + + reduce using rule + + ( + + ) + + + + ] + + + + + + + + + + + + + Conflict between rule + + and token + + resolved as + + an + + + ( + + ). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/compiler/win_flex_bison/data/xslt/xml2xhtml.xsl b/compiler/win_flex_bison/data/xslt/xml2xhtml.xsl new file mode 100644 index 0000000..aaa5dba --- /dev/null +++ b/compiler/win_flex_bison/data/xslt/xml2xhtml.xsl @@ -0,0 +1,765 @@ + + + + + + + + + + + + + + + + <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 + +

    + +

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

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + → + + + + + + + + • + + + + + • + + + + + + + + + + + + + + + + + + + + + + + %empty + + + + [ + + ] + + + + + + , + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + error + ( + + ) + + + + + + + + + + + + [ + + + + accept + + + + + + + + + ( + + ) + + + + ] + + + + + + + + + + + + + Conflict between + + + + + + + and token + + resolved as + + an + + + ( + + ). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + diff --git a/compiler/win_flex_bison/win_bison.exe b/compiler/win_flex_bison/win_bison.exe new file mode 100644 index 0000000000000000000000000000000000000000..5f6025f531ce9a55692b7dc0b38b7ef0d7a15cb6 GIT binary patch literal 677376 zcmeFaePC48(LcVMy-60>a2H)PYLHY@MPq3sK?w`G0XDowH>}yEYQR?IS>sD1*+r-c z1~*%|9M)p1Pid=9O|g%*+7_$W&&%>)IdkUBt+;uu#b&WsH2fwK7E24R^yA^b|M`#IYO#zQ`}>iWmxulF zD=pS}fBec#p}XqxYnOcczm|OS-u&CYdEb5C4(EUC&io~j`||I)FMr03{``BteaD^S zb8?0km{sq)&+^O1_4`gHe~;aDZ~u?*eC)2f`>Xj{)BjyucYNpW{ulY0e7?8;VSfMZ z{vYD{xc=>vpWr(FJ2m}d`1;t%C-{0#KV9eFb$f`~_@WW{ycWwmYo_Jo?+<@7nWxi| zVI5%|ImR-_Zn4~#!O6CwEQ`g7+uM*vP@;RhLMs0xua@573aCi6Sv)H_Bju$6d`(@r z+?vh9EaT|TH{8+*xSsKI+i=Tmk6J9R{%V*d?~Ip&35W3BGx*5;tUp_QW}flkJC}uV zf9GtBhx$chC1ObX$ww{Ym)!BqFd$R17?si3L%806Yub+o02!~cS(Yuqi+#gDAh^DQ zYub;;Vrd<}q;ARWNaL|$%mhQr_A~N%#xJ?^o^K-~joktmSk~gYPgdHz69G}sdlXtMr%i$w%A(JOM6eQTB_x?M9ON5!;U!zS)6;T>Vw z;Z0aXIHODxGNZWZqs-ah&LYMVves8J2x-sp0dMSpY@a>RpnqpDw2 z^%Wm?R~^-x+E9TgbBc;y;cm-gFL71*%vprfJ2;F`Uv`m;UHKY0O&* ze+;&*cntVtDF9E9+z!+gi3`OWqGcW42(KgBn%yRC7`tto`;Z>}K2qb;t%i4?(QOIe zD?TYa*7gsZJL0JOrr3duwhXs-pl-g{u_>Dx>dY?eXhAnDZ+14>!oa6f>}~7H6s`@0 zb2RrHd!0*6bHrV%#9omR{o7dm`3@tadxXdc&KH)%KI%?Ye>rMj@-yKb5W_uacRCPd zYjYn$g8uLWzy+`-y!P_wRzexkrAGrS^)-3)uF5XXF{KvMfJG&v~hu;;ceB&Hex7%id{VD6muPDNqAgwSB!Y5XfJFt z{4V#_I_G@9?6?V-nCqYsJm|E|b%{E=5$SaAiD=Qe<1)nbT%*nvFR`E4cWJNKTR2w} zI|`?3MxDdmwlvdt&>>EUiq7H#Mx9+m?CoAj&9;{@Pj4r1T12^KlxY)MS9ue3TeZ8? z2jm)=z|L}e;W4A3--z^d+nL@(L;rlA44g~kW{*y}j%L4TB>WoQqmdEqgegnc6x1#n z`urk0QClFFjloj|5k&D}19QV693#as12f!L5T8aQ0UUJb(HFq;MO%E9)u=eAk8Prw zERB;aVwc|ZReIH5c&hCKo6&H{{iz;3mr^2*=#Fvmk}XE$ND`ir9sR($^!PPMifb!{J+^b%a4}1Zd$icj z<;O9qc$rn?Y(UPtTWbqDgm;`T?%n50MDh}m+(g8Mxs!+-txQ}iEe?xibw_l2f$;VV zOVdt07Nd6b;sYYGuie{0;}gpZqV3sj|FXp$liY1a#ddw>r($0$5w43SJWKA2&q>(! z0*`mbZ{V8;hN+Z2b$(IN5&fW5cUq!t9^E-|vEJRGJ3UT))NtK-1Gob}=If*8IPsis zJ{Lt>JxIz&Qc-k=hf_z*DT;3Oxc4r3Ni=MCzg>4uVee{3QQTu4J}a?m_%!$1OL|4c zIN{xAl)2nx+ES;x%vm==G#oO@>_(ZR`+i@ge7zDR+HeRc?*5kW_K6~KLxKC9x-r7r zDqJn`@^N$G+B$u#$5QGH+owlcHTOG9`jQ|!>aVc`Y5T|~-iZD! zTUczpEkss@ZTc(c>CbOnbsk7)X4HE`11X4E1!BMZr2eoCGm_YDRgWj(JqR8{m6T+} z%ZR?je%p>xZ*SckLlJLcG+yA`k=dAkG9dfv++Q^=?T1wHb@p$kwgx1#E3+lQHjm72TKUN>5lfxR6CkBz(5iVVeQbA*-1 zKFMmmedWRq%-mm~KRk|@r?=NLov^YWzy!?1BvF=xRXZ`@Uj5-tLSgkd;DT@m_*U%( zr5N7+Y2cDzOT>)9nbs`(jD#knaMODPnrs?dq_f8A2eS#t$tMyC$o9e@FLl2rB1|HsWF=&pJgmBx`NK(p;gv1a)JWPhJ8DK=_GlNYjEP z(l1*UXMy8%l0ZDJH$A4BuEv<^<3vS)$o5wzBKZJ{;ttwM zlR;b?kOxjuKMT5V0QYv+QTOVod-UJYT^jJq`)}axb$<=)+nDQe&!wq1m#1EzG1qR) zb#$Lo>6dem4ZxzQ2Z|XNZO63ei(U_vVyyss|57>^c0^V@Dtd1HmMnCF%;~1q*BzpAp-D*Yfk5F_>HI$=C9a^KF)5 zls$x(U=F4375;dgCeDi;2u~C9wPvDK_r8Ydf^&#n&<6@{lrl!UF#5A+hnE@>%dd##VZzztun_B(mlQ%!;WIR19`x za1WBzi>HX7jrcmMvCbLS;sh_@cf@CbQeU9d9fezIX0_Fwi;48jxqz;p)vP*bWG*q? zZrf$V2xsmNrE5WEK;4Q@u|n7C7kfz8YA0RmL8WWeIm9W!NEQrM<3UhzJDUL7%YhlR zjx~+Nro&nK7hU(v4d!3!eQfy-MAJf#B4|DDE-l?u*Ag6@wOAGO5Yb{ng~B; z7ml?G1z!mNQA6R6Mw)>4z0?P8OmI`_GbR_EBlS5>eMnQGox(Cdv5`8MWbWmT#72TG zDYk3&aFv8z()HFrGZb;^uOMx}xIm3k1hi<|I5CkFthi&7unO(FvDW2TC-%9whO=fy z+qCX((T)@w$}Wp_r=#+`I5jaJQ76K*Eb3yB5%!jKF-RSb#-rrm_$ci^NQac#2`` zRJfR{x#!yJE)&y1va%--zT@uWN{Uc!_4$w5n*JD_%k#FmXCY!1}Pg!WT3IQ_FX7gR}%Ni zj&65}I7^Qw9;dg^ykj(R-5Dz~j0{C?m4Nx#Q4;ja=*QIWg6_%52}nTo$y+Nh(Rd8# z>K7>j*{bVUqd;dW1B=9JZBU=dI9b{xsu_mPk;Z=pfCNM;I;Js={v2J=Tzk!NtVq9Q+-*ucxG zIL$QZ5{Y6XPSgNh+=vs;lZ{w^iv}mq-qx8R-iCsv$W1tkOtvtJ*z#U*MqzSghp+|} zLq;jk-?@txZm{0MeU_J-T~_o>lKC|q4RE8#JyhOc9mk|?Q;d%Pl70_WsH%6ql0#4Q zQg`k1eWENpD2c+grW6VXppPodikDgXB$)dL12q8Xxo;gw{n12`$s@3N1tJ9d@#Isa_@YrtgDY z05eW>5967MWw|p^R2ka$%~=+I=pg>qWXRX9&m!9Q$sVw1 zfUo^{-!CPZKc)jd3~B7T&UmW)s_2$SBoA zbH@QIrH!ct-Y;TC!^M=NgKLRJ_oSByx%yUZnQdVC)eqEpVZ2rVlz3@e1?(Y=Z8 zFtz?P-V`V8Ic~4Bu1f4vhKBdD|A3xZ3U`TpZ@zC-_n;e~VKGAB)^WA|O35e;^wLjY zU4dnWj3SYqro7>({&;v8RgZ-R)Z9qF2ljyf1r?(_8KGc4-JyBVHFOXFYPuOTzI=?Z z85v@$ac-?D0X0>{zNNV{-_v$auLcJxCO|W1xCc2VI3 zG57=VZ)8NLth2=P)&-4fr{2_w(L~u?`bXSVf{^4~g8c}h?2}{)T03a!gQ*M)SuEdR z-Rak(KS2qxHNMD7dL-;^%Kp`Oy(L^LPNXbb^2I??Lg$%AoG(`;+n(*d2)NX z%@UM%E}$}a8~I?-LN1B?WD@iw>!I?*oy1J1cp#4^Fjmzx=z!)9*z0sC$V1qBR;5yl zQEO9cBzsY`BY}#=OxL1W+yK{ClP?dt!K@-K(Jw|qH#2So%I!wb5zVqj0~+2ql_k%( z(HVeY%#+IoRAZ)#)`v55MZ57p9`~5~TLG(yU5qlUhV!)1^L%Z|XZe?rF8_{aJ_%*S zLjn-i(5FaW3}2Wi4z0SKx!`S+O|}#Vm4bb>vjhMEVY!pO>RG(DISl;#|A`#EX*{Sj zwfH#?4@vu?*%7gZ1yFPEyR$7yx{4{Qn)~R9RW*^fD!h~xDCmkL4W_7${;t&Q=usGz z!1bQxXIJrY(H}b;z6$mnmW;s~3+T0(wO?(OPrmXSizQeyTs|MjvXq0(x<6U+7E0fR z(mo_Vj%1}GV(idu+W(z_b*3VebAo;)pyi8LSP*OPHOBw|UK6@U^=oXhU-Qr}%EXFf za}N!uWZm?nz~od@-}xAzHZ`4Racfoz`vL56Eb0?Qp%+x`ZIjGVe>9+KC!I%rfK5-u zq=(XfW%I35=U8l+PXpuFLa5Pv#m8kqDHis$^b!3=!$9fim+^8%Ve#Q+GOUUjHqbc? zuOrtcwC}<4D(vMjzJ4+-x~I-@Di ziUKi)Uc);6SJ5BWepqg3BjU3)TjhY8E2-}m4Ff^>)=gQc%B(ko>s1fyi4tV*Bx)%! zk@~uxKq>!%l=YJC!VrjLFyJnoKMhOvi7!w#B2O8_{-l^lbrc_tZXc&sgr#G6%u^w$ zMyo+jwhN0pv+@1emdNGerpb=!Opej^+QQL9Ibvknry0UxxK<^y++4W+bdF&b!pBKZj2Dm}@i%%ctlRpK8 ziHY}M2tZUZ#0A*c^yXSTWBtk0EF7zVm@CCZ0>X*?cemBrGHEb|wq<5>2qTH@R2Aqm zwymeviz5y=TM&eMEwEe{wgJhI#H`U4s@cb1a}V8=xIzNzx*X&;+J<|q|7^L;bBiq zBy>VgWj?22RZ?;iQ_eep;(#~md%!vQl{4CruHT;lonGV#QXcwY#Q^gZ{5#s? z@MB}9dZ2U+QLp~!O1x*G1O1$NAn5?%+f2$?2R`sJG`XPc?FS5LxabKuo@1S2m=%3O zTL-ZZHRCFANH|_(N&yRu6YKlKFBR+CP>Ft4^qJi69Z@|n9bIs97wV0a*%JLrQVTW{ z>}Y$t(juppm^531UJxj#?^p+sXy&OV_Ya4}A$0j5Gs_CFN*+x@2lRb>t0!C-lB%M< zVzZ*Jpdt{^Q9S$PQ6M{&KcHwhSezis?|T4`KPf-V+0epcj80hvg9s^+)WQr@_Cu;H zG=P?52#7&Sj8eE1$plr70rRt8Fj?P8??KjUeblXSs{YY5jAU-eBJlr`c~7Dn1M!V>WkHB2?cneJ1{UVqD?g*1j~A%~iudnTAr`s_GE zX$zixatm#xV2J>hQ54EkIiE@9+>e|<%utm8_#_!%m;Pc*p@@@Kz`f9={BrBRh@_pO zKZ)-vMGjdkgyTnvtNm)egc=pjJjpih(v zAL+1ni(Z%!zqMBEiO;mQb=hpY+#PilXIEdZqRoqN78%XbI<&nfMpMa#_{75 zctpF@dWECheQe3IFz%C{)rTf$MqA-P(C0q2B(^YA#QE=3#TO-~bxHy=ys=NpI%K(1 z+~6o|i$6pgj>Za?c-!4x=L`nqVq!x#u<0}45({DXbiVvw-LXO;P+AdqP~_~ zC+sWH{>(J{$_dslEgoLU(>k%it`xbj?hl4?@5Frk7;*qzYaRe`Bsm0@^bkCU!#)^W zn}A}7KgaKspwm{lGikS>{_BN&6**K;nTMM#e*vAcG9^YOO4f;K^C~OBZ>ouW%AwqC zDn8zxNph5aj7YC(v?u;bwS1BOD#(1_Oy!KKKJvnN7{!$udmwx-+wbpIcKcejBQ5HO zI|`?gve1^uaDP&F`C8Nb>Ut3yyBCNYlHKKoYb96eSx;4?dw*6hj43Oj81kz!IOM3; zq#f>BvTo(4$_O?OG7uFPDD@QjEmtXAzdN(mqk~8wEz;#nOr+*R`2>CPF=Of`&GA>q zGn1O5$|L8^C8d<@DN;J2P? zsqT6c4Jvu($4s|}!k{d$@PvG(}8nY0@_^`|?*%E3}xjT}%|9uRi zkKjyWaBPV~{$|BmmyHKJm}g<5uPC%u75YK4P%8>y?dN-H75rg zH3!UXw^3N4V!wvpu{C{+umsii72c2xre;a+=SEf6Mv3t z7uud613A)!W*0d;y|4=C6|TqHKFTayqPdsQ4&NLHYzcAKi-OF6#&9_M4EN2)x*yZV zZjNu8YNv4POjH(kY{o!f#<5x=>v-VP)%?I1*IWY1E=vJojSY{tC{bkBn=S!ZLLCZK z+X_vRVe{rxb3E>;tUSd#(SWHbwSWc=sxse8mZ8lAV0Y*;miY&m0M;itRNWB!skRCR zR46d%Ce-_rCe&)vavBI7RSjL1Y{-v>KtAW;*?0F2Q!V$&7uM6fOWER1TxpJ_fWXZ@ zIw=$QlJ(|tuo|G4X^wAAJ|37HQTe81>3@90(kn5Ms6+NohBT>w?yMF6anVA#_v6&; zR`viF@#{B{I%p4XCL;9*u>0zh!>BmJfhHHPsKh(#sb=?I^!P@=SBxeCRrZu^?YzQ9 zDjYou)PINWkUO{&?b@X#NuwNFGIE*s!i;J9YvJ9Xqr;aApuC_^w=Od zjl`~QlANeX)h)HA_ZZx8d1m6{ys?ADM)t&?GktdRR71F>u0r#?G!9C!OW>yDf9YJLJoT@!9nQ8Vv zfm-(Jz_d{7T|K@NeJ1#rq`Cp5x8lqMcfF~C;;iry3j zf?v{lhir1uorxf%+Yax5B_6Pv_Q=&)<*=KbEc_T-;-hN;?$Qgx%Zd~5va}~k&X=2E zG3J=5;;YuoNtM&ZfqE^w9u+^k?!qC`f;XQL0QM+ z@sPi6sPQg{h|dG)U$yNA%06 z=!;jn$Xf6c8h(vl`L<}dm9&3KySQ5H@bb|@k5^h3uU%~|WBBZf->-GwSbU&#bUzA& zy_@I)eMV^S4&V-cVv(`J3aF$2vI#;5lQMcr(`W3pb=Zzgi%$6ymBNNFUnAQ9fZxNB z)#Bds&~UK}miim^po1U)4`3Xh@;dcRWTUGwGI{eTFxc46c5gpQ0gC&Ls-rZLsQ@aE z#N@NEIFV{EPq8%&E=3aJ_x!}Qp|u1SdHIJ->7us_rUjU#plzvf=}k{j!p_&!=tv%F zuk-j;(%;B8*=u)#f{ns|3O?l-wzg7lj~?Z%nRVRImM*5t;^Uzw`T5s)rey$V)z(Yh z!7T90bx4K&1q!pli%m{LcK{+9VU)pai7RNwz6~gdhNJQF40nHnllNEr^5$e4*e57F zmDtdPj`EgMF!VGxT1wTEN1F>^?QiQOhunC}AZ+&n?dJO1T%2U11n*%p{{{nUEuh6a zv|B6!A{RDJtpoSAgh!EHH4AN2%0EelDDQt_T@{*AgHDi7KdEZ8w*uNr+PmXksD|V; z$p-b$fV$*MrLVzSKMM;6{Soq9!=ho{^&XgJT;Nzv)M^%c8KB@|^oH#5X8Myu(rN1} z^=c)*a=|)IMI4FRA#ZQzw=l!=Tj!Y>rg4V6>TRK19vp-k4X%)rvFcsC_Sx$^mNxvp zgWo>CV~2GgFImr9$JO3P2B&BL9luOOA?OXVAvO1mkQ zc2z2E0q#`UqEyUa0*^Lh>SPTm1mJCI+rKcjwJwBJ_mj2%~;bjC52MLF8}NY|GSFip8o8<4bUVI-q^ zTa8t|dPA0l>|fB8ozgW}-#4(Q4hJ>aj72dfCTJ7>V6;Gn$iS9w=vJV+#u<=hU?%AP z%U{W|=*}!CRlZ=fCtqyWN8z~~j<_DD+9y(-j*(fZ`ylySX#EDhn{L^#QX9v_mSl{2_PFL0{EEOsG`wp0o2SNmi=w+tdT z8^w509lhUAM=9TMb^j{vVf7i0{yM3@ajF~`)SXt}Afn0?qHY4B$bICBW)FB- ztX1UX{vEbZZ$~9_8Pu_RER(5Eo_wFj7IFcAg#Tpv-#8tcd3qCx5xn{lUe#n6v8&Lq zT!RM@r(06PIwE6|Y}1w4NJBI^=TB7aFrZ|&@Ti9c~4;S9y z9O6PXT!l@8$%3avyXR zTzrkZTYMPSQwvy3JXV6dAq!3X4rKMoU!!*z`msEWZ!`7Twu#+bS`MOHP)dCvJ2IOP z-;W~5yd9Zw*-T}&7o|bzbtSL@@>Sd*$4@v1!7+U}M27*nv6F`rsHx^HQ?``ZyAF~$ zIgh*DHH+YR=@hd2{c4)WLcg2v`?~pii`QeJ-*4gfF7uaIoZ?UU+_YBewMTN2pwu>4 ztG7*PO>siS5Rtz!Ks);2@^SBgPk!bBr^jBaBX)e58%`oC3dOEqe0gepVCr{!7lqFO zBdx5l&X>0n1y*6b>zprtpteSFhHKDYMcF$q1sOEWguRm>40|V$0WL%axb*O)YXYX& z+HWBj{oaM&TKqnMUz2^)_()$O|AVB)^o_p)YNWeFcV<+|kFEt?c7n&`K@pzScG_^0 z<;n8yb>vu{1{IKaiSZ^1R5F4`Gl^eT*TJO6x!VHzytef$lB1txlHK;HS#vy=Eqx%3 z?yqdo?#AW9E%|ggcgqaAIJVT%C3DMB#UdYrOwygSPoSl7UT-do$Uh%ovbq;}e9Tkj zb=bTH{oH~SO#Xg3A2-qMlfc#TlE^$aL~!G|5tO07D2B{Q#3F;T3Q4FUmrFX&Qc|(Q z@v3AHd@vtyTMa4BZnESmv}pszuy)E<_1HE%>04Ghu^L4sd^_#|>O#i9bApnrbq1?>q953usJO>&XV(F)JZiFgQW{ zrWknqT^p?v*5%U8-aO;oPWtB@i1HtLq0t2#iPQY)5oA6WTYk<{ckWM zH5U$RD`t5tSK{|-{7%B}_4qBv?=`bM=uGm5=WC^@3Xm6`)Aot&L_h|5Y4lj9(Jr>} zLuB^_LeBxS(gB}n^yhl&UT6VQ;GrgSfID)#&n=zG%+ZHcVetW8BteckMcKfXWytD& zm=5H>hP2`>lXz%vp~V~O?z*^VD?6^B?37PqdAy%nB@K3s-P1xI@$DeEL4yT_}0 zR+}4>%6xZj>~Omm&T=3=dZT+Q9L6eo8*SD0Z;kekTe87~Z;~C*e5UzZh3o(r)M5Rp zAuJB>v5!QexryqvmT3?Ge2BY%nIJ%)*Ve<;HO=(Hc~v!Wkz_tmuj z(n_}%=F|SmcDmJZTVn}@aNnL;kH7RIcV57$k8|pC$<&vS3L%tScO;u3`66=2_hG^T z+E3r9Kl%hJVMj2wM^f{RQzlu$A?4gq(h`tw+u@KvOmjSLf}!W`g_Q(KVeKIZKJw9k z^(uTZRKIfqzR=6`QdZ#==-kC+k-&1i6g# zt9=&Q+XjS^E~m+^^Hshv3`~CN<7DuNTppcj2P;T~FAl9k&Ab2uT*rZAL6Gg4{1WgF z1mW?7RW7j7tf4@(KM@&K%CEz4Hto(tLinrh_V6rUFw{yl(IN~r{e|u7E-;YsTPUgf za@=0JsTWzI32U&$@olB1)np*^i=5fHg;_<|_$;!7FXI&{cz5(10R3ap-k(UoWGlwmcmpWMoQ@IhsrIX*4w88)FxT4XF9+3yfa=Bb<43xCpj|< zN1{uoQiJ-VCjjndDrN4M<*-Xm-X=J+(D^q#_TR{W{hJ3JKBM6%{7}pj*w_l2P6`n$ zo9*5n0MSA_7mwZrc)~3vzChzj*NS2QVyalGx!Ho>;2}5o%t9YdLedV{EJySo$t{ax z*a342d%#Cq7F-%cjJn`e4EO4Ccp1B|uKx`jZQvGn?TXvY^F;H0hhu9_xYCwHH@!;T z2p0-Fdx4j15M@{KUK+UEsJK@`Q|yJbEX54K+~O9>-PhK?Dk>z(LmlqLj{h6GGZZ|4 zOEEeOz=&OiIkmXzP5+JR5qSXjg}cD~>n^OZGBc6?7>#`l0wVR83+;gWl`73;rx_K} zy+4v2%~^|F8Ac9qACc3Dzwx}`C-z_Zj#+QcJ@n$U!l`t1pM+ZWpz?UUv>R+4WB_M9Me%X{1wUpTt#fTFsq(2KR%VWhy8g(pf6Ro#oP8cCfRr;w3su zOi|>#fWN8Ea=kh0=mk1U*R;;kOJfXGXpEuG7&qpN>Z8#IHA{FFkXO878lh;qhRKtL zq7g#p*|tNoTSX2*lg<>vA7MkKfJ1^w6L7e4xQpwz;2^(HwCdOtUGB6*#?T~?Yjy$f zoKC24Y%2Y!vG6SXAHfld zTVn@Se1(~QP)xmpx>^!-e;m$Q?Z{r`xX$C=TK^F=9c6Ed_T(z=;13iZ#$nxRgd^x9 z!LbER1XBz~Z)(OfGnL{4@Mo)nEBFR%`eDLt>AWu{~4tCxO z2^wFa2^RM7cQ_wMYp=u6S~tTCCu`{#DBOPB<-~8WMM`ICR}P-3rE{2c0*%WP%^<2q zv|V%O*1z1HrBX$8FM#e|aT)Cor4we0Nto>K;I4mPW#>KzeBA3PCe`u-oHG?*z$=hGb`;RN?NHQ})EKDbe0qnRW<4K%J z52+&tr_n=Sk{OE- zaPep?i(mm8x#E&|xn{~QC+KxV>36h9Ry*jOERF~+F|z)&^AvVw6RS1*ki|ukKCX&R zC07|7F6g8xaPSr~+h4phU{o9liZSHSYsg&ot{wSS~Nz-SGFkPQTQj$F-5L?D*=phcpXOw7`dwWZrD;i2~ZLvr0p%YAp zMM+EP1uJfjFV}<)0ehX8t+|c5NFLy(m?@?0Uoq>j4TLs?%l8H`GJ4`I=EDI!F$s(PWXGEp3#o*&9j>Z(3j z%ohLL;#TbUd!}OkpLm7%Zi9#_#OmO9eK}9cx*jjq;0WU=G6O=ff$8PXQ{kB5VZ0HT2g15p_%x z9jMa1ul~1ineWFkDK5>}Ui z1R|#7hi)Al=Uld+=L&D9s5s(@w$&QmPLPQ^lPCzMp&=VjU!xClcatB{VH-%n0Gy_0 z!!vWnW0>^_0OU-D&+4aB-c#0=vdX7FngxXm+GQgEX%T;c0*D0z&IZ2$Ia7F}=DyKh zHi`h=q#Qw!W>UX4kr_%UbvSm< z8XR0^FRWB5;QJ$hA5J7D#HwFq=v5fb=EJ@RSD|{;V9g{2F4-Y$ z-2gW$8q5+3-;;cQtPn~jcLcNB>_~L`RcGl-@N9i~85PZ!N8UC20yRo?r*Z1HiFfEt zw`2|i3+KTm?6<vPWlv{Y4sXstfWDdjWQ{pDiiK|NDyceggO}BO3vK zu*(4cPdRZ2@Lxqi0KfSeBH)osH>8&n(U4ZJ2$+$33HP27nSd!*WoR9+IA1<{81PhY zKr~!_k>*}x*P|3yMlS-eG5c;SSGfh|k|Y z6!F-?{4z6bx&16)Rx|C?pT8{PpBa}9(9qh{EEDwN40Mk>%Pc#VeU^SGbT3Wz<4kmK zg_f6w?%jVp8@jWG^iDoYnL_oc8TG;Cgw%qr%V_1tyi(~FU5~p#=$)7Tr(cNPxk;Xa;~!@d62S{r*S%H_Gz(i46F8(n4BaV}l70hmy$9ARV-= zKi2XLIO6{-@>nvy>9IWjEwx9A^;F9$@-MF2fgYvBw_=}9c$+jJBoA3SVDM|qhG}Ip z#f4FEGYk%DlNe3u=?ULdA!b) zPawOz?MiTy5k9{to5ZRZX_oTAR7F;ih0}e)gO|y}y_xb>ycQhtL+N6)=H*8fg-RvP zqC`3~U1MQ|&8#7po4$~1ptor?(4!ICO^M=|u%cD2gAyR!U`%QH1(~PYImQ!(x)I5P z>`q*LYl&i7elpRgwUU|nAY98pAXT0oiERbT9Bz74jO!o9+Upg)BC z!Nn)7k4cS=69ib5K3^dA3}sTGdsGz|A!*ee5EeC#8ml=FSvdgH8F$aHw|mea7L*=} ziH%c26gMc&e|;c7YpC-P&mavZMmL!hS71Cv2Lzbn=3fFzuoWk;z_AllHPX8|@}LbM z6&^a!NSi!xK6T9&IRw49wjYry%^+=88ywju34trnk>p&WJxG|24UUF1^e6&+c2A4n z;t9{EvrOoLlTRUqmnKgj-9q*p6}d&Uo9mO(qVNrCfLX+p8+Txm44%DW4YE| z#^6ZIv|2GKd`jaqKBl3Q|c7^>)HE{wY$Bhd|pym*}%Zqwpgn?e^>p8292+uh49pq6~H4vk>4 zOu+?{rK=vradrqBrO0xz%HmU5W}}hhu_Ek*Eq_m)1yiw-RE*NHb%KKl$uYmqK&=5e z`acb!fQN8kEDxdkG9H3>2#1OF*i=G9oM@C8&rJlqBsF3`{j2Cn8eHS?Wync3(*?-L zfzc3J3L#7NQ5+!f6McmTkxJiE!2~_<|9b)XaZs3J!L{>WjN9Uib9SHLi}2h=^MPV4 zj!JCoK#73#s$O<)J1yrOgXk5^OZ@SY??!hF$QdXgHdBl!)YM(g1Xb8haBZA|&8pD> z`7yu>1a#AwIAiyC(DM`d4>wVY3bnSG7&!tvS(P#5 ziS0ZtJ8Jdz8~hShva6LKLG(jpgK`z zCMxg<#UOPW9F-1&D)uczwHzcm(HoE_UEy^KwvwYT-bz$3+{GPPq~Ld%|zseh(D1A-5VxS%8Oz=~Q9r$lxf1dWO?eA9iA;59ud>OtB zS#g*1F}!U0KGsKNI-&K14pCzZZ-xsFLQ9Z2O}?5?aVF?tJ@rlg5-AwydhXb}=um1e zhWgL_$))olN3fSF-zCTWL$4jhJ#6B!!{Y5NJ+!O)gcs9p^{ip5J@%%ZoALn_ea2f` z9Jqq#|9*h7%=oma_4o5ArJ+Zkact8h&a?{~u9dJD%J-q_Vjkc`fjq>wL1+Pc_%4Cn zkAAro_jDizaV?MO6?+ib7AH$j>J>1LQ>>I?geX!w#F$L~O?j(Xy1~chjlvEP1I{pq zLTED}m$lHW&F#L3D#m+y6XrJy@rKJeF}eVZFki#01f2Q6b)i{3_9^8=G=Oxj8qdj^ zFE(qYy-b{_;W~$N8dVsi8b=Umkt>^{aoI3S*acGh?I$25`S9D+D`*B`j^&O31LWvO zj(RmooXE!tp!MJPsa=2*9=Jl2Jse_A@P)Oh2>uycAsN;q^Wj$5~7f z=2}W)>POg0>?O|IkG;m&0mRC#)DT)Fb^x)mRg~2PuI*v3&3zObQ3@Q7|=Z;wgJSgo8IZl@NFPpig)Y4hjUd2S}T_IW#vQY>U)> zxe8o73g%Yqe+ca{{rO%)dkhCgtx%G&{XvL39J!KoT%0FL5BQCcCTbjo9iA zyOt5t%SPnM92&*YCS0dA(KVMc54O@p{y3?ALp;Ik)PO@tFZw`hrW(<>L)}VCKW~SwrX^$tPZ1^21DecH*#XHjKcK z&?@$DKpum90XP5i7?_imYVrWC0r`FoAs(@u%*X+>e)7@!sd&@S^%FVlI}xjiLjhq0 z%+3==i~pz2Gp&WvNK8*->6Lz^|XgtY9srCLY3CL?-f*bfMRLaK!1M+e_gUS>j+Id(c zst9pCpFrNg|MMea7v!4mFi-Vk4S{bkFf{}Nafe5#H(G~J8tVZ?CXCZw)Zzu2QSlw& z|Bnaq%O?^_u;7=Ek_tp}J6B2V$6rYu+$3R!ALd60sE^=u(D)bN%q*D)L=mFv$)`C^ z4u!@*%tBM#>W}^c*8aF_qlN*&^@f&XamPj)o>6rqy3I}}AgeoZmbi)1EX|WBR#gX_ z0)#6=lwx<%JAnOLxF^K(%vBaXE%3e#5o>L4K%aMS)#LOjpy+b#R2VVmgasjO%e63V zIb(MSjLY7A82fDQWttxM(z>exVc0!b3YhJYRv4|f*-zY22M>kbJb`S0AMR4t>oXBnHss z3Vd^<>Il*Y+#P7xKvH$5z9vR4HQv5OKKcA{o)?NA10bjiaH7w=*ySRQjpge8nH&y0 zCFesWNoN;1PuI{{vrl^xiPhDlpum*?Zngj+!a64{1djccK^cUI=pII2j*<0mF+We#1mtn?#_<9z<}C zRbwuYb9xo7?)`eKh~`E$9L8_4N4I6j4}N3?Q32z9@(6Bm6p4W8gK8>p)NO-L%w9m& zDpRxAozg6hux4?Tbc+6Vb%q!^#ct>n_||}0Wa67B(C9KDeY?*|y@J?Y?FIS6-O>DT zP*%L+ahiav!Pu1svmw<^E4R}@^ZvB9&^Irflu`@YuL0(zAJTm22NsO$j2kprx)!5@ zz`h#SfU(dnL)eF+Df<$Sjmpz9H`0p^b}czNd*6~zu*$2qW66pul)S$b9tyU7mLbc(N4sb6 zU6hRteU`8tXPB+-L-iW2h)CRT*7gvhqn}yf^;BWIhA$K}z=eWhUUamb%m5pfy^jKS z^x+__v7raGBCx;qqP06?!cNlPq1!P>bl__tP-O8rm8L5xAz}~6S1=fHDB!0Ut0Tnh zNrdfOwk$bxGW7sENh<`eDingwAO!Gp!Vkjp^pY$%ofZh&?7~ReSg#*zvRW-DCsW(K zaqr`Byc}s#TJ9H6z~Z%3KO8>$%=%Bqe-4&3a+QNnqjkTTj$b6W8|>j>L3x*YEmEk} zy2^p|bm~NaSwETB6y{AF69pW$&@fAyvZkxmsK9HIKWm+(TO z4Jzw=h7i3y@Bg6L|J-625VFg~W@|$rGzgI7I);f8l2{@xTw$-craPN%`o*=F3y4eH zD?o3&P=KLiHY@X$FxnYIW`@bfk{9S7U}ggR3JaN=suP{b7lZt+B}Dr3C%;P9pUKq` z5%7Q%73@@5{b_-V5Ph(JI*3XGL8bbEgyCl^X6GjMixG4_R>cq%vuA-Pr*B>iS{<)4 zo+34h?I{;fWgJeN?D{LAoY0nLcBOI&fxU;7wt&xIs}>eyvmI!NR$lHmBbO)(wz4Ia zFyr8Pw4Gcc{@P`u+HTb1Wm@SpC^>HaVv-)~!9*+^LxPhH_$Rt+9Avcrxb35{HCEfl z@|wSASd606jp9ep<2c7=|6-#!m|B6sW+mR-m`dHqDn1;bK*niy@!QY=6<;K^4?#OP zb}@orfD`vn0h1ySM)G<4VdEmRzWQQ>Ip32jk}ooW16@vhTLmuocTtQ81g8$)AYN8c z&Q1IKQZnemJA*67$(N?*h(&oc;;H(YpU?x|#>wu8Gn-a;cJtT};-MekS^BN|3c<>R zMZ<8K>WG)C@sOFC=KG+T`doTxQ>Mi<4NFi2q%t7RJOBdX8b*#DbsGEvOQ0WRovjEy zkyhqWWgJY9e;S4|OHn4W$J_t{yaySM*sSbyw8#_3Kv~(4a3~K;on3`cB1_#WQfink z2iFV>^`_5(4d{*a@4;#kdImNYSz)E6OPs&dVe)BMw3vtTLMkap)q;!c#ANSG@+Y1h zgHeEd=01y1Yp_AtTBpn>88QPcgPmgOLH(ESz(b#mz%Pq!i`SMG=}jThFnJH-81G>$ zdk+G+qtduqfx`GkY9nJh47k9`BvvSSo;+y>;NWc6(ARZ2syVGMkke?G^wVvNC>;IE zzc}mqW(tS|COhm^#`9u;7JUzH8yRn|TLq2U$`Uss;-4L+ zgWo)&G?8cNT2d^pe;7UR;$VYTEPsGBaK-?_0LpeYLF9Hn5%-$4lY&w)kkm>*B}sz= zujjBMfq)BSZ8mph(>GNkO(FDq_8&0M+V2s(RN{j6Y7Xq;6l)R zxN6FCkwy#v%ce=O#4?{hC>wuDGK%-^=yP3UQ>B<)GDHg3A^v~@(QoxYp~09k-!Hof3;mGPL7eaCf$~hcCb)f)fW2pE8K()jA?hY{ z%@xpSfP&&qMuAQA0|nUv-+Q{zp14+C^<97-p9Ltu6(TlKGD&V~uu@Qmeke`+x zc|U$g<^2#>G-c*u`lwYW1t7Bj3C0LN8JL#e$DLZMAv2B+JXa!h1BuaASW&$gexfdWF0W_u0VPysW zpj5h!)NDG$v#FD?nYMW7z-;OmoK5EPpc)RS6VPFr{B#(Iy?29}J7`A)_nAW@xF-cQ zh6QSP8l*7pFQ89g(2lloED;kDA28wxc`*>o@WmAvPLveM=iyR@TfdQ4Bok49vfMr) zASaTEVta1a4UA#4lRPPVlNd&ONky?(Zj7N~z!^@;N9A*PpjBbq+hM@itoRG8fe?oZ zC@-Xd@+t#m`(hYtn~1-#KAooTz5wvNkPaR7kNJce9TrFN!ft{0>6jV4qWrv9jH{Ffs-Pb*tTVM89V}n!ZHAy_E#DsjdD%i1XfCzoQG?`SYek@>PQ3p zm7N?40kBt;#Y;WRMXjrut;_+>n^CgY)xzPzH`6QllS$DgyG* z37VeCi8rXvk{k*qChmr1T0RBwhCJBP8Vl_w7YqqT8D>buxCZ6pT!({B1jCG@%KQjA z8#4ZucmX)qFX?)%ynUs5yaiW;1DKHo%E*gc!l6wJ`hOWggHf&~#28ufVM5e3L~GLIw4Jy@;MM{_p|$kKM}Jy|;dE~~ zFZdFp>4B!?IMxbZ!&YO+1GtBteiVN?@dqM1-2Si$6e24vICkQOx4d!&9Y3u zae&TM6(ew*A&0V6!YQB3c2^5Jh!hLtQ z*NPc-yL;L?J@!9}gB0(CXHBVIKZd?hV{w-_^%$|{vgG&hN+!jQFPB1F4Rad=&fV0h ze}Gm*gMAA*veQ#xw>La4xGCLLm#% z$_7Lmb7{R@i_t@<$Phz;qDDssKqV^>^8}v`O+-4e@%8h`v>)Z7Z(_e&y_21nOd*}Kio6)UAVxoNupDxKwfT9Y{b|dDA*-XBL=zdEesMSN-%WDKyB4b64Y5@ zhj^n~6R?LGx-nA=EN-7U%xaNuj3DQP*YS6-T1<13H-3H!Re8aeuwO^bw4eo!QBIcC zXpbG909rw43K{D&VG2N8iF?cgDuuq^{H4LKkp=D=&H~qkcDr^!lG@NC>`;Z>~0Bzha+01OL6dS1qy| z*+x*~zSD>-_&z3+@8O8=@6Daa?(k*kvj?-k9$#2;e05U0Y4aCU2<*Y3N0l8?Hb_q2+yJ7`aV7_diY+TjJpzDPF$9(vO%f`b(x z*?yY!`;2AhS@-YFh zQw7An&}cHAgm{`A!#tEogk}Dayv4`cz4&TfVjApxV$gRttGa6ob{Nl)-_f20v_6Sf zbdmwjb{ZVEr>Fvc3ZRN3r%}XqP{j5@iqM;`0@l#}R0hHUIu6-ZT6Oxj!0?ZIckpZyE**N9jN{~3Q( z*slCf`1?BWmxjKs4Xgs2AS4x-{5HXxKny1DI1`^G{2BxWe13$@wlnZqjOk9qfkYO19TCZ{WWDT4LkQnsI&R+mKv@Fbp zFU@3ZMMi+mV91V)ayz~Ac7{CH&7tFAMcnn@d>^`xdjHI?Xqe;JGemfg?C^d-hAvF* zxc6!3?hDfR?5n96gMqwSA;wgoI_8|)T-ziUlUZ7n-T8!B8 zB;x6y8EbbddiyFrc5h6TR;(9q=9?X~VF0VEKiD({J#RYP;-LXhggm(xur~Aj^#!Uv zS3%w9$eB7X%{TTHsuZ3O$OOw$k`hzJ_{KpMebWV;p z8#U=eed;pJ%?gGx6`S`pC_%UdfqmRX&F7sijn1Sma7GskTM$+N-&vP$uq8snA?oM~ z4MOSzVs|6C`-!EBs+ii207OJyBj9>~Frg64Fkoj!Pgx_^D&Q@7Hbp%Dgbytfe7vU>IBcJMsIebP7E#F&xeBWhn|hXWN$tUaoqhx$qIq%+&l4xj zLR)Y5^QX;if~q3bSx^|V;zyC`#s-RbieWx6Z348w?w7{ z6-__?bGVieNi)(m69eNHSQ4$}3iFj7$TO(PtceSB&!vh?+5y!^N`pKB0IolYg(NQQ-p1E8P8{aT2qjZ`vO_-jPngcU!HcJe@JF5AR?$cj%0 zRD6P9k}4L}kX%e*1xOlPEn`kA^2%xU5IJR170Jrkf;5DYo<(6rkN%^+I-2xVJHTtp zq!u6`K_Adgj`~QiopncIf8j*)#n7&=Ofc?;H|GJ>{4G}#N=X>4XMZre`I*-g!~x%x zJr0sYsk2xlo?` zCHnUh>Qq94G8{fUPT_qO0t-u)he zkd335$gC=Wf%k$+$V=zDf~J;BecuXuM-&W|?fR zqWksK_gfHSlvdDo918S>W{@m>2MA3b=W?iGdYrsFl**%}eZ1ws>x_G!Oc*$O%$+em z)IzIU_358*rGgK18}mynPbN$4L@Bhr2G2gMk*~atP4UUEAxDzgeuiwxV>~dhMmDBC zxl)7qh6?6V1u8;a9#f;kFAK1hiBChzJl@hwD!pkW$=wCSMuQEV_!~0wXLn=|Zow@$ zo_BQW0>If4h+GM)YU?l9riYLU!|7}z{Uw~Zc%k?jyupl#lp7Y?@4rr-e00`t0f+`v z3LE1MxPyhUnX)L8Dlgw$3o#z3+Yh1qP<1=4r|OpIv$+%Y7Z52eM1M;2SYAfq*ALZ< z_sjh8*eb^4#5Of1)ZW53q9?Vb-Wm-@W8NXVE=rFn93mxoJJ0ieC+F9DyR+X%4&{pGFgf=f~=dY5aW*gyz_VXlOa7 z)pVrH(rHVFso*IVj@3!@EF~mZ?2Tk@FLWc4yDt3i!4*p znlcL}CQ`_B`EUse_t%UM%KEE-BM=QjD2Ma#p_sjdqjQ0ya)l$GT>3HNsM$^x^NL?!cZ@9&W@nSFnZDtc5IhOFk@9>D2eF6>V z$;~JidK`42s`)h@yC=(MaS?kt2@)(lDmi-W6mP|EP67DM?u_CC0CG@HLzjqn`kPB2 z`HZQAoyKJsTd>yKiz-a}TMD!BvP_@6Zz~!)goW9iS0kbz(I?^+;uaICdqhx<*sz=jNS=CA$qCcI>BT{ht^?8G81hP326quh)$&nERo#Mll1n3ZFs9*Y}dFWJa<7! zIX<}yFHsNzeXd_HT*Vt_!4I(f9r~V)IbYw7msxFFee%^-RNW6}ftT<-xd6VGg$uBC zOXJjgs0YT>JAkP0CDExL+n+U&)W?|L*AdYY-EM73*7q{7&wp^N+;tLpZ~srMzTF8NPYBh2$ZUo)#dIv!O& z!&Se7TMWsVNQF@~T_mO-b=?eR6AnbDPU5PsOY8Lz{>SwFXtMekRsRB4|D9y@Q~|1| zi-dWZs*g@xN4187(WzH)_16!n9{NQZWb8gUK3V@)ss5L_{tJ`!Qw^w}E;6F(PfVOg zPa_d;#iU3Z-xBr6egqW(Q$i5YG^qo51ARX3OU+;N`%POZJ`*w8;nSMvdrognBkK5{ zEvC#1$RB(S94g}Q$7>` zDDi8$isjsjt|HFXl_AeBvBk!Je00|f!5n(pK|-1SlB<==;M{a%+a8#2I%&d3%unaF z>0>2ezG$$1g`?3ecqO?Y>!D z8^0kX5RZ|wVcJ(C#G5Q@?a66dWyicNe2Z|Cfwd#~{=nWXkCVdR5!Wt;DEW}?2^ub( z$0mB3N+1TvL|DWGy;gflu=f1z3bMCq4o_kLC86Z1ph4;_Bh`S3vq7ya8 zBj<5kw~OP=uvfr&tokML#ZnoKMLVXKi8_F^Bc?4hnP7!8L>imO-6-Mlyj^B0fvniE zqK^7Pe_hcD&ANAQiAyTKO5urdio3Vys}i{R`ly&$QS9hSlJfttJurVJI5F-PDfZ=+=p8VzSbm-X z#c~eRbF(&bebxI5BWYFde=dqwllmDc;w-KWrsL|IcZ%Xga12l5O{hc{pffNS4M#+Y zGK~JuKkDbTZrbNjs*g>US{czD&q=)f)MGa5KMCl)$_$jAalnAsoNwd`gX4dSvbNn9+m(v=Db?xud2Kq)3;c%Z8sN*Cm)41=2C1$zutqK zOMgV%$dKljm^;*=3NsNI7QO|zN8plTW@3*F(pX~FU}8uJ5SycLgjf?AgF66HjJ7Fs ztfaiMdhf*?ZU2zKLm28Lyt1vXBLbjL5Ta+KNivH;F@egz-g3acmI3g~$N z0}Dvlw-p4~&E=pjWNAs$L|}y4>$X`+N_B(jc`RS%q3;dm;y=g+Q!fs( zw?t6BO9>1c5J(qqP1DoOU$&5L`lt<(vNXK;XJ`V+QQaz$unHYdGZ~a*9c%TAOkwjp z^jBcRoui!gvNXQ#IiSQTl(;i1aVHw1ein|z)kLM3uWFP(6dny`l^Fjwb=*2VcQHO| z+7`-^+9{7p4nd%13QQC>f<^9^pDl~<*m$itk}nBQqcB$-g_R%?O0{T=h^dTEHi-w2 z=5sfIC{^OW0TnUqbX)>CVDy2XktJpsT$DoF3`#RU2Fe6lzll9Cpsh5#kkDdt9Wr|7 zK=>AEee4kth?(&cr1SI~)!{YE5Xy_kdC!%f)&7K#xy~@|1hn&}dNyV3Ltqf%O#~!Q zTx!)Nq$pq?AT+K8(Je{RonOe7{Yjj?A-W5SzzYk+ot}vbFQN68A46W_g>f+L<~^EI?dceYZcw(dmj_ zfmo+2^|ey8Uxvq)+Ij}!j4j%CUn{ngWH1og_LvGsXT<3|0t?heNmXqAQ@v<;mq?RG zx$-KNf`-fm`_llP$20*}of6T%xYL>}ivuw`80LH2LgfA!znJTwTrT38D6%_H50!cW zZdi+3H2~*%n;9UZ{h89{kKXk@!u-XPxjwBiB#SEx9aDq{kKYVi+dCA&nAFYsze4YMV-{M>DJQCK;f9nB4PvyT=8iM~;ZBO6+ zTfd*IgInX`zcrs6D$q*$Z@o*3KgoaVB$C;&J=uTjbaHh0Z#{kg$5ktP&npPjs&F8)X^!5?{kGX6;0 zy5Wz0o*I87`t-( zv!mTN{@j$T!^NKmXlM`onIOfVgg;$ldounEAV+un!T5ye_n2RZ3rCnR3dF?i zTdBROe=8b9EO-z7OwMeqpRyC?wms}q836p0Nk1a^DLa9mGI{4XBfZN{nG9|>KV`2X zwh%vMtH069PnjK!dU=SSGM4QV@GA3nEB|Eulr32t_x?f3v)2INUr!(ZAAqLx@_&vD z%^5D?|3~p3yS5hp+rD`U{Qo-mzljc<0{QmwWVKRXK^04@Sgtybhf5|2IFV9cL|9nz)!+-reHU3NVY2yD^`oMo_ zQYZfFhl~H(zcupv>G40@3;+4<1OEv<75+;@z<+JeDeym8hl~Hy$k7x3rTCNZKc8f$ z#D8*pTKq>7Le~F{J@9{fC;m$ZlK3z0J@H=#w>$nL3Dfoe%f0Yla)STz=#Kx}dgH&8 z*NOk|E~5887=a{~+ZGSREwbx46ZriE@nq6>X5_BYaQ3YtAiD_pplX)WgIhQP$?WuC z`E5id2rpg#mEyWmj#cLS+3~B|4pQfg+}#{eJ+KX%)PoV(_J42RMcZ2Y4c?|@V?{32 z?4%I4_~^f2|63hd7W|k|P0UY+$RTPt_Chy_v&!e>5~n?lQGr+Rjlg|B73mN98%R;h zeBp4M$rjI&e?{zJDcQs=3s>V{v&eUvBM_a_oVEh-V@hkG^Fm{U0_}O&>G>Xwq|=IW zGL@Jz+l1-(3tqPvNvt_q34Eeu%c1X`fUbuhc)usI5fY;Kl2MK2gPI&}*lT^xxP53N zgcnfM9P{?0h(!yZ5r#C{)Ka*U(h@C&yX3(|s%HYj3J>wuwk9D;|ABkIiJ=qx7`N?K z6|@KsXT%LtW_rpd7n?{WixT; zgQ`{~Dx%y(Y7JDqe_=E*enuiXh(jRk;pQhiQ)s}U+@|Wpw7`Qne+#J>>_Fl6P>Jes z6bFVOZY*q5EspW<(GYR2dLA9=l><^~l&3lEb{XzK&0xY%VCBPH{H&bbNVItw<8pfN ze$*g^-7uC>aWo@6UdP|VD9;z?9&cnPhwr0-XT~$zsPCcb~r7kxk}?a@hV9Y zJ-9W4F>TFpnp@JOF!`s+(jCP`T9 zCcM5gp}De7#>RVe5<%L+jXr7D<$QL|xTsJt+ibz@x_zH8-c- zA&HOvRo|EC`yY9?MT_Rw(U&?ukI3f^KJD0tMJquX-6)Oz4L^IO(fbf_vROO&eG-C= zYR)x9!8LqJ-UKq)kCEJ-sZIB+JIX$NJ>vRdV{9|lyxik38)mC=N^2Fu)W z&AYp6TvKAwsL`$GyXVB?yQ=-mkEm7-kE!TnQdx)P@=j7&`+H__gAhr~X@8g!sJ%ge zDeoS${Rb?nWoaAb@ZO|>2zcm3U0Tog>d&fq38w*!eqihN>ZU{09TNigiWYLN zQin*!qrayVTORG}tGw+D^-1L|kkR}3$L6c=E8jx$9Yrdb_}Hx1_m%Y)$vQrn)wQ9D z=BRdh1Uc%@>g;gcFx$<7qL_A9$F+77Vt=jIW*(l*e3)5H4vU&!wG%R86XR15d|tf2 z?&7uIhDLs!;WGF+!+*kWF~(P8BV-t1AUegqvYhe0hNg10gvm2W%g_)9w zfL2mn)|}013M26|wr4zUWI`3$)jFz~DFjIw4TpF$_%LT(HfC&R%pJs3oEaWVb%L(u zFPJ=FYOzoqxyNfV#pr%GKN-1OBQrpiwzB>>o{zTWd+y(!?`h%hrXBg7XZahp zGv9M;SH9;b2Z{rnx~?`{4vf1B^QhQE3IE#~h#{7t0ne*E3Z z-zf48;O_z6%XoT5{PX`(Mx>1BM=_~hEi0}6hylK?QU?+@Xt008h#^Bqj0mKU7&hXJ zGc!gEKg*`@oSk{jx#wkhE^o>ARPgr{f9?F`&}WbL)c;aW9o5g9+D-Yu>Nmg%`qh|H zaD*)66*stCfbvhU0{?dI>9GPAIn6OGLD_&M$_Fe~MgXOl==m-S@VxTs@j|XL`9yX3 zJQe3>xau!S{RAez{2`&z-uP_)T=OJT|F2AR`683`-nT=Aa_5QFsJY2$V&jQ)gM; zptCb`5S|0q-3rkBKGkhGtA2iZas49y#OI^^>e5~1mcPp->Tdr;{>Wtrdn_0k5uU_K z#6Ia8-_?GE%)>Wn4M*kjVfa=ejo5o-xMq_AYabGF{!`#-iV13nXAL2K8*-V3%#x4~ zp42pFO9&#-DfZK+306sh*9fWJIgN7Od5|>b35=ld@fZ0Z!!VoSRrw6BswTrG8}eIC zecNhH-RP$NGc!i!f77_j@Px_7!+ccl%$LG;+UR{tR=N2%+5}(G1P%9+ zV4_V>>Lyrg6U>lL<5Ob>`P4Dqjs6nR;l_G)3x*%_5C{HYJiMSBDL;Aqm}jYjh)6R-E6?l!EqnLo?v`C!mp)hh znq|<@__Zl@Ypy}{3nlNr0`&Q!1@;Birbhdg56M>L;a~llNHYD%uJofM{S|Kdte)vt zCDSKZDctfsl0L;vFITv_m0zAr|3+7Oxg}`!qr<#Ka&DAsSS%qZGBzZ4PkS2Ap>^oG zhvgosUQIM1%-|)`q^GSJ%?_WWK9+<~`S+%9Z|=lwEEvemu={J?*PatZtVJ$;0`U=MbLZLt0K6 z`CQ4R*xRn0khJgAbz27ipozzuC^zx=GyIl@J2dC>B`UMX4665~@)z|2ONn`s;IO}; zvtd8s8=mkvKUt+s-`?D_O>6j;Hr>TDoJBsgyU3Ef!9($nG8z>ZcD1K8JX({@v<*nN zDav1W8;~mv$m?prMQ#Jq+y_;+nm>OMr*goKuL{Fb0w7|&09W#IOO=^G zSufLG)!PwD?8hD+1X&ce-e>$!{2Yb4osyYS6R@34RS($6=Pt*^R_kYY`Kuk`Ilkbm zRA1x`F*$IU781>5+vI@Xaq(!m4uVx`emjp*ohmBnDElD(W4Jq@d!^U79ubn8&0YepvAFxVT2V=c&|j%u>Q$LO^?2hLo2ruLoaS?X&H z{%Dzni+TB*Q{)Ry8|;f1>DUsEnom6e)1;WbCLo81Po97@P1QL8m!mvZ1GundZKRKS z%UKZwdr_f}or!0NraEcx&;OkUyFHVcu;V4i0r9-S-REO_aw1+~B4mU*ry_$sGmYJ* zLdQQ#bN>U0+itEIU}N884*OvM-U!-oyk#22K-799Z#&I+Gk z4)QUgIp{`gVQE3M+u}`&G;+cWZ~1`dyyR{jQnf1I^IRscfx?P5On8@=8xS67Vvr7P zy8+&Co-T*aT;EBCGM#AyvOxVzK?jpsDsDL!XrhNm1eq!c-_ED`9OGp1Z5r2Z1$7># zX()$|O4h+gBc*ytInb$^d!8?M!!pRcp0tJ&i;=ip5I>GvP=hlN^-a|Q@07( z-^bWOX4q#0)``)=B{$c+v}F~U8*BJs5eg9{L;WMlp`mIC#e7Gq*hh6Vm$+(;%RGu` zGSP``x_@CBCrp-!uDnTw{<+7OcJYfkaEVBNpINI0VWD)7AX$ujyG+ZMyX!4{EHUHmpe^%;fmvdjLO;nC4 zaS3HJwx4r%Pwhve4jgjEc;14#4GV zhVO}#3CgfmhVUdYtR#Gd*i!Q!v!ogRD-Y^Ah|^d241CcGQF*$71;X*KaZ*|bK9TbD z1FX*P?F-E-HFuGRn;ib2mRG*nCCff)5?UZvRJs6!_6XY3qI51pxU13ClmP9d4DLPz zcSX+XwjiBnTO=n<7}FG<-DTPBlC)>8yCl7HojZWtYfJ8@yUjfIdSI)31~CA(Q_|&i zG2RqI_>q8Q8!hT<_=_J-0tTp>NSZXQ~SCW)2Onl%%w8ZdFC5T-T1=!azGk z>CPO#73>Ygmx~#^4x!#0m`IiA&G9qt1;JfWZ}ptf{hYRWL{RL#TNT9e_xqooT@4^JX;QZ8?acEWe<>`9Ska`QlJ~gKo1jFY!=L9ION7x zrg+R;<;CEMGbgjU$(OqAz5N$$n^5ErSi5Dt+q%T*)z(Vd`l8#`qRiA?@9m3KW?Zz3 zPSViW?93Qlo#UmY((hQ2m^3WJFv>A$h8V(r;aUZ6G6gHWD~ALt(^vTD4!vs~#C^|i z)vKsH?EQ{3djpAKz_I@zo>{^f8n})?C0AJ6`RWVH@KWR3P=)V5Cx2|LFf-T@O%IRO zgkRFCe64|!@E8r4XX}n2VyrlgLC2eCE=Zfn%gL#egH*q zpYSTHe_k@_!pK>Z7DfgKwl;;#4>qKET8D*SA#rP3c%S6CLh?*cnXb8_`%20#G*MFV zSrR@V3DRw=+#4F&UTw#EB7qGvla@f~y6|aDTNMZ>Mldh{F1uOt<@=cTcJ()jksgj7 zWvh!9c;AHam4(g?jd-);{?0saaJVF|xKg|kr^&?65vSHg{^~!CjQi`Hl)%sS#Zqu8 z*Pn}p9<}yE8PkK~%YTDMc~+_Ml~bK*l-7i|!~C&MgIdt|6lJALSeH8=&{)a{Nx(|KcCYns#IyeuB43p={| zwemKI0sTEMo9vX7)E+ydG8E~&(r z2SWg_f;}lZ#pKo%9&4R0Rz{;)-P2UzktSsRhZ;0Zd(L8SaIu|a8W8ud?>5QQUqy&hp>I;>m=j=ltAabqTe9Wr;AZ10mEDOhK zDGtop>8lUa`4W)MMcnD)a*|u={uSwSOUw(BYK~S~yxAN>Ei~dRS!!foUXF>lS)zEc9bJ$H}H}+CP=e{dj#n z$}2K8dqa-$s@w3F8NMCDYTo)fBhk+O`soOt&I{NZIA`Ly(Q{#e&ZsX)nK&gSI<$IQ zzv}J%U`vnWHnk@8YoZsHm>CZvU>#t-e5!C(~eS`O_JC ztYUtDG1g1wZK=`5o^E-8+I`^ZZ{%oI%baA(yw5H3FP{-RhXc&dho(Yca*vn!1TQL% zVV>TUkp{^Z3SJ+k%HG1>X9ufsaVmCezDb_4fo7@}l|`b+$}XCSxzt9^Vy;>%nAAw# zWBj%8XFy<4uZBJt(dOV7WrBL-tvnlDGF;4=?|nac!B~9rmLC;6%C&^KgZ$^XuJz_1 z+#htoi5eR5))3k<$ozU32i7Ab8!P`YtRnMhH&>h`)nu}Mj^H}%!O9HTuO;$+Z8jAs z1MCgHQ{GPEQgc4luz?27mS7-xI4y4}+{@4@4fqUw0nLg{$M_7i1%>rh~a~Z6B8y& zy1+dl*-~*qG%1ge);d{RbB~LWaew26+l5(Tfe88VvE%eZA7*jpN%gUWFu$V+vW$nn_VWLL_oISE?ZNhnYvYwE z@kvk1eBl{qhIfOwtG9--swVk7k@Gi5E9YWNEP=7cEtk@R*>uZC0Wt6QrWUdJ3tm~i zQ*13n{mzaY@772OyMQur9^r44{qS6~v62DecI?2IcMC?R{abUk;l_fU^s#t`tdIzv z_&{FZcpJq$!bQcvi1;l=+(1x^cRjQ%F`bbN+L2tljRl45jC#oI<{@jCRHc{v`0yas9*+C7- z0(Ozcr)-c?fPo1)?>VpO{1j%!{SUQxhsuySo))i2k#R=kzD#KWypVE9w&1?<{kaDN zrA-JJ0%sPsQOsmEB0?V$(NW@cMVNn%NyaMBDY0Pj7iLuG!`iWmwPS+Xlk!~{#IHdA zv4ztyw*t}C!V9*OabNK4$^o&nwbsyrBGbYTfUw~4+biAa&kD*!;;XKoIhYJvdMDafR;r&q;aw~RL3)_9q&D{Np*>S z;yYNo#@d3vSvMOE-kWT2I}L89!5fRsp>MM~%x1fepOTK4SOsZZ{mj%Pwpb^bS!cFA*{Nt>;xFryJ?^A);~ic!w4 z{K1endYd})>U86U>mb~Cz36xwbW`caze{)LL08M-PZ=IZa8=NErZ+g#w<5!t(g*tX zE18!>-@;=>SlAA%MJ+#J`$jS9+jmc3?S&G!C_Rxo4+JpYsEW3`;oivbA&Yw}R=BwL z=+(MDUdwj;qY~=N%g=6|)(mMO2ZF1p+WECKIF4sn)NaJvwn+Bf8~dJ*jcN$=Flka?yNt1qhfb z6hr}Zq4!74#k+Drltrvd!g7W)02}oxkkLdCF}ALAa_;m7@3hX$;{MHDLJ~>ru64EQ^wN%l_O-xm zg~tv~!n@w~xiu5J64dWTs{={L=0lv@?6o7sIMu!Z$0~#V7~SODMM&%{4#*vya$06f zU@H*CrSCC;DQ7T#{G0*t+3j;J{Kng*ru@jp=UJK9Zs$o(Djc{| zqYxeQK3*g|f1w56earvkD9B7!==~l^)eEZ(o;Dw94}vEUYH0&InM`K@BPxPNofT;C z6bny5C6|G}&Yzem`%p=156e4ip21y5;SKyv21r}!`Js<7tL%f)?Kj-<_{A0+zaSt+$ zsB|UA+y2xKv0g9l==MPDtJ^pYvoh=J*9T{ejh^KwKs(bPPTf=8g!DX6^B)4Ig_({w zQ|gtJrG_NrdyOxnG7D zV4WhhW!*!~lbqInDs_sO=|;I*ZNw=TN7XNQJ>|5#NOVfm&IGCHr|GAO?zd zVb&i`0pC*5Ox2$d1|#1)VFnN*MwA`zeLZF}vRc?7ml5HxX-4+)LmUaWel7R-gyq>Q zr-%btIWNt0GB&d_ALe+Uz>h6!(^wUww+@v6`A&iccG%`;6a|-OFW>3*eo;nnMRuTO zsVuwKFf!FGI_%M7N5ulsFH=zRh+mfxd_PcgR2nz{I0h%sA($Xt-&3~0{xk+OvXq`a1V(OvUI?qqpck!^NJ zfoxMaONbTtC)}OA@@Cy{dbjrM$1tZbiy6uHw|E;Rf9q#Ek0thD)zX=tMSa)$WtVTW z_7m!x*O*+krw8xOUjA=1mp0Gth|NfsXWNp+u^Ac4!^!7pr1B!1kEO`9h7M|R22`)| zd!o6vt!F3ON=rHCy)Jv@xykj5?9w!4QwxIEWiNkASkkr$Q<>;rP>^sFsLV7Ao9pS( zvq0@?tw>zi=liSK97WIT?Ap5#cXR}%q<4&|ctl(zX`O+%;&g`1o$E}Q22~t@P{kJF zoauN|96TI@hr&IiCM#6&Nfs~(&G^;sMo1QF1-k?$3)^6F+k!NAEh;PtixknpOBT!I z=>Un7@IcM?rLBddS*d4dIO)z5IRC(XwGueRx9yL(r*Cr>`n=B63`MGMICy}GW=iCZk+OQ{ z42TLWq-{jd7g%>U&F)1{e5&WbQE(O~Hk0o4M04ysUSGzj4hH68-f!7?JOkq8y|>5w zK@Z|yF&^x}gKpffZ<*@*A!`bXlhJo_Y1lOzRNY!O4bie!Fzq|81dZZ2nR$i|TKX4;&w* zf+->pv*Zm2_W3k5mY-phoky#jRoTIh0!1Ie#J2}^UtPYwETu(+_i!vCFDW&7Y<+<| zmQG-XHEbaA_`77E<4povsYxddfE>+$n3!s5C$f@kbL{30S#&&%YNjZT14h)|Iuu5}kMXf`c8D$4~WUhH&t%#aVn0F!F zB5VIEPr9TV=Y;OY&6{C5_Tff5`Xb#Q?v%2o#MpaY!`A>E*Vb0n?AliuKxF9a-`9aM zRX*VM!`Py9*%m)eob11^_g3AN3EpyN79MzX?!j2$5%$w8Ihlcb$_eDvxnaGicsLwi zPGKkBE($!u=O&h8$JO@nr+BV(u zcu>YTXQ~%o09oIK&VDQF8;ZTiGdzlwQ(TPMp{y_+nS+ZL{B*`X?klf=N4?#|JN84fL zRe^hk1J%V=XmOB(SlAUSg79v3g)QED5cpf?7j|psuZzt-3{x@th)^#aHAC4RWL|)v zSC%$7d1KK*lm*M_9~i(8iMadE_D_i3ciOXdSLc0j5h~n?{E%ivUtW|Hw_#uLm6$)Z4$-G z;Esx+j{hDM%pNFA-sn3>a!Y$g@k#n-_DFrJwl^3P3sj0k&L~RaWP1H2$tQx4VVdZ%J&~DDyPe>iMkd zs*UYqyOX!sDj{S%-mSuGz3d!2H}0EDw7ydFP3m)^hmoNcQ9fsYk5b_0wERKlCdy}0 zL53k41bC4R#Z+2j_VNr8Sa3}oyer^WPiln4`(L28H2g5>i_N%fBs(IPgysy91rlbD)XoSY%T9&^ zorDOU1<~XY$VpQ~>gX42Sv}bKdqGgMl%o^d!FiPIu4YK)5?q}+GrQ0(XPXmQ>k|q0 z*zhK;cI!o$&V*ku|Me;_;my+95L0GbxpNdYDcA!R6$2>^<@Be-YpIJXH<~M=1dbCG z47Pn6*=Q%~Q=E2KcBcPUu;@MfoeQNNvTrY-xWhe=MD80p@-bQvPY*vwo%IcvqrJ1s|;08csqBN@$-<)+Sf$Ex4_nyfE7ci4bprQH& z-=_)O z$Un+(8PzXYzA~fHS&l@)SN-{v)mKC>g=2xufQ3PJkR~fpIlP|FnPHV7kt#)m|MN9Z z$xO-J-P)h0IEItbr>Ab)D9@ns!Q~q;`Z`EAh#Hz?K11gIud?EcyH#L%qX7K`w zx9!Pma4JQ2wfdTr)t~FDJ?F|vOt1FzZ!XGAX}y47L;>K%*|scnJYkyi{jp`%}w&{YBD-tlrS-J7`C0w;6_2&+{6Y6LxB{| zMp)_p;$G!KWNXQl{z<#iyY;#3DIxT2m91C)Ww4#eCiA-jFTXdr= zkP8LPI*=j|avdSCCf!%f(r`o)JhYI@CU%aqTT@A6b&j}jfF~m+-tVrTk>M2M)q=|< z-;Y#sDr=xZ&C0WuHi&-Fi_sp3v2CU1Swf1)B$W^iup2i0;WyC-TLgt|??eI-qDQh_zBgG82s1@20K?_TW z?wQ_`5S<>{?G+q#L%%+c=-J48dmSn@Wwq{!>t+ld-=iH3}#-DoRo# zt>DzuD2?53?n}&^_=f66jlOy^HOh;QIhi_+>_v?RR_j5ACt^v`d7UI_m@UxKqXpi0 zmXjn#51K0WI_iH|XphiP^Yv0_iZ0nd`8y!3>VuZzB$R(MBe-qEM$%5dPvPx>5}EIP z0&kyVD@~s|;q5%eSJ*z$0Jw=$Q0t#V0C_q7Ih1*vY7a-vv3JoGd6<|@zCg`o5HO%& zA|<1?9rg<>4Fn|YNwXfhB)K|KI(EBQ=d6-zH`Zy}+;A4TO3WAp?70VN)P#|N`!)$4 zPy3M%GYsJ|8a;$)BCT)FDA6rFm;m-i+=176IgHn!`JI?I4rL_z z6%JXGi3l5!L*M(%%_ce9v)?%W0U^_wQB>QLo{ zcK>SkGhE}zN6gz&z!4l8#hRl0NMf8ow%L7aKaX{$0*?YcfxkfC;2=>EMNX#!tOZ!dT0KL;B0>+E9U>c zGhDWLy&?&pT4Xmg%YU#Ws7@(YXE487cr0s8z74BZ+uo zS?31yF;s_gW~no&F7BPka+7yY@SVtovLL*0oELN;Q#0yB zV^cE+KPdm5^AVXwSz*JgIlr6k`0tM)q_l-=Mp7NNoWbwx;XG=9q!=RAyE7y+7xOxn zW|<$&>tdxg3dEQ=Aq<)Th;Z(UI^5A(Zn=WwdcaY2a=d26?@Wm!-t7;M65L-tne85o z$s!=HLG0yu?|0QPtwezhV^%+>fAw2l89>X2$Nc?l>32Pie51o1&F_jBvGD6U!R~4r zs1ccrP*0iX%IUg4lNpgC_X6*X5VCL!h>ZlMzM$fRlJF=CEdIGJuuMQ6sw#k5jHoNw zP1DMS@b5s?pF?1EQWVld1j5;u6@hrybjl?oqAk7Gqk zP#7O52=t=7_X3GuA&zlr|VZ zi(TxQAya_50qj~!ngq!|_x@*f+vqOE9Cqoxa2p9q%&>v7&+}DP`dEYimGn!iD+dh; z)QU8*xHMjPK+}cHQD&un(P5G0i5?1Wi;gI9xZ0MD(zO|b*nowuB`uRL329B+D6fHE54n&>&B4I0Tky|UH)0fD zOJd`)cr1-+TyxsrXg7z1QqN-Jb1O6C z&<4n;u4bOD-PJgnL@j9{*~F4JxC=)+v$uuied89;3H_FV4Ad+pYw)#- zEcB$)B##sj8#0SGR06b=)&q`ygA*b1?z5dO$d;TVBu`+Sobgu{*!>_tWJ*z}p`+Cm zhiKi0Xlzwg97evdw7TL?gQ5epm0~?*gXB)#woxAF81FMA%5ICv${HV9qs+Gj9FLJΝ_+=Ck=M|CrcrofIfy9Q^?gv3VNz%Ta_ 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%0DS$*ow6i8yvtd5r8 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%0AIqdKK;gj?a&nl97Y;1MVLs0$U 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%0D0=>1LTAY#!orqTnIzu*0WB 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%0D?J>_hbAm^Y|QR6RW3} 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

    peB{6^%t39`Q`heQ|>mUBt)8A{^_U`)2x7xpP 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 literal 0 HcmV?d00001 diff --git a/compiler/win_flex_bison/win_flex.exe b/compiler/win_flex_bison/win_flex.exe new file mode 100644 index 0000000000000000000000000000000000000000..cff271ed2496df38373175447bab6308c5ed06d7 GIT binary patch literal 571392 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¬^w`TjSHW1 zsbzN!b+paswaAF4q*cL%?uX_IQDNju5$FPh{vElOlLE$LY9mWV$Q_(=9{ zPwde6+8vnD#_k-Ug#7Ey5o(wxp_cs9@+)>|YR2XWeG+~aO&5L&_-1pauZM3#a0xdOpGP}sXKuL)A5VB=(z^< z3p>Hs=fr?h&&8rcOvDsq7l!WWDXM3o+eH9;SC#<<0JcOflaYgM!b8Li0@g-`*Q+&J zf%3$&(d^7cO#V&&*sk%htv`+(JAHXx%N_0+(V-gzOd_jzOUuk@7vT4L@;6sSY90Q( zRE0sn(yT;aBo2lgiA=_tArbQns%X*vTJ?;!)&vNy1K&-kRkv;@{bG$>bf20e<+-DZ zm8yLumN~6b7MbE)Bz~@1f&rqoKD-y2o9o-u+*@d4iJVFySlk=Cgsg>363kw{hB!}N z)5u!omD(h`Rmry@CnLnXj0vfOV;xRc3o`xy)cimwQ7s;a;dxt3C^)T7k2X(mae+ zkI4hn*#h9$j!AM2roU|pWGmivr8P9}w_dRNq{*^j8lDP5oZ;z{AqkE3LAdXHSxY>1 zbV2_!JkYN$e1mR*SKV{~WZ^YYFHTce%tw>Md}I`G^`3zcJ~XYu6<$gS_Fovt;Rp3& zE06jLWVDBka$l0OzaE$|(stAixo1?1qxP08e6sPsvfI-GuzSPID! z(eJ|#X*51$XgK#dt-^trXMwAh$}{w9fsW9xQ?8NP==tQ8MT`g`c3j`nhCN zeR|uwuz>-Rub#M!z4N`i{!YFYRENa@UtM@I+3muP!ojNnJP} z9n%ZByi?PLhz?IrmQGuzV^(C!rweYq27*mFC z`2`)mc*i`|;afo7{!m|?C!&n#dD55@xzXRzn8#NiW5nID{8St0cz}M#0A0&h`11zK zT~|Zk`A8`*`|Qmu;cn3BOFpOkyb+aZWRpMqkjZ?%P9j8BZY1An{u+~}<0tjUYPMh{ zD8-|_f|Zc?Pq7nc``h9)T=riC(4PK60gTjB%`l5wT(8liGSL|&xqLSQxEc8 zufBPT@S+&>HKWNLuHisTbIIQtbqA&I<1%-2frFm+fFF6($lH#}XJUOL^?l3_8&W+e zq}p#<{~rcUe|#I}(#SsldeIXdhn=fom5t>MnmLTGf9>-IH&dJLimc~9dns>-ww_{*o?3CVf8qwfK~B!C|+?;y>T5t*y=PVjt{dz zIR7v^vJ>jrg{)RJ`bH%QpfV!d3j>GL8`=j@a+5K%B)7VYGo-4J^@mw~&tT)z+}~#{ zKCH(xl~;1prjEE%v=z@%3aS6bGs`HL_@DP$i9#AD|MDbUb zolHWBrV#yknF!%bL`xh*x$3Pih3L&ry^#{DR3x~pbr<(hZpeGNbl9%`a@ppL&+HW9lEa z;sL*Z`&_x}XM9|&D|Z?@@fa+&Nh}sejoyIiB=_3jIM}4^k#Z*tvy7O0DbF=}u8L)Hp*gd2qgs=SfK`uaBScyk~_4^A79hr%5;Vrr4pe zn4sOF!;G)zay$Rs*Jc4?h#f(d$!TJ&IpB(n#snK*e7rq-=J^rt%p$HZpr+ZRByMBK z4(}c!Gl7{(>U~@ZZxeKellR&i10`;}vhm=d0k><{)O9Vpbv@Gk=%e zWxd-mHm2o~4{ezk6(72E9j#MYre7;_X1DMsV^o<7>ScRX8u@8k9{0- z#c;A)Ln#=aeLTLrP#s!VooJbEbjvj1MJ_1rc%-a6IVR#Z9BO_Tl~Z|?#hRdp@? z&txXa00U=`fI$(WL`8!d2`XVg10e|y1BsCYswDQRX)antGDEQP2o8}ax{k6T- zR%&l+-}a%!M=>EZ36Da+R#9lh*4h(?YIs}{Br?D6+WX8TL2U2+{Xd_7J~?O3*=Il2 zUVH7e*WP=rwaYW3ss6VEE~!+p$G?B=Xw&`m`f1k$Q|ebc9l_Mu;W7UGYoerho4DXa zSR3&I%gq^If2lFXL9y*k>C?wHE}KYk!OZ%#6KVOTCC=$fopzW{&oJam@DDltKCpt* z$vn3*BX9u#j6@5A^Ket8r8$a1z`;lKL7|5fQ15RIB!yE#9dY+0^|v5!tROb}En=*G zFOT?5#0YT6jBC_PJCLkM%hfLJi?`WjrE=Rej&H`B&vSsHl)O+Ziro9Ga2C#KMR*Li>G^)SS7c7A}pMlFq-!d5Aqk9 zwa-2dD3($caSsKdTSXZ}ujR$TR2?(=6+vm4^r8{7!XxTAGBO`yH0Dv_B5jV$*Tr65 z7m?66&)OGpkCbLANGDdZS==4QXNXi#^e0mhJ#dETv==dO-RlU<7ge1(O?~FDQYiJB z;JDb7np<^+Zr^TKX#LHqLecTYHqMcpQnN;XpBn#OrM|QG60dN7d+f8T2?T5_52!5r z;YPy@`jNlbvvw5ABBr~M8i@u(N>?V~3c3lg96sSB!9b zZDq$+So(to>Do9*OEpLdES=QfN5sG9s_$vB6a`Hc%vn^7YUYlXP_83%9Da-xn9tV?RDYBlqNjg;Vd-bQM8yg>yo_E@BY+NZ1(>M?Gn{*oL z!c$Ij&Q4CX#b0R(eQVmVU@_;J1!tRUGlZ7MgW?KsoV`)e@v>$c$Bi>Ij*I)Y z3Kp@!d|8OKs&bn14x>OJ64q&s3*~Wiq#Qw?*5slq`=mdr?wqgmi%-(+!^L)I{t$we z@6w;qw~+3`FTJ=L8uUoVKb-?oN%4g|FG@ zc-TLP;5IsEN`BXO39-riCS7K| zF7xeecA3eaQ6|0WoD%6z!7?+2c3nG6c+>r6||NZIbuaeHa>(xH+ zb4a|1tDe0yuH&1v`y4KF6fVO#^hJuxY+*HF0GAO$r=E_j72GtLLzvTzhF5uKxR~BF zs&Vne;AD>X9upHfiYKUK6j6H|Ifrc z5O@7=ZOr~SS698D@1;S+Jq;aBl^3S@iR@?`lk*W^PZSt0tSa$&P(f)L#}~#6nym|> z_vn7FYk<(>FgDiWHX8G0a-|MxoYh~|dV1)nPpd?hWtur=K4MdEc=1VQ=KkZxmqjbF z!ry6pxq%1s&*rYIj;yyCSN(6Tn}I}hz07z{N75d1wMM2shWu_0jojuoQz9J5FuO0j zuurUQk%zja$KfPA*q3#ToTF134z0UN)`!kSrhYZz-eCG7Y;=u~WOMt%<#w`o8ds|r z3m-SWQY-S%GH;bR%xuZZ&vfQzRE8I14m9vFDw^AqMGls~_GFQc;RHO1Fs+|NG8X<~ zj7%0Onx8&?IC(tT`-{13aSZxX2Y=Tb2G`p25tG*3C2Ho>b#xj_!Lt5~Gfvq!XVG`G zx!3slKILg)1Y`#zl?7$QAU4!bnfr{N??vJ7h?RE}8x`z%c!A;^6&7n3LorUQ0u!ue zp2W9;BQVPPwR$!weOR_4tk$jFz*J)OU8i5;Km!l^%b2X2+na{6s?RFSnEKO~2ZQv5 z+TeptbH&R?5ew!Yl;s=ap#e!jW&U(#*Y?fi5=M6REZEp@>&UK?yZ60HL1tT>0 zx3)jaI$n+yX%0>gO&by%CGCSk_AtvNq@9|9?+)}IY=mplnDMAM#j?zoRAZD_FW$h( zvEo?)P)e-3vB4bJK4_#fh7>Rz^oBk^>1=owp3u@u!?Q9hYziewB6oYg-}jPbh&WdE ziiZeB!9ftx&@6fkMnOj;KUPtCs&Eo=8mD%Q3y)ysX;r2=c{7?UKW@A|taCG-rNl;e z08=DC)zuzZ5bN1Lu?1O4#Jdz%dpMONO%!WrFLJ9|R!=(3+T{RPqz>TERs_O)u~0OT zuZ5)DxzlPV3k+h3x-g?egRozw2FWpg+@Xbdk!wXpJ|Iix(Gf5s7?p``CPz!SRWa66 zAXxIpf1c?7OZ6aNHt)00YOi#=b}@@9=5&hm7RwcCzK8WXR}1d-{4F>WF!DPXlRBVH zk_xlfUzdr%S2sZcwQ$_0A!5HLff2|AIS3rAbBC+k;DN(M3)5q(Jdq{%Lvy_|k)6BN zRjO&oFDaNKtZZR=gi}FV1dD7c2Pa?)#_6Z3yuyszKHUffeXy}gPpEp*C!z^yGho4I z(=u<;)Pws&Cj_4=}n&LyN!)c&`8tw85C#T>-h_gzyL1vk@P&0*6ywZmN7cLz!LCI-xu&G z7`o}sgGffT=Uqx8#KT-{k++m~GoARwN3~%|tkdv$jFH6$6UU}n>ey7yL+vYx;O8My zaL_(F^)4ahH2Nk>qj(ny_M%7hoyqj~V$ZOHv|cGX;dygoo#obL-)G}_Kzft@lBbeq z(2-jtOBHlatP^1ZcuopD&-}l@BgSw+U}-9Hmvd5y^|>V?V$v%fo~&HzUtul2Uie5- zV4Sspr}CP6@ z|Bu=6@^|wzp!{09{Jm2Cshs9vCvuZ_Fm4);eFcJ|afOS6-r>yzvh$idV*^JKZ}+Q6 zwGTw!_m7t7!7E__AMEOrYYJ}c3p!}W)D_Xd?~5xR@0Y2Qv06nW%v z-tDpdrcr9$`#sq@sp2j(+csN4!Kw#&iiHm3KgNrNZj_Y1$%>d+iSHH`AcmRqJY+Pi z0xyB)tjT5M&wj%===Bl;%glLR`HBq@2Uy9WM1+b;TCJPiRJ?BQT6Zfh26@(Wp;_MrJgM&IOYy#}@hEPwwCz zTw>0YH0BNRw%i?Y2SqMn{k+fGhW!C0GU}ZQ`mBtrgy}zgkyY2j0`4dlq|V^4z=+J_ zFebHVbezF1e2HZCtmLH%(V4d#NpkhJv&do>ou^u1xzCzG2~C(wcgw0|O~%N4Ha~sb z>YIujT7#x>p*uEOUS%U+j`&TsdQOQA=%?bt&H7`eshGbfW({ljn0k1v&SIoBX8i}5 z13l4Vytq>YqubQyGAl&oB>(2XBrE$`w#H5(�d9mO_G;^M9GQ(3@Z>npu`v>#&m` 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 z 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 i@JUPx|DH}Re>0;