From b06947a5a0f16aaf8ffc7bac046b29fe8617c859 Mon Sep 17 00:00:00 2001 From: _xeroxz Date: Tue, 18 May 2021 21:38:47 -0700 Subject: [PATCH] added source code, gitignore, gitmodules, etc --- .gitignore | 388 ++ .gitmodules | 3 + dependencies/vmprofiler | 1 + src/cli-parser.hpp | 580 +++ src/compiler.cpp | 144 + src/compiler.h | 49 + .../Bison/win_bison_custom_build.props | 23 + .../Bison/win_bison_custom_build.targets | 101 + .../Bison/win_bison_custom_build.xml | 281 ++ .../Flex/win_flex_custom_build.props | 23 + .../Flex/win_flex_custom_build.targets | 94 + .../Flex/win_flex_custom_build.xml | 243 ++ src/custom_build_rules/how_to_use.txt | 1 + .../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 ++ src/data/Makefile.am | 30 + src/data/Makefile.in | 1639 ++++++++ src/data/README | 70 + src/data/bison.m4 | 610 +++ src/data/c++-skel.m4 | 26 + src/data/c++.m4 | 205 + src/data/c-like.m4 | 44 + src/data/c-skel.m4 | 26 + src/data/c.m4 | 722 ++++ src/data/glr.c | 2589 +++++++++++++ src/data/glr.cc | 346 ++ src/data/java-skel.m4 | 26 + src/data/java.m4 | 304 ++ src/data/lalr1.cc | 1143 ++++++ src/data/lalr1.java | 927 +++++ src/data/location.cc | 299 ++ src/data/m4sugar/foreach.m4 | 362 ++ src/data/m4sugar/m4sugar.m4 | 3301 +++++++++++++++++ src/data/stack.hh | 121 + src/data/xslt/bison.xsl | 105 + src/data/xslt/xml2dot.xsl | 397 ++ src/data/xslt/xml2text.xsl | 569 +++ src/data/xslt/xml2xhtml.xsl | 745 ++++ src/data/yacc.c | 2065 +++++++++++ src/icon.ico | Bin 0 -> 4022 bytes src/icon.rc | 3 + src/lexer.flex.cpp | 1756 +++++++++ src/lexer.l | 11 + src/main.cpp | 223 ++ src/parser.cpp | 31 + src/parser.h | 29 + src/parser.tab.cpp | 1587 ++++++++ src/parser.tab.h | 89 + src/parser.y | 25 + src/vmasm.hpp | 22 + src/vmassembler.vcxproj | 105 + src/vmassembler.vcxproj.filters | 92 + src/win_bison.exe | Bin 0 -> 561152 bytes src/win_flex.exe | Bin 0 -> 564736 bytes vmassembler.sln | 22 + 62 files changed, 24094 insertions(+) create mode 100644 .gitignore create mode 100644 .gitmodules create mode 160000 dependencies/vmprofiler create mode 100644 src/cli-parser.hpp create mode 100644 src/compiler.cpp create mode 100644 src/compiler.h create mode 100644 src/custom_build_rules/Bison/win_bison_custom_build.props create mode 100644 src/custom_build_rules/Bison/win_bison_custom_build.targets create mode 100644 src/custom_build_rules/Bison/win_bison_custom_build.xml create mode 100644 src/custom_build_rules/Flex/win_flex_custom_build.props create mode 100644 src/custom_build_rules/Flex/win_flex_custom_build.targets create mode 100644 src/custom_build_rules/Flex/win_flex_custom_build.xml create mode 100644 src/custom_build_rules/how_to_use.txt create mode 100644 src/custom_build_rules/win_bison_only/win_bison_custom_build.props create mode 100644 src/custom_build_rules/win_bison_only/win_bison_custom_build.targets create mode 100644 src/custom_build_rules/win_bison_only/win_bison_custom_build.xml create mode 100644 src/custom_build_rules/win_flex_bison_custom_build.props create mode 100644 src/custom_build_rules/win_flex_bison_custom_build.targets create mode 100644 src/custom_build_rules/win_flex_bison_custom_build.xml create mode 100644 src/custom_build_rules/win_flex_only/win_flex_custom_build.props create mode 100644 src/custom_build_rules/win_flex_only/win_flex_custom_build.targets create mode 100644 src/custom_build_rules/win_flex_only/win_flex_custom_build.xml create mode 100644 src/data/Makefile.am create mode 100644 src/data/Makefile.in create mode 100644 src/data/README create mode 100644 src/data/bison.m4 create mode 100644 src/data/c++-skel.m4 create mode 100644 src/data/c++.m4 create mode 100644 src/data/c-like.m4 create mode 100644 src/data/c-skel.m4 create mode 100644 src/data/c.m4 create mode 100644 src/data/glr.c create mode 100644 src/data/glr.cc create mode 100644 src/data/java-skel.m4 create mode 100644 src/data/java.m4 create mode 100644 src/data/lalr1.cc create mode 100644 src/data/lalr1.java create mode 100644 src/data/location.cc create mode 100644 src/data/m4sugar/foreach.m4 create mode 100644 src/data/m4sugar/m4sugar.m4 create mode 100644 src/data/stack.hh create mode 100644 src/data/xslt/bison.xsl create mode 100644 src/data/xslt/xml2dot.xsl create mode 100644 src/data/xslt/xml2text.xsl create mode 100644 src/data/xslt/xml2xhtml.xsl create mode 100644 src/data/yacc.c create mode 100644 src/icon.ico create mode 100644 src/icon.rc create mode 100644 src/lexer.flex.cpp create mode 100644 src/lexer.l create mode 100644 src/main.cpp create mode 100644 src/parser.cpp create mode 100644 src/parser.h create mode 100644 src/parser.tab.cpp create mode 100644 src/parser.tab.h create mode 100644 src/parser.y create mode 100644 src/vmasm.hpp create mode 100644 src/vmassembler.vcxproj create mode 100644 src/vmassembler.vcxproj.filters create mode 100644 src/win_bison.exe create mode 100644 src/win_flex.exe create mode 100644 vmassembler.sln diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..72de34f --- /dev/null +++ b/.gitignore @@ -0,0 +1,388 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Ww][Ii][Nn]32/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ +[Ll]ogs/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET Core +project.lock.json +project.fragment.lock.json +artifacts/ + +# ASP.NET Scaffolding +ScaffoldingReadMe.txt + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.tlog +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Coverlet is a free, cross platform Code Coverage Tool +coverage*.json +coverage*.xml +coverage*.info + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Nuget personal access tokens and Credentials +nuget.config + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ + +# Fody - auto-generated XML schema +FodyWeavers.xsd + +# VS Code files for those working on multiple tools +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +*.code-workspace + +# Local History for Visual Studio Code +.history/ + +# Windows Installer files from build outputs +*.cab +*.msi +*.msix +*.msm +*.msp + +# JetBrains Rider +.idea/ +*.sln.iml \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..013d5e9 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "dependencies/vmprofiler"] + path = dependencies/vmprofiler + url = https://githacks.org/vmp2/vmprofiler.git diff --git a/dependencies/vmprofiler b/dependencies/vmprofiler new file mode 160000 index 0000000..a05293a --- /dev/null +++ b/dependencies/vmprofiler @@ -0,0 +1 @@ +Subproject commit a05293ab21c93c024792a8064a8344241b947f81 diff --git a/src/cli-parser.hpp b/src/cli-parser.hpp new file mode 100644 index 0000000..0b404ee --- /dev/null +++ b/src/cli-parser.hpp @@ -0,0 +1,580 @@ +/** + * License: Apache 2.0 with LLVM Exception or GPL v3 + * + * Author: Jesse Laning + */ + +#ifndef ARGPARSE_H +#define ARGPARSE_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace argparse { + namespace detail { + static inline bool _not_space(int ch) { return !std::isspace(ch); } + static inline void _ltrim(std::string& s, bool (*f)(int) = _not_space) { + s.erase(s.begin(), std::find_if(s.begin(), s.end(), f)); + } + static inline void _rtrim(std::string& s, bool (*f)(int) = _not_space) { + s.erase(std::find_if(s.rbegin(), s.rend(), f).base(), s.end()); + } + static inline void _trim(std::string& s, bool (*f)(int) = _not_space) { + _ltrim(s, f); + _rtrim(s, f); + } + static inline std::string _ltrim_copy(std::string s, + bool (*f)(int) = _not_space) { + _ltrim(s, f); + return s; + } + static inline std::string _rtrim_copy(std::string s, + bool (*f)(int) = _not_space) { + _rtrim(s, f); + return s; + } + static inline std::string _trim_copy(std::string s, + bool (*f)(int) = _not_space) { + _trim(s, f); + return s; + } + template + static inline std::string _join(InputIt begin, InputIt end, + const std::string& separator = " ") { + std::ostringstream ss; + if (begin != end) { + ss << *begin++; + } + while (begin != end) { + ss << separator; + ss << *begin++; + } + return ss.str(); + } + static inline bool _is_number(const std::string& arg) { + std::istringstream iss(arg); + float f; + iss >> std::noskipws >> f; + return iss.eof() && !iss.fail(); + } + + static inline int _find_equal(const std::string& s) { + for (size_t i = 0; i < s.length(); ++i) { + // if find graph symbol before equal, end search + // i.e. don't accept --asd)f=0 arguments + // but allow --asd_f and --asd-f arguments + if (std::ispunct(static_cast(s[i]))) { + if (s[i] == '=') { + return static_cast(i); + } + else if (s[i] == '_' || s[i] == '-') { + continue; + } + return -1; + } + } + return -1; + } + + static inline size_t _find_name_end(const std::string& s) { + size_t i; + for (i = 0; i < s.length(); ++i) { + if (std::ispunct(static_cast(s[i]))) { + break; + } + } + return i; + } + + namespace is_vector_impl { + template + struct is_vector : std::false_type {}; + template + struct is_vector> : std::true_type {}; + } // namespace is_vector_impl + + // type trait to utilize the implementation type traits as well as decay the + // type + template + struct is_vector { + static constexpr bool const value = + is_vector_impl::is_vector::type>::value; + }; + } // namespace detail + + class argument_parser_t { + private: + public: + class Argument; + + class Result { + public: + Result() {} + Result(std::string err) noexcept : _error(true), _what(err) {} + + operator bool() const { return _error; } + + friend std::ostream& operator<<(std::ostream& os, const Result& dt); + + const std::string& what() const { return _what; } + + private: + bool _error{ false }; + std::string _what{}; + }; + + class Argument { + public: + enum Position : int { LAST = -1, DONT_CARE = -2 }; + enum Count : int { ANY = -1 }; + + Argument& name(const std::string& name) { + _names.push_back(name); + return *this; + } + + Argument& names(std::vector names) { + _names.insert(_names.end(), names.begin(), names.end()); + return *this; + } + + Argument& description(const std::string& description) { + _desc = description; + return *this; + } + + Argument& required(bool req) { + _required = req; + return *this; + } + + Argument& position(int position) { + if (position != Position::LAST) { + // position + 1 because technically argument zero is the name of the + // executable + _position = position + 1; + } + else { + _position = position; + } + return *this; + } + + Argument& count(int count) { + _count = count; + return *this; + } + + bool found() const { return _found; } + + template + typename std::enable_if::value, T>::type get() { + T t = T(); + typename T::value_type vt; + for (auto& s : _values) { + std::istringstream in(s); + in >> vt; + t.push_back(vt); + } + return t; + } + + template + typename std::enable_if::value, T>::type get() { + std::istringstream in(get()); + T t = T(); + in >> t >> std::ws; + return t; + } + + private: + Argument(const std::string& name, const std::string& desc, + bool required = false) + : _desc(desc), _required(required) { + _names.push_back(name); + } + + Argument() {} + + friend class argument_parser_t; + int _position{ Position::DONT_CARE }; + int _count{ Count::ANY }; + std::vector _names{}; + std::string _desc{}; + bool _found{ false }; + bool _required{ false }; + int _index{ -1 }; + + std::vector _values{}; + }; + + argument_parser_t(std::string bin, std::string desc) + : _bin(bin), _desc(desc) {} + + Argument& add_argument() { + _arguments.push_back({}); + _arguments.back()._index = static_cast(_arguments.size()) - 1; + return _arguments.back(); + } + + Argument& add_argument(const std::string& name, const std::string& long_name, + const std::string& desc, const bool required = false) { + _arguments.push_back(Argument(name, desc, required)); + _arguments.back()._names.push_back(long_name); + _arguments.back()._index = static_cast(_arguments.size()) - 1; + return _arguments.back(); + } + + Argument& add_argument(const std::string& name, const std::string& desc, + const bool required = false) { + _arguments.push_back(Argument(name, desc, required)); + _arguments.back()._index = static_cast(_arguments.size()) - 1; + return _arguments.back(); + } + + void print_help(size_t count = 0, size_t page = 0) { + if (page * count > _arguments.size()) { + return; + } + if (page == 0) { + std::cout << "Usage: " << _bin; + if (_positional_arguments.empty()) { + std::cout << " [options...]" << std::endl; + } + else { + int current = 1; + for (auto& v : _positional_arguments) { + if (v.first != Argument::Position::LAST) { + for (; current < v.first; current++) { + std::cout << " [" << current << "]"; + } + std::cout + << " [" + << detail::_ltrim_copy( + _arguments[static_cast(v.second)]._names[0], + [](int c) -> bool { return c != static_cast('-'); }) + << "]"; + } + } + auto it = _positional_arguments.find(Argument::Position::LAST); + if (it == _positional_arguments.end()) { + std::cout << " [options...]"; + } + else { + std::cout + << " [options...] [" + << detail::_ltrim_copy( + _arguments[static_cast(it->second)]._names[0], + [](int c) -> bool { return c != static_cast('-'); }) + << "]"; + } + std::cout << std::endl; + } + std::cout << "Options:" << std::endl; + } + if (count == 0) { + page = 0; + count = _arguments.size(); + } + for (size_t i = page * count; + i < std::min(page * count + count, _arguments.size()); i++) { + Argument& a = _arguments[i]; + std::string name = a._names[0]; + for (size_t n = 1; n < a._names.size(); ++n) { + name.append(", " + a._names[n]); + } + std::cout << " " << std::setw(23) << std::left << name << std::setw(23) + << a._desc; + if (a._required) { + std::cout << " (Required)"; + } + std::cout << std::endl; + } + } + + Result parse(int argc, const char* argv[]) { + Result err; + if (argc > 1) { + // build name map + for (auto& a : _arguments) { + for (auto& n : a._names) { + std::string name = detail::_ltrim_copy( + n, [](int c) -> bool { return c != static_cast('-'); }); + if (_name_map.find(name) != _name_map.end()) { + return Result("Duplicate of argument name: " + n); + } + _name_map[name] = a._index; + } + if (a._position >= 0 || a._position == Argument::Position::LAST) { + _positional_arguments[a._position] = a._index; + } + } + if (err) { + return err; + } + + // parse + std::string current_arg; + size_t arg_len; + for (int argv_index = 1; argv_index < argc; ++argv_index) { + current_arg = std::string(argv[argv_index]); + arg_len = current_arg.length(); + if (arg_len == 0) { + continue; + } + if (_help_enabled && (current_arg == "-h" || current_arg == "--help")) { + _arguments[static_cast(_name_map["help"])]._found = true; + } + else if (argv_index == argc - 1 && + _positional_arguments.find(Argument::Position::LAST) != + _positional_arguments.end()) { + err = _end_argument(); + Result b = err; + err = _add_value(current_arg, Argument::Position::LAST); + if (b) { + return b; + } + if (err) { + return err; + } + } + else if (arg_len >= 2 && + !detail::_is_number(current_arg)) { // ignores the case if + // the arg is just a - + // look for -a (short) or --arg (long) args + if (current_arg[0] == '-') { + err = _end_argument(); + if (err) { + return err; + } + // look for --arg (long) args + if (current_arg[1] == '-') { + err = _begin_argument(current_arg.substr(2), true, argv_index); + if (err) { + return err; + } + } + else { // short args + err = _begin_argument(current_arg.substr(1), false, argv_index); + if (err) { + return err; + } + } + } + else { // argument value + err = _add_value(current_arg, argv_index); + if (err) { + return err; + } + } + } + else { // argument value + err = _add_value(current_arg, argv_index); + if (err) { + return err; + } + } + } + } + if (_help_enabled && exists("help")) { + return Result(); + } + err = _end_argument(); + if (err) { + return err; + } + for (auto& p : _positional_arguments) { + Argument& a = _arguments[static_cast(p.second)]; + if (a._values.size() > 0 && a._values[0][0] == '-') { + std::string name = detail::_ltrim_copy(a._values[0], [](int c) -> bool { + return c != static_cast('-'); + }); + if (_name_map.find(name) != _name_map.end()) { + if (a._position == Argument::Position::LAST) { + return Result( + "Poisitional argument expected at the end, but argument " + + a._values[0] + " found instead"); + } + else { + return Result("Poisitional argument expected in position " + + std::to_string(a._position) + ", but argument " + + a._values[0] + " found instead"); + } + } + } + } + for (auto& a : _arguments) { + if (a._required && !a._found) { + return Result("Required argument not found: " + a._names[0]); + } + if (a._position >= 0 && argc >= a._position && !a._found) { + return Result("Argument " + a._names[0] + " expected in position " + + std::to_string(a._position)); + } + } + return Result(); + } + + void enable_help() { + add_argument("-h", "--help", "Shows this page", false); + _help_enabled = true; + } + + bool exists(const std::string& name) const { + std::string n = detail::_ltrim_copy( + name, [](int c) -> bool { return c != static_cast('-'); }); + auto it = _name_map.find(n); + if (it != _name_map.end()) { + return _arguments[static_cast(it->second)]._found; + } + return false; + } + + template + T get(const std::string& name) { + auto t = _name_map.find(name); + if (t != _name_map.end()) { + return _arguments[static_cast(t->second)].get(); + } + return T(); + } + + private: + Result _begin_argument(const std::string& arg, bool longarg, int position) { + auto it = _positional_arguments.find(position); + if (it != _positional_arguments.end()) { + Result err = _end_argument(); + Argument& a = _arguments[static_cast(it->second)]; + a._values.push_back((longarg ? "--" : "-") + arg); + a._found = true; + return err; + } + if (_current != -1) { + return Result("Current argument left open"); + } + size_t name_end = detail::_find_name_end(arg); + std::string arg_name = arg.substr(0, name_end); + if (longarg) { + int equal_pos = detail::_find_equal(arg); + auto nmf = _name_map.find(arg_name); + if (nmf == _name_map.end()) { + return Result("Unrecognized command line option '" + arg_name + "'"); + } + _current = nmf->second; + _arguments[static_cast(nmf->second)]._found = true; + if (equal_pos == 0 || + (equal_pos < 0 && + arg_name.length() < arg.length())) { // malformed argument + return Result("Malformed argument: " + arg); + } + else if (equal_pos > 0) { + std::string arg_value = arg.substr(name_end + 1); + _add_value(arg_value, position); + } + } + else { + Result r; + if (arg_name.length() == 1) { + return _begin_argument(arg, true, position); + } + else { + for (char& c : arg_name) { + r = _begin_argument(std::string(1, c), true, position); + if (r) { + return r; + } + r = _end_argument(); + if (r) { + return r; + } + } + } + } + return Result(); + } + + Result _add_value(const std::string& value, int location) { + if (_current >= 0) { + Result err; + Argument& a = _arguments[static_cast(_current)]; + if (a._count >= 0 && static_cast(a._values.size()) >= a._count) { + err = _end_argument(); + if (err) { + return err; + } + goto unnamed; + } + a._values.push_back(value); + if (a._count >= 0 && static_cast(a._values.size()) >= a._count) { + err = _end_argument(); + if (err) { + return err; + } + } + return Result(); + } + else { + unnamed: + auto it = _positional_arguments.find(location); + if (it != _positional_arguments.end()) { + Argument& a = _arguments[static_cast(it->second)]; + a._values.push_back(value); + a._found = true; + } + // TODO + return Result(); + } + } + + Result _end_argument() { + if (_current >= 0) { + Argument& a = _arguments[static_cast(_current)]; + _current = -1; + if (static_cast(a._values.size()) < a._count) { + return Result("Too few arguments given for " + a._names[0]); + } + if (a._count >= 0) { + if (static_cast(a._values.size()) > a._count) { + return Result("Too many arguments given for " + a._names[0]); + } + } + } + return Result(); + } + + bool _help_enabled{ false }; + int _current{ -1 }; + std::string _bin{}; + std::string _desc{}; + std::vector _arguments{}; + std::map _positional_arguments{}; + std::map _name_map{}; + }; + + std::ostream& operator<<(std::ostream& os, const argument_parser_t::Result& r) { + os << r.what(); + return os; + } + template <> + inline std::string argument_parser_t::Argument::get() { + return detail::_join(_values.begin(), _values.end()); + } + template <> + inline std::vector + argument_parser_t::Argument::get>() { + return _values; + } + +} // namespace argparse +#endif \ No newline at end of file diff --git a/src/compiler.cpp b/src/compiler.cpp new file mode 100644 index 0000000..948708d --- /dev/null +++ b/src/compiler.cpp @@ -0,0 +1,144 @@ +#include "compiler.h" + +namespace vm +{ + compiler_t::compiler_t( + base_data_t base_data, + vmp2::exec_type_t exec_type, + std::vector* vm_handlers, + zydis_routine_t* calc_jmp + ) + : module_base(base_data.module_base), + image_base(base_data.image_base), + exec_type(exec_type), + vm_handlers(vm_handlers), + calc_jmp(calc_jmp) + { + if (!parse_t::get_instance()->for_each( + [&](_vinstr_meta* vinstr) -> bool + { + std::printf("> vinstr name = %s, has imm = %d, imm = 0x%p\n", + vinstr->name.c_str(), vinstr->has_imm, vinstr->imm); + + for (auto& vm_handler : *vm_handlers) + if (vm_handler.profile && vm_handler.profile->name == vinstr->name) + return true; + + std::printf("> this vm protected file does not have the vm handler for: %s...\n", + vinstr->name.c_str()); + + return false; + } + )) + { + std::printf("[!] binary does not have the required vm handlers...\n"); + exit(-1); + } + + if(!vm::handler::get_operand_transforms(*calc_jmp, calc_jmp_transforms)) + { + std::printf("[!] failed to extract calc_jmp transformations...\n"); + exit(-1); + } + } + + std::pair*> compiler_t::encode() + { + parse_t::get_instance()->for_each( + [&](_vinstr_meta* vinstr) -> bool + { + for (auto itr = vm_handlers->begin(); itr != vm_handlers->end(); ++itr) + { + if (itr->profile && itr->profile->name == vinstr->name) + { + vinstrs.push_back({ (std::uint8_t)(itr - vm_handlers->begin()), + vinstr->imm, itr->profile->imm_size }); + break; + } + } + return true; + } + ); + + return { true, &vinstrs }; + } + + std::pair*> compiler_t::encrypt() + { + const auto end_of_module = + NT_HEADER(module_base)->OptionalHeader.SizeOfImage + image_base; + + // + // init decryption key... + // + + // decryption key starts off as the image + // base address of the virtual instructions... + std::uintptr_t decrypt_key = end_of_module, start_addr; + if (exec_type == vmp2::exec_type_t::backward) + { + std::for_each(vinstrs.begin(), vinstrs.end(), + [&](const vinstr_data& vinstr) + { + (++decrypt_key) += + vinstr.imm_size ? vinstr.imm_size / 8 : 0; + } + ); + } + start_addr = decrypt_key; + + // + // invert the encoded virtual instructions operands if vip advances backward... + // + + if (exec_type == vmp2::exec_type_t::backward) + std::reverse(vinstrs.begin(), vinstrs.end()); + + // + // loop over the instructions and encrypt them... + // + + for (auto& vinstr : vinstrs) + { + std::printf("> decrypt key = 0x%p\n", decrypt_key); + + auto vm_handler_idx = vinstr.vm_handler; + std::tie(vinstr.vm_handler, decrypt_key) = + vm::encrypt_operand(calc_jmp_transforms, + vinstr.vm_handler, decrypt_key); + + if (!vinstr.imm_size) + { + result_buffer.push_back(vinstr.vm_handler); + continue; + } + + auto transforms = vm_handlers->at(vm_handler_idx).transforms; + std::tie(vinstr.operand, decrypt_key) = + vm::encrypt_operand(transforms, vinstr.operand, decrypt_key); + + // + // operands must be backwards if VIP advances backward... + // + + if (exec_type == vmp2::exec_type_t::backward) + { + for (auto idx = 0u; idx < vinstr.imm_size / 8; ++idx) + result_buffer.push_back( + reinterpret_cast(&vinstr.operand)[idx]); + + result_buffer.push_back(vinstr.vm_handler); + } + else + { + result_buffer.push_back(vinstr.vm_handler); + + for (auto idx = 0u; idx < vinstr.imm_size / 8; ++idx) + result_buffer.push_back( + reinterpret_cast(&vinstr.operand)[idx]); + } + } + + return { start_addr, &result_buffer }; + } +} \ No newline at end of file diff --git a/src/compiler.h b/src/compiler.h new file mode 100644 index 0000000..ede5a91 --- /dev/null +++ b/src/compiler.h @@ -0,0 +1,49 @@ +#pragma once +#include +#include +#include +#include +#include +#include "parser.h" + +#define NT_HEADER(x) \ + reinterpret_cast( \ + reinterpret_cast(x)->e_lfanew + x) + +namespace vm +{ + struct base_data_t + { + std::uintptr_t module_base; + std::uintptr_t image_base; + }; + + struct vinstr_data + { + std::uint8_t vm_handler; + std::uint64_t operand; + std::uint8_t imm_size; // size in bits... + }; + + class compiler_t + { + public: + explicit compiler_t( + base_data_t base_data, + vmp2::exec_type_t exec_type, + std::vector* vm_handlers, + zydis_routine_t* calc_jmp + ); + + std::pair*> encode(); + std::pair* > encrypt(); + private: + transform::map_t calc_jmp_transforms; + zydis_routine_t* calc_jmp; + std::vector* vm_handlers; + vmp2::exec_type_t exec_type; + std::vector vinstrs; + std::vector result_buffer; + std::uintptr_t image_base, module_base; + }; +} \ No newline at end of file diff --git a/src/custom_build_rules/Bison/win_bison_custom_build.props b/src/custom_build_rules/Bison/win_bison_custom_build.props new file mode 100644 index 0000000..3916385 --- /dev/null +++ b/src/custom_build_rules/Bison/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); + Process "%(Filename)%(Extension)" bison file + + + \ No newline at end of file diff --git a/src/custom_build_rules/Bison/win_bison_custom_build.targets b/src/custom_build_rules/Bison/win_bison_custom_build.targets new file mode 100644 index 0000000..11c7ab6 --- /dev/null +++ b/src/custom_build_rules/Bison/win_bison_custom_build.targets @@ -0,0 +1,101 @@ + + + + + + BisonTarget + + + FlexTarget + + + + $(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml + + + $(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml + + + + + + + + @(Bison, '|') + + + + + + + + + $(ComputeLinkInputsTargets); + ComputeBisonOutput; + + + $(ComputeLibInputsTargets); + ComputeBisonOutput; + + + + + + + + + + + + \ No newline at end of file diff --git a/src/custom_build_rules/Bison/win_bison_custom_build.xml b/src/custom_build_rules/Bison/win_bison_custom_build.xml new file mode 100644 index 0000000..3688091 --- /dev/null +++ b/src/custom_build_rules/Bison/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/src/custom_build_rules/Flex/win_flex_custom_build.props b/src/custom_build_rules/Flex/win_flex_custom_build.props new file mode 100644 index 0000000..9203b4a --- /dev/null +++ b/src/custom_build_rules/Flex/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/src/custom_build_rules/Flex/win_flex_custom_build.targets b/src/custom_build_rules/Flex/win_flex_custom_build.targets new file mode 100644 index 0000000..2e81555 --- /dev/null +++ b/src/custom_build_rules/Flex/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/src/custom_build_rules/Flex/win_flex_custom_build.xml b/src/custom_build_rules/Flex/win_flex_custom_build.xml new file mode 100644 index 0000000..b75d925 --- /dev/null +++ b/src/custom_build_rules/Flex/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/src/custom_build_rules/how_to_use.txt b/src/custom_build_rules/how_to_use.txt new file mode 100644 index 0000000..e4dd84b --- /dev/null +++ b/src/custom_build_rules/how_to_use.txt @@ -0,0 +1 @@ +https://sourceforge.net/p/winflexbison/wiki/Visual%20Studio%20custom%20build%20rules/ \ No newline at end of file diff --git a/src/custom_build_rules/win_bison_only/win_bison_custom_build.props b/src/custom_build_rules/win_bison_only/win_bison_custom_build.props new file mode 100644 index 0000000..3916385 --- /dev/null +++ b/src/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); + Process "%(Filename)%(Extension)" bison file + + + \ No newline at end of file diff --git a/src/custom_build_rules/win_bison_only/win_bison_custom_build.targets b/src/custom_build_rules/win_bison_only/win_bison_custom_build.targets new file mode 100644 index 0000000..feb0de2 --- /dev/null +++ b/src/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/src/custom_build_rules/win_bison_only/win_bison_custom_build.xml b/src/custom_build_rules/win_bison_only/win_bison_custom_build.xml new file mode 100644 index 0000000..1d51e62 --- /dev/null +++ b/src/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/src/custom_build_rules/win_flex_bison_custom_build.props b/src/custom_build_rules/win_flex_bison_custom_build.props new file mode 100644 index 0000000..93998ef --- /dev/null +++ b/src/custom_build_rules/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); + 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/src/custom_build_rules/win_flex_bison_custom_build.targets b/src/custom_build_rules/win_flex_bison_custom_build.targets new file mode 100644 index 0000000..2fabf74 --- /dev/null +++ b/src/custom_build_rules/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/src/custom_build_rules/win_flex_bison_custom_build.xml b/src/custom_build_rules/win_flex_bison_custom_build.xml new file mode 100644 index 0000000..d42d514 --- /dev/null +++ b/src/custom_build_rules/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/src/custom_build_rules/win_flex_only/win_flex_custom_build.props b/src/custom_build_rules/win_flex_only/win_flex_custom_build.props new file mode 100644 index 0000000..9203b4a --- /dev/null +++ b/src/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/src/custom_build_rules/win_flex_only/win_flex_custom_build.targets b/src/custom_build_rules/win_flex_only/win_flex_custom_build.targets new file mode 100644 index 0000000..2e81555 --- /dev/null +++ b/src/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/src/custom_build_rules/win_flex_only/win_flex_custom_build.xml b/src/custom_build_rules/win_flex_only/win_flex_custom_build.xml new file mode 100644 index 0000000..b75d925 --- /dev/null +++ b/src/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/src/data/Makefile.am b/src/data/Makefile.am new file mode 100644 index 0000000..1fd10b4 --- /dev/null +++ b/src/data/Makefile.am @@ -0,0 +1,30 @@ +## Copyright (C) 2002, 2005-2012 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 = README bison.m4 \ + c-like.m4 \ + c-skel.m4 c.m4 yacc.c glr.c \ + c++-skel.m4 c++.m4 location.cc lalr1.cc glr.cc stack.hh \ + java-skel.m4 java.m4 lalr1.java + +m4sugardir = $(pkgdatadir)/m4sugar +dist_m4sugar_DATA = m4sugar/m4sugar.m4 m4sugar/foreach.m4 + +xsltdir = $(pkgdatadir)/xslt +dist_xslt_DATA = \ + xslt/bison.xsl \ + xslt/xml2dot.xsl \ + xslt/xml2text.xsl \ + xslt/xml2xhtml.xsl diff --git a/src/data/Makefile.in b/src/data/Makefile.in new file mode 100644 index 0000000..aae8326 --- /dev/null +++ b/src/data/Makefile.in @@ -0,0 +1,1639 @@ +# Makefile.in generated by automake 1.12.5 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2012 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# 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 . + +VPATH = @srcdir@ +am__make_dryrun = \ + { \ + am__dry=no; \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + echo 'am--echo: ; @echo "AM" OK' | $(MAKE) -f - 2>/dev/null \ + | grep '^AM OK$$' >/dev/null || am__dry=yes;; \ + *) \ + for am__flg in $$MAKEFLAGS; do \ + case $$am__flg in \ + *=*|--*) ;; \ + *n*) am__dry=yes; break;; \ + esac; \ + done;; \ + esac; \ + test $$am__dry = yes; \ + } +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = data +DIST_COMMON = README $(dist_m4sugar_DATA) $(dist_pkgdata_DATA) \ + $(dist_xslt_DATA) $(srcdir)/Makefile.am $(srcdir)/Makefile.in +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/00gnulib.m4 \ + $(top_srcdir)/m4/alloca.m4 $(top_srcdir)/m4/asm-underscore.m4 \ + $(top_srcdir)/m4/assert.m4 $(top_srcdir)/m4/bison-i18n.m4 \ + $(top_srcdir)/m4/c-working.m4 $(top_srcdir)/m4/calloc.m4 \ + $(top_srcdir)/m4/close-stream.m4 $(top_srcdir)/m4/close.m4 \ + $(top_srcdir)/m4/closeout.m4 $(top_srcdir)/m4/codeset.m4 \ + $(top_srcdir)/m4/config-h.m4 $(top_srcdir)/m4/configmake.m4 \ + $(top_srcdir)/m4/cxx.m4 $(top_srcdir)/m4/dirname.m4 \ + $(top_srcdir)/m4/dmalloc.m4 \ + $(top_srcdir)/m4/double-slash-root.m4 $(top_srcdir)/m4/dup2.m4 \ + $(top_srcdir)/m4/environ.m4 $(top_srcdir)/m4/errno_h.m4 \ + $(top_srcdir)/m4/error.m4 $(top_srcdir)/m4/exponentd.m4 \ + $(top_srcdir)/m4/exponentf.m4 $(top_srcdir)/m4/exponentl.m4 \ + $(top_srcdir)/m4/extensions.m4 \ + $(top_srcdir)/m4/extern-inline.m4 \ + $(top_srcdir)/m4/fatal-signal.m4 $(top_srcdir)/m4/fcntl-o.m4 \ + $(top_srcdir)/m4/fcntl.m4 $(top_srcdir)/m4/fcntl_h.m4 \ + $(top_srcdir)/m4/flex.m4 $(top_srcdir)/m4/float_h.m4 \ + $(top_srcdir)/m4/fopen.m4 $(top_srcdir)/m4/fpending.m4 \ + $(top_srcdir)/m4/fpieee.m4 $(top_srcdir)/m4/fprintf-posix.m4 \ + $(top_srcdir)/m4/frexp.m4 $(top_srcdir)/m4/frexpl.m4 \ + $(top_srcdir)/m4/fseterr.m4 $(top_srcdir)/m4/fstat.m4 \ + $(top_srcdir)/m4/getdelim.m4 $(top_srcdir)/m4/getdtablesize.m4 \ + $(top_srcdir)/m4/getline.m4 $(top_srcdir)/m4/getopt.m4 \ + $(top_srcdir)/m4/gettext.m4 $(top_srcdir)/m4/glibc21.m4 \ + $(top_srcdir)/m4/gnulib-common.m4 \ + $(top_srcdir)/m4/gnulib-comp.m4 $(top_srcdir)/m4/iconv.m4 \ + $(top_srcdir)/m4/include_next.m4 \ + $(top_srcdir)/m4/intlmacosx.m4 $(top_srcdir)/m4/intmax_t.m4 \ + $(top_srcdir)/m4/inttypes-pri.m4 $(top_srcdir)/m4/inttypes.m4 \ + $(top_srcdir)/m4/inttypes_h.m4 $(top_srcdir)/m4/isnan.m4 \ + $(top_srcdir)/m4/isnand.m4 $(top_srcdir)/m4/isnanf.m4 \ + $(top_srcdir)/m4/isnanl.m4 $(top_srcdir)/m4/iswblank.m4 \ + $(top_srcdir)/m4/javacomp.m4 $(top_srcdir)/m4/javaexec.m4 \ + $(top_srcdir)/m4/largefile.m4 $(top_srcdir)/m4/ldexp.m4 \ + $(top_srcdir)/m4/ldexpl.m4 $(top_srcdir)/m4/lib-ld.m4 \ + $(top_srcdir)/m4/lib-link.m4 $(top_srcdir)/m4/lib-prefix.m4 \ + $(top_srcdir)/m4/libunistring-base.m4 \ + $(top_srcdir)/m4/localcharset.m4 $(top_srcdir)/m4/locale-fr.m4 \ + $(top_srcdir)/m4/locale-ja.m4 $(top_srcdir)/m4/locale-zh.m4 \ + $(top_srcdir)/m4/lock.m4 $(top_srcdir)/m4/longlong.m4 \ + $(top_srcdir)/m4/m4.m4 $(top_srcdir)/m4/malloc.m4 \ + $(top_srcdir)/m4/math_h.m4 $(top_srcdir)/m4/mbchar.m4 \ + $(top_srcdir)/m4/mbiter.m4 $(top_srcdir)/m4/mbrtowc.m4 \ + $(top_srcdir)/m4/mbsinit.m4 $(top_srcdir)/m4/mbstate_t.m4 \ + $(top_srcdir)/m4/mbswidth.m4 $(top_srcdir)/m4/memchr.m4 \ + $(top_srcdir)/m4/mmap-anon.m4 $(top_srcdir)/m4/mode_t.m4 \ + $(top_srcdir)/m4/msvc-inval.m4 \ + $(top_srcdir)/m4/msvc-nothrow.m4 $(top_srcdir)/m4/multiarch.m4 \ + $(top_srcdir)/m4/nls.m4 $(top_srcdir)/m4/nocrash.m4 \ + $(top_srcdir)/m4/obstack-printf.m4 $(top_srcdir)/m4/off_t.m4 \ + $(top_srcdir)/m4/open.m4 $(top_srcdir)/m4/pathmax.m4 \ + $(top_srcdir)/m4/perror.m4 $(top_srcdir)/m4/pipe2.m4 \ + $(top_srcdir)/m4/po.m4 $(top_srcdir)/m4/posix_spawn.m4 \ + $(top_srcdir)/m4/printf-frexp.m4 \ + $(top_srcdir)/m4/printf-frexpl.m4 \ + $(top_srcdir)/m4/printf-posix-rpl.m4 \ + $(top_srcdir)/m4/printf.m4 $(top_srcdir)/m4/progtest.m4 \ + $(top_srcdir)/m4/quote.m4 $(top_srcdir)/m4/quotearg.m4 \ + $(top_srcdir)/m4/raise.m4 $(top_srcdir)/m4/rawmemchr.m4 \ + $(top_srcdir)/m4/realloc.m4 $(top_srcdir)/m4/sched_h.m4 \ + $(top_srcdir)/m4/setenv.m4 $(top_srcdir)/m4/sig_atomic_t.m4 \ + $(top_srcdir)/m4/sigaction.m4 $(top_srcdir)/m4/signal_h.m4 \ + $(top_srcdir)/m4/signalblocking.m4 $(top_srcdir)/m4/signbit.m4 \ + $(top_srcdir)/m4/size_max.m4 \ + $(top_srcdir)/m4/snprintf-posix.m4 \ + $(top_srcdir)/m4/snprintf.m4 $(top_srcdir)/m4/spawn-pipe.m4 \ + $(top_srcdir)/m4/spawn_h.m4 $(top_srcdir)/m4/sprintf-posix.m4 \ + $(top_srcdir)/m4/ssize_t.m4 $(top_srcdir)/m4/stat.m4 \ + $(top_srcdir)/m4/stdbool.m4 $(top_srcdir)/m4/stddef_h.m4 \ + $(top_srcdir)/m4/stdint.m4 $(top_srcdir)/m4/stdint_h.m4 \ + $(top_srcdir)/m4/stdio_h.m4 $(top_srcdir)/m4/stdlib_h.m4 \ + $(top_srcdir)/m4/stpcpy.m4 $(top_srcdir)/m4/strchrnul.m4 \ + $(top_srcdir)/m4/strdup.m4 $(top_srcdir)/m4/strerror.m4 \ + $(top_srcdir)/m4/strerror_r.m4 $(top_srcdir)/m4/string_h.m4 \ + $(top_srcdir)/m4/strndup.m4 $(top_srcdir)/m4/strnlen.m4 \ + $(top_srcdir)/m4/strtoul.m4 $(top_srcdir)/m4/strverscmp.m4 \ + $(top_srcdir)/m4/sys_socket_h.m4 \ + $(top_srcdir)/m4/sys_stat_h.m4 $(top_srcdir)/m4/sys_types_h.m4 \ + $(top_srcdir)/m4/sys_wait_h.m4 $(top_srcdir)/m4/threadlib.m4 \ + $(top_srcdir)/m4/time_h.m4 $(top_srcdir)/m4/timevar.m4 \ + $(top_srcdir)/m4/unistd-safer.m4 $(top_srcdir)/m4/unistd_h.m4 \ + $(top_srcdir)/m4/unlocked-io.m4 $(top_srcdir)/m4/vasnprintf.m4 \ + $(top_srcdir)/m4/vfprintf-posix.m4 \ + $(top_srcdir)/m4/vsnprintf-posix.m4 \ + $(top_srcdir)/m4/vsnprintf.m4 \ + $(top_srcdir)/m4/vsprintf-posix.m4 \ + $(top_srcdir)/m4/wait-process.m4 $(top_srcdir)/m4/waitpid.m4 \ + $(top_srcdir)/m4/warn-on-use.m4 $(top_srcdir)/m4/warnings.m4 \ + $(top_srcdir)/m4/wchar_h.m4 $(top_srcdir)/m4/wchar_t.m4 \ + $(top_srcdir)/m4/wctype_h.m4 $(top_srcdir)/m4/wcwidth.m4 \ + $(top_srcdir)/m4/wint_t.m4 $(top_srcdir)/m4/xalloc.m4 \ + $(top_srcdir)/m4/xsize.m4 $(top_srcdir)/m4/xstrndup.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/lib/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +SOURCES = +DIST_SOURCES = +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(m4sugardir)" "$(DESTDIR)$(pkgdatadir)" \ + "$(DESTDIR)$(xsltdir)" +DATA = $(dist_m4sugar_DATA) $(dist_pkgdata_DATA) $(dist_xslt_DATA) +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +pkglibexecdir = @pkglibexecdir@ +ACLOCAL = @ACLOCAL@ +ALLOCA = @ALLOCA@ +ALLOCA_H = @ALLOCA_H@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +APPLE_UNIVERSAL_BUILD = @APPLE_UNIVERSAL_BUILD@ +AR = @AR@ +ARFLAGS = @ARFLAGS@ +ASM_SYMBOL_PREFIX = @ASM_SYMBOL_PREFIX@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOM4TE = @AUTOM4TE@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +BISON_CXX_WORKS = @BISON_CXX_WORKS@ +BISON_C_WORKS = @BISON_C_WORKS@ +BISON_LOCALEDIR = @BISON_LOCALEDIR@ +BITSIZEOF_PTRDIFF_T = @BITSIZEOF_PTRDIFF_T@ +BITSIZEOF_SIG_ATOMIC_T = @BITSIZEOF_SIG_ATOMIC_T@ +BITSIZEOF_SIZE_T = @BITSIZEOF_SIZE_T@ +BITSIZEOF_WCHAR_T = @BITSIZEOF_WCHAR_T@ +BITSIZEOF_WINT_T = @BITSIZEOF_WINT_T@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CLASSPATH = @CLASSPATH@ +CLASSPATH_SEPARATOR = @CLASSPATH_SEPARATOR@ +CONFIG_INCLUDE = @CONFIG_INCLUDE@ +CONF_JAVA = @CONF_JAVA@ +CONF_JAVAC = @CONF_JAVAC@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CXX_COMPILER_POSIXLY_CORRECT = @CXX_COMPILER_POSIXLY_CORRECT@ +CYGPATH_W = @CYGPATH_W@ +C_COMPILER_POSIXLY_CORRECT = @C_COMPILER_POSIXLY_CORRECT@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DOT = @DOT@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EMULTIHOP_HIDDEN = @EMULTIHOP_HIDDEN@ +EMULTIHOP_VALUE = @EMULTIHOP_VALUE@ +ENOLINK_HIDDEN = @ENOLINK_HIDDEN@ +ENOLINK_VALUE = @ENOLINK_VALUE@ +EOVERFLOW_HIDDEN = @EOVERFLOW_HIDDEN@ +EOVERFLOW_VALUE = @EOVERFLOW_VALUE@ +ERRNO_H = @ERRNO_H@ +EXEEXT = @EXEEXT@ +FLOAT_H = @FLOAT_H@ +GCC = @GCC@ +GETOPT_H = @GETOPT_H@ +GETTEXT_MACRO_VERSION = @GETTEXT_MACRO_VERSION@ +GLIBC21 = @GLIBC21@ +GMSGFMT = @GMSGFMT@ +GMSGFMT_015 = @GMSGFMT_015@ +GNULIB_ACOSF = @GNULIB_ACOSF@ +GNULIB_ACOSL = @GNULIB_ACOSL@ +GNULIB_ASINF = @GNULIB_ASINF@ +GNULIB_ASINL = @GNULIB_ASINL@ +GNULIB_ATAN2F = @GNULIB_ATAN2F@ +GNULIB_ATANF = @GNULIB_ATANF@ +GNULIB_ATANL = @GNULIB_ATANL@ +GNULIB_ATOLL = @GNULIB_ATOLL@ +GNULIB_BTOWC = @GNULIB_BTOWC@ +GNULIB_CALLOC_POSIX = @GNULIB_CALLOC_POSIX@ +GNULIB_CANONICALIZE_FILE_NAME = @GNULIB_CANONICALIZE_FILE_NAME@ +GNULIB_CBRT = @GNULIB_CBRT@ +GNULIB_CBRTF = @GNULIB_CBRTF@ +GNULIB_CBRTL = @GNULIB_CBRTL@ +GNULIB_CEIL = @GNULIB_CEIL@ +GNULIB_CEILF = @GNULIB_CEILF@ +GNULIB_CEILL = @GNULIB_CEILL@ +GNULIB_CHDIR = @GNULIB_CHDIR@ +GNULIB_CHOWN = @GNULIB_CHOWN@ +GNULIB_CLOSE = @GNULIB_CLOSE@ +GNULIB_COPYSIGN = @GNULIB_COPYSIGN@ +GNULIB_COPYSIGNF = @GNULIB_COPYSIGNF@ +GNULIB_COPYSIGNL = @GNULIB_COPYSIGNL@ +GNULIB_COSF = @GNULIB_COSF@ +GNULIB_COSHF = @GNULIB_COSHF@ +GNULIB_COSL = @GNULIB_COSL@ +GNULIB_DPRINTF = @GNULIB_DPRINTF@ +GNULIB_DUP = @GNULIB_DUP@ +GNULIB_DUP2 = @GNULIB_DUP2@ +GNULIB_DUP3 = @GNULIB_DUP3@ +GNULIB_ENVIRON = @GNULIB_ENVIRON@ +GNULIB_EUIDACCESS = @GNULIB_EUIDACCESS@ +GNULIB_EXP2 = @GNULIB_EXP2@ +GNULIB_EXP2F = @GNULIB_EXP2F@ +GNULIB_EXP2L = @GNULIB_EXP2L@ +GNULIB_EXPF = @GNULIB_EXPF@ +GNULIB_EXPL = @GNULIB_EXPL@ +GNULIB_EXPM1 = @GNULIB_EXPM1@ +GNULIB_EXPM1F = @GNULIB_EXPM1F@ +GNULIB_EXPM1L = @GNULIB_EXPM1L@ +GNULIB_FABSF = @GNULIB_FABSF@ +GNULIB_FABSL = @GNULIB_FABSL@ +GNULIB_FACCESSAT = @GNULIB_FACCESSAT@ +GNULIB_FCHDIR = @GNULIB_FCHDIR@ +GNULIB_FCHMODAT = @GNULIB_FCHMODAT@ +GNULIB_FCHOWNAT = @GNULIB_FCHOWNAT@ +GNULIB_FCLOSE = @GNULIB_FCLOSE@ +GNULIB_FCNTL = @GNULIB_FCNTL@ +GNULIB_FDATASYNC = @GNULIB_FDATASYNC@ +GNULIB_FDOPEN = @GNULIB_FDOPEN@ +GNULIB_FFLUSH = @GNULIB_FFLUSH@ +GNULIB_FFSL = @GNULIB_FFSL@ +GNULIB_FFSLL = @GNULIB_FFSLL@ +GNULIB_FGETC = @GNULIB_FGETC@ +GNULIB_FGETS = @GNULIB_FGETS@ +GNULIB_FLOOR = @GNULIB_FLOOR@ +GNULIB_FLOORF = @GNULIB_FLOORF@ +GNULIB_FLOORL = @GNULIB_FLOORL@ +GNULIB_FMA = @GNULIB_FMA@ +GNULIB_FMAF = @GNULIB_FMAF@ +GNULIB_FMAL = @GNULIB_FMAL@ +GNULIB_FMOD = @GNULIB_FMOD@ +GNULIB_FMODF = @GNULIB_FMODF@ +GNULIB_FMODL = @GNULIB_FMODL@ +GNULIB_FOPEN = @GNULIB_FOPEN@ +GNULIB_FPRINTF = @GNULIB_FPRINTF@ +GNULIB_FPRINTF_POSIX = @GNULIB_FPRINTF_POSIX@ +GNULIB_FPURGE = @GNULIB_FPURGE@ +GNULIB_FPUTC = @GNULIB_FPUTC@ +GNULIB_FPUTS = @GNULIB_FPUTS@ +GNULIB_FREAD = @GNULIB_FREAD@ +GNULIB_FREOPEN = @GNULIB_FREOPEN@ +GNULIB_FREXP = @GNULIB_FREXP@ +GNULIB_FREXPF = @GNULIB_FREXPF@ +GNULIB_FREXPL = @GNULIB_FREXPL@ +GNULIB_FSCANF = @GNULIB_FSCANF@ +GNULIB_FSEEK = @GNULIB_FSEEK@ +GNULIB_FSEEKO = @GNULIB_FSEEKO@ +GNULIB_FSTAT = @GNULIB_FSTAT@ +GNULIB_FSTATAT = @GNULIB_FSTATAT@ +GNULIB_FSYNC = @GNULIB_FSYNC@ +GNULIB_FTELL = @GNULIB_FTELL@ +GNULIB_FTELLO = @GNULIB_FTELLO@ +GNULIB_FTRUNCATE = @GNULIB_FTRUNCATE@ +GNULIB_FUTIMENS = @GNULIB_FUTIMENS@ +GNULIB_FWRITE = @GNULIB_FWRITE@ +GNULIB_GETC = @GNULIB_GETC@ +GNULIB_GETCHAR = @GNULIB_GETCHAR@ +GNULIB_GETCWD = @GNULIB_GETCWD@ +GNULIB_GETDELIM = @GNULIB_GETDELIM@ +GNULIB_GETDOMAINNAME = @GNULIB_GETDOMAINNAME@ +GNULIB_GETDTABLESIZE = @GNULIB_GETDTABLESIZE@ +GNULIB_GETGROUPS = @GNULIB_GETGROUPS@ +GNULIB_GETHOSTNAME = @GNULIB_GETHOSTNAME@ +GNULIB_GETLINE = @GNULIB_GETLINE@ +GNULIB_GETLOADAVG = @GNULIB_GETLOADAVG@ +GNULIB_GETLOGIN = @GNULIB_GETLOGIN@ +GNULIB_GETLOGIN_R = @GNULIB_GETLOGIN_R@ +GNULIB_GETPAGESIZE = @GNULIB_GETPAGESIZE@ +GNULIB_GETSUBOPT = @GNULIB_GETSUBOPT@ +GNULIB_GETUSERSHELL = @GNULIB_GETUSERSHELL@ +GNULIB_GL_UNISTD_H_GETOPT = @GNULIB_GL_UNISTD_H_GETOPT@ +GNULIB_GRANTPT = @GNULIB_GRANTPT@ +GNULIB_GROUP_MEMBER = @GNULIB_GROUP_MEMBER@ +GNULIB_HYPOT = @GNULIB_HYPOT@ +GNULIB_HYPOTF = @GNULIB_HYPOTF@ +GNULIB_HYPOTL = @GNULIB_HYPOTL@ +GNULIB_ILOGB = @GNULIB_ILOGB@ +GNULIB_ILOGBF = @GNULIB_ILOGBF@ +GNULIB_ILOGBL = @GNULIB_ILOGBL@ +GNULIB_IMAXABS = @GNULIB_IMAXABS@ +GNULIB_IMAXDIV = @GNULIB_IMAXDIV@ +GNULIB_ISATTY = @GNULIB_ISATTY@ +GNULIB_ISFINITE = @GNULIB_ISFINITE@ +GNULIB_ISINF = @GNULIB_ISINF@ +GNULIB_ISNAN = @GNULIB_ISNAN@ +GNULIB_ISNAND = @GNULIB_ISNAND@ +GNULIB_ISNANF = @GNULIB_ISNANF@ +GNULIB_ISNANL = @GNULIB_ISNANL@ +GNULIB_ISWBLANK = @GNULIB_ISWBLANK@ +GNULIB_ISWCTYPE = @GNULIB_ISWCTYPE@ +GNULIB_LCHMOD = @GNULIB_LCHMOD@ +GNULIB_LCHOWN = @GNULIB_LCHOWN@ +GNULIB_LDEXPF = @GNULIB_LDEXPF@ +GNULIB_LDEXPL = @GNULIB_LDEXPL@ +GNULIB_LINK = @GNULIB_LINK@ +GNULIB_LINKAT = @GNULIB_LINKAT@ +GNULIB_LOG = @GNULIB_LOG@ +GNULIB_LOG10 = @GNULIB_LOG10@ +GNULIB_LOG10F = @GNULIB_LOG10F@ +GNULIB_LOG10L = @GNULIB_LOG10L@ +GNULIB_LOG1P = @GNULIB_LOG1P@ +GNULIB_LOG1PF = @GNULIB_LOG1PF@ +GNULIB_LOG1PL = @GNULIB_LOG1PL@ +GNULIB_LOG2 = @GNULIB_LOG2@ +GNULIB_LOG2F = @GNULIB_LOG2F@ +GNULIB_LOG2L = @GNULIB_LOG2L@ +GNULIB_LOGB = @GNULIB_LOGB@ +GNULIB_LOGBF = @GNULIB_LOGBF@ +GNULIB_LOGBL = @GNULIB_LOGBL@ +GNULIB_LOGF = @GNULIB_LOGF@ +GNULIB_LOGL = @GNULIB_LOGL@ +GNULIB_LSEEK = @GNULIB_LSEEK@ +GNULIB_LSTAT = @GNULIB_LSTAT@ +GNULIB_MALLOC_POSIX = @GNULIB_MALLOC_POSIX@ +GNULIB_MBRLEN = @GNULIB_MBRLEN@ +GNULIB_MBRTOWC = @GNULIB_MBRTOWC@ +GNULIB_MBSCASECMP = @GNULIB_MBSCASECMP@ +GNULIB_MBSCASESTR = @GNULIB_MBSCASESTR@ +GNULIB_MBSCHR = @GNULIB_MBSCHR@ +GNULIB_MBSCSPN = @GNULIB_MBSCSPN@ +GNULIB_MBSINIT = @GNULIB_MBSINIT@ +GNULIB_MBSLEN = @GNULIB_MBSLEN@ +GNULIB_MBSNCASECMP = @GNULIB_MBSNCASECMP@ +GNULIB_MBSNLEN = @GNULIB_MBSNLEN@ +GNULIB_MBSNRTOWCS = @GNULIB_MBSNRTOWCS@ +GNULIB_MBSPBRK = @GNULIB_MBSPBRK@ +GNULIB_MBSPCASECMP = @GNULIB_MBSPCASECMP@ +GNULIB_MBSRCHR = @GNULIB_MBSRCHR@ +GNULIB_MBSRTOWCS = @GNULIB_MBSRTOWCS@ +GNULIB_MBSSEP = @GNULIB_MBSSEP@ +GNULIB_MBSSPN = @GNULIB_MBSSPN@ +GNULIB_MBSSTR = @GNULIB_MBSSTR@ +GNULIB_MBSTOK_R = @GNULIB_MBSTOK_R@ +GNULIB_MBTOWC = @GNULIB_MBTOWC@ +GNULIB_MEMCHR = @GNULIB_MEMCHR@ +GNULIB_MEMMEM = @GNULIB_MEMMEM@ +GNULIB_MEMPCPY = @GNULIB_MEMPCPY@ +GNULIB_MEMRCHR = @GNULIB_MEMRCHR@ +GNULIB_MKDIRAT = @GNULIB_MKDIRAT@ +GNULIB_MKDTEMP = @GNULIB_MKDTEMP@ +GNULIB_MKFIFO = @GNULIB_MKFIFO@ +GNULIB_MKFIFOAT = @GNULIB_MKFIFOAT@ +GNULIB_MKNOD = @GNULIB_MKNOD@ +GNULIB_MKNODAT = @GNULIB_MKNODAT@ +GNULIB_MKOSTEMP = @GNULIB_MKOSTEMP@ +GNULIB_MKOSTEMPS = @GNULIB_MKOSTEMPS@ +GNULIB_MKSTEMP = @GNULIB_MKSTEMP@ +GNULIB_MKSTEMPS = @GNULIB_MKSTEMPS@ +GNULIB_MKTIME = @GNULIB_MKTIME@ +GNULIB_MODF = @GNULIB_MODF@ +GNULIB_MODFF = @GNULIB_MODFF@ +GNULIB_MODFL = @GNULIB_MODFL@ +GNULIB_NANOSLEEP = @GNULIB_NANOSLEEP@ +GNULIB_NONBLOCKING = @GNULIB_NONBLOCKING@ +GNULIB_OBSTACK_PRINTF = @GNULIB_OBSTACK_PRINTF@ +GNULIB_OBSTACK_PRINTF_POSIX = @GNULIB_OBSTACK_PRINTF_POSIX@ +GNULIB_OPEN = @GNULIB_OPEN@ +GNULIB_OPENAT = @GNULIB_OPENAT@ +GNULIB_PCLOSE = @GNULIB_PCLOSE@ +GNULIB_PERROR = @GNULIB_PERROR@ +GNULIB_PIPE = @GNULIB_PIPE@ +GNULIB_PIPE2 = @GNULIB_PIPE2@ +GNULIB_POPEN = @GNULIB_POPEN@ +GNULIB_POSIX_OPENPT = @GNULIB_POSIX_OPENPT@ +GNULIB_POSIX_SPAWN = @GNULIB_POSIX_SPAWN@ +GNULIB_POSIX_SPAWNATTR_DESTROY = @GNULIB_POSIX_SPAWNATTR_DESTROY@ +GNULIB_POSIX_SPAWNATTR_GETFLAGS = @GNULIB_POSIX_SPAWNATTR_GETFLAGS@ +GNULIB_POSIX_SPAWNATTR_GETPGROUP = @GNULIB_POSIX_SPAWNATTR_GETPGROUP@ +GNULIB_POSIX_SPAWNATTR_GETSCHEDPARAM = @GNULIB_POSIX_SPAWNATTR_GETSCHEDPARAM@ +GNULIB_POSIX_SPAWNATTR_GETSCHEDPOLICY = @GNULIB_POSIX_SPAWNATTR_GETSCHEDPOLICY@ +GNULIB_POSIX_SPAWNATTR_GETSIGDEFAULT = @GNULIB_POSIX_SPAWNATTR_GETSIGDEFAULT@ +GNULIB_POSIX_SPAWNATTR_GETSIGMASK = @GNULIB_POSIX_SPAWNATTR_GETSIGMASK@ +GNULIB_POSIX_SPAWNATTR_INIT = @GNULIB_POSIX_SPAWNATTR_INIT@ +GNULIB_POSIX_SPAWNATTR_SETFLAGS = @GNULIB_POSIX_SPAWNATTR_SETFLAGS@ +GNULIB_POSIX_SPAWNATTR_SETPGROUP = @GNULIB_POSIX_SPAWNATTR_SETPGROUP@ +GNULIB_POSIX_SPAWNATTR_SETSCHEDPARAM = @GNULIB_POSIX_SPAWNATTR_SETSCHEDPARAM@ +GNULIB_POSIX_SPAWNATTR_SETSCHEDPOLICY = @GNULIB_POSIX_SPAWNATTR_SETSCHEDPOLICY@ +GNULIB_POSIX_SPAWNATTR_SETSIGDEFAULT = @GNULIB_POSIX_SPAWNATTR_SETSIGDEFAULT@ +GNULIB_POSIX_SPAWNATTR_SETSIGMASK = @GNULIB_POSIX_SPAWNATTR_SETSIGMASK@ +GNULIB_POSIX_SPAWNP = @GNULIB_POSIX_SPAWNP@ +GNULIB_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE = @GNULIB_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE@ +GNULIB_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 = @GNULIB_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2@ +GNULIB_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN = @GNULIB_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN@ +GNULIB_POSIX_SPAWN_FILE_ACTIONS_DESTROY = @GNULIB_POSIX_SPAWN_FILE_ACTIONS_DESTROY@ +GNULIB_POSIX_SPAWN_FILE_ACTIONS_INIT = @GNULIB_POSIX_SPAWN_FILE_ACTIONS_INIT@ +GNULIB_POWF = @GNULIB_POWF@ +GNULIB_PREAD = @GNULIB_PREAD@ +GNULIB_PRINTF = @GNULIB_PRINTF@ +GNULIB_PRINTF_POSIX = @GNULIB_PRINTF_POSIX@ +GNULIB_PTHREAD_SIGMASK = @GNULIB_PTHREAD_SIGMASK@ +GNULIB_PTSNAME = @GNULIB_PTSNAME@ +GNULIB_PTSNAME_R = @GNULIB_PTSNAME_R@ +GNULIB_PUTC = @GNULIB_PUTC@ +GNULIB_PUTCHAR = @GNULIB_PUTCHAR@ +GNULIB_PUTENV = @GNULIB_PUTENV@ +GNULIB_PUTS = @GNULIB_PUTS@ +GNULIB_PWRITE = @GNULIB_PWRITE@ +GNULIB_RAISE = @GNULIB_RAISE@ +GNULIB_RANDOM = @GNULIB_RANDOM@ +GNULIB_RANDOM_R = @GNULIB_RANDOM_R@ +GNULIB_RAWMEMCHR = @GNULIB_RAWMEMCHR@ +GNULIB_READ = @GNULIB_READ@ +GNULIB_READLINK = @GNULIB_READLINK@ +GNULIB_READLINKAT = @GNULIB_READLINKAT@ +GNULIB_REALLOC_POSIX = @GNULIB_REALLOC_POSIX@ +GNULIB_REALPATH = @GNULIB_REALPATH@ +GNULIB_REMAINDER = @GNULIB_REMAINDER@ +GNULIB_REMAINDERF = @GNULIB_REMAINDERF@ +GNULIB_REMAINDERL = @GNULIB_REMAINDERL@ +GNULIB_REMOVE = @GNULIB_REMOVE@ +GNULIB_RENAME = @GNULIB_RENAME@ +GNULIB_RENAMEAT = @GNULIB_RENAMEAT@ +GNULIB_RINT = @GNULIB_RINT@ +GNULIB_RINTF = @GNULIB_RINTF@ +GNULIB_RINTL = @GNULIB_RINTL@ +GNULIB_RMDIR = @GNULIB_RMDIR@ +GNULIB_ROUND = @GNULIB_ROUND@ +GNULIB_ROUNDF = @GNULIB_ROUNDF@ +GNULIB_ROUNDL = @GNULIB_ROUNDL@ +GNULIB_RPMATCH = @GNULIB_RPMATCH@ +GNULIB_SCANF = @GNULIB_SCANF@ +GNULIB_SETENV = @GNULIB_SETENV@ +GNULIB_SETHOSTNAME = @GNULIB_SETHOSTNAME@ +GNULIB_SIGACTION = @GNULIB_SIGACTION@ +GNULIB_SIGNAL_H_SIGPIPE = @GNULIB_SIGNAL_H_SIGPIPE@ +GNULIB_SIGNBIT = @GNULIB_SIGNBIT@ +GNULIB_SIGPROCMASK = @GNULIB_SIGPROCMASK@ +GNULIB_SINF = @GNULIB_SINF@ +GNULIB_SINHF = @GNULIB_SINHF@ +GNULIB_SINL = @GNULIB_SINL@ +GNULIB_SLEEP = @GNULIB_SLEEP@ +GNULIB_SNPRINTF = @GNULIB_SNPRINTF@ +GNULIB_SPRINTF_POSIX = @GNULIB_SPRINTF_POSIX@ +GNULIB_SQRTF = @GNULIB_SQRTF@ +GNULIB_SQRTL = @GNULIB_SQRTL@ +GNULIB_STAT = @GNULIB_STAT@ +GNULIB_STDIO_H_NONBLOCKING = @GNULIB_STDIO_H_NONBLOCKING@ +GNULIB_STDIO_H_SIGPIPE = @GNULIB_STDIO_H_SIGPIPE@ +GNULIB_STPCPY = @GNULIB_STPCPY@ +GNULIB_STPNCPY = @GNULIB_STPNCPY@ +GNULIB_STRCASESTR = @GNULIB_STRCASESTR@ +GNULIB_STRCHRNUL = @GNULIB_STRCHRNUL@ +GNULIB_STRDUP = @GNULIB_STRDUP@ +GNULIB_STRERROR = @GNULIB_STRERROR@ +GNULIB_STRERROR_R = @GNULIB_STRERROR_R@ +GNULIB_STRNCAT = @GNULIB_STRNCAT@ +GNULIB_STRNDUP = @GNULIB_STRNDUP@ +GNULIB_STRNLEN = @GNULIB_STRNLEN@ +GNULIB_STRPBRK = @GNULIB_STRPBRK@ +GNULIB_STRPTIME = @GNULIB_STRPTIME@ +GNULIB_STRSEP = @GNULIB_STRSEP@ +GNULIB_STRSIGNAL = @GNULIB_STRSIGNAL@ +GNULIB_STRSTR = @GNULIB_STRSTR@ +GNULIB_STRTOD = @GNULIB_STRTOD@ +GNULIB_STRTOIMAX = @GNULIB_STRTOIMAX@ +GNULIB_STRTOK_R = @GNULIB_STRTOK_R@ +GNULIB_STRTOLL = @GNULIB_STRTOLL@ +GNULIB_STRTOULL = @GNULIB_STRTOULL@ +GNULIB_STRTOUMAX = @GNULIB_STRTOUMAX@ +GNULIB_STRVERSCMP = @GNULIB_STRVERSCMP@ +GNULIB_SYMLINK = @GNULIB_SYMLINK@ +GNULIB_SYMLINKAT = @GNULIB_SYMLINKAT@ +GNULIB_SYSTEM_POSIX = @GNULIB_SYSTEM_POSIX@ +GNULIB_TANF = @GNULIB_TANF@ +GNULIB_TANHF = @GNULIB_TANHF@ +GNULIB_TANL = @GNULIB_TANL@ +GNULIB_TIMEGM = @GNULIB_TIMEGM@ +GNULIB_TIME_R = @GNULIB_TIME_R@ +GNULIB_TMPFILE = @GNULIB_TMPFILE@ +GNULIB_TOWCTRANS = @GNULIB_TOWCTRANS@ +GNULIB_TRUNC = @GNULIB_TRUNC@ +GNULIB_TRUNCF = @GNULIB_TRUNCF@ +GNULIB_TRUNCL = @GNULIB_TRUNCL@ +GNULIB_TTYNAME_R = @GNULIB_TTYNAME_R@ +GNULIB_UNISTD_H_NONBLOCKING = @GNULIB_UNISTD_H_NONBLOCKING@ +GNULIB_UNISTD_H_SIGPIPE = @GNULIB_UNISTD_H_SIGPIPE@ +GNULIB_UNLINK = @GNULIB_UNLINK@ +GNULIB_UNLINKAT = @GNULIB_UNLINKAT@ +GNULIB_UNLOCKPT = @GNULIB_UNLOCKPT@ +GNULIB_UNSETENV = @GNULIB_UNSETENV@ +GNULIB_USLEEP = @GNULIB_USLEEP@ +GNULIB_UTIMENSAT = @GNULIB_UTIMENSAT@ +GNULIB_VASPRINTF = @GNULIB_VASPRINTF@ +GNULIB_VDPRINTF = @GNULIB_VDPRINTF@ +GNULIB_VFPRINTF = @GNULIB_VFPRINTF@ +GNULIB_VFPRINTF_POSIX = @GNULIB_VFPRINTF_POSIX@ +GNULIB_VFSCANF = @GNULIB_VFSCANF@ +GNULIB_VPRINTF = @GNULIB_VPRINTF@ +GNULIB_VPRINTF_POSIX = @GNULIB_VPRINTF_POSIX@ +GNULIB_VSCANF = @GNULIB_VSCANF@ +GNULIB_VSNPRINTF = @GNULIB_VSNPRINTF@ +GNULIB_VSPRINTF_POSIX = @GNULIB_VSPRINTF_POSIX@ +GNULIB_WAITPID = @GNULIB_WAITPID@ +GNULIB_WCPCPY = @GNULIB_WCPCPY@ +GNULIB_WCPNCPY = @GNULIB_WCPNCPY@ +GNULIB_WCRTOMB = @GNULIB_WCRTOMB@ +GNULIB_WCSCASECMP = @GNULIB_WCSCASECMP@ +GNULIB_WCSCAT = @GNULIB_WCSCAT@ +GNULIB_WCSCHR = @GNULIB_WCSCHR@ +GNULIB_WCSCMP = @GNULIB_WCSCMP@ +GNULIB_WCSCOLL = @GNULIB_WCSCOLL@ +GNULIB_WCSCPY = @GNULIB_WCSCPY@ +GNULIB_WCSCSPN = @GNULIB_WCSCSPN@ +GNULIB_WCSDUP = @GNULIB_WCSDUP@ +GNULIB_WCSLEN = @GNULIB_WCSLEN@ +GNULIB_WCSNCASECMP = @GNULIB_WCSNCASECMP@ +GNULIB_WCSNCAT = @GNULIB_WCSNCAT@ +GNULIB_WCSNCMP = @GNULIB_WCSNCMP@ +GNULIB_WCSNCPY = @GNULIB_WCSNCPY@ +GNULIB_WCSNLEN = @GNULIB_WCSNLEN@ +GNULIB_WCSNRTOMBS = @GNULIB_WCSNRTOMBS@ +GNULIB_WCSPBRK = @GNULIB_WCSPBRK@ +GNULIB_WCSRCHR = @GNULIB_WCSRCHR@ +GNULIB_WCSRTOMBS = @GNULIB_WCSRTOMBS@ +GNULIB_WCSSPN = @GNULIB_WCSSPN@ +GNULIB_WCSSTR = @GNULIB_WCSSTR@ +GNULIB_WCSTOK = @GNULIB_WCSTOK@ +GNULIB_WCSWIDTH = @GNULIB_WCSWIDTH@ +GNULIB_WCSXFRM = @GNULIB_WCSXFRM@ +GNULIB_WCTOB = @GNULIB_WCTOB@ +GNULIB_WCTOMB = @GNULIB_WCTOMB@ +GNULIB_WCTRANS = @GNULIB_WCTRANS@ +GNULIB_WCTYPE = @GNULIB_WCTYPE@ +GNULIB_WCWIDTH = @GNULIB_WCWIDTH@ +GNULIB_WMEMCHR = @GNULIB_WMEMCHR@ +GNULIB_WMEMCMP = @GNULIB_WMEMCMP@ +GNULIB_WMEMCPY = @GNULIB_WMEMCPY@ +GNULIB_WMEMMOVE = @GNULIB_WMEMMOVE@ +GNULIB_WMEMSET = @GNULIB_WMEMSET@ +GNULIB_WRITE = @GNULIB_WRITE@ +GNULIB__EXIT = @GNULIB__EXIT@ +GREP = @GREP@ +HAVE_ACOSF = @HAVE_ACOSF@ +HAVE_ACOSL = @HAVE_ACOSL@ +HAVE_ASINF = @HAVE_ASINF@ +HAVE_ASINL = @HAVE_ASINL@ +HAVE_ATAN2F = @HAVE_ATAN2F@ +HAVE_ATANF = @HAVE_ATANF@ +HAVE_ATANL = @HAVE_ATANL@ +HAVE_ATOLL = @HAVE_ATOLL@ +HAVE_BTOWC = @HAVE_BTOWC@ +HAVE_CANONICALIZE_FILE_NAME = @HAVE_CANONICALIZE_FILE_NAME@ +HAVE_CBRT = @HAVE_CBRT@ +HAVE_CBRTF = @HAVE_CBRTF@ +HAVE_CBRTL = @HAVE_CBRTL@ +HAVE_CHOWN = @HAVE_CHOWN@ +HAVE_COPYSIGN = @HAVE_COPYSIGN@ +HAVE_COPYSIGNL = @HAVE_COPYSIGNL@ +HAVE_COSF = @HAVE_COSF@ +HAVE_COSHF = @HAVE_COSHF@ +HAVE_COSL = @HAVE_COSL@ +HAVE_DECL_ACOSL = @HAVE_DECL_ACOSL@ +HAVE_DECL_ASINL = @HAVE_DECL_ASINL@ +HAVE_DECL_ATANL = @HAVE_DECL_ATANL@ +HAVE_DECL_CBRTF = @HAVE_DECL_CBRTF@ +HAVE_DECL_CBRTL = @HAVE_DECL_CBRTL@ +HAVE_DECL_CEILF = @HAVE_DECL_CEILF@ +HAVE_DECL_CEILL = @HAVE_DECL_CEILL@ +HAVE_DECL_COPYSIGNF = @HAVE_DECL_COPYSIGNF@ +HAVE_DECL_COSL = @HAVE_DECL_COSL@ +HAVE_DECL_ENVIRON = @HAVE_DECL_ENVIRON@ +HAVE_DECL_EXP2 = @HAVE_DECL_EXP2@ +HAVE_DECL_EXP2F = @HAVE_DECL_EXP2F@ +HAVE_DECL_EXP2L = @HAVE_DECL_EXP2L@ +HAVE_DECL_EXPL = @HAVE_DECL_EXPL@ +HAVE_DECL_EXPM1L = @HAVE_DECL_EXPM1L@ +HAVE_DECL_FCHDIR = @HAVE_DECL_FCHDIR@ +HAVE_DECL_FDATASYNC = @HAVE_DECL_FDATASYNC@ +HAVE_DECL_FLOORF = @HAVE_DECL_FLOORF@ +HAVE_DECL_FLOORL = @HAVE_DECL_FLOORL@ +HAVE_DECL_FPURGE = @HAVE_DECL_FPURGE@ +HAVE_DECL_FREXPL = @HAVE_DECL_FREXPL@ +HAVE_DECL_FSEEKO = @HAVE_DECL_FSEEKO@ +HAVE_DECL_FTELLO = @HAVE_DECL_FTELLO@ +HAVE_DECL_GETDELIM = @HAVE_DECL_GETDELIM@ +HAVE_DECL_GETDOMAINNAME = @HAVE_DECL_GETDOMAINNAME@ +HAVE_DECL_GETLINE = @HAVE_DECL_GETLINE@ +HAVE_DECL_GETLOADAVG = @HAVE_DECL_GETLOADAVG@ +HAVE_DECL_GETLOGIN_R = @HAVE_DECL_GETLOGIN_R@ +HAVE_DECL_GETPAGESIZE = @HAVE_DECL_GETPAGESIZE@ +HAVE_DECL_GETUSERSHELL = @HAVE_DECL_GETUSERSHELL@ +HAVE_DECL_IMAXABS = @HAVE_DECL_IMAXABS@ +HAVE_DECL_IMAXDIV = @HAVE_DECL_IMAXDIV@ +HAVE_DECL_LDEXPL = @HAVE_DECL_LDEXPL@ +HAVE_DECL_LOCALTIME_R = @HAVE_DECL_LOCALTIME_R@ +HAVE_DECL_LOG10L = @HAVE_DECL_LOG10L@ +HAVE_DECL_LOG2 = @HAVE_DECL_LOG2@ +HAVE_DECL_LOG2F = @HAVE_DECL_LOG2F@ +HAVE_DECL_LOG2L = @HAVE_DECL_LOG2L@ +HAVE_DECL_LOGB = @HAVE_DECL_LOGB@ +HAVE_DECL_LOGL = @HAVE_DECL_LOGL@ +HAVE_DECL_MEMMEM = @HAVE_DECL_MEMMEM@ +HAVE_DECL_MEMRCHR = @HAVE_DECL_MEMRCHR@ +HAVE_DECL_OBSTACK_PRINTF = @HAVE_DECL_OBSTACK_PRINTF@ +HAVE_DECL_REMAINDER = @HAVE_DECL_REMAINDER@ +HAVE_DECL_REMAINDERL = @HAVE_DECL_REMAINDERL@ +HAVE_DECL_RINTF = @HAVE_DECL_RINTF@ +HAVE_DECL_ROUND = @HAVE_DECL_ROUND@ +HAVE_DECL_ROUNDF = @HAVE_DECL_ROUNDF@ +HAVE_DECL_ROUNDL = @HAVE_DECL_ROUNDL@ +HAVE_DECL_SETENV = @HAVE_DECL_SETENV@ +HAVE_DECL_SETHOSTNAME = @HAVE_DECL_SETHOSTNAME@ +HAVE_DECL_SINL = @HAVE_DECL_SINL@ +HAVE_DECL_SNPRINTF = @HAVE_DECL_SNPRINTF@ +HAVE_DECL_SQRTL = @HAVE_DECL_SQRTL@ +HAVE_DECL_STRDUP = @HAVE_DECL_STRDUP@ +HAVE_DECL_STRERROR_R = @HAVE_DECL_STRERROR_R@ +HAVE_DECL_STRNDUP = @HAVE_DECL_STRNDUP@ +HAVE_DECL_STRNLEN = @HAVE_DECL_STRNLEN@ +HAVE_DECL_STRSIGNAL = @HAVE_DECL_STRSIGNAL@ +HAVE_DECL_STRTOIMAX = @HAVE_DECL_STRTOIMAX@ +HAVE_DECL_STRTOK_R = @HAVE_DECL_STRTOK_R@ +HAVE_DECL_STRTOUMAX = @HAVE_DECL_STRTOUMAX@ +HAVE_DECL_TANL = @HAVE_DECL_TANL@ +HAVE_DECL_TRUNC = @HAVE_DECL_TRUNC@ +HAVE_DECL_TRUNCF = @HAVE_DECL_TRUNCF@ +HAVE_DECL_TRUNCL = @HAVE_DECL_TRUNCL@ +HAVE_DECL_TTYNAME_R = @HAVE_DECL_TTYNAME_R@ +HAVE_DECL_UNSETENV = @HAVE_DECL_UNSETENV@ +HAVE_DECL_VSNPRINTF = @HAVE_DECL_VSNPRINTF@ +HAVE_DECL_WCTOB = @HAVE_DECL_WCTOB@ +HAVE_DECL_WCWIDTH = @HAVE_DECL_WCWIDTH@ +HAVE_DPRINTF = @HAVE_DPRINTF@ +HAVE_DUP2 = @HAVE_DUP2@ +HAVE_DUP3 = @HAVE_DUP3@ +HAVE_EUIDACCESS = @HAVE_EUIDACCESS@ +HAVE_EXPF = @HAVE_EXPF@ +HAVE_EXPL = @HAVE_EXPL@ +HAVE_EXPM1 = @HAVE_EXPM1@ +HAVE_EXPM1F = @HAVE_EXPM1F@ +HAVE_FABSF = @HAVE_FABSF@ +HAVE_FABSL = @HAVE_FABSL@ +HAVE_FACCESSAT = @HAVE_FACCESSAT@ +HAVE_FCHDIR = @HAVE_FCHDIR@ +HAVE_FCHMODAT = @HAVE_FCHMODAT@ +HAVE_FCHOWNAT = @HAVE_FCHOWNAT@ +HAVE_FCNTL = @HAVE_FCNTL@ +HAVE_FDATASYNC = @HAVE_FDATASYNC@ +HAVE_FEATURES_H = @HAVE_FEATURES_H@ +HAVE_FFSL = @HAVE_FFSL@ +HAVE_FFSLL = @HAVE_FFSLL@ +HAVE_FMA = @HAVE_FMA@ +HAVE_FMAF = @HAVE_FMAF@ +HAVE_FMAL = @HAVE_FMAL@ +HAVE_FMODF = @HAVE_FMODF@ +HAVE_FMODL = @HAVE_FMODL@ +HAVE_FREXPF = @HAVE_FREXPF@ +HAVE_FSEEKO = @HAVE_FSEEKO@ +HAVE_FSTATAT = @HAVE_FSTATAT@ +HAVE_FSYNC = @HAVE_FSYNC@ +HAVE_FTELLO = @HAVE_FTELLO@ +HAVE_FTRUNCATE = @HAVE_FTRUNCATE@ +HAVE_FUTIMENS = @HAVE_FUTIMENS@ +HAVE_GCJ_C = @HAVE_GCJ_C@ +HAVE_GCJ_IN_PATH = @HAVE_GCJ_IN_PATH@ +HAVE_GETDTABLESIZE = @HAVE_GETDTABLESIZE@ +HAVE_GETGROUPS = @HAVE_GETGROUPS@ +HAVE_GETHOSTNAME = @HAVE_GETHOSTNAME@ +HAVE_GETLOGIN = @HAVE_GETLOGIN@ +HAVE_GETOPT_H = @HAVE_GETOPT_H@ +HAVE_GETPAGESIZE = @HAVE_GETPAGESIZE@ +HAVE_GETSUBOPT = @HAVE_GETSUBOPT@ +HAVE_GIJ = @HAVE_GIJ@ +HAVE_GIJ_IN_PATH = @HAVE_GIJ_IN_PATH@ +HAVE_GRANTPT = @HAVE_GRANTPT@ +HAVE_GROUP_MEMBER = @HAVE_GROUP_MEMBER@ +HAVE_HYPOTF = @HAVE_HYPOTF@ +HAVE_HYPOTL = @HAVE_HYPOTL@ +HAVE_ILOGB = @HAVE_ILOGB@ +HAVE_ILOGBF = @HAVE_ILOGBF@ +HAVE_ILOGBL = @HAVE_ILOGBL@ +HAVE_INTTYPES_H = @HAVE_INTTYPES_H@ +HAVE_ISNAND = @HAVE_ISNAND@ +HAVE_ISNANF = @HAVE_ISNANF@ +HAVE_ISNANL = @HAVE_ISNANL@ +HAVE_ISWBLANK = @HAVE_ISWBLANK@ +HAVE_ISWCNTRL = @HAVE_ISWCNTRL@ +HAVE_JAVA = @HAVE_JAVA@ +HAVE_JAVAC = @HAVE_JAVAC@ +HAVE_JAVAC_ENVVAR = @HAVE_JAVAC_ENVVAR@ +HAVE_JAVAC_IN_PATH = @HAVE_JAVAC_IN_PATH@ +HAVE_JAVA_ENVVAR = @HAVE_JAVA_ENVVAR@ +HAVE_JAVA_IN_PATH = @HAVE_JAVA_IN_PATH@ +HAVE_JIKES = @HAVE_JIKES@ +HAVE_JIKES_IN_PATH = @HAVE_JIKES_IN_PATH@ +HAVE_JRE = @HAVE_JRE@ +HAVE_JRE_IN_PATH = @HAVE_JRE_IN_PATH@ +HAVE_JVIEW = @HAVE_JVIEW@ +HAVE_JVIEW_IN_PATH = @HAVE_JVIEW_IN_PATH@ +HAVE_LCHMOD = @HAVE_LCHMOD@ +HAVE_LCHOWN = @HAVE_LCHOWN@ +HAVE_LDEXPF = @HAVE_LDEXPF@ +HAVE_LINK = @HAVE_LINK@ +HAVE_LINKAT = @HAVE_LINKAT@ +HAVE_LOG10F = @HAVE_LOG10F@ +HAVE_LOG10L = @HAVE_LOG10L@ +HAVE_LOG1P = @HAVE_LOG1P@ +HAVE_LOG1PF = @HAVE_LOG1PF@ +HAVE_LOG1PL = @HAVE_LOG1PL@ +HAVE_LOGBF = @HAVE_LOGBF@ +HAVE_LOGBL = @HAVE_LOGBL@ +HAVE_LOGF = @HAVE_LOGF@ +HAVE_LOGL = @HAVE_LOGL@ +HAVE_LONG_LONG_INT = @HAVE_LONG_LONG_INT@ +HAVE_LSTAT = @HAVE_LSTAT@ +HAVE_MBRLEN = @HAVE_MBRLEN@ +HAVE_MBRTOWC = @HAVE_MBRTOWC@ +HAVE_MBSINIT = @HAVE_MBSINIT@ +HAVE_MBSLEN = @HAVE_MBSLEN@ +HAVE_MBSNRTOWCS = @HAVE_MBSNRTOWCS@ +HAVE_MBSRTOWCS = @HAVE_MBSRTOWCS@ +HAVE_MEMCHR = @HAVE_MEMCHR@ +HAVE_MEMPCPY = @HAVE_MEMPCPY@ +HAVE_MKDIRAT = @HAVE_MKDIRAT@ +HAVE_MKDTEMP = @HAVE_MKDTEMP@ +HAVE_MKFIFO = @HAVE_MKFIFO@ +HAVE_MKFIFOAT = @HAVE_MKFIFOAT@ +HAVE_MKNOD = @HAVE_MKNOD@ +HAVE_MKNODAT = @HAVE_MKNODAT@ +HAVE_MKOSTEMP = @HAVE_MKOSTEMP@ +HAVE_MKOSTEMPS = @HAVE_MKOSTEMPS@ +HAVE_MKSTEMP = @HAVE_MKSTEMP@ +HAVE_MKSTEMPS = @HAVE_MKSTEMPS@ +HAVE_MODFF = @HAVE_MODFF@ +HAVE_MODFL = @HAVE_MODFL@ +HAVE_MSVC_INVALID_PARAMETER_HANDLER = @HAVE_MSVC_INVALID_PARAMETER_HANDLER@ +HAVE_NANOSLEEP = @HAVE_NANOSLEEP@ +HAVE_OPENAT = @HAVE_OPENAT@ +HAVE_OS_H = @HAVE_OS_H@ +HAVE_PCLOSE = @HAVE_PCLOSE@ +HAVE_PIPE = @HAVE_PIPE@ +HAVE_PIPE2 = @HAVE_PIPE2@ +HAVE_POPEN = @HAVE_POPEN@ +HAVE_POSIX_OPENPT = @HAVE_POSIX_OPENPT@ +HAVE_POSIX_SIGNALBLOCKING = @HAVE_POSIX_SIGNALBLOCKING@ +HAVE_POSIX_SPAWN = @HAVE_POSIX_SPAWN@ +HAVE_POSIX_SPAWNATTR_T = @HAVE_POSIX_SPAWNATTR_T@ +HAVE_POSIX_SPAWN_FILE_ACTIONS_T = @HAVE_POSIX_SPAWN_FILE_ACTIONS_T@ +HAVE_POWF = @HAVE_POWF@ +HAVE_PREAD = @HAVE_PREAD@ +HAVE_PTHREAD_SIGMASK = @HAVE_PTHREAD_SIGMASK@ +HAVE_PTSNAME = @HAVE_PTSNAME@ +HAVE_PTSNAME_R = @HAVE_PTSNAME_R@ +HAVE_PWRITE = @HAVE_PWRITE@ +HAVE_RAISE = @HAVE_RAISE@ +HAVE_RANDOM = @HAVE_RANDOM@ +HAVE_RANDOM_H = @HAVE_RANDOM_H@ +HAVE_RANDOM_R = @HAVE_RANDOM_R@ +HAVE_RAWMEMCHR = @HAVE_RAWMEMCHR@ +HAVE_READLINK = @HAVE_READLINK@ +HAVE_READLINKAT = @HAVE_READLINKAT@ +HAVE_REALPATH = @HAVE_REALPATH@ +HAVE_REMAINDER = @HAVE_REMAINDER@ +HAVE_REMAINDERF = @HAVE_REMAINDERF@ +HAVE_RENAMEAT = @HAVE_RENAMEAT@ +HAVE_RINT = @HAVE_RINT@ +HAVE_RINTL = @HAVE_RINTL@ +HAVE_RPMATCH = @HAVE_RPMATCH@ +HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = @HAVE_SAME_LONG_DOUBLE_AS_DOUBLE@ +HAVE_SCHED_H = @HAVE_SCHED_H@ +HAVE_SETENV = @HAVE_SETENV@ +HAVE_SETHOSTNAME = @HAVE_SETHOSTNAME@ +HAVE_SIGACTION = @HAVE_SIGACTION@ +HAVE_SIGHANDLER_T = @HAVE_SIGHANDLER_T@ +HAVE_SIGINFO_T = @HAVE_SIGINFO_T@ +HAVE_SIGNED_SIG_ATOMIC_T = @HAVE_SIGNED_SIG_ATOMIC_T@ +HAVE_SIGNED_WCHAR_T = @HAVE_SIGNED_WCHAR_T@ +HAVE_SIGNED_WINT_T = @HAVE_SIGNED_WINT_T@ +HAVE_SIGSET_T = @HAVE_SIGSET_T@ +HAVE_SINF = @HAVE_SINF@ +HAVE_SINHF = @HAVE_SINHF@ +HAVE_SINL = @HAVE_SINL@ +HAVE_SLEEP = @HAVE_SLEEP@ +HAVE_SPAWN_H = @HAVE_SPAWN_H@ +HAVE_SQRTF = @HAVE_SQRTF@ +HAVE_SQRTL = @HAVE_SQRTL@ +HAVE_STDINT_H = @HAVE_STDINT_H@ +HAVE_STPCPY = @HAVE_STPCPY@ +HAVE_STPNCPY = @HAVE_STPNCPY@ +HAVE_STRCASESTR = @HAVE_STRCASESTR@ +HAVE_STRCHRNUL = @HAVE_STRCHRNUL@ +HAVE_STRPBRK = @HAVE_STRPBRK@ +HAVE_STRPTIME = @HAVE_STRPTIME@ +HAVE_STRSEP = @HAVE_STRSEP@ +HAVE_STRTOD = @HAVE_STRTOD@ +HAVE_STRTOLL = @HAVE_STRTOLL@ +HAVE_STRTOULL = @HAVE_STRTOULL@ +HAVE_STRUCT_RANDOM_DATA = @HAVE_STRUCT_RANDOM_DATA@ +HAVE_STRUCT_SCHED_PARAM = @HAVE_STRUCT_SCHED_PARAM@ +HAVE_STRUCT_SIGACTION_SA_SIGACTION = @HAVE_STRUCT_SIGACTION_SA_SIGACTION@ +HAVE_STRVERSCMP = @HAVE_STRVERSCMP@ +HAVE_SYMLINK = @HAVE_SYMLINK@ +HAVE_SYMLINKAT = @HAVE_SYMLINKAT@ +HAVE_SYS_BITYPES_H = @HAVE_SYS_BITYPES_H@ +HAVE_SYS_INTTYPES_H = @HAVE_SYS_INTTYPES_H@ +HAVE_SYS_LOADAVG_H = @HAVE_SYS_LOADAVG_H@ +HAVE_SYS_PARAM_H = @HAVE_SYS_PARAM_H@ +HAVE_SYS_TYPES_H = @HAVE_SYS_TYPES_H@ +HAVE_TANF = @HAVE_TANF@ +HAVE_TANHF = @HAVE_TANHF@ +HAVE_TANL = @HAVE_TANL@ +HAVE_TIMEGM = @HAVE_TIMEGM@ +HAVE_TYPE_VOLATILE_SIG_ATOMIC_T = @HAVE_TYPE_VOLATILE_SIG_ATOMIC_T@ +HAVE_UNISTD_H = @HAVE_UNISTD_H@ +HAVE_UNLINKAT = @HAVE_UNLINKAT@ +HAVE_UNLOCKPT = @HAVE_UNLOCKPT@ +HAVE_UNSIGNED_LONG_LONG_INT = @HAVE_UNSIGNED_LONG_LONG_INT@ +HAVE_USLEEP = @HAVE_USLEEP@ +HAVE_UTIMENSAT = @HAVE_UTIMENSAT@ +HAVE_VASPRINTF = @HAVE_VASPRINTF@ +HAVE_VDPRINTF = @HAVE_VDPRINTF@ +HAVE_WCHAR_H = @HAVE_WCHAR_H@ +HAVE_WCHAR_T = @HAVE_WCHAR_T@ +HAVE_WCPCPY = @HAVE_WCPCPY@ +HAVE_WCPNCPY = @HAVE_WCPNCPY@ +HAVE_WCRTOMB = @HAVE_WCRTOMB@ +HAVE_WCSCASECMP = @HAVE_WCSCASECMP@ +HAVE_WCSCAT = @HAVE_WCSCAT@ +HAVE_WCSCHR = @HAVE_WCSCHR@ +HAVE_WCSCMP = @HAVE_WCSCMP@ +HAVE_WCSCOLL = @HAVE_WCSCOLL@ +HAVE_WCSCPY = @HAVE_WCSCPY@ +HAVE_WCSCSPN = @HAVE_WCSCSPN@ +HAVE_WCSDUP = @HAVE_WCSDUP@ +HAVE_WCSLEN = @HAVE_WCSLEN@ +HAVE_WCSNCASECMP = @HAVE_WCSNCASECMP@ +HAVE_WCSNCAT = @HAVE_WCSNCAT@ +HAVE_WCSNCMP = @HAVE_WCSNCMP@ +HAVE_WCSNCPY = @HAVE_WCSNCPY@ +HAVE_WCSNLEN = @HAVE_WCSNLEN@ +HAVE_WCSNRTOMBS = @HAVE_WCSNRTOMBS@ +HAVE_WCSPBRK = @HAVE_WCSPBRK@ +HAVE_WCSRCHR = @HAVE_WCSRCHR@ +HAVE_WCSRTOMBS = @HAVE_WCSRTOMBS@ +HAVE_WCSSPN = @HAVE_WCSSPN@ +HAVE_WCSSTR = @HAVE_WCSSTR@ +HAVE_WCSTOK = @HAVE_WCSTOK@ +HAVE_WCSWIDTH = @HAVE_WCSWIDTH@ +HAVE_WCSXFRM = @HAVE_WCSXFRM@ +HAVE_WCTRANS_T = @HAVE_WCTRANS_T@ +HAVE_WCTYPE_H = @HAVE_WCTYPE_H@ +HAVE_WCTYPE_T = @HAVE_WCTYPE_T@ +HAVE_WINSOCK2_H = @HAVE_WINSOCK2_H@ +HAVE_WINT_T = @HAVE_WINT_T@ +HAVE_WMEMCHR = @HAVE_WMEMCHR@ +HAVE_WMEMCMP = @HAVE_WMEMCMP@ +HAVE_WMEMCPY = @HAVE_WMEMCPY@ +HAVE_WMEMMOVE = @HAVE_WMEMMOVE@ +HAVE_WMEMSET = @HAVE_WMEMSET@ +HAVE__BOOL = @HAVE__BOOL@ +HAVE__EXIT = @HAVE__EXIT@ +HELP2MAN = @HELP2MAN@ +INCLUDE_NEXT = @INCLUDE_NEXT@ +INCLUDE_NEXT_AS_FIRST_DIRECTIVE = @INCLUDE_NEXT_AS_FIRST_DIRECTIVE@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +INT32_MAX_LT_INTMAX_MAX = @INT32_MAX_LT_INTMAX_MAX@ +INT64_MAX_EQ_LONG_MAX = @INT64_MAX_EQ_LONG_MAX@ +INTLLIBS = @INTLLIBS@ +INTL_MACOSX_LIBS = @INTL_MACOSX_LIBS@ +ISNAND_LIBM = @ISNAND_LIBM@ +ISNANF_LIBM = @ISNANF_LIBM@ +ISNANL_LIBM = @ISNANL_LIBM@ +ISNAN_LIBM = @ISNAN_LIBM@ +LDEXPL_LIBM = @LDEXPL_LIBM@ +LDEXP_LIBM = @LDEXP_LIBM@ +LDFLAGS = @LDFLAGS@ +LEX = @LEX@ +LEXLIB = @LEXLIB@ +LEX_IS_FLEX = @LEX_IS_FLEX@ +LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ +LIBBISON_LIBDEPS = @LIBBISON_LIBDEPS@ +LIBBISON_LTLIBDEPS = @LIBBISON_LTLIBDEPS@ +LIBICONV = @LIBICONV@ +LIBINTL = @LIBINTL@ +LIBMULTITHREAD = @LIBMULTITHREAD@ +LIBOBJS = @LIBOBJS@ +LIBPTH = @LIBPTH@ +LIBPTH_PREFIX = @LIBPTH_PREFIX@ +LIBS = @LIBS@ +LIBTHREAD = @LIBTHREAD@ +LIBUNISTRING_UNITYPES_H = @LIBUNISTRING_UNITYPES_H@ +LIBUNISTRING_UNIWIDTH_H = @LIBUNISTRING_UNIWIDTH_H@ +LOCALCHARSET_TESTS_ENVIRONMENT = @LOCALCHARSET_TESTS_ENVIRONMENT@ +LOCALE_FR_UTF8 = @LOCALE_FR_UTF8@ +LOCALE_JA = @LOCALE_JA@ +LOCALE_ZH_CN = @LOCALE_ZH_CN@ +LTLIBICONV = @LTLIBICONV@ +LTLIBINTL = @LTLIBINTL@ +LTLIBMULTITHREAD = @LTLIBMULTITHREAD@ +LTLIBOBJS = @LTLIBOBJS@ +LTLIBPTH = @LTLIBPTH@ +LTLIBTHREAD = @LTLIBTHREAD@ +M4 = @M4@ +M4_DEBUGFILE = @M4_DEBUGFILE@ +M4_GNU = @M4_GNU@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +MSGFMT = @MSGFMT@ +MSGFMT_015 = @MSGFMT_015@ +MSGMERGE = @MSGMERGE@ +NEXT_AS_FIRST_DIRECTIVE_ERRNO_H = @NEXT_AS_FIRST_DIRECTIVE_ERRNO_H@ +NEXT_AS_FIRST_DIRECTIVE_FCNTL_H = @NEXT_AS_FIRST_DIRECTIVE_FCNTL_H@ +NEXT_AS_FIRST_DIRECTIVE_FLOAT_H = @NEXT_AS_FIRST_DIRECTIVE_FLOAT_H@ +NEXT_AS_FIRST_DIRECTIVE_GETOPT_H = @NEXT_AS_FIRST_DIRECTIVE_GETOPT_H@ +NEXT_AS_FIRST_DIRECTIVE_INTTYPES_H = @NEXT_AS_FIRST_DIRECTIVE_INTTYPES_H@ +NEXT_AS_FIRST_DIRECTIVE_MATH_H = @NEXT_AS_FIRST_DIRECTIVE_MATH_H@ +NEXT_AS_FIRST_DIRECTIVE_SCHED_H = @NEXT_AS_FIRST_DIRECTIVE_SCHED_H@ +NEXT_AS_FIRST_DIRECTIVE_SIGNAL_H = @NEXT_AS_FIRST_DIRECTIVE_SIGNAL_H@ +NEXT_AS_FIRST_DIRECTIVE_SPAWN_H = @NEXT_AS_FIRST_DIRECTIVE_SPAWN_H@ +NEXT_AS_FIRST_DIRECTIVE_STDDEF_H = @NEXT_AS_FIRST_DIRECTIVE_STDDEF_H@ +NEXT_AS_FIRST_DIRECTIVE_STDINT_H = @NEXT_AS_FIRST_DIRECTIVE_STDINT_H@ +NEXT_AS_FIRST_DIRECTIVE_STDIO_H = @NEXT_AS_FIRST_DIRECTIVE_STDIO_H@ +NEXT_AS_FIRST_DIRECTIVE_STDLIB_H = @NEXT_AS_FIRST_DIRECTIVE_STDLIB_H@ +NEXT_AS_FIRST_DIRECTIVE_STRING_H = @NEXT_AS_FIRST_DIRECTIVE_STRING_H@ +NEXT_AS_FIRST_DIRECTIVE_SYS_STAT_H = @NEXT_AS_FIRST_DIRECTIVE_SYS_STAT_H@ +NEXT_AS_FIRST_DIRECTIVE_SYS_TYPES_H = @NEXT_AS_FIRST_DIRECTIVE_SYS_TYPES_H@ +NEXT_AS_FIRST_DIRECTIVE_SYS_WAIT_H = @NEXT_AS_FIRST_DIRECTIVE_SYS_WAIT_H@ +NEXT_AS_FIRST_DIRECTIVE_TIME_H = @NEXT_AS_FIRST_DIRECTIVE_TIME_H@ +NEXT_AS_FIRST_DIRECTIVE_UNISTD_H = @NEXT_AS_FIRST_DIRECTIVE_UNISTD_H@ +NEXT_AS_FIRST_DIRECTIVE_WCHAR_H = @NEXT_AS_FIRST_DIRECTIVE_WCHAR_H@ +NEXT_AS_FIRST_DIRECTIVE_WCTYPE_H = @NEXT_AS_FIRST_DIRECTIVE_WCTYPE_H@ +NEXT_ERRNO_H = @NEXT_ERRNO_H@ +NEXT_FCNTL_H = @NEXT_FCNTL_H@ +NEXT_FLOAT_H = @NEXT_FLOAT_H@ +NEXT_GETOPT_H = @NEXT_GETOPT_H@ +NEXT_INTTYPES_H = @NEXT_INTTYPES_H@ +NEXT_MATH_H = @NEXT_MATH_H@ +NEXT_SCHED_H = @NEXT_SCHED_H@ +NEXT_SIGNAL_H = @NEXT_SIGNAL_H@ +NEXT_SPAWN_H = @NEXT_SPAWN_H@ +NEXT_STDDEF_H = @NEXT_STDDEF_H@ +NEXT_STDINT_H = @NEXT_STDINT_H@ +NEXT_STDIO_H = @NEXT_STDIO_H@ +NEXT_STDLIB_H = @NEXT_STDLIB_H@ +NEXT_STRING_H = @NEXT_STRING_H@ +NEXT_SYS_STAT_H = @NEXT_SYS_STAT_H@ +NEXT_SYS_TYPES_H = @NEXT_SYS_TYPES_H@ +NEXT_SYS_WAIT_H = @NEXT_SYS_WAIT_H@ +NEXT_TIME_H = @NEXT_TIME_H@ +NEXT_UNISTD_H = @NEXT_UNISTD_H@ +NEXT_WCHAR_H = @NEXT_WCHAR_H@ +NEXT_WCTYPE_H = @NEXT_WCTYPE_H@ +OBJEXT = @OBJEXT@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_COPYRIGHT_YEAR = @PACKAGE_COPYRIGHT_YEAR@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PERL = @PERL@ +POSUB = @POSUB@ +PRAGMA_COLUMNS = @PRAGMA_COLUMNS@ +PRAGMA_SYSTEM_HEADER = @PRAGMA_SYSTEM_HEADER@ +PRIPTR_PREFIX = @PRIPTR_PREFIX@ +PRI_MACROS_BROKEN = @PRI_MACROS_BROKEN@ +PTHREAD_H_DEFINES_STRUCT_TIMESPEC = @PTHREAD_H_DEFINES_STRUCT_TIMESPEC@ +PTRDIFF_T_SUFFIX = @PTRDIFF_T_SUFFIX@ +RANLIB = @RANLIB@ +REPLACE_BTOWC = @REPLACE_BTOWC@ +REPLACE_CALLOC = @REPLACE_CALLOC@ +REPLACE_CANONICALIZE_FILE_NAME = @REPLACE_CANONICALIZE_FILE_NAME@ +REPLACE_CBRTF = @REPLACE_CBRTF@ +REPLACE_CBRTL = @REPLACE_CBRTL@ +REPLACE_CEIL = @REPLACE_CEIL@ +REPLACE_CEILF = @REPLACE_CEILF@ +REPLACE_CEILL = @REPLACE_CEILL@ +REPLACE_CHOWN = @REPLACE_CHOWN@ +REPLACE_CLOSE = @REPLACE_CLOSE@ +REPLACE_DPRINTF = @REPLACE_DPRINTF@ +REPLACE_DUP = @REPLACE_DUP@ +REPLACE_DUP2 = @REPLACE_DUP2@ +REPLACE_EXP2 = @REPLACE_EXP2@ +REPLACE_EXP2L = @REPLACE_EXP2L@ +REPLACE_EXPM1 = @REPLACE_EXPM1@ +REPLACE_EXPM1F = @REPLACE_EXPM1F@ +REPLACE_FABSL = @REPLACE_FABSL@ +REPLACE_FCHOWNAT = @REPLACE_FCHOWNAT@ +REPLACE_FCLOSE = @REPLACE_FCLOSE@ +REPLACE_FCNTL = @REPLACE_FCNTL@ +REPLACE_FDOPEN = @REPLACE_FDOPEN@ +REPLACE_FFLUSH = @REPLACE_FFLUSH@ +REPLACE_FLOOR = @REPLACE_FLOOR@ +REPLACE_FLOORF = @REPLACE_FLOORF@ +REPLACE_FLOORL = @REPLACE_FLOORL@ +REPLACE_FMA = @REPLACE_FMA@ +REPLACE_FMAF = @REPLACE_FMAF@ +REPLACE_FMAL = @REPLACE_FMAL@ +REPLACE_FMOD = @REPLACE_FMOD@ +REPLACE_FMODF = @REPLACE_FMODF@ +REPLACE_FMODL = @REPLACE_FMODL@ +REPLACE_FOPEN = @REPLACE_FOPEN@ +REPLACE_FPRINTF = @REPLACE_FPRINTF@ +REPLACE_FPURGE = @REPLACE_FPURGE@ +REPLACE_FREOPEN = @REPLACE_FREOPEN@ +REPLACE_FREXP = @REPLACE_FREXP@ +REPLACE_FREXPF = @REPLACE_FREXPF@ +REPLACE_FREXPL = @REPLACE_FREXPL@ +REPLACE_FSEEK = @REPLACE_FSEEK@ +REPLACE_FSEEKO = @REPLACE_FSEEKO@ +REPLACE_FSTAT = @REPLACE_FSTAT@ +REPLACE_FSTATAT = @REPLACE_FSTATAT@ +REPLACE_FTELL = @REPLACE_FTELL@ +REPLACE_FTELLO = @REPLACE_FTELLO@ +REPLACE_FTRUNCATE = @REPLACE_FTRUNCATE@ +REPLACE_FUTIMENS = @REPLACE_FUTIMENS@ +REPLACE_GETCWD = @REPLACE_GETCWD@ +REPLACE_GETDELIM = @REPLACE_GETDELIM@ +REPLACE_GETDOMAINNAME = @REPLACE_GETDOMAINNAME@ +REPLACE_GETGROUPS = @REPLACE_GETGROUPS@ +REPLACE_GETLINE = @REPLACE_GETLINE@ +REPLACE_GETLOGIN_R = @REPLACE_GETLOGIN_R@ +REPLACE_GETPAGESIZE = @REPLACE_GETPAGESIZE@ +REPLACE_HUGE_VAL = @REPLACE_HUGE_VAL@ +REPLACE_HYPOT = @REPLACE_HYPOT@ +REPLACE_HYPOTF = @REPLACE_HYPOTF@ +REPLACE_HYPOTL = @REPLACE_HYPOTL@ +REPLACE_ILOGB = @REPLACE_ILOGB@ +REPLACE_ILOGBF = @REPLACE_ILOGBF@ +REPLACE_ISATTY = @REPLACE_ISATTY@ +REPLACE_ISFINITE = @REPLACE_ISFINITE@ +REPLACE_ISINF = @REPLACE_ISINF@ +REPLACE_ISNAN = @REPLACE_ISNAN@ +REPLACE_ISWBLANK = @REPLACE_ISWBLANK@ +REPLACE_ISWCNTRL = @REPLACE_ISWCNTRL@ +REPLACE_ITOLD = @REPLACE_ITOLD@ +REPLACE_LCHOWN = @REPLACE_LCHOWN@ +REPLACE_LDEXPL = @REPLACE_LDEXPL@ +REPLACE_LINK = @REPLACE_LINK@ +REPLACE_LINKAT = @REPLACE_LINKAT@ +REPLACE_LOCALTIME_R = @REPLACE_LOCALTIME_R@ +REPLACE_LOG = @REPLACE_LOG@ +REPLACE_LOG10 = @REPLACE_LOG10@ +REPLACE_LOG10F = @REPLACE_LOG10F@ +REPLACE_LOG10L = @REPLACE_LOG10L@ +REPLACE_LOG1P = @REPLACE_LOG1P@ +REPLACE_LOG1PF = @REPLACE_LOG1PF@ +REPLACE_LOG1PL = @REPLACE_LOG1PL@ +REPLACE_LOG2 = @REPLACE_LOG2@ +REPLACE_LOG2F = @REPLACE_LOG2F@ +REPLACE_LOG2L = @REPLACE_LOG2L@ +REPLACE_LOGB = @REPLACE_LOGB@ +REPLACE_LOGBF = @REPLACE_LOGBF@ +REPLACE_LOGBL = @REPLACE_LOGBL@ +REPLACE_LOGF = @REPLACE_LOGF@ +REPLACE_LOGL = @REPLACE_LOGL@ +REPLACE_LSEEK = @REPLACE_LSEEK@ +REPLACE_LSTAT = @REPLACE_LSTAT@ +REPLACE_MALLOC = @REPLACE_MALLOC@ +REPLACE_MBRLEN = @REPLACE_MBRLEN@ +REPLACE_MBRTOWC = @REPLACE_MBRTOWC@ +REPLACE_MBSINIT = @REPLACE_MBSINIT@ +REPLACE_MBSNRTOWCS = @REPLACE_MBSNRTOWCS@ +REPLACE_MBSRTOWCS = @REPLACE_MBSRTOWCS@ +REPLACE_MBSTATE_T = @REPLACE_MBSTATE_T@ +REPLACE_MBTOWC = @REPLACE_MBTOWC@ +REPLACE_MEMCHR = @REPLACE_MEMCHR@ +REPLACE_MEMMEM = @REPLACE_MEMMEM@ +REPLACE_MKDIR = @REPLACE_MKDIR@ +REPLACE_MKFIFO = @REPLACE_MKFIFO@ +REPLACE_MKNOD = @REPLACE_MKNOD@ +REPLACE_MKSTEMP = @REPLACE_MKSTEMP@ +REPLACE_MKTIME = @REPLACE_MKTIME@ +REPLACE_MODF = @REPLACE_MODF@ +REPLACE_MODFF = @REPLACE_MODFF@ +REPLACE_MODFL = @REPLACE_MODFL@ +REPLACE_NAN = @REPLACE_NAN@ +REPLACE_NANOSLEEP = @REPLACE_NANOSLEEP@ +REPLACE_NULL = @REPLACE_NULL@ +REPLACE_OBSTACK_PRINTF = @REPLACE_OBSTACK_PRINTF@ +REPLACE_OPEN = @REPLACE_OPEN@ +REPLACE_OPENAT = @REPLACE_OPENAT@ +REPLACE_PERROR = @REPLACE_PERROR@ +REPLACE_POPEN = @REPLACE_POPEN@ +REPLACE_POSIX_SPAWN = @REPLACE_POSIX_SPAWN@ +REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE = @REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE@ +REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 = @REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2@ +REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN = @REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN@ +REPLACE_PREAD = @REPLACE_PREAD@ +REPLACE_PRINTF = @REPLACE_PRINTF@ +REPLACE_PTHREAD_SIGMASK = @REPLACE_PTHREAD_SIGMASK@ +REPLACE_PTSNAME = @REPLACE_PTSNAME@ +REPLACE_PTSNAME_R = @REPLACE_PTSNAME_R@ +REPLACE_PUTENV = @REPLACE_PUTENV@ +REPLACE_PWRITE = @REPLACE_PWRITE@ +REPLACE_RAISE = @REPLACE_RAISE@ +REPLACE_RANDOM_R = @REPLACE_RANDOM_R@ +REPLACE_READ = @REPLACE_READ@ +REPLACE_READLINK = @REPLACE_READLINK@ +REPLACE_REALLOC = @REPLACE_REALLOC@ +REPLACE_REALPATH = @REPLACE_REALPATH@ +REPLACE_REMAINDER = @REPLACE_REMAINDER@ +REPLACE_REMAINDERF = @REPLACE_REMAINDERF@ +REPLACE_REMAINDERL = @REPLACE_REMAINDERL@ +REPLACE_REMOVE = @REPLACE_REMOVE@ +REPLACE_RENAME = @REPLACE_RENAME@ +REPLACE_RENAMEAT = @REPLACE_RENAMEAT@ +REPLACE_RMDIR = @REPLACE_RMDIR@ +REPLACE_ROUND = @REPLACE_ROUND@ +REPLACE_ROUNDF = @REPLACE_ROUNDF@ +REPLACE_ROUNDL = @REPLACE_ROUNDL@ +REPLACE_SETENV = @REPLACE_SETENV@ +REPLACE_SIGNBIT = @REPLACE_SIGNBIT@ +REPLACE_SIGNBIT_USING_GCC = @REPLACE_SIGNBIT_USING_GCC@ +REPLACE_SLEEP = @REPLACE_SLEEP@ +REPLACE_SNPRINTF = @REPLACE_SNPRINTF@ +REPLACE_SPRINTF = @REPLACE_SPRINTF@ +REPLACE_SQRTL = @REPLACE_SQRTL@ +REPLACE_STAT = @REPLACE_STAT@ +REPLACE_STDIO_READ_FUNCS = @REPLACE_STDIO_READ_FUNCS@ +REPLACE_STDIO_WRITE_FUNCS = @REPLACE_STDIO_WRITE_FUNCS@ +REPLACE_STPNCPY = @REPLACE_STPNCPY@ +REPLACE_STRCASESTR = @REPLACE_STRCASESTR@ +REPLACE_STRCHRNUL = @REPLACE_STRCHRNUL@ +REPLACE_STRDUP = @REPLACE_STRDUP@ +REPLACE_STRERROR = @REPLACE_STRERROR@ +REPLACE_STRERROR_R = @REPLACE_STRERROR_R@ +REPLACE_STRNCAT = @REPLACE_STRNCAT@ +REPLACE_STRNDUP = @REPLACE_STRNDUP@ +REPLACE_STRNLEN = @REPLACE_STRNLEN@ +REPLACE_STRSIGNAL = @REPLACE_STRSIGNAL@ +REPLACE_STRSTR = @REPLACE_STRSTR@ +REPLACE_STRTOD = @REPLACE_STRTOD@ +REPLACE_STRTOIMAX = @REPLACE_STRTOIMAX@ +REPLACE_STRTOK_R = @REPLACE_STRTOK_R@ +REPLACE_SYMLINK = @REPLACE_SYMLINK@ +REPLACE_TIMEGM = @REPLACE_TIMEGM@ +REPLACE_TMPFILE = @REPLACE_TMPFILE@ +REPLACE_TOWLOWER = @REPLACE_TOWLOWER@ +REPLACE_TRUNC = @REPLACE_TRUNC@ +REPLACE_TRUNCF = @REPLACE_TRUNCF@ +REPLACE_TRUNCL = @REPLACE_TRUNCL@ +REPLACE_TTYNAME_R = @REPLACE_TTYNAME_R@ +REPLACE_UNLINK = @REPLACE_UNLINK@ +REPLACE_UNLINKAT = @REPLACE_UNLINKAT@ +REPLACE_UNSETENV = @REPLACE_UNSETENV@ +REPLACE_USLEEP = @REPLACE_USLEEP@ +REPLACE_UTIMENSAT = @REPLACE_UTIMENSAT@ +REPLACE_VASPRINTF = @REPLACE_VASPRINTF@ +REPLACE_VDPRINTF = @REPLACE_VDPRINTF@ +REPLACE_VFPRINTF = @REPLACE_VFPRINTF@ +REPLACE_VPRINTF = @REPLACE_VPRINTF@ +REPLACE_VSNPRINTF = @REPLACE_VSNPRINTF@ +REPLACE_VSPRINTF = @REPLACE_VSPRINTF@ +REPLACE_WCRTOMB = @REPLACE_WCRTOMB@ +REPLACE_WCSNRTOMBS = @REPLACE_WCSNRTOMBS@ +REPLACE_WCSRTOMBS = @REPLACE_WCSRTOMBS@ +REPLACE_WCSWIDTH = @REPLACE_WCSWIDTH@ +REPLACE_WCTOB = @REPLACE_WCTOB@ +REPLACE_WCTOMB = @REPLACE_WCTOMB@ +REPLACE_WCWIDTH = @REPLACE_WCWIDTH@ +REPLACE_WRITE = @REPLACE_WRITE@ +SCHED_H = @SCHED_H@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +SIG_ATOMIC_T_SUFFIX = @SIG_ATOMIC_T_SUFFIX@ +SIZE_T_SUFFIX = @SIZE_T_SUFFIX@ +STDBOOL_H = @STDBOOL_H@ +STDDEF_H = @STDDEF_H@ +STDINT_H = @STDINT_H@ +STRIP = @STRIP@ +SYS_TIME_H_DEFINES_STRUCT_TIMESPEC = @SYS_TIME_H_DEFINES_STRUCT_TIMESPEC@ +TIME_H_DEFINES_STRUCT_TIMESPEC = @TIME_H_DEFINES_STRUCT_TIMESPEC@ +UINT32_MAX_LT_UINTMAX_MAX = @UINT32_MAX_LT_UINTMAX_MAX@ +UINT64_MAX_EQ_ULONG_MAX = @UINT64_MAX_EQ_ULONG_MAX@ +UNDEFINE_STRTOK_R = @UNDEFINE_STRTOK_R@ +UNISTD_H_HAVE_WINSOCK2_H = @UNISTD_H_HAVE_WINSOCK2_H@ +UNISTD_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS = @UNISTD_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS@ +USE_NLS = @USE_NLS@ +VALGRIND = @VALGRIND@ +VALGRIND_PREBISON = @VALGRIND_PREBISON@ +VERSION = @VERSION@ +WARN_CFLAGS = @WARN_CFLAGS@ +WARN_CFLAGS_TEST = @WARN_CFLAGS_TEST@ +WARN_CXXFLAGS = @WARN_CXXFLAGS@ +WARN_CXXFLAGS_TEST = @WARN_CXXFLAGS_TEST@ +WCHAR_T_SUFFIX = @WCHAR_T_SUFFIX@ +WERROR_CFLAGS = @WERROR_CFLAGS@ +WERROR_CXXFLAGS = @WERROR_CXXFLAGS@ +WINDOWS_64_BIT_OFF_T = @WINDOWS_64_BIT_OFF_T@ +WINDOWS_64_BIT_ST_SIZE = @WINDOWS_64_BIT_ST_SIZE@ +WINT_T_SUFFIX = @WINT_T_SUFFIX@ +XGETTEXT = @XGETTEXT@ +XGETTEXT_015 = @XGETTEXT_015@ +XGETTEXT_EXTRA_OPTIONS = @XGETTEXT_EXTRA_OPTIONS@ +XSLTPROC = @XSLTPROC@ +YACC = @YACC@ +YACC_LIBRARY = @YACC_LIBRARY@ +YACC_SCRIPT = @YACC_SCRIPT@ +YFLAGS = @YFLAGS@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +aclocaldir = @aclocaldir@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +gl_LIBOBJS = @gl_LIBOBJS@ +gl_LTLIBOBJS = @gl_LTLIBOBJS@ +gltests_LIBOBJS = @gltests_LIBOBJS@ +gltests_LTLIBOBJS = @gltests_LTLIBOBJS@ +gltests_WITNESS = @gltests_WITNESS@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +lispdir = @lispdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +dist_pkgdata_DATA = README bison.m4 \ + c-like.m4 \ + c-skel.m4 c.m4 yacc.c glr.c \ + c++-skel.m4 c++.m4 location.cc lalr1.cc glr.cc stack.hh \ + java-skel.m4 java.m4 lalr1.java + +m4sugardir = $(pkgdatadir)/m4sugar +dist_m4sugar_DATA = m4sugar/m4sugar.m4 m4sugar/foreach.m4 +xsltdir = $(pkgdatadir)/xslt +dist_xslt_DATA = \ + xslt/bison.xsl \ + xslt/xml2dot.xsl \ + xslt/xml2text.xsl \ + xslt/xml2xhtml.xsl + +all: all-am + +.SUFFIXES: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnits data/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --gnits data/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): +install-dist_m4sugarDATA: $(dist_m4sugar_DATA) + @$(NORMAL_INSTALL) + @list='$(dist_m4sugar_DATA)'; test -n "$(m4sugardir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(m4sugardir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(m4sugardir)" || exit 1; \ + fi; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(m4sugardir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(m4sugardir)" || exit $$?; \ + done + +uninstall-dist_m4sugarDATA: + @$(NORMAL_UNINSTALL) + @list='$(dist_m4sugar_DATA)'; test -n "$(m4sugardir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + dir='$(DESTDIR)$(m4sugardir)'; $(am__uninstall_files_from_dir) +install-dist_pkgdataDATA: $(dist_pkgdata_DATA) + @$(NORMAL_INSTALL) + @list='$(dist_pkgdata_DATA)'; test -n "$(pkgdatadir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(pkgdatadir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(pkgdatadir)" || exit 1; \ + fi; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgdatadir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgdatadir)" || exit $$?; \ + done + +uninstall-dist_pkgdataDATA: + @$(NORMAL_UNINSTALL) + @list='$(dist_pkgdata_DATA)'; test -n "$(pkgdatadir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + dir='$(DESTDIR)$(pkgdatadir)'; $(am__uninstall_files_from_dir) +install-dist_xsltDATA: $(dist_xslt_DATA) + @$(NORMAL_INSTALL) + @list='$(dist_xslt_DATA)'; test -n "$(xsltdir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(xsltdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(xsltdir)" || exit 1; \ + fi; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(xsltdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(xsltdir)" || exit $$?; \ + done + +uninstall-dist_xsltDATA: + @$(NORMAL_UNINSTALL) + @list='$(dist_xslt_DATA)'; test -n "$(xsltdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + dir='$(DESTDIR)$(xsltdir)'; $(am__uninstall_files_from_dir) +tags: TAGS +TAGS: + +ctags: CTAGS +CTAGS: + +cscope cscopelist: + + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(DATA) +installdirs: + for dir in "$(DESTDIR)$(m4sugardir)" "$(DESTDIR)$(pkgdatadir)" "$(DESTDIR)$(xsltdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic mostlyclean-am + +distclean: distclean-am + -rm -f Makefile +distclean-am: clean-am distclean-generic + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-dist_m4sugarDATA install-dist_pkgdataDATA \ + install-dist_xsltDATA + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-generic + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-dist_m4sugarDATA uninstall-dist_pkgdataDATA \ + uninstall-dist_xsltDATA + +.MAKE: install-am install-strip + +.PHONY: all all-am check check-am clean clean-generic distclean \ + distclean-generic distdir dvi dvi-am html html-am info info-am \ + install install-am install-data install-data-am \ + install-dist_m4sugarDATA install-dist_pkgdataDATA \ + install-dist_xsltDATA install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-man install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic pdf \ + pdf-am ps ps-am uninstall uninstall-am \ + uninstall-dist_m4sugarDATA uninstall-dist_pkgdataDATA \ + uninstall-dist_xsltDATA + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/src/data/README b/src/data/README new file mode 100644 index 0000000..e78c1cf --- /dev/null +++ b/src/data/README @@ -0,0 +1,70 @@ +-*- outline -*- + +This directory contains data needed by Bison. + +* Skeletons +Bison skeletons: the general shapes of the different parser kinds, +that are specialized for specific grammars by the bison program. + +Currently, the supported skeletons are: + +- yacc.c + It used to be named bison.simple: it corresponds to C Yacc + compatible LALR(1) parsers. + +- lalr1.cc + Produces a C++ parser class. + +- lalr1.java + Produces a Java parser class. + +- glr.c + A Generalized LR C parser based on Bison's LALR(1) tables. + +- glr.cc + A Generalized LR C++ parser. Actually a C++ wrapper around glr.c. + +These skeletons are the only ones supported by the Bison team. +Because the interface between skeletons and the bison program is not +finished, *we are not bound to it*. In particular, Bison is not +mature enough for us to consider that ``foreign skeletons'' are +supported. + +* m4sugar +This directory contains M4sugar, sort of an extended library for M4, +which is used by Bison to instantiate the skeletons. + +* xslt +This directory contains XSLT programs that transform Bison's XML output +into various formats. + +- bison.xsl + A library of routines used by the other XSLT programs. + +- xml2dot.xsl + Conversion into GraphViz's dot format. + +- xml2text.xsl + Conversion into text. + +- xml2xhtml.xsl + Conversion into XHTML. + +----- + +Copyright (C) 2002, 2008-2012 Free Software Foundation, Inc. + +This file is part of GNU Bison. + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . diff --git a/src/data/bison.m4 b/src/data/bison.m4 new file mode 100644 index 0000000..a24b162 --- /dev/null +++ b/src/data/bison.m4 @@ -0,0 +1,610 @@ + -*- Autoconf -*- + +# Language-independent M4 Macros for Bison. + +# Copyright (C) 2002, 2004-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +## ---------------- ## +## Identification. ## +## ---------------- ## + +# b4_copyright(TITLE, YEARS) +# -------------------------- +m4_define([b4_copyright], +[b4_comment([A Bison parser, made by GNU Bison b4_version.]) + +b4_comment([$1 + +m4_text_wrap([Copyright (C) $2 Free Software Foundation, Inc.], [ ]) + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see .]) + +b4_comment([As a special exception, you may create a larger work that contains +part or all of the Bison parser skeleton and distribute that work +under terms of your choice, so long as that work isn't itself a +parser generator using the skeleton or a modified version thereof +as a parser skeleton. Alternatively, if you modify or redistribute +the parser skeleton itself, you may (at your option) remove this +special exception, which will cause the skeleton and the resulting +Bison output files to be licensed under the GNU General Public +License without this special exception. + +This special exception was added by the Free Software Foundation in +version 2.2 of Bison.])]) + + +## -------- ## +## Output. ## +## -------- ## + +# b4_output_begin(FILE) +# --------------------- +# Enable output, i.e., send to diversion 0, expand after "#", and +# generate the tag to output into FILE. Must be followed by EOL. +m4_define([b4_output_begin], +[m4_changecom() +m4_divert_push(0)dnl +@output(m4_unquote([$1])@)@dnl +]) + + +# b4_output_end() +# --------------- +# Output nothing, restore # as comment character (no expansions after #). +m4_define([b4_output_end], +[m4_divert_pop(0) +m4_changecom([#]) +]) + + +## ---------------- ## +## Error handling. ## +## ---------------- ## + +# The following error handling macros print error directives that should not +# become arguments of other macro invocations since they would likely then be +# mangled. Thus, they print to stdout directly. + +# b4_cat(TEXT) +# ------------ +# Write TEXT to stdout. Precede the final newline with an @ so that it's +# escaped. For example: +# +# b4_cat([[@complain(invalid input@)]]) +m4_define([b4_cat], +[m4_syscmd([cat <<'_m4eof' +]m4_bpatsubst(m4_dquote($1), [_m4eof], [_m4@`eof])[@ +_m4eof +])dnl +m4_if(m4_sysval, [0], [], [m4_fatal([$0: cannot write to stdout])])]) + +# b4_error(KIND, FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------------- +# Write @KIND(FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_error([[warn]], [[invalid value for '%s': %s]], [[foo]], [[3]]) +m4_define([b4_error], +[b4_cat([[@]$1[(]$2[]]dnl +[m4_if([$#], [2], [], + [m4_foreach([b4_arg], + m4_dquote(m4_shift(m4_shift($@))), + [[@,]b4_arg])])[@)]])]) + +# b4_error_at(KIND, START, END, FORMAT, [ARG1], [ARG2], ...) +# ---------------------------------------------------------- +# Write @KIND_at(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_error_at([[complain]], [[input.y:2.3]], [[input.y:5.4]], +# [[invalid %s]], [[foo]]) +m4_define([b4_error_at], +[b4_cat([[@]$1[_at(]$2[@,]$3[@,]$4[]]dnl +[m4_if([$#], [4], [], + [m4_foreach([b4_arg], + m4_dquote(m4_shift(m4_shift(m4_shift(m4_shift($@))))), + [[@,]b4_arg])])[@)]])]) + +# b4_warn(FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------ +# Write @warn(FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_warn([[invalid value for '%s': %s]], [[foo]], [[3]]) +# +# As a simple test suite, this: +# +# m4_divert(-1) +# m4_define([asdf], [ASDF]) +# m4_define([fsa], [FSA]) +# m4_define([fdsa], [FDSA]) +# b4_warn([[[asdf), asdf]]], [[[fsa), fsa]]], [[[fdsa), fdsa]]]) +# b4_warn([[asdf), asdf]], [[fsa), fsa]], [[fdsa), fdsa]]) +# b4_warn() +# b4_warn(1) +# b4_warn(1, 2) +# +# Should produce this without newlines: +# +# @warn([asdf), asdf]@,[fsa), fsa]@,[fdsa), fdsa]@) +# @warn(asdf), asdf@,fsa), fsa@,fdsa), fdsa@) +# @warn(@) +# @warn(1@) +# @warn(1@,2@) +m4_define([b4_warn], +[b4_error([[warn]], $@)]) + +# b4_warn_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# --------------------------------------------------- +# Write @warn(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# For example: +# +# b4_warn_at([[input.y:2.3]], [[input.y:5.4]], [[invalid %s]], [[foo]]) +m4_define([b4_warn_at], +[b4_error_at([[warn]], $@)]) + +# b4_complain(FORMAT, [ARG1], [ARG2], ...) +# ---------------------------------------- +# Write @complain(FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# See b4_warn example. +m4_define([b4_complain], +[b4_error([[complain]], $@)]) + +# b4_complain_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------------------------- +# Write @complain(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. +# +# See b4_warn_at example. +m4_define([b4_complain_at], +[b4_error_at([[complain]], $@)]) + +# b4_fatal(FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------- +# Write @fatal(FORMAT@,ARG1@,ARG2@,...@) to stdout and exit. +# +# See b4_warn example. +m4_define([b4_fatal], +[b4_error([[fatal]], $@)dnl +m4_exit(1)]) + +# b4_fatal_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# ---------------------------------------------------- +# Write @fatal(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout and exit. +# +# See b4_warn_at example. +m4_define([b4_fatal_at], +[b4_error_at([[fatal]], $@)dnl +m4_exit(1)]) + + +## ------------ ## +## Data Types. ## +## ------------ ## + +# b4_ints_in(INT1, INT2, LOW, HIGH) +# --------------------------------- +# Return 1 iff both INT1 and INT2 are in [LOW, HIGH], 0 otherwise. +m4_define([b4_ints_in], +[m4_eval([$3 <= $1 && $1 <= $4 && $3 <= $2 && $2 <= $4])]) + + + +## ------------------ ## +## Decoding options. ## +## ------------------ ## + +# b4_flag_if(FLAG, IF-TRUE, IF-FALSE) +# ----------------------------------- +# Run IF-TRUE if b4_FLAG_flag is 1, IF-FALSE if FLAG is 0, otherwise fail. +m4_define([b4_flag_if], +[m4_case(b4_$1_flag, + [0], [$3], + [1], [$2], + [m4_fatal([invalid $1 value: ]$1)])]) + + +# b4_define_flag_if(FLAG) +# ----------------------- +# Define "b4_FLAG_if(IF-TRUE, IF-FALSE)" that depends on the +# value of the Boolean FLAG. +m4_define([b4_define_flag_if], +[_b4_define_flag_if($[1], $[2], [$1])]) + +# _b4_define_flag_if($1, $2, FLAG) +# -------------------------------- +# Work around the impossibility to define macros inside macros, +# because issuing `[$1]' is not possible in M4. GNU M4 should provide +# $$1 a la M5/TeX. +m4_define([_b4_define_flag_if], +[m4_if([$1$2], $[1]$[2], [], + [m4_fatal([$0: Invalid arguments: $@])])dnl +m4_define([b4_$3_if], + [b4_flag_if([$3], [$1], [$2])])]) + + +# b4_FLAG_if(IF-TRUE, IF-FALSE) +# ----------------------------- +# Expand IF-TRUE, if FLAG is true, IF-FALSE otherwise. +b4_define_flag_if([defines]) # Whether headers are requested. +b4_define_flag_if([error_verbose]) # Whether error are verbose. +b4_define_flag_if([glr]) # Whether a GLR parser is requested. +b4_define_flag_if([locations]) # Whether locations are tracked. +b4_define_flag_if([nondeterministic]) # Whether conflicts should be handled. +b4_define_flag_if([token_table]) # Whether yytoken_table is demanded. +b4_define_flag_if([yacc]) # Whether POSIX Yacc is emulated. + +# yytoken_table is needed to support verbose errors. +b4_error_verbose_if([m4_define([b4_token_table_flag], [1])]) + + + +## ----------- ## +## Synclines. ## +## ----------- ## + +# b4_basename(NAME) +# ----------------- +# Similar to POSIX basename; the differences don't matter here. +# Beware that NAME is not evaluated. +m4_define([b4_basename], +[m4_bpatsubst([$1], [^.*/\([^/]+\)/*$], [\1])]) + + +# b4_syncline(LINE, FILE) +# ----------------------- +m4_define([b4_syncline], +[b4_flag_if([synclines], +[b4_sync_end([__line__], [b4_basename(m4_quote(__file__))]) +b4_sync_start([$1], [$2])])]) + +m4_define([b4_sync_end], [b4_comment([Line $1 of $2])]) +m4_define([b4_sync_start], [b4_comment([Line $1 of $2])]) + +# b4_user_code(USER-CODE) +# ----------------------- +# Emit code from the user, ending it with synclines. +m4_define([b4_user_code], +[$1 +b4_syncline([@oline@], [@ofile@])]) + + +# b4_define_user_code(MACRO) +# -------------------------- +# From b4_MACRO, build b4_user_MACRO that includes the synclines. +m4_define([b4_define_user_code], +[m4_define([b4_user_$1], +[b4_user_code([b4_$1])])]) + + +# b4_user_actions +# b4_user_initial_action +# b4_user_post_prologue +# b4_user_pre_prologue +# b4_user_stype +# ---------------------- +# Macros that issue user code, ending with synclines. +b4_define_user_code([actions]) +b4_define_user_code([initial_action]) +b4_define_user_code([post_prologue]) +b4_define_user_code([pre_prologue]) +b4_define_user_code([stype]) + + +# b4_check_user_names(WHAT, USER-LIST, BISON-NAMESPACE) +# ----------------------------------------------------- +# Complain if any name of type WHAT is used by the user (as recorded in +# USER-LIST) but is not used by Bison (as recorded by macros in the +# namespace BISON-NAMESPACE). +# +# USER-LIST must expand to a list specifying all user occurrences of all names +# of type WHAT. Each item in the list must be a triplet specifying one +# occurrence: name, start boundary, and end boundary. Empty string names are +# fine. An empty list is fine. +# +# For example, to define b4_foo_user_names to be used for USER-LIST with three +# name occurrences and with correct quoting: +# +# m4_define([b4_foo_user_names], +# [[[[[[bar]], [[parser.y:1.7]], [[parser.y:1.16]]]], +# [[[[bar]], [[parser.y:5.7]], [[parser.y:5.16]]]], +# [[[[baz]], [[parser.y:8.7]], [[parser.y:8.16]]]]]]) +# +# The macro BISON-NAMESPACE(bar) must be defined iff the name bar of type WHAT +# is used by Bison (in the front-end or in the skeleton). Empty string names +# are fine, but it would be ugly for Bison to actually use one. +# +# For example, to use b4_foo_bison_names for BISON-NAMESPACE and define that +# the names bar and baz are used by Bison: +# +# m4_define([b4_foo_bison_names(bar)]) +# m4_define([b4_foo_bison_names(baz)]) +# +# To invoke b4_check_user_names with TYPE foo, with USER-LIST +# b4_foo_user_names, with BISON-NAMESPACE b4_foo_bison_names, and with correct +# quoting: +# +# b4_check_user_names([[foo]], [b4_foo_user_names], +# [[b4_foo_bison_names]]) +m4_define([b4_check_user_names], +[m4_foreach([b4_occurrence], $2, +[m4_pushdef([b4_occurrence], b4_occurrence)dnl +m4_pushdef([b4_user_name], m4_car(b4_occurrence))dnl +m4_pushdef([b4_start], m4_car(m4_shift(b4_occurrence)))dnl +m4_pushdef([b4_end], m4_shift(m4_shift(b4_occurrence)))dnl +m4_ifndef($3[(]m4_quote(b4_user_name)[)], + [b4_complain_at([b4_start], [b4_end], + [[%s '%s' is not used]], + [$1], [b4_user_name])])[]dnl +m4_popdef([b4_occurrence])dnl +m4_popdef([b4_user_name])dnl +m4_popdef([b4_start])dnl +m4_popdef([b4_end])dnl +])]) + + + + +## --------------------- ## +## b4_percent_define_*. ## +## --------------------- ## + + +# b4_percent_define_use(VARIABLE) +# ------------------------------- +# Declare that VARIABLE was used. +m4_define([b4_percent_define_use], +[m4_define([b4_percent_define_bison_variables(]$1[)])dnl +]) + +# b4_percent_define_get(VARIABLE, [DEFAULT]) +# ------------------------------------------ +# Mimic muscle_percent_define_get in ../src/muscle-tab.h. That is, if +# the %define variable VARIABLE is defined, emit its value. Contrary +# to its C counterpart, return DEFAULT otherwise. Also, record +# Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_get([[foo]]) +m4_define([b4_percent_define_get], +[b4_percent_define_use([$1])dnl +m4_ifdef([b4_percent_define(]$1[)], + [m4_indir([b4_percent_define(]$1[)])], + [$2])]) + + +# b4_percent_define_get_loc(VARIABLE) +# ----------------------------------- +# Mimic muscle_percent_define_get_loc in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is undefined, complain fatally since that's +# a Bison or skeleton error. Otherwise, return its definition location in a +# form approriate for the first two arguments of b4_warn_at, b4_complain_at, or +# b4_fatal_at. Don't record this as a Bison usage of VARIABLE as there's no +# reason to suspect that the user-supplied value has yet influenced the output. +# +# For example: +# +# b4_complain_at(b4_percent_define_get_loc([[foo]]), [[invalid foo]]) +m4_define([b4_percent_define_get_loc], +[m4_ifdef([b4_percent_define_loc(]$1[)], + [m4_pushdef([b4_loc], m4_indir([b4_percent_define_loc(]$1[)]))dnl +b4_loc[]dnl +m4_popdef([b4_loc])], + [b4_fatal([[b4_percent_define_get_loc: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_define_get_syncline(VARIABLE) +# ---------------------------------------- +# Mimic muscle_percent_define_get_syncline in ../src/muscle-tab.h exactly. +# That is, if the %define variable VARIABLE is undefined, complain fatally +# since that's a Bison or skeleton error. Otherwise, return its definition +# location as a b4_syncline invocation. Don't record this as a Bison usage of +# VARIABLE as there's no reason to suspect that the user-supplied value has yet +# influenced the output. +# +# For example: +# +# b4_percent_define_get_syncline([[foo]]) +m4_define([b4_percent_define_get_syncline], +[m4_ifdef([b4_percent_define_syncline(]$1[)], + [m4_indir([b4_percent_define_syncline(]$1[)])], + [b4_fatal([[b4_percent_define_get_syncline: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_define_ifdef(VARIABLE, IF-TRUE, [IF-FALSE]) +# ------------------------------------------------------ +# Mimic muscle_percent_define_ifdef in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is defined, expand IF-TRUE, else expand +# IF-FALSE. Also, record Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]]) +m4_define([b4_percent_define_ifdef], +[m4_ifdef([b4_percent_define(]$1[)], + [m4_define([b4_percent_define_bison_variables(]$1[)])$2], + [$3])]) + +# b4_percent_define_flag_if(VARIABLE, IF-TRUE, [IF-FALSE]) +# -------------------------------------------------------- +# Mimic muscle_percent_define_flag_if in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is defined to "" or "true", expand IF-TRUE. +# If it is defined to "false", expand IF-FALSE. Complain if it is undefined +# (a Bison or skeleton error since the default value should have been set +# already) or defined to any other value (possibly a user error). Also, record +# Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_flag_if([[foo]], [[it's true]], [[it's false]]) +m4_define([b4_percent_define_flag_if], +[b4_percent_define_ifdef([$1], + [m4_case(b4_percent_define_get([$1]), + [], [$2], [true], [$2], [false], [$3], + [m4_expand_once([b4_complain_at(b4_percent_define_get_loc([$1]), + [[invalid value for %%define Boolean variable '%s']], + [$1])], + [[b4_percent_define_flag_if($1)]])])], + [b4_fatal([[b4_percent_define_flag_if: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_define_default(VARIABLE, DEFAULT) +# -------------------------------------------- +# Mimic muscle_percent_define_default in ../src/muscle-tab.h exactly. That is, +# if the %define variable VARIABLE is undefined, set its value to DEFAULT. +# Don't record this as a Bison usage of VARIABLE as there's no reason to +# suspect that the value has yet influenced the output. +# +# For example: +# +# b4_percent_define_default([[foo]], [[default value]]) +m4_define([b4_percent_define_default], +[m4_ifndef([b4_percent_define(]$1[)], + [m4_define([b4_percent_define(]$1[)], [$2])dnl + m4_define([b4_percent_define_loc(]$1[)], + [[[[:-1.-1]], + [[:-1.-1]]]])dnl + m4_define([b4_percent_define_syncline(]$1[)], [[]])])]) + +# b4_percent_define_check_values(VALUES) +# -------------------------------------- +# Mimic muscle_percent_define_check_values in ../src/muscle-tab.h exactly +# except that the VALUES structure is more appropriate for M4. That is, VALUES +# is a list of sublists of strings. For each sublist, the first string is the +# name of a %define variable, and all remaining strings in that sublist are the +# valid values for that variable. Complain if such a variable is undefined (a +# Bison error since the default value should have been set already) or defined +# to any other value (possibly a user error). Don't record this as a Bison +# usage of the variable as there's no reason to suspect that the value has yet +# influenced the output. +# +# For example: +# +# b4_percent_define_check_values([[[[foo]], [[foo-value1]], [[foo-value2]]]], +# [[[[bar]], [[bar-value1]]]]) +m4_define([b4_percent_define_check_values], +[m4_foreach([b4_sublist], m4_quote($@), + [_b4_percent_define_check_values(b4_sublist)])]) + +m4_define([_b4_percent_define_check_values], +[m4_ifdef([b4_percent_define(]$1[)], + [m4_pushdef([b4_good_value], [0])dnl + m4_if($#, 1, [], + [m4_foreach([b4_value], m4_dquote(m4_shift($@)), + [m4_if(m4_indir([b4_percent_define(]$1[)]), b4_value, + [m4_define([b4_good_value], [1])])])])dnl + m4_if(b4_good_value, [0], + [b4_complain_at(b4_percent_define_get_loc([$1]), + [[invalid value for %%define variable '%s': '%s']], + [$1], + m4_dquote(m4_indir([b4_percent_define(]$1[)]))) + m4_foreach([b4_value], m4_dquote(m4_shift($@)), + [b4_complain_at(b4_percent_define_get_loc([$1]), + [[accepted value: '%s']], + m4_dquote(b4_value))])])dnl + m4_popdef([b4_good_value])], + [b4_fatal([[b4_percent_define_check_values: undefined %%define variable '%s']], [$1])])]) + +# b4_percent_code_get([QUALIFIER]) +# -------------------------------- +# If any %code blocks for QUALIFIER are defined, emit them beginning with a +# comment and ending with synclines and a newline. If QUALIFIER is not +# specified or empty, do this for the unqualified %code blocks. Also, record +# Bison's usage of QUALIFIER (if specified) by defining +# b4_percent_code_bison_qualifiers(QUALIFIER). +# +# For example, to emit any unqualified %code blocks followed by any %code +# blocks for the qualifier foo: +# +# b4_percent_code_get +# b4_percent_code_get([[foo]]) +m4_define([b4_percent_code_get], +[m4_pushdef([b4_macro_name], [[b4_percent_code(]$1[)]])dnl +m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])dnl +m4_ifdef(b4_macro_name, +[b4_comment([m4_if([$#], [0], [[Unqualified %code]], + [["%code ]$1["]])[ blocks.]]) +b4_user_code([m4_indir(b4_macro_name)]) +])dnl +m4_popdef([b4_macro_name])]) + +# b4_percent_code_ifdef(QUALIFIER, IF-TRUE, [IF-FALSE]) +# ----------------------------------------------------- +# If any %code blocks for QUALIFIER (or unqualified %code blocks if +# QUALIFIER is empty) are defined, expand IF-TRUE, else expand IF-FALSE. +# Also, record Bison's usage of QUALIFIER (if specified) by defining +# b4_percent_code_bison_qualifiers(QUALIFIER). +m4_define([b4_percent_code_ifdef], +[m4_ifdef([b4_percent_code(]$1[)], + [m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])$2], + [$3])]) + + +## ----------------------------------------------------------- ## +## After processing the skeletons, check that all the user's ## +## %define variables and %code qualifiers were used by Bison. ## +## ----------------------------------------------------------- ## + +m4_define([b4_check_user_names_wrap], +[m4_ifdef([b4_percent_]$1[_user_]$2[s], + [b4_check_user_names([[%]$1 $2], + [b4_percent_]$1[_user_]$2[s], + [[b4_percent_]$1[_bison_]$2[s]])])]) + +m4_wrap_lifo([ +b4_check_user_names_wrap([[define]], [[variable]]) +b4_check_user_names_wrap([[code]], [[qualifier]]) +]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# m4_define_default([b4_lex_param], []) dnl breaks other skeletons +m4_define_default([b4_pre_prologue], []) +m4_define_default([b4_post_prologue], []) +m4_define_default([b4_epilogue], []) +m4_define_default([b4_parse_param], []) + +# The initial column and line. +m4_define_default([b4_location_initial_column], [1]) +m4_define_default([b4_location_initial_line], [1]) + +# Sanity checks. +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])])]) diff --git a/src/data/c++-skel.m4 b/src/data/c++-skel.m4 new file mode 100644 index 0000000..4421d18 --- /dev/null +++ b/src/data/c++-skel.m4 @@ -0,0 +1,26 @@ + -*- Autoconf -*- + +# C++ skeleton dispatching for Bison. + +# Copyright (C) 2006-2007, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +b4_glr_if( [m4_define([b4_used_skeleton], [b4_pkgdatadir/[glr.cc]])]) +b4_nondeterministic_if([m4_define([b4_used_skeleton], [b4_pkgdatadir/[glr.cc]])]) + +m4_define_default([b4_used_skeleton], [b4_pkgdatadir/[lalr1.cc]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/src/data/c++.m4 b/src/data/c++.m4 new file mode 100644 index 0000000..8b98b8c --- /dev/null +++ b/src/data/c++.m4 @@ -0,0 +1,205 @@ + -*- Autoconf -*- + +# C++ skeleton for Bison + +# Copyright (C) 2002-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_include(b4_pkgdatadir/[c.m4]) + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Default parser class name. +b4_percent_define_default([[parser_class_name]], [[parser]]) + +# Don't do that so that we remember whether we're using a user +# request, or the default value. +# +# b4_percent_define_default([[api.location.type]], [[location]]) + +b4_percent_define_default([[filename_type]], [[std::string]]) +b4_percent_define_default([[namespace]], m4_defn([b4_prefix])) +b4_percent_define_default([[global_tokens_and_yystype]], [[false]]) +b4_percent_define_default([[define_location_comparison]], + [m4_if(b4_percent_define_get([[filename_type]]), + [std::string], [[true]], [[false]])]) + + +## ----------- ## +## Namespace. ## +## ----------- ## + +m4_define([b4_namespace_ref], [b4_percent_define_get([[namespace]])]) + +# Don't permit an empty b4_namespace_ref. Any `::parser::foo' appended to it +# would compile as an absolute reference with `parser' in the global namespace. +# b4_namespace_open would open an anonymous namespace and thus establish +# internal linkage. This would compile. However, it's cryptic, and internal +# linkage for the parser would be specified in all translation units that +# include the header, which is always generated. If we ever need to permit +# internal linkage somehow, surely we can find a cleaner approach. +m4_if(m4_bregexp(b4_namespace_ref, [^[ ]*$]), [-1], [], +[b4_complain_at(b4_percent_define_get_loc([[namespace]]), + [[namespace reference is empty]])]) + +# Instead of assuming the C++ compiler will do it, Bison should reject any +# invalid b4_namepsace_ref that would be converted to a valid +# b4_namespace_open. The problem is that Bison doesn't always output +# b4_namespace_ref to uncommented code but should reserve the ability to do so +# in future releases without risking breaking any existing user grammars. +# Specifically, don't allow empty names as b4_namespace_open would just convert +# those into anonymous namespaces, and that might tempt some users. +m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*::]), [-1], [], +[b4_complain_at(b4_percent_define_get_loc([[namespace]]), + [[namespace reference has consecutive "::"]])]) +m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*$]), [-1], [], +[b4_complain_at(b4_percent_define_get_loc([[namespace]]), + [[namespace reference has a trailing "::"]])]) + +m4_define([b4_namespace_open], +[b4_user_code([b4_percent_define_get_syncline([[namespace]]) +[namespace ]m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref), + [^\(.\)[ ]*::], [\1])), + [::], [ { namespace ])[ {]])]) + +m4_define([b4_namespace_close], +[b4_user_code([b4_percent_define_get_syncline([[namespace]]) +m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref[ ]), + [^\(.\)[ ]*\(::\)?\([^][:]\|:[^:]\)*], + [\1])), + [::\([^][:]\|:[^:]\)*], [} ])[} // ]b4_namespace_ref])]) + + +# b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) +# ----------------------------------------------------- +# Output the definition of the tokens as enums. +m4_define([b4_token_enums], +[/* Tokens. */ + enum yytokentype { +m4_map_sep([ b4_token_enum], [, +], + [$@]) + }; +]) + + + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_lhs_value([TYPE]) +# -------------------- +# Expansion of $$. +m4_define([b4_lhs_value], +[(yyval[]m4_ifval([$1], [.$1]))]) + + +# b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) +# -------------------------------------- +# Expansion of $NUM, where the current rule has RULE-LENGTH +# symbols on RHS. +m4_define([b4_rhs_value], +[(yysemantic_stack_@{($1) - ($2)@}m4_ifval([$3], [.$3]))]) + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[(yylocation_stack_@{($1) - ($2)@})]) + + +# b4_parse_param_decl +# ------------------- +# Extra formal arguments of the constructor. +# Change the parameter names from "foo" into "foo_yyarg", so that +# there is no collision bw the user chosen attribute name, and the +# argument name in the constructor. +m4_define([b4_parse_param_decl], +[m4_ifset([b4_parse_param], + [m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])]) + +m4_define([b4_parse_param_decl_1], +[$1_yyarg]) + + + +# b4_parse_param_cons +# ------------------- +# Extra initialisations of the constructor. +m4_define([b4_parse_param_cons], + [m4_ifset([b4_parse_param], + [ + b4_cc_constructor_calls(b4_parse_param)])]) +m4_define([b4_cc_constructor_calls], + [m4_map_sep([b4_cc_constructor_call], [, + ], [$@])]) +m4_define([b4_cc_constructor_call], + [$2 ($2_yyarg)]) + +# b4_parse_param_vars +# ------------------- +# Extra instance variables. +m4_define([b4_parse_param_vars], + [m4_ifset([b4_parse_param], + [ + /* User arguments. */ +b4_cc_var_decls(b4_parse_param)])]) +m4_define([b4_cc_var_decls], + [m4_map_sep([b4_cc_var_decl], [ +], [$@])]) +m4_define([b4_cc_var_decl], + [ $1;]) + + +## ---------## +## Values. ## +## ---------## + +# b4_yylloc_default_define +# ------------------------ +# Define YYLLOC_DEFAULT. +m4_define([b4_yylloc_default_define], +[[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +# ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).begin = YYRHSLOC (Rhs, 1).begin; \ + (Current).end = YYRHSLOC (Rhs, N).end; \ + } \ + else \ + { \ + (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ + } \ + while (/*CONSTCOND*/ false) +# endif +]]) diff --git a/src/data/c-like.m4 b/src/data/c-like.m4 new file mode 100644 index 0000000..c2abce7 --- /dev/null +++ b/src/data/c-like.m4 @@ -0,0 +1,44 @@ + -*- Autoconf -*- + +# Common code for C-like languages (C, C++, Java, etc.) + +# Copyright (C) 2012 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_dollar_dollar_(VALUE, FIELD, DEFAULT-FIELD) +# ---------------------------------------------- +# If FIELD (or DEFAULT-FIELD) is non-null, return "VALUE.FIELD", +# otherwise just VALUE. Be sure to pass "(VALUE)" is VALUE is a +# pointer. +m4_define([b4_dollar_dollar_], +[m4_if([$2], [[]], + [m4_ifval([$3], [($1.$3)], + [$1])], + [($1.$2)])]) + +# b4_dollar_pushdef(VALUE-POINTER, DEFAULT-FIELD, LOCATION) +# b4_dollar_popdef +# --------------------------------------------------------- +# Define b4_dollar_dollar for VALUE and DEFAULT-FIELD, +# and b4_at_dollar for LOCATION. +m4_define([b4_dollar_pushdef], +[m4_pushdef([b4_dollar_dollar], + [b4_dollar_dollar_([$1], m4_dquote($][1), [$2])])dnl +m4_pushdef([b4_at_dollar], [$3])dnl +]) +m4_define([b4_dollar_popdef], +[m4_popdef([b4_at_dollar])dnl +m4_popdef([b4_dollar_dollar])dnl +]) diff --git a/src/data/c-skel.m4 b/src/data/c-skel.m4 new file mode 100644 index 0000000..8bcae59 --- /dev/null +++ b/src/data/c-skel.m4 @@ -0,0 +1,26 @@ + -*- Autoconf -*- + +# C skeleton dispatching for Bison. + +# Copyright (C) 2006-2007, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +b4_glr_if( [m4_define([b4_used_skeleton], [b4_pkgdatadir/[glr.c]])]) +b4_nondeterministic_if([m4_define([b4_used_skeleton], [b4_pkgdatadir/[glr.c]])]) + +m4_define_default([b4_used_skeleton], [b4_pkgdatadir/[yacc.c]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/src/data/c.m4 b/src/data/c.m4 new file mode 100644 index 0000000..b294daa --- /dev/null +++ b/src/data/c.m4 @@ -0,0 +1,722 @@ + -*- Autoconf -*- + +# C M4 Macros for Bison. + +# Copyright (C) 2002, 2004-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_include(b4_pkgdatadir/[c-like.m4]) + +# b4_tocpp(STRING) +# ---------------- +# Convert STRING into a valid C macro name. +m4_define([b4_tocpp], +[m4_toupper(m4_bpatsubst(m4_quote($1), [[^a-zA-Z0-9]+], [_]))]) + + +# b4_cpp_guard(FILE) +# ------------------ +# A valid C macro name to use as a CPP header guard for FILE. +m4_define([b4_cpp_guard], +[[YY_]b4_tocpp(m4_defn([b4_prefix])/[$1])[_INCLUDED]]) + + +# b4_cpp_guard_open(FILE) +# b4_cpp_guard_close(FILE) +# ------------------------ +# If FILE does not expand to nothing, open/close CPP inclusion guards for FILE. +m4_define([b4_cpp_guard_open], +[m4_ifval(m4_quote($1), +[#ifndef b4_cpp_guard([$1]) +# define b4_cpp_guard([$1])])]) + +m4_define([b4_cpp_guard_close], +[m4_ifval(m4_quote($1), +[#endif b4_comment([!b4_cpp_guard([$1])])])]) + + +## ---------------- ## +## Identification. ## +## ---------------- ## + +# b4_comment(TEXT) +# ---------------- +m4_define([b4_comment], [/* m4_bpatsubst([$1], [ +], [ + ]) */]) + +# b4_identification +# ----------------- +# Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or +# b4_pull_flag if they use the values of the %define variables api.pure or +# api.push-pull. +m4_define([b4_identification], +[[/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "]b4_version[" + +/* Skeleton name. */ +#define YYSKELETON_NAME ]b4_skeleton[]m4_ifdef([b4_pure_flag], [[ + +/* Pure parsers. */ +#define YYPURE ]b4_pure_flag])[]m4_ifdef([b4_push_flag], [[ + +/* Push parsers. */ +#define YYPUSH ]b4_push_flag])[]m4_ifdef([b4_pull_flag], [[ + +/* Pull parsers. */ +#define YYPULL ]b4_pull_flag])[ +]]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# b4_api_prefix, b4_api_PREFIX +# ---------------------------- +# Corresponds to %define api.prefix +b4_percent_define_default([[api.prefix]], [[yy]]) +m4_define([b4_api_prefix], +[b4_percent_define_get([[api.prefix]])]) +m4_define([b4_api_PREFIX], +[m4_toupper(b4_api_prefix)]) + + +# b4_prefix +# --------- +# If the %name-prefix is not given, it is api.prefix. +m4_define_default([b4_prefix], [b4_api_prefix]) + +# If the %union is not named, its name is YYSTYPE. +m4_define_default([b4_union_name], [b4_api_PREFIX[]STYPE]) + + +## ------------------------ ## +## Pure/impure interfaces. ## +## ------------------------ ## + +# b4_user_args +# ------------ +m4_define([b4_user_args], +[m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])]) + + +# b4_parse_param +# -------------- +# If defined, b4_parse_param arrives double quoted, but below we prefer +# it to be single quoted. +m4_define([b4_parse_param], +b4_parse_param) + + +# b4_parse_param_for(DECL, FORMAL, BODY) +# --------------------------------------- +# Iterate over the user parameters, binding the declaration to DECL, +# the formal name to FORMAL, and evaluating the BODY. +m4_define([b4_parse_param_for], +[m4_foreach([$1_$2], m4_defn([b4_parse_param]), +[m4_pushdef([$1], m4_unquote(m4_car($1_$2)))dnl +m4_pushdef([$2], m4_shift($1_$2))dnl +$3[]dnl +m4_popdef([$2])dnl +m4_popdef([$1])dnl +])]) + +# b4_parse_param_use +# ------------------ +# `YYUSE' all the parse-params. +m4_define([b4_parse_param_use], +[b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal); +])dnl +]) + + +## ------------ ## +## Data Types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# MIN to MAX (included). +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char], + b4_ints_in($@, [-128], [127]), [1], [signed char], + + b4_ints_in($@, [0], [65535]), [1], [unsigned short int], + b4_ints_in($@, [-32768], [32767]), [1], [short int], + + m4_eval([0 <= $1]), [1], [unsigned int], + + [int])]) + + +# b4_int_type_for(NAME) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# `NAME_min' to `NAME_max' (included). +m4_define([b4_int_type_for], +[b4_int_type($1_min, $1_max)]) + + +# b4_table_value_equals(TABLE, VALUE, LITERAL) +# -------------------------------------------- +# Without inducing a comparison warning from the compiler, check if the +# literal value LITERAL equals VALUE from table TABLE, which must have +# TABLE_min and TABLE_max defined. YYID must be defined as an identity +# function that suppresses warnings about constant conditions. +m4_define([b4_table_value_equals], +[m4_if(m4_eval($3 < m4_indir([b4_]$1[_min]) + || m4_indir([b4_]$1[_max]) < $3), [1], + [[YYID (0)]], + [(!!(($2) == ($3)))])]) + + +## ---------## +## Values. ## +## ---------## + + +# b4_null_define +# -------------- +# Portability issues: define a YY_NULL appropriate for the current +# language (C, C++98, or C++11). +m4_define([b4_null_define], +[# ifndef YY_NULL +# if defined __cplusplus && 201103L <= __cplusplus +# define YY_NULL nullptr +# else +# define YY_NULL 0 +# endif +# endif[]dnl +]) + + +# b4_null +# ------- +# Return a null pointer constant. +m4_define([b4_null], [YY_NULL]) + + + +## ------------------------- ## +## Assigning token numbers. ## +## ------------------------- ## + +# b4_token_define(TOKEN-NAME, TOKEN-NUMBER) +# ----------------------------------------- +# Output the definition of this token as #define. +m4_define([b4_token_define], +[#define $1 $2 +]) + + +# b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) +# ------------------------------------------------------- +# Output the definition of the tokens (if there are) as #defines. +m4_define([b4_token_defines], +[m4_if([$#$1], [1], [], +[/* Tokens. */ +m4_map([b4_token_define], [$@])]) +]) + + +# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER) +# --------------------------------------- +# Output the definition of this token as an enum. +m4_define([b4_token_enum], +[$1 = $2]) + + +# b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) +# ----------------------------------------------------- +# Output the definition of the tokens (if there are) as enums. +m4_define([b4_token_enums], +[m4_if([$#$1], [1], [], +[[/* Tokens. */ +#ifndef ]b4_api_PREFIX[TOKENTYPE +# define ]b4_api_PREFIX[TOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum ]b4_api_prefix[tokentype { +]m4_map_sep([ b4_token_enum], [, +], + [$@])[ + }; +#endif +]])]) + + +# b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) +# ------------------------------------------------------------- +# Output the definition of the tokens (if there are any) as enums and, if POSIX +# Yacc is enabled, as #defines. +m4_define([b4_token_enums_defines], +[b4_token_enums($@)b4_yacc_if([b4_token_defines($@)], []) +]) + + + +## --------------------------------------------- ## +## Defining C functions in both K&R and ANSI-C. ## +## --------------------------------------------- ## + + +# b4_modern_c +# ----------- +# A predicate useful in #if to determine whether C is ancient or modern. +# +# If __STDC__ is defined, the compiler is modern. IBM xlc 7.0 when run +# as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic +# reasons, but it defines __C99__FUNC__ so check that as well. +# Microsoft C normally doesn't define these macros, but it defines _MSC_VER. +# Consider a C++ compiler to be modern if it defines __cplusplus. +# +m4_define([b4_c_modern], + [[(defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER)]]) + +# b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ---------------------------------------------------------- +# Declare the function NAME. +m4_define([b4_c_function_def], +[#if b4_c_modern +b4_c_ansi_function_def($@) +#else +$2 +$1 (b4_c_knr_formal_names(m4_shift2($@))) +b4_c_knr_formal_decls(m4_shift2($@)) +#endif[]dnl +]) + + +# b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# --------------------------------------------------------------- +# Declare the function NAME in ANSI. +m4_define([b4_c_ansi_function_def], +[$2 +$1 (b4_c_ansi_formals(m4_shift2($@)))[]dnl +]) + + +# b4_c_ansi_formals([DECL1, NAME1], ...) +# -------------------------------------- +# Output the arguments ANSI-C definition. +m4_define([b4_c_ansi_formals], +[m4_if([$#], [0], [void], + [$#$1], [1], [void], + [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])]) + +m4_define([b4_c_ansi_formal], +[$1]) + + +# b4_c_knr_formal_names([DECL1, NAME1], ...) +# ------------------------------------------ +# Output the argument names. +m4_define([b4_c_knr_formal_names], +[m4_map_sep([b4_c_knr_formal_name], [, ], [$@])]) + +m4_define([b4_c_knr_formal_name], +[$2]) + + +# b4_c_knr_formal_decls([DECL1, NAME1], ...) +# ------------------------------------------ +# Output the K&R argument declarations. +m4_define([b4_c_knr_formal_decls], +[m4_map_sep([b4_c_knr_formal_decl], + [ +], + [$@])]) + +m4_define([b4_c_knr_formal_decl], +[ $1;]) + + + +## ------------------------------------------------------------ ## +## Declaring (prototyping) C functions in both K&R and ANSI-C. ## +## ------------------------------------------------------------ ## + + +# b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ---------------------------------------------------------------- +# Declare the function NAME ANSI C style. +m4_define([b4_c_ansi_function_decl], +[$2 $1 (b4_c_ansi_formals(m4_shift2($@)));[]dnl +]) + + + +# b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ----------------------------------------------------------- +# Declare the function NAME in both K&R and ANSI C. +m4_define([b4_c_function_decl], +[#if defined __STDC__ || defined __cplusplus +b4_c_ansi_function_decl($@) +#else +$2 $1 (); +#endif[]dnl +]) + + + +## --------------------- ## +## Calling C functions. ## +## --------------------- ## + + +# b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...) +# ----------------------------------------------------------- +# Call the function NAME with arguments NAME1, NAME2 etc. +m4_define([b4_c_function_call], +[$1 (b4_c_args(m4_shift2($@)))[]dnl +]) + + +# b4_c_args([DECL1, NAME1], ...) +# ------------------------------ +# Output the arguments NAME1, NAME2... +m4_define([b4_c_args], +[m4_map_sep([b4_c_arg], [, ], [$@])]) + +m4_define([b4_c_arg], +[$2]) + + +## ----------- ## +## Synclines. ## +## ----------- ## + +# b4_sync_start(LINE, FILE) +# ----------------------- +m4_define([b4_sync_start], [[#]line $1 $2]) + + +## -------------- ## +## User actions. ## +## -------------- ## + +# b4_case(LABEL, STATEMENTS) +# -------------------------- +m4_define([b4_case], +[ case $1: +$2 + break;]) + +# b4_symbol_actions(FILENAME, LINENO, +# SYMBOL-TAG, SYMBOL-NUM, +# SYMBOL-ACTION, SYMBOL-TYPENAME) +# ------------------------------------------------- +# Issue the code for a symbol action (e.g., %printer). +# +# Define b4_dollar_dollar([TYPE-NAME]), and b4_at_dollar, which are +# invoked where $$ and @$ were specified by the user. +m4_define([b4_symbol_actions], +[b4_dollar_pushdef([(*yyvaluep)], [$6], [(*yylocationp)])dnl + case $4: /* $3 */ +b4_syncline([$2], [$1]) + $5; +b4_syncline([@oline@], [@ofile@]) + break; +b4_dollar_popdef[]dnl +]) + + +# b4_yydestruct_generate(FUNCTION-DECLARATOR) +# ------------------------------------------- +# Generate the "yydestruct" function, which declaration is issued using +# FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C +# or "b4_c_function_def" for K&R. +m4_define_default([b4_yydestruct_generate], +[[/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +/*ARGSUSED*/ +]$1([yydestruct], + [static void], + [[const char *yymsg], [yymsg]], + [[int yytype], [yytype]], + [[YYSTYPE *yyvaluep], [yyvaluep]][]dnl +b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl +m4_ifset([b4_parse_param], [, b4_parse_param]))[ +{ + YYUSE (yyvaluep); +]b4_locations_if([ YYUSE (yylocationp); +])dnl +b4_parse_param_use[]dnl +[ + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { +]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ + default: + break; + } +}]dnl +]) + + +# b4_yy_symbol_print_generate(FUNCTION-DECLARATOR) +# ------------------------------------------------ +# Generate the "yy_symbol_print" function, which declaration is issued using +# FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C +# or "b4_c_function_def" for K&R. +m4_define_default([b4_yy_symbol_print_generate], +[[ +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +]$1([yy_symbol_value_print], + [static void], + [[FILE *yyoutput], [yyoutput]], + [[int yytype], [yytype]], + [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl +b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl +m4_ifset([b4_parse_param], [, b4_parse_param]))[ +{ + FILE *yyo = yyoutput; + YYUSE (yyo); + if (!yyvaluep) + return; +]b4_locations_if([ YYUSE (yylocationp); +])dnl +b4_parse_param_use[]dnl +[# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# else + YYUSE (yyoutput); +# endif + switch (yytype) + { +]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl +[ default: + break; + } +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +]$1([yy_symbol_print], + [static void], + [[FILE *yyoutput], [yyoutput]], + [[int yytype], [yytype]], + [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl +b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl +m4_ifset([b4_parse_param], [, b4_parse_param]))[ +{ + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + +]b4_locations_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp); + YYFPRINTF (yyoutput, ": "); +])dnl +[ yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl +b4_locations_if([, yylocationp])[]b4_user_args[); + YYFPRINTF (yyoutput, ")"); +}]dnl +]) + +## -------------- ## +## Declarations. ## +## -------------- ## + +# b4_declare_yylstype +# ------------------- +# Declarations that might either go into the header (if --defines) or +# in the parser body. Declare YYSTYPE/YYLTYPE, and yylval/yylloc. +m4_define([b4_declare_yylstype], +[[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED +]m4_ifdef([b4_stype], +[[typedef union ]b4_union_name[ +{ +]b4_user_stype[ +} ]b4_api_PREFIX[STYPE; +# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1]], +[m4_if(b4_tag_seen_flag, 0, +[[typedef int ]b4_api_PREFIX[STYPE; +# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1]])])[ +# define ]b4_api_prefix[stype ]b4_api_PREFIX[STYPE /* obsolescent; will be withdrawn */ +# define ]b4_api_PREFIX[STYPE_IS_DECLARED 1 +#endif]b4_locations_if([[ + +#if ! defined ]b4_api_PREFIX[LTYPE && ! defined ]b4_api_PREFIX[LTYPE_IS_DECLARED +typedef struct ]b4_api_PREFIX[LTYPE +{ + int first_line; + int first_column; + int last_line; + int last_column; +} ]b4_api_PREFIX[LTYPE; +# define ]b4_api_prefix[ltype ]b4_api_PREFIX[LTYPE /* obsolescent; will be withdrawn */ +# define ]b4_api_PREFIX[LTYPE_IS_DECLARED 1 +# define ]b4_api_PREFIX[LTYPE_IS_TRIVIAL 1 +#endif]]) + +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], +[[/* Enabling traces. */ +]m4_if(b4_api_prefix, [yy], +[[#ifndef YYDEBUG +# define YYDEBUG ]b4_debug_flag[ +#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_debug_flag[ +# 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 (YYID (N)) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (YYID (0)) +#endif +]]) + +# b4_yy_location_print_define +# --------------------------- +# Define YY_LOCATION_PRINT. +m4_define([b4_yy_location_print_define], +[b4_locations_if([[ +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +#ifndef __attribute__ +/* This feature is available in gcc versions 2.5 and later. */ +# if (! defined __GNUC__ || __GNUC__ < 2 \ + || (__GNUC__ == 2 && __GNUC_MINOR__ < 5)) +# define __attribute__(Spec) /* empty */ +# endif +#endif + +#ifndef YY_LOCATION_PRINT +# if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL + +/* Print *YYLOCP on YYO. Private, do not rely on its existence. */ + +__attribute__((__unused__)) +]b4_c_function_def([yy_location_print_], + [static unsigned], + [[FILE *yyo], [yyo]], + [[YYLTYPE const * const yylocp], [yylocp]])[ +{ + unsigned res = 0; + int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0; + if (0 <= yylocp->first_line) + { + res += fprintf (yyo, "%d", yylocp->first_line); + if (0 <= yylocp->first_column) + res += fprintf (yyo, ".%d", yylocp->first_column); + } + if (0 <= yylocp->last_line) + { + if (yylocp->first_line < yylocp->last_line) + { + res += fprintf (yyo, "-%d", yylocp->last_line); + if (0 <= end_col) + res += fprintf (yyo, ".%d", end_col); + } + else if (0 <= end_col && yylocp->first_column < end_col) + res += fprintf (yyo, "-%d", end_col); + } + return res; + } + +# define YY_LOCATION_PRINT(File, Loc) \ + yy_location_print_ (File, &(Loc)) + +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif]], +[[/* This macro is provided for backward compatibility. */ +#ifndef YY_LOCATION_PRINT +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +#endif]]) +]) + +# b4_yyloc_default +# ---------------- +# Expand to a possible default value for yylloc. +m4_define([b4_yyloc_default], +[[ +# if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL + = { ]m4_join([, ], + m4_defn([b4_location_initial_line]), + m4_defn([b4_location_initial_column]), + m4_defn([b4_location_initial_line]), + m4_defn([b4_location_initial_column]))[ } +# endif +]]) diff --git a/src/data/glr.c b/src/data/glr.c new file mode 100644 index 0000000..db76f61 --- /dev/null +++ b/src/data/glr.c @@ -0,0 +1,2589 @@ + -*- C -*- + +# GLR skeleton for Bison + +# Copyright (C) 2002-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +# If we are loaded by glr.cc, do not override c++.m4 definitions by +# those of c.m4. +m4_if(b4_skeleton, ["glr.c"], + [m4_include(b4_pkgdatadir/[c.m4])]) + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Stack parameters. +m4_define_default([b4_stack_depth_max], [10000]) +m4_define_default([b4_stack_depth_init], [200]) + + + +## ------------------------ ## +## Pure/impure interfaces. ## +## ------------------------ ## + +b4_define_flag_if([pure]) +# If glr.cc is including this file and thus has already set b4_pure_flag, +# do not change the value of b4_pure_flag, and do not record a use of api.pure. +m4_ifndef([b4_pure_flag], +[b4_percent_define_default([[api.pure]], [[false]]) + m4_define([b4_pure_flag], + [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])]) + +# b4_user_formals +# --------------- +# The possible parse-params formal arguments preceded by a comma. +# +# This is not shared with yacc.c in c.m4 because GLR relies on ISO C +# formal argument declarations. +m4_define([b4_user_formals], +[m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])]) + + +# b4_lex_param +# ------------ +# Accumule in b4_lex_param all the yylex arguments. +# Yes, this is quite ugly... +m4_define([b4_lex_param], +m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl +b4_locations_if([, [[YYLTYPE *], [&yylloc]]])])dnl +m4_ifdef([b4_lex_param], [, ]b4_lex_param))) + + +# b4_yyerror_args +# --------------- +# Optional effective arguments passed to yyerror: user args plus yylloc, and +# a trailing comma. +m4_define([b4_yyerror_args], +[b4_pure_if([b4_locations_if([yylocp, ])])dnl +m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) + + +# b4_lyyerror_args +# ---------------- +# Same as above, but on the lookahead, hence &yylloc instead of yylocp. +m4_define([b4_lyyerror_args], +[b4_pure_if([b4_locations_if([&yylloc, ])])dnl +m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) + + +# b4_pure_args +# ------------ +# Same as b4_yyerror_args, but with a leading comma. +m4_define([b4_pure_args], +[b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args]) + + +# b4_lpure_args +# ------------- +# Same as above, but on the lookahead, hence &yylloc instead of yylocp. +m4_define([b4_lpure_args], +[b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args]) + + + +# b4_pure_formals +# --------------- +# Arguments passed to yyerror: user formals plus yylocp with leading comma. +m4_define([b4_pure_formals], +[b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals]) + + +# b4_locuser_formals(LOC = yylocp) +# -------------------------------- +m4_define([b4_locuser_formals], +[b4_locations_if([, YYLTYPE *m4_default([$1], [yylocp])])[]b4_user_formals]) + + +# b4_locuser_args(LOC = yylocp) +# ----------------------------- +m4_define([b4_locuser_args], +[b4_locations_if([, m4_default([$1], [yylocp])])[]b4_user_args]) + + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_lhs_value([TYPE]) +# -------------------- +# Expansion of $$. +m4_define([b4_lhs_value], +[((*yyvalp)[]m4_ifval([$1], [.$1]))]) + + +# b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) +# -------------------------------------- +# Expansion of $NUM, where the current rule has RULE-LENGTH +# symbols on RHS. +m4_define([b4_rhs_value], +[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3]))]) + + + +## ----------- ## +## Locations. ## +## ----------- ## + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(*yylocp)]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yyloc)]) + + +## -------------- ## +## Declarations. ## +## -------------- ## + +# b4_shared_declarations +# ---------------------- +# Declaration that might either go into the header (if --defines) +# or open coded in the parser body. +m4_define([b4_shared_declarations], +[b4_declare_yydebug[ +]b4_percent_code_get([[requires]])[ +]b4_token_enums(b4_tokens)[ +]b4_declare_yylstype[ +]b4_c_ansi_function_decl(b4_prefix[parse], [int], b4_parse_param)[ +]b4_percent_code_get([[provides]])[]dnl +]) + + +## -------------- ## +## Output files. ## +## -------------- ## + +b4_output_begin([b4_parser_file_name]) +b4_copyright([Skeleton implementation for Bison GLR parsers in C], + [2002-2012])[ + +/* C GLR parser skeleton written by Paul Hilfinger. */ + +]b4_identification + +b4_percent_code_get([[top]])[ +]m4_if(b4_api_prefix, [yy], [], +[[/* Substitute the type names. */ +#define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[ +#define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[ +]m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */ +#define yyparse ]b4_prefix[parse +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char +#define yydebug ]b4_prefix[debug +#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])])[ + +/* Copy the first part of user declarations. */ +]b4_user_pre_prologue[ + +]b4_null_define[ + +]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]], + [b4_shared_declarations])[ + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE ]b4_error_verbose_flag[ +#endif + +/* Default (constant) value used for initialization for null + right-hand sides. Unlike the standard yacc.c template, here we set + the default value of $$ to a zeroed-out value. Since the default + value is undefined, this behavior is technically correct. */ +static YYSTYPE yyval_default;]b4_locations_if([[ +static YYLTYPE yyloc_default][]b4_yyloc_default;])[ + +/* Copy the second part of user declarations. */ +]b4_user_post_prologue +b4_percent_code_get[]dnl + +[#include +#include +#include + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(E) ((void) (E)) +#else +# define YYUSE(E) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +# define YYID(N) (N) +#else +]b4_c_function_def([YYID], [static int], [[int i], [i]])[ +{ + return i; +} +#endif + +#ifndef YYFREE +# define YYFREE free +#endif +#ifndef YYMALLOC +# define YYMALLOC malloc +#endif +#ifndef YYREALLOC +# define YYREALLOC realloc +#endif + +#define YYSIZEMAX ((size_t) -1) + +#ifdef __cplusplus + typedef bool yybool; +#else + typedef unsigned char yybool; +#endif +#define yytrue 1 +#define yyfalse 0 + +#ifndef YYSETJMP +# include +# define YYJMP_BUF jmp_buf +# define YYSETJMP(Env) setjmp (Env) +/* Pacify clang. */ +# define YYLONGJMP(Env, Val) (longjmp (Env, Val), YYASSERT (0)) +#endif + +/*-----------------. +| GCC extensions. | +`-----------------*/ + +#ifndef __attribute__ +/* This feature is available in gcc versions 2.5 and later. */ +# if (! defined __GNUC__ || __GNUC__ < 2 \ + || (__GNUC__ == 2 && __GNUC_MINOR__ < 5)) +# define __attribute__(Spec) /* empty */ +# endif +#endif + +#ifndef YYASSERT +# define YYASSERT(Condition) ((void) ((Condition) || (abort (), 0))) +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL ]b4_final_state_number[ +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST ]b4_last[ + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS ]b4_tokens_number[ +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS ]b4_nterms_number[ +/* YYNRULES -- Number of rules. */ +#define YYNRULES ]b4_rules_number[ +/* YYNRULES -- Number of states. */ +#define YYNSTATES ]b4_states_number[ +/* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */ +#define YYMAXRHS ]b4_r2_max[ +/* YYMAXLEFT -- Maximum number of symbols to the left of a handle + accessed by $0, $-1, etc., in any rule. */ +#define YYMAXLEFT ]b4_max_left_semantic_context[ + +/* YYTRANSLATE(X) -- Bison symbol number corresponding to X. */ +#define YYUNDEFTOK ]b4_undef_token_number[ +#define YYMAXUTOK ]b4_user_token_number_max[ + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const ]b4_int_type_for([b4_translate])[ yytranslate[] = +{ + ]b4_translate[ +}; + +#if ]b4_api_PREFIX[DEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = +{ + ]b4_prhs[ +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = +{ + ]b4_rhs[ +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const ]b4_int_type_for([b4_rline])[ yyrline[] = +{ + ]b4_rline[ +}; +#endif + +#if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[ +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + ]b4_tname[ +}; +#endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const ]b4_int_type_for([b4_r1])[ yyr1[] = +{ + ]b4_r1[ +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const ]b4_int_type_for([b4_r2])[ yyr2[] = +{ + ]b4_r2[ +}; + +/* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ +static const ]b4_int_type_for([b4_dprec])[ yydprec[] = +{ + ]b4_dprec[ +}; + +/* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ +static const ]b4_int_type_for([b4_merger])[ yymerger[] = +{ + ]b4_merger[ +}; + +/* YYDEFACT[S] -- default reduction number in state S. Performed when + YYTABLE doesn't specify something else to do. Zero means the default + is an error. */ +static const ]b4_int_type_for([b4_defact])[ yydefact[] = +{ + ]b4_defact[ +}; + +/* YYPDEFGOTO[NTERM-NUM]. */ +static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = +{ + ]b4_defgoto[ +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF ]b4_pact_ninf[ +static const ]b4_int_type_for([b4_pact])[ yypact[] = +{ + ]b4_pact[ +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = +{ + ]b4_pgoto[ +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF ]b4_table_ninf[ +static const ]b4_int_type_for([b4_table])[ yytable[] = +{ + ]b4_table[ +}; + +/* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of + list of conflicting reductions corresponding to action entry for + state STATE-NUM in yytable. 0 means no conflicts. The list in + yyconfl is terminated by a rule number of 0. */ +static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = +{ + ]b4_conflict_list_heads[ +}; + +/* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by + 0, pointed into by YYCONFLP. */ +]dnl Do not use b4_int_type_for here, since there are places where +dnl pointers onto yyconfl are taken, which type is "short int *". +dnl We probably ought to introduce a type for confl. +[static const short int yyconfl[] = +{ + ]b4_conflicting_rules[ +}; + +static const ]b4_int_type_for([b4_check])[ yycheck[] = +{ + ]b4_check[ +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const ]b4_int_type_for([b4_stos])[ yystos[] = +{ + ]b4_stos[ +}; + +/* Error token number */ +#define YYTERROR 1 + +]b4_locations_if([[ +]b4_yylloc_default_define[ +# define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) +]])[ +]b4_yy_location_print_define[ + +/* YYLEX -- calling `yylex' with the right arguments. */ +#define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ + +]b4_pure_if( +[ +#undef yynerrs +#define yynerrs (yystackp->yyerrcnt) +#undef yychar +#define yychar (yystackp->yyrawchar) +#undef yylval +#define yylval (yystackp->yyval) +#undef yylloc +#define yylloc (yystackp->yyloc) +m4_if(b4_prefix[], [yy], [], +[#define b4_prefix[]nerrs yynerrs +#define b4_prefix[]char yychar +#define b4_prefix[]lval yylval +#define b4_prefix[]lloc yylloc])], +[YYSTYPE yylval;]b4_locations_if([[ +YYLTYPE yylloc;]])[ + +int yynerrs; +int yychar;])[ + +static const int YYEOF = 0; +static const int YYEMPTY = -2; + +typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; + +#define YYCHK(YYE) \ + do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; } \ + while (YYID (0)) + +#if ]b4_api_PREFIX[DEBUG + +# ifndef YYFPRINTF +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (YYID (0)) + +]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[ + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; + +#else /* !]b4_api_PREFIX[DEBUG */ + +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) + +#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 +# if (! 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)) +# define YYSTACKEXPANDABLE 1 +# else +# define YYSTACKEXPANDABLE 0 +# endif +#endif + +#if YYSTACKEXPANDABLE +# define YY_RESERVE_GLRSTACK(Yystack) \ + do { \ + if (Yystack->yyspaceLeft < YYHEADROOM) \ + yyexpandGLRStack (Yystack); \ + } while (YYID (0)) +#else +# define YY_RESERVE_GLRSTACK(Yystack) \ + do { \ + if (Yystack->yyspaceLeft < YYHEADROOM) \ + yyMemoryExhausted (Yystack); \ + } while (YYID (0)) +#endif + + +#if YYERROR_VERBOSE + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +yystpcpy (char *yydest, const char *yysrc) +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static size_t +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + size_t yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return strlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +#endif /* !YYERROR_VERBOSE */ + +/** State numbers, as in LALR(1) machine */ +typedef int yyStateNum; + +/** Rule numbers, as in LALR(1) machine */ +typedef int yyRuleNum; + +/** Grammar symbol */ +typedef short int yySymbol; + +/** Item references, as in LALR(1) machine */ +typedef short int yyItemNum; + +typedef struct yyGLRState yyGLRState; +typedef struct yyGLRStateSet yyGLRStateSet; +typedef struct yySemanticOption yySemanticOption; +typedef union yyGLRStackItem yyGLRStackItem; +typedef struct yyGLRStack yyGLRStack; + +struct yyGLRState { + /** Type tag: always true. */ + yybool yyisState; + /** Type tag for yysemantics. If true, yysval applies, otherwise + * yyfirstVal applies. */ + yybool yyresolved; + /** Number of corresponding LALR(1) machine state. */ + yyStateNum yylrState; + /** Preceding state in this stack */ + yyGLRState* yypred; + /** Source position of the first token produced by my symbol */ + size_t yyposn; + union { + /** First in a chain of alternative reductions producing the + * non-terminal corresponding to this state, threaded through + * yynext. */ + yySemanticOption* yyfirstVal; + /** Semantic value for this state. */ + YYSTYPE yysval; + } yysemantics;]b4_locations_if([[ + /** Source location for this state. */ + YYLTYPE yyloc;]])[ +}; + +struct yyGLRStateSet { + yyGLRState** yystates; + /** During nondeterministic operation, yylookaheadNeeds tracks which + * stacks have actually needed the current lookahead. During deterministic + * operation, yylookaheadNeeds[0] is not maintained since it would merely + * duplicate yychar != YYEMPTY. */ + yybool* yylookaheadNeeds; + size_t yysize, yycapacity; +}; + +struct yySemanticOption { + /** Type tag: always false. */ + yybool yyisState; + /** Rule number for this reduction */ + yyRuleNum yyrule; + /** The last RHS state in the list of states to be reduced. */ + yyGLRState* yystate; + /** The lookahead for this reduction. */ + int yyrawchar; + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ + /** Next sibling in chain of options. To facilitate merging, + * options are chained in decreasing order by address. */ + yySemanticOption* yynext; +}; + +/** Type of the items in the GLR stack. The yyisState field + * indicates which item of the union is valid. */ +union yyGLRStackItem { + yyGLRState yystate; + yySemanticOption yyoption; +}; + +struct yyGLRStack { + int yyerrState; +]b4_locations_if([[ /* To compute the location of the error token. */ + yyGLRStackItem yyerror_range[3];]])[ +]b4_pure_if( +[ + int yyerrcnt; + int yyrawchar; + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ +])[ + YYJMP_BUF yyexception_buffer; + yyGLRStackItem* yyitems; + yyGLRStackItem* yynextFree; + size_t yyspaceLeft; + yyGLRState* yysplitPoint; + yyGLRState* yylastDeleted; + yyGLRStateSet yytops; +}; + +#if YYSTACKEXPANDABLE +static void yyexpandGLRStack (yyGLRStack* yystackp); +#endif + +static void yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) + __attribute__ ((__noreturn__)); +static void +yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) +{ + if (yymsg != YY_NULL) + yyerror (]b4_yyerror_args[yymsg); + YYLONGJMP (yystackp->yyexception_buffer, 1); +} + +static void yyMemoryExhausted (yyGLRStack* yystackp) + __attribute__ ((__noreturn__)); +static void +yyMemoryExhausted (yyGLRStack* yystackp) +{ + YYLONGJMP (yystackp->yyexception_buffer, 2); +} + +#if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE +/** A printable representation of TOKEN. */ +static inline const char* +yytokenName (yySymbol yytoken) +{ + if (yytoken == YYEMPTY) + return ""; + + return yytname[yytoken]; +} +#endif + +/** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting + * at YYVSP[YYLOW0].yystate.yypred. Leaves YYVSP[YYLOW1].yystate.yypred + * containing the pointer to the next state in the chain. */ +static void yyfillin (yyGLRStackItem *, int, int) __attribute__ ((__unused__)); +static void +yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1) +{ + int i; + yyGLRState *s = yyvsp[yylow0].yystate.yypred; + for (i = yylow0-1; i >= yylow1; i -= 1) + { + YYASSERT (s->yyresolved); + yyvsp[i].yystate.yyresolved = yytrue; + yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;]b4_locations_if([[ + yyvsp[i].yystate.yyloc = s->yyloc;]])[ + s = yyvsp[i].yystate.yypred = s->yypred; + } +} + +/* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in + * YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1. + * For convenience, always return YYLOW1. */ +static inline int yyfill (yyGLRStackItem *, int *, int, yybool) + __attribute__ ((__unused__)); +static inline int +yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal) +{ + if (!yynormal && yylow1 < *yylow) + { + yyfillin (yyvsp, *yylow, yylow1); + *yylow = yylow1; + } + return yylow1; +} + +/** Perform user action for rule number YYN, with RHS length YYRHSLEN, + * and top stack item YYVSP. YYLVALP points to place to put semantic + * value ($$), and yylocp points to place for location information + * (@@$). Returns yyok for normal return, yyaccept for YYACCEPT, + * yyerr for YYERROR, yyabort for YYABORT. */ +/*ARGSUSED*/ static YYRESULTTAG +yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, + yyGLRStack* yystackp, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + yybool yynormal __attribute__ ((__unused__)) = + (yystackp->yysplitPoint == YY_NULL); + int yylow; +]b4_parse_param_use[]dnl +[# undef yyerrok +# define yyerrok (yystackp->yyerrState = 0) +# undef YYACCEPT +# define YYACCEPT return yyaccept +# undef YYABORT +# define YYABORT return yyabort +# undef YYERROR +# define YYERROR return yyerrok, yyerr +# undef YYRECOVERING +# define YYRECOVERING() (yystackp->yyerrState != 0) +# undef yyclearin +# define yyclearin (yychar = YYEMPTY) +# undef YYFILL +# define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal) +# undef YYBACKUP +# define YYBACKUP(Token, Value) \ + return yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")), \ + yyerrok, yyerr + + yylow = 1; + if (yyrhslen == 0) + *yyvalp = yyval_default; + else + *yyvalp = yyvsp[YYFILL(1 - (int)yyrhslen)].yystate.yysemantics.yysval; ]b4_locations_if([[ + YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); + yystackp->yyerror_range[1].yystate.yyloc = *yylocp; +]])[ + switch (yyn) + { + ]b4_user_actions[ + default: break; + } + + return yyok; +# undef yyerrok +# undef YYABORT +# undef YYACCEPT +# undef YYERROR +# undef YYBACKUP +# undef yyclearin +# undef YYRECOVERING +} + + +/*ARGSUSED*/ static void +yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) +{ + YYUSE (yy0); + YYUSE (yy1); + + switch (yyn) + { + ]b4_mergers[ + default: break; + } +} + + /* Bison grammar-table manipulation. */ + +]b4_yydestruct_generate([b4_c_ansi_function_def])[ + +/** Number of symbols composing the right hand side of rule #RULE. */ +static inline int +yyrhsLength (yyRuleNum yyrule) +{ + return yyr2[yyrule]; +} + +static void +yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[) +{ + if (yys->yyresolved) + yydestruct (yymsg, yystos[yys->yylrState], + &yys->yysemantics.yysval]b4_locuser_args([&yys->yyloc])[); + else + { +#if ]b4_api_PREFIX[DEBUG + if (yydebug) + { + if (yys->yysemantics.yyfirstVal) + YYFPRINTF (stderr, "%s unresolved ", yymsg); + else + YYFPRINTF (stderr, "%s incomplete ", yymsg); + yy_symbol_print (stderr, yystos[yys->yylrState], + YY_NULL]b4_locuser_args([&yys->yyloc])[); + YYFPRINTF (stderr, "\n"); + } +#endif + + if (yys->yysemantics.yyfirstVal) + { + yySemanticOption *yyoption = yys->yysemantics.yyfirstVal; + yyGLRState *yyrh; + int yyn; + for (yyrh = yyoption->yystate, yyn = yyrhsLength (yyoption->yyrule); + yyn > 0; + yyrh = yyrh->yypred, yyn -= 1) + yydestroyGLRState (yymsg, yyrh]b4_user_args[); + } + } +} + +/** Left-hand-side symbol for rule #RULE. */ +static inline yySymbol +yylhsNonterm (yyRuleNum yyrule) +{ + return yyr1[yyrule]; +} + +#define yypact_value_is_default(Yystate) \ + ]b4_table_value_equals([[pact]], [[Yystate]], [b4_pact_ninf])[ + +/** True iff LR state STATE has only a default reduction (regardless + * of token). */ +static inline yybool +yyisDefaultedState (yyStateNum yystate) +{ + return yypact_value_is_default (yypact[yystate]); +} + +/** The default reduction for STATE, assuming it has one. */ +static inline yyRuleNum +yydefaultAction (yyStateNum yystate) +{ + return yydefact[yystate]; +} + +#define yytable_value_is_error(Yytable_value) \ + ]b4_table_value_equals([[table]], [[Yytable_value]], [b4_table_ninf])[ + +/** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN. + * Result R means + * R < 0: Reduce on rule -R. + * R = 0: Error. + * R > 0: Shift to state R. + * Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of + * conflicting reductions. + */ +static inline void +yygetLRActions (yyStateNum yystate, int yytoken, + int* yyaction, const short int** yyconflicts) +{ + int yyindex = yypact[yystate] + yytoken; + if (yypact_value_is_default (yypact[yystate]) + || yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) + { + *yyaction = -yydefact[yystate]; + *yyconflicts = yyconfl; + } + else if (! yytable_value_is_error (yytable[yyindex])) + { + *yyaction = yytable[yyindex]; + *yyconflicts = yyconfl + yyconflp[yyindex]; + } + else + { + *yyaction = 0; + *yyconflicts = yyconfl + yyconflp[yyindex]; + } +} + +static inline yyStateNum +yyLRgotoState (yyStateNum yystate, yySymbol yylhs) +{ + int yyr; + yyr = yypgoto[yylhs - YYNTOKENS] + yystate; + if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) + return yytable[yyr]; + else + return yydefgoto[yylhs - YYNTOKENS]; +} + +static inline yybool +yyisShiftAction (int yyaction) +{ + return 0 < yyaction; +} + +static inline yybool +yyisErrorAction (int yyaction) +{ + return yyaction == 0; +} + + /* GLRStates */ + +/** Return a fresh GLRStackItem. Callers should call + * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient + * headroom. */ + +static inline yyGLRStackItem* +yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState) +{ + yyGLRStackItem* yynewItem = yystackp->yynextFree; + yystackp->yyspaceLeft -= 1; + yystackp->yynextFree += 1; + yynewItem->yystate.yyisState = yyisState; + return yynewItem; +} + +/** Add a new semantic action that will execute the action for rule + * RULENUM on the semantic values in RHS to the list of + * alternative actions for STATE. Assumes that RHS comes from + * stack #K of *STACKP. */ +static void +yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate, + yyGLRState* rhs, yyRuleNum yyrule) +{ + yySemanticOption* yynewOption = + &yynewGLRStackItem (yystackp, yyfalse)->yyoption; + yynewOption->yystate = rhs; + yynewOption->yyrule = yyrule; + if (yystackp->yytops.yylookaheadNeeds[yyk]) + { + yynewOption->yyrawchar = yychar; + yynewOption->yyval = yylval;]b4_locations_if([ + yynewOption->yyloc = yylloc;])[ + } + else + yynewOption->yyrawchar = YYEMPTY; + yynewOption->yynext = yystate->yysemantics.yyfirstVal; + yystate->yysemantics.yyfirstVal = yynewOption; + + YY_RESERVE_GLRSTACK (yystackp); +} + + /* GLRStacks */ + +/** Initialize SET to a singleton set containing an empty stack. */ +static yybool +yyinitStateSet (yyGLRStateSet* yyset) +{ + yyset->yysize = 1; + yyset->yycapacity = 16; + yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]); + if (! yyset->yystates) + return yyfalse; + yyset->yystates[0] = YY_NULL; + yyset->yylookaheadNeeds = + (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]); + if (! yyset->yylookaheadNeeds) + { + YYFREE (yyset->yystates); + return yyfalse; + } + return yytrue; +} + +static void yyfreeStateSet (yyGLRStateSet* yyset) +{ + YYFREE (yyset->yystates); + YYFREE (yyset->yylookaheadNeeds); +} + +/** Initialize STACK to a single empty stack, with total maximum + * capacity for all stacks of SIZE. */ +static yybool +yyinitGLRStack (yyGLRStack* yystackp, size_t yysize) +{ + yystackp->yyerrState = 0; + yynerrs = 0; + yystackp->yyspaceLeft = yysize; + yystackp->yyitems = + (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystackp->yynextFree[0]); + if (!yystackp->yyitems) + return yyfalse; + yystackp->yynextFree = yystackp->yyitems; + yystackp->yysplitPoint = YY_NULL; + yystackp->yylastDeleted = YY_NULL; + return yyinitStateSet (&yystackp->yytops); +} + + +#if YYSTACKEXPANDABLE +# define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \ + &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE + +/** If STACK is expandable, extend it. WARNING: Pointers into the + stack from outside should be considered invalid after this call. + We always expand when there are 1 or fewer items left AFTER an + allocation, so that we can avoid having external pointers exist + across an allocation. */ +static void +yyexpandGLRStack (yyGLRStack* yystackp) +{ + yyGLRStackItem* yynewItems; + yyGLRStackItem* yyp0, *yyp1; + size_t yynewSize; + size_t yyn; + size_t yysize = yystackp->yynextFree - yystackp->yyitems; + if (YYMAXDEPTH - YYHEADROOM < yysize) + yyMemoryExhausted (yystackp); + yynewSize = 2*yysize; + if (YYMAXDEPTH < yynewSize) + yynewSize = YYMAXDEPTH; + yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]); + if (! yynewItems) + yyMemoryExhausted (yystackp); + for (yyp0 = yystackp->yyitems, yyp1 = yynewItems, yyn = yysize; + 0 < yyn; + yyn -= 1, yyp0 += 1, yyp1 += 1) + { + *yyp1 = *yyp0; + if (*(yybool *) yyp0) + { + yyGLRState* yys0 = &yyp0->yystate; + yyGLRState* yys1 = &yyp1->yystate; + if (yys0->yypred != YY_NULL) + yys1->yypred = + YYRELOC (yyp0, yyp1, yys0->yypred, yystate); + if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != YY_NULL) + yys1->yysemantics.yyfirstVal = + YYRELOC (yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); + } + else + { + yySemanticOption* yyv0 = &yyp0->yyoption; + yySemanticOption* yyv1 = &yyp1->yyoption; + if (yyv0->yystate != YY_NULL) + yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate); + if (yyv0->yynext != YY_NULL) + yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption); + } + } + if (yystackp->yysplitPoint != YY_NULL) + yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems, + yystackp->yysplitPoint, yystate); + + for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1) + if (yystackp->yytops.yystates[yyn] != YY_NULL) + yystackp->yytops.yystates[yyn] = + YYRELOC (yystackp->yyitems, yynewItems, + yystackp->yytops.yystates[yyn], yystate); + YYFREE (yystackp->yyitems); + yystackp->yyitems = yynewItems; + yystackp->yynextFree = yynewItems + yysize; + yystackp->yyspaceLeft = yynewSize - yysize; +} +#endif + +static void +yyfreeGLRStack (yyGLRStack* yystackp) +{ + YYFREE (yystackp->yyitems); + yyfreeStateSet (&yystackp->yytops); +} + +/** Assuming that S is a GLRState somewhere on STACK, update the + * splitpoint of STACK, if needed, so that it is at least as deep as + * S. */ +static inline void +yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys) +{ + if (yystackp->yysplitPoint != YY_NULL && yystackp->yysplitPoint > yys) + yystackp->yysplitPoint = yys; +} + +/** Invalidate stack #K in STACK. */ +static inline void +yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk) +{ + if (yystackp->yytops.yystates[yyk] != YY_NULL) + yystackp->yylastDeleted = yystackp->yytops.yystates[yyk]; + yystackp->yytops.yystates[yyk] = YY_NULL; +} + +/** Undelete the last stack that was marked as deleted. Can only be + done once after a deletion, and only when all other stacks have + been deleted. */ +static void +yyundeleteLastStack (yyGLRStack* yystackp) +{ + if (yystackp->yylastDeleted == YY_NULL || yystackp->yytops.yysize != 0) + return; + yystackp->yytops.yystates[0] = yystackp->yylastDeleted; + yystackp->yytops.yysize = 1; + YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n")); + yystackp->yylastDeleted = YY_NULL; +} + +static inline void +yyremoveDeletes (yyGLRStack* yystackp) +{ + size_t yyi, yyj; + yyi = yyj = 0; + while (yyj < yystackp->yytops.yysize) + { + if (yystackp->yytops.yystates[yyi] == YY_NULL) + { + if (yyi == yyj) + { + YYDPRINTF ((stderr, "Removing dead stacks.\n")); + } + yystackp->yytops.yysize -= 1; + } + else + { + yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi]; + /* In the current implementation, it's unnecessary to copy + yystackp->yytops.yylookaheadNeeds[yyi] since, after + yyremoveDeletes returns, the parser immediately either enters + deterministic operation or shifts a token. However, it doesn't + hurt, and the code might evolve to need it. */ + yystackp->yytops.yylookaheadNeeds[yyj] = + yystackp->yytops.yylookaheadNeeds[yyi]; + if (yyj != yyi) + { + YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n", + (unsigned long int) yyi, (unsigned long int) yyj)); + } + yyj += 1; + } + yyi += 1; + } +} + +/** Shift to a new state on stack #K of STACK, corresponding to LR state + * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */ +static inline void +yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, + size_t yyposn, + YYSTYPE* yyvalp]b4_locations_if([, YYLTYPE* yylocp])[) +{ + yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; + + yynewState->yylrState = yylrState; + yynewState->yyposn = yyposn; + yynewState->yyresolved = yytrue; + yynewState->yypred = yystackp->yytops.yystates[yyk]; + yynewState->yysemantics.yysval = *yyvalp;]b4_locations_if([ + yynewState->yyloc = *yylocp;])[ + yystackp->yytops.yystates[yyk] = yynewState; + + YY_RESERVE_GLRSTACK (yystackp); +} + +/** Shift stack #K of YYSTACK, to a new state corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with the (unresolved) + * semantic value of YYRHS under the action for YYRULE. */ +static inline void +yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, + size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule) +{ + yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; + + yynewState->yylrState = yylrState; + yynewState->yyposn = yyposn; + yynewState->yyresolved = yyfalse; + yynewState->yypred = yystackp->yytops.yystates[yyk]; + yynewState->yysemantics.yyfirstVal = YY_NULL; + yystackp->yytops.yystates[yyk] = yynewState; + + /* Invokes YY_RESERVE_GLRSTACK. */ + yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule); +} + +/** Pop the symbols consumed by reduction #RULE from the top of stack + * #K of STACK, and perform the appropriate semantic action on their + * semantic values. Assumes that all ambiguities in semantic values + * have been previously resolved. Set *VALP to the resulting value, + * and *LOCP to the computed location (if any). Return value is as + * for userAction. */ +static inline YYRESULTTAG +yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + int yynrhs = yyrhsLength (yyrule); + + if (yystackp->yysplitPoint == YY_NULL) + { + /* Standard special case: single stack. */ + yyGLRStackItem* rhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; + YYASSERT (yyk == 0); + yystackp->yynextFree -= yynrhs; + yystackp->yyspaceLeft += yynrhs; + yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate; + return yyuserAction (yyrule, yynrhs, rhs, yystackp, + yyvalp]b4_locuser_args[); + } + else + { + /* At present, doAction is never called in nondeterministic + * mode, so this branch is never taken. It is here in + * anticipation of a future feature that will allow immediate + * evaluation of selected actions in nondeterministic mode. */ + int yyi; + yyGLRState* yys; + yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred + = yystackp->yytops.yystates[yyk];]b4_locations_if([[ + if (yynrhs == 0) + /* Set default location. */ + yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[ + for (yyi = 0; yyi < yynrhs; yyi += 1) + { + yys = yys->yypred; + YYASSERT (yys); + } + yyupdateSplit (yystackp, yys); + yystackp->yytops.yystates[yyk] = yys; + return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + yystackp, yyvalp]b4_locuser_args[); + } +} + +#if !]b4_api_PREFIX[DEBUG +# define YY_REDUCE_PRINT(Args) +#else +# define YY_REDUCE_PRINT(Args) \ +do { \ + if (yydebug) \ + yy_reduce_print Args; \ +} while (YYID (0)) + +/*----------------------------------------------------------. +| Report that the RULE is going to be reduced on stack #K. | +`----------------------------------------------------------*/ + +/*ARGSUSED*/ static inline void +yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + int yynrhs = yyrhsLength (yyrule); + yybool yynormal __attribute__ ((__unused__)) = + (yystackp->yysplitPoint == YY_NULL); + yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; + int yylow = 1; + int yyi; + YYUSE (yyvalp);]b4_locations_if([ + YYUSE (yylocp);])[ +]b4_parse_param_use[]dnl +[ YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n", + (unsigned long int) yyk, yyrule - 1, + (unsigned long int) yyrline[yyrule]); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &]b4_rhs_value(yynrhs, yyi + 1)[ + ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl + b4_user_args[); + YYFPRINTF (stderr, "\n"); + } +} +#endif + +/** Pop items off stack #K of STACK according to grammar rule RULE, + * and push back on the resulting nonterminal symbol. Perform the + * semantic action associated with RULE and store its value with the + * newly pushed state, if FORCEEVAL or if STACK is currently + * unambiguous. Otherwise, store the deferred semantic action with + * the new state. If the new state would have an identical input + * position, LR state, and predecessor to an existing state on the stack, + * it is identified with that existing state, eliminating stack #K from + * the STACK. In this case, the (necessarily deferred) semantic value is + * added to the options for the existing state's semantic value. + */ +static inline YYRESULTTAG +yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, + yybool yyforceEval]b4_user_formals[) +{ + size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn; + + if (yyforceEval || yystackp->yysplitPoint == YY_NULL) + { + YYSTYPE yysval;]b4_locations_if([ + YYLTYPE yyloc;])[ + + YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[)); + YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[)); + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc); + yyglrShift (yystackp, yyk, + yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, + yylhsNonterm (yyrule)), + yyposn, &yysval]b4_locations_if([, &yyloc])[); + } + else + { + size_t yyi; + int yyn; + yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk]; + yyStateNum yynewLRState; + + for (yys = yystackp->yytops.yystates[yyk], yyn = yyrhsLength (yyrule); + 0 < yyn; yyn -= 1) + { + yys = yys->yypred; + YYASSERT (yys); + } + yyupdateSplit (yystackp, yys); + yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule)); + YYDPRINTF ((stderr, + "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n", + (unsigned long int) yyk, yyrule - 1, yynewLRState)); + for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) + if (yyi != yyk && yystackp->yytops.yystates[yyi] != YY_NULL) + { + yyGLRState *yysplit = yystackp->yysplitPoint; + yyGLRState *yyp = yystackp->yytops.yystates[yyi]; + while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn) + { + if (yyp->yylrState == yynewLRState && yyp->yypred == yys) + { + yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule); + yymarkStackDeleted (yystackp, yyk); + YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n", + (unsigned long int) yyk, + (unsigned long int) yyi)); + return yyok; + } + yyp = yyp->yypred; + } + } + yystackp->yytops.yystates[yyk] = yys; + yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule); + } + return yyok; +} + +static size_t +yysplitStack (yyGLRStack* yystackp, size_t yyk) +{ + if (yystackp->yysplitPoint == YY_NULL) + { + YYASSERT (yyk == 0); + yystackp->yysplitPoint = yystackp->yytops.yystates[yyk]; + } + if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity) + { + yyGLRState** yynewStates; + yybool* yynewLookaheadNeeds; + + yynewStates = YY_NULL; + + if (yystackp->yytops.yycapacity + > (YYSIZEMAX / (2 * sizeof yynewStates[0]))) + yyMemoryExhausted (yystackp); + yystackp->yytops.yycapacity *= 2; + + yynewStates = + (yyGLRState**) YYREALLOC (yystackp->yytops.yystates, + (yystackp->yytops.yycapacity + * sizeof yynewStates[0])); + if (yynewStates == YY_NULL) + yyMemoryExhausted (yystackp); + yystackp->yytops.yystates = yynewStates; + + yynewLookaheadNeeds = + (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds, + (yystackp->yytops.yycapacity + * sizeof yynewLookaheadNeeds[0])); + if (yynewLookaheadNeeds == YY_NULL) + yyMemoryExhausted (yystackp); + yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds; + } + yystackp->yytops.yystates[yystackp->yytops.yysize] + = yystackp->yytops.yystates[yyk]; + yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize] + = yystackp->yytops.yylookaheadNeeds[yyk]; + yystackp->yytops.yysize += 1; + return yystackp->yytops.yysize-1; +} + +/** True iff Y0 and Y1 represent identical options at the top level. + * That is, they represent the same rule applied to RHS symbols + * that produce the same terminal symbols. */ +static yybool +yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1) +{ + if (yyy0->yyrule == yyy1->yyrule) + { + yyGLRState *yys0, *yys1; + int yyn; + for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, + yyn = yyrhsLength (yyy0->yyrule); + yyn > 0; + yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) + if (yys0->yyposn != yys1->yyposn) + return yyfalse; + return yytrue; + } + else + return yyfalse; +} + +/** Assuming identicalOptions (Y0,Y1), destructively merge the + * alternative semantic values for the RHS-symbols of Y1 and Y0. */ +static void +yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1) +{ + yyGLRState *yys0, *yys1; + int yyn; + for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, + yyn = yyrhsLength (yyy0->yyrule); + yyn > 0; + yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) + { + if (yys0 == yys1) + break; + else if (yys0->yyresolved) + { + yys1->yyresolved = yytrue; + yys1->yysemantics.yysval = yys0->yysemantics.yysval; + } + else if (yys1->yyresolved) + { + yys0->yyresolved = yytrue; + yys0->yysemantics.yysval = yys1->yysemantics.yysval; + } + else + { + yySemanticOption** yyz0p = &yys0->yysemantics.yyfirstVal; + yySemanticOption* yyz1 = yys1->yysemantics.yyfirstVal; + while (YYID (yytrue)) + { + if (yyz1 == *yyz0p || yyz1 == YY_NULL) + break; + else if (*yyz0p == YY_NULL) + { + *yyz0p = yyz1; + break; + } + else if (*yyz0p < yyz1) + { + yySemanticOption* yyz = *yyz0p; + *yyz0p = yyz1; + yyz1 = yyz1->yynext; + (*yyz0p)->yynext = yyz; + } + yyz0p = &(*yyz0p)->yynext; + } + yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal; + } + } +} + +/** Y0 and Y1 represent two possible actions to take in a given + * parsing state; return 0 if no combination is possible, + * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */ +static int +yypreference (yySemanticOption* y0, yySemanticOption* y1) +{ + yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule; + int p0 = yydprec[r0], p1 = yydprec[r1]; + + if (p0 == p1) + { + if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1]) + return 0; + else + return 1; + } + if (p0 == 0 || p1 == 0) + return 0; + if (p0 < p1) + return 3; + if (p1 < p0) + return 2; + return 0; +} + +static YYRESULTTAG yyresolveValue (yyGLRState* yys, + yyGLRStack* yystackp]b4_user_formals[); + + +/** Resolve the previous N states starting at and including state S. If result + * != yyok, some states may have been left unresolved possibly with empty + * semantic option chains. Regardless of whether result = yyok, each state + * has been left with consistent data so that yydestroyGLRState can be invoked + * if necessary. */ +static YYRESULTTAG +yyresolveStates (yyGLRState* yys, int yyn, + yyGLRStack* yystackp]b4_user_formals[) +{ + if (0 < yyn) + { + YYASSERT (yys->yypred); + YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[)); + if (! yys->yyresolved) + YYCHK (yyresolveValue (yys, yystackp]b4_user_args[)); + } + return yyok; +} + +/** Resolve the states for the RHS of OPT, perform its user action, and return + * the semantic value and location. Regardless of whether result = yyok, all + * RHS states have been destroyed (assuming the user action destroys all RHS + * semantic values if invoked). */ +static YYRESULTTAG +yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, + YYSTYPE* yyvalp]b4_locuser_formals[) +{ + yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; + int yynrhs = yyrhsLength (yyopt->yyrule); + YYRESULTTAG yyflag = + yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[); + if (yyflag != yyok) + { + yyGLRState *yys; + for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1) + yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); + return yyflag; + } + + yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[ + if (yynrhs == 0) + /* Set default location. */ + yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[ + { + int yychar_current = yychar; + YYSTYPE yylval_current = yylval;]b4_locations_if([ + YYLTYPE yylloc_current = yylloc;])[ + yychar = yyopt->yyrawchar; + yylval = yyopt->yyval;]b4_locations_if([ + yylloc = yyopt->yyloc;])[ + yyflag = yyuserAction (yyopt->yyrule, yynrhs, + yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, + yystackp, yyvalp]b4_locuser_args[); + yychar = yychar_current; + yylval = yylval_current;]b4_locations_if([ + yylloc = yylloc_current;])[ + } + return yyflag; +} + +#if ]b4_api_PREFIX[DEBUG +static void +yyreportTree (yySemanticOption* yyx, int yyindent) +{ + int yynrhs = yyrhsLength (yyx->yyrule); + int yyi; + yyGLRState* yys; + yyGLRState* yystates[1 + YYMAXRHS]; + yyGLRState yyleftmost_state; + + for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred) + yystates[yyi] = yys; + if (yys == YY_NULL) + { + yyleftmost_state.yyposn = 0; + yystates[0] = &yyleftmost_state; + } + else + yystates[0] = yys; + + if (yyx->yystate->yyposn < yys->yyposn + 1) + YYFPRINTF (stderr, "%*s%s -> \n", + yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), + yyx->yyrule - 1); + else + YYFPRINTF (stderr, "%*s%s -> \n", + yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), + yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1), + (unsigned long int) yyx->yystate->yyposn); + for (yyi = 1; yyi <= yynrhs; yyi += 1) + { + if (yystates[yyi]->yyresolved) + { + if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) + YYFPRINTF (stderr, "%*s%s \n", yyindent+2, "", + yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1])); + else + YYFPRINTF (stderr, "%*s%s \n", yyindent+2, "", + yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]), + (unsigned long int) (yystates[yyi - 1]->yyposn + 1), + (unsigned long int) yystates[yyi]->yyposn); + } + else + yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2); + } +} +#endif + +/*ARGSUSED*/ static YYRESULTTAG +yyreportAmbiguity (yySemanticOption* yyx0, + yySemanticOption* yyx1]b4_pure_formals[) +{ + YYUSE (yyx0); + YYUSE (yyx1); + +#if ]b4_api_PREFIX[DEBUG + YYFPRINTF (stderr, "Ambiguity detected.\n"); + YYFPRINTF (stderr, "Option 1,\n"); + yyreportTree (yyx0, 2); + YYFPRINTF (stderr, "\nOption 2,\n"); + yyreportTree (yyx1, 2); + YYFPRINTF (stderr, "\n"); +#endif + + yyerror (]b4_yyerror_args[YY_("syntax is ambiguous")); + return yyabort; +}]b4_locations_if([[ + +/** Starting at and including state S1, resolve the location for each of the + * previous N1 states that is unresolved. The first semantic option of a state + * is always chosen. */ +static void +yyresolveLocations (yyGLRState* yys1, int yyn1, + yyGLRStack *yystackp]b4_user_formals[) +{ + if (0 < yyn1) + { + yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[); + if (!yys1->yyresolved) + { + yyGLRStackItem yyrhsloc[1 + YYMAXRHS]; + int yynrhs; + yySemanticOption *yyoption = yys1->yysemantics.yyfirstVal; + YYASSERT (yyoption != YY_NULL); + yynrhs = yyrhsLength (yyoption->yyrule); + if (yynrhs > 0) + { + yyGLRState *yys; + int yyn; + yyresolveLocations (yyoption->yystate, yynrhs, + yystackp]b4_user_args[); + for (yys = yyoption->yystate, yyn = yynrhs; + yyn > 0; + yys = yys->yypred, yyn -= 1) + yyrhsloc[yyn].yystate.yyloc = yys->yyloc; + } + else + { + /* Both yyresolveAction and yyresolveLocations traverse the GSS + in reverse rightmost order. It is only necessary to invoke + yyresolveLocations on a subforest for which yyresolveAction + would have been invoked next had an ambiguity not been + detected. Thus the location of the previous state (but not + necessarily the previous state itself) is guaranteed to be + resolved already. */ + yyGLRState *yyprevious = yyoption->yystate; + yyrhsloc[0].yystate.yyloc = yyprevious->yyloc; + } + { + int yychar_current = yychar; + YYSTYPE yylval_current = yylval; + YYLTYPE yylloc_current = yylloc; + yychar = yyoption->yyrawchar; + yylval = yyoption->yyval; + yylloc = yyoption->yyloc; + YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs); + yychar = yychar_current; + yylval = yylval_current; + yylloc = yylloc_current; + } + } + } +}]])[ + +/** Resolve the ambiguity represented in state S, perform the indicated + * actions, and set the semantic value of S. If result != yyok, the chain of + * semantic options in S has been cleared instead or it has been left + * unmodified except that redundant options may have been removed. Regardless + * of whether result = yyok, S has been left with consistent data so that + * yydestroyGLRState can be invoked if necessary. */ +static YYRESULTTAG +yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[) +{ + yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal; + yySemanticOption* yybest = yyoptionList; + yySemanticOption** yypp; + yybool yymerge = yyfalse; + YYSTYPE yysval; + YYRESULTTAG yyflag;]b4_locations_if([ + YYLTYPE *yylocp = &yys->yyloc;])[ + + for (yypp = &yyoptionList->yynext; *yypp != YY_NULL; ) + { + yySemanticOption* yyp = *yypp; + + if (yyidenticalOptions (yybest, yyp)) + { + yymergeOptionSets (yybest, yyp); + *yypp = yyp->yynext; + } + else + { + switch (yypreference (yybest, yyp)) + { + case 0:]b4_locations_if([[ + yyresolveLocations (yys, 1, yystackp]b4_user_args[);]])[ + return yyreportAmbiguity (yybest, yyp]b4_pure_args[); + break; + case 1: + yymerge = yytrue; + break; + case 2: + break; + case 3: + yybest = yyp; + yymerge = yyfalse; + break; + default: + /* This cannot happen so it is not worth a YYASSERT (yyfalse), + but some compilers complain if the default case is + omitted. */ + break; + } + yypp = &yyp->yynext; + } + } + + if (yymerge) + { + yySemanticOption* yyp; + int yyprec = yydprec[yybest->yyrule]; + yyflag = yyresolveAction (yybest, yystackp, &yysval]b4_locuser_args[); + if (yyflag == yyok) + for (yyp = yybest->yynext; yyp != YY_NULL; yyp = yyp->yynext) + { + if (yyprec == yydprec[yyp->yyrule]) + { + YYSTYPE yysval_other;]b4_locations_if([ + YYLTYPE yydummy;])[ + yyflag = yyresolveAction (yyp, yystackp, &yysval_other]b4_locuser_args([&yydummy])[); + if (yyflag != yyok) + { + yydestruct ("Cleanup: discarding incompletely merged value for", + yystos[yys->yylrState], + &yysval]b4_locuser_args[); + break; + } + yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other); + } + } + } + else + yyflag = yyresolveAction (yybest, yystackp, &yysval]b4_locuser_args([yylocp])[); + + if (yyflag == yyok) + { + yys->yyresolved = yytrue; + yys->yysemantics.yysval = yysval; + } + else + yys->yysemantics.yyfirstVal = YY_NULL; + return yyflag; +} + +static YYRESULTTAG +yyresolveStack (yyGLRStack* yystackp]b4_user_formals[) +{ + if (yystackp->yysplitPoint != YY_NULL) + { + yyGLRState* yys; + int yyn; + + for (yyn = 0, yys = yystackp->yytops.yystates[0]; + yys != yystackp->yysplitPoint; + yys = yys->yypred, yyn += 1) + continue; + YYCHK (yyresolveStates (yystackp->yytops.yystates[0], yyn, yystackp + ]b4_user_args[)); + } + return yyok; +} + +static void +yycompressStack (yyGLRStack* yystackp) +{ + yyGLRState* yyp, *yyq, *yyr; + + if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == YY_NULL) + return; + + for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = YY_NULL; + yyp != yystackp->yysplitPoint; + yyr = yyp, yyp = yyq, yyq = yyp->yypred) + yyp->yypred = yyr; + + yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems; + yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1; + yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems; + yystackp->yysplitPoint = YY_NULL; + yystackp->yylastDeleted = YY_NULL; + + while (yyr != YY_NULL) + { + yystackp->yynextFree->yystate = *yyr; + yyr = yyr->yypred; + yystackp->yynextFree->yystate.yypred = &yystackp->yynextFree[-1].yystate; + yystackp->yytops.yystates[0] = &yystackp->yynextFree->yystate; + yystackp->yynextFree += 1; + yystackp->yyspaceLeft -= 1; + } +} + +static YYRESULTTAG +yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, + size_t yyposn]b4_pure_formals[) +{ + int yyaction; + const short int* yyconflicts; + yyRuleNum yyrule; + + while (yystackp->yytops.yystates[yyk] != YY_NULL) + { + yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState; + YYDPRINTF ((stderr, "Stack %lu Entering state %d\n", + (unsigned long int) yyk, yystate)); + + YYASSERT (yystate != YYFINAL); + + if (yyisDefaultedState (yystate)) + { + yyrule = yydefaultAction (yystate); + if (yyrule == 0) + { + YYDPRINTF ((stderr, "Stack %lu dies.\n", + (unsigned long int) yyk)); + yymarkStackDeleted (yystackp, yyk); + return yyok; + } + YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[)); + } + else + { + yySymbol yytoken; + yystackp->yytops.yylookaheadNeeds[yyk] = yytrue; + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); + + while (*yyconflicts != 0) + { + size_t yynewStack = yysplitStack (yystackp, yyk); + YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n", + (unsigned long int) yynewStack, + (unsigned long int) yyk)); + YYCHK (yyglrReduce (yystackp, yynewStack, + *yyconflicts, yyfalse]b4_user_args[)); + YYCHK (yyprocessOneStack (yystackp, yynewStack, + yyposn]b4_pure_args[)); + yyconflicts += 1; + } + + if (yyisShiftAction (yyaction)) + break; + else if (yyisErrorAction (yyaction)) + { + YYDPRINTF ((stderr, "Stack %lu dies.\n", + (unsigned long int) yyk)); + yymarkStackDeleted (yystackp, yyk); + break; + } + else + YYCHK (yyglrReduce (yystackp, yyk, -yyaction, + yyfalse]b4_user_args[)); + } + } + return yyok; +} + +/*ARGSUSED*/ static void +yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) +{ + if (yystackp->yyerrState != 0) + return; +#if ! YYERROR_VERBOSE + yyerror (]b4_lyyerror_args[YY_("syntax error")); +#else + { + yySymbol yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); + size_t yysize0 = yytnamerr (YY_NULL, yytokenName (yytoken)); + size_t yysize = yysize0; + yybool yysize_overflow = yyfalse; + char* yymsg = YY_NULL; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULL; + /* Arguments of yyformat. */ + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; + + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yytoken != YYEMPTY) + { + int yyn = yypact[yystackp->yytops.yystates[0]->yylrState]; + yyarg[yycount++] = yytokenName (yytoken); + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for this + state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + break; + } + yyarg[yycount++] = yytokenName (yyx); + { + size_t yysz = yysize + yytnamerr (YY_NULL, yytokenName (yyx)); + yysize_overflow |= yysz < yysize; + yysize = yysz; + } + } + } + } + + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + { + size_t yysz = yysize + strlen (yyformat); + yysize_overflow |= yysz < yysize; + yysize = yysz; + } + + if (!yysize_overflow) + yymsg = (char *) YYMALLOC (yysize); + + if (yymsg) + { + char *yyp = yymsg; + int yyi = 0; + while ((*yyp = *yyformat)) + { + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } + } + yyerror (]b4_lyyerror_args[yymsg); + YYFREE (yymsg); + } + else + { + yyerror (]b4_lyyerror_args[YY_("syntax error")); + yyMemoryExhausted (yystackp); + } + } +#endif /* YYERROR_VERBOSE */ + yynerrs += 1; +} + +/* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP, + yylval, and yylloc are the syntactic category, semantic value, and location + of the lookahead. */ +/*ARGSUSED*/ static void +yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) +{ + size_t yyk; + int yyj; + + if (yystackp->yyerrState == 3) + /* We just shifted the error token and (perhaps) took some + reductions. Skip tokens until we can proceed. */ + while (YYID (yytrue)) + { + yySymbol yytoken; + if (yychar == YYEOF) + yyFail (yystackp][]b4_lpure_args[, YY_NULL); + if (yychar != YYEMPTY) + {]b4_locations_if([[ + /* We throw away the lookahead, but the error range + of the shifted error token must take it into account. */ + yyGLRState *yys = yystackp->yytops.yystates[0]; + yyGLRStackItem yyerror_range[3]; + yyerror_range[1].yystate.yyloc = yys->yyloc; + yyerror_range[2].yystate.yyloc = yylloc; + YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Error: discarding", + yytoken, &yylval]b4_locuser_args([&yylloc])[); + } + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + yyj = yypact[yystackp->yytops.yystates[0]->yylrState]; + if (yypact_value_is_default (yyj)) + return; + yyj += yytoken; + if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken) + { + if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0) + return; + } + else if (! yytable_value_is_error (yytable[yyj])) + return; + } + + /* Reduce to one stack. */ + for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1) + if (yystackp->yytops.yystates[yyk] != YY_NULL) + break; + if (yyk >= yystackp->yytops.yysize) + yyFail (yystackp][]b4_lpure_args[, YY_NULL); + for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1) + yymarkStackDeleted (yystackp, yyk); + yyremoveDeletes (yystackp); + yycompressStack (yystackp); + + /* Now pop stack until we find a state that shifts the error token. */ + yystackp->yyerrState = 3; + while (yystackp->yytops.yystates[0] != YY_NULL) + { + yyGLRState *yys = yystackp->yytops.yystates[0]; + yyj = yypact[yys->yylrState]; + if (! yypact_value_is_default (yyj)) + { + yyj += YYTERROR; + if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR + && yyisShiftAction (yytable[yyj])) + { + /* Shift the error token. */]b4_locations_if([[ + /* First adjust its location.*/ + YYLTYPE yyerrloc; + yystackp->yyerror_range[2].yystate.yyloc = yylloc; + YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[ + YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]], + &yylval, &yyerrloc); + yyglrShift (yystackp, 0, yytable[yyj], + yys->yyposn, &yylval]b4_locations_if([, &yyerrloc])[); + yys = yystackp->yytops.yystates[0]; + break; + } + }]b4_locations_if([[ + yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ + if (yys->yypred != YY_NULL) + yydestroyGLRState ("Error: popping", yys]b4_user_args[); + yystackp->yytops.yystates[0] = yys->yypred; + yystackp->yynextFree -= 1; + yystackp->yyspaceLeft += 1; + } + if (yystackp->yytops.yystates[0] == YY_NULL) + yyFail (yystackp][]b4_lpure_args[, YY_NULL); +} + +#define YYCHK1(YYE) \ + do { \ + switch (YYE) { \ + case yyok: \ + break; \ + case yyabort: \ + goto yyabortlab; \ + case yyaccept: \ + goto yyacceptlab; \ + case yyerr: \ + goto yyuser_error; \ + default: \ + goto yybuglab; \ + } \ + } while (YYID (0)) + + +/*----------. +| yyparse. | +`----------*/ + +]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[ +{ + int yyresult; + yyGLRStack yystack; + yyGLRStack* const yystackp = &yystack; + size_t yyposn; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yychar = YYEMPTY; + yylval = yyval_default;]b4_locations_if([ + yylloc = yyloc_default;])[ +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [yylloc])dnl +/* User initialization code. */ +b4_user_initial_action +b4_dollar_popdef])[]dnl +[ + if (! yyinitGLRStack (yystackp, YYINITDEPTH)) + goto yyexhaustedlab; + switch (YYSETJMP (yystack.yyexception_buffer)) + { + case 0: break; + case 1: goto yyabortlab; + case 2: goto yyexhaustedlab; + default: goto yybuglab; + } + yyglrShift (&yystack, 0, 0, 0, &yylval]b4_locations_if([, &yylloc])[); + yyposn = 0; + + while (YYID (yytrue)) + { + /* For efficiency, we have two loops, the first of which is + specialized to deterministic operation (single stack, no + potential ambiguity). */ + /* Standard mode */ + while (YYID (yytrue)) + { + yyRuleNum yyrule; + int yyaction; + const short int* yyconflicts; + + yyStateNum yystate = yystack.yytops.yystates[0]->yylrState; + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + if (yystate == YYFINAL) + goto yyacceptlab; + if (yyisDefaultedState (yystate)) + { + yyrule = yydefaultAction (yystate); + if (yyrule == 0) + { +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[)); + } + else + { + yySymbol yytoken; + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); + if (*yyconflicts != 0) + break; + if (yyisShiftAction (yyaction)) + { + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + yychar = YYEMPTY; + yyposn += 1; + yyglrShift (&yystack, 0, yyaction, yyposn, &yylval]b4_locations_if([, &yylloc])[); + if (0 < yystack.yyerrState) + yystack.yyerrState -= 1; + } + else if (yyisErrorAction (yyaction)) + { +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + else + YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[)); + } + } + + while (YYID (yytrue)) + { + yySymbol yytoken_to_shift; + size_t yys; + + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY; + + /* yyprocessOneStack returns one of three things: + + - An error flag. If the caller is yyprocessOneStack, it + immediately returns as well. When the caller is finally + yyparse, it jumps to an error label via YYCHK1. + + - yyok, but yyprocessOneStack has invoked yymarkStackDeleted + (&yystack, yys), which sets the top state of yys to NULL. Thus, + yyparse's following invocation of yyremoveDeletes will remove + the stack. + + - yyok, when ready to shift a token. + + Except in the first case, yyparse will invoke yyremoveDeletes and + then shift the next token onto all remaining stacks. This + synchronization of the shift (that is, after all preceding + reductions on all stacks) helps prevent double destructor calls + on yylval in the event of memory exhaustion. */ + + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[)); + yyremoveDeletes (&yystack); + if (yystack.yytops.yysize == 0) + { + yyundeleteLastStack (&yystack); + if (yystack.yytops.yysize == 0) + yyFail (&yystack][]b4_lpure_args[, YY_("syntax error")); + YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); + YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + + /* If any yyglrShift call fails, it will fail after shifting. Thus, + a copy of yylval will already be on stack 0 in the event of a + failure in the following loop. Thus, yychar is set to YYEMPTY + before the loop to make sure the user destructor for yylval isn't + called twice. */ + yytoken_to_shift = YYTRANSLATE (yychar); + yychar = YYEMPTY; + yyposn += 1; + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + { + int yyaction; + const short int* yyconflicts; + yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState; + yygetLRActions (yystate, yytoken_to_shift, &yyaction, + &yyconflicts); + /* Note that yyconflicts were handled by yyprocessOneStack. */ + YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys)); + YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc); + yyglrShift (&yystack, yys, yyaction, yyposn, + &yylval]b4_locations_if([, &yylloc])[); + YYDPRINTF ((stderr, "Stack %lu now in state #%d\n", + (unsigned long int) yys, + yystack.yytops.yystates[yys]->yylrState)); + } + + if (yystack.yytops.yysize == 1) + { + YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); + YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); + yycompressStack (&yystack); + break; + } + } + continue; + yyuser_error: + yyrecoverSyntaxError (&yystack]b4_user_args[); + yyposn = yystack.yytops.yystates[0]->yyposn; + } + + yyacceptlab: + yyresult = 0; + goto yyreturn; + + yybuglab: + YYASSERT (yyfalse); + goto yyabortlab; + + yyabortlab: + yyresult = 1; + goto yyreturn; + + yyexhaustedlab: + yyerror (]b4_lyyerror_args[YY_("memory exhausted")); + yyresult = 2; + goto yyreturn; + + yyreturn: + if (yychar != YYEMPTY) + yydestruct ("Cleanup: discarding lookahead", + YYTRANSLATE (yychar), &yylval]b4_locuser_args([&yylloc])[); + + /* If the stack is well-formed, pop the stack until it is empty, + destroying its entries as we go. But free the stack regardless + of whether it is well-formed. */ + if (yystack.yyitems) + { + yyGLRState** yystates = yystack.yytops.yystates; + if (yystates) + { + size_t yysize = yystack.yytops.yysize; + size_t yyk; + for (yyk = 0; yyk < yysize; yyk += 1) + if (yystates[yyk]) + { + while (yystates[yyk]) + { + yyGLRState *yys = yystates[yyk]; +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]] +)[ if (yys->yypred != YY_NULL) + yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); + yystates[yyk] = yys->yypred; + yystack.yynextFree -= 1; + yystack.yyspaceLeft += 1; + } + break; + } + } + yyfreeGLRStack (&yystack); + } + + /* Make sure YYID is used. */ + return YYID (yyresult); +} + +/* DEBUGGING ONLY */ +#if ]b4_api_PREFIX[DEBUG +static void yypstack (yyGLRStack* yystackp, size_t yyk) + __attribute__ ((__unused__)); +static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__)); + +static void +yy_yypstack (yyGLRState* yys) +{ + if (yys->yypred) + { + yy_yypstack (yys->yypred); + YYFPRINTF (stderr, " -> "); + } + YYFPRINTF (stderr, "%d@@%lu", yys->yylrState, + (unsigned long int) yys->yyposn); +} + +static void +yypstates (yyGLRState* yyst) +{ + if (yyst == YY_NULL) + YYFPRINTF (stderr, ""); + else + yy_yypstack (yyst); + YYFPRINTF (stderr, "\n"); +} + +static void +yypstack (yyGLRStack* yystackp, size_t yyk) +{ + yypstates (yystackp->yytops.yystates[yyk]); +} + +#define YYINDEX(YYX) \ + ((YYX) == YY_NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems) + + +static void +yypdumpstack (yyGLRStack* yystackp) +{ + yyGLRStackItem* yyp; + size_t yyi; + for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1) + { + YYFPRINTF (stderr, "%3lu. ", + (unsigned long int) (yyp - yystackp->yyitems)); + if (*(yybool *) yyp) + { + YYFPRINTF (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld", + yyp->yystate.yyresolved, yyp->yystate.yylrState, + (unsigned long int) yyp->yystate.yyposn, + (long int) YYINDEX (yyp->yystate.yypred)); + if (! yyp->yystate.yyresolved) + YYFPRINTF (stderr, ", firstVal: %ld", + (long int) YYINDEX (yyp->yystate + .yysemantics.yyfirstVal)); + } + else + { + YYFPRINTF (stderr, "Option. rule: %d, state: %ld, next: %ld", + yyp->yyoption.yyrule - 1, + (long int) YYINDEX (yyp->yyoption.yystate), + (long int) YYINDEX (yyp->yyoption.yynext)); + } + YYFPRINTF (stderr, "\n"); + } + YYFPRINTF (stderr, "Tops:"); + for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) + YYFPRINTF (stderr, "%lu: %ld; ", (unsigned long int) yyi, + (long int) YYINDEX (yystackp->yytops.yystates[yyi])); + YYFPRINTF (stderr, "\n"); +} +#endif +]b4_epilogue[]dnl +b4_output_end() + +# glr.cc produces its own header. +m4_if(b4_skeleton, ["glr.c"], +[b4_defines_if( +[b4_output_begin([b4_spec_defines_file]) +b4_copyright([Skeleton interface for Bison GLR parsers in C], + [2002-2012])[ + +]b4_cpp_guard_open([b4_spec_defines_file])[ +]b4_shared_declarations[ +]b4_cpp_guard_close([b4_spec_defines_file])[ +]b4_output_end() +])]) diff --git a/src/data/glr.cc b/src/data/glr.cc new file mode 100644 index 0000000..49b4fa1 --- /dev/null +++ b/src/data/glr.cc @@ -0,0 +1,346 @@ + -*- C -*- + +# C++ GLR skeleton for Bison + +# Copyright (C) 2002-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +# This skeleton produces a C++ class that encapsulates a C glr parser. +# This is in order to reduce the maintenance burden. The glr.c +# skeleton is clean and pure enough so that there are no real +# problems. The C++ interface is the same as that of lalr1.cc. In +# fact, glr.c can replace yacc.c without the user noticing any +# difference, and similarly for glr.cc replacing lalr1.cc. +# +# The passing of parse-params +# +# The additional arguments are stored as members of the parser +# object, yyparser. The C routines need to carry yyparser +# throughout the C parser; that easy: just let yyparser become an +# additional parse-param. But because the C++ skeleton needs to +# know the "real" original parse-param, we save them +# (b4_parse_param_orig). Note that b4_parse_param is overquoted +# (and c.m4 strips one level of quotes). This is a PITA, and +# explains why there are so many levels of quotes. +# +# The locations +# +# We use location.cc just like lalr1.cc, but because glr.c stores +# the locations in a (C++) union, the position and location classes +# must not have a constructor. Therefore, contrary to lalr1.cc, we +# must not define "b4_location_constructors". As a consequence the +# user must initialize the first positions (in particular the +# filename member). + +# We require a pure interface using locations. +m4_define([b4_locations_flag], [1]) +m4_define([b4_pure_flag], [1]) + +# The header is mandatory. +b4_defines_if([], + [b4_fatal([b4_skeleton[: using %%defines is mandatory]])]) + +m4_include(b4_pkgdatadir/[c++.m4]) +b4_percent_define_ifdef([[api.location.type]], [], + [m4_include(b4_pkgdatadir/[location.cc])]) + +m4_define([b4_parser_class_name], + [b4_percent_define_get([[parser_class_name]])]) + +# Save the parse parameters. +m4_define([b4_parse_param_orig], m4_defn([b4_parse_param])) + + +# b4_yy_symbol_print_generate +# --------------------------- +# Bypass the default implementation to generate the "yy_symbol_print" +# and "yy_symbol_value_print" functions. +m4_define([b4_yy_symbol_print_generate], +[[ +/*--------------------. +| Print this symbol. | +`--------------------*/ + +]b4_c_ansi_function_def([yy_symbol_print], + [static void], + [[FILE *], []], + [[int yytype], [yytype]], + [[const ]b4_namespace_ref::b4_parser_class_name[::semantic_type *yyvaluep], + [yyvaluep]], + [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], + [yylocationp]], + b4_parse_param)[ +{ +]b4_parse_param_use[]dnl +[ yyparser.yy_symbol_print_ (yytype, yyvaluep]b4_locations_if([, yylocationp])[); +} +]])[ + +# Hijack the initial action to initialize the locations. +]b4_locations_if([b4_percent_define_ifdef([[api.location.type]], [], +[m4_define([b4_initial_action], +[yylloc.initialize ();]m4_ifdef([b4_initial_action], [ +m4_defn([b4_initial_action])]))])])[ + +# Hijack the post prologue to insert early definition of YYLLOC_DEFAULT +# and declaration of yyerror. +]m4_append([b4_post_prologue], +[b4_syncline([@oline@], [@ofile@])[ +]b4_yylloc_default_define[ +#define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) +]b4_c_ansi_function_decl([yyerror], + [static void], + [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], + [yylocationp]], + b4_parse_param, + [[const char* msg], [msg]])]) + + +# Hijack the epilogue to define implementations (yyerror, parser member +# functions etc.). +m4_append([b4_epilogue], +[b4_syncline([@oline@], [@ofile@])[ +/*------------------. +| Report an error. | +`------------------*/ + +]b4_c_ansi_function_def([yyerror], + [static void], + [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], + [yylocationp]], + b4_parse_param, + [[const char* msg], [msg]])[ +{ +]b4_parse_param_use[]dnl +[ yyparser.error (*yylocationp, msg); +} + + +]b4_namespace_open[ +]dnl In this section, the parse param are the original parse_params. +m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl +[ /// Build a parser object. + ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ + :])[ +#if ]b4_api_PREFIX[DEBUG + ]m4_ifset([b4_parse_param], [ ], [ :])[ + yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ +#endif]b4_parse_param_cons[ + { + } + + ]b4_parser_class_name::~b4_parser_class_name[ () + { + } + + int + ]b4_parser_class_name[::parse () + { + return ::yyparse (*this]b4_user_args[); + } + +#if ]b4_api_PREFIX[DEBUG + /*--------------------. + | Print this symbol. | + `--------------------*/ + + inline void + ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, + const semantic_type* yyvaluep, + const location_type* yylocationp) + { + YYUSE (yylocationp); + YYUSE (yyvaluep); + std::ostream& yyoutput = debug_stream (); + std::ostream& yyo = yyoutput; + YYUSE (yyo); + switch (yytype) + { + ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl +[ default: + break; + } + } + + + void + ]b4_parser_class_name[::yy_symbol_print_ (int yytype, + const semantic_type* yyvaluep, + const location_type* yylocationp) + { + *yycdebug_ << (yytype < YYNTOKENS ? "token" : "nterm") + << ' ' << yytname[yytype] << " (" + << *yylocationp << ": "; + yy_symbol_value_print_ (yytype, yyvaluep, yylocationp); + *yycdebug_ << ')'; + } + + std::ostream& + ]b4_parser_class_name[::debug_stream () const + { + return *yycdebug_; + } + + void + ]b4_parser_class_name[::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + ]b4_parser_class_name[::debug_level_type + ]b4_parser_class_name[::debug_level () const + { + return yydebug; + } + + void + ]b4_parser_class_name[::set_debug_level (debug_level_type l) + { + // Actually, it is yydebug which is really used. + yydebug = l; + } + +#endif +]m4_popdef([b4_parse_param])dnl +b4_namespace_close]) + + +# Let glr.c believe that the user arguments include the parser itself. +m4_ifset([b4_parse_param], +[m4_pushdef([b4_parse_param], + [[b4_namespace_ref::b4_parser_class_name[& yyparser], [[yyparser]]],] +m4_defn([b4_parse_param]))], +[m4_pushdef([b4_parse_param], + [[b4_namespace_ref::b4_parser_class_name[& yyparser], [[yyparser]]]]) +]) +m4_include(b4_pkgdatadir/[glr.c]) +m4_popdef([b4_parse_param]) + +b4_output_begin([b4_spec_defines_file]) +b4_copyright([Skeleton interface for Bison GLR parsers in C++], + [2002-2006, 2009-2012])[ + +/* C++ GLR parser skeleton written by Akim Demaille. */ + +]b4_cpp_guard_open([b4_spec_defines_file])[ + +]b4_percent_code_get([[requires]])[ + +# include +# include +]b4_percent_define_ifdef([[api.location.type]], [], + [[# include "location.hh"]])[ + +]b4_YYDEBUG_define[ + +]b4_namespace_open[ + /// A Bison parser. + class ]b4_parser_class_name[ + { + public: + /// Symbol semantic values. +# ifndef ]b4_api_PREFIX[STYPE +]m4_ifdef([b4_stype], +[ union semantic_type + { +b4_user_stype + };], +[m4_if(b4_tag_seen_flag, 0, +[[ typedef int semantic_type;]], +[[ typedef ]b4_api_PREFIX[STYPE semantic_type;]])])[ +# else + typedef ]b4_api_PREFIX[STYPE semantic_type; +# endif + /// Symbol locations. + typedef ]b4_percent_define_get([[api.location.type]], + [[location]])[ location_type; + /// Tokens. + struct token + { + ]b4_token_enums(b4_tokens)[ + }; + /// Token type. + typedef token::yytokentype token_type; + + /// Build a parser object. + ]b4_parser_class_name[ (]b4_parse_param_decl[); + virtual ~]b4_parser_class_name[ (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + virtual int parse (); + + /// The current debugging stream. + std::ostream& debug_stream () const; + /// Set the current debugging stream. + void set_debug_stream (std::ostream &); + + /// Type for debugging levels. + typedef int debug_level_type; + /// The current debugging level. + debug_level_type debug_level () const; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); + + private: + + public: + /// Report a syntax error. + /// \param loc where the syntax error is found. + /// \param msg a description of the syntax error. + virtual void error (const location_type& loc, const std::string& msg); + private: + +# if ]b4_api_PREFIX[DEBUG + public: + /// \brief Report a symbol value on the debug stream. + /// \param yytype The token type. + /// \param yyvaluep Its semantic value. + /// \param yylocationp Its location. + virtual void yy_symbol_value_print_ (int yytype, + const semantic_type* yyvaluep, + const location_type* yylocationp); + /// \brief Report a symbol on the debug stream. + /// \param yytype The token type. + /// \param yyvaluep Its semantic value. + /// \param yylocationp Its location. + virtual void yy_symbol_print_ (int yytype, + const semantic_type* yyvaluep, + const location_type* yylocationp); + private: + /* Debugging. */ + std::ostream* yycdebug_; +# endif + +]b4_parse_param_vars[ + }; + +]dnl Redirections for glr.c. +b4_percent_define_flag_if([[global_tokens_and_yystype]], +[b4_token_defines(b4_tokens)]) +[ +#ifndef ]b4_api_PREFIX[STYPE +# define ]b4_api_PREFIX[STYPE ]b4_namespace_ref[::]b4_parser_class_name[::semantic_type +#endif +#ifndef ]b4_api_PREFIX[LTYPE +# define ]b4_api_PREFIX[LTYPE ]b4_namespace_ref[::]b4_parser_class_name[::location_type +#endif + +]b4_namespace_close[ +]b4_percent_code_get([[provides]])[ +]b4_cpp_guard_close([b4_spec_defines_file])[ +]b4_output_end() diff --git a/src/data/java-skel.m4 b/src/data/java-skel.m4 new file mode 100644 index 0000000..81bf02a --- /dev/null +++ b/src/data/java-skel.m4 @@ -0,0 +1,26 @@ + -*- Autoconf -*- + +# Java skeleton dispatching for Bison. + +# Copyright (C) 2007, 2009-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +b4_glr_if( [b4_complain([%%glr-parser not supported for Java])]) +b4_nondeterministic_if([b4_complain([%%nondeterministic-parser not supported for Java])]) + +m4_define_default([b4_used_skeleton], [b4_pkgdatadir/[lalr1.java]]) +m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"]) + +m4_include(b4_used_skeleton) diff --git a/src/data/java.m4 b/src/data/java.m4 new file mode 100644 index 0000000..627028b --- /dev/null +++ b/src/data/java.m4 @@ -0,0 +1,304 @@ + -*- Autoconf -*- + +# Java language support for Bison + +# Copyright (C) 2007-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_include(b4_pkgdatadir/[c-like.m4]) + +# b4_comment(TEXT) +# ---------------- +m4_define([b4_comment], [/* m4_bpatsubst([$1], [ +], [ + ]) */]) + + +# b4_list2(LIST1, LIST2) +# -------------------------- +# Join two lists with a comma if necessary. +m4_define([b4_list2], + [$1[]m4_ifval(m4_quote($1), [m4_ifval(m4_quote($2), [[, ]])])[]$2]) + + +# b4_percent_define_get3(DEF, PRE, POST, NOT) +# ------------------------------------------- +# Expand to the value of DEF surrounded by PRE and POST if it's %define'ed, +# otherwise NOT. +m4_define([b4_percent_define_get3], + [m4_ifval(m4_quote(b4_percent_define_get([$1])), + [$2[]b4_percent_define_get([$1])[]$3], [$4])]) + + + +# b4_flag_value(BOOLEAN-FLAG) +# --------------------------- +m4_define([b4_flag_value], [b4_flag_if([$1], [true], [false])]) + + +# b4_public_if(TRUE, FALSE) +# ------------------------- +b4_percent_define_default([[public]], [[false]]) +m4_define([b4_public_if], +[b4_percent_define_flag_if([public], [$1], [$2])]) + + +# b4_abstract_if(TRUE, FALSE) +# --------------------------- +b4_percent_define_default([[abstract]], [[false]]) +m4_define([b4_abstract_if], +[b4_percent_define_flag_if([abstract], [$1], [$2])]) + + +# b4_final_if(TRUE, FALSE) +# --------------------------- +b4_percent_define_default([[final]], [[false]]) +m4_define([b4_final_if], +[b4_percent_define_flag_if([final], [$1], [$2])]) + + +# b4_strictfp_if(TRUE, FALSE) +# --------------------------- +b4_percent_define_default([[strictfp]], [[false]]) +m4_define([b4_strictfp_if], +[b4_percent_define_flag_if([strictfp], [$1], [$2])]) + + +# b4_lexer_if(TRUE, FALSE) +# ------------------------ +m4_define([b4_lexer_if], +[b4_percent_code_ifdef([[lexer]], [$1], [$2])]) + + +# b4_identification +# ----------------- +m4_define([b4_identification], +[ /** Version number for the Bison executable that generated this parser. */ + public static final String bisonVersion = "b4_version"; + + /** Name of the skeleton that generated this parser. */ + public static final String bisonSkeleton = b4_skeleton; +]) + + +## ------------ ## +## Data types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# MIN to MAX (included). +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [-128], [127]), [1], [byte], + b4_ints_in($@, [-32768], [32767]), [1], [short], + [int])]) + +# b4_int_type_for(NAME) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# `NAME_min' to `NAME_max' (included). +m4_define([b4_int_type_for], +[b4_int_type($1_min, $1_max)]) + +# b4_null +# ------- +m4_define([b4_null], [null]) + + +## ------------------------- ## +## Assigning token numbers. ## +## ------------------------- ## + +# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER) +# --------------------------------------- +# Output the definition of this token as an enum. +m4_define([b4_token_enum], +[ /** Token number, to be returned by the scanner. */ + public static final int $1 = $2; +]) + + +# b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) +# ----------------------------------------------------- +# Output the definition of the tokens (if there are) as enums. +m4_define([b4_token_enums], +[m4_if([$#$1], [1], [], +[/* Tokens. */ +m4_map([b4_token_enum], [$@])]) +]) + +# b4-case(ID, CODE) +# ----------------- +# We need to fool Java's stupid unreachable code detection. +m4_define([b4_case], [ case $1: + if (yyn == $1) + $2; + break; + ]) + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +m4_define([b4_yystype], [b4_percent_define_get([[stype]])]) +b4_percent_define_default([[stype]], [[Object]]) + +# %name-prefix +m4_define_default([b4_prefix], [[YY]]) + +b4_percent_define_default([[parser_class_name]], [b4_prefix[]Parser]) +m4_define([b4_parser_class_name], [b4_percent_define_get([[parser_class_name]])]) + +b4_percent_define_default([[lex_throws]], [[java.io.IOException]]) +m4_define([b4_lex_throws], [b4_percent_define_get([[lex_throws]])]) + +b4_percent_define_default([[throws]], []) +m4_define([b4_throws], [b4_percent_define_get([[throws]])]) + +b4_percent_define_default([[api.location.type]], [Location]) +m4_define([b4_location_type], [b4_percent_define_get([[api.location.type]])]) + +b4_percent_define_default([[api.position.type]], [Position]) +m4_define([b4_position_type], [b4_percent_define_get([[api.position.type]])]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_lhs_value([TYPE]) +# -------------------- +# Expansion of $$. +m4_define([b4_lhs_value], [yyval]) + + +# b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) +# -------------------------------------- +# Expansion of $NUM, where the current rule has RULE-LENGTH +# symbols on RHS. +# +# In this simple implementation, %token and %type have class names +# between the angle brackets. +m4_define([b4_rhs_value], +[(m4_ifval($3, [($3)])[](yystack.valueAt ($1-($2))))]) + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[yystack.locationAt ($1-($2))]) + + +# b4_lex_param +# b4_parse_param +# -------------- +# If defined, b4_lex_param arrives double quoted, but below we prefer +# it to be single quoted. Same for b4_parse_param. + +# TODO: should be in bison.m4 +m4_define_default([b4_lex_param], [[]]) +m4_define([b4_lex_param], b4_lex_param) +m4_define([b4_parse_param], b4_parse_param) + +# b4_lex_param_decl +# ------------------- +# Extra formal arguments of the constructor. +m4_define([b4_lex_param_decl], +[m4_ifset([b4_lex_param], + [b4_remove_comma([$1], + b4_param_decls(b4_lex_param))], + [$1])]) + +m4_define([b4_param_decls], + [m4_map([b4_param_decl], [$@])]) +m4_define([b4_param_decl], [, $1]) + +m4_define([b4_remove_comma], [m4_ifval(m4_quote($1), [$1, ], [])m4_shift2($@)]) + + + +# b4_parse_param_decl +# ------------------- +# Extra formal arguments of the constructor. +m4_define([b4_parse_param_decl], +[m4_ifset([b4_parse_param], + [b4_remove_comma([$1], + b4_param_decls(b4_parse_param))], + [$1])]) + + + +# b4_lex_param_call +# ------------------- +# Delegating the lexer parameters to the lexer constructor. +m4_define([b4_lex_param_call], + [m4_ifset([b4_lex_param], + [b4_remove_comma([$1], + b4_param_calls(b4_lex_param))], + [$1])]) +m4_define([b4_param_calls], + [m4_map([b4_param_call], [$@])]) +m4_define([b4_param_call], [, $2]) + + + +# b4_parse_param_cons +# ------------------- +# Extra initialisations of the constructor. +m4_define([b4_parse_param_cons], + [m4_ifset([b4_parse_param], + [b4_constructor_calls(b4_parse_param)])]) + +m4_define([b4_constructor_calls], + [m4_map([b4_constructor_call], [$@])]) +m4_define([b4_constructor_call], + [this.$2 = $2; + ]) + + + +# b4_parse_param_vars +# ------------------- +# Extra instance variables. +m4_define([b4_parse_param_vars], + [m4_ifset([b4_parse_param], + [ + /* User arguments. */ +b4_var_decls(b4_parse_param)])]) + +m4_define([b4_var_decls], + [m4_map_sep([b4_var_decl], [ +], [$@])]) +m4_define([b4_var_decl], + [ protected final $1;]) + + + +# b4_maybe_throws(THROWS) +# ----------------------- +# Expand to either an empty string or "throws THROWS". +m4_define([b4_maybe_throws], + [m4_ifval($1, [throws $1])]) diff --git a/src/data/lalr1.cc b/src/data/lalr1.cc new file mode 100644 index 0000000..237b246 --- /dev/null +++ b/src/data/lalr1.cc @@ -0,0 +1,1143 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_include(b4_pkgdatadir/[c++.m4]) + +m4_define([b4_parser_class_name], + [b4_percent_define_get([[parser_class_name]])]) + +# The header is mandatory. +b4_defines_if([], + [b4_fatal([b4_skeleton[: using %%defines is mandatory]])]) + +b4_percent_define_ifdef([[api.location.type]], [], + [# Backward compatibility. + m4_define([b4_location_constructors]) + m4_include(b4_pkgdatadir/[location.cc])]) +m4_include(b4_pkgdatadir/[stack.hh]) + +b4_defines_if( +[b4_output_begin([b4_spec_defines_file]) +b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++], + [2002-2012]) +[ +/** + ** \file ]b4_spec_defines_file[ + ** Define the ]b4_namespace_ref[::parser class. + */ + +/* C++ LALR(1) parser skeleton written by Akim Demaille. */ + +]b4_cpp_guard_open([b4_spec_defines_file])[ + +]b4_percent_code_get([[requires]])[ + +#include +#include +#include "stack.hh" +]b4_percent_define_ifdef([[api.location.type]], [], + [[#include "location.hh"]])[ + +]b4_YYDEBUG_define[ + +]b4_namespace_open[ + + /// A Bison parser. + class ]b4_parser_class_name[ + { + public: + /// Symbol semantic values. +#ifndef ]b4_api_PREFIX[STYPE +]m4_ifdef([b4_stype], +[ union semantic_type + { +b4_user_stype + };], +[m4_if(b4_tag_seen_flag, 0, +[[ typedef int semantic_type;]], +[[ typedef ]b4_api_PREFIX[STYPE semantic_type;]])])[ +#else + typedef ]b4_api_PREFIX[STYPE semantic_type; +#endif + /// Symbol locations. + typedef ]b4_percent_define_get([[api.location.type]], + [[location]])[ location_type; + /// Tokens. + struct token + { + ]b4_token_enums(b4_tokens)[ + }; + /// Token type. + typedef token::yytokentype token_type; + + /// Build a parser object. + ]b4_parser_class_name[ (]b4_parse_param_decl[); + virtual ~]b4_parser_class_name[ (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + virtual int parse (); + +#if ]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 + + private: + /// Report a syntax error. + /// \param loc where the syntax error is found. + /// \param msg a description of the syntax error. + virtual void error (const location_type& loc, const std::string& msg); + + /// Generate an error message. + /// \param state the state where the error occurred. + /// \param tok the lookahead token. + virtual std::string yysyntax_error_ (int yystate, int tok); + +#if ]b4_api_PREFIX[DEBUG + /// \brief Report a symbol value on the debug stream. + /// \param yytype The token type. + /// \param yyvaluep Its semantic value. + /// \param yylocationp Its location. + virtual void yy_symbol_value_print_ (int yytype, + const semantic_type* yyvaluep, + const location_type* yylocationp); + /// \brief Report a symbol on the debug stream. + /// \param yytype The token type. + /// \param yyvaluep Its semantic value. + /// \param yylocationp Its location. + virtual void yy_symbol_print_ (int yytype, + const semantic_type* yyvaluep, + const location_type* yylocationp); +#endif + + + /// State numbers. + typedef int state_type; + /// State stack type. + typedef stack state_stack_type; + /// Semantic value stack type. + typedef stack semantic_stack_type; + /// location stack type. + typedef stack location_stack_type; + + /// The state stack. + state_stack_type yystate_stack_; + /// The semantic value stack. + semantic_stack_type yysemantic_stack_; + /// The location stack. + location_stack_type yylocation_stack_; + + /// Whether the given \c yypact_ value indicates a defaulted state. + /// \param yyvalue the value to check + static bool yy_pact_value_is_default_ (int yyvalue); + + /// Whether the given \c yytable_ value indicates a syntax error. + /// \param yyvalue the value to check + static bool yy_table_value_is_error_ (int yyvalue); + + /// Internal symbol numbers. + typedef ]b4_int_type_for([b4_translate])[ token_number_type; + /* Tables. */ + /// For a state, the index in \a yytable_ of its portion. + static const ]b4_int_type_for([b4_pact])[ yypact_[]; + static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_; + + /// For a state, default reduction number. + /// Unless\a yytable_ specifies something else to do. + /// Zero means the default is an error. + static const ]b4_int_type_for([b4_defact])[ yydefact_[]; + + static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[]; + static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[]; + + /// What to do in a state. + /// \a yytable_[yypact_[s]]: what to do in state \a s. + /// - if positive, shift that token. + /// - if negative, reduce the rule which number is the opposite. + /// - if zero, do what YYDEFACT says. + static const ]b4_int_type_for([b4_table])[ yytable_[]; + static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_; + + static const ]b4_int_type_for([b4_check])[ yycheck_[]; + + /// For a state, its accessing symbol. + static const ]b4_int_type_for([b4_stos])[ yystos_[]; + + /// For a rule, its LHS. + static const ]b4_int_type_for([b4_r1])[ yyr1_[]; + /// For a rule, its RHS length. + static const ]b4_int_type_for([b4_r2])[ yyr2_[]; ]b4_error_verbose_if([ + + /// Convert the symbol name \a n to a form suitable for a diagnostic. + static std::string yytnamerr_ (const char *n);])[ + +]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[ + /// For a symbol, its name in clear. + static const char* const yytname_[]; +]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[ + /// A type to store symbol numbers and -1. + typedef ]b4_int_type_for([b4_rhs])[ rhs_number_type; + /// A `-1'-separated list of the rules' RHS. + static const rhs_number_type yyrhs_[]; + /// For each rule, the index of the first RHS symbol in \a yyrhs_. + static const ]b4_int_type_for([b4_prhs])[ yyprhs_[]; + /// For each rule, its source line number. + static const ]b4_int_type_for([b4_rline])[ yyrline_[]; + /// For each scanner token number, its symbol number. + static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[]; + /// Report on the debug stream that the rule \a r is going to be reduced. + virtual void yy_reduce_print_ (int r); + /// Print the state stack on the debug stream. + virtual void yystack_print_ (); + + /* Debugging. */ + int yydebug_; + std::ostream* yycdebug_; +#endif + + /// Convert a scanner token number \a t to a symbol number. + token_number_type yytranslate_ (int t); + + /// \brief Reclaim the memory associated to a symbol. + /// \param yymsg Why this token is reclaimed. + /// If null, do not display the symbol, just free it. + /// \param yytype The symbol type. + /// \param yyvaluep Its semantic value. + /// \param yylocationp Its location. + inline void yydestruct_ (const char* yymsg, + int yytype, + semantic_type* yyvaluep, + location_type* yylocationp); + + /// Pop \a n symbols the three stacks. + inline void yypop_ (unsigned int n = 1); + + /* Constants. */ + static const int yyeof_; + /* LAST_ -- Last index in TABLE_. */ + static const int yylast_; + static const int yynnts_; + static const int yyempty_; + static const int yyfinal_; + static const int yyterror_; + static const int yyerrcode_; + static const int yyntokens_; + static const unsigned int yyuser_token_number_max_; + static const token_number_type yyundef_token_; +]b4_parse_param_vars[ + }; +]b4_namespace_close[ + +]b4_percent_define_flag_if([[global_tokens_and_yystype]], +[b4_token_defines(b4_tokens) + +#ifndef ]b4_api_PREFIX[STYPE + /* Redirection for backward compatibility. */ +# define ]b4_api_PREFIX[STYPE b4_namespace_ref::b4_parser_class_name::semantic_type +#endif +])[ +]b4_percent_code_get([[provides]])[ +]b4_cpp_guard_close([b4_spec_defines_file]) +b4_output_end() +]) + + +b4_output_begin([b4_parser_file_name]) +b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++], + [2002-2012]) +b4_percent_code_get([[top]])[]dnl +m4_if(b4_prefix, [yy], [], +[ +// Take the name prefix into account. +#define yylex b4_prefix[]lex])[ + +/* First part of user declarations. */ +]b4_user_pre_prologue[ + +]b4_defines_if([[ +#include "@basename(]b4_spec_defines_file[@)"]])[ + +/* User implementation prologue. */ +]b4_user_post_prologue[ +]b4_percent_code_get[ + +]b4_null_define[ + +#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 + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +]b4_yylloc_default_define[ + +/* Suppress unused-variable warnings by "using" E. */ +#define YYUSE(e) ((void) (e)) + +/* Enable debugging if requested. */ +#if ]b4_api_PREFIX[DEBUG + +/* A pseudo ostream that takes yydebug_ into account. */ +# define YYCDEBUG if (yydebug_) (*yycdebug_) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug_) \ + { \ + *yycdebug_ << Title << ' '; \ + yy_symbol_print_ ((Type), (Value), (Location)); \ + *yycdebug_ << std::endl; \ + } \ +} while (false) + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug_) \ + yy_reduce_print_ (Rule); \ +} while (false) + +# define YY_STACK_PRINT() \ +do { \ + if (yydebug_) \ + yystack_print_ (); \ +} while (false) + +#else /* !]b4_api_PREFIX[DEBUG */ + +# define YYCDEBUG if (false) std::cerr +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) YYUSE(Type) +# 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 (yychar = yyempty_) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYRECOVERING() (!!yyerrstatus_) + +]b4_namespace_open[]b4_error_verbose_if([[ + + /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ + std::string + ]b4_parser_class_name[::yytnamerr_ (const char *yystr) + { + if (*yystr == '"') + { + std::string yyr = ""; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + yyr += *yyp; + break; + + case '"': + return yyr; + } + do_not_strip_quotes: ; + } + + return yystr; + } +]])[ + + /// Build a parser object. + ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ + :])[ +#if ]b4_api_PREFIX[DEBUG + ]m4_ifset([b4_parse_param], [ ], [ :])[yydebug_ (false), + yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ +#endif]b4_parse_param_cons[ + { + } + + ]b4_parser_class_name::~b4_parser_class_name[ () + { + } + +#if ]b4_api_PREFIX[DEBUG + /*--------------------------------. + | Print this symbol on YYOUTPUT. | + `--------------------------------*/ + + inline void + ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, + const semantic_type* yyvaluep, const location_type* yylocationp) + { + YYUSE (yylocationp); + YYUSE (yyvaluep); + std::ostream& yyo = debug_stream (); + std::ostream& yyoutput = yyo; + YYUSE (yyoutput); + switch (yytype) + { + ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl +[ default: + break; + } + } + + + void + ]b4_parser_class_name[::yy_symbol_print_ (int yytype, + const semantic_type* yyvaluep, const location_type* yylocationp) + { + *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm") + << ' ' << yytname_[yytype] << " (" + << *yylocationp << ": "; + yy_symbol_value_print_ (yytype, yyvaluep, yylocationp); + *yycdebug_ << ')'; + } +#endif + + void + ]b4_parser_class_name[::yydestruct_ (const char* yymsg, + int yytype, semantic_type* yyvaluep, location_type* yylocationp) + { + YYUSE (yylocationp); + YYUSE (yymsg); + YYUSE (yyvaluep); + + if (yymsg) + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ + default: + break; + } + } + + void + ]b4_parser_class_name[::yypop_ (unsigned int n) + { + yystate_stack_.pop (n); + yysemantic_stack_.pop (n); + yylocation_stack_.pop (n); + } + +#if ]b4_api_PREFIX[DEBUG + std::ostream& + ]b4_parser_class_name[::debug_stream () const + { + return *yycdebug_; + } + + void + ]b4_parser_class_name[::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + ]b4_parser_class_name[::debug_level_type + ]b4_parser_class_name[::debug_level () const + { + return yydebug_; + } + + void + ]b4_parser_class_name[::set_debug_level (debug_level_type l) + { + yydebug_ = l; + } +#endif + + inline bool + ]b4_parser_class_name[::yy_pact_value_is_default_ (int yyvalue) + { + return yyvalue == yypact_ninf_; + } + + inline bool + ]b4_parser_class_name[::yy_table_value_is_error_ (int yyvalue) + { + return yyvalue == yytable_ninf_; + } + + int + ]b4_parser_class_name[::parse () + { + /// Lookahead and lookahead in internal form. + int yychar = yyempty_; + int yytoken = 0; + + // State. + int yyn; + int yylen = 0; + int yystate = 0; + + // Error handling. + int yynerrs_ = 0; + int yyerrstatus_ = 0; + + /// Semantic value of the lookahead. + static semantic_type yyval_default; + semantic_type yylval = yyval_default; + /// Location of the lookahead. + location_type yylloc; + /// The locations where the error started and ended. + location_type yyerror_range[3]; + + /// $$. + semantic_type yyval; + /// @@$. + location_type yyloc; + + int yyresult; + + // FIXME: This shoud be completely indented. It is not yet to + // avoid gratuitous conflicts when merging into the master branch. + try + { + YYCDEBUG << "Starting parse" << std::endl; + +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [yylloc])dnl +/* User initialization code. */ +b4_user_initial_action +b4_dollar_popdef])[]dnl + + [ /* Initialize the stacks. The initial state will be pushed in + yynewstate, since the latter expects the semantical and the + location values to have been already stored, initialize these + stacks with a primary value. */ + yystate_stack_ = state_stack_type (0); + yysemantic_stack_ = semantic_stack_type (0); + yylocation_stack_ = location_stack_type (0); + yysemantic_stack_.push (yylval); + yylocation_stack_.push (yylloc); + + /* New state. */ + yynewstate: + yystate_stack_.push (yystate); + YYCDEBUG << "Entering state " << yystate << std::endl; + + /* Accept? */ + if (yystate == yyfinal_) + goto yyacceptlab; + + goto yybackup; + + /* Backup. */ + yybackup: + + /* Try to take a decision without lookahead. */ + yyn = yypact_[yystate]; + if (yy_pact_value_is_default_ (yyn)) + goto yydefault; + + /* Read a lookahead token. */ + if (yychar == yyempty_) + { + YYCDEBUG << "Reading a token: "; + yychar = ]b4_c_function_call([yylex], [int], + [b4_api_PREFIX[STYPE*], [&yylval]][]dnl +b4_locations_if([, [[location*], [&yylloc]]])dnl +m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; + } + + /* Convert token to internal form. */ + if (yychar <= yyeof_) + { + yychar = yytoken = yyeof_; + YYCDEBUG << "Now at end of input." << std::endl; + } + else + { + yytoken = yytranslate_ (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) + goto yydefault; + + /* Reduce or error. */ + yyn = yytable_[yyn]; + if (yyn <= 0) + { + if (yy_table_value_is_error_ (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the token being shifted. */ + yychar = yyempty_; + + yysemantic_stack_.push (yylval); + yylocation_stack_.push (yylloc); + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus_) + --yyerrstatus_; + + yystate = yyn; + goto yynewstate; + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + yydefault: + yyn = yydefact_[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + /*-----------------------------. + | yyreduce -- Do a reduction. | + `-----------------------------*/ + yyreduce: + yylen = yyr2_[yyn]; + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. Otherwise, use the top of the stack. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. */ + if (yylen) + yyval = yysemantic_stack_[yylen - 1]; + else + yyval = yysemantic_stack_[0]; + + // Compute the default @@$. + { + slice slice (yylocation_stack_, yylen); + YYLLOC_DEFAULT (yyloc, slice, yylen); + } + + // Perform the reduction. + YY_REDUCE_PRINT (yyn); + 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. In the case of YYABORT or YYACCEPT, an incorrect + destructor might then be invoked immediately. In the case of + YYERROR, subsequent parser actions might lead to an incorrect + destructor call or verbose syntax error message before the + lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc); + + yypop_ (yylen); + yylen = 0; + YY_STACK_PRINT (); + + yysemantic_stack_.push (yyval); + yylocation_stack_.push (yyloc); + + /* Shift the result of the reduction. */ + yyn = yyr1_[yyn]; + yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0]; + if (0 <= yystate && yystate <= yylast_ + && yycheck_[yystate] == yystate_stack_[0]) + yystate = yytable_[yystate]; + else + yystate = yydefgoto_[yyn - yyntokens_]; + goto yynewstate; + + /*------------------------------------. + | yyerrlab -- here on detecting error | + `------------------------------------*/ + yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yytranslate_ (yychar); + + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus_) + { + ++yynerrs_; + if (yychar == yyempty_) + yytoken = yyempty_; + error (yylloc, yysyntax_error_ (yystate, yytoken)); + } + + yyerror_range[1] = yylloc; + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + if (yychar <= yyeof_) + { + /* Return failure if at end of input. */ + if (yychar == yyeof_) + YYABORT; + } + else + { + yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc); + yychar = yyempty_; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + + /*---------------------------------------------------. + | yyerrorlab -- error raised explicitly by YYERROR. | + `---------------------------------------------------*/ + yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (false) + goto yyerrorlab; + + yyerror_range[1] = yylocation_stack_[yylen - 1]; + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + yypop_ (yylen); + yylen = 0; + yystate = yystate_stack_[0]; + goto yyerrlab1; + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + yyerrlab1: + yyerrstatus_ = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact_[yystate]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += yyterror_; + if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yystate_stack_.height () == 1) + YYABORT; + + yyerror_range[1] = yylocation_stack_[0]; + yydestruct_ ("Error: popping", + yystos_[yystate], + &yysemantic_stack_[0], &yylocation_stack_[0]); + yypop_ (); + yystate = yystate_stack_[0]; + YY_STACK_PRINT (); + } + + yyerror_range[2] = yylloc; + // Using YYLLOC is tempting, but would change the location of + // the lookahead. YYLOC is available though. + YYLLOC_DEFAULT (yyloc, yyerror_range, 2); + yysemantic_stack_.push (yylval); + yylocation_stack_.push (yyloc); + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos_[yyn], + &yysemantic_stack_[0], &yylocation_stack_[0]); + + yystate = yyn; + goto yynewstate; + + /* Accept. */ + yyacceptlab: + yyresult = 0; + goto yyreturn; + + /* Abort. */ + yyabortlab: + yyresult = 1; + goto yyreturn; + + yyreturn: + if (yychar != yyempty_) + { + /* 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, + &yylloc); + } + + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + yypop_ (yylen); + while (1 < yystate_stack_.height ()) + { + yydestruct_ ("Cleanup: popping", + yystos_[yystate_stack_[0]], + &yysemantic_stack_[0], + &yylocation_stack_[0]); + yypop_ (); + } + + return yyresult; + } + catch (...) + { + YYCDEBUG << "Exception caught: cleaning lookahead and stack" + << std::endl; + // Do not try to display the values of the reclaimed symbols, + // as their printer might throw an exception. + if (yychar != yyempty_) + { + /* Make sure we have latest lookahead translation. See + comments at user semantic actions for why this is + necessary. */ + yytoken = yytranslate_ (yychar); + yydestruct_ (YY_NULL, yytoken, &yylval, &yylloc); + } + + while (1 < yystate_stack_.height ()) + { + yydestruct_ (YY_NULL, + yystos_[yystate_stack_[0]], + &yysemantic_stack_[0], + &yylocation_stack_[0]); + yypop_ (); + } + throw; + } + } + + // Generate an error message. + std::string + ]b4_parser_class_name[::yysyntax_error_ (]dnl +b4_error_verbose_if([int yystate, int yytoken], + [int, int])[) + {]b4_error_verbose_if([[ + std::string yyres; + // Number of reported tokens (one for the "unexpected", one per + // "expected"). + size_t yycount = 0; + // Its maximum. + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + // Arguments of yyformat. + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yytoken) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is + a consistent state with a default action. There might have + been a previous inconsistent state, consistent state with a + non-default action, or user semantic action that manipulated + yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state + merging (from LALR or IELR) and default reductions corrupt the + expected token list. However, the list is correct for + canonical LR with one exception: it will still contain any + token that will not be accepted due to an error action in a + later state. + */ + if (yytoken != yyempty_) + { + yyarg[yycount++] = yytname_[yytoken]; + int yyn = yypact_[yystate]; + if (!yy_pact_value_is_default_ (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = yylast_ - yyn + 1; + int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_ + && !yy_table_value_is_error_ (yytable_[yyx + yyn])) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + break; + } + else + yyarg[yycount++] = yytname_[yyx]; + } + } + } + + char const* yyformat = YY_NULL; + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + // Argument number. + size_t yyi = 0; + for (char const* yyp = yyformat; *yyp; ++yyp) + if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) + { + yyres += yytnamerr_ (yyarg[yyi++]); + ++yyp; + } + else + yyres += *yyp; + return yyres;]], [[ + return YY_("syntax error");]])[ + } + + + /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ + const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[; + const ]b4_int_type_for([b4_pact])[ + ]b4_parser_class_name[::yypact_[] = + { + ]b4_pact[ + }; + + /* YYDEFACT[S] -- default reduction number in state S. Performed when + YYTABLE doesn't specify something else to do. Zero means the + default is an error. */ + const ]b4_int_type_for([b4_defact])[ + ]b4_parser_class_name[::yydefact_[] = + { + ]b4_defact[ + }; + + /* YYPGOTO[NTERM-NUM]. */ + const ]b4_int_type_for([b4_pgoto])[ + ]b4_parser_class_name[::yypgoto_[] = + { + ]b4_pgoto[ + }; + + /* YYDEFGOTO[NTERM-NUM]. */ + const ]b4_int_type_for([b4_defgoto])[ + ]b4_parser_class_name[::yydefgoto_[] = + { + ]b4_defgoto[ + }; + + /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If YYTABLE_NINF_, syntax error. */ + const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[; + const ]b4_int_type_for([b4_table])[ + ]b4_parser_class_name[::yytable_[] = + { + ]b4_table[ + }; + + /* YYCHECK. */ + const ]b4_int_type_for([b4_check])[ + ]b4_parser_class_name[::yycheck_[] = + { + ]b4_check[ + }; + + /* STOS_[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ + const ]b4_int_type_for([b4_stos])[ + ]b4_parser_class_name[::yystos_[] = + { + ]b4_stos[ + }; + +#if ]b4_api_PREFIX[DEBUG + /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding + to YYLEX-NUM. */ + const ]b4_int_type_for([b4_toknum])[ + ]b4_parser_class_name[::yytoken_number_[] = + { + ]b4_toknum[ + }; +#endif + + /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ + const ]b4_int_type_for([b4_r1])[ + ]b4_parser_class_name[::yyr1_[] = + { + ]b4_r1[ + }; + + /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ + const ]b4_int_type_for([b4_r2])[ + ]b4_parser_class_name[::yyr2_[] = + { + ]b4_r2[ + }; + +]b4_token_table_if([], [[#if ]b4_api_PREFIX[DEBUG]])[ + /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at \a yyntokens_, nonterminals. */ + const char* + const ]b4_parser_class_name[::yytname_[] = + { + ]b4_tname[ + }; + +]b4_token_table_if([[#if ]b4_api_PREFIX[DEBUG]])[ + /* YYRHS -- A `-1'-separated list of the rules' RHS. */ + const ]b4_parser_class_name[::rhs_number_type + ]b4_parser_class_name[::yyrhs_[] = + { + ]b4_rhs[ + }; + + /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ + const ]b4_int_type_for([b4_prhs])[ + ]b4_parser_class_name[::yyprhs_[] = + { + ]b4_prhs[ + }; + + /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ + const ]b4_int_type_for([b4_rline])[ + ]b4_parser_class_name[::yyrline_[] = + { + ]b4_rline[ + }; + + // Print the state stack on the debug stream. + void + ]b4_parser_class_name[::yystack_print_ () + { + *yycdebug_ << "Stack now"; + for (state_stack_type::const_iterator i = yystate_stack_.begin (); + i != yystate_stack_.end (); ++i) + *yycdebug_ << ' ' << *i; + *yycdebug_ << std::endl; + } + + // Report on the debug stream that the rule \a yyrule is going to be reduced. + void + ]b4_parser_class_name[::yy_reduce_print_ (int yyrule) + { + unsigned int yylno = yyrline_[yyrule]; + int yynrhs = yyr2_[yyrule]; + /* Print the symbols being reduced, and their result. */ + *yycdebug_ << "Reducing stack by rule " << yyrule - 1 + << " (line " << yylno << "):" << std::endl; + /* The symbols being reduced. */ + for (int yyi = 0; yyi < yynrhs; yyi++) + YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", + yyrhs_[yyprhs_[yyrule] + yyi], + &]b4_rhs_value(yynrhs, yyi + 1)[, + &]b4_rhs_location(yynrhs, yyi + 1)[); + } +#endif // ]b4_api_PREFIX[DEBUG + + /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ + ]b4_parser_class_name[::token_number_type + ]b4_parser_class_name[::yytranslate_ (int t) + { + static + const token_number_type + translate_table[] = + { + ]b4_translate[ + }; + if ((unsigned int) t <= yyuser_token_number_max_) + return translate_table[t]; + else + return yyundef_token_; + } + + const int ]b4_parser_class_name[::yyeof_ = 0; + const int ]b4_parser_class_name[::yylast_ = ]b4_last[; + const int ]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[; + const int ]b4_parser_class_name[::yyempty_ = -2; + const int ]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[; + const int ]b4_parser_class_name[::yyterror_ = 1; + const int ]b4_parser_class_name[::yyerrcode_ = 256; + const int ]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[; + + const unsigned int ]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[; + const ]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[; + +]b4_namespace_close[ +]b4_epilogue[]dnl +b4_output_end() diff --git a/src/data/lalr1.java b/src/data/lalr1.java new file mode 100644 index 0000000..e961fc5 --- /dev/null +++ b/src/data/lalr1.java @@ -0,0 +1,927 @@ +# Java skeleton for Bison -*- autoconf -*- + +# Copyright (C) 2007-2012 Free Software Foundation, Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +m4_include(b4_pkgdatadir/[java.m4]) + +b4_defines_if([b4_fatal([%s: %%defines does not make sense in Java], [b4_skeleton])]) +m4_ifval(m4_defn([b4_symbol_destructors]), + [b4_fatal([%s: %%destructor does not make sense in Java], [b4_skeleton])], + []) + +b4_output_begin([b4_parser_file_name]) +b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java], + [2007-2012]) + +b4_percent_define_ifdef([package], [package b4_percent_define_get([package]); +])[/* First part of user declarations. */ +]b4_pre_prologue +b4_percent_code_get([[imports]]) +[/** + * A Bison parser, automatically generated from ]m4_bpatsubst(b4_file_name, [^"\(.*\)"$], [\1])[. + * + * @@author LALR (1) parser skeleton written by Paolo Bonzini. + */ +]b4_public_if([public ])dnl +b4_abstract_if([abstract ])dnl +b4_final_if([final ])dnl +b4_strictfp_if([strictfp ])dnl +[class ]b4_parser_class_name[]dnl +b4_percent_define_get3([extends], [ extends ])dnl +b4_percent_define_get3([implements], [ implements ])[ +{ + ]b4_identification[ + + /** True if verbose error messages are enabled. */ + public boolean errorVerbose = ]b4_flag_value([error_verbose]); + +b4_locations_if([[ + /** + * A class defining a pair of positions. Positions, defined by the + * ]b4_position_type[ class, denote a point in the input. + * Locations represent a part of the input through the beginning + * and ending positions. */ + public class ]b4_location_type[ { + /** The first, inclusive, position in the range. */ + public ]b4_position_type[ begin; + + /** The first position beyond the range. */ + public ]b4_position_type[ end; + + /** + * Create a ]b4_location_type[ denoting an empty range located at + * a given point. + * @@param loc The position at which the range is anchored. */ + public ]b4_location_type[ (]b4_position_type[ loc) { + this.begin = this.end = loc; + } + + /** + * Create a ]b4_location_type[ from the endpoints of the range. + * @@param begin The first position included in the range. + * @@param end The first position beyond the range. */ + public ]b4_location_type[ (]b4_position_type[ begin, ]b4_position_type[ end) { + this.begin = begin; + this.end = end; + } + + /** + * Print a representation of the location. For this to be correct, + * ]b4_position_type[ should override the equals + * method. */ + public String toString () { + if (begin.equals (end)) + return begin.toString (); + else + return begin.toString () + "-" + end.toString (); + } + } + +]]) + +[ /** Token returned by the scanner to signal the end of its input. */ + public static final int EOF = 0;] + +b4_token_enums(b4_tokens) + + b4_locations_if([[ + private ]b4_location_type[ yylloc (YYStack rhs, int n) + { + if (n > 0) + return new ]b4_location_type[ (rhs.locationAt (n-1).begin, rhs.locationAt (0).end); + else + return new ]b4_location_type[ (rhs.locationAt (0).end); + }]])[ + + /** + * Communication interface between the scanner and the Bison-generated + * parser ]b4_parser_class_name[. + */ + public interface Lexer { + ]b4_locations_if([[/** + * Method to retrieve the beginning position of the last scanned token. + * @@return the position at which the last scanned token starts. */ + ]b4_position_type[ getStartPos (); + + /** + * Method to retrieve the ending position of the last scanned token. + * @@return the first position beyond the last scanned token. */ + ]b4_position_type[ getEndPos ();]])[ + + /** + * Method to retrieve the semantic value of the last scanned token. + * @@return the semantic value of the last scanned token. */ + ]b4_yystype[ getLVal (); + + /** + * Entry point for the scanner. Returns the token identifier corresponding + * to the next token and prepares to return the semantic value + * ]b4_locations_if([and beginning/ending positions ])[of the token. + * @@return the token identifier corresponding to the next token. */ + int yylex () ]b4_maybe_throws([b4_lex_throws])[; + + /** + * Entry point for error reporting. Emits an error + * ]b4_locations_if([referring to the given location ])[in a user-defined way. + * + * ]b4_locations_if([[@@param loc The location of the element to which the + * error message is related]])[ + * @@param s The string for the error message. */ + void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s);] + } + + b4_lexer_if([[private class YYLexer implements Lexer { +]b4_percent_code_get([[lexer]])[ + } + + ]])[/** The object doing lexical analysis for us. */ + private Lexer yylexer; + ] + b4_parse_param_vars + +b4_lexer_if([[ + /** + * Instantiates the Bison-generated parser. + */ + public ]b4_parser_class_name (b4_parse_param_decl([b4_lex_param_decl])[) { + this.yylexer = new YYLexer(]b4_lex_param_call[); + ]b4_parse_param_cons[ + } +]]) + + /** + * Instantiates the Bison-generated parser. + * @@param yylexer The scanner that will supply tokens to the parser. + */ + b4_lexer_if([[protected]], [[public]]) b4_parser_class_name[ (]b4_parse_param_decl([[Lexer yylexer]])[) { + this.yylexer = yylexer; + ]b4_parse_param_cons[ + } + + private java.io.PrintStream yyDebugStream = System.err; + + /** + * Return the PrintStream on which the debugging output is + * printed. + */ + public final java.io.PrintStream getDebugStream () { return yyDebugStream; } + + /** + * Set the PrintStream on which the debug output is printed. + * @@param s The stream that is used for debugging output. + */ + public final void setDebugStream(java.io.PrintStream s) { yyDebugStream = s; } + + private int yydebug = 0; + + /** + * Answer the verbosity of the debugging output; 0 means that all kinds of + * output from the parser are suppressed. + */ + public final int getDebugLevel() { return yydebug; } + + /** + * Set the verbosity of the debugging output; 0 means that all kinds of + * output from the parser are suppressed. + * @@param level The verbosity level for debugging output. + */ + public final void setDebugLevel(int level) { yydebug = level; } + + private final int yylex () ]b4_maybe_throws([b4_lex_throws]) [{ + return yylexer.yylex (); + } + protected final void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s) { + yylexer.yyerror (]b4_locations_if([loc, ])[s); + } + + ]b4_locations_if([ + protected final void yyerror (String s) { + yylexer.yyerror ((]b4_location_type[)null, s); + } + protected final void yyerror (]b4_position_type[ loc, String s) { + yylexer.yyerror (new ]b4_location_type[ (loc), s); + }]) + + [protected final void yycdebug (String s) { + if (yydebug > 0) + yyDebugStream.println (s); + } + + private final class YYStack { + private int[] stateStack = new int[16]; + ]b4_locations_if([[private ]b4_location_type[[] locStack = new ]b4_location_type[[16];]])[ + private ]b4_yystype[[] valueStack = new ]b4_yystype[[16]; + + public int size = 16; + public int height = -1; + + public final void push (int state, ]b4_yystype[ value]dnl + b4_locations_if([, ]b4_location_type[ loc])[) { + height++; + if (size == height) + { + int[] newStateStack = new int[size * 2]; + System.arraycopy (stateStack, 0, newStateStack, 0, height); + stateStack = newStateStack; + ]b4_locations_if([[ + ]b4_location_type[[] newLocStack = new ]b4_location_type[[size * 2]; + System.arraycopy (locStack, 0, newLocStack, 0, height); + locStack = newLocStack;]]) + + b4_yystype[[] newValueStack = new ]b4_yystype[[size * 2]; + System.arraycopy (valueStack, 0, newValueStack, 0, height); + valueStack = newValueStack; + + size *= 2; + } + + stateStack[height] = state; + ]b4_locations_if([[locStack[height] = loc;]])[ + valueStack[height] = value; + } + + public final void pop () { + pop (1); + } + + public final void pop (int num) { + // Avoid memory leaks... garbage collection is a white lie! + if (num > 0) { + java.util.Arrays.fill (valueStack, height - num + 1, height + 1, null); + ]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height + 1, null);]])[ + } + height -= num; + } + + public final int stateAt (int i) { + return stateStack[height - i]; + } + + ]b4_locations_if([[public final ]b4_location_type[ locationAt (int i) { + return locStack[height - i]; + } + + ]])[public final ]b4_yystype[ valueAt (int i) { + return valueStack[height - i]; + } + + // Print the state stack on the debug stream. + public void print (java.io.PrintStream out) + { + out.print ("Stack now"); + + for (int i = 0; i <= height; i++) + { + out.print (' '); + out.print (stateStack[i]); + } + out.println (); + } + } + + /** + * Returned by a Bison action in order to stop the parsing process and + * return success (true). */ + public static final int YYACCEPT = 0; + + /** + * Returned by a Bison action in order to stop the parsing process and + * return failure (false). */ + public static final int YYABORT = 1; + + /** + * 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; + + private int yyerrstatus_ = 0; + + /** + * Return whether error recovery is being done. In this state, the parser + * reads token until it reaches a known state, and then restarts normal + * operation. */ + public final boolean recovering () + { + return yyerrstatus_ == 0; + } + + private int yyaction (int yyn, YYStack yystack, int yylen) ]b4_maybe_throws([b4_throws])[ + { + ]b4_yystype[ yyval; + ]b4_locations_if([b4_location_type[ yyloc = yylloc (yystack, yylen);]])[ + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. Otherwise, use the top of the stack. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. */ + if (yylen > 0) + yyval = yystack.valueAt (yylen - 1); + else + yyval = yystack.valueAt (0); + + yy_reduce_print (yyn, yystack); + + switch (yyn) + { + ]b4_user_actions[ + default: break; + } + + yy_symbol_print ("-> $$ =", yyr1_[yyn], yyval]b4_locations_if([, yyloc])[); + + yystack.pop (yylen); + yylen = 0; + + /* Shift the result of the reduction. */ + yyn = yyr1_[yyn]; + int yystate = yypgoto_[yyn - yyntokens_] + yystack.stateAt (0); + if (0 <= yystate && yystate <= yylast_ + && yycheck_[yystate] == yystack.stateAt (0)) + yystate = yytable_[yystate]; + else + yystate = yydefgoto_[yyn - yyntokens_]; + + yystack.push (yystate, yyval]b4_locations_if([, yyloc])[); + return YYNEWSTATE; + } + + /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ + private final String yytnamerr_ (String yystr) + { + if (yystr.charAt (0) == '"') + { + StringBuffer yyr = new StringBuffer (); + strip_quotes: for (int i = 1; i < yystr.length (); i++) + switch (yystr.charAt (i)) + { + case '\'': + case ',': + break strip_quotes; + + case '\\': + if (yystr.charAt(++i) != '\\') + break strip_quotes; + /* Fall through. */ + default: + yyr.append (yystr.charAt (i)); + break; + + case '"': + return yyr.toString (); + } + } + else if (yystr.equals ("$end")) + return "end of input"; + + return yystr; + } + + /*--------------------------------. + | Print this symbol on YYOUTPUT. | + `--------------------------------*/ + + private void yy_symbol_print (String s, int yytype, + ]b4_yystype[ yyvaluep]dnl + b4_locations_if([, Object yylocationp])[) + { + if (yydebug > 0) + yycdebug (s + (yytype < yyntokens_ ? " token " : " nterm ") + + yytname_[yytype] + " ("]b4_locations_if([ + + yylocationp + ": "])[ + + (yyvaluep == null ? "(null)" : yyvaluep.toString ()) + ")"); + } + + /** + * Parse input from the scanner that was specified at object construction + * time. Return whether the end of the input was reached successfully. + * + * @@return true if the parsing succeeds. Note that this does not + * imply that there were no syntax errors. + */ + public boolean parse () ]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[ + { + /// Lookahead and lookahead in internal form. + int yychar = yyempty_; + int yytoken = 0; + + /* State. */ + int yyn = 0; + int yylen = 0; + int yystate = 0; + + YYStack yystack = new YYStack (); + + /* Error handling. */ + int yynerrs_ = 0; + ]b4_locations_if([/// The location where the error started. + ]b4_location_type[ yyerrloc = null; + + /// ]b4_location_type[ of the lookahead. + ]b4_location_type[ yylloc = new ]b4_location_type[ (null, null); + + /// @@$. + ]b4_location_type[ yyloc;]) + + /// Semantic value of the lookahead. + b4_yystype[ yylval = null; + + yycdebug ("Starting parse\n"); + yyerrstatus_ = 0; + +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [yylloc])dnl +/* User initialization code. */ +b4_user_initial_action +b4_dollar_popdef])[]dnl + + [ /* Initialize the stack. */ + yystack.push (yystate, yylval]b4_locations_if([, yylloc])[); + + int label = YYNEWSTATE; + for (;;) + switch (label) + { + /* New state. Unlike in the C/C++ skeletons, the state is already + pushed when we come here. */ + case YYNEWSTATE: + yycdebug ("Entering state " + yystate + "\n"); + if (yydebug > 0) + yystack.print (yyDebugStream); + + /* Accept? */ + if (yystate == yyfinal_) + return true; + + /* Take a decision. First try without lookahead. */ + yyn = yypact_[yystate]; + if (yy_pact_value_is_default_ (yyn)) + { + label = YYDEFAULT; + break; + } + + /* Read a lookahead token. */ + if (yychar == yyempty_) + { + yycdebug ("Reading a token: "); + yychar = yylex ();] + b4_locations_if([[ + yylloc = new ]b4_location_type[(yylexer.getStartPos (), + yylexer.getEndPos ());]]) + yylval = yylexer.getLVal ();[ + } + + /* Convert token to internal form. */ + if (yychar <= EOF) + { + yychar = yytoken = EOF; + yycdebug ("Now at end of input.\n"); + } + else + { + yytoken = yytranslate_ (yychar); + yy_symbol_print ("Next token is", yytoken, + yylval]b4_locations_if([, yylloc])[); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) + label = YYDEFAULT; + + /* <= 0 means reduce or error. */ + else if ((yyn = yytable_[yyn]) <= 0) + { + if (yy_table_value_is_error_ (yyn)) + label = YYERRLAB; + else + { + yyn = -yyn; + label = YYREDUCE; + } + } + + else + { + /* Shift the lookahead token. */ + yy_symbol_print ("Shifting", yytoken, + yylval]b4_locations_if([, yylloc])[); + + /* Discard the token being shifted. */ + yychar = yyempty_; + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus_ > 0) + --yyerrstatus_; + + yystate = yyn; + yystack.push (yystate, yylval]b4_locations_if([, yylloc])[); + label = YYNEWSTATE; + } + break; + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + case YYDEFAULT: + yyn = yydefact_[yystate]; + if (yyn == 0) + label = YYERRLAB; + else + label = YYREDUCE; + break; + + /*-----------------------------. + | yyreduce -- Do a reduction. | + `-----------------------------*/ + case YYREDUCE: + yylen = yyr2_[yyn]; + label = yyaction (yyn, yystack, yylen); + yystate = yystack.stateAt (0); + break; + + /*------------------------------------. + | yyerrlab -- here on detecting error | + `------------------------------------*/ + case YYERRLAB: + /* If not already recovering from an error, report this error. */ + if (yyerrstatus_ == 0) + { + ++yynerrs_; + if (yychar == yyempty_) + yytoken = yyempty_; + yyerror (]b4_locations_if([yylloc, ])[yysyntax_error (yystate, yytoken)); + } + + ]b4_locations_if([yyerrloc = yylloc;])[ + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= EOF) + { + /* Return failure if at end of input. */ + if (yychar == EOF) + return false; + } + else + yychar = yyempty_; + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + label = YYERRLAB1; + break; + + /*---------------------------------------------------. + | errorlab -- error raised explicitly by YYERROR. | + `---------------------------------------------------*/ + case YYERROR: + + ]b4_locations_if([yyerrloc = yystack.locationAt (yylen - 1);])[ + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + yystack.pop (yylen); + yylen = 0; + yystate = yystack.stateAt (0); + label = YYERRLAB1; + break; + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + case YYERRLAB1: + yyerrstatus_ = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact_[yystate]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += yyterror_; + if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yystack.height == 0) + return false; + + ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[ + yystack.pop (); + yystate = yystack.stateAt (0); + if (yydebug > 0) + yystack.print (yyDebugStream); + } + + ]b4_locations_if([ + /* Muck with the stack to setup for yylloc. */ + yystack.push (0, null, yylloc); + yystack.push (0, null, yyerrloc); + yyloc = yylloc (yystack, 2); + yystack.pop (2);])[ + + /* Shift the error token. */ + yy_symbol_print ("Shifting", yystos_[yyn], + yylval]b4_locations_if([, yyloc])[); + + yystate = yyn; + yystack.push (yyn, yylval]b4_locations_if([, yyloc])[); + label = YYNEWSTATE; + break; + + /* Accept. */ + case YYACCEPT: + return true; + + /* Abort. */ + case YYABORT: + return false; + } + } + + // Generate an error message. + private String yysyntax_error (int yystate, int tok) + { + if (errorVerbose) + { + /* There are many possibilities here to consider: + - Assume YYFAIL is not used. It's too flawed to consider. + See + + for details. YYERROR is fine as it does not invoke this + function. + - If this state is a consistent state with a default action, + then the only way this function was invoked is if the + default action is an error action. In that case, don't + check for expected tokens because there are none. + - The only way there can be no lookahead present (in tok) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this + state is a consistent state with a default action. There + might have been a previous inconsistent state, consistent + state with a non-default action, or user semantic action + that manipulated yychar. (However, yychar is currently out + of scope during semantic actions.) + - Of course, the expected token list depends on states to + have correct lookahead information, and it depends on the + parser not to perform extra reductions after fetching a + lookahead from the scanner and before detecting a syntax + error. Thus, state merging (from LALR or IELR) and default + reductions corrupt the expected token list. However, the + list is correct for canonical LR with one exception: it + will still contain any token that will not be accepted due + to an error action in a later state. + */ + if (tok != yyempty_) + { + // FIXME: This method of building the message is not compatible + // with internationalization. + StringBuffer res = + new StringBuffer ("syntax error, unexpected "); + res.append (yytnamerr_ (yytname_[tok])); + int yyn = yypact_[yystate]; + if (!yy_pact_value_is_default_ (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative + indexes in YYCHECK. In other words, skip the first + -YYN actions for this state because they are default + actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = yylast_ - yyn + 1; + int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_; + int count = 0; + for (int x = yyxbegin; x < yyxend; ++x) + if (yycheck_[x + yyn] == x && x != yyterror_ + && !yy_table_value_is_error_ (yytable_[x + yyn])) + ++count; + if (count < 5) + { + count = 0; + for (int x = yyxbegin; x < yyxend; ++x) + if (yycheck_[x + yyn] == x && x != yyterror_ + && !yy_table_value_is_error_ (yytable_[x + yyn])) + { + res.append (count++ == 0 ? ", expecting " : " or "); + res.append (yytnamerr_ (yytname_[x])); + } + } + } + return res.toString (); + } + } + + return "syntax error"; + } + + /** + * Whether the given yypact_ value indicates a defaulted state. + * @@param yyvalue the value to check + */ + private static boolean yy_pact_value_is_default_ (int yyvalue) + { + return yyvalue == yypact_ninf_; + } + + /** + * Whether the given yytable_ value indicates a syntax error. + * @@param yyvalue the value to check + */ + private static boolean yy_table_value_is_error_ (int yyvalue) + { + return yyvalue == yytable_ninf_; + } + + /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ + private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[; + private static final ]b4_int_type_for([b4_pact])[ yypact_[] = + { + ]b4_pact[ + }; + + /* YYDEFACT[S] -- default reduction number in state S. Performed when + YYTABLE doesn't specify something else to do. Zero means the + default is an error. */ + private static final ]b4_int_type_for([b4_defact])[ yydefact_[] = + { + ]b4_defact[ + }; + + /* YYPGOTO[NTERM-NUM]. */ + private static final ]b4_int_type_for([b4_pgoto])[ yypgoto_[] = + { + ]b4_pgoto[ + }; + + /* YYDEFGOTO[NTERM-NUM]. */ + private static final ]b4_int_type_for([b4_defgoto])[ + yydefgoto_[] = + { + ]b4_defgoto[ + }; + + /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If YYTABLE_NINF_, syntax error. */ + private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[; + private static final ]b4_int_type_for([b4_table])[ + yytable_[] = + { + ]b4_table[ + }; + + /* YYCHECK. */ + private static final ]b4_int_type_for([b4_check])[ + yycheck_[] = + { + ]b4_check[ + }; + + /* STOS_[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ + private static final ]b4_int_type_for([b4_stos])[ + yystos_[] = + { + ]b4_stos[ + }; + + /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding + to YYLEX-NUM. */ + private static final ]b4_int_type_for([b4_toknum])[ + yytoken_number_[] = + { + ]b4_toknum[ + }; + + /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ + private static final ]b4_int_type_for([b4_r1])[ + yyr1_[] = + { + ]b4_r1[ + }; + + /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ + private static final ]b4_int_type_for([b4_r2])[ + yyr2_[] = + { + ]b4_r2[ + }; + + /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at \a yyntokens_, nonterminals. */ + private static final String yytname_[] = + { + ]b4_tname[ + }; + + /* YYRHS -- A `-1'-separated list of the rules' RHS. */ + private static final ]b4_int_type_for([b4_rhs])[ yyrhs_[] = + { + ]b4_rhs[ + }; + + /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ + private static final ]b4_int_type_for([b4_prhs])[ yyprhs_[] = + { + ]b4_prhs[ + }; + + /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ + private static final ]b4_int_type_for([b4_rline])[ yyrline_[] = + { + ]b4_rline[ + }; + + // Report on the debug stream that the rule yyrule is going to be reduced. + private void yy_reduce_print (int yyrule, YYStack yystack) + { + if (yydebug == 0) + return; + + int yylno = yyrline_[yyrule]; + int yynrhs = yyr2_[yyrule]; + /* Print the symbols being reduced, and their result. */ + yycdebug ("Reducing stack by rule " + (yyrule - 1) + + " (line " + yylno + "), "); + + /* The symbols being reduced. */ + for (int yyi = 0; yyi < yynrhs; yyi++) + yy_symbol_print (" $" + (yyi + 1) + " =", + yyrhs_[yyprhs_[yyrule] + yyi], + ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([, + b4_rhs_location(yynrhs, yyi + 1)])[); + } + + /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ + private static final ]b4_int_type_for([b4_translate])[ yytranslate_table_[] = + { + ]b4_translate[ + }; + + private static final ]b4_int_type_for([b4_translate])[ yytranslate_ (int t) + { + if (t >= 0 && t <= yyuser_token_number_max_) + return yytranslate_table_[t]; + else + return yyundef_token_; + } + + private static final int yylast_ = ]b4_last[; + private static final int yynnts_ = ]b4_nterms_number[; + private static final int yyempty_ = -2; + private static final int yyfinal_ = ]b4_final_state_number[; + private static final int yyterror_ = 1; + private static final int yyerrcode_ = 256; + private static final int yyntokens_ = ]b4_tokens_number[; + + private static final int yyuser_token_number_max_ = ]b4_user_token_number_max[; + private static final int yyundef_token_ = ]b4_undef_token_number[; + +]/* User implementation code. */ +b4_percent_code_get[]dnl + +} + +b4_epilogue +b4_output_end() diff --git a/src/data/location.cc b/src/data/location.cc new file mode 100644 index 0000000..4082e09 --- /dev/null +++ b/src/data/location.cc @@ -0,0 +1,299 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2007, 2009-2012 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_output_begin([b4_dir_prefix[]position.hh]) +b4_copyright([Positions for Bison parsers in C++], + [2002-2007, 2009-2012])[ + +/** + ** \file ]b4_dir_prefix[position.hh + ** Define the ]b4_namespace_ref[::position class. + */ + +]b4_cpp_guard_open([b4_dir_prefix[]position.hh])[ + +# include // std::max +# include +# include + +]b4_null_define[ + +]b4_namespace_open[ + /// Abstract a position. + class position + { + public: +]m4_ifdef([b4_location_constructors], [[ + /// Construct a position. + explicit position (]b4_percent_define_get([[filename_type]])[* f = YY_NULL, + unsigned int l = ]b4_location_initial_line[u, + unsigned int c = ]b4_location_initial_column[u) + : filename (f) + , line (l) + , column (c) + { + } + +]])[ + /// Initialization. + void initialize (]b4_percent_define_get([[filename_type]])[* fn = YY_NULL, + unsigned int l = ]b4_location_initial_line[u, + unsigned int c = ]b4_location_initial_column[u) + { + filename = fn; + line = l; + column = c; + } + + /** \name Line and Column related manipulators + ** \{ */ + /// (line related) Advance to the COUNT next lines. + void lines (int count = 1) + { + column = ]b4_location_initial_column[u; + line += count; + } + + /// (column related) Advance to the COUNT next columns. + void columns (int count = 1) + { + column = std::max (]b4_location_initial_column[u, column + count); + } + /** \} */ + + /// File name to which this position refers. + ]b4_percent_define_get([[filename_type]])[* filename; + /// Current line number. + unsigned int line; + /// Current column number. + unsigned int column; + }; + + /// Add and assign a position. + inline position& + operator+= (position& res, const int width) + { + res.columns (width); + return res; + } + + /// Add two position objects. + inline const position + operator+ (const position& begin, const int width) + { + position res = begin; + return res += width; + } + + /// Add and assign a position. + inline position& + operator-= (position& res, const int width) + { + return res += -width; + } + + /// Add two position objects. + inline const position + operator- (const position& begin, const int width) + { + return begin + -width; + } +]b4_percent_define_flag_if([[define_location_comparison]], [[ + /// Compare two position objects. + inline bool + operator== (const position& pos1, const position& pos2) + { + return (pos1.line == pos2.line + && pos1.column == pos2.column + && (pos1.filename == pos2.filename + || (pos1.filename && pos2.filename + && *pos1.filename == *pos2.filename))); + } + + /// Compare two position objects. + inline bool + operator!= (const position& pos1, const position& pos2) + { + return !(pos1 == pos2); + } +]])[ + /** \brief Intercept output stream redirection. + ** \param ostr the destination output stream + ** \param pos a reference to the position to redirect + */ + template + inline std::basic_ostream& + operator<< (std::basic_ostream& ostr, const position& pos) + { + if (pos.filename) + ostr << *pos.filename << ':'; + return ostr << pos.line << '.' << pos.column; + } + +]b4_namespace_close[ +]b4_cpp_guard_close([b4_dir_prefix[]position.hh]) +b4_output_end() + + +b4_output_begin([b4_dir_prefix[]location.hh]) +b4_copyright([Locations for Bison parsers in C++], + [2002-2007, 2009-2012])[ + +/** + ** \file ]b4_dir_prefix[location.hh + ** Define the ]b4_namespace_ref[::location class. + */ + +]b4_cpp_guard_open([b4_dir_prefix[]location.hh])[ + +# include "position.hh" + +]b4_namespace_open[ + + /// Abstract a location. + class location + { + public: +]m4_ifdef([b4_location_constructors], [ + /// Construct a location from \a b to \a e. + location (const position& b, const position& e) + : begin (b) + , end (e) + { + } + + /// Construct a 0-width location in \a p. + explicit location (const position& p = position ()) + : begin (p) + , end (p) + { + } + + /// Construct a 0-width location in \a f, \a l, \a c. + explicit location (]b4_percent_define_get([[filename_type]])[* f, + unsigned int l = ]b4_location_initial_line[u, + unsigned int c = ]b4_location_initial_column[u) + : begin (f, l, c) + , end (f, l, c) + { + } + +])[ + /// Initialization. + void initialize (]b4_percent_define_get([[filename_type]])[* f = YY_NULL, + unsigned int l = ]b4_location_initial_line[u, + unsigned int c = ]b4_location_initial_column[u) + { + begin.initialize (f, l, c); + end = begin; + } + + /** \name Line and Column related manipulators + ** \{ */ + public: + /// Reset initial location to final location. + void step () + { + begin = end; + } + + /// Extend the current location to the COUNT next columns. + void columns (unsigned int count = 1) + { + end += count; + } + + /// Extend the current location to the COUNT next lines. + void lines (unsigned int count = 1) + { + end.lines (count); + } + /** \} */ + + + public: + /// Beginning of the located region. + position begin; + /// End of the located region. + position end; + }; + + /// Join two location objects to create a location. + inline const location operator+ (const location& begin, const location& end) + { + location res = begin; + res.end = end.end; + return res; + } + + /// Add two location objects. + inline const location operator+ (const location& begin, unsigned int width) + { + location res = begin; + res.columns (width); + return res; + } + + /// Add and assign a location. + inline location& operator+= (location& res, unsigned int width) + { + res.columns (width); + return res; + } +]b4_percent_define_flag_if([[define_location_comparison]], [[ + /// Compare two location objects. + inline bool + operator== (const location& loc1, const location& loc2) + { + return loc1.begin == loc2.begin && loc1.end == loc2.end; + } + + /// Compare two location objects. + inline bool + operator!= (const location& loc1, const location& loc2) + { + return !(loc1 == loc2); + } +]])[ + /** \brief Intercept output stream redirection. + ** \param ostr the destination output stream + ** \param loc a reference to the location to redirect + ** + ** Avoid duplicate information. + */ + template + inline std::basic_ostream& + operator<< (std::basic_ostream& ostr, const location& loc) + { + position last = loc.end - 1; + ostr << loc.begin; + if (last.filename + && (!loc.begin.filename + || *loc.begin.filename != *last.filename)) + ostr << '-' << last; + else if (loc.begin.line != last.line) + ostr << '-' << last.line << '.' << last.column; + else if (loc.begin.column != last.column) + ostr << '-' << last.column; + return ostr; + } + +]b4_namespace_close[ + +]b4_cpp_guard_close([b4_dir_prefix[]location.hh]) +b4_output_end() diff --git a/src/data/m4sugar/foreach.m4 b/src/data/m4sugar/foreach.m4 new file mode 100644 index 0000000..3fc1913 --- /dev/null +++ b/src/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-2012 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/src/data/m4sugar/m4sugar.m4 b/src/data/m4sugar/m4sugar.m4 new file mode 100644 index 0000000..12a9ab7 --- /dev/null +++ b/src/data/m4sugar/m4sugar.m4 @@ -0,0 +1,3301 @@ +divert(-1)# -*- Autoconf -*- +# This file is part of Autoconf. +# Base M4 layer. +# Requires GNU M4. +# +# Copyright (C) 1999-2012 Free Software Foundation, Inc. + +# This file is part of Autoconf. This program is free +# software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# Under Section 7 of GPL version 3, you are granted additional +# permissions described in the Autoconf Configure Script Exception, +# version 3.0, as published by the Free Software Foundation. +# +# You should have received a copy of the GNU General Public License +# and a copy of the Autoconf Configure Script Exception along with +# this program; see the files COPYINGv3 and COPYING.EXCEPTION +# respectively. If not, see . + +# Written by Akim Demaille. + +# Set the quotes, whatever the current quoting system. +changequote() +changequote([, ]) + +# Some old m4's don't support m4exit. But they provide +# equivalent functionality by core dumping because of the +# long macros we define. +ifdef([__gnu__], , +[errprint(M4sugar requires GNU M4. Install it before installing M4sugar or +set the M4 environment variable to its absolute file name.) +m4exit(2)]) + + +## ------------------------------- ## +## 1. Simulate --prefix-builtins. ## +## ------------------------------- ## + +# m4_define +# m4_defn +# m4_undefine +define([m4_define], defn([define])) +define([m4_defn], defn([defn])) +define([m4_undefine], defn([undefine])) + +m4_undefine([define]) +m4_undefine([defn]) +m4_undefine([undefine]) + + +# m4_copy(SRC, DST) +# ----------------- +# Define DST as the definition of SRC. +# What's the difference between: +# 1. m4_copy([from], [to]) +# 2. m4_define([to], [from($@)]) +# Well, obviously 1 is more expensive in space. Maybe 2 is more expensive +# in time, but because of the space cost of 1, it's not that obvious. +# Nevertheless, one huge difference is the handling of `$0'. If `from' +# uses `$0', then with 1, `to''s `$0' is `to', while it is `from' in 2. +# The user would certainly prefer to see `to'. +# +# This definition is in effect during m4sugar initialization, when +# there are no pushdef stacks; later on, we redefine it to something +# more powerful for all other clients to use. +m4_define([m4_copy], +[m4_define([$2], m4_defn([$1]))]) + + +# m4_rename(SRC, DST) +# ------------------- +# Rename the macro SRC to DST. +m4_define([m4_rename], +[m4_copy([$1], [$2])m4_undefine([$1])]) + + +# m4_rename_m4(MACRO-NAME) +# ------------------------ +# Rename MACRO-NAME to m4_MACRO-NAME. +m4_define([m4_rename_m4], +[m4_rename([$1], [m4_$1])]) + + +# m4_copy_unm4(m4_MACRO-NAME) +# --------------------------- +# Copy m4_MACRO-NAME to MACRO-NAME. +m4_define([m4_copy_unm4], +[m4_copy([$1], m4_bpatsubst([$1], [^m4_\(.*\)], [[\1]]))]) + + +# Some m4 internals have names colliding with tokens we might use. +# Rename them a` la `m4 --prefix-builtins'. Conditionals first, since +# some subsequent renames are conditional. +m4_rename_m4([ifdef]) +m4_rename([ifelse], [m4_if]) + +m4_rename_m4([builtin]) +m4_rename_m4([changecom]) +m4_rename_m4([changequote]) +m4_ifdef([changeword],dnl conditionally available in 1.4.x +[m4_undefine([changeword])]) +m4_rename_m4([debugfile]) +m4_rename_m4([debugmode]) +m4_rename_m4([decr]) +m4_rename_m4([divnum]) +m4_rename_m4([dumpdef]) +m4_rename_m4([errprint]) +m4_rename_m4([esyscmd]) +m4_rename_m4([eval]) +m4_rename_m4([format]) +m4_undefine([include]) +m4_rename_m4([incr]) +m4_rename_m4([index]) +m4_rename_m4([indir]) +m4_rename_m4([len]) +m4_rename([m4exit], [m4_exit]) +m4_undefine([m4wrap]) +m4_ifdef([mkstemp],dnl added in M4 1.4.8 +[m4_rename_m4([mkstemp]) +m4_copy([m4_mkstemp], [m4_maketemp]) +m4_undefine([maketemp])], +[m4_rename_m4([maketemp]) +m4_copy([m4_maketemp], [m4_mkstemp])]) +m4_rename([patsubst], [m4_bpatsubst]) +m4_rename_m4([popdef]) +m4_rename_m4([pushdef]) +m4_rename([regexp], [m4_bregexp]) +m4_rename_m4([shift]) +m4_undefine([sinclude]) +m4_rename_m4([substr]) +m4_ifdef([symbols],dnl present only in alpha-quality 1.4o +[m4_rename_m4([symbols])]) +m4_rename_m4([syscmd]) +m4_rename_m4([sysval]) +m4_rename_m4([traceoff]) +m4_rename_m4([traceon]) +m4_rename_m4([translit]) + +# _m4_defn(ARG) +# ------------- +# _m4_defn is for internal use only - it bypasses the wrapper, so it +# must only be used on one argument at a time, and only on macros +# known to be defined. Make sure this still works if the user renames +# m4_defn but not _m4_defn. +m4_copy([m4_defn], [_m4_defn]) + +# _m4_divert_raw(NUM) +# ------------------- +# _m4_divert_raw is for internal use only. Use this instead of +# m4_builtin([divert], NUM), so that tracing diversion flow is easier. +m4_rename([divert], [_m4_divert_raw]) + +# _m4_popdef(ARG...) +# ------------------ +# _m4_popdef is for internal use only - it bypasses the wrapper, so it +# must only be used on macros known to be defined. Make sure this +# still works if the user renames m4_popdef but not _m4_popdef. +m4_copy([m4_popdef], [_m4_popdef]) + +# _m4_undefine(ARG...) +# -------------------- +# _m4_undefine is for internal use only - it bypasses the wrapper, so +# it must only be used on macros known to be defined. Make sure this +# still works if the user renames m4_undefine but not _m4_undefine. +m4_copy([m4_undefine], [_m4_undefine]) + +# _m4_undivert(NUM...) +# -------------------- +# _m4_undivert is for internal use only, and should always be given +# arguments. Use this instead of m4_builtin([undivert], NUM...), so +# that tracing diversion flow is easier. +m4_rename([undivert], [_m4_undivert]) + + +## ------------------- ## +## 2. Error messages. ## +## ------------------- ## + + +# m4_location +# ----------- +# Output the current file, colon, and the current line number. +m4_define([m4_location], +[__file__:__line__]) + + +# m4_errprintn(MSG) +# ----------------- +# Same as `errprint', but with the missing end of line. +m4_define([m4_errprintn], +[m4_errprint([$1 +])]) + + +# m4_warning(MSG) +# --------------- +# Warn the user. +m4_define([m4_warning], +[m4_errprintn(m4_location[: warning: $1])]) + + +# m4_fatal(MSG, [EXIT-STATUS]) +# ---------------------------- +# Fatal the user. :) +m4_define([m4_fatal], +[m4_errprintn(m4_location[: error: $1] +m4_expansion_stack)m4_exit(m4_if([$2],, 1, [$2]))]) + + +# m4_assert(EXPRESSION, [EXIT-STATUS = 1]) +# ---------------------------------------- +# This macro ensures that EXPRESSION evaluates to true, and exits if +# EXPRESSION evaluates to false. +m4_define([m4_assert], +[m4_if(m4_eval([$1]), 0, + [m4_fatal([assert failed: $1], [$2])])]) + + + +## ------------- ## +## 3. Warnings. ## +## ------------- ## + + +# _m4_warn(CATEGORY, MESSAGE, [STACK-TRACE]) +# ------------------------------------------ +# Report a MESSAGE to the user if the CATEGORY of warnings is enabled. +# This is for traces only. +# If present, STACK-TRACE is a \n-separated list of "LOCATION: MESSAGE", +# where the last line (and no other) ends with "the top level". +# +# Within m4, the macro is a no-op. This macro really matters +# when autom4te post-processes the trace output. +m4_define([_m4_warn], []) + + +# m4_warn(CATEGORY, MESSAGE) +# -------------------------- +# Report a MESSAGE to the user if the CATEGORY of warnings is enabled. +m4_define([m4_warn], +[_m4_warn([$1], [$2], +m4_ifdef([_m4_expansion_stack], [m4_expansion_stack]))]) + + + +## ------------------- ## +## 4. File inclusion. ## +## ------------------- ## + + +# We also want to neutralize include (and sinclude for symmetry), +# but we want to extend them slightly: warn when a file is included +# several times. This is, in general, a dangerous operation, because +# too many people forget to quote the first argument of m4_define. +# +# For instance in the following case: +# m4_define(foo, [bar]) +# then a second reading will turn into +# m4_define(bar, [bar]) +# which is certainly not what was meant. + +# m4_include_unique(FILE) +# ----------------------- +# Declare that the FILE was loading; and warn if it has already +# been included. +m4_define([m4_include_unique], +[m4_ifdef([m4_include($1)], + [m4_warn([syntax], [file `$1' included several times])])dnl +m4_define([m4_include($1)])]) + + +# m4_include(FILE) +# ---------------- +# Like the builtin include, but warns against multiple inclusions. +m4_define([m4_include], +[m4_include_unique([$1])dnl +m4_builtin([include], [$1])]) + + +# m4_sinclude(FILE) +# ----------------- +# Like the builtin sinclude, but warns against multiple inclusions. +m4_define([m4_sinclude], +[m4_include_unique([$1])dnl +m4_builtin([sinclude], [$1])]) + + + +## ------------------------------------ ## +## 5. Additional branching constructs. ## +## ------------------------------------ ## + +# Both `m4_ifval' and `m4_ifset' tests against the empty string. The +# difference is that `m4_ifset' is specialized on macros. +# +# In case of arguments of macros, eg. $1, it makes little difference. +# In the case of a macro `FOO', you don't want to check `m4_ifval(FOO, +# TRUE)', because if `FOO' expands with commas, there is a shifting of +# the arguments. So you want to run `m4_ifval([FOO])', but then you just +# compare the *string* `FOO' against `', which, of course fails. +# +# So you want the variation `m4_ifset' that expects a macro name as $1. +# If this macro is both defined and defined to a non empty value, then +# it runs TRUE, etc. + + +# m4_ifblank(COND, [IF-BLANK], [IF-TEXT]) +# m4_ifnblank(COND, [IF-TEXT], [IF-BLANK]) +# ---------------------------------------- +# If COND is empty, or consists only of blanks (space, tab, newline), +# then expand IF-BLANK, otherwise expand IF-TEXT. This differs from +# m4_ifval only if COND has just whitespace, but it helps optimize in +# spite of users who mistakenly leave trailing space after what they +# thought was an empty argument: +# macro( +# [] +# ) +# +# Writing one macro in terms of the other causes extra overhead, so +# we inline both definitions. +m4_define([m4_ifblank], +[m4_if(m4_translit([[$1]], [ ][ ][ +]), [], [$2], [$3])]) + +m4_define([m4_ifnblank], +[m4_if(m4_translit([[$1]], [ ][ ][ +]), [], [$3], [$2])]) + + +# m4_ifval(COND, [IF-TRUE], [IF-FALSE]) +# ------------------------------------- +# If COND is not the empty string, expand IF-TRUE, otherwise IF-FALSE. +# Comparable to m4_ifdef. +m4_define([m4_ifval], +[m4_if([$1], [], [$3], [$2])]) + + +# m4_n(TEXT) +# ---------- +# If TEXT is not empty, return TEXT and a new line, otherwise nothing. +m4_define([m4_n], +[m4_if([$1], + [], [], + [$1 +])]) + + +# m4_ifvaln(COND, [IF-TRUE], [IF-FALSE]) +# -------------------------------------- +# Same as `m4_ifval', but add an extra newline to IF-TRUE or IF-FALSE +# unless that argument is empty. +m4_define([m4_ifvaln], +[m4_if([$1], + [], [m4_n([$3])], + [m4_n([$2])])]) + + +# m4_ifset(MACRO, [IF-TRUE], [IF-FALSE]) +# -------------------------------------- +# If MACRO has no definition, or of its definition is the empty string, +# expand IF-FALSE, otherwise IF-TRUE. +m4_define([m4_ifset], +[m4_ifdef([$1], + [m4_ifval(_m4_defn([$1]), [$2], [$3])], + [$3])]) + + +# m4_ifndef(NAME, [IF-NOT-DEFINED], [IF-DEFINED]) +# ----------------------------------------------- +m4_define([m4_ifndef], +[m4_ifdef([$1], [$3], [$2])]) + + +# m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) +# ----------------------------------------------------------- +# m4 equivalent of +# switch (SWITCH) +# { +# case VAL1: +# IF-VAL1; +# break; +# case VAL2: +# IF-VAL2; +# break; +# ... +# default: +# DEFAULT; +# break; +# }. +# All the values are optional, and the macro is robust to active +# symbols properly quoted. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_case], +[m4_if([$#], 0, [], + [$#], 1, [], + [$#], 2, [$2], + [$1], [$2], [$3], + [$0([$1], m4_shift3($@))])]) + + +# m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) +# ----------------------------------------------------- +# m4 equivalent of +# +# if (SWITCH =~ RE1) +# VAL1; +# elif (SWITCH =~ RE2) +# VAL2; +# elif ... +# ... +# else +# DEFAULT +# +# All the values are optional, and the macro is robust to active symbols +# properly quoted. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_bmatch], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [$2], + [m4_if(m4_bregexp([$1], [$2]), -1, [$0([$1], m4_shift3($@))], + [$3])])]) + +# m4_argn(N, ARGS...) +# ------------------- +# Extract argument N (greater than 0) from ARGS. Example: +# m4_define([b], [B]) +# m4_argn([2], [a], [b], [c]) => b +# +# Rather than using m4_car(m4_shiftn([$1], $@)), we exploit the fact that +# GNU m4 can directly reference any argument, through an indirect macro. +m4_define([m4_argn], +[m4_assert([0 < $1])]dnl +[m4_pushdef([_$0], [_m4_popdef([_$0])]m4_dquote([$]m4_incr([$1])))_$0($@)]) + + +# m4_car(ARGS...) +# m4_cdr(ARGS...) +# --------------- +# Manipulate m4 lists. m4_car returns the first argument. m4_cdr +# bundles all but the first argument into a quoted list. These two +# macros are generally used with list arguments, with quoting removed +# to break the list into multiple m4 ARGS. +m4_define([m4_car], [[$1]]) +m4_define([m4_cdr], +[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], + [$#], 1, [], + [m4_dquote(m4_shift($@))])]) + +# _m4_cdr(ARGS...) +# ---------------- +# Like m4_cdr, except include a leading comma unless only one argument +# remains. Why? Because comparing a large list against [] is more +# expensive in expansion time than comparing the number of arguments; so +# _m4_cdr can be used to reduce the number of arguments when it is time +# to end recursion. +m4_define([_m4_cdr], +[m4_if([$#], 1, [], + [, m4_dquote(m4_shift($@))])]) + + + +# m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT]) +# ------------------------------------------------------------------- +# Similar to m4_if, except that each TEST is expanded when encountered. +# If the expansion of TESTn matches the string VALn, the result is IF-VALn. +# The result is DEFAULT if no tests passed. This macro allows +# short-circuiting of expensive tests, where it pays to arrange quick +# filter tests to run first. +# +# For an example, consider a previous implementation of _AS_QUOTE_IFELSE: +# +# m4_if(m4_index([$1], [\]), [-1], [$2], +# m4_eval(m4_index([$1], [\\]) >= 0), [1], [$2], +# m4_eval(m4_index([$1], [\$]) >= 0), [1], [$2], +# m4_eval(m4_index([$1], [\`]) >= 0), [1], [$3], +# m4_eval(m4_index([$1], [\"]) >= 0), [1], [$3], +# [$2]) +# +# Here, m4_index is computed 5 times, and m4_eval 4, even if $1 contains +# no backslash. It is more efficient to do: +# +# m4_cond([m4_index([$1], [\])], [-1], [$2], +# [m4_eval(m4_index([$1], [\\]) >= 0)], [1], [$2], +# [m4_eval(m4_index([$1], [\$]) >= 0)], [1], [$2], +# [m4_eval(m4_index([$1], [\`]) >= 0)], [1], [$3], +# [m4_eval(m4_index([$1], [\"]) >= 0)], [1], [$3], +# [$2]) +# +# In the common case of $1 with no backslash, only one m4_index expansion +# occurs, and m4_eval is avoided altogether. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_cond], +[m4_if([$#], [0], [m4_fatal([$0: cannot be called without arguments])], + [$#], [1], [$1], + m4_eval([$# % 3]), [2], [m4_fatal([$0: missing an argument])], + [_$0($@)])]) + +m4_define([_m4_cond], +[m4_if(($1), [($2)], [$3], + [$#], [3], [], + [$#], [4], [$4], + [$0(m4_shift3($@))])]) + + +## ---------------------------------------- ## +## 6. Enhanced version of some primitives. ## +## ---------------------------------------- ## + +# m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) +# ---------------------------------------------------- +# m4 equivalent of +# +# $_ = STRING; +# s/RE1/SUBST1/g; +# s/RE2/SUBST2/g; +# ... +# +# All the values are optional, and the macro is robust to active symbols +# properly quoted. +# +# I would have liked to name this macro `m4_bpatsubst', unfortunately, +# due to quotation problems, I need to double quote $1 below, therefore +# the anchors are broken :( I can't let users be trapped by that. +# +# Recall that m4_shift3 always results in an argument. Hence, we need +# to distinguish between a final deletion vs. ending recursion. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_bpatsubsts], +[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], + [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], + [$#], 2, [m4_unquote(m4_builtin([patsubst], [[$1]], [$2]))], + [$#], 3, [m4_unquote(m4_builtin([patsubst], [[$1]], [$2], [$3]))], + [_$0($@m4_if(m4_eval($# & 1), 0, [,]))])]) +m4_define([_m4_bpatsubsts], +[m4_if([$#], 2, [$1], + [$0(m4_builtin([patsubst], [[$1]], [$2], [$3]), + m4_shift3($@))])]) + + +# m4_copy(SRC, DST) +# ----------------- +# Define the pushdef stack DST as a copy of the pushdef stack SRC; +# give an error if DST is already defined. This is particularly nice +# for copying self-modifying pushdef stacks, where the top definition +# includes one-shot initialization that is later popped to the normal +# definition. This version intentionally does nothing if SRC is +# undefined. +# +# Some macros simply can't be renamed with this method: namely, anything +# involved in the implementation of m4_stack_foreach_sep. +m4_define([m4_copy], +[m4_ifdef([$2], [m4_fatal([$0: won't overwrite defined macro: $2])], + [m4_stack_foreach_sep([$1], [m4_pushdef([$2],], [)])])]dnl +[m4_ifdef([m4_location($1)], [m4_define([m4_location($2)], m4_location)])]) + + +# m4_copy_force(SRC, DST) +# m4_rename_force(SRC, DST) +# ------------------------- +# Like m4_copy/m4_rename, except blindly overwrite any existing DST. +# Note that m4_copy_force tolerates undefined SRC, while m4_rename_force +# does not. +m4_define([m4_copy_force], +[m4_ifdef([$2], [_m4_undefine([$2])])m4_copy($@)]) + +m4_define([m4_rename_force], +[m4_ifdef([$2], [_m4_undefine([$2])])m4_rename($@)]) + + +# m4_define_default(MACRO, VALUE) +# ------------------------------- +# If MACRO is undefined, set it to VALUE. +m4_define([m4_define_default], +[m4_ifndef([$1], [m4_define($@)])]) + + +# m4_default(EXP1, EXP2) +# m4_default_nblank(EXP1, EXP2) +# ----------------------------- +# Returns EXP1 if not empty/blank, otherwise EXP2. Expand the result. +# +# m4_default is called on hot paths, so inline the contents of m4_ifval, +# for one less round of expansion. +m4_define([m4_default], +[m4_if([$1], [], [$2], [$1])]) + +m4_define([m4_default_nblank], +[m4_ifblank([$1], [$2], [$1])]) + + +# m4_default_quoted(EXP1, EXP2) +# m4_default_nblank_quoted(EXP1, EXP2) +# ------------------------------------ +# Returns EXP1 if non empty/blank, otherwise EXP2. Leave the result quoted. +# +# For comparison: +# m4_define([active], [ACTIVE]) +# m4_default([active], [default]) => ACTIVE +# m4_default([], [active]) => ACTIVE +# -m4_default([ ], [active])- => - - +# -m4_default_nblank([ ], [active])- => -ACTIVE- +# m4_default_quoted([active], [default]) => active +# m4_default_quoted([], [active]) => active +# -m4_default_quoted([ ], [active])- => - - +# -m4_default_nblank_quoted([ ], [active])- => -active- +# +# m4_default macro is called on hot paths, so inline the contents of m4_ifval, +# for one less round of expansion. +m4_define([m4_default_quoted], +[m4_if([$1], [], [[$2]], [[$1]])]) + +m4_define([m4_default_nblank_quoted], +[m4_ifblank([$1], [[$2]], [[$1]])]) + + +# m4_defn(NAME) +# ------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). This replacement is not a full-featured +# replacement: if any of the defined macros contain unbalanced quoting, but +# when pasted together result in a well-quoted string, then only native m4 +# support is able to get it correct. But that's where quadrigraphs come in +# handy, if you really need unbalanced quotes inside your macros. +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_defn], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_defn([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + + +# m4_dumpdef(NAME...) +# ------------------- +# In m4 1.4.x, dumpdef writes to the current debugfile, rather than +# stderr. This in turn royally confuses autom4te; so we follow the +# lead of newer m4 and always dump to stderr. Unlike the original, +# this version requires an argument, since there is no convenient way +# in m4 1.4.x to grab the names of all defined macros. Newer m4 +# always dumps to stderr, regardless of the current debugfile; it also +# provides m4symbols as a way to grab all current macro names. But +# dumpdefs is not frequently called, so we don't need to worry about +# conditionally using these newer features. Also, this version +# doesn't sort multiple arguments. +# +# If we detect m4 1.6 or newer, then provide an alternate definition, +# installed during m4_init, that allows builtins through. +# Unfortunately, there is no nice way in m4 1.4.x to dump builtins. +m4_define([m4_dumpdef], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_ifdef([$1], [m4_errprintn( + [$1: ]m4_dquote(_m4_defn([$1])))], [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + +m4_define([_m4_dumpdef], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_builtin([dumpdef], [$1])], + [m4_map_args_sep([m4_builtin([dumpdef],], [)], [], $@)])]) + + +# m4_dumpdefs(NAME...) +# -------------------- +# Similar to `m4_dumpdef(NAME)', but if NAME was m4_pushdef'ed, display its +# value stack (most recent displayed first). Also, this version silently +# ignores undefined macros, rather than erroring out. +# +# This macro cheats, because it relies on the current definition of NAME +# while the second argument of m4_stack_foreach_lifo is evaluated (which +# would be undefined according to the API). +m4_define([m4_dumpdefs], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [m4_stack_foreach_lifo([$1], [m4_dumpdef([$1])m4_ignore])], + [m4_map_args([$0], $@)])]) + +# m4_esyscmd_s(COMMAND) +# --------------------- +# Like m4_esyscmd, except strip any trailing newlines, thus behaving +# more like shell command substitution. +m4_define([m4_esyscmd_s], +[m4_chomp_all(m4_esyscmd([$1]))]) + + +# m4_popdef(NAME) +# --------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_popdef], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_popdef([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + + +# m4_shiftn(N, ...) +# ----------------- +# Returns ... shifted N times. Useful for recursive "varargs" constructs. +# +# Autoconf does not use this macro, because it is inherently slower than +# calling the common cases of m4_shift2 or m4_shift3 directly. But it +# might as well be fast for other clients, such as Libtool. One way to +# do this is to expand $@ only once in _m4_shiftn (otherwise, for long +# lists, the expansion of m4_if takes twice as much memory as what the +# list itself occupies, only to throw away the unused branch). The end +# result is strictly equivalent to +# m4_if([$1], 1, [m4_shift(,m4_shift(m4_shift($@)))], +# [_m4_shiftn(m4_decr([$1]), m4_shift(m4_shift($@)))]) +# but with the final `m4_shift(m4_shift($@)))' shared between the two +# paths. The first leg uses a no-op m4_shift(,$@) to balance out the (). +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_shiftn], +[m4_assert(0 < $1 && $1 < $#)_$0($@)]) + +m4_define([_m4_shiftn], +[m4_if([$1], 1, [m4_shift(], + [$0(m4_decr([$1])]), m4_shift(m4_shift($@)))]) + +# m4_shift2(...) +# m4_shift3(...) +# -------------- +# Returns ... shifted twice, and three times. Faster than m4_shiftn. +m4_define([m4_shift2], [m4_shift(m4_shift($@))]) +m4_define([m4_shift3], [m4_shift(m4_shift(m4_shift($@)))]) + +# _m4_shift2(...) +# _m4_shift3(...) +# --------------- +# Like m4_shift2 or m4_shift3, except include a leading comma unless shifting +# consumes all arguments. Why? Because in recursion, it is nice to +# distinguish between 1 element left and 0 elements left, based on how many +# arguments this shift expands to. +m4_define([_m4_shift2], +[m4_if([$#], [2], [], + [, m4_shift(m4_shift($@))])]) +m4_define([_m4_shift3], +[m4_if([$#], [3], [], + [, m4_shift(m4_shift(m4_shift($@)))])]) + + +# m4_undefine(NAME) +# ----------------- +# Like the original, except guarantee a warning when using something which is +# undefined (unlike M4 1.4.x). +# +# This macro is called frequently, so minimize the amount of additional +# expansions by skipping m4_ifndef. Better yet, if __m4_version__ exists, +# (added in M4 1.6), then let m4 do the job for us (see m4_init). +m4_define([m4_undefine], +[m4_if([$#], [0], [[$0]], + [$#], [1], [m4_ifdef([$1], [_m4_undefine([$1])], + [m4_fatal([$0: undefined macro: $1])])], + [m4_map_args([$0], $@)])]) + +# _m4_wrap(PRE, POST) +# ------------------- +# Helper macro for m4_wrap and m4_wrap_lifo. Allows nested calls to +# m4_wrap within wrapped text. Use _m4_defn and _m4_popdef for speed. +m4_define([_m4_wrap], +[m4_ifdef([$0_text], + [m4_define([$0_text], [$1]_m4_defn([$0_text])[$2])], + [m4_builtin([m4wrap], [m4_unquote( + _m4_defn([$0_text])_m4_popdef([$0_text]))])m4_define([$0_text], [$1$2])])]) + +# m4_wrap(TEXT) +# ------------- +# Append TEXT to the list of hooks to be executed at the end of input. +# Whereas the order of the original may be LIFO in the underlying m4, +# this version is always FIFO. +m4_define([m4_wrap], +[_m4_wrap([], [$1[]])]) + +# m4_wrap_lifo(TEXT) +# ------------------ +# Prepend TEXT to the list of hooks to be executed at the end of input. +# Whereas the order of m4_wrap may be FIFO in the underlying m4, this +# version is always LIFO. +m4_define([m4_wrap_lifo], +[_m4_wrap([$1[]])]) + +## ------------------------- ## +## 7. Quoting manipulation. ## +## ------------------------- ## + + +# m4_apply(MACRO, LIST) +# --------------------- +# Invoke MACRO, with arguments provided from the quoted list of +# comma-separated quoted arguments. If LIST is empty, invoke MACRO +# without arguments. The expansion will not be concatenated with +# subsequent text. +m4_define([m4_apply], +[m4_if([$2], [], [$1], [$1($2)])[]]) + +# _m4_apply(MACRO, LIST) +# ---------------------- +# Like m4_apply, except do nothing if LIST is empty. +m4_define([_m4_apply], +[m4_if([$2], [], [], [$1($2)[]])]) + + +# m4_count(ARGS) +# -------------- +# Return a count of how many ARGS are present. +m4_define([m4_count], [$#]) + + +# m4_curry(MACRO, ARG...) +# ----------------------- +# Perform argument currying. The expansion of this macro is another +# macro that takes exactly one argument, appends it to the end of the +# original ARG list, then invokes MACRO. For example: +# m4_curry([m4_curry], [m4_reverse], [1])([2])([3]) => 3, 2, 1 +# Not quite as practical as m4_incr, but you could also do: +# m4_define([add], [m4_eval(([$1]) + ([$2]))]) +# m4_define([add_one], [m4_curry([add], [1])]) +# add_one()([2]) => 3 +m4_define([m4_curry], [$1(m4_shift($@,)_$0]) +m4_define([_m4_curry], [[$1])]) + + +# m4_do(STRING, ...) +# ------------------ +# This macro invokes all its arguments (in sequence, of course). It is +# useful for making your macros more structured and readable by dropping +# unnecessary dnl's and have the macros indented properly. No concatenation +# occurs after a STRING; use m4_unquote(m4_join(,STRING)) for that. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_do], +[m4_if([$#], 0, [], + [$#], 1, [$1[]], + [$1[]$0(m4_shift($@))])]) + + +# m4_dquote(ARGS) +# --------------- +# Return ARGS as a quoted list of quoted arguments. +m4_define([m4_dquote], [[$@]]) + + +# m4_dquote_elt(ARGS) +# ------------------- +# Return ARGS as an unquoted list of double-quoted arguments. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_dquote_elt], +[m4_if([$#], [0], [], + [$#], [1], [[[$1]]], + [[[$1]],$0(m4_shift($@))])]) + + +# m4_echo(ARGS) +# ------------- +# Return the ARGS, with the same level of quoting. Whitespace after +# unquoted commas are consumed. +m4_define([m4_echo], [$@]) + + +# m4_expand(ARG) +# _m4_expand(ARG) +# --------------- +# Return the expansion of ARG as a single string. Unlike +# m4_quote($1), this preserves whitespace following single-quoted +# commas that appear within ARG. It also deals with shell case +# statements. +# +# m4_define([active], [ACT, IVE]) +# m4_define([active2], [[ACT, IVE]]) +# m4_quote(active, active2) +# => ACT,IVE,ACT, IVE +# m4_expand([active, active2]) +# => ACT, IVE, ACT, IVE +# +# Unfortunately, due to limitations in m4, ARG must expand to +# something with balanced quotes (use quadrigraphs to get around +# this), and should not contain the unlikely delimiters -=<{( or +# )}>=-. It is possible to have unbalanced quoted `(' or `)', as well +# as unbalanced unquoted `)'. m4_expand can handle unterminated +# comments or dnl on the final line, at the expense of speed; it also +# aids in detecting attempts to incorrectly change the current +# diversion inside ARG. Meanwhile, _m4_expand is faster but must be +# given a terminated expansion, and has no safety checks for +# mis-diverted text. +# +# Exploit that extra unquoted () will group unquoted commas and the +# following whitespace. m4_bpatsubst can't handle newlines inside $1, +# and m4_substr strips quoting. So we (ab)use m4_changequote, using +# temporary quotes to remove the delimiters that conveniently included +# the unquoted () that were added prior to the changequote. +# +# Thanks to shell case statements, too many people are prone to pass +# underquoted `)', so we try to detect that by passing a marker as a +# fourth argument; if the marker is not present, then we assume that +# we encountered an early `)', and re-expand the first argument, but +# this time with one more `(' in the second argument and in the +# open-quote delimiter. We must also ignore the slop from the +# previous try. The final macro is thus half line-noise, half art. +m4_define([m4_expand], +[m4_pushdef([m4_divert], _m4_defn([_m4_divert_unsafe]))]dnl +[m4_pushdef([m4_divert_push], _m4_defn([_m4_divert_unsafe]))]dnl +[m4_chomp(_$0([$1 +]))_m4_popdef([m4_divert], [m4_divert_push])]) + +m4_define([_m4_expand], [$0_([$1], [(], -=<{($1)}>=-, [}>=-])]) + +m4_define([_m4_expand_], +[m4_if([$4], [}>=-], + [m4_changequote([-=<{$2], [)}>=-])$3m4_changequote([, ])], + [$0([$1], [($2], -=<{($2$1)}>=-, [}>=-])m4_ignore$2])]) + + +# m4_ignore(ARGS) +# --------------- +# Expands to nothing. Useful for conditionally ignoring an arbitrary +# number of arguments (see _m4_list_cmp for an example). +m4_define([m4_ignore]) + + +# m4_make_list(ARGS) +# ------------------ +# Similar to m4_dquote, this creates a quoted list of quoted ARGS. This +# version is less efficient than m4_dquote, but separates each argument +# with a comma and newline, rather than just comma, for readability. +# When developing an m4sugar algorithm, you could temporarily use +# m4_pushdef([m4_dquote],m4_defn([m4_make_list])) +# around your code to make debugging easier. +m4_define([m4_make_list], [m4_join([, +], m4_dquote_elt($@))]) + + +# m4_noquote(STRING) +# ------------------ +# Return the result of ignoring all quotes in STRING and invoking the +# macros it contains. Among other things, this is useful for enabling +# macro invocations inside strings with [] blocks (for instance regexps +# and help-strings). On the other hand, since all quotes are disabled, +# any macro expanded during this time that relies on nested [] quoting +# will likely crash and burn. This macro is seldom useful; consider +# m4_unquote or m4_expand instead. +m4_define([m4_noquote], +[m4_changequote([-=<{(],[)}>=-])$1-=<{()}>=-m4_changequote([,])]) + + +# m4_quote(ARGS) +# -------------- +# Return ARGS as a single argument. Any whitespace after unquoted commas +# is stripped. There is always output, even when there were no arguments. +# +# It is important to realize the difference between `m4_quote(exp)' and +# `[exp]': in the first case you obtain the quoted *result* of the +# expansion of EXP, while in the latter you just obtain the string +# `exp'. +m4_define([m4_quote], [[$*]]) + + +# _m4_quote(ARGS) +# --------------- +# Like m4_quote, except that when there are no arguments, there is no +# output. For conditional scenarios (such as passing _m4_quote as the +# macro name in m4_mapall), this feature can be used to distinguish between +# one argument of the empty string vs. no arguments. However, in the +# normal case with arguments present, this is less efficient than m4_quote. +m4_define([_m4_quote], +[m4_if([$#], [0], [], [[$*]])]) + + +# m4_reverse(ARGS) +# ---------------- +# Output ARGS in reverse order. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_reverse], +[m4_if([$#], [0], [], [$#], [1], [[$1]], + [$0(m4_shift($@)), [$1]])]) + + +# m4_unquote(ARGS) +# ---------------- +# Remove one layer of quotes from each ARG, performing one level of +# expansion. For one argument, m4_unquote([arg]) is more efficient than +# m4_do([arg]), but for multiple arguments, the difference is that +# m4_unquote separates arguments with commas while m4_do concatenates. +# Follow this macro with [] if concatenation with subsequent text is +# undesired. +m4_define([m4_unquote], [$*]) + + +## -------------------------- ## +## 8. Implementing m4 loops. ## +## -------------------------- ## + + +# m4_for(VARIABLE, FIRST, LAST, [STEP = +/-1], EXPRESSION) +# -------------------------------------------------------- +# Expand EXPRESSION defining VARIABLE to FROM, FROM + 1, ..., TO with +# increments of STEP. Both limits are included, and bounds are +# checked for consistency. The algorithm is robust to indirect +# VARIABLE names. Changing VARIABLE inside EXPRESSION will not impact +# the number of iterations. +# +# Uses _m4_defn for speed, and avoid dnl in the macro body. Factor +# the _m4_for call so that EXPRESSION is only parsed once. +m4_define([m4_for], +[m4_pushdef([$1], m4_eval([$2]))]dnl +[m4_cond([m4_eval(([$3]) > ([$2]))], 1, + [m4_pushdef([_m4_step], m4_eval(m4_default_quoted([$4], + 1)))m4_assert(_m4_step > 0)_$0(_m4_defn([$1]), + m4_eval((([$3]) - ([$2])) / _m4_step * _m4_step + ([$2])), _m4_step,], + [m4_eval(([$3]) < ([$2]))], 1, + [m4_pushdef([_m4_step], m4_eval(m4_default_quoted([$4], + -1)))m4_assert(_m4_step < 0)_$0(_m4_defn([$1]), + m4_eval((([$2]) - ([$3])) / -(_m4_step) * _m4_step + ([$2])), _m4_step,], + [m4_pushdef([_m4_step])_$0(_m4_defn([$1]), _m4_defn([$1]), 0,])]dnl +[[m4_define([$1],], [)$5])m4_popdef([_m4_step], [$1])]) + +# _m4_for(COUNT, LAST, STEP, PRE, POST) +# ------------------------------------- +# Core of the loop, no consistency checks, all arguments are plain +# numbers. Expand PRE[COUNT]POST, then alter COUNT by STEP and +# iterate if COUNT is not LAST. +m4_define([_m4_for], +[$4[$1]$5[]m4_if([$1], [$2], [], + [$0(m4_eval([$1 + $3]), [$2], [$3], [$4], [$5])])]) + + +# Implementing `foreach' loops in m4 is much more tricky than it may +# seem. For example, the old M4 1.4.4 manual had an incorrect example, +# which looked like this (when translated to m4sugar): +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], +# | [m4_pushdef([$1])_foreach([$1], [$2], [$3])m4_popdef([$1])]) +# | m4_define([_arg1], [$1]) +# | m4_define([_foreach], +# | [m4_if([$2], [()], , +# | [m4_define([$1], _arg1$2)$3[]_foreach([$1], (m4_shift$2), [$3])])]) +# +# But then if you run +# +# | m4_define(a, 1) +# | m4_define(b, 2) +# | m4_define(c, 3) +# | foreach([f], [([a], [(b], [c)])], [echo f +# | ]) +# +# it gives +# +# => echo 1 +# => echo (2,3) +# +# which is not what is expected. +# +# Of course the problem is that many quotes are missing. So you add +# plenty of quotes at random places, until you reach the expected +# result. Alternatively, if you are a quoting wizard, you directly +# reach the following implementation (but if you really did, then +# apply to the maintenance of m4sugar!). +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) +# | m4_define([_arg1], [[$1]]) +# | m4_define([_foreach], +# | [m4_if($2, [()], , +# | [m4_define([$1], [_arg1$2])$3[]_foreach([$1], [(m4_shift$2)], [$3])])]) +# +# which this time answers +# +# => echo a +# => echo (b +# => echo c) +# +# Bingo! +# +# Well, not quite. +# +# With a better look, you realize that the parens are more a pain than +# a help: since anyway you need to quote properly the list, you end up +# with always using an outermost pair of parens and an outermost pair +# of quotes. Rejecting the parens both eases the implementation, and +# simplifies the use: +# +# | # foreach(VAR, (LIST), STMT) +# | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) +# | m4_define([_arg1], [$1]) +# | m4_define([_foreach], +# | [m4_if($2, [], , +# | [m4_define([$1], [_arg1($2)])$3[]_foreach([$1], [m4_shift($2)], [$3])])]) +# +# +# Now, just replace the `$2' with `m4_quote($2)' in the outer `m4_if' +# to improve robustness, and you come up with a nice implementation +# that doesn't require extra parentheses in the user's LIST. +# +# But wait - now the algorithm is quadratic, because every recursion of +# the algorithm keeps the entire LIST and merely adds another m4_shift to +# the quoted text. If the user has a lot of elements in LIST, you can +# bring the system to its knees with the memory m4 then requires, or trip +# the m4 --nesting-limit recursion factor. The only way to avoid +# quadratic growth is ensure m4_shift is expanded prior to the recursion. +# Hence the design below. +# +# The M4 manual now includes a chapter devoted to this issue, with +# the lessons learned from m4sugar. And still, this design is only +# optimal for M4 1.6; see foreach.m4 for yet more comments on why +# M4 1.4.x uses yet another implementation. + + +# m4_foreach(VARIABLE, LIST, EXPRESSION) +# -------------------------------------- +# +# Expand EXPRESSION assigning each value of the LIST to VARIABLE. +# LIST should have the form `item_1, item_2, ..., item_n', i.e. the +# whole list must *quoted*. Quote members too if you don't want them +# to be expanded. +# +# This macro is robust to active symbols: +# | m4_define(active, [ACT, IVE]) +# | m4_foreach(Var, [active, active], [-Var-]) +# => -ACT--IVE--ACT--IVE- +# +# | m4_foreach(Var, [[active], [active]], [-Var-]) +# => -ACT, IVE--ACT, IVE- +# +# | m4_foreach(Var, [[[active]], [[active]]], [-Var-]) +# => -active--active- +# +# This macro is called frequently, so avoid extra expansions such as +# m4_ifval and dnl. Also, since $2 might be quite large, try to use it +# as little as possible in _m4_foreach; each extra use requires that much +# more memory for expansion. So, rather than directly compare $2 against +# [] and use m4_car/m4_cdr for recursion, we instead unbox the list (which +# requires swapping the argument order in the helper), insert an ignored +# third argument, and use m4_shift3 to detect when recursion is complete, +# at which point this looks very much like m4_map_args. +m4_define([m4_foreach], +[m4_if([$2], [], [], + [m4_pushdef([$1])_$0([m4_define([$1],], [)$3], [], + $2)m4_popdef([$1])])]) + +# _m4_foreach(PRE, POST, IGNORED, ARG...) +# --------------------------------------- +# Form the common basis of the m4_foreach and m4_map macros. For each +# ARG, expand PRE[ARG]POST[]. The IGNORED argument makes recursion +# easier, and must be supplied rather than implicit. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([_m4_foreach], +[m4_if([$#], [3], [], + [$1[$4]$2[]$0([$1], [$2], m4_shift3($@))])]) + + +# m4_foreach_w(VARIABLE, LIST, EXPRESSION) +# ---------------------------------------- +# Like m4_foreach, but the list is whitespace separated. Depending on +# EXPRESSION, it may be more efficient to use m4_map_args_w. +# +# This macro is robust to active symbols: +# m4_foreach_w([Var], [ active +# b act\ +# ive ], [-Var-])end +# => -active--b--active-end +# +# This used to use a slower implementation based on m4_foreach: +# m4_foreach([$1], m4_split(m4_normalize([$2]), [ ]), [$3]) +m4_define([m4_foreach_w], +[m4_pushdef([$1])m4_map_args_w([$2], + [m4_define([$1],], [)$3])m4_popdef([$1])]) + + +# m4_map(MACRO, LIST) +# m4_mapall(MACRO, LIST) +# ---------------------- +# Invoke MACRO($1), MACRO($2) etc. where $1, $2... are the elements of +# LIST. $1, $2... must in turn be lists, appropriate for m4_apply. +# If LIST contains an empty sublist, m4_map skips the expansion of +# MACRO, while m4_mapall expands MACRO with no arguments. +# +# Since LIST may be quite large, we want to minimize how often it +# appears in the expansion. Rather than use m4_car/m4_cdr iteration, +# we unbox the list, and use _m4_foreach for iteration. For m4_map, +# an empty list behaves like an empty sublist and gets ignored; for +# m4_mapall, we must special-case the empty list. +m4_define([m4_map], +[_m4_foreach([_m4_apply([$1],], [)], [], $2)]) + +m4_define([m4_mapall], +[m4_if([$2], [], [], + [_m4_foreach([m4_apply([$1],], [)], [], $2)])]) + + +# m4_map_sep(MACRO, [SEPARATOR], LIST) +# m4_mapall_sep(MACRO, [SEPARATOR], LIST) +# --------------------------------------- +# Invoke MACRO($1), SEPARATOR, MACRO($2), ..., MACRO($N) where $1, +# $2... $N are the elements of LIST, and are in turn lists appropriate +# for m4_apply. SEPARATOR is expanded, in order to allow the creation +# of a list of arguments by using a single-quoted comma as the +# separator. For each empty sublist, m4_map_sep skips the expansion +# of MACRO and SEPARATOR, while m4_mapall_sep expands MACRO with no +# arguments. +# +# For m4_mapall_sep, merely expand the first iteration without the +# separator, then include separator as part of subsequent recursion; +# but avoid extra expansion of LIST's side-effects via a helper macro. +# For m4_map_sep, things are trickier - we don't know if the first +# list element is an empty sublist, so we must define a self-modifying +# helper macro and use that as the separator instead. +m4_define([m4_map_sep], +[m4_pushdef([m4_Sep], [m4_define([m4_Sep], _m4_defn([m4_unquote]))])]dnl +[_m4_foreach([_m4_apply([m4_Sep([$2])[]$1],], [)], [], $3)m4_popdef([m4_Sep])]) + +m4_define([m4_mapall_sep], +[m4_if([$3], [], [], [_$0([$1], [$2], $3)])]) + +m4_define([_m4_mapall_sep], +[m4_apply([$1], [$3])_m4_foreach([m4_apply([$2[]$1],], [)], m4_shift2($@))]) + +# m4_map_args(EXPRESSION, ARG...) +# ------------------------------- +# Expand EXPRESSION([ARG]) for each argument. More efficient than +# m4_foreach([var], [ARG...], [EXPRESSION(m4_defn([var]))]) +# Shorthand for m4_map_args_sep([EXPRESSION(], [)], [], ARG...). +m4_define([m4_map_args], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [], + [$#], [2], [$1([$2])[]], + [_m4_foreach([$1(], [)], $@)])]) + + +# m4_map_args_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...) +# ------------------------------------------------------------- +# Perform a pairwise grouping of consecutive ARGs, by expanding +# EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the +# final argument is expanded with END-EXPR([ARGn]). +# +# For example: +# m4_define([show], [($*)m4_newline])dnl +# m4_map_args_pair([show], [], [a], [b], [c], [d], [e])dnl +# => (a,b) +# => (c,d) +# => (e) +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_map_args_pair], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [m4_fatal([$0: too few arguments: $#: $1])], + [$#], [2], [], + [$#], [3], [m4_default([$2], [$1])([$3])[]], + [$#], [4], [$1([$3], [$4])[]], + [$1([$3], [$4])[]$0([$1], [$2], m4_shift(m4_shift3($@)))])]) + + +# m4_map_args_sep([PRE], [POST], [SEP], ARG...) +# --------------------------------------------- +# Expand PRE[ARG]POST for each argument, with SEP between arguments. +m4_define([m4_map_args_sep], +[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])], + [$#], [1], [], + [$#], [2], [], + [$#], [3], [], + [$#], [4], [$1[$4]$2[]], + [$1[$4]$2[]_m4_foreach([$3[]$1], [$2], m4_shift3($@))])]) + + +# m4_map_args_w(STRING, [PRE], [POST], [SEP]) +# ------------------------------------------- +# Perform the expansion of PRE[word]POST[] for each word in STRING +# separated by whitespace. More efficient than: +# m4_foreach_w([var], [STRING], [PRE[]m4_defn([var])POST]) +# Additionally, expand SEP between words. +# +# As long as we have to use m4_bpatsubst to split the string, we might +# as well make it also apply PRE and POST; this avoids iteration +# altogether. But we must be careful of any \ in PRE or POST. +# _m4_strip returns a quoted string, but that's okay, since it also +# supplies an empty leading and trailing argument due to our +# intentional whitespace around STRING. We use m4_substr to strip the +# empty elements and remove the extra layer of quoting. +m4_define([m4_map_args_w], +[_$0(_m4_split([ ]m4_flatten([$1])[ ], [[ ]+], + m4_if(m4_index([$2$3$4], [\]), [-1], [[$3[]$4[]$2]], + [m4_bpatsubst([[$3[]$4[]$2]], [\\], [\\\\])])), + m4_len([[]$3[]$4]), m4_len([$4[]$2[]]))]) + +m4_define([_m4_map_args_w], +[m4_substr([$1], [$2], m4_eval(m4_len([$1]) - [$2] - [$3]))]) + + +# m4_stack_foreach(MACRO, FUNC) +# m4_stack_foreach_lifo(MACRO, FUNC) +# ---------------------------------- +# Pass each stacked definition of MACRO to the one-argument macro FUNC. +# m4_stack_foreach proceeds in FIFO order, while m4_stack_foreach_lifo +# processes the topmost definitions first. In addition, FUNC should +# not push or pop definitions of MACRO, and should not expect anything about +# the active definition of MACRO (it will not be the topmost, and may not +# be the one passed to FUNC either). +# +# Some macros simply can't be examined with this method: namely, +# anything involved in the implementation of _m4_stack_reverse. +m4_define([m4_stack_foreach], +[_m4_stack_reverse([$1], [m4_tmp-$1])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1], [$2(_m4_defn([m4_tmp-$1]))])]) + +m4_define([m4_stack_foreach_lifo], +[_m4_stack_reverse([$1], [m4_tmp-$1], [$2(_m4_defn([m4_tmp-$1]))])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1])]) + +# m4_stack_foreach_sep(MACRO, [PRE], [POST], [SEP]) +# m4_stack_foreach_sep_lifo(MACRO, [PRE], [POST], [SEP]) +# ------------------------------------------------------ +# Similar to m4_stack_foreach and m4_stack_foreach_lifo, in that every +# definition of a pushdef stack will be visited. But rather than +# passing the definition as a single argument to a macro, this variant +# expands the concatenation of PRE[]definition[]POST, and expands SEP +# between consecutive expansions. Note that m4_stack_foreach([a], [b]) +# is equivalent to m4_stack_foreach_sep([a], [b(], [)]). +m4_define([m4_stack_foreach_sep], +[_m4_stack_reverse([$1], [m4_tmp-$1])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1], [$2[]_m4_defn([m4_tmp-$1])$3], [$4[]])]) + +m4_define([m4_stack_foreach_sep_lifo], +[_m4_stack_reverse([$1], [m4_tmp-$1], [$2[]_m4_defn([m4_tmp-$1])$3], [$4[]])]dnl +[_m4_stack_reverse([m4_tmp-$1], [$1])]) + + +# _m4_stack_reverse(OLD, NEW, [ACTION], [SEP]) +# -------------------------------------------- +# A recursive worker for pushdef stack manipulation. Destructively +# copy the OLD stack into the NEW, and expanding ACTION for each +# iteration. After the first iteration, SEP is promoted to the front +# of ACTION (note that SEP should include a trailing [] if it is to +# avoid interfering with ACTION). The current definition is examined +# after the NEW has been pushed but before OLD has been popped; this +# order is important, as ACTION is permitted to operate on either +# _m4_defn([OLD]) or _m4_defn([NEW]). Since the operation is +# destructive, this macro is generally used twice, with a temporary +# macro name holding the swapped copy. +m4_define([_m4_stack_reverse], +[m4_ifdef([$1], [m4_pushdef([$2], + _m4_defn([$1]))$3[]_m4_popdef([$1])$0([$1], [$2], [$4$3])])]) + + + +## --------------------------- ## +## 9. More diversion support. ## +## --------------------------- ## + + +# m4_cleardivert(DIVERSION-NAME...) +# --------------------------------- +# Discard any text in DIVERSION-NAME. +# +# This works even inside m4_expand. +m4_define([m4_cleardivert], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [_m4_divert_raw([-1])m4_undivert($@)_m4_divert_raw( + _m4_divert(_m4_defn([_m4_divert_diversion]), [-]))])]) + + +# _m4_divert(DIVERSION-NAME or NUMBER, [NOWARN]) +# ---------------------------------------------- +# If DIVERSION-NAME is the name of a diversion, return its number, +# otherwise if it is a NUMBER return it. Issue a warning about +# the use of a number instead of a name, unless NOWARN is provided. +m4_define([_m4_divert], +[m4_ifdef([_m4_divert($1)], + [m4_indir([_m4_divert($1)])], + [m4_if([$2], [], [m4_warn([syntax], + [prefer named diversions])])$1])]) + +# KILL is only used to suppress output. +m4_define([_m4_divert(KILL)], -1) + +# The empty diversion name is a synonym for 0. +m4_define([_m4_divert()], 0) + + +# m4_divert_stack +# --------------- +# Print the diversion stack, if it's nonempty. The caller is +# responsible for any leading or trailing newline. +m4_define([m4_divert_stack], +[m4_stack_foreach_sep_lifo([_m4_divert_stack], [], [], [ +])]) + + +# m4_divert_stack_push(MACRO-NAME, DIVERSION-NAME) +# ------------------------------------------------ +# Form an entry of the diversion stack from caller MACRO-NAME and +# entering DIVERSION-NAME and push it. +m4_define([m4_divert_stack_push], +[m4_pushdef([_m4_divert_stack], m4_location[: $1: $2])]) + + +# m4_divert(DIVERSION-NAME) +# ------------------------- +# Change the diversion stream to DIVERSION-NAME. +m4_define([m4_divert], +[m4_popdef([_m4_divert_stack])]dnl +[m4_define([_m4_divert_diversion], [$1])]dnl +[m4_divert_stack_push([$0], [$1])]dnl +[_m4_divert_raw(_m4_divert([$1]))]) + + +# m4_divert_push(DIVERSION-NAME, [NOWARN]) +# ---------------------------------------- +# Change the diversion stream to DIVERSION-NAME, while stacking old values. +# For internal use only: if NOWARN is not empty, DIVERSION-NAME can be a +# number instead of a name. +m4_define([m4_divert_push], +[m4_divert_stack_push([$0], [$1])]dnl +[m4_pushdef([_m4_divert_diversion], [$1])]dnl +[_m4_divert_raw(_m4_divert([$1], [$2]))]) + + +# m4_divert_pop([DIVERSION-NAME]) +# ------------------------------- +# Change the diversion stream to its previous value, unstacking it. +# If specified, verify we left DIVERSION-NAME. +# When we pop the last value from the stack, we divert to -1. +m4_define([m4_divert_pop], +[m4_if([$1], [], [], + [$1], _m4_defn([_m4_divert_diversion]), [], + [m4_fatal([$0($1): diversion mismatch: +]m4_divert_stack)])]dnl +[_m4_popdef([_m4_divert_stack], [_m4_divert_diversion])]dnl +[m4_ifdef([_m4_divert_diversion], [], + [m4_fatal([too many m4_divert_pop])])]dnl +[_m4_divert_raw(_m4_divert(_m4_defn([_m4_divert_diversion]), [-]))]) + + +# m4_divert_text(DIVERSION-NAME, CONTENT) +# --------------------------------------- +# Output CONTENT into DIVERSION-NAME (which may be a number actually). +# An end of line is appended for free to CONTENT. +m4_define([m4_divert_text], +[m4_divert_push([$1])$2 +m4_divert_pop([$1])]) + + +# m4_divert_once(DIVERSION-NAME, CONTENT) +# --------------------------------------- +# Output CONTENT into DIVERSION-NAME once, if not already there. +# An end of line is appended for free to CONTENT. +m4_define([m4_divert_once], +[m4_expand_once([m4_divert_text([$1], [$2])])]) + + +# _m4_divert_unsafe(DIVERSION-NAME) +# --------------------------------- +# Issue a warning that the attempt to change the current diversion to +# DIVERSION-NAME is unsafe, because this macro is being expanded +# during argument collection of m4_expand. +m4_define([_m4_divert_unsafe], +[m4_fatal([$0: cannot change diversion to `$1' inside m4_expand])]) + + +# m4_undivert(DIVERSION-NAME...) +# ------------------------------ +# Undivert DIVERSION-NAME. Unlike the M4 version, this requires at +# least one DIVERSION-NAME; also, due to support for named diversions, +# this should not be used to undivert files. +m4_define([m4_undivert], +[m4_if([$#], [0], [m4_fatal([$0: missing argument])], + [$#], [1], [_m4_undivert(_m4_divert([$1]))], + [m4_map_args([$0], $@)])]) + + +## --------------------------------------------- ## +## 10. Defining macros with bells and whistles. ## +## --------------------------------------------- ## + +# `m4_defun' is basically `m4_define' but it equips the macro with the +# needed machinery for `m4_require'. A macro must be m4_defun'd if +# either it is m4_require'd, or it m4_require's. +# +# Two things deserve attention and are detailed below: +# 1. Implementation of m4_require +# 2. Keeping track of the expansion stack +# +# 1. Implementation of m4_require +# =============================== +# +# Of course m4_defun calls m4_provide, so that a macro which has +# been expanded is not expanded again when m4_require'd, but the +# difficult part is the proper expansion of macros when they are +# m4_require'd. +# +# The implementation is based on three ideas, (i) using diversions to +# prepare the expansion of the macro and its dependencies (by Franc,ois +# Pinard), (ii) expand the most recently m4_require'd macros _after_ +# the previous macros (by Axel Thimm), and (iii) track instances of +# provide before require (by Eric Blake). +# +# +# The first idea: why use diversions? +# ----------------------------------- +# +# When a macro requires another, the other macro is expanded in new +# diversion, GROW. When the outer macro is fully expanded, we first +# undivert the most nested diversions (GROW - 1...), and finally +# undivert GROW. To understand why we need several diversions, +# consider the following example: +# +# | m4_defun([TEST1], [Test...m4_require([TEST2])1]) +# | m4_defun([TEST2], [Test...m4_require([TEST3])2]) +# | m4_defun([TEST3], [Test...3]) +# +# Because m4_require is not required to be first in the outer macros, we +# must keep the expansions of the various levels of m4_require separated. +# Right before executing the epilogue of TEST1, we have: +# +# GROW - 2: Test...3 +# GROW - 1: Test...2 +# GROW: Test...1 +# BODY: +# +# Finally the epilogue of TEST1 undiverts GROW - 2, GROW - 1, and +# GROW into the regular flow, BODY. +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: Test...3; Test...2; Test...1 +# +# (The semicolons are here for clarification, but of course are not +# emitted.) This is what Autoconf 2.0 (I think) to 2.13 (I'm sure) +# implement. +# +# +# The second idea: first required first out +# ----------------------------------------- +# +# The natural implementation of the idea above is buggy and produces +# very surprising results in some situations. Let's consider the +# following example to explain the bug: +# +# | m4_defun([TEST1], [m4_require([TEST2a])m4_require([TEST2b])]) +# | m4_defun([TEST2a], []) +# | m4_defun([TEST2b], [m4_require([TEST3])]) +# | m4_defun([TEST3], [m4_require([TEST2a])]) +# | +# | AC_INIT +# | TEST1 +# +# The dependencies between the macros are: +# +# 3 --- 2b +# / \ is m4_require'd by +# / \ left -------------------- right +# 2a ------------ 1 +# +# If you strictly apply the rules given in the previous section you get: +# +# GROW - 2: TEST3 +# GROW - 1: TEST2a; TEST2b +# GROW: TEST1 +# BODY: +# +# (TEST2a, although required by TEST3 is not expanded in GROW - 3 +# because is has already been expanded before in GROW - 1, so it has +# been AC_PROVIDE'd, so it is not expanded again) so when you undivert +# the stack of diversions, you get: +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: TEST3; TEST2a; TEST2b; TEST1 +# +# i.e., TEST2a is expanded after TEST3 although the latter required the +# former. +# +# Starting from 2.50, we use an implementation provided by Axel Thimm. +# The idea is simple: the order in which macros are emitted must be the +# same as the one in which macros are expanded. (The bug above can +# indeed be described as: a macro has been m4_provide'd before its +# dependent, but it is emitted after: the lack of correlation between +# emission and expansion order is guilty). +# +# How to do that? You keep the stack of diversions to elaborate the +# macros, but each time a macro is fully expanded, emit it immediately. +# +# In the example above, when TEST2a is expanded, but it's epilogue is +# not run yet, you have: +# +# GROW - 2: +# GROW - 1: TEST2a +# GROW: Elaboration of TEST1 +# BODY: +# +# The epilogue of TEST2a emits it immediately: +# +# GROW - 2: +# GROW - 1: +# GROW: Elaboration of TEST1 +# BODY: TEST2a +# +# TEST2b then requires TEST3, so right before the epilogue of TEST3, you +# have: +# +# GROW - 2: TEST3 +# GROW - 1: Elaboration of TEST2b +# GROW: Elaboration of TEST1 +# BODY: TEST2a +# +# The epilogue of TEST3 emits it: +# +# GROW - 2: +# GROW - 1: Elaboration of TEST2b +# GROW: Elaboration of TEST1 +# BODY: TEST2a; TEST3 +# +# TEST2b is now completely expanded, and emitted: +# +# GROW - 2: +# GROW - 1: +# GROW: Elaboration of TEST1 +# BODY: TEST2a; TEST3; TEST2b +# +# and finally, TEST1 is finished and emitted: +# +# GROW - 2: +# GROW - 1: +# GROW: +# BODY: TEST2a; TEST3; TEST2b: TEST1 +# +# The idea is simple, but the implementation is a bit involved. If +# you are like me, you will want to see the actual functioning of this +# implementation to be convinced. The next section gives the full +# details. +# +# +# The Axel Thimm implementation at work +# ------------------------------------- +# +# We consider the macros above, and this configure.ac: +# +# AC_INIT +# TEST1 +# +# You should keep the definitions of _m4_defun_pro, _m4_defun_epi, and +# m4_require at hand to follow the steps. +# +# This implementation tries not to assume that the current diversion is +# BODY, so as soon as a macro (m4_defun'd) is expanded, we first +# record the current diversion under the name _m4_divert_dump (denoted +# DUMP below for short). This introduces an important difference with +# the previous versions of Autoconf: you cannot use m4_require if you +# are not inside an m4_defun'd macro, and especially, you cannot +# m4_require directly from the top level. +# +# We have not tried to simulate the old behavior (better yet, we +# diagnose it), because it is too dangerous: a macro m4_require'd from +# the top level is expanded before the body of `configure', i.e., before +# any other test was run. I let you imagine the result of requiring +# AC_STDC_HEADERS for instance, before AC_PROG_CC was actually run.... +# +# After AC_INIT was run, the current diversion is BODY. +# * AC_INIT was run +# DUMP: undefined +# diversion stack: BODY |- +# +# * TEST1 is expanded +# The prologue of TEST1 sets _m4_divert_dump, which is the diversion +# where the current elaboration will be dumped, to the current +# diversion. It also m4_divert_push to GROW, where the full +# expansion of TEST1 and its dependencies will be elaborated. +# DUMP: BODY +# BODY: empty +# diversions: GROW, BODY |- +# +# * TEST1 requires TEST2a +# _m4_require_call m4_divert_pushes another temporary diversion, +# GROW - 1, and expands TEST2a in there. +# DUMP: BODY +# BODY: empty +# GROW - 1: TEST2a +# diversions: GROW - 1, GROW, BODY |- +# Then the content of the temporary diversion is moved to DUMP and the +# temporary diversion is popped. +# DUMP: BODY +# BODY: TEST2a +# diversions: GROW, BODY |- +# +# * TEST1 requires TEST2b +# Again, _m4_require_call pushes GROW - 1 and heads to expand TEST2b. +# DUMP: BODY +# BODY: TEST2a +# diversions: GROW - 1, GROW, BODY |- +# +# * TEST2b requires TEST3 +# _m4_require_call pushes GROW - 2 and expands TEST3 here. +# (TEST3 requires TEST2a, but TEST2a has already been m4_provide'd, so +# nothing happens.) +# DUMP: BODY +# BODY: TEST2a +# GROW - 2: TEST3 +# diversions: GROW - 2, GROW - 1, GROW, BODY |- +# Then the diversion is appended to DUMP, and popped. +# DUMP: BODY +# BODY: TEST2a; TEST3 +# diversions: GROW - 1, GROW, BODY |- +# +# * TEST1 requires TEST2b (contd.) +# The content of TEST2b is expanded... +# DUMP: BODY +# BODY: TEST2a; TEST3 +# GROW - 1: TEST2b, +# diversions: GROW - 1, GROW, BODY |- +# ... and moved to DUMP. +# DUMP: BODY +# BODY: TEST2a; TEST3; TEST2b +# diversions: GROW, BODY |- +# +# * TEST1 is expanded: epilogue +# TEST1's own content is in GROW... +# DUMP: BODY +# BODY: TEST2a; TEST3; TEST2b +# GROW: TEST1 +# diversions: BODY |- +# ... and it's epilogue moves it to DUMP and then undefines DUMP. +# DUMP: undefined +# BODY: TEST2a; TEST3; TEST2b; TEST1 +# diversions: BODY |- +# +# +# The third idea: track macros provided before they were required +# --------------------------------------------------------------- +# +# Using just the first two ideas, Autoconf 2.50 through 2.63 still had +# a subtle bug for more than seven years. Let's consider the +# following example to explain the bug: +# +# | m4_defun([TEST1], [1]) +# | m4_defun([TEST2], [2[]m4_require([TEST1])]) +# | m4_defun([TEST3], [3 TEST1 m4_require([TEST2])]) +# | TEST3 +# +# After the prologue of TEST3, we are collecting text in GROW with the +# intent of dumping it in BODY during the epilogue. Next, we +# encounter the direct invocation of TEST1, which provides the macro +# in place in GROW. From there, we encounter a requirement for TEST2, +# which must be collected in a new diversion. While expanding TEST2, +# we encounter a requirement for TEST1, but since it has already been +# expanded, the Axel Thimm algorithm states that we can treat it as a +# no-op. But that would lead to an end result of `2 3 1', meaning +# that we have once again output a macro (TEST2) prior to its +# requirements (TEST1). +# +# The problem can only occur if a single defun'd macro first provides, +# then later indirectly requires, the same macro. Note that directly +# expanding then requiring a macro is okay: because the dependency was +# met, the require phase can be a no-op. For that matter, the outer +# macro can even require two helpers, where the first helper expands +# the macro, and the second helper indirectly requires the macro. +# Out-of-order expansion is only present if the inner macro is +# required by something that will be hoisted in front of where the +# direct expansion occurred. In other words, we must be careful not +# to warn on: +# +# | m4_defun([TEST4], [4]) +# | m4_defun([TEST5], [5 TEST4 m4_require([TEST4])]) +# | TEST5 => 5 4 +# +# or even the more complex: +# +# | m4_defun([TEST6], [6]) +# | m4_defun([TEST7], [7 TEST6]) +# | m4_defun([TEST8], [8 m4_require([TEST6])]) +# | m4_defun([TEST9], [9 m4_require([TEST8])]) +# | m4_defun([TEST10], [10 m4_require([TEST7]) m4_require([TEST9])]) +# | TEST10 => 7 6 8 9 10 +# +# So, to detect whether a require was direct or indirect, m4_defun and +# m4_require track the name of the macro that caused a diversion to be +# created (using the stack _m4_diverting, coupled with an O(1) lookup +# _m4_diverting([NAME])), and m4_provide stores the name associated +# with the diversion at which a macro was provided. A require call is +# direct if it occurs within the same diversion where the macro was +# provided, or if the diversion associated with the providing context +# has been collected. +# +# The implementation of the warning involves tracking the set of +# macros which have been provided since the start of the outermost +# defun'd macro (the set is named _m4_provide). When starting an +# outermost macro, the set is emptied; when a macro is provided, it is +# added to the set; when require expands the body of a macro, it is +# removed from the set; and when a macro is indirectly required, the +# set is checked. If a macro is in the set, then it has been provided +# before it was required, and we satisfy dependencies by expanding the +# macro as if it had never been provided; in the example given above, +# this means we now output `1 2 3 1'. Meanwhile, a warning is issued +# to inform the user that her macros trigger the bug in older autoconf +# versions, and that her output file now contains redundant contents +# (and possibly new problems, if the repeated macro was not +# idempotent). Meanwhile, macros defined by m4_defun_once instead of +# m4_defun are idempotent, avoiding any warning or duplicate output. +# +# +# 2. Keeping track of the expansion stack +# ======================================= +# +# When M4 expansion goes wrong it is often extremely hard to find the +# path amongst macros that drove to the failure. What is needed is +# the stack of macro `calls'. One could imagine that GNU M4 would +# maintain a stack of macro expansions, unfortunately it doesn't, so +# we do it by hand. This is of course extremely costly, but the help +# this stack provides is worth it. Nevertheless to limit the +# performance penalty this is implemented only for m4_defun'd macros, +# not for define'd macros. +# +# Each time we enter an m4_defun'd macros, we add a definition in +# _m4_expansion_stack, and when we exit the macro, we remove it (thanks +# to pushdef/popdef). m4_stack_foreach is used to print the expansion +# stack in the rare cases when it's needed. +# +# In addition, we want to detect circular m4_require dependencies. +# Each time we expand a macro FOO we define _m4_expanding(FOO); and +# m4_require(BAR) simply checks whether _m4_expanding(BAR) is defined. + + +# m4_expansion_stack +# ------------------ +# Expands to the entire contents of the expansion stack. The caller +# must supply a trailing newline. This macro always prints a +# location; check whether _m4_expansion_stack is defined to filter out +# the case when no defun'd macro is in force. +m4_define([m4_expansion_stack], +[m4_stack_foreach_sep_lifo([_$0], [_$0_entry(], [) +])m4_location[: the top level]]) + +# _m4_expansion_stack_entry(MACRO) +# -------------------------------- +# Format an entry for MACRO found on the expansion stack. +m4_define([_m4_expansion_stack_entry], +[_m4_defn([m4_location($1)])[: $1 is expanded from...]]) + +# m4_expansion_stack_push(MACRO) +# ------------------------------ +# Form an entry of the expansion stack on entry to MACRO and push it. +m4_define([m4_expansion_stack_push], +[m4_pushdef([_m4_expansion_stack], [$1])]) + + +# _m4_divert(GROW) +# ---------------- +# This diversion is used by the m4_defun/m4_require machinery. It is +# important to keep room before GROW because for each nested +# AC_REQUIRE we use an additional diversion (i.e., two m4_require's +# will use GROW - 2. More than 3 levels has never seemed to be +# needed.) +# +# ... +# - GROW - 2 +# m4_require'd code, 2 level deep +# - GROW - 1 +# m4_require'd code, 1 level deep +# - GROW +# m4_defun'd macros are elaborated here. + +m4_define([_m4_divert(GROW)], 10000) + + +# _m4_defun_pro(MACRO-NAME) +# ------------------------- +# The prologue for Autoconf macros. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and m4_defn overhead. +m4_define([_m4_defun_pro], +[m4_ifdef([_m4_expansion_stack], [], [_m4_defun_pro_outer([$1])])]dnl +[m4_expansion_stack_push([$1])m4_pushdef([_m4_expanding($1)])]) + +m4_define([_m4_defun_pro_outer], +[m4_set_delete([_m4_provide])]dnl +[m4_pushdef([_m4_diverting([$1])])m4_pushdef([_m4_diverting], [$1])]dnl +[m4_pushdef([_m4_divert_dump], m4_divnum)m4_divert_push([GROW])]) + +# _m4_defun_epi(MACRO-NAME) +# ------------------------- +# The Epilogue for Autoconf macros. MACRO-NAME only helps tracing +# the PRO/EPI pairs. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and m4_popdef overhead. +m4_define([_m4_defun_epi], +[_m4_popdef([_m4_expanding($1)], [_m4_expansion_stack])]dnl +[m4_ifdef([_m4_expansion_stack], [], [_m4_defun_epi_outer([$1])])]dnl +[m4_provide([$1])]) + +m4_define([_m4_defun_epi_outer], +[_m4_popdef([_m4_divert_dump], [_m4_diverting([$1])], [_m4_diverting])]dnl +[m4_divert_pop([GROW])m4_undivert([GROW])]) + + +# _m4_divert_dump +# --------------- +# If blank, we are outside of any defun'd macro. Otherwise, expands +# to the diversion number (not name) where require'd macros should be +# moved once completed. +m4_define([_m4_divert_dump]) + + +# m4_divert_require(DIVERSION, NAME-TO-CHECK, [BODY-TO-EXPAND]) +# ------------------------------------------------------------- +# Same as m4_require, but BODY-TO-EXPAND goes into the named DIVERSION; +# requirements still go in the current diversion though. +# +m4_define([m4_divert_require], +[m4_ifdef([_m4_expanding($2)], + [m4_fatal([$0: circular dependency of $2])])]dnl +[m4_if(_m4_divert_dump, [], + [m4_fatal([$0($2): cannot be used outside of an m4_defun'd macro])])]dnl +[m4_provide_if([$2], [], + [_m4_require_call([$2], [$3], _m4_divert([$1], [-]))])]) + + +# m4_defun(NAME, EXPANSION, [MACRO = m4_define]) +# ---------------------------------------------- +# Define a macro NAME which automatically provides itself. Add +# machinery so the macro automatically switches expansion to the +# diversion stack if it is not already using it, prior to EXPANSION. +# In this case, once finished, it will bring back all the code +# accumulated in the diversion stack. This, combined with m4_require, +# achieves the topological ordering of macros. We don't use this +# macro to define some frequently called macros that are not involved +# in ordering constraints, to save m4 processing. +# +# MACRO is an undocumented argument; when set to m4_pushdef, and NAME +# is already defined, the new definition is added to the pushdef +# stack, rather than overwriting the current definition. It can thus +# be used to write self-modifying macros, which pop themselves to a +# previously m4_define'd definition so that subsequent use of the +# macro is faster. +m4_define([m4_defun], +[m4_define([m4_location($1)], m4_location)]dnl +[m4_default([$3], [m4_define])([$1], + [_m4_defun_pro(]m4_dquote($[0])[)$2[]_m4_defun_epi(]m4_dquote($[0])[)])]) + + +# m4_defun_init(NAME, INIT, COMMON) +# --------------------------------- +# Like m4_defun, but split EXPANSION into two portions: INIT which is +# done only the first time NAME is invoked, and COMMON which is +# expanded every time. +# +# For now, the COMMON definition is always m4_define'd, giving an even +# lighter-weight definition. m4_defun allows self-providing, but once +# a macro is provided, m4_require no longer cares if it is m4_define'd +# or m4_defun'd. m4_defun also provides location tracking to identify +# dependency bugs, but once the INIT has been expanded, we know there +# are no dependency bugs. However, if a future use needs COMMON to be +# m4_defun'd, we can add a parameter, similar to the third parameter +# to m4_defun. +m4_define([m4_defun_init], +[m4_define([$1], [$3[]])m4_defun([$1], + [$2[]_m4_popdef(]m4_dquote($[0])[)m4_indir(]m4_dquote($[0])dnl +[m4_if(]m4_dquote($[#])[, [0], [], ]m4_dquote([,$]@)[))], [m4_pushdef])]) + + +# m4_defun_once(NAME, EXPANSION) +# ------------------------------ +# Like m4_defun, but guarantee that EXPANSION only happens once +# (thereafter, using NAME is a no-op). +# +# If _m4_divert_dump is empty, we are called at the top level; +# otherwise, we must ensure that we are required in front of the +# current defun'd macro. Use a helper macro so that EXPANSION need +# only occur once in the definition of NAME, since it might be large. +m4_define([m4_defun_once], +[m4_define([m4_location($1)], m4_location)]dnl +[m4_define([$1], [_m4_defun_once([$1], [$2], m4_if(_m4_divert_dump, [], + [[_m4_defun_pro([$1])m4_unquote(], [)_m4_defun_epi([$1])]], +m4_ifdef([_m4_diverting([$1])], [-]), [-], [[m4_unquote(], [)]], + [[_m4_require_call([$1],], [, _m4_divert_dump)]]))])]) + +m4_define([_m4_defun_once], +[m4_pushdef([$1])$3[$2[]m4_provide([$1])]$4]) + + +# m4_pattern_forbid(ERE, [WHY]) +# ----------------------------- +# Declare that no token matching the forbidden extended regular +# expression ERE should be seen in the output unless... +m4_define([m4_pattern_forbid], []) + + +# m4_pattern_allow(ERE) +# --------------------- +# ... that token also matches the allowed extended regular expression ERE. +# Both used via traces. +m4_define([m4_pattern_allow], []) + + +## --------------------------------- ## +## 11. Dependencies between macros. ## +## --------------------------------- ## + + +# m4_before(THIS-MACRO-NAME, CALLED-MACRO-NAME) +# --------------------------------------------- +# Issue a warning if CALLED-MACRO-NAME was called before THIS-MACRO-NAME. +m4_define([m4_before], +[m4_provide_if([$2], + [m4_warn([syntax], [$2 was called before $1])])]) + + +# m4_require(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK]) +# ----------------------------------------------------------- +# If NAME-TO-CHECK has never been expanded (actually, if it is not +# m4_provide'd), expand BODY-TO-EXPAND *before* the current macro +# expansion; follow the expansion with a newline. Once expanded, emit +# it in _m4_divert_dump. Keep track of the m4_require chain in +# _m4_expansion_stack. +# +# The normal cases are: +# +# - NAME-TO-CHECK == BODY-TO-EXPAND +# Which you can use for regular macros with or without arguments, e.g., +# m4_require([AC_PROG_CC], [AC_PROG_CC]) +# m4_require([AC_CHECK_HEADERS(threads.h)], [AC_CHECK_HEADERS(threads.h)]) +# which is just the same as +# m4_require([AC_PROG_CC]) +# m4_require([AC_CHECK_HEADERS(threads.h)]) +# +# - BODY-TO-EXPAND == m4_indir([NAME-TO-CHECK]) +# In the case of macros with irregular names. For instance: +# m4_require([AC_LANG_COMPILER(C)], [indir([AC_LANG_COMPILER(C)])]) +# which means `if the macro named `AC_LANG_COMPILER(C)' (the parens are +# part of the name, it is not an argument) has not been run, then +# call it.' +# Had you used +# m4_require([AC_LANG_COMPILER(C)], [AC_LANG_COMPILER(C)]) +# then m4_require would have tried to expand `AC_LANG_COMPILER(C)', i.e., +# call the macro `AC_LANG_COMPILER' with `C' as argument. +# +# You could argue that `AC_LANG_COMPILER', when it receives an argument +# such as `C' should dispatch the call to `AC_LANG_COMPILER(C)'. But this +# `extension' prevents `AC_LANG_COMPILER' from having actual arguments that +# it passes to `AC_LANG_COMPILER(C)'. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and other overhead on the common path. +m4_define([m4_require], +[m4_ifdef([_m4_expanding($1)], + [m4_fatal([$0: circular dependency of $1])])]dnl +[m4_if(_m4_divert_dump, [], + [m4_fatal([$0($1): cannot be used outside of an ]dnl +m4_if([$0], [m4_require], [[m4_defun]], [[AC_DEFUN]])['d macro])])]dnl +[m4_provide_if([$1], [m4_set_contains([_m4_provide], [$1], + [_m4_require_check([$1], _m4_defn([m4_provide($1)]), [$0])], [m4_ignore])], + [_m4_require_call])([$1], [$2], _m4_divert_dump)]) + + +# _m4_require_call(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK], +# DIVERSION-NUMBER) +# ----------------------------------------------------------------- +# If m4_require decides to expand the body, it calls this macro. The +# expansion is placed in DIVERSION-NUMBER. +# +# This is called frequently, so minimize the number of macro invocations +# by avoiding dnl and other overhead on the common path. +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_warn([syntax], [$1 is m4_require'd but not m4_defun'd])])]dnl +[_m4_divert_raw($3)_m4_undivert(_m4_divert_grow)]dnl +[m4_divert_pop(_m4_divert_grow)_m4_popdef([_m4_divert_grow], +[_m4_diverting([$1])], [_m4_diverting])]) + + +# _m4_require_check(NAME-TO-CHECK, OWNER, CALLER) +# ----------------------------------------------- +# NAME-TO-CHECK has been identified as previously expanded in the +# diversion owned by OWNER. If this is a problem, warn on behalf of +# CALLER and return _m4_require_call; otherwise return m4_ignore. +m4_define([_m4_require_check], +[m4_if(_m4_defn([_m4_diverting]), [$2], [m4_ignore], + m4_ifdef([_m4_diverting([$2])], [-]), [-], [m4_warn([syntax], + [$3: `$1' was expanded before it was required +http://www.gnu.org/software/autoconf/manual/autoconf.html#Expanded-Before-Required])_m4_require_call], + [m4_ignore])]) + + +# _m4_divert_grow +# --------------- +# The counter for _m4_require_call. +m4_define([_m4_divert_grow], _m4_divert([GROW])) + + +# m4_expand_once(TEXT, [WITNESS = TEXT]) +# -------------------------------------- +# If TEXT has never been expanded, expand it *here*. Use WITNESS as +# as a memory that TEXT has already been expanded. +m4_define([m4_expand_once], +[m4_provide_if(m4_default_quoted([$2], [$1]), + [], + [m4_provide(m4_default_quoted([$2], [$1]))[]$1])]) + + +# m4_provide(MACRO-NAME) +# ---------------------- +m4_define([m4_provide], +[m4_ifdef([m4_provide($1)], [], +[m4_set_add([_m4_provide], [$1], [m4_define([m4_provide($1)], + m4_ifdef([_m4_diverting], [_m4_defn([_m4_diverting])]))])])]) + + +# m4_provide_if(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED) +# ------------------------------------------------------- +# If MACRO-NAME is provided do IF-PROVIDED, else IF-NOT-PROVIDED. +# The purpose of this macro is to provide the user with a means to +# check macros which are provided without letting her know how the +# information is coded. +m4_define([m4_provide_if], +[m4_ifdef([m4_provide($1)], + [$2], [$3])]) + + +## --------------------- ## +## 12. Text processing. ## +## --------------------- ## + + +# m4_cr_letters +# m4_cr_LETTERS +# m4_cr_Letters +# ------------- +m4_define([m4_cr_letters], [abcdefghijklmnopqrstuvwxyz]) +m4_define([m4_cr_LETTERS], [ABCDEFGHIJKLMNOPQRSTUVWXYZ]) +m4_define([m4_cr_Letters], +m4_defn([m4_cr_letters])dnl +m4_defn([m4_cr_LETTERS])dnl +) + + +# m4_cr_digits +# ------------ +m4_define([m4_cr_digits], [0123456789]) + + +# m4_cr_alnum +# ----------- +m4_define([m4_cr_alnum], +m4_defn([m4_cr_Letters])dnl +m4_defn([m4_cr_digits])dnl +) + + +# m4_cr_symbols1 +# m4_cr_symbols2 +# -------------- +m4_define([m4_cr_symbols1], +m4_defn([m4_cr_Letters])dnl +_) + +m4_define([m4_cr_symbols2], +m4_defn([m4_cr_symbols1])dnl +m4_defn([m4_cr_digits])dnl +) + +# m4_cr_all +# --------- +# The character range representing everything, with `-' as the last +# character, since it is special to m4_translit. Use with care, because +# it contains characters special to M4 (fortunately, both ASCII and EBCDIC +# have [] in order, so m4_defn([m4_cr_all]) remains a valid string). It +# also contains characters special to terminals, so it should never be +# displayed in an error message. Also, attempts to map [ and ] to other +# characters via m4_translit must deal with the fact that m4_translit does +# not add quotes to the output. +# +# In EBCDIC, $ is immediately followed by *, which leads to problems +# if m4_cr_all is inlined into a macro definition; so swap them. +# +# It is mainly useful in generating inverted character range maps, for use +# in places where m4_translit is faster than an equivalent m4_bpatsubst; +# the regex `[^a-z]' is equivalent to: +# m4_translit(m4_dquote(m4_defn([m4_cr_all])), [a-z]) +m4_define([m4_cr_all], +m4_translit(m4_dquote(m4_format(m4_dquote(m4_for( + ,1,255,,[[%c]]))m4_for([i],1,255,,[,i]))), [$*-], [*$])-) + + +# _m4_define_cr_not(CATEGORY) +# --------------------------- +# Define m4_cr_not_CATEGORY as the inverse of m4_cr_CATEGORY. +m4_define([_m4_define_cr_not], +[m4_define([m4_cr_not_$1], + m4_translit(m4_dquote(m4_defn([m4_cr_all])), + m4_defn([m4_cr_$1])))]) + + +# m4_cr_not_letters +# m4_cr_not_LETTERS +# m4_cr_not_Letters +# m4_cr_not_digits +# m4_cr_not_alnum +# m4_cr_not_symbols1 +# m4_cr_not_symbols2 +# ------------------ +# Inverse character sets +_m4_define_cr_not([letters]) +_m4_define_cr_not([LETTERS]) +_m4_define_cr_not([Letters]) +_m4_define_cr_not([digits]) +_m4_define_cr_not([alnum]) +_m4_define_cr_not([symbols1]) +_m4_define_cr_not([symbols2]) + + +# m4_newline([STRING]) +# -------------------- +# Expands to a newline, possibly followed by STRING. Exists mostly for +# formatting reasons. +m4_define([m4_newline], [ +$1]) + + +# m4_re_escape(STRING) +# -------------------- +# Escape RE active characters in STRING. +m4_define([m4_re_escape], +[m4_bpatsubst([$1], + [[][*+.?\^$]], [\\\&])]) + + +# m4_re_string +# ------------ +# Regexp for `[a-zA-Z_0-9]*' +# m4_dquote provides literal [] for the character class. +m4_define([m4_re_string], +m4_dquote(m4_defn([m4_cr_symbols2]))dnl +[*]dnl +) + + +# m4_re_word +# ---------- +# Regexp for `[a-zA-Z_][a-zA-Z_0-9]*' +m4_define([m4_re_word], +m4_dquote(m4_defn([m4_cr_symbols1]))dnl +m4_defn([m4_re_string])dnl +) + + +# m4_tolower(STRING) +# m4_toupper(STRING) +# ------------------ +# These macros convert STRING to lowercase or uppercase. +# +# Rather than expand the m4_defn each time, we inline them up front. +m4_define([m4_tolower], +[m4_translit([[$1]], ]m4_dquote(m4_defn([m4_cr_LETTERS]))[, + ]m4_dquote(m4_defn([m4_cr_letters]))[)]) +m4_define([m4_toupper], +[m4_translit([[$1]], ]m4_dquote(m4_defn([m4_cr_letters]))[, + ]m4_dquote(m4_defn([m4_cr_LETTERS]))[)]) + + +# m4_split(STRING, [REGEXP]) +# -------------------------- +# Split STRING into an m4 list of quoted elements. The elements are +# quoted with [ and ]. Beginning spaces and end spaces *are kept*. +# Use m4_strip to remove them. +# +# REGEXP specifies where to split. Default is [\t ]+. +# +# If STRING is empty, the result is an empty list. +# +# Pay attention to the m4_changequotes. When m4 reads the definition of +# m4_split, it still has quotes set to [ and ]. Luckily, these are matched +# in the macro body, so the definition is stored correctly. Use the same +# alternate quotes as m4_noquote; it must be unlikely to appear in $1. +# +# Also, notice that $1 is quoted twice, since we want the result to +# be quoted. Then you should understand that the argument of +# patsubst is -=<{(STRING)}>=- (i.e., with additional -=<{( and )}>=-). +# +# This macro is safe on active symbols, i.e.: +# m4_define(active, ACTIVE) +# m4_split([active active ])end +# => [active], [active], []end +# +# Optimize on regex of ` ' (space), since m4_foreach_w already guarantees +# that the list contains single space separators, and a common case is +# splitting a single-element list. This macro is called frequently, +# so avoid unnecessary dnl inside the definition. +m4_define([m4_split], +[m4_if([$1], [], [], + [$2], [ ], [m4_if(m4_index([$1], [ ]), [-1], [[[$1]]], + [_$0([$1], [$2], [, ])])], + [$2], [], [_$0([$1], [[ ]+], [, ])], + [_$0([$1], [$2], [, ])])]) + +m4_define([_m4_split], +[m4_changequote([-=<{(],[)}>=-])]dnl +[[m4_bpatsubst(-=<{(-=<{($1)}>=-)}>=-, -=<{($2)}>=-, + -=<{(]$3[)}>=-)]m4_changequote([, ])]) + + +# m4_chomp(STRING) +# m4_chomp_all(STRING) +# -------------------- +# Return STRING quoted, but without a trailing newline. m4_chomp +# removes at most one newline, while m4_chomp_all removes all +# consecutive trailing newlines. Embedded newlines are not touched, +# and a trailing backslash-newline leaves just a trailing backslash. +# +# m4_bregexp is slower than m4_index, and we don't always want to +# remove all newlines; hence the two variants. We massage characters +# to give a nicer pattern to match, particularly since m4_bregexp is +# line-oriented. Both versions must guarantee a match, to avoid bugs +# with precision -1 in m4_format in older m4. +m4_define([m4_chomp], +[m4_format([[%.*s]], m4_index(m4_translit([[$1]], [ +/.], [/ ])[./.], [/.]), [$1])]) + +m4_define([m4_chomp_all], +[m4_format([[%.*s]], m4_bregexp(m4_translit([[$1]], [ +/], [/ ]), [/*$]), [$1])]) + + +# m4_flatten(STRING) +# ------------------ +# If STRING contains end of lines, replace them with spaces. If there +# are backslashed end of lines, remove them. This macro is safe with +# active symbols. +# m4_define(active, ACTIVE) +# m4_flatten([active +# act\ +# ive])end +# => active activeend +# +# In m4, m4_bpatsubst is expensive, so first check for a newline. +m4_define([m4_flatten], +[m4_if(m4_index([$1], [ +]), [-1], [[$1]], + [m4_translit(m4_bpatsubst([[[$1]]], [\\ +]), [ +], [ ])])]) + + +# m4_strip(STRING) +# ---------------- +# Expands into STRING with tabs and spaces singled out into a single +# space, and removing leading and trailing spaces. +# +# This macro is robust to active symbols. +# m4_define(active, ACTIVE) +# m4_strip([ active active ])end +# => active activeend +# +# First, notice that we guarantee trailing space. Why? Because regular +# expressions are greedy, and `.* ?' would always group the space into the +# .* portion. The algorithm is simpler by avoiding `?' at the end. The +# algorithm correctly strips everything if STRING is just ` '. +# +# Then notice the second pattern: it is in charge of removing the +# leading/trailing spaces. Why not just `[^ ]'? Because they are +# applied to over-quoted strings, i.e. more or less [STRING], due +# to the limitations of m4_bpatsubsts. So the leading space in STRING +# is the *second* character; equally for the trailing space. +m4_define([m4_strip], +[m4_bpatsubsts([$1 ], + [[ ]+], [ ], + [^. ?\(.*\) .$], [[[\1]]])]) + + +# m4_normalize(STRING) +# -------------------- +# Apply m4_flatten and m4_strip to STRING. +# +# The argument is quoted, so that the macro is robust to active symbols: +# +# m4_define(active, ACTIVE) +# m4_normalize([ act\ +# ive +# active ])end +# => active activeend + +m4_define([m4_normalize], +[m4_strip(m4_flatten([$1]))]) + + + +# m4_join(SEP, ARG1, ARG2...) +# --------------------------- +# Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG +# is the empty string. No expansion is performed on SEP or ARGs. +# +# Since the number of arguments to join can be arbitrarily long, we +# want to avoid having more than one $@ in the macro definition; +# otherwise, the expansion would require twice the memory of the already +# long list. Hence, m4_join merely looks for the first non-empty element, +# and outputs just that element; while _m4_join looks for all non-empty +# elements, and outputs them following a separator. The final trick to +# note is that we decide between recursing with $0 or _$0 based on the +# nested m4_if ending with `_'. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_join], +[m4_if([$#], [1], [], + [$#], [2], [[$2]], + [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift2($@))])]) +m4_define([_m4_join], +[m4_if([$#$2], [2], [], + [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift2($@))])]) + +# m4_joinall(SEP, ARG1, ARG2...) +# ------------------------------ +# Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP. +# No expansion is performed on SEP or ARGs. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_joinall], [[$2]_$0([$1], m4_shift($@))]) +m4_define([_m4_joinall], +[m4_if([$#], [2], [], [[$1$3]$0([$1], m4_shift2($@))])]) + +# m4_combine([SEPARATOR], PREFIX-LIST, [INFIX], SUFFIX...) +# -------------------------------------------------------- +# Produce the pairwise combination of every element in the quoted, +# comma-separated PREFIX-LIST with every element from the SUFFIX arguments. +# Each pair is joined with INFIX, and pairs are separated by SEPARATOR. +# No expansion occurs on SEPARATOR, INFIX, or elements of either list. +# +# For example: +# m4_combine([, ], [[a], [b], [c]], [-], [1], [2], [3]) +# => a-1, a-2, a-3, b-1, b-2, b-3, c-1, c-2, c-3 +# +# This definition is a bit hairy; the thing to realize is that we want +# to construct m4_map_args_sep([[prefix$3]], [], [[$1]], m4_shift3($@)) +# as the inner loop, using each prefix generated by the outer loop, +# and without recalculating m4_shift3 every outer iteration. +m4_define([m4_combine], +[m4_if([$2], [], [], m4_eval([$# > 3]), [1], +[m4_map_args_sep([m4_map_args_sep(m4_dquote(], [)[[$3]], [], [[$1]],]]]dnl +[m4_dquote(m4_dquote(m4_shift3($@)))[[)], [[$1]], $2)])]) + + +# m4_append(MACRO-NAME, STRING, [SEPARATOR]) +# ------------------------------------------ +# Redefine MACRO-NAME to hold its former content plus `SEPARATOR`'STRING' +# at the end. It is valid to use this macro with MACRO-NAME undefined, +# in which case no SEPARATOR is added. Be aware that the criterion is +# `not being defined', and not `not being empty'. +# +# Note that neither STRING nor SEPARATOR are expanded here; rather, when +# you expand MACRO-NAME, they will be expanded at that point in time. +# +# This macro is robust to active symbols. It can be used to grow +# strings. +# +# | m4_define(active, ACTIVE)dnl +# | m4_append([sentence], [This is an])dnl +# | m4_append([sentence], [ active ])dnl +# | m4_append([sentence], [symbol.])dnl +# | sentence +# | m4_undefine([active])dnl +# | sentence +# => This is an ACTIVE symbol. +# => This is an active symbol. +# +# It can be used to define hooks. +# +# | m4_define(active, ACTIVE)dnl +# | m4_append([hooks], [m4_define([act1], [act2])])dnl +# | m4_append([hooks], [m4_define([act2], [active])])dnl +# | m4_undefine([active])dnl +# | act1 +# | hooks +# | act1 +# => act1 +# => +# => active +# +# It can also be used to create lists, although this particular usage was +# broken prior to autoconf 2.62. +# | m4_append([list], [one], [, ])dnl +# | m4_append([list], [two], [, ])dnl +# | m4_append([list], [three], [, ])dnl +# | list +# | m4_dquote(list) +# => one, two, three +# => [one],[two],[three] +# +# Note that m4_append can benefit from amortized O(n) m4 behavior, if +# the underlying m4 implementation is smart enough to avoid copying existing +# contents when enlarging a macro's definition into any pre-allocated storage +# (m4 1.4.x unfortunately does not implement this optimization). We do +# not implement m4_prepend, since it is inherently O(n^2) (pre-allocated +# storage only occurs at the end of a macro, so the existing contents must +# always be moved). +# +# Use _m4_defn for speed. +m4_define([m4_append], +[m4_define([$1], m4_ifdef([$1], [_m4_defn([$1])[$3]])[$2])]) + + +# m4_append_uniq(MACRO-NAME, STRING, [SEPARATOR], [IF-UNIQ], [IF-DUP]) +# -------------------------------------------------------------------- +# Like `m4_append', but append only if not yet present. Additionally, +# expand IF-UNIQ if STRING was appended, or IF-DUP if STRING was already +# present. Also, warn if SEPARATOR is not empty and occurs within STRING, +# as the algorithm no longer guarantees uniqueness. +# +# Note that while m4_append can be O(n) (depending on the quality of the +# underlying M4 implementation), m4_append_uniq is inherently O(n^2) +# because each append operation searches the entire string. +m4_define([m4_append_uniq], +[m4_ifval([$3], [m4_if(m4_index([$2], [$3]), [-1], [], + [m4_warn([syntax], + [$0: `$2' contains `$3'])])])_$0($@)]) +m4_define([_m4_append_uniq], +[m4_ifdef([$1], + [m4_if(m4_index([$3]_m4_defn([$1])[$3], [$3$2$3]), [-1], + [m4_append([$1], [$2], [$3])$4], [$5])], + [m4_define([$1], [$2])$4])]) + +# m4_append_uniq_w(MACRO-NAME, STRINGS) +# ------------------------------------- +# For each of the words in the whitespace separated list STRINGS, append +# only the unique strings to the definition of MACRO-NAME. +# +# Use _m4_defn for speed. +m4_define([m4_append_uniq_w], +[m4_map_args_w([$2], [_m4_append_uniq([$1],], [, [ ])])]) + + +# m4_escape(STRING) +# ----------------- +# Output quoted STRING, but with embedded #, $, [ and ] turned into +# quadrigraphs. +# +# It is faster to check if STRING is already good using m4_translit +# than to blindly perform four m4_bpatsubst. +# +# Because the translit is stripping quotes, it must also neutralize +# anything that might be in a macro name, as well as comments, commas, +# and parentheses. All the problem characters are unified so that a +# single m4_index can scan the result. +# +# Rather than expand m4_defn every time m4_escape is expanded, we +# inline its expansion up front. +m4_define([m4_escape], +[m4_if(m4_index(m4_translit([$1], + [[]#,()]]m4_dquote(m4_defn([m4_cr_symbols2]))[, [$$$]), [$]), + [-1], [m4_echo], [_$0])([$1])]) + +m4_define([_m4_escape], +[m4_changequote([-=<{(],[)}>=-])]dnl +[m4_bpatsubst(m4_bpatsubst(m4_bpatsubst(m4_bpatsubst( + -=<{(-=<{(-=<{(-=<{(-=<{($1)}>=-)}>=-)}>=-)}>=-)}>=-, + -=<{(#)}>=-, -=<{(@%:@)}>=-), + -=<{(\[)}>=-, -=<{(@<:@)}>=-), + -=<{(\])}>=-, -=<{(@:>@)}>=-), + -=<{(\$)}>=-, -=<{(@S|@)}>=-)m4_changequote([,])]) + + +# m4_text_wrap(STRING, [PREFIX], [FIRST-PREFIX], [WIDTH]) +# ------------------------------------------------------- +# Expands into STRING wrapped to hold in WIDTH columns (default = 79). +# If PREFIX is given, each line is prefixed with it. If FIRST-PREFIX is +# specified, then the first line is prefixed with it. As a special case, +# if the length of FIRST-PREFIX is greater than that of PREFIX, then +# FIRST-PREFIX will be left alone on the first line. +# +# No expansion occurs on the contents STRING, PREFIX, or FIRST-PREFIX, +# although quadrigraphs are correctly recognized. More precisely, +# you may redefine m4_qlen to recognize whatever escape sequences that +# you will post-process. +# +# Typical outputs are: +# +# m4_text_wrap([Short string */], [ ], [/* ], 20) +# => /* Short string */ +# +# m4_text_wrap([Much longer string */], [ ], [/* ], 20) +# => /* Much longer +# => string */ +# +# m4_text_wrap([Short doc.], [ ], [ --short ], 30) +# => --short Short doc. +# +# m4_text_wrap([Short doc.], [ ], [ --too-wide ], 30) +# => --too-wide +# => Short doc. +# +# m4_text_wrap([Super long documentation.], [ ], [ --too-wide ], 30) +# => --too-wide +# => Super long +# => documentation. +# +# FIXME: there is no checking of a longer PREFIX than WIDTH, but do +# we really want to bother with people trying each single corner +# of a software? +# +# This macro does not leave a trailing space behind the last word of a line, +# which complicates it a bit. The algorithm is otherwise stupid and simple: +# all the words are preceded by m4_Separator which is defined to empty for +# the first word, and then ` ' (single space) for all the others. +# +# The algorithm uses a helper that uses $2 through $4 directly, rather than +# using local variables, to avoid m4_defn overhead, or expansion swallowing +# any $. It also bypasses m4_popdef overhead with _m4_popdef since no user +# macro expansion occurs in the meantime. Also, the definition is written +# with m4_do, to avoid time wasted on dnl during expansion (since this is +# already a time-consuming macro). +m4_define([m4_text_wrap], +[_$0(m4_escape([$1]), [$2], m4_default_quoted([$3], [$2]), + m4_default_quoted([$4], [79]))]) + +m4_define([_m4_text_wrap], +m4_do(dnl set up local variables, to avoid repeated calculations +[[m4_pushdef([m4_Indent], m4_qlen([$2]))]], +[[m4_pushdef([m4_Cursor], m4_qlen([$3]))]], +[[m4_pushdef([m4_Separator], [m4_define([m4_Separator], [ ])])]], +dnl expand the first prefix, then check its length vs. regular prefix +dnl same length: nothing special +dnl prefix1 longer: output on line by itself, and reset cursor +dnl prefix1 shorter: pad to length of prefix, and reset cursor +[[[$3]m4_cond([m4_Cursor], m4_Indent, [], + [m4_eval(m4_Cursor > m4_Indent)], [1], [ +[$2]m4_define([m4_Cursor], m4_Indent)], + [m4_format([%*s], m4_max([0], + m4_eval(m4_Indent - m4_Cursor)), [])m4_define([m4_Cursor], m4_Indent)])]], +dnl now, for each word, compute the cursor after the word is output, then +dnl check if the cursor would exceed the wrap column +dnl if so, reset cursor, and insert newline and prefix +dnl if not, insert the separator (usually a space) +dnl either way, insert the word +[[m4_map_args_w([$1], [$0_word(], [, [$2], [$4])])]], +dnl finally, clean up the local variables +[[_m4_popdef([m4_Separator], [m4_Cursor], [m4_Indent])]])) + +m4_define([_m4_text_wrap_word], +[m4_define([m4_Cursor], m4_eval(m4_Cursor + m4_qlen([$1]) + 1))]dnl +[m4_if(m4_eval(m4_Cursor > ([$3])), + [1], [m4_define([m4_Cursor], m4_eval(m4_Indent + m4_qlen([$1]) + 1)) +[$2]], + [m4_Separator[]])[$1]]) + +# m4_text_box(MESSAGE, [FRAME-CHARACTER = `-']) +# --------------------------------------------- +# Turn MESSAGE into: +# ## ------- ## +# ## MESSAGE ## +# ## ------- ## +# using FRAME-CHARACTER in the border. +# +# Quadrigraphs are correctly recognized. More precisely, you may +# redefine m4_qlen to recognize whatever escape sequences that you +# will post-process. +m4_define([m4_text_box], +[m4_pushdef([m4_Border], + m4_translit(m4_format([[[%*s]]], m4_decr(m4_qlen(_m4_expand([$1 +]))), []), [ ], m4_default_quoted([$2], [-])))]dnl +[[##] _m4_defn([m4_Border]) [##] +[##] $1 [##] +[##] _m4_defn([m4_Border]) [##]_m4_popdef([m4_Border])]) + + +# m4_qlen(STRING) +# --------------- +# Expands to the length of STRING after autom4te converts all quadrigraphs. +# +# If you use some other means of post-processing m4 output rather than +# autom4te, then you may redefine this macro to recognize whatever +# escape sequences your post-processor will handle. For that matter, +# m4_define([m4_qlen], m4_defn([m4_len])) is sufficient if you don't +# do any post-processing. +# +# Avoid bpatsubsts for the common case of no quadrigraphs. Cache +# results, as configure scripts tend to ask about lengths of common +# strings like `/*' and `*/' rather frequently. Minimize the number +# of times that $1 occurs in m4_qlen, so there is less text to parse +# on a cache hit. +m4_define([m4_qlen], +[m4_ifdef([$0-$1], [_m4_defn([$0-]], [_$0(])[$1])]) +m4_define([_m4_qlen], +[m4_define([m4_qlen-$1], +m4_if(m4_index([$1], [@]), [-1], [m4_len([$1])], + [m4_len(m4_bpatsubst([[$1]], + [@\(\(<:\|:>\|S|\|%:\|\{:\|:\}\)\(@\)\|&t@\)], + [\3]))]))_m4_defn([m4_qlen-$1])]) + +# m4_copyright_condense(TEXT) +# --------------------------- +# Condense the copyright notice in TEXT to only display the final +# year, wrapping the results to fit in 80 columns. +m4_define([m4_copyright_condense], +[m4_text_wrap(m4_bpatsubst(m4_flatten([[$1]]), +[(C)[- ,0-9]*\([1-9][0-9][0-9][0-9]\)], [(C) \1]))]) + +## ----------------------- ## +## 13. Number processing. ## +## ----------------------- ## + +# m4_cmp(A, B) +# ------------ +# Compare two integer expressions. +# A < B -> -1 +# A = B -> 0 +# A > B -> 1 +m4_define([m4_cmp], +[m4_eval((([$1]) > ([$2])) - (([$1]) < ([$2])))]) + + +# m4_list_cmp(A, B) +# ----------------- +# +# Compare the two lists of integer expressions A and B. For instance: +# m4_list_cmp([1, 0], [1]) -> 0 +# m4_list_cmp([1, 0], [1, 0]) -> 0 +# m4_list_cmp([1, 2], [1, 0]) -> 1 +# m4_list_cmp([1, 2, 3], [1, 2]) -> 1 +# m4_list_cmp([1, 2, -3], [1, 2]) -> -1 +# m4_list_cmp([1, 0], [1, 2]) -> -1 +# m4_list_cmp([1], [1, 2]) -> -1 +# m4_define([xa], [oops])dnl +# m4_list_cmp([[0xa]], [5+5]) -> 0 +# +# Rather than face the overhead of m4_case, we use a helper function whose +# expansion includes the name of the macro to invoke on the tail, either +# m4_ignore or m4_unquote. This is particularly useful when comparing +# long lists, since less text is being expanded for deciding when to end +# recursion. The recursion is between a pair of macros that alternate +# which list is trimmed by one element; this is more efficient than +# calling m4_cdr on both lists from a single macro. Guarantee exactly +# one expansion of both lists' side effects. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_list_cmp], +[_$0_raw(m4_dquote($1), m4_dquote($2))]) + +m4_define([_m4_list_cmp_raw], +[m4_if([$1], [$2], [0], [_m4_list_cmp_1([$1], $2)])]) + +m4_define([_m4_list_cmp], +[m4_if([$1], [], [0m4_ignore], [$2], [0], [m4_unquote], [$2m4_ignore])]) + +m4_define([_m4_list_cmp_1], +[_m4_list_cmp_2([$2], [m4_shift2($@)], $1)]) + +m4_define([_m4_list_cmp_2], +[_m4_list_cmp([$1$3], m4_cmp([$3+0], [$1+0]))( + [_m4_list_cmp_1(m4_dquote(m4_shift3($@)), $2)])]) + +# m4_max(EXPR, ...) +# m4_min(EXPR, ...) +# ----------------- +# Return the decimal value of the maximum (or minimum) in a series of +# integer expressions. +# +# M4 1.4.x doesn't provide ?:. Hence this huge m4_eval. Avoid m4_eval +# if both arguments are identical, but be aware of m4_max(0xa, 10) (hence +# the use of <=, not just <, in the second multiply). +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_max], +[m4_if([$#], [0], [m4_fatal([too few arguments to $0])], + [$#], [1], [m4_eval([$1])], + [$#$1], [2$2], [m4_eval([$1])], + [$#], [2], [_$0($@)], + [_m4_minmax([_$0], $@)])]) + +m4_define([_m4_max], +[m4_eval((([$1]) > ([$2])) * ([$1]) + (([$1]) <= ([$2])) * ([$2]))]) + +m4_define([m4_min], +[m4_if([$#], [0], [m4_fatal([too few arguments to $0])], + [$#], [1], [m4_eval([$1])], + [$#$1], [2$2], [m4_eval([$1])], + [$#], [2], [_$0($@)], + [_m4_minmax([_$0], $@)])]) + +m4_define([_m4_min], +[m4_eval((([$1]) < ([$2])) * ([$1]) + (([$1]) >= ([$2])) * ([$2]))]) + +# _m4_minmax(METHOD, ARG1, ARG2...) +# --------------------------------- +# Common recursion code for m4_max and m4_min. METHOD must be _m4_max +# or _m4_min, and there must be at least two arguments to combine. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([_m4_minmax], +[m4_if([$#], [3], [$1([$2], [$3])], + [$0([$1], $1([$2], [$3]), m4_shift3($@))])]) + + +# m4_sign(A) +# ---------- +# The sign of the integer expression A. +m4_define([m4_sign], +[m4_eval((([$1]) > 0) - (([$1]) < 0))]) + + + +## ------------------------ ## +## 14. Version processing. ## +## ------------------------ ## + + +# m4_version_unletter(VERSION) +# ---------------------------- +# Normalize beta version numbers with letters to numeric expressions, which +# can then be handed to m4_eval for the purpose of comparison. +# +# Nl -> (N+1).-1.(l#) +# +# for example: +# [2.14a] -> [0,2,14+1,-1,[0r36:a]] -> 2.15.-1.10 +# [2.14b] -> [0,2,15+1,-1,[0r36:b]] -> 2.15.-1.11 +# [2.61aa.b] -> [0,2.61,1,-1,[0r36:aa],+1,-1,[0r36:b]] -> 2.62.-1.370.1.-1.11 +# [08] -> [0,[0r10:0]8] -> 8 +# +# This macro expects reasonable version numbers, but can handle double +# letters and does not expand any macros. Original version strings can +# use both `.' and `-' separators. +# +# Inline constant expansions, to avoid m4_defn overhead. +# _m4_version_unletter is the real workhorse used by m4_version_compare, +# but since [0r36:a] and commas are less readable than 10 and dots, we +# provide a wrapper for human use. +m4_define([m4_version_unletter], +[m4_substr(m4_map_args([.m4_eval], m4_unquote(_$0([$1]))), [3])]) +m4_define([_m4_version_unletter], +[m4_bpatsubst(m4_bpatsubst(m4_translit([[[[0,$1]]]], [.-], [,,]),]dnl +m4_dquote(m4_dquote(m4_defn([m4_cr_Letters])))[[+], + [+1,-1,[0r36:\&]]), [,0], [,[0r10:0]])]) + + +# m4_version_compare(VERSION-1, VERSION-2) +# ---------------------------------------- +# Compare the two version numbers and expand into +# -1 if VERSION-1 < VERSION-2 +# 0 if = +# 1 if > +# +# Since _m4_version_unletter does not output side effects, we can +# safely bypass the overhead of m4_version_cmp. +m4_define([m4_version_compare], +[_m4_list_cmp_raw(_m4_version_unletter([$1]), _m4_version_unletter([$2]))]) + + +# m4_PACKAGE_NAME +# m4_PACKAGE_TARNAME +# m4_PACKAGE_VERSION +# m4_PACKAGE_STRING +# m4_PACKAGE_BUGREPORT +# -------------------- +# If m4sugar/version.m4 is present, then define version strings. This +# file is optional, provided by Autoconf but absent in Bison. +m4_sinclude([m4sugar/version.m4]) + + +# m4_version_prereq(VERSION, [IF-OK], [IF-NOT = FAIL]) +# ---------------------------------------------------- +# Check this Autoconf version against VERSION. +m4_define([m4_version_prereq], +m4_ifdef([m4_PACKAGE_VERSION], +[[m4_if(m4_version_compare(]m4_dquote(m4_defn([m4_PACKAGE_VERSION]))[, [$1]), + [-1], + [m4_default([$3], + [m4_fatal([Autoconf version $1 or higher is required], + [63])])], + [$2])]], +[[m4_fatal([m4sugar/version.m4 not found])]])) + + +## ------------------ ## +## 15. Set handling. ## +## ------------------ ## + +# Autoconf likes to create arbitrarily large sets; for example, as of +# this writing, the configure.ac for coreutils tracks a set of more +# than 400 AC_SUBST. How do we track all of these set members, +# without introducing duplicates? We could use m4_append_uniq, with +# the set NAME residing in the contents of the macro NAME. +# Unfortunately, m4_append_uniq is quadratic for set creation, because +# it costs O(n) to search the string for each of O(n) insertions; not +# to mention that with m4 1.4.x, even using m4_append is slow, costing +# O(n) rather than O(1) per insertion. Other set operations, not used +# by Autoconf but still possible by manipulation of the definition +# tracked in macro NAME, include O(n) deletion of one element and O(n) +# computation of set size. Because the set is exposed to the user via +# the definition of a single macro, we cannot cache any data about the +# set without risking the cache being invalidated by the user +# redefining NAME. +# +# Can we do better? Yes, because m4 gives us an O(1) search function +# for free: ifdef. Additionally, even m4 1.4.x gives us an O(1) +# insert operation for free: pushdef. But to use these, we must +# represent the set via a group of macros; to keep the set consistent, +# we must hide the set so that the user can only manipulate it through +# accessor macros. The contents of the set are maintained through two +# access points; _m4_set([name]) is a pushdef stack of values in the +# set, useful for O(n) traversal of the set contents; while the +# existence of _m4_set([name],value) with no particular value is +# useful for O(1) querying of set membership. And since the user +# cannot externally manipulate the set, we are free to add additional +# caching macros for other performance improvements. Deletion can be +# O(1) per element rather than O(n), by reworking the definition of +# _m4_set([name],value) to be 0 or 1 based on current membership, and +# adding _m4_set_cleanup(name) to defer the O(n) cleanup of +# _m4_set([name]) until we have another reason to do an O(n) +# traversal. The existence of _m4_set_cleanup(name) can then be used +# elsewhere to determine if we must dereference _m4_set([name],value), +# or assume that definition implies set membership. Finally, size can +# be tracked in an O(1) fashion with _m4_set_size(name). +# +# The quoting in _m4_set([name],value) is chosen so that there is no +# ambiguity with a set whose name contains a comma, and so that we can +# supply the value via _m4_defn([_m4_set([name])]) without needing any +# quote manipulation. + +# m4_set_add(SET, VALUE, [IF-UNIQ], [IF-DUP]) +# ------------------------------------------- +# Add VALUE as an element of SET. Expand IF-UNIQ on the first +# addition, and IF-DUP if it is already in the set. Addition of one +# element is O(1), such that overall set creation is O(n). +# +# We do not want to add a duplicate for a previously deleted but +# unpruned element, but it is just as easy to check existence directly +# as it is to query _m4_set_cleanup($1). +m4_define([m4_set_add], +[m4_ifdef([_m4_set([$1],$2)], + [m4_if(m4_indir([_m4_set([$1],$2)]), [0], + [m4_define([_m4_set([$1],$2)], + [1])_m4_set_size([$1], [m4_incr])$3], [$4])], + [m4_define([_m4_set([$1],$2)], + [1])m4_pushdef([_m4_set([$1])], + [$2])_m4_set_size([$1], [m4_incr])$3])]) + +# m4_set_add_all(SET, VALUE...) +# ----------------------------- +# Add each VALUE into SET. This is O(n) in the number of VALUEs, and +# can be faster than calling m4_set_add for each VALUE. +# +# Implement two recursion helpers; the check variant is slower but +# handles the case where an element has previously been removed but +# not pruned. The recursion helpers ignore their second argument, so +# that we can use the faster m4_shift2 and 2 arguments, rather than +# _m4_shift2 and one argument, as the signal to end recursion. +# +# Please keep foreach.m4 in sync with any adjustments made here. +m4_define([m4_set_add_all], +[m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1]) + + m4_len(m4_ifdef([_m4_set_cleanup($1)], [_$0_check], [_$0])([$1], $@))))]) + +m4_define([_m4_set_add_all], +[m4_if([$#], [2], [], + [m4_ifdef([_m4_set([$1],$3)], [], + [m4_define([_m4_set([$1],$3)], [1])m4_pushdef([_m4_set([$1])], + [$3])-])$0([$1], m4_shift2($@))])]) + +m4_define([_m4_set_add_all_check], +[m4_if([$#], [2], [], + [m4_set_add([$1], [$3])$0([$1], m4_shift2($@))])]) + +# m4_set_contains(SET, VALUE, [IF-PRESENT], [IF-ABSENT]) +# ------------------------------------------------------ +# Expand IF-PRESENT if SET contains VALUE, otherwise expand IF-ABSENT. +# This is always O(1). +m4_define([m4_set_contains], +[m4_ifdef([_m4_set_cleanup($1)], + [m4_if(m4_ifdef([_m4_set([$1],$2)], + [m4_indir([_m4_set([$1],$2)])], [0]), [1], [$3], [$4])], + [m4_ifdef([_m4_set([$1],$2)], [$3], [$4])])]) + +# m4_set_contents(SET, [SEP]) +# --------------------------- +# Expand to a single string containing all the elements in SET, +# separated by SEP, without modifying SET. No provision is made for +# disambiguating set elements that contain non-empty SEP as a +# sub-string, or for recognizing a set that contains only the empty +# string. Order of the output is not guaranteed. If any elements +# have been previously removed from the set, this action will prune +# the unused memory. This is O(n) in the size of the set before +# pruning. +# +# Use _m4_popdef for speed. The existence of _m4_set_cleanup($1) +# determines which version of _1 helper we use. +m4_define([m4_set_contents], +[m4_set_map_sep([$1], [], [], [[$2]])]) + +# _m4_set_contents_1(SET) +# _m4_set_contents_1c(SET) +# _m4_set_contents_2(SET, [PRE], [POST], [SEP]) +# --------------------------------------------- +# Expand to a list of quoted elements currently in the set, each +# surrounded by PRE and POST, and moving SEP in front of PRE on +# recursion. To avoid nesting limit restrictions, the algorithm must +# be broken into two parts; _1 destructively copies the stack in +# reverse into _m4_set_($1), producing no output; then _2 +# destructively copies _m4_set_($1) back into the stack in reverse. +# If no elements were deleted, then this visits the set in the order +# that elements were inserted. Behavior is undefined if PRE/POST/SEP +# tries to recursively list or modify SET in any way other than +# calling m4_set_remove on the current element. Use _1 if all entries +# in the stack are guaranteed to be in the set, and _1c to prune +# removed entries. Uses _m4_defn and _m4_popdef for speed. +m4_define([_m4_set_contents_1], +[_m4_stack_reverse([_m4_set([$1])], [_m4_set_($1)])]) + +m4_define([_m4_set_contents_1c], +[m4_ifdef([_m4_set([$1])], + [m4_set_contains([$1], _m4_defn([_m4_set([$1])]), + [m4_pushdef([_m4_set_($1)], _m4_defn([_m4_set([$1])]))], + [_m4_popdef([_m4_set([$1],]_m4_defn( + [_m4_set([$1])])[)])])_m4_popdef([_m4_set([$1])])$0([$1])], + [_m4_popdef([_m4_set_cleanup($1)])])]) + +m4_define([_m4_set_contents_2], +[_m4_stack_reverse([_m4_set_($1)], [_m4_set([$1])], + [$2[]_m4_defn([_m4_set_($1)])$3], [$4[]])]) + +# m4_set_delete(SET) +# ------------------ +# Delete all elements in SET, and reclaim any memory occupied by the +# set. This is O(n) in the set size. +# +# Use _m4_defn and _m4_popdef for speed. +m4_define([m4_set_delete], +[m4_ifdef([_m4_set([$1])], + [_m4_popdef([_m4_set([$1],]_m4_defn([_m4_set([$1])])[)], + [_m4_set([$1])])$0([$1])], + [m4_ifdef([_m4_set_cleanup($1)], + [_m4_popdef([_m4_set_cleanup($1)])])m4_ifdef( + [_m4_set_size($1)], + [_m4_popdef([_m4_set_size($1)])])])]) + +# m4_set_difference(SET1, SET2) +# ----------------------------- +# Produce a LIST of quoted elements that occur in SET1 but not SET2. +# Output a comma prior to any elements, to distinguish the empty +# string from no elements. This can be directly used as a series of +# arguments, such as for m4_join, or wrapped inside quotes for use in +# m4_foreach. Order of the output is not guaranteed. +# +# Short-circuit the idempotence relation. +m4_define([m4_set_difference], +[m4_if([$1], [$2], [], [m4_set_map_sep([$1], [_$0([$2],], [)])])]) + +m4_define([_m4_set_difference], +[m4_set_contains([$1], [$2], [], [,[$2]])]) + +# m4_set_dump(SET, [SEP]) +# ----------------------- +# Expand to a single string containing all the elements in SET, +# separated by SEP, then delete SET. In general, if you only need to +# list the contents once, this is faster than m4_set_contents. No +# provision is made for disambiguating set elements that contain +# non-empty SEP as a sub-string. Order of the output is not +# guaranteed. This is O(n) in the size of the set before pruning. +# +# Use _m4_popdef for speed. Use existence of _m4_set_cleanup($1) to +# decide if more expensive recursion is needed. +m4_define([m4_set_dump], +[m4_ifdef([_m4_set_size($1)], + [_m4_popdef([_m4_set_size($1)])])m4_ifdef([_m4_set_cleanup($1)], + [_$0_check], [_$0])([$1], [], [$2])]) + +# _m4_set_dump(SET, [SEP], [PREP]) +# _m4_set_dump_check(SET, [SEP], [PREP]) +# -------------------------------------- +# Print SEP and the current element, then delete the element and +# recurse with empty SEP changed to PREP. The check variant checks +# whether the element has been previously removed. Use _m4_defn and +# _m4_popdef for speed. +m4_define([_m4_set_dump], +[m4_ifdef([_m4_set([$1])], + [[$2]_m4_defn([_m4_set([$1])])_m4_popdef([_m4_set([$1],]_m4_defn( + [_m4_set([$1])])[)], [_m4_set([$1])])$0([$1], [$2$3])])]) + +m4_define([_m4_set_dump_check], +[m4_ifdef([_m4_set([$1])], + [m4_set_contains([$1], _m4_defn([_m4_set([$1])]), + [[$2]_m4_defn([_m4_set([$1])])])_m4_popdef( + [_m4_set([$1],]_m4_defn([_m4_set([$1])])[)], + [_m4_set([$1])])$0([$1], [$2$3])], + [_m4_popdef([_m4_set_cleanup($1)])])]) + +# m4_set_empty(SET, [IF-EMPTY], [IF-ELEMENTS]) +# -------------------------------------------- +# Expand IF-EMPTY if SET has no elements, otherwise IF-ELEMENTS. +m4_define([m4_set_empty], +[m4_ifdef([_m4_set_size($1)], + [m4_if(m4_indir([_m4_set_size($1)]), [0], [$2], [$3])], [$2])]) + +# m4_set_foreach(SET, VAR, ACTION) +# -------------------------------- +# For each element of SET, define VAR to the element and expand +# ACTION. ACTION should not recursively list SET's contents, add +# elements to SET, nor delete any element from SET except the one +# currently in VAR. The order that the elements are visited in is not +# guaranteed. This is faster than the corresponding m4_foreach([VAR], +# m4_indir([m4_dquote]m4_set_listc([SET])), [ACTION]) +m4_define([m4_set_foreach], +[m4_pushdef([$2])m4_set_map_sep([$1], [m4_define([$2],], [)$3])]) + +# m4_set_intersection(SET1, SET2) +# ------------------------------- +# Produce a LIST of quoted elements that occur in both SET1 or SET2. +# Output a comma prior to any elements, to distinguish the empty +# string from no elements. This can be directly used as a series of +# arguments, such as for m4_join, or wrapped inside quotes for use in +# m4_foreach. Order of the output is not guaranteed. +# +# Iterate over the smaller set, and short-circuit the idempotence +# relation. +m4_define([m4_set_intersection], +[m4_if([$1], [$2], [m4_set_listc([$1])], + m4_eval(m4_set_size([$2]) < m4_set_size([$1])), [1], [$0([$2], [$1])], + [m4_set_map_sep([$1], [_$0([$2],], [)])])]) + +m4_define([_m4_set_intersection], +[m4_set_contains([$1], [$2], [,[$2]])]) + +# m4_set_list(SET) +# m4_set_listc(SET) +# ----------------- +# Produce a LIST of quoted elements of SET. This can be directly used +# as a series of arguments, such as for m4_join or m4_set_add_all, or +# wrapped inside quotes for use in m4_foreach or m4_map. With +# m4_set_list, there is no way to distinguish an empty set from a set +# containing only the empty string; with m4_set_listc, a leading comma +# is output if there are any elements. +m4_define([m4_set_list], +[m4_set_map_sep([$1], [], [], [,])]) + +m4_define([m4_set_listc], +[m4_set_map_sep([$1], [,])]) + +# m4_set_map(SET, ACTION) +# ----------------------- +# For each element of SET, expand ACTION with a single argument of the +# current element. ACTION should not recursively list SET's contents, +# add elements to SET, nor delete any element from SET except the one +# passed as an argument. The order that the elements are visited in +# is not guaranteed. This is faster than either of the corresponding +# m4_map_args([ACTION]m4_set_listc([SET])) +# m4_set_foreach([SET], [VAR], [ACTION(m4_defn([VAR]))]) +m4_define([m4_set_map], +[m4_set_map_sep([$1], [$2(], [)])]) + +# m4_set_map_sep(SET, [PRE], [POST], [SEP]) +# ----------------------------------------- +# For each element of SET, expand PRE[value]POST[], and expand SEP +# between elements. +m4_define([m4_set_map_sep], +[m4_ifdef([_m4_set_cleanup($1)], [_m4_set_contents_1c], + [_m4_set_contents_1])([$1])_m4_set_contents_2($@)]) + +# m4_set_remove(SET, VALUE, [IF-PRESENT], [IF-ABSENT]) +# ---------------------------------------------------- +# If VALUE is an element of SET, delete it and expand IF-PRESENT. +# Otherwise expand IF-ABSENT. Deleting a single value is O(1), +# although it leaves memory occupied until the next O(n) traversal of +# the set which will compact the set. +# +# Optimize if the element being removed is the most recently added, +# since defining _m4_set_cleanup($1) slows down so many other macros. +# In particular, this plays well with m4_set_foreach and m4_set_map. +m4_define([m4_set_remove], +[m4_set_contains([$1], [$2], [_m4_set_size([$1], + [m4_decr])m4_if(_m4_defn([_m4_set([$1])]), [$2], + [_m4_popdef([_m4_set([$1],$2)], [_m4_set([$1])])], + [m4_define([_m4_set_cleanup($1)])m4_define( + [_m4_set([$1],$2)], [0])])$3], [$4])]) + +# m4_set_size(SET) +# ---------------- +# Expand to the number of elements currently in SET. This operation +# is O(1), and thus more efficient than m4_count(m4_set_list([SET])). +m4_define([m4_set_size], +[m4_ifdef([_m4_set_size($1)], [m4_indir([_m4_set_size($1)])], [0])]) + +# _m4_set_size(SET, ACTION) +# ------------------------- +# ACTION must be either m4_incr or m4_decr, and the size of SET is +# changed accordingly. If the set is empty, ACTION must not be +# m4_decr. +m4_define([_m4_set_size], +[m4_define([_m4_set_size($1)], + m4_ifdef([_m4_set_size($1)], [$2(m4_indir([_m4_set_size($1)]))], + [1]))]) + +# m4_set_union(SET1, SET2) +# ------------------------ +# Produce a LIST of double quoted elements that occur in either SET1 +# or SET2, without duplicates. Output a comma prior to any elements, +# to distinguish the empty string from no elements. This can be +# directly used as a series of arguments, such as for m4_join, or +# wrapped inside quotes for use in m4_foreach. Order of the output is +# not guaranteed. +# +# We can rely on the fact that m4_set_listc prunes SET1, so we don't +# need to check _m4_set([$1],element) for 0. Short-circuit the +# idempotence relation. +m4_define([m4_set_union], +[m4_set_listc([$1])m4_if([$1], [$2], [], + [m4_set_map_sep([$2], [_$0([$1],], [)])])]) + +m4_define([_m4_set_union], +[m4_ifdef([_m4_set([$1],$2)], [], [,[$2]])]) + + +## ------------------- ## +## 16. File handling. ## +## ------------------- ## + + +# It is a real pity that M4 comes with no macros to bind a diversion +# to a file. So we have to deal without, which makes us a lot more +# fragile than we should. + + +# m4_file_append(FILE-NAME, CONTENT) +# ---------------------------------- +m4_define([m4_file_append], +[m4_syscmd([cat >>$1 <<_m4eof +$2 +_m4eof +]) +m4_if(m4_sysval, [0], [], + [m4_fatal([$0: cannot write: $1])])]) + + + +## ------------------------ ## +## 17. Setting M4sugar up. ## +## ------------------------ ## + +# _m4_divert_diversion should be defined. +m4_divert_push([KILL]) + +# m4_init +# ------- +# Initialize the m4sugar language. +m4_define([m4_init], +[# All the M4sugar macros start with `m4_', except `dnl' kept as is +# for sake of simplicity. +m4_pattern_forbid([^_?m4_]) +m4_pattern_forbid([^dnl$]) + +# If __m4_version__ is defined, we assume that we are being run by M4 +# 1.6 or newer, thus $@ recursion is linear, and debugmode(+do) +# is available for faster checks of dereferencing undefined macros +# and forcing dumpdef to print to stderr regardless of debugfile. +# But if it is missing, we assume we are being run by M4 1.4.x, that +# $@ recursion is quadratic, and that we need foreach-based +# replacement macros. Also, m4 prior to 1.4.8 loses track of location +# during m4wrap text; __line__ should never be 0. +# +# Use the raw builtin to avoid tripping up include tracing. +# Meanwhile, avoid m4_copy, since it temporarily undefines m4_defn. +m4_ifdef([__m4_version__], +[m4_debugmode([+do]) +m4_define([m4_defn], _m4_defn([_m4_defn])) +m4_define([m4_dumpdef], _m4_defn([_m4_dumpdef])) +m4_define([m4_popdef], _m4_defn([_m4_popdef])) +m4_define([m4_undefine], _m4_defn([_m4_undefine]))], +[m4_builtin([include], [m4sugar/foreach.m4]) +m4_wrap_lifo([m4_if(__line__, [0], [m4_pushdef([m4_location], +]]m4_dquote(m4_dquote(m4_dquote(__file__:__line__)))[[)])])]) + +# Rewrite the first entry of the diversion stack. +m4_divert([KILL]) + +# Check the divert push/pop perfect balance. +# Some users are prone to also use m4_wrap to register last-minute +# m4_divert_text; so after our diversion cleanups, we restore +# KILL as the bottom of the diversion stack. +m4_wrap([m4_popdef([_m4_divert_diversion])m4_ifdef( + [_m4_divert_diversion], [m4_fatal([$0: unbalanced m4_divert_push: +]m4_divert_stack)])_m4_popdef([_m4_divert_stack])m4_divert_push([KILL])]) +]) diff --git a/src/data/stack.hh b/src/data/stack.hh new file mode 100644 index 0000000..ab1049c --- /dev/null +++ b/src/data/stack.hh @@ -0,0 +1,121 @@ +# C++ skeleton for Bison + +# Copyright (C) 2002-2012 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-2012]) + +b4_output_begin([b4_dir_prefix[]stack.hh]) +b4_copyright([Stack handling for Bison parsers in C++], + [2002-2012])[ + +/** + ** \file ]b4_dir_prefix[stack.hh + ** Define the ]b4_namespace_ref[::stack class. + */ + +]b4_cpp_guard_open([b4_dir_prefix[]stack.hh])[ + +# include + +]b4_namespace_open[ + template > + class stack + { + public: + // Hide our reversed order. + typedef typename S::reverse_iterator iterator; + typedef typename S::const_reverse_iterator const_iterator; + + stack () : seq_ () + { + } + + stack (unsigned int n) : seq_ (n) + { + } + + inline + T& + operator [] (unsigned int i) + { + return seq_[i]; + } + + inline + const T& + operator [] (unsigned int i) const + { + return seq_[i]; + } + + inline + void + push (const T& t) + { + seq_.push_front (t); + } + + inline + void + pop (unsigned int n = 1) + { + for (; n; --n) + seq_.pop_front (); + } + + inline + unsigned int + height () const + { + return seq_.size (); + } + + inline const_iterator begin () const { return seq_.rbegin (); } + inline const_iterator end () const { return seq_.rend (); } + + private: + S seq_; + }; + + /// Present a slice of the top of a stack. + template > + class slice + { + public: + slice (const S& stack, unsigned int range) + : stack_ (stack) + , range_ (range) + { + } + + inline + const T& + operator [] (unsigned int i) const + { + return stack_[range_ - i]; + } + + private: + const S& stack_; + unsigned int range_; + }; +]b4_namespace_close[ + +]b4_cpp_guard_close([b4_dir_prefix[]stack.hh]) +b4_output_end() + +m4_popdef([b4_copyright_years]) diff --git a/src/data/xslt/bison.xsl b/src/data/xslt/bison.xsl new file mode 100644 index 0000000..40575ef --- /dev/null +++ b/src/data/xslt/bison.xsl @@ -0,0 +1,105 @@ + + + + + + + + + + + + + + + + + + + + + + + + + s + + + r + + + + + + , + + + + + 0 + + + + + + + + + + + diff --git a/src/data/xslt/xml2dot.xsl b/src/data/xslt/xml2dot.xsl new file mode 100644 index 0000000..dceb8e1 --- /dev/null +++ b/src/data/xslt/xml2dot.xsl @@ -0,0 +1,397 @@ + + + + + + + + + + + + + + + // Generated by GNU Bison + + . + // Report bugs to < + + >. + // Home page: < + + >. + + + + + + + + digraph " + + + + " { + node [fontname = courier, shape = box, colorscheme = paired6] + edge [fontname = courier] + + + + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + label="[ + + + + + + , + + + ]", + + + + style=solid] + + + + + + + + + 3 + + + 5 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + : + + + + . + + + + + . + + + + + + + + + + + + + [ + + ] + + + + + + , + + + + + + + + + + + -> " + + R + + + d + + " [ + + + + + + + + " + + R + + + d + + " [label=" + + + Acc", fillcolor=1 + + + R + + ", fillcolor= + + + + , shape=diamond, style=filled] + + + + + + + + + + dotted + + + solid + + + dashed + + + + + + + + + + + + + + + + + [label=" + State + + \n + + + + \l"] + + + + + + + + + + -> + + [style= + + + label=" + + + + " + + ] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/data/xslt/xml2text.xsl b/src/data/xslt/xml2text.xsl new file mode 100644 index 0000000..8b3f5ae --- /dev/null +++ b/src/data/xslt/xml2text.xsl @@ -0,0 +1,569 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Nonterminals useless in grammar + + + + + + + + + + + + Terminals unused in grammar + + + + + + + + + + + + + + Rules useless in grammar + + + + + + + + + + + Rules useless in parser due to conflicts + + + + + + + + + Grammar + + + + + + + + + + + + + + + + + + + + + + + + + Terminals, with rules where they appear + + + + + + Nonterminals, with rules where they appear + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + on@left: + + + + + + + , + + on@right: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + State + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + : + + + + + + + . + + + + + + + + + . + + + + + + + + + + + + + + + + /* empty */ + + + + [ + + ] + + + + + + , + + + + + + + + + + + + + shift, and go to state + + + + go to state + + + + + + + + + + + + + + error + ( + + ) + + + + + + + + + + + + [ + + + + accept + + + reduce using rule + + ( + + ) + + + + ] + + + + + + + + + + + + + Conflict between rule + + and token + + resolved as + + an + + + ( + + ). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/data/xslt/xml2xhtml.xsl b/src/data/xslt/xml2xhtml.xsl new file mode 100644 index 0000000..f8126cf --- /dev/null +++ b/src/data/xslt/xml2xhtml.xsl @@ -0,0 +1,745 @@ + + + + + + + + + + + + + + + <xsl:value-of select="bison-xml-report/filename"/> + <xsl:text> - GNU Bison XML Automaton Report</xsl:text> + + + + + + + + + + + + +

GNU Bison XML Automaton Report

+

+ input grammar: +

+ + +

Table of Contents

+ + + + + + + + + +

+ + Reductions +

+ + + + + + +

+ + Nonterminals useless in grammar +

+ + +

+ + + + + + +

+ + + + +

+ + Terminals unused in grammar +

+ + +

+ + + + + + + +

+ + + + +

+ + Rules useless in grammar +

+ + + +

+ + + + +

+ + + + + + +

+ + Rules useless in parser due to conflicts +

+ +

+ + + +

+ + + + + +

+ + Grammar +

+ +

+ + + +

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

+ + Conflicts +

+ + + + + +

+ + +

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

+ + Terminals, with rules where they appear +

+ +

+ +

+ + + + +

+ + Nonterminals, with rules where they appear +

+ +

+ +

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

+ + Automaton +

+ + + + + + + + +

+ + + + + + state + +

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + → + + + + + + + + . + + + + + + + + + + . + + + + + + + + + + + + + + + + + + + + + + + ε + + + + [ + + ] + + + + + + , + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + error + ( + + ) + + + + + + + + + + + + [ + + + + accept + + + + + + + + + ( + + ) + + + + ] + + + + + + + + + + + + + Conflict between + + + + + + + and token + + resolved as + + an + + + ( + + ). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + diff --git a/src/data/yacc.c b/src/data/yacc.c new file mode 100644 index 0000000..b34549f --- /dev/null +++ b/src/data/yacc.c @@ -0,0 +1,2065 @@ + -*- C -*- + +# Yacc compatible skeleton for Bison + +# Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, +# Inc. + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# Check the value of %define api.push-pull. +b4_percent_define_default([[api.push-pull]], [[pull]]) +b4_percent_define_check_values([[[[api.push-pull]], + [[pull]], [[push]], [[both]]]]) +b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]]) +b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]]) +m4_case(b4_percent_define_get([[api.push-pull]]), + [pull], [m4_define([b4_push_flag], [[0]])], + [push], [m4_define([b4_pull_flag], [[0]])]) + +# Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing +# tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the +# behavior of Bison at all when push parsing is already requested. +b4_define_flag_if([use_push_for_pull]) +b4_use_push_for_pull_if([ + b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])], + [m4_define([b4_push_flag], [[1]])])]) + +# Check the value of %define parse.lac and friends, where LAC stands for +# lookahead correction. +b4_percent_define_default([[parse.lac]], [[none]]) +b4_percent_define_default([[parse.lac.es-capacity-initial]], [[20]]) +b4_percent_define_default([[parse.lac.memory-trace]], [[failures]]) +b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]], + [[[[parse.lac.memory-trace]], + [[failures]], [[full]]]]) +b4_define_flag_if([lac]) +m4_define([b4_lac_flag], + [m4_if(b4_percent_define_get([[parse.lac]]), + [none], [[0]], [[1]])]) + +m4_include(b4_pkgdatadir/[c.m4]) + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Stack parameters. +m4_define_default([b4_stack_depth_max], [10000]) +m4_define_default([b4_stack_depth_init], [200]) + + +## ------------------------ ## +## Pure/impure interfaces. ## +## ------------------------ ## + +b4_percent_define_default([[api.pure]], [[false]]) +b4_percent_define_check_values([[[[api.pure]], + [[false]], [[true]], [[]], [[full]]]]) + +m4_define([b4_pure_flag], [[0]]) +m4_case(b4_percent_define_get([[api.pure]]), + [false], [m4_define([b4_pure_flag], [[0]])], + [true], [m4_define([b4_pure_flag], [[1]])], + [], [m4_define([b4_pure_flag], [[1]])], + [full], [m4_define([b4_pure_flag], [[2]])]) + +m4_define([b4_pure_if], +[m4_case(b4_pure_flag, + [0], [$2], + [1], [$1], + [2], [$1])]) + [m4_fatal([invalid api.pure value: ]$1)])]) + +# b4_yyerror_arg_loc_if(ARG) +# -------------------------- +# Expand ARG iff yyerror is to be given a location as argument. +m4_define([b4_yyerror_arg_loc_if], +[b4_locations_if([m4_case(b4_pure_flag, + [1], [m4_ifset([b4_parse_param], [$1])], + [2], [$1])])]) + +# b4_yyerror_args +# --------------- +# Arguments passed to yyerror: user args plus yylloc. +m4_define([b4_yyerror_args], +[b4_yyerror_arg_loc_if([&yylloc, ])dnl +m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) + + +# b4_lex_param +# ------------ +# Accumulate in b4_lex_param all the yylex arguments. +# b4_lex_param arrives quoted twice, but we want to keep only one level. +m4_define([b4_lex_param], +m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl +b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl +m4_ifdef([b4_lex_param], b4_lex_param))) + + +## ------------ ## +## Data Types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# Return the smallest int type able to handle numbers ranging from +# MIN to MAX (included). Overwrite the version from c.m4, which +# uses only C89 types, so that the user can override the shorter +# types, and so that pre-C89 compilers are handled correctly. +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [0], [255]), [1], [yytype_uint8], + b4_ints_in($@, [-128], [127]), [1], [yytype_int8], + + b4_ints_in($@, [0], [65535]), [1], [yytype_uint16], + b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16], + + m4_eval([0 <= $1]), [1], [unsigned int], + + [int])]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + +# b4_lhs_value([TYPE]) +# -------------------- +# Expansion of $$. +m4_define([b4_lhs_value], +[(yyval[]m4_ifval([$1], [.$1]))]) + + +# b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) +# -------------------------------------- +# Expansion of $NUM, where the current rule has RULE-LENGTH +# symbols on RHS. +m4_define([b4_rhs_value], +[(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))]) + + + +## ----------- ## +## Locations. ## +## ----------- ## + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[(yyloc)]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[(yylsp@{($2) - ($1)@})]) + + +## -------------- ## +## Declarations. ## +## -------------- ## + +# b4_declare_scanner_communication_variables +# ------------------------------------------ +# Declare the variables that are global, or local to YYPARSE if +# pure-parser. +m4_define([b4_declare_scanner_communication_variables], [[ +/* The lookahead symbol. */ +int yychar; + +]b4_pure_if([[ +#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") +#else +/* Default value used for initialization, for pacifying older GCCs + or non-GCC compilers. */ +static YYSTYPE yyval_default; +# define YY_INITIAL_VALUE(Value) = Value +#endif]b4_locations_if([[ +static YYLTYPE yyloc_default][]b4_yyloc_default[;]])])[ +#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 + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);]b4_locations_if([[ + +/* Location data for the lookahead symbol. */ +YYLTYPE yylloc]b4_pure_if([ = yyloc_default], [b4_yyloc_default])[; +]])b4_pure_if([], [[ + +/* Number of syntax errors so far. */ +int yynerrs;]])]) + + +# b4_declare_parser_state_variables +# --------------------------------- +# Declare all the variables that are needed to maintain the parser state +# between calls to yypush_parse. +m4_define([b4_declare_parser_state_variables], [b4_pure_if([[ + /* Number of syntax errors so far. */ + int yynerrs; +]])[ + int yystate; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + + /* The stacks and their tools: + `yyss': related to states. + `yyvs': related to semantic values.]b4_locations_if([[ + `yyls': related to locations.]])[ + + Refer to the stacks through separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs; + YYSTYPE *yyvsp;]b4_locations_if([[ + + /* The location stack. */ + YYLTYPE yylsa[YYINITDEPTH]; + YYLTYPE *yyls; + YYLTYPE *yylsp; + + /* The locations where the error started and ended. */ + YYLTYPE yyerror_range[3];]])[ + + YYSIZE_T yystacksize;]b4_lac_if([[ + + yytype_int16 yyesa@{]b4_percent_define_get([[parse.lac.es-capacity-initial]])[@}; + yytype_int16 *yyes; + YYSIZE_T yyes_capacity;]])]) + + +# b4_declare_yyparse_push_ +# ------------------------ +# Declaration of yyparse (and dependencies) when using the push parser +# (including in pull mode). +m4_define([b4_declare_yyparse_push_], +[[#ifndef YYPUSH_MORE_DEFINED +# define YYPUSH_MORE_DEFINED +enum { YYPUSH_MORE = 4 }; +#endif + +typedef struct ]b4_prefix[pstate ]b4_prefix[pstate; + +]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param) +])b4_c_function_decl([b4_prefix[push_parse]], [[int]], + [[b4_prefix[pstate *ps]], [[ps]]]b4_pure_if([, + [[[int pushed_char]], [[pushed_char]]], + [[b4_api_PREFIX[STYPE const *pushed_val]], [[pushed_val]]]b4_locations_if([, + [[b4_api_PREFIX[LTYPE *pushed_loc]], [[pushed_loc]]]])])m4_ifset([b4_parse_param], [, + b4_parse_param])) +b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]], + [[b4_prefix[pstate *ps]], [[ps]]]m4_ifset([b4_parse_param], [, + b4_parse_param]))]) +b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]], + [[[void]], []]) +b4_c_function_decl([b4_prefix[pstate_delete]], [[void]], + [[b4_prefix[pstate *ps]], [[ps]]])dnl +]) + +# b4_declare_yyparse_ +# ------------------- +# When not the push parser. +m4_define([b4_declare_yyparse_], +[[#ifdef YYPARSE_PARAM +]b4_c_function_decl(b4_prefix[parse], [int], + [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[ +#else /* ! YYPARSE_PARAM */ +]b4_c_function_decl(b4_prefix[parse], [int], b4_parse_param)[ +#endif /* ! YYPARSE_PARAM */]dnl +]) + + +# b4_declare_yyparse +# ------------------ +m4_define([b4_declare_yyparse], +[b4_push_if([b4_declare_yyparse_push_], + [b4_declare_yyparse_])[]dnl +]) + + +# b4_shared_declarations +# ---------------------- +# Declaration that might either go into the header (if --defines) +# or open coded in the parser body. +m4_define([b4_shared_declarations], +[b4_cpp_guard_open([b4_spec_defines_file])[ +]b4_declare_yydebug[ +]b4_percent_code_get([[requires]])[ +]b4_token_enums_defines(b4_tokens)[ +]b4_declare_yylstype[ +]b4_declare_yyparse[ +]b4_percent_code_get([[provides]])[ +]b4_cpp_guard_close([b4_spec_defines_file])[]dnl +]) + + +## -------------- ## +## Output files. ## +## -------------- ## + +b4_output_begin([b4_parser_file_name]) +b4_copyright([Bison implementation for Yacc-like parsers in C], + [1984, 1989-1990, 2000-2012])[ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +]b4_identification +b4_percent_code_get([[top]])[]dnl +m4_if(b4_api_prefix, [yy], [], +[[/* Substitute the type names. */ +#define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[ +#define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[ +]m4_if(b4_prefix, [yy], [], +[[/* Substitute the variable and function names. */]b4_pull_if([[ +#define yyparse ]b4_prefix[parse]])b4_push_if([[ +#define yypush_parse ]b4_prefix[push_parse]b4_pull_if([[ +#define yypull_parse ]b4_prefix[pull_parse]])[ +#define yypstate_new ]b4_prefix[pstate_new +#define yypstate_delete ]b4_prefix[pstate_delete +#define yypstate ]b4_prefix[pstate]])[ +#define yylex ]b4_prefix[lex +#define yyerror ]b4_prefix[error +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char +#define yydebug ]b4_prefix[debug +#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])])[ + +/* Copy the first part of user declarations. */ +]b4_user_pre_prologue[ + +]b4_null_define[ + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE ]b4_error_verbose_flag[ +#endif + +]m4_ifval(m4_quote(b4_spec_defines_file), +[[/* In a future release of Bison, this section will be replaced + by #include "@basename(]b4_spec_defines_file[@)". */ +]])dnl +b4_shared_declarations[ + +/* Copy the second part of user declarations. */ +]b4_user_post_prologue +b4_percent_code_get[]dnl + +[#ifdef short +# undef short +#endif + +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#elif ]b4_c_modern[ +typedef signed char yytype_int8; +#else +typedef short int yytype_int8; +#endif + +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; +#else +typedef unsigned short int yytype_uint16; +#endif + +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif ! defined YYSIZE_T && ]b4_c_modern[ +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned int +# endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + +#ifndef YY_ +# if 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 + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(E) ((void) (E)) +#else +# define YYUSE(E) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +# define YYID(N) (N) +#else +]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[ +{ + return yyi; +} +#endif + +#if ]b4_lac_if([[1]], [[! defined yyoverflow || YYERROR_VERBOSE]])[ + +/* The parser invokes alloca or malloc; define the necessary symbols. */]dnl +b4_push_if([], [b4_lac_if([], [[ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && ]b4_c_modern[ +# 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 (YYID (0)) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined 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 && ]b4_c_modern[ +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS && ]b4_c_modern[ +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif]b4_lac_if([[ +# define YYCOPY_NEEDED 1]])[ +#endif]b4_lac_if([], [[ /* ! defined yyoverflow || YYERROR_VERBOSE */]])[ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (]b4_locations_if([[defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL \ + && ]])[defined ]b4_api_PREFIX[STYPE_IS_TRIVIAL && ]b4_api_PREFIX[STYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss_alloc; + YYSTYPE yyvs_alloc;]b4_locations_if([ + YYLTYPE yyls_alloc;])[ +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +]b4_locations_if( +[# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + + 2 * YYSTACK_GAP_MAXIMUM)], +[# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM)])[ + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (YYID (0)) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from SRC to DST. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(Dst, Src, Count) \ + __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) +# else +# define YYCOPY(Dst, Src, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (Dst)[yyi] = (Src)[yyi]; \ + } \ + while (YYID (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[ +/* YYNRULES -- Number of states. */ +#define YYNSTATES ]b4_states_number[ + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK ]b4_undef_token_number[ +#define YYMAXUTOK ]b4_user_token_number_max[ + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const ]b4_int_type_for([b4_translate])[ yytranslate[] = +{ + ]b4_translate[ +}; + +#if ]b4_api_PREFIX[DEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = +{ + ]b4_prhs[ +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = +{ + ]b4_rhs[ +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const ]b4_int_type_for([b4_rline])[ yyrline[] = +{ + ]b4_rline[ +}; +#endif + +#if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[ +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + ]b4_tname[ +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = +{ + ]b4_toknum[ +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const ]b4_int_type_for([b4_r1])[ yyr1[] = +{ + ]b4_r1[ +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const ]b4_int_type_for([b4_r2])[ yyr2[] = +{ + ]b4_r2[ +}; + +/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const ]b4_int_type_for([b4_defact])[ yydefact[] = +{ + ]b4_defact[ +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = +{ + ]b4_defgoto[ +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF ]b4_pact_ninf[ +static const ]b4_int_type_for([b4_pact])[ yypact[] = +{ + ]b4_pact[ +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = +{ + ]b4_pgoto[ +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF ]b4_table_ninf[ +static const ]b4_int_type_for([b4_table])[ yytable[] = +{ + ]b4_table[ +}; + +#define yypact_value_is_default(Yystate) \ + ]b4_table_value_equals([[pact]], [[Yystate]], [b4_pact_ninf])[ + +#define yytable_value_is_error(Yytable_value) \ + ]b4_table_value_equals([[table]], [[Yytable_value]], [b4_table_ninf])[ + +static const ]b4_int_type_for([b4_check])[ yycheck[] = +{ + ]b4_check[ +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const ]b4_int_type_for([b4_stos])[ yystos[] = +{ + ]b4_stos[ +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. However, + YYFAIL appears to be in use. Nevertheless, it is formally deprecated + in Bison 2.4.2's NEWS entry, where a plan to phase it out is + discussed. */ + +#define YYFAIL goto yyerrlab +#if defined YYFAIL + /* This is here to suppress warnings from the GCC cpp's + -Wunused-macros. Normally we don't worry about that warning, but + some users do, and we want to make it easy for users to remove + YYFAIL uses, which will produce warnings from Bison 2.5. */ +#endif + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \]b4_lac_if([[ + YY_LAC_DISCARD ("YYBACKUP"); \]])[ + goto yybackup; \ + } \ + else \ + { \ + yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (YYID (0)) + +/* Error token number */ +#define YYTERROR 1 +#define YYERRCODE 256 + +]b4_locations_if([[ +]b4_yylloc_default_define[ +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +]])[ +]b4_yy_location_print_define[ + +/* YYLEX -- calling `yylex' with the right arguments. */ +#ifdef YYLEX_PARAM +# define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM) +#else +# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ +#endif + +/* Enable debugging if requested. */ +#if ]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 (YYID (0)) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value]b4_locations_if([, Location])[]b4_user_args[); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + +]b4_yy_symbol_print_generate([b4_c_function_def])[ + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +]b4_c_function_def([yy_stack_print], [static void], + [[yytype_int16 *yybottom], [yybottom]], + [[yytype_int16 *yytop], [yytop]])[ +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (YYID (0)) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +]b4_c_function_def([yy_reduce_print], [static void], + [[YYSTYPE *yyvsp], [yyvsp]], + b4_locations_if([[[YYLTYPE *yylsp], [yylsp]], + ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [, + b4_parse_param]))[ +{ + int yynrhs = yyr2[yyrule]; + int yyi; + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &]b4_rhs_value(yynrhs, yyi + 1)[ + ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl + b4_user_args[); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ +} while (YYID (0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !]b4_api_PREFIX[DEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !]b4_api_PREFIX[DEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH ]b4_stack_depth_init[ +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH ]b4_stack_depth_max[ +#endif]b4_lac_if([[ + +/* Given a state stack such that *YYBOTTOM is its bottom, such that + *YYTOP is either its top or is YYTOP_EMPTY to indicate an empty + stack, and such that *YYCAPACITY is the maximum number of elements it + can hold without a reallocation, make sure there is enough room to + store YYADD more elements. If not, allocate a new stack using + YYSTACK_ALLOC, copy the existing elements, and adjust *YYBOTTOM, + *YYTOP, and *YYCAPACITY to reflect the new capacity and memory + location. If *YYBOTTOM != YYBOTTOM_NO_FREE, then free the old stack + using YYSTACK_FREE. Return 0 if successful or if no reallocation is + required. Return 1 if memory is exhausted. */ +static int +yy_lac_stack_realloc (YYSIZE_T *yycapacity, YYSIZE_T yyadd, +#if ]b4_api_PREFIX[DEBUG + char const *yydebug_prefix, + char const *yydebug_suffix, +#endif + yytype_int16 **yybottom, + yytype_int16 *yybottom_no_free, + yytype_int16 **yytop, yytype_int16 *yytop_empty) +{ + YYSIZE_T yysize_old = + *yytop == yytop_empty ? 0 : *yytop - *yybottom + 1; + YYSIZE_T yysize_new = yysize_old + yyadd; + if (*yycapacity < yysize_new) + { + YYSIZE_T yyalloc = 2 * yysize_new; + yytype_int16 *yybottom_new; + /* Use YYMAXDEPTH for maximum stack size given that the stack + should never need to grow larger than the main state stack + needs to grow without LAC. */ + if (YYMAXDEPTH < yysize_new) + { + YYDPRINTF ((stderr, "%smax size exceeded%s", yydebug_prefix, + yydebug_suffix)); + return 1; + } + if (YYMAXDEPTH < yyalloc) + yyalloc = YYMAXDEPTH; + yybottom_new = + (yytype_int16*) YYSTACK_ALLOC (yyalloc * sizeof *yybottom_new); + if (!yybottom_new) + { + YYDPRINTF ((stderr, "%srealloc failed%s", yydebug_prefix, + yydebug_suffix)); + return 1; + } + if (*yytop != yytop_empty) + { + YYCOPY (yybottom_new, *yybottom, yysize_old); + *yytop = yybottom_new + (yysize_old - 1); + } + if (*yybottom != yybottom_no_free) + YYSTACK_FREE (*yybottom); + *yybottom = yybottom_new; + *yycapacity = yyalloc;]m4_if(b4_percent_define_get([[parse.lac.memory-trace]]), + [full], [[ + YYDPRINTF ((stderr, "%srealloc to %lu%s", yydebug_prefix, + (unsigned long int) yyalloc, yydebug_suffix));]])[ + } + return 0; +} + +/* Establish the initial context for the current lookahead if no initial + context is currently established. + + We define a context as a snapshot of the parser stacks. We define + the initial context for a lookahead as the context in which the + parser initially examines that lookahead in order to select a + syntactic action. Thus, if the lookahead eventually proves + syntactically unacceptable (possibly in a later context reached via a + series of reductions), the initial context can be used to determine + the exact set of tokens that would be syntactically acceptable in the + lookahead's place. Moreover, it is the context after which any + further semantic actions would be erroneous because they would be + determined by a syntactically unacceptable token. + + YY_LAC_ESTABLISH should be invoked when a reduction is about to be + performed in an inconsistent state (which, for the purposes of LAC, + includes consistent states that don't know they're consistent because + their default reductions have been disabled). Iff there is a + lookahead token, it should also be invoked before reporting a syntax + error. This latter case is for the sake of the debugging output. + + For parse.lac=full, the implementation of YY_LAC_ESTABLISH is as + follows. If no initial context is currently established for the + current lookahead, then check if that lookahead can eventually be + shifted if syntactic actions continue from the current context. + Report a syntax error if it cannot. */ +#define YY_LAC_ESTABLISH \ +do { \ + if (!yy_lac_established) \ + { \ + YYDPRINTF ((stderr, \ + "LAC: initial context established for %s\n", \ + yytname[yytoken])); \ + yy_lac_established = 1; \ + { \ + int yy_lac_status = \ + yy_lac (yyesa, &yyes, &yyes_capacity, yyssp, yytoken); \ + if (yy_lac_status == 2) \ + goto yyexhaustedlab; \ + if (yy_lac_status == 1) \ + goto yyerrlab; \ + } \ + } \ +} while (YYID (0)) + +/* Discard any previous initial lookahead context because of Event, + which may be a lookahead change or an invalidation of the currently + established initial context for the current lookahead. + + The most common example of a lookahead change is a shift. An example + of both cases is syntax error recovery. That is, a syntax error + occurs when the lookahead is syntactically erroneous for the + currently established initial context, so error recovery manipulates + the parser stacks to try to find a new initial context in which the + current lookahead is syntactically acceptable. If it fails to find + such a context, it discards the lookahead. */ +#if ]b4_api_PREFIX[DEBUG +# define YY_LAC_DISCARD(Event) \ +do { \ + if (yy_lac_established) \ + { \ + if (yydebug) \ + YYFPRINTF (stderr, "LAC: initial context discarded due to " \ + Event "\n"); \ + yy_lac_established = 0; \ + } \ +} while (YYID (0)) +#else +# define YY_LAC_DISCARD(Event) yy_lac_established = 0 +#endif + +/* Given the stack whose top is *YYSSP, return 0 iff YYTOKEN can + eventually (after perhaps some reductions) be shifted, return 1 if + not, or return 2 if memory is exhausted. As preconditions and + postconditions: *YYES_CAPACITY is the allocated size of the array to + which *YYES points, and either *YYES = YYESA or *YYES points to an + array allocated with YYSTACK_ALLOC. yy_lac may overwrite the + contents of either array, alter *YYES and *YYES_CAPACITY, and free + any old *YYES other than YYESA. */ +static int +yy_lac (yytype_int16 *yyesa, yytype_int16 **yyes, + YYSIZE_T *yyes_capacity, yytype_int16 *yyssp, int yytoken) +{ + yytype_int16 *yyes_prev = yyssp; + yytype_int16 *yyesp = yyes_prev; + YYDPRINTF ((stderr, "LAC: checking lookahead %s:", yytname[yytoken])); + if (yytoken == YYUNDEFTOK) + { + YYDPRINTF ((stderr, " Always Err\n")); + return 1; + } + while (1) + { + int yyrule = yypact[*yyesp]; + if (yypact_value_is_default (yyrule) + || (yyrule += yytoken) < 0 || YYLAST < yyrule + || yycheck[yyrule] != yytoken) + { + yyrule = yydefact[*yyesp]; + if (yyrule == 0) + { + YYDPRINTF ((stderr, " Err\n")); + return 1; + } + } + else + { + yyrule = yytable[yyrule]; + if (yytable_value_is_error (yyrule)) + { + YYDPRINTF ((stderr, " Err\n")); + return 1; + } + if (0 < yyrule) + { + YYDPRINTF ((stderr, " S%d\n", yyrule)); + return 0; + } + yyrule = -yyrule; + } + { + YYSIZE_T yylen = yyr2[yyrule]; + YYDPRINTF ((stderr, " R%d", yyrule - 1)); + if (yyesp != yyes_prev) + { + YYSIZE_T yysize = yyesp - *yyes + 1; + if (yylen < yysize) + { + yyesp -= yylen; + yylen = 0; + } + else + { + yylen -= yysize; + yyesp = yyes_prev; + } + } + if (yylen) + yyesp = yyes_prev -= yylen; + } + { + int yystate; + { + int yylhs = yyr1[yyrule] - YYNTOKENS; + yystate = yypgoto[yylhs] + *yyesp; + if (yystate < 0 || YYLAST < yystate + || yycheck[yystate] != *yyesp) + yystate = yydefgoto[yylhs]; + else + yystate = yytable[yystate]; + } + if (yyesp == yyes_prev) + { + yyesp = *yyes; + *yyesp = yystate; + } + else + { + if (yy_lac_stack_realloc (yyes_capacity, 1, +#if ]b4_api_PREFIX[DEBUG + " (", ")", +#endif + yyes, yyesa, &yyesp, yyes_prev)) + { + YYDPRINTF ((stderr, "\n")); + return 2; + } + *++yyesp = yystate; + } + YYDPRINTF ((stderr, " G%d", yystate)); + } + } +}]])[ + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +]b4_c_function_def([yystrlen], [static YYSIZE_T], + [[const char *yystr], [yystr]])[ +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +]b4_c_function_def([yystpcpy], [static char *], + [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[ +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP.]b4_lac_if([[ In order to see if a particular token T is a + valid looakhead, invoke yy_lac (YYESA, YYES, YYES_CAPACITY, YYSSP, T).]])[ + + Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return 2 if the + required number of bytes is too large to store]b4_lac_if([[ or if + yy_lac returned 2]])[. */ +static int +yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, + ]b4_lac_if([[yytype_int16 *yyesa, yytype_int16 **yyes, + YYSIZE_T *yyes_capacity, ]])[yytype_int16 *yyssp, int yytoken) +{ + YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]); + YYSIZE_T yysize = yysize0; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULL; + /* Arguments of yyformat. */ + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; + + /* There are many possibilities here to consider: + - Assume YYFAIL is not used. It's too flawed to consider. See + + for details. YYERROR is fine as it does not invoke this + function. + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar.]b4_lac_if([[ + In the first two cases, it might appear that the current syntax + error should have been detected in the previous state when yy_lac + was invoked. However, at that time, there might have been a + different syntax error that discarded a different initial context + during error recovery, leaving behind the current lookahead.]], [[ + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state.]])[ + */ + if (yytoken != YYEMPTY) + { + int yyn = yypact[*yyssp];]b4_lac_if([[ + YYDPRINTF ((stderr, "Constructing syntax error message\n"));]])[ + yyarg[yycount++] = yytname[yytoken]; + if (!yypact_value_is_default (yyn)) + {]b4_lac_if([], [[ + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;]])[ + int yyx;]b4_lac_if([[ + + for (yyx = 0; yyx < YYNTOKENS; ++yyx) + if (yyx != YYTERROR && yyx != YYUNDEFTOK) + { + { + int yy_lac_status = yy_lac (yyesa, yyes, yyes_capacity, + yyssp, yyx); + if (yy_lac_status == 2) + return 2; + if (yy_lac_status == 1) + continue; + }]], [[ + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR + && !yytable_value_is_error (yytable[yyx + yyn])) + {]])[ + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + break; + } + yyarg[yycount++] = yytname[yyx]; + { + YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]); + if (! (yysize <= yysize1 + && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + } + }]b4_lac_if([[ +# if ]b4_api_PREFIX[DEBUG + else if (yydebug) + YYFPRINTF (stderr, "No expected tokens.\n"); +# endif]])[ + } + + switch (yycount) + { +# define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +# undef YYCASE_ + } + + { + YYSIZE_T yysize1 = yysize + yystrlen (yyformat); + if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return 1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } + } + return 0; +} +#endif /* YYERROR_VERBOSE */ + +]b4_yydestruct_generate([b4_c_function_def])[ + +]b4_pure_if([], [ + +b4_declare_scanner_communication_variables])[]b4_push_if([[ + +struct yypstate + {]b4_declare_parser_state_variables[ + /* Used to determine if this is the first time this instance has + been used. */ + int yynew; + };]b4_pure_if([], [[ + +static char yypstate_allocated = 0;]])b4_pull_if([ + +b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[ +{ + return yypull_parse (YY_NULL]m4_ifset([b4_parse_param], + [[, ]b4_c_args(b4_parse_param)])[); +} + +]b4_c_function_def([[yypull_parse]], [[int]], + [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, + b4_parse_param]))[ +{ + int yystatus; + yypstate *yyps_local;]b4_pure_if([[ + int yychar; + YYSTYPE yylval;]b4_locations_if([[ + static YYLTYPE yyloc_default][]b4_yyloc_default[; + YYLTYPE yylloc = yyloc_default;]])])[ + if (yyps) + yyps_local = yyps; + else + { + yyps_local = yypstate_new (); + if (!yyps_local) + {]b4_pure_if([[ + yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[ + if (!yypstate_allocated) + yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[ + return 2; + } + } + do { + yychar = YYLEX; + yystatus = + yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[); + } while (yystatus == YYPUSH_MORE); + if (!yyps) + yypstate_delete (yyps_local); + return yystatus; +}]])[ + +/* Initialize the parser data structure. */ +]b4_c_function_def([[yypstate_new]], [[yypstate *]])[ +{ + yypstate *yyps;]b4_pure_if([], [[ + if (yypstate_allocated) + return YY_NULL;]])[ + yyps = (yypstate *) malloc (sizeof *yyps); + if (!yyps) + return YY_NULL; + yyps->yynew = 1;]b4_pure_if([], [[ + yypstate_allocated = 1;]])[ + return yyps; +} + +]b4_c_function_def([[yypstate_delete]], [[void]], + [[[yypstate *yyps]], [[yyps]]])[ +{ +#ifndef yyoverflow + /* If the stack was reallocated but the parse did not complete, then the + stack still needs to be freed. */ + if (!yyps->yynew && yyps->yyss != yyps->yyssa) + YYSTACK_FREE (yyps->yyss); +#endif]b4_lac_if([[ + if (!yyps->yynew && yyps->yyes != yyps->yyesa) + YYSTACK_FREE (yyps->yyes);]])[ + free (yyps);]b4_pure_if([], [[ + yypstate_allocated = 0;]])[ +} +]b4_pure_if([[ +#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs]])[ +#define yystate yyps->yystate +#define yyerrstatus yyps->yyerrstatus +#define yyssa yyps->yyssa +#define yyss yyps->yyss +#define yyssp yyps->yyssp +#define yyvsa yyps->yyvsa +#define yyvs yyps->yyvs +#define yyvsp yyps->yyvsp]b4_locations_if([[ +#define yylsa yyps->yylsa +#define yyls yyps->yyls +#define yylsp yyps->yylsp +#define yyerror_range yyps->yyerror_range]])[ +#define yystacksize yyps->yystacksize]b4_lac_if([[ +#define yyesa yyps->yyesa +#define yyes yyps->yyes +#define yyes_capacity yyps->yyes_capacity]])[ + + +/*---------------. +| yypush_parse. | +`---------------*/ + +]b4_c_function_def([[yypush_parse]], [[int]], + [[[yypstate *yyps]], [[yyps]]]b4_pure_if([, + [[[int yypushed_char]], [[yypushed_char]]], + [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([, + [[[YYLTYPE *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [, + b4_parse_param]))], [[ + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +]b4_c_function_def([yyparse], [int], + [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[ +#else /* ! YYPARSE_PARAM */ +]b4_c_function_def([yyparse], [int], b4_parse_param)[ +#endif]])[ +{]b4_pure_if([b4_declare_scanner_communication_variables +])b4_push_if([b4_pure_if([], [[ + int yypushed_char = yychar; + YYSTYPE yypushed_val = yylval;]b4_locations_if([[ + YYLTYPE yypushed_loc = yylloc;]]) +])], + [b4_declare_parser_state_variables +])b4_lac_if([[ + int yy_lac_established = 0;]])[ + int yyn; + int yyresult; + /* Lookahead token as an internal (translated) token number. */ + int yytoken = 0; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ + +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0;]b4_push_if([[ + + if (!yyps->yynew) + { + yyn = yypact[yystate]; + goto yyread_pushed_token; + }]])[ + + yyssp = yyss = yyssa; + yyvsp = yyvs = yyvsa;]b4_locations_if([[ + yylsp = yyls = yylsa;]])[ + yystacksize = YYINITDEPTH;]b4_lac_if([[ + + yyes = yyesa; + yyes_capacity = sizeof yyesa / sizeof *yyes; + if (YYMAXDEPTH < yyes_capacity) + yyes_capacity = YYMAXDEPTH;]])[ + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([m4_define([b4_dollar_dollar_used])yylval], [], + [b4_push_if([b4_pure_if([*])yypushed_loc], [yylloc])])dnl +/* User initialization code. */ +b4_user_initial_action +b4_dollar_popdef[]dnl +m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval; +]])])dnl +b4_locations_if([[ yylsp[0] = ]b4_push_if([b4_pure_if([*])yypushed_loc], [yylloc])[; +]])dnl +[ goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss;]b4_locations_if([ + YYLTYPE *yyls1 = yyls;])[ + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([ + &yyls1, yysize * sizeof (*yylsp),])[ + &yystacksize); +]b4_locations_if([ + yyls = yyls1;])[ + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([ + YYSTACK_RELOCATE (yyls_alloc, yyls);])[ +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1;]b4_locations_if([ + yylsp = yyls + yysize - 1;])[ + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ + if (yychar == YYEMPTY) + {]b4_push_if([[ + if (!yyps->yynew) + {]b4_use_push_for_pull_if([], [[ + YYDPRINTF ((stderr, "Return for a new token:\n"));]])[ + yyresult = YYPUSH_MORE; + goto yypushreturn; + } + yyps->yynew = 0;]b4_pure_if([], [[ + /* Restoring the pushed token is only necessary for the first + yypush_parse invocation since subsequent invocations don't overwrite + it before jumping to yyread_pushed_token. */ + yychar = yypushed_char; + yylval = yypushed_val;]b4_locations_if([[ + yylloc = yypushed_loc;]])])[ +yyread_pushed_token:]])[ + YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[ + yychar = yypushed_char; + if (yypushed_val) + yylval = *yypushed_val;]b4_locations_if([[ + if (yypushed_loc) + yylloc = *yypushed_loc;]])])], [[ + yychar = YYLEX;]])[ + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)]b4_lac_if([[ + { + YY_LAC_ESTABLISH; + goto yydefault; + }]], [[ + goto yydefault;]])[ + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab;]b4_lac_if([[ + YY_LAC_ESTABLISH;]])[ + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token. */ + yychar = YYEMPTY;]b4_lac_if([[ + YY_LAC_DISCARD ("shift");]])[ + + yystate = yyn; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END +]b4_locations_if([ *++yylsp = yylloc;])[ + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + +]b4_locations_if( +[[ /* Default location. */ + YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[ + YY_REDUCE_PRINT (yyn);]b4_lac_if([[ + { + int yychar_backup = yychar; + switch (yyn) + { + ]b4_user_actions[ + default: break; + } + if (yychar_backup != yychar) + YY_LAC_DISCARD ("yychar change"); + }]], [[ + switch (yyn) + { + ]b4_user_actions[ + default: break; + }]])[ + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval;]b4_locations_if([ + *++yylsp = yyloc;])[ + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); + + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + yyerror (]b4_yyerror_args[YY_("syntax error")); +#else +# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \]b4_lac_if([[ + yyesa, &yyes, &yyes_capacity, \]])[ + yyssp, yytoken) + { + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status;]b4_lac_if([[ + if (yychar != YYEMPTY) + YY_LAC_ESTABLISH;]])[ + yysyntax_error_status = YYSYNTAX_ERROR; + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == 1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); + if (!yymsg) + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = 2; + } + else + { + yysyntax_error_status = YYSYNTAX_ERROR; + yymsgp = yymsg; + } + } + yyerror (]b4_yyerror_args[yymsgp); + if (yysyntax_error_status == 2) + goto yyexhaustedlab; + } +# undef YYSYNTAX_ERROR +#endif + } + +]b4_locations_if([[ yyerror_range[1] = yylloc;]])[ + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + +]b4_locations_if([[ yyerror_range[1] = yylsp[1-yylen]; +]])[ /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + +]b4_locations_if([[ yyerror_range[1] = *yylsp;]])[ + yydestruct ("Error: popping", + yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + }]b4_lac_if([[ + + /* If the stack popping above didn't lose the initial context for the + current lookahead token, the shift below will for sure. */ + YY_LAC_DISCARD ("error recovery");]])[ + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END +]b4_locations_if([[ + yyerror_range[2] = yylloc; + /* Using YYLLOC is tempting, but would change the location of + the lookahead. YYLOC is available though. */ + YYLLOC_DEFAULT (yyloc, yyerror_range, 2); + *++yylsp = yyloc;]])[ + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#if ]b4_lac_if([[1]], [[!defined yyoverflow || YYERROR_VERBOSE]])[ +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror (]b4_yyerror_args[YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEMPTY) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); + } + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif]b4_lac_if([[ + if (yyes != yyesa) + YYSTACK_FREE (yyes);]])b4_push_if([[ + yyps->yynew = 1; + +yypushreturn:]])[ +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + /* Make sure YYID is used. */ + return YYID (yyresult); +} + + +]b4_epilogue[]dnl +b4_output_end() + +b4_defines_if( +[b4_output_begin([b4_spec_defines_file])[ +]b4_copyright([Bison interface for Yacc-like parsers in C], + [1984, 1989-1990, 2000-2012])[ + +]b4_shared_declarations[ +]b4_output_end() +]) diff --git a/src/icon.ico b/src/icon.ico new file mode 100644 index 0000000000000000000000000000000000000000..131e64e1ce853270e52f5987aff154a39c05c34f GIT binary patch literal 4022 zcmcha$!{A~9LI-$0B+o%mAWJ}A&H$FhzM!~0&zpoLurv%1ZkmM3pbiJOP5H1pkfh= zR79!U#5s{7E);0$gi<(UhbC#_rZm8%jc3N|%zXL2dGEQl@x)o$I(nXXY|rQO`~Kd0 zlNiQ5{Mq=RA)bvB_Zi0hhGA55Y~*O+5a;~|-y6JF4tc^bu!e^V&;Qm!_6GjVnf~wk z+!`*os;_9yKe+^+jem}|YY`;f>|JqiRNafYB|I1Z0!`CBXqY~VJ#?_$%pG-bJej#* z?;txoeGJ=YKR_!-JstKIIC#o)RlzRvVa@(KcZ2LN(a5?5w`KNyf3#ka4zJT;N%i7( zIXHgV9=k5(+mI}ESY-~Hy&&pV>~No8d#F1jjyd0%v{zj*@DZ_Cmq6lS#0~gABV=@Ci^v?ofK?6 zl!GAo~GkzCV^#Y#XL+!?sM=bTFBN zInvE}x05-vmF^C8qnxe<2_P<`R3^cXRD)eji-5J^lC>P{SH)xxPicg%0(~MXZN!CJD)L&gJX3 zn1Kb0YKiGyf8Cd_ootcIFZhOIWsOFpt%%R`I*5g35m-pM>cEXC4?0;N?X|k=MeMsLdpSfn19(4|Z4%{C?pKu(a zV+YXJe*(Bv;E-p(v1+zs~uM z$f1_(u&O)MCD?pTeyGbu)j>M+bA$YK2NFYXuDNc_*2jDf3tSiMcRe|cyp?Fac4+MO zu;~DBGRmN=N%i;F%I^7^6?Dw0%bc5HAK35uPCEG6OOGb{)UpT7$2?r3r+Bz}W0Nn} z{hW9BgAQbA2f?mkCe25Iaqb-?!__ynbyJHkpdEgogQ&NGIn?m@2-#yko45Ge6L~SX m;FWgx=}(!%qdmaHb@_oi&DI*4^W7LQG`l{w{y+F`AO8av%2SX4 literal 0 HcmV?d00001 diff --git a/src/icon.rc b/src/icon.rc new file mode 100644 index 0000000..ac3155f --- /dev/null +++ b/src/icon.rc @@ -0,0 +1,3 @@ +// Icon Resource Definition +#define MAIN_ICON 102 +MAIN_ICON ICON "icon.ico" \ No newline at end of file diff --git a/src/lexer.flex.cpp b/src/lexer.flex.cpp new file mode 100644 index 0000000..043f22d --- /dev/null +++ b/src/lexer.flex.cpp @@ -0,0 +1,1756 @@ +#line 1 "lexer.flex.cpp" + +#line 3 "lexer.flex.cpp" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. + */ +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN (yy_start) = 1 + 2 * +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START (((yy_start) - 1) / 2) +#define YYSTATE YY_START +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +extern int yyleng; + +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + #define YY_LESS_LINENO(n) + #define YY_LINENO_REWIND_TO(ptr) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = (yy_hold_char); \ + YY_RESTORE_YY_MORE_OFFSET \ + (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) +#define unput(c) yyunput( c, (yytext_ptr) ) + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = NULL; +static int yy_init = 0; /* whether we need to initialize */ +static int yy_start = 0; /* 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 ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); + +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); + +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); + +#define yy_new_buffer yy_create_buffer +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ +typedef flex_uint8_t YY_CHAR; + +FILE *yyin = NULL, *yyout = NULL; + +typedef int yy_state_type; + +extern int yylineno; +int yylineno = 1; + +extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state ( void ); +static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); +static int yy_get_next_buffer ( void ); +static void yynoreturn yy_fatal_error ( const char* msg ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ + (yy_c_buf_p) = yy_cp; +#define YY_NUM_RULES 5 +#define YY_END_OF_BUFFER 6 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static const flex_int16_t yy_accept[13] = + { 0, + 0, 0, 6, 5, 4, 3, 2, 2, 2, 2, + 1, 0 + } ; + +static const YY_CHAR yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 4, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 1, 1, 1, + 1, 1, 2, 1, 5, 5, 5, 5, 5, 5, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, + 1, 1, 1, 1, 6, 1, 5, 5, 5, 5, + + 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, + 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static const YY_CHAR yy_meta[8] = + { 0, + 1, 1, 1, 2, 2, 2, 2 + } ; + +static const flex_int16_t yy_base[14] = + { 0, + 0, 0, 12, 13, 13, 13, 4, 0, 0, 4, + 0, 13, 8 + } ; + +static const flex_int16_t yy_def[14] = + { 0, + 12, 1, 12, 12, 12, 12, 13, 13, 13, 13, + 10, 0, 12 + } ; + +static const flex_int16_t yy_nxt[21] = + { 0, + 4, 5, 6, 7, 8, 8, 8, 11, 11, 9, + 10, 12, 3, 12, 12, 12, 12, 12, 12, 12 + } ; + +static const flex_int16_t yy_chk[21] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 10, 10, 13, + 7, 3, 12, 12, 12, 12, 12, 12, 12, 12 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +extern int yy_flex_debug; +int yy_flex_debug = 0; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "lexer.l" +#line 2 "lexer.l" +#include "parser.tab.h" +#include +#line 449 "lexer.flex.cpp" +#line 450 "lexer.flex.cpp" + +#define INITIAL 0 + +/*windows compatibility case*/ +#include +#define isatty _isatty +#define fileno _fileno + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +static int yy_init_globals ( void ); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( void ); + +int yyget_debug ( void ); + +void yyset_debug ( int debug_flag ); + +YY_EXTRA_TYPE yyget_extra ( void ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined ); + +FILE *yyget_in ( void ); + +void yyset_in ( FILE * _in_str ); + +FILE *yyget_out ( void ); + +void yyset_out ( FILE * _out_str ); + + int yyget_leng ( void ); + +char *yyget_text ( void ); + +int yyget_lineno ( void ); + +void yyset_lineno ( int _line_number ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( void ); +#else +extern int yywrap ( void ); +#endif +#endif + +#ifndef YY_NO_UNPUT + + static void yyunput ( int c, char *buf_ptr ); + +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * ); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput ( void ); +#else +static int input ( void ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + int n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex (void); + +#define YY_DECL int yylex (void) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK /*LINTED*/break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_load_buffer_state( ); + } + + { +#line 6 "lexer.l" + +#line 666 "lexer.flex.cpp" + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ + { + yy_cp = (yy_c_buf_p); + + /* Support of yytext. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = (yy_start); +yy_match: + do + { + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 13 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 13 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 7 "lexer.l" +{ yylval.imm_val = strtoull(yytext, nullptr, 16); return IMM; } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 8 "lexer.l" +{ strcpy(yylval.vinstr_name, yytext); return VINSTR; } + YY_BREAK +case 3: +/* rule 3 can match eol */ +YY_RULE_SETUP +#line 9 "lexer.l" +{ yylineno++; } + YY_BREAK +case 4: +/* rule 4 can match eol */ +YY_RULE_SETUP +#line 10 "lexer.l" + + YY_BREAK +case 5: +YY_RULE_SETUP +#line 11 "lexer.l" +ECHO; + YY_BREAK +#line 750 "lexer.flex.cpp" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = (yy_c_buf_p); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of user's declarations */ +} /* end of yylex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (void) +{ + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = (yytext_ptr); + int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (void) +{ + yy_state_type yy_current_state; + char *yy_cp; + + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 13 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +{ + int yy_is_jam; + char *yy_cp = (yy_c_buf_p); + + YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 13 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 12); + + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_UNPUT + + static void yyunput (int c, char * yy_bp ) +{ + char *yy_cp; + + yy_cp = (yy_c_buf_p); + + /* undo effects of setting up yytext */ + *yy_cp = (yy_hold_char); + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + int number_to_move = (yy_n_chars) + 2; + char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; + char *source = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; + + while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = + (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + (yytext_ptr) = yy_bp; + (yy_hold_char) = *yy_cp; + (yy_c_buf_p) = yy_cp; +} + +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (void) +#else + static int input (void) +#endif + +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( ) ) + return 0; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyrestart (FILE * input_file ) +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + +static void yy_load_buffer_state (void) +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + (yy_hold_char) = *(yy_c_buf_p); +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ + void yy_delete_buffer (YY_BUFFER_STATE b ) +{ + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree( (void *) b->yy_ch_buf ); + + yyfree( (void *) b ); +} + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) + +{ + int oerrno = errno; + + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ + void yy_flush_buffer (YY_BUFFER_STATE b ) +{ + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +void yypop_buffer_state (void) +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void yyensure_buffer_stack (void) +{ + yy_size_t num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + yy_size_t grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return NULL; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = NULL; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (const char * yystr ) +{ + + return yy_scan_bytes( yystr, (int) strlen(yystr) ); +} + +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yynoreturn yy_fatal_error (const char* msg ) +{ + fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ + (yy_hold_char) = *(yy_c_buf_p); \ + *(yy_c_buf_p) = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the current line number. + * + */ +int yyget_lineno (void) +{ + + return yylineno; +} + +/** Get the input stream. + * + */ +FILE *yyget_in (void) +{ + return yyin; +} + +/** Get the output stream. + * + */ +FILE *yyget_out (void) +{ + return yyout; +} + +/** Get the length of the current token. + * + */ +int yyget_leng (void) +{ + return yyleng; +} + +/** Get the current token. + * + */ + +char *yyget_text (void) +{ + return yytext; +} + +/** Set the current line number. + * @param _line_number line number + * + */ +void yyset_lineno (int _line_number ) +{ + + yylineno = _line_number; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param _in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * _in_str ) +{ + yyin = _in_str ; +} + +void yyset_out (FILE * _out_str ) +{ + yyout = _out_str ; +} + +int yyget_debug (void) +{ + return yy_flex_debug; +} + +void yyset_debug (int _bdebug ) +{ + yy_flex_debug = _bdebug ; +} + +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + (yy_buffer_stack) = NULL; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = NULL; + (yy_init) = 0; + (yy_start) = 0; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = NULL; + yyout = NULL; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} + +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer( YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } + + /* Destroy the stack itself. */ + yyfree((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( ); + + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, const char * s2, int n ) +{ + + int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (const char * s ) +{ + int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size ) +{ + return malloc(size); +} + +void *yyrealloc (void * ptr, yy_size_t size ) +{ + + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return realloc(ptr, size); +} + +void yyfree (void * ptr ) +{ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 11 "lexer.l" + diff --git a/src/lexer.l b/src/lexer.l new file mode 100644 index 0000000..ed0701e --- /dev/null +++ b/src/lexer.l @@ -0,0 +1,11 @@ +%{ +#include "parser.tab.h" +#include +%} + +%% +0[xX][0-9a-fA-F]+ { yylval.imm_val = strtoull(yytext, nullptr, 16); return IMM; } +[a-zA-Z0-9_]+ { strcpy(yylval.vinstr_name, yytext); return VINSTR; } +"\n" { yylineno++; } +[ ?\t\n\r] +%% \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..ac8e52e --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,223 @@ +#include +#include +#include +#include +#include + +#include "compiler.h" +#include "parser.tab.h" +#include "parser.h" +#include "cli-parser.hpp" +#include "vmasm.hpp" + +extern FILE* yyin; +extern "C" int yywrap() +{ return 1; } + +void yyerror(char* msg) +{ std::printf("[!] parsing failure: %s\n", msg); } + +int __cdecl main(int argc, const char* argv[]) +{ + // + // handle arguments from the commandline... + // + + argparse::argument_parser_t argp( + "vmassembler", "virtual instruction assembler for VMProtect 2"); + + argp.add_argument() + .names({ "--input", "--in" }) + .description("path to a vasm file to be assembled...") + .required(true); + + argp.add_argument() + .names({ "--vmpbin", "--bin" }) + .description("path to protected binary...") + .required(true); + + argp.add_argument() + .names({ "--vmentry", "--entry" }) + .description("rva to vm entry...") + .required(true); + + argp.add_argument() + .names({ "--imagebase", "--base" }) + .description("optional header image base field value...") + .required(true); + + argp.add_argument() + .name({ "--advancement" }) + .description("which direction vip advances... the options are 'forward' and 'backward'") + .required(true); + + argp.add_argument() + .name({ "--output" }) + .description("output file name and path...") + .required(true); + + argp.enable_help(); + auto err = argp.parse(argc, argv); + + if (err) + { + std::cout << err << std::endl; + return -1; + } + + if (argp.exists("help")) + { + argp.print_help(); + return 0; + } + + // + // set yyin to the vasm file... + // + + if ((yyin = fopen(argp.get("input").c_str(), "r")) == nullptr) + { + std::printf("[!] failed to open vasm file...\n"); + return -1; + } + + // + // parse vasm file for all of the instructions... + // + + yyparse(); + std::printf("[+] finished parsing vasm file...\n"); + + // + // init vm variables... + // + + const auto module_base = + reinterpret_cast( + LoadLibraryExA(argp.get("vmpbin").c_str(), + NULL, DONT_RESOLVE_DLL_REFERENCES)); + + const auto vm_entry_rva = std::strtoull( + argp.get("vmentry").c_str(), nullptr, 16); + + const auto image_base = std::strtoull( + argp.get("imagebase").c_str(), nullptr, 16); + + vmp2::exec_type_t advancement = + argp.get("advancement") == "backward" ? + vmp2::exec_type_t::backward : vmp2::exec_type_t::forward; + + zydis_routine_t vm_entry, calc_jmp; + std::vector vm_handlers; + std::uintptr_t* vm_handler_table; + ZydisDecodedInstruction encrypt_rva; + + if (!vm::util::flatten(vm_entry, module_base + vm_entry_rva)) + { + std::printf("[!] failed to flatten vm entry...\n"); + return -1; + } + + std::printf("[+] flattened vm_entry...\n"); + vm::util::deobfuscate(vm_entry); + std::printf("[+] deobfuscated vm_entry...\n"); + vm::util::print(vm_entry); + + if (!(vm_handler_table = vm::handler::table::get(vm_entry))) + { + std::printf("[!] failed to obtain vm handler table...\n"); + return -1; + } + + if (!vm::handler::get_all(module_base, image_base, vm_entry, vm_handler_table, vm_handlers)) + { + std::printf("[!] failed to get all vm handlers...\n"); + return -1; + } + + if (!vm::get_calc_jmp(vm_entry, calc_jmp)) + { + std::printf("[!] failed to get calc_jmp...\n"); + return -1; + } + + if (!vm::get_vinstr_rva_transform(vm_entry, &encrypt_rva)) + { + std::printf("[!] failed to get virtual instruction rva encryption transform...\n"); + return -1; + } + + vm::compiler_t compiler({ module_base, image_base }, advancement, &vm_handlers, &calc_jmp); + + // + // encode virtual instructions... + // + + auto [encoded_success, vinstrs] = compiler.encode(); + std::printf("[+] finished encoding... encoded instructions below...\n"); + + if (!encoded_success) + { + std::printf("[!] failed to encode virtual instructions...\n"); + return -1; + } + + for (auto& vinstr : *vinstrs) + { + if (vinstr.imm_size) + std::printf("> 0x%x - 0x%x\n", vinstr.vm_handler, vinstr.operand); + else + std::printf("> 0x%x\n", vinstr.vm_handler); + } + + // + // encrypt virtual instructions... + // + + auto [entry_rva, result_buffer] = compiler.encrypt(); + std::printf("[+] finished encrypting... encrypted instructions below...\n"); + + if (!entry_rva) + { + std::printf("[!] failed to encrypt virtual instructions...\n"); + return -1; + } + + std::printf("> virtual instructions must be allocated at = 0x%p\n", entry_rva); + std::printf("> "); + { + auto idx = 0u; + for (auto byte : *result_buffer) + { + std::printf("0x%x ", byte); + if (++idx == 10) + { + std::printf("\n"); + idx = 0u; + } + } + } + std::printf("\n"); + + // + // write the result to disk... + // + + vmasm::file_header_t file_header; + file_header.magic = VASM_MAGIC; + file_header.epoch_time = std::time(nullptr); + file_header.vasm_size = result_buffer->size(); + file_header.alloc_rva = (entry_rva - image_base); + file_header.vasm_offset = sizeof vmasm::file_header_t; + file_header.encrypted_rva = vm::transform::apply( + encrypt_rva.operands[0].size, + encrypt_rva.mnemonic, entry_rva, + // check to see if this instruction has an IMM... + vm::transform::has_imm(&encrypt_rva) ? + encrypt_rva.operands[1].imm.value.u : 0); + + std::ofstream output(argp.get("output"), std::ios::binary); + output.write(reinterpret_cast(&file_header), sizeof file_header); + output.write(reinterpret_cast(result_buffer->data()), result_buffer->size()); + output.close(); +} \ No newline at end of file diff --git a/src/parser.cpp b/src/parser.cpp new file mode 100644 index 0000000..0c9515c --- /dev/null +++ b/src/parser.cpp @@ -0,0 +1,31 @@ +#include "parser.h" + +parse_t::parse_t() +{} + +auto parse_t::get_instance() -> parse_t* +{ + static parse_t obj; + return &obj; +} + +void parse_t::add_vinstr(std::string vinstr_name) +{ + _vinstr_meta data{ vinstr_name, false, 0u }; + vinstrs.push_back(data); +} + +void parse_t::add_vinstr(std::string vinstr_name, std::uintptr_t imm_val) +{ + _vinstr_meta data{ vinstr_name, true, imm_val }; + vinstrs.push_back(data); +} + +bool parse_t::for_each(callback_t callback) +{ + for (auto& entry : vinstrs) + if (!callback(&entry)) + return false; + + return true; +} \ No newline at end of file diff --git a/src/parser.h b/src/parser.h new file mode 100644 index 0000000..06d1cfb --- /dev/null +++ b/src/parser.h @@ -0,0 +1,29 @@ +#pragma once +#include +#include +#include +#include + +struct _vinstr_meta +{ + std::string name; + + bool has_imm; + std::uintptr_t imm; +}; + +using callback_t = std::function; + +// this singleton class contains all the +// information for parsed virtual instructions... +class parse_t +{ +public: + static auto get_instance() -> parse_t*; + void add_vinstr(std::string vinstr_name); + void add_vinstr(std::string vinstr_name, std::uintptr_t imm_val); + bool for_each(callback_t callback); +private: + parse_t(); + std::vector<_vinstr_meta> vinstrs; +}; \ No newline at end of file diff --git a/src/parser.tab.cpp b/src/parser.tab.cpp new file mode 100644 index 0000000..86b7956 --- /dev/null +++ b/src/parser.tab.cpp @@ -0,0 +1,1587 @@ +/* A Bison parser, made by GNU Bison 2.7. */ + +/* Bison implementation for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* As a special exception, 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. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "2.7" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + + + + +/* Copy the first part of user declarations. */ +/* Line 371 of yacc.c */ +#line 1 "parser.y" + +#include +#include "parser.h" +int yylex(void); +void yyerror(char *); +extern int yylineno; + +/* Line 371 of yacc.c */ +#line 76 "parser.tab.cpp" + +# ifndef YY_NULL +# if defined __cplusplus && 201103L <= __cplusplus +# define YY_NULL nullptr +# else +# define YY_NULL 0 +# endif +# endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +/* In a future release of Bison, this section will be replaced + by #include "parser.tab.h". */ +#ifndef YY_YY_PARSER_TAB_H_INCLUDED +# define YY_YY_PARSER_TAB_H_INCLUDED +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif +#if YYDEBUG +extern int yydebug; +#endif + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + VINSTR = 258, + IMM = 259 + }; +#endif + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +{ +/* Line 387 of yacc.c */ +#line 10 "parser.y" + +char vinstr_name[20]; +unsigned long long imm_val; + + +/* Line 387 of yacc.c */ +#line 129 "parser.tab.cpp" +} YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +#endif + +extern YYSTYPE yylval; + +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + +#endif /* !YY_YY_PARSER_TAB_H_INCLUDED */ + +/* Copy the second part of user declarations. */ + +/* Line 390 of yacc.c */ +#line 157 "parser.tab.cpp" + +#ifdef short +# undef short +#endif + +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#elif (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +typedef signed char yytype_int8; +#else +typedef short int yytype_int8; +#endif + +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; +#else +typedef unsigned short int yytype_uint16; +#endif + +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned int +# endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(E) ((void) (E)) +#else +# define YYUSE(E) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +# define YYID(N) (N) +#else +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static int +YYID (int yyi) +#else +static int +YYID (yyi) + int yyi; +#endif +{ + return yyi; +} +#endif + +#if ! defined yyoverflow || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# 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 (YYID (0)) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined 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 && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss_alloc; + YYSTYPE yyvs_alloc; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (YYID (0)) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from SRC to DST. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(Dst, Src, Count) \ + __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) +# else +# define YYCOPY(Dst, Src, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (Dst)[yyi] = (Src)[yyi]; \ + } \ + while (YYID (0)) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 4 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 6 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 5 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 2 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 5 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 7 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 259 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const yytype_uint8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const yytype_uint8 yyprhs[] = +{ + 0, 0, 3, 5, 8, 11 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int8 yyrhs[] = +{ + 6, 0, -1, 3, -1, 3, 4, -1, 6, 3, + -1, 6, 3, 4, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint8 yyrline[] = +{ + 0, 20, 20, 21, 22, 23 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE || 0 +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "VINSTR", "IMM", "$accept", "PROGRAM", YY_NULL +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const yytype_uint16 yytoknum[] = +{ + 0, 256, 257, 258, 259 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint8 yyr1[] = +{ + 0, 5, 6, 6, 6, 6 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = +{ + 0, 2, 1, 2, 2, 3 +}; + +/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const yytype_uint8 yydefact[] = +{ + 0, 2, 0, 3, 1, 4, 5 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int8 yydefgoto[] = +{ + -1, 2 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -3 +static const yytype_int8 yypact[] = +{ + -2, 1, 0, -3, -3, 2, -3 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int8 yypgoto[] = +{ + -3, -3 +}; + +/* 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. */ +#define YYTABLE_NINF -1 +static const yytype_uint8 yytable[] = +{ + 4, 1, 0, 5, 0, 3, 6 +}; + +#define yypact_value_is_default(Yystate) \ + (!!((Yystate) == (-3))) + +#define yytable_value_is_error(Yytable_value) \ + YYID (0) + +static const yytype_int8 yycheck[] = +{ + 0, 3, -1, 3, -1, 4, 4 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint8 yystos[] = +{ + 0, 3, 6, 4, 0, 3, 4 +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. However, + YYFAIL appears to be in use. Nevertheless, it is formally deprecated + in Bison 2.4.2's NEWS entry, where a plan to phase it out is + discussed. */ + +#define YYFAIL goto yyerrlab +#if defined YYFAIL + /* This is here to suppress warnings from the GCC cpp's + -Wunused-macros. Normally we don't worry about that warning, but + some users do, and we want to make it easy for users to remove + YYFAIL uses, which will produce warnings from Bison 2.5. */ +#endif + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (YYID (0)) + +/* Error token number */ +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* This macro is provided for backward compatibility. */ +#ifndef YY_LOCATION_PRINT +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ +#ifdef YYLEX_PARAM +# define YYLEX yylex (YYLEX_PARAM) +#else +# define YYLEX yylex () +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (YYID (0)) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_value_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + FILE *yyo = yyoutput; + YYUSE (yyo); + if (!yyvaluep) + return; +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# else + YYUSE (yyoutput); +# endif + switch (yytype) + { + default: + break; + } +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + yy_symbol_value_print (yyoutput, yytype, yyvaluep); + YYFPRINTF (yyoutput, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) +#else +static void +yy_stack_print (yybottom, yytop) + yytype_int16 *yybottom; + yytype_int16 *yytop; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (YYID (0)) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_reduce_print (YYSTYPE *yyvsp, int yyrule) +#else +static void +yy_reduce_print (yyvsp, yyrule) + YYSTYPE *yyvsp; + int yyrule; +#endif +{ + int yynrhs = yyr2[yyrule]; + int yyi; + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &(yyvsp[(yyi + 1) - (yynrhs)]) + ); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyvsp, Rule); \ +} while (YYID (0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#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 10000 +#endif + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static YYSIZE_T +yystrlen (const char *yystr) +#else +static YYSIZE_T +yystrlen (yystr) + const char *yystr; +#endif +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static char * +yystpcpy (char *yydest, const char *yysrc) +#else +static char * +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +#endif +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP. + + Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return 2 if the + required number of bytes is too large to store. */ +static int +yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, + yytype_int16 *yyssp, int yytoken) +{ + YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]); + YYSIZE_T yysize = yysize0; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULL; + /* Arguments of yyformat. */ + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; + + /* There are many possibilities here to consider: + - Assume YYFAIL is not used. It's too flawed to consider. See + + for details. YYERROR is fine as it does not invoke this + function. + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yytoken != YYEMPTY) + { + int yyn = yypact[*yyssp]; + yyarg[yycount++] = yytname[yytoken]; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + break; + } + yyarg[yycount++] = yytname[yyx]; + { + YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]); + if (! (yysize <= yysize1 + && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + } + } + } + + switch (yycount) + { +# define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +# undef YYCASE_ + } + + { + YYSIZE_T yysize1 = yysize + yystrlen (yyformat); + if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return 1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } + } + return 0; +} +#endif /* YYERROR_VERBOSE */ + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yymsg, yytype, yyvaluep) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + YYUSE (yyvaluep); + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + + + + +/* The lookahead symbol. */ +int yychar; + + +#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 + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval YY_INITIAL_VALUE(yyval_default); + +/* Number of syntax errors so far. */ +int yynerrs; + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void *YYPARSE_PARAM) +#else +int +yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +#endif +#else /* ! YYPARSE_PARAM */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void) +#else +int +yyparse () + +#endif +#endif +{ + int yystate; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + + /* The stacks and their tools: + `yyss': related to states. + `yyvs': related to semantic values. + + Refer to the stacks through separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs; + YYSTYPE *yyvsp; + + YYSIZE_T yystacksize; + + int yyn; + int yyresult; + /* Lookahead token as an internal (translated) token number. */ + int yytoken = 0; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + yyssp = yyss = yyssa; + yyvsp = yyvs = yyvsa; + yystacksize = YYINITDEPTH; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token. */ + yychar = YYEMPTY; + + yystate = yyn; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END + + 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]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: +/* Line 1792 of yacc.c */ +#line 20 "parser.y" + { parse_t::get_instance()->add_vinstr((yyvsp[(1) - (1)].vinstr_name)); } + break; + + case 3: +/* Line 1792 of yacc.c */ +#line 21 "parser.y" + { parse_t::get_instance()->add_vinstr((yyvsp[(1) - (2)].vinstr_name), (yyvsp[(2) - (2)].imm_val)); } + break; + + case 4: +/* Line 1792 of yacc.c */ +#line 22 "parser.y" + { parse_t::get_instance()->add_vinstr((yyvsp[(2) - (2)].vinstr_name)); } + break; + + case 5: +/* Line 1792 of yacc.c */ +#line 23 "parser.y" + { parse_t::get_instance()->add_vinstr((yyvsp[(2) - (3)].vinstr_name), (yyvsp[(3) - (3)].imm_val)); } + break; + + +/* Line 1792 of yacc.c */ +#line 1356 "parser.tab.cpp" + default: break; + } + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); + + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + yyerror (YY_((char*)"syntax error")); +#else +# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ + yyssp, yytoken) + { + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status; + yysyntax_error_status = YYSYNTAX_ERROR; + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == 1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); + if (!yymsg) + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = 2; + } + else + { + yysyntax_error_status = YYSYNTAX_ERROR; + yymsgp = yymsg; + } + } + yyerror (yymsgp); + if (yysyntax_error_status == 2) + goto yyexhaustedlab; + } +# undef YYSYNTAX_ERROR +#endif + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + yystos[yystate], yyvsp); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#if !defined yyoverflow || YYERROR_VERBOSE +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror (YY_((char*)"memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEMPTY) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval); + } + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + /* Make sure YYID is used. */ + return YYID (yyresult); +} + + +/* Line 2055 of yacc.c */ +#line 25 "parser.y" diff --git a/src/parser.tab.h b/src/parser.tab.h new file mode 100644 index 0000000..f5d7ed0 --- /dev/null +++ b/src/parser.tab.h @@ -0,0 +1,89 @@ +/* A Bison parser, made by GNU Bison 2.7. */ + +/* Bison interface for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* As a special exception, 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. */ + +#ifndef YY_YY_PARSER_TAB_H_INCLUDED +# define YY_YY_PARSER_TAB_H_INCLUDED +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif +#if YYDEBUG +extern int yydebug; +#endif + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + VINSTR = 258, + IMM = 259 + }; +#endif + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +{ +/* Line 2058 of yacc.c */ +#line 10 "parser.y" + +char vinstr_name[20]; +unsigned long long imm_val; + + +/* Line 2058 of yacc.c */ +#line 67 "parser.tab.h" +} YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +#endif + +extern YYSTYPE yylval; + +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + +#endif /* !YY_YY_PARSER_TAB_H_INCLUDED */ diff --git a/src/parser.y b/src/parser.y new file mode 100644 index 0000000..9ae154a --- /dev/null +++ b/src/parser.y @@ -0,0 +1,25 @@ +%{ +#include +#include "parser.h" +int yylex(void); +void yyerror(char *); +extern int yylineno; +%} + + +%union { +char vinstr_name[20]; +unsigned long long imm_val; +} + +%token VINSTR +%token IMM + +%% +PROGRAM: + VINSTR { parse_t::get_instance()->add_vinstr($1); } + | VINSTR IMM { parse_t::get_instance()->add_vinstr($1, $2); } + | PROGRAM VINSTR { parse_t::get_instance()->add_vinstr($2); } + | PROGRAM VINSTR IMM { parse_t::get_instance()->add_vinstr($2, $3); } + ; +%% \ No newline at end of file diff --git a/src/vmasm.hpp b/src/vmasm.hpp new file mode 100644 index 0000000..f017f98 --- /dev/null +++ b/src/vmasm.hpp @@ -0,0 +1,22 @@ +#pragma once +#include +#define VASM_MAGIC 'MSAV' + +namespace vmasm +{ + enum class version_t + { + v1 + }; + + struct file_header_t + { + std::uint32_t magic; // VASM + version_t version; + std::uint64_t epoch_time; + std::uint64_t alloc_rva; + std::uint64_t encrypted_rva; + std::uint32_t vasm_size; + std::uint32_t vasm_offset; + }; +} \ No newline at end of file diff --git a/src/vmassembler.vcxproj b/src/vmassembler.vcxproj new file mode 100644 index 0000000..fc01983 --- /dev/null +++ b/src/vmassembler.vcxproj @@ -0,0 +1,105 @@ + + + + + Release + x64 + + + + 16.0 + Win32Proj + {6ac977ff-bd53-4a74-8452-69b3500924e8} + vmassembler + 10.0 + + + + Application + false + v142 + true + MultiByte + + + + + + + + + + + + + false + $(ProjectDir)tools\;$(IncludePath);$(ProjectDir)vmprofiler\ + + + + Level3 + true + true + true + NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + true + stdcpp17 + + + Console + true + true + true + + + + + + + + + + + + + + + + + + false + Document + + + + + + + + + + + + + + + {e06e2e87-82b9-4dc2-a1e9-fe371cdbaac2} + + + {88a23124-5640-35a0-b890-311d7a67a7d2} + + + {d0b6092a-9944-4f24-9486-4b7dae372619} + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/vmassembler.vcxproj.filters b/src/vmassembler.vcxproj.filters new file mode 100644 index 0000000..8701b9b --- /dev/null +++ b/src/vmassembler.vcxproj.filters @@ -0,0 +1,92 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {588916a0-07de-47a7-8441-90c069dce494} + + + {f85b7642-b2f1-4e4a-b0f7-12bf32019ea5} + + + {a6446cc2-eff0-4347-89a4-e49bfb61fc97} + + + {29199b7a-1038-4779-8865-1e07e47242f1} + + + {56b7bb3b-daad-492d-a59d-7531b8aecfde} + + + {68c2cdf5-2680-4dba-9f55-1a2ca991b49f} + + + {64515351-6807-48cf-a795-ee2538e1b999} + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Grammer Files + + + + + Grammer Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + Resource Files + + + + + Resource Files + + + \ No newline at end of file diff --git a/src/win_bison.exe b/src/win_bison.exe new file mode 100644 index 0000000000000000000000000000000000000000..1dc7ee1966f8fabf5386b6a7d0624a938bd8d46d GIT binary patch literal 561152 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�q@%U#!Y>bmJ}|d_aG|RsQsA_Ewb{-z*RG{e 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 J{-6Bk{{R-66$$_V literal 0 HcmV?d00001 diff --git a/src/win_flex.exe b/src/win_flex.exe new file mode 100644 index 0000000000000000000000000000000000000000..ace8cf41e9046ba39668dd3db2ee4df4eea5638f GIT binary patch literal 564736 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¬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 literal 0 HcmV?d00001 diff --git a/vmassembler.sln b/vmassembler.sln new file mode 100644 index 0000000..0f6b3bc --- /dev/null +++ b/vmassembler.sln @@ -0,0 +1,22 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.30907.101 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vmassembler", "src\vmassembler.vcxproj", "{6AC977FF-BD53-4A74-8452-69B3500924E8}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {6AC977FF-BD53-4A74-8452-69B3500924E8}.Release|x64.ActiveCfg = Release|x64 + {6AC977FF-BD53-4A74-8452-69B3500924E8}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {BDC537F0-DE8E-4744-A03B-BD9FD0B98C60} + EndGlobalSection +EndGlobal