mirror of
https://github.com/YACReader/yacreader
synced 2025-06-03 09:08:20 -04:00
1124 lines
29 KiB
C++
1124 lines
29 KiB
C++
// generate_cpp.hpp
|
|
// Copyright (c) 2005-2018 Ben Hanson (http://www.benhanson.net/)
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
#ifndef LEXERTL_GENERATE_CPP_HPP
|
|
#define LEXERTL_GENERATE_CPP_HPP
|
|
|
|
#include "enums.hpp"
|
|
#include <sstream>
|
|
#include "state_machine.hpp"
|
|
|
|
namespace lexertl
|
|
{
|
|
class table_based_cpp
|
|
{
|
|
public:
|
|
template<typename char_type, typename id_type>
|
|
static void generate_cpp
|
|
(const std::string &name_,
|
|
const basic_state_machine<char_type, id_type> &sm_,
|
|
const bool pointers_, std::ostream &os_)
|
|
{
|
|
using sm = basic_state_machine<char_type, id_type>;
|
|
using internals = typename sm::internals;
|
|
const internals &internals_ = sm_.data();
|
|
std::size_t additional_tabs_ = 0;
|
|
|
|
os_ << "template<typename iter_type, typename id_type>\n";
|
|
os_ << "void " << name_ << " (lexertl::";
|
|
|
|
if (internals_._features & recursive_bit)
|
|
{
|
|
os_ << "recursive_match_results";
|
|
}
|
|
else
|
|
{
|
|
os_ << "match_results";
|
|
}
|
|
|
|
os_ << "<iter_type, id_type> &results_)\n";
|
|
os_ << "{\n";
|
|
os_ << " using results = lexertl::";
|
|
|
|
if (internals_._features & recursive_bit)
|
|
{
|
|
os_ << "recursive_match_results";
|
|
}
|
|
else
|
|
{
|
|
os_ << "match_results";
|
|
}
|
|
|
|
os_ << "<iter_type, id_type>;\n";
|
|
os_ << " using char_type = typename results::char_type;\n";
|
|
os_ << " typename results::iter_type end_token_ = "
|
|
"results_.second;\n";
|
|
|
|
if (internals_._features & skip_bit)
|
|
{
|
|
os_ << "skip:\n";
|
|
}
|
|
|
|
os_ << " typename results::iter_type curr_ = results_.second;\n\n";
|
|
os_ << " results_.first = curr_;\n\n";
|
|
|
|
if (internals_._features & again_bit)
|
|
{
|
|
os_ << "again:\n";
|
|
}
|
|
|
|
os_ << " if (curr_ == results_.eoi)\n";
|
|
os_ << " {\n";
|
|
// We want a number regardless of id_type.
|
|
os_ << " results_.id = " << static_cast<std::size_t>
|
|
(internals_._eoi) << ";\n";
|
|
os_ << " results_.user_id = results::npos();\n";
|
|
os_ << " return;\n";
|
|
os_ << " }\n\n";
|
|
|
|
if (internals_._features & bol_bit)
|
|
{
|
|
os_ << " bool bol_ = results_.bol;\n";
|
|
}
|
|
|
|
dump_tables(sm_, 1, pointers_, os_);
|
|
|
|
if (internals_._dfa.size() > 1)
|
|
{
|
|
os_ << " const id_type *lookup_ = lookups_[results_.state];\n";
|
|
os_ << " const id_type dfa_alphabet_ = dfa_alphabets_"
|
|
"[results_.state];\n";
|
|
os_ << " const ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "void * const";
|
|
}
|
|
else
|
|
{
|
|
os_ << "id_type";
|
|
}
|
|
|
|
os_ << " *dfa_ = dfas_[results_.state];\n";
|
|
}
|
|
|
|
os_ << " const ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "void * const";
|
|
}
|
|
else
|
|
{
|
|
os_ << "id_type";
|
|
}
|
|
|
|
os_ << " *ptr_ = dfa_ + dfa_alphabet_;\n";
|
|
os_ << " bool end_state_ = *ptr_ != 0;\n";
|
|
|
|
if (internals_._features & recursive_bit)
|
|
{
|
|
os_ << " bool pop_ = (";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*ptr_";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << ')';
|
|
}
|
|
|
|
os_ <<" & " << pop_dfa_bit;
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << ')';
|
|
}
|
|
|
|
os_ << ") != 0;\n";
|
|
}
|
|
|
|
os_ << " id_type id_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*(ptr_ + " << id_index << ")";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "))";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
os_ << " id_type uid_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*(ptr_ + " << user_id_index << ")";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "))";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
|
|
if (internals_._features & recursive_bit)
|
|
{
|
|
os_ << " id_type push_dfa_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*(ptr_ + " << push_dfa_index << ")";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "))";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
}
|
|
|
|
if (internals_._dfa.size() > 1)
|
|
{
|
|
os_ << " id_type start_state_ = results_.state;\n";
|
|
}
|
|
|
|
if (internals_._features & bol_bit)
|
|
{
|
|
os_ << " bool end_bol_ = bol_;\n";
|
|
}
|
|
|
|
if (internals_._features & eol_bit)
|
|
{
|
|
os_ << " ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "const void * const *";
|
|
}
|
|
else
|
|
{
|
|
os_ << "id_type ";
|
|
}
|
|
|
|
os_ << "EOL_state_ = 0;\n";
|
|
}
|
|
|
|
os_ << '\n';
|
|
|
|
if (internals_._features & bol_bit)
|
|
{
|
|
os_ << " if (bol_)\n";
|
|
os_ << " {\n";
|
|
os_ << " const ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "void *";
|
|
}
|
|
else
|
|
{
|
|
os_ << "id_type ";
|
|
}
|
|
|
|
os_ << "state_ = *dfa_;\n\n";
|
|
os_ << " if (state_)\n";
|
|
os_ << " {\n";
|
|
os_ << " ptr_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "reinterpret_cast<void * const *>(state_);\n";
|
|
}
|
|
else
|
|
{
|
|
os_ << "&dfa_[state_ * dfa_alphabet_];\n";
|
|
}
|
|
|
|
os_ << " }\n";
|
|
os_ << " }\n\n";
|
|
}
|
|
|
|
os_ << " while (curr_ != results_.eoi)\n";
|
|
os_ << " {\n";
|
|
|
|
if (internals_._features & eol_bit)
|
|
{
|
|
os_ << " EOL_state_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "reinterpret_cast<const void * const *>(";
|
|
}
|
|
|
|
os_ << "ptr_[" << eol_index << ']';
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << ')';
|
|
}
|
|
|
|
os_ << ";\n\n";
|
|
os_ << " if (EOL_state_ && *curr_ == '\\n')\n";
|
|
os_ << " {\n";
|
|
os_ << " ptr_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "EOL_state_";
|
|
}
|
|
else
|
|
{
|
|
os_ << "&dfa_[EOL_state_ * dfa_alphabet_]";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
os_ << " }\n";
|
|
os_ << " else\n";
|
|
os_ << " {\n";
|
|
++additional_tabs_;
|
|
}
|
|
|
|
output_char_loop(internals_._features, additional_tabs_, pointers_,
|
|
os_, std::integral_constant<bool,
|
|
(sizeof(typename sm::traits::input_char_type) > 1)>());
|
|
|
|
if (internals_._features & eol_bit)
|
|
{
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " }\n";
|
|
--additional_tabs_;
|
|
}
|
|
|
|
os_ << '\n';
|
|
os_ << " if (*ptr_)\n";
|
|
os_ << " {\n";
|
|
os_ << " end_state_ = true;\n";
|
|
|
|
|
|
if (internals_._features & recursive_bit)
|
|
{
|
|
os_ << " pop_ = (";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*ptr_";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << ')';
|
|
}
|
|
|
|
os_ <<" & " << pop_dfa_bit;
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << ')';
|
|
}
|
|
|
|
os_ << ") != 0;\n";
|
|
}
|
|
|
|
os_ << " id_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*(ptr_ + " << id_index << ")";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "))";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
os_ << " uid_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*(ptr_ + " << user_id_index << ")";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "))";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
|
|
if (internals_._features & recursive_bit)
|
|
{
|
|
os_ << " push_dfa_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*(ptr_ + " << push_dfa_index << ')';
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "))";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
}
|
|
|
|
if (internals_._dfa.size() > 1)
|
|
{
|
|
os_ << " start_state_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*(ptr_ + " << next_dfa_index << ')';
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "))";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
}
|
|
|
|
if (internals_._features & bol_bit)
|
|
{
|
|
os_ << " end_bol_ = bol_;\n";
|
|
}
|
|
|
|
os_ << " end_token_ = curr_;\n";
|
|
os_ << " }\n";
|
|
os_ << " }\n\n";
|
|
output_quit(os_, std::integral_constant<bool,
|
|
(sizeof(typename sm::traits::input_char_type) > 1)>());
|
|
|
|
if (internals_._features & eol_bit)
|
|
{
|
|
os_ << " if (curr_ == results_.eoi)\n";
|
|
os_ << " {\n";
|
|
os_ << " EOL_state_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "reinterpret_cast<const void * const *>(";
|
|
}
|
|
|
|
os_ << "ptr_[" << eol_index << ']';
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << ')';
|
|
}
|
|
|
|
os_ << ";\n";
|
|
os_ << "\n";
|
|
os_ << " if (EOL_state_)\n";
|
|
os_ << " {\n";
|
|
os_ << " ptr_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "EOL_state_";
|
|
}
|
|
else
|
|
{
|
|
os_ << "&dfa_[EOL_state_ * dfa_alphabet_]";
|
|
}
|
|
|
|
os_ << ";\n\n";
|
|
os_ << " if (*ptr_)\n";
|
|
os_ << " {\n";
|
|
os_ << " end_state_ = true;\n";
|
|
|
|
|
|
if (internals_._features & recursive_bit)
|
|
{
|
|
os_ << " pop_ = (";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*ptr_";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << ')';
|
|
}
|
|
|
|
os_ <<" & " << pop_dfa_bit;
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << ')';
|
|
}
|
|
|
|
os_ << ") != 0;\n";
|
|
}
|
|
|
|
os_ << " id_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*(ptr_ + " << id_index << ")";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "))";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
os_ << " uid_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*(ptr_ + " << user_id_index << ")";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "))";
|
|
}
|
|
|
|
os_ <<";\n";
|
|
|
|
if (internals_._features & recursive_bit)
|
|
{
|
|
os_ << " push_dfa_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*(ptr_ + " << push_dfa_index << ')';
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "))";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
}
|
|
|
|
if (internals_._dfa.size() > 1)
|
|
{
|
|
os_ << " start_state_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
// Done this way for GCC:
|
|
os_ << "static_cast<id_type>(reinterpret_cast<ptrdiff_t>(";
|
|
}
|
|
|
|
os_ << "*(ptr_ + " << next_dfa_index << ')';
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "))";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
}
|
|
|
|
if (internals_._features & bol_bit)
|
|
{
|
|
os_ << " end_bol_ = bol_;\n";
|
|
}
|
|
|
|
os_ << " end_token_ = curr_;\n";
|
|
os_ << " }\n";
|
|
os_ << " }\n";
|
|
os_ << " }\n\n";
|
|
}
|
|
|
|
os_ << " if (end_state_)\n";
|
|
os_ << " {\n";
|
|
os_ << " // Return longest match\n";
|
|
|
|
if (internals_._features & recursive_bit)
|
|
{
|
|
os_ << " if (pop_)\n";
|
|
os_ << " {\n";
|
|
os_ << " start_state_ = results_."
|
|
"stack.top().first;\n";
|
|
os_ << " results_.stack.pop();\n";
|
|
os_ << " }\n";
|
|
os_ << " else if (push_dfa_ != results_.npos())\n";
|
|
os_ << " {\n";
|
|
os_ << " results_.stack.push(typename results::"
|
|
"id_type_pair\n";
|
|
os_ << " (push_dfa_, id_));\n";
|
|
os_ << " }\n\n";
|
|
}
|
|
|
|
if (internals_._dfa.size() > 1)
|
|
{
|
|
os_ << " results_.state = start_state_;\n";
|
|
}
|
|
|
|
if (internals_._features & bol_bit)
|
|
{
|
|
os_ << " results_.bol = end_bol_;\n";
|
|
}
|
|
|
|
os_ << " results_.second = end_token_;\n";
|
|
|
|
if (internals_._features & skip_bit)
|
|
{
|
|
// We want a number regardless of id_type.
|
|
os_ << "\n if (id_ == results_.skip()) goto skip;\n";
|
|
}
|
|
|
|
if (internals_._features & again_bit)
|
|
{
|
|
// We want a number regardless of id_type.
|
|
os_ << "\n if (id_ == "
|
|
<< static_cast<std::size_t>(internals_._eoi);
|
|
|
|
if (internals_._features & recursive_bit)
|
|
{
|
|
os_ << " || (pop_ && !results_.stack.empty() &&\n";
|
|
// We want a number regardless of id_type.
|
|
os_ << " results_.stack.top().second == "
|
|
<< static_cast<std::size_t>(internals_._eoi) << ')';
|
|
}
|
|
|
|
os_ << ")\n";
|
|
os_ << " {\n";
|
|
os_ << " curr_ = end_token_;\n";
|
|
os_ << " goto again;\n";
|
|
os_ << " }\n";
|
|
}
|
|
|
|
os_ << " }\n";
|
|
os_ << " else\n";
|
|
os_ << " {\n";
|
|
os_ << " // No match causes char to be skipped\n";
|
|
os_ << " results_.second = end_token_;\n";
|
|
|
|
if (internals_._features & bol_bit)
|
|
{
|
|
os_ << " results_.bol = *results_.second == '\\n';\n";
|
|
}
|
|
|
|
os_ << " results_.first = results_.second;\n";
|
|
os_ << " ++results_.second;\n";
|
|
os_ << " id_ = results::npos();\n";
|
|
os_ << " uid_ = results::npos();\n";
|
|
os_ << " }\n\n";
|
|
os_ << " results_.id = id_;\n";
|
|
os_ << " results_.user_id = uid_;\n";
|
|
os_ << "}\n";
|
|
}
|
|
|
|
template<typename char_type, typename id_type>
|
|
static void dump_tables
|
|
(const basic_state_machine<char_type, id_type> &sm_,
|
|
const std::size_t tabs_, const bool pointers_, std::ostream &os_)
|
|
{
|
|
const typename detail::basic_internals<id_type> &internals_ =
|
|
sm_.data();
|
|
const std::size_t lookup_divisor_ = 8;
|
|
// Lookup is always 256 entries long now
|
|
const std::size_t lookup_quotient_ = 256 / lookup_divisor_;
|
|
const std::size_t dfas_ = internals_._lookup.size();
|
|
|
|
output_tabs(tabs_, os_);
|
|
os_ << "static const id_type lookup";
|
|
|
|
if (dfas_ > 1)
|
|
{
|
|
os_ << "s_[][" << 256;
|
|
}
|
|
else
|
|
{
|
|
os_ << "_[";
|
|
}
|
|
|
|
os_ << "] = \n";
|
|
output_tabs(tabs_ + 1, os_);
|
|
|
|
if (dfas_ > 1)
|
|
{
|
|
os_ << '{';
|
|
}
|
|
|
|
for (std::size_t l_ = 0; l_ < dfas_; ++l_)
|
|
{
|
|
const id_type *ptr_ = &internals_._lookup[l_].front();
|
|
|
|
// We want numbers regardless of id_type.
|
|
os_ << "{0x" << std::hex << static_cast<std::size_t>(*ptr_++);
|
|
|
|
for (std::size_t col_ = 1; col_ < lookup_divisor_; ++col_)
|
|
{
|
|
// We want numbers regardless of id_type.
|
|
os_ << ", 0x" << std::hex << static_cast<std::size_t>(*ptr_++);
|
|
}
|
|
|
|
for (std::size_t row_ = 1; row_ < lookup_quotient_; ++row_)
|
|
{
|
|
os_ << ",\n";
|
|
output_tabs(tabs_ + 1, os_);
|
|
// We want numbers regardless of id_type.
|
|
os_ << "0x" << std::hex << static_cast<std::size_t>(*ptr_++);
|
|
|
|
for (std::size_t col_ = 1; col_ < lookup_divisor_; ++col_)
|
|
{
|
|
// We want numbers regardless of id_type.
|
|
os_ << ", 0x" << std::hex <<
|
|
static_cast<std::size_t>(*ptr_++);
|
|
}
|
|
}
|
|
|
|
os_ << '}';
|
|
|
|
if (l_ + 1 < dfas_)
|
|
{
|
|
os_ << ",\n";
|
|
output_tabs(tabs_ + 1, os_);
|
|
}
|
|
}
|
|
|
|
if (dfas_ > 1)
|
|
{
|
|
os_ << '}';
|
|
}
|
|
|
|
os_ << ";\n";
|
|
output_tabs(tabs_, os_);
|
|
os_ << "static const id_type dfa_alphabet";
|
|
|
|
if (dfas_ > 1)
|
|
{
|
|
os_ << "s_[" << std::dec << dfas_ << "] = {";
|
|
}
|
|
else
|
|
{
|
|
os_ << "_ = ";
|
|
}
|
|
|
|
// We want numbers regardless of id_type.
|
|
os_ << "0x" << std::hex << static_cast<std::size_t>
|
|
(internals_._dfa_alphabet[0]);
|
|
|
|
for (std::size_t col_ = 1; col_ < dfas_; ++col_)
|
|
{
|
|
// We want numbers regardless of id_type.
|
|
os_ << ", 0x" << std::hex << static_cast<std::size_t>(internals_.
|
|
_dfa_alphabet[col_]);
|
|
}
|
|
|
|
if (dfas_ > 1)
|
|
{
|
|
os_ << '}';
|
|
}
|
|
|
|
os_ << ";\n";
|
|
|
|
// DFAs are usually different sizes, so dump separately
|
|
for (std::size_t dfa_ = 0; dfa_ < dfas_; ++dfa_)
|
|
{
|
|
const id_type dfa_alphabet_ = internals_._dfa_alphabet[dfa_];
|
|
const std::size_t rows_ = internals_._dfa[dfa_].size() /
|
|
dfa_alphabet_;
|
|
const id_type *ptr_ = &internals_._dfa[dfa_].front();
|
|
std::string dfa_name_ = "dfa";
|
|
|
|
output_tabs(tabs_, os_);
|
|
os_ << "static const ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "void *";
|
|
}
|
|
else
|
|
{
|
|
os_ << "id_type ";
|
|
}
|
|
|
|
os_ << dfa_name_;
|
|
|
|
if (dfas_ > 1)
|
|
{
|
|
std::ostringstream ss_;
|
|
|
|
ss_ << dfa_;
|
|
dfa_name_ += ss_.str();
|
|
os_ << dfa_;
|
|
}
|
|
|
|
dfa_name_ += '_';
|
|
os_ << "_[] = {";
|
|
|
|
for (std::size_t row_ = 0; row_ < rows_; ++row_)
|
|
{
|
|
dump_row(row_ == 0, ptr_, dfa_name_, dfa_alphabet_,
|
|
pointers_, os_);
|
|
|
|
if (row_ + 1 < rows_)
|
|
{
|
|
os_ << ",\n";
|
|
output_tabs(tabs_ + 1, os_);
|
|
}
|
|
}
|
|
|
|
os_ << "};\n";
|
|
}
|
|
|
|
if (dfas_ > 1)
|
|
{
|
|
output_tabs(tabs_, os_);
|
|
os_ << "static const ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "void * const";
|
|
}
|
|
else
|
|
{
|
|
os_ << "id_type";
|
|
}
|
|
|
|
os_ << " *dfas_[] = {dfa0_";
|
|
|
|
for (std::size_t col_ = 1; col_ < dfas_; ++col_)
|
|
{
|
|
os_ << ", dfa" << col_ << '_';
|
|
}
|
|
|
|
os_ << "};\n";
|
|
}
|
|
|
|
os_ << std::dec;
|
|
}
|
|
|
|
protected:
|
|
template<typename id_type>
|
|
static void dump_row(const bool first_, const id_type * &ptr_,
|
|
const std::string &dfa_name_, const id_type dfa_alphabet_,
|
|
const bool pointers_, std::ostream &os_)
|
|
{
|
|
if (pointers_)
|
|
{
|
|
bool zero_ = *ptr_ == 0;
|
|
|
|
if (first_)
|
|
{
|
|
// We want numbers regardless of id_type.
|
|
os_ << dfa_name_ << " + 0x" << std::hex <<
|
|
static_cast<std::size_t>(*ptr_++) * dfa_alphabet_;
|
|
}
|
|
else if (!zero_)
|
|
{
|
|
os_ << "reinterpret_cast<const void *>(0x"
|
|
// We want numbers regardless of id_type.
|
|
<< std::hex << static_cast<std::size_t>(*ptr_++) << ')';
|
|
}
|
|
else
|
|
{
|
|
// We want numbers regardless of id_type.
|
|
os_ << "0x" << std::hex << static_cast<std::size_t>(*ptr_++);
|
|
}
|
|
|
|
for (id_type id_index_ = id_index; id_index_ < transitions_index;
|
|
++id_index_, ++ptr_)
|
|
{
|
|
os_ << ", ";
|
|
zero_ = *ptr_ == 0;
|
|
|
|
if (!zero_)
|
|
{
|
|
os_ << "reinterpret_cast<const void *>(";
|
|
}
|
|
|
|
// We want numbers regardless of id_type.
|
|
os_ << "0x" << std::hex << static_cast<std::size_t>(*ptr_);
|
|
|
|
if (!zero_)
|
|
{
|
|
os_ << ')';
|
|
}
|
|
}
|
|
|
|
for (id_type alphabet_ = transitions_index;
|
|
alphabet_ < dfa_alphabet_; ++alphabet_, ++ptr_)
|
|
{
|
|
// We want numbers regardless of id_type.
|
|
os_ << ", ";
|
|
|
|
if (*ptr_ == 0)
|
|
{
|
|
os_ << 0;
|
|
}
|
|
else
|
|
{
|
|
// We want numbers regardless of id_type.
|
|
os_ << dfa_name_ + " + 0x" << std::hex <<
|
|
static_cast<std::size_t>(*ptr_) * dfa_alphabet_;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We want numbers regardless of id_type.
|
|
os_ << "0x" << std::hex << static_cast<std::size_t>(*ptr_++);
|
|
|
|
for (id_type alphabet_ = 1; alphabet_ < dfa_alphabet_;
|
|
++alphabet_, ++ptr_)
|
|
{
|
|
// We want numbers regardless of id_type.
|
|
os_ << ", 0x" << std::hex << static_cast<std::size_t>(*ptr_);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void output_tabs(const std::size_t tabs_, std::ostream &os_)
|
|
{
|
|
for (std::size_t i_ = 0; i_ < tabs_; ++i_)
|
|
{
|
|
os_ << " ";
|
|
}
|
|
}
|
|
|
|
template<typename id_type>
|
|
static void output_char_loop(const id_type features_,
|
|
const std::size_t additional_tabs_, const bool pointers_,
|
|
std::ostream &os_, const std::false_type &)
|
|
{
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " const typename results::char_type prev_char_ = "
|
|
"*curr_++;\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " const ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "void * const *";
|
|
}
|
|
else
|
|
{
|
|
os_ << "id_type ";
|
|
}
|
|
|
|
os_ << "state_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "reinterpret_cast<void * const *>\n ";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << '(';
|
|
}
|
|
|
|
os_ << "ptr_[lookup_";
|
|
|
|
if (!pointers_)
|
|
{
|
|
os_ << "\n ";
|
|
output_tabs(additional_tabs_, os_);
|
|
}
|
|
|
|
os_ << "[static_cast<typename results::index_type>";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "\n ";
|
|
output_tabs(additional_tabs_, os_);
|
|
}
|
|
|
|
os_ << "(prev_char_)]]";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << ')';
|
|
}
|
|
|
|
os_ << ";\n\n";
|
|
|
|
if (features_ & bol_bit)
|
|
{
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " bol_ = prev_char_ == '\\n';\n\n";
|
|
}
|
|
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " if (state_ == 0)\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " {\n";
|
|
|
|
if (features_ & eol_bit)
|
|
{
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " EOL_state_ = 0;\n";
|
|
}
|
|
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " break;\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " }\n\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " ptr_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "state_";
|
|
}
|
|
else
|
|
{
|
|
os_ << "&dfa_[state_ * dfa_alphabet_]";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
}
|
|
|
|
template<typename id_type>
|
|
static void output_char_loop(const id_type features_,
|
|
const std::size_t additional_tabs_, const bool pointers_,
|
|
std::ostream &os_, const std::true_type &)
|
|
{
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " const std::size_t bytes_ =\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " sizeof(typename results::char_type) < 3 ?\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " sizeof(typename results::char_type) : 3;\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " const std::size_t shift_[] = {0, 8, 16};\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " typename results::char_type prev_char_ = "
|
|
"*curr_++;\n\n";
|
|
|
|
if (features_ & bol_bit)
|
|
{
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " bol_ = prev_char_ == '\\n';\n\n";
|
|
}
|
|
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " for (std::size_t i_ = 0; i_ < bytes_; ++i_)\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " {\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " const ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "void * const *";
|
|
}
|
|
else
|
|
{
|
|
os_ << "id_type ";
|
|
}
|
|
|
|
os_ << "state_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "reinterpret_cast<void * const *>\n ";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << '(';
|
|
}
|
|
|
|
os_ << "ptr_[lookup_[static_cast\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " <unsigned char>((prev_char_ >>\n"
|
|
" shift_[bytes_ - 1 - i_]) & 0xff)]]";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << ')';
|
|
}
|
|
|
|
os_ << ";\n\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " if (state_ == 0)\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " {\n";
|
|
|
|
if (features_ & eol_bit)
|
|
{
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " EOL_state_ = 0;\n";
|
|
}
|
|
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " goto quit;\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " }\n\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " ptr_ = ";
|
|
|
|
if (pointers_)
|
|
{
|
|
os_ << "state_";
|
|
}
|
|
else
|
|
{
|
|
os_ << "&dfa_[state_ * dfa_alphabet_]";
|
|
}
|
|
|
|
os_ << ";\n";
|
|
output_tabs(additional_tabs_, os_);
|
|
os_ << " }\n";
|
|
}
|
|
|
|
static void output_quit(std::ostream &, const std::false_type &)
|
|
{
|
|
// Nothing to do
|
|
}
|
|
|
|
static void output_quit(std::ostream &os_, const std::true_type &)
|
|
{
|
|
os_ << "quit:\n";
|
|
}
|
|
};
|
|
}
|
|
|
|
#endif
|