diff options
Diffstat (limited to 'src/boost/libs/wave/samples')
90 files changed, 24678 insertions, 0 deletions
diff --git a/src/boost/libs/wave/samples/Jamfile.v2 b/src/boost/libs/wave/samples/Jamfile.v2 new file mode 100644 index 00000000..2df785dc --- /dev/null +++ b/src/boost/libs/wave/samples/Jamfile.v2 @@ -0,0 +1,21 @@ +# Copyright Vladimir Prus 2004. +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt +# or copy at http://www.boost.org/LICENSE_1_0.txt) + +project + : requirements <hardcode-dll-paths>true + ; + +build-project advanced_hooks/build ; +build-project cpp_tokens/build ; +build-project lexed_tokens/build ; +build-project list_includes/build ; +build-project quick_start/build ; +build-project waveidl/build ; +build-project hannibal/build ; +build-project real_positions/build ; +build-project token_statistics/build ; +build-project preprocess_pragma_output/build ; +build-project custom_directives/build ; +build-project emit_custom_line_directives/build ; diff --git a/src/boost/libs/wave/samples/advanced_hooks/advanced_hooks.cpp b/src/boost/libs/wave/samples/advanced_hooks/advanced_hooks.cpp new file mode 100644 index 00000000..37fdbef2 --- /dev/null +++ b/src/boost/libs/wave/samples/advanced_hooks/advanced_hooks.cpp @@ -0,0 +1,124 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Sample demonstrating the usage of advanced preprocessor hooks. + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <iostream> +#include <fstream> +#include <string> +#include <vector> + +/////////////////////////////////////////////////////////////////////////////// +// Include Wave itself +#include <boost/wave.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include the lexer stuff +#include <boost/wave/cpplexer/cpp_lex_token.hpp> // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer class + +#include "advanced_hooks.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// Main entry point +// +// This sample shows how to use the advanced hooks to output not only the +// preprocessed tokens but also the conditional directives found in the input +// file (these are commented out, tough) and the tokens from inside the +// conditional block which were not evaluated because the corresponding +// condition was false. These tokens are commented out as well. +// +int main(int argc, char *argv[]) +{ + if (2 != argc) { + std::cerr << "Usage: advanced_hooks infile" << std::endl; + return -1; + } + +// current file position is saved for exception handling +boost::wave::util::file_position_type current_position; + + try { + // Open and read in the specified input file. + std::ifstream instream(argv[1]); + std::string instring; + + if (!instream.is_open()) { + std::cerr << "Could not open input file: " << argv[1] << std::endl; + return -2; + } + instream.unsetf(std::ios::skipws); + instring = std::string(std::istreambuf_iterator<char>(instream.rdbuf()), + std::istreambuf_iterator<char>()); + + // The template boost::wave::cpplexer::lex_token<> is the token type to be + // used by the Wave library. + typedef boost::wave::cpplexer::lex_token<> token_type; + + // The template boost::wave::cpplexer::lex_iterator<> is the lexer type to + // be used by the Wave library. + typedef boost::wave::cpplexer::lex_iterator<token_type> lex_iterator_type; + + // This is the resulting context type to use. The first template parameter + // should match the iterator type to be used during construction of the + // corresponding context object (see below). + typedef boost::wave::context<std::string::iterator, lex_iterator_type, + boost::wave::iteration_context_policies::load_file_to_string, + advanced_preprocessing_hooks + > context_type; + + // The preprocessor iterator shouldn't be constructed directly. It is + // to be generated through a wave::context<> object. This wave:context<> + // object additionally may be used to initialize and define different + // parameters of the actual preprocessing (not done here). + // + // The preprocessing of the input stream is done on the fly behind the + // scenes during iteration over the context_type::iterator_type stream. + context_type ctx (instring.begin(), instring.end(), argv[1]); + + ctx.set_language(boost::wave::enable_long_long(ctx.get_language())); + ctx.set_language(boost::wave::enable_preserve_comments(ctx.get_language())); + ctx.set_language(boost::wave::enable_prefer_pp_numbers(ctx.get_language())); + + // analyze the input file, print out the preprocessed tokens + context_type::iterator_type first = ctx.begin(); + context_type::iterator_type last = ctx.end(); + + while (first != last) { + current_position = (*first).get_position(); + std::cout << (*first).get_value(); + ++first; + } + } + catch (boost::wave::cpp_exception const& e) { + // some preprocessing error + std::cerr + << e.file_name() << "(" << e.line_no() << "): " + << e.description() << std::endl; + return 2; + } + catch (std::exception const& e) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "exception caught: " << e.what() + << std::endl; + return 3; + } + catch (...) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "unexpected exception caught." << std::endl; + return 4; + } + return 0; +} diff --git a/src/boost/libs/wave/samples/advanced_hooks/advanced_hooks.hpp b/src/boost/libs/wave/samples/advanced_hooks/advanced_hooks.hpp new file mode 100644 index 00000000..c779c0a0 --- /dev/null +++ b/src/boost/libs/wave/samples/advanced_hooks/advanced_hooks.hpp @@ -0,0 +1,167 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(BOOST_WAVE_ADVANCED_PREPROCESSING_HOOKS_INCLUDED) +#define BOOST_WAVE_ADVANCED_PREPROCESSING_HOOKS_INCLUDED + +#include <cstdio> +#include <ostream> +#include <string> + +#include <boost/assert.hpp> +#include <boost/config.hpp> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/util/macro_helpers.hpp> +#include <boost/wave/preprocessing_hooks.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// The advanced_preprocessing_hooks policy class is used to register some +// of the more advanced (and probably more rarely used hooks with the Wave +// library. +// +// This policy type is used as a template parameter to the boost::wave::context<> +// object. +// +/////////////////////////////////////////////////////////////////////////////// +class advanced_preprocessing_hooks +: public boost::wave::context_policies::default_preprocessing_hooks +{ +public: + advanced_preprocessing_hooks() : need_comment(true) {} + + /////////////////////////////////////////////////////////////////////////// + // + // The function 'found_directive' is called, whenever a preprocessor + // directive was encountered, but before the corresponding action is + // executed. + // + // The parameter 'ctx' is a reference to the context object used for + // instantiating the preprocessing iterators by the user. + // + // The parameter 'directive' is a reference to the token holding the + // preprocessing directive. + // + /////////////////////////////////////////////////////////////////////////// +#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0 + template <typename TokenT> + void + found_directive(TokenT const& directive) +#else + template <typename ContextT, typename TokenT> + bool + found_directive(ContextT const& ctx, TokenT const& directive) +#endif + { + // print the commented conditional directives + using namespace boost::wave; + token_id id = token_id(directive); + switch (id) { + case T_PP_IFDEF: + case T_PP_IFNDEF: + case T_PP_IF: + case T_PP_ELIF: + std::cout << "// " << directive.get_value() << " "; + need_comment = false; + break; + + case T_PP_ELSE: + case T_PP_ENDIF: + std::cout << "// " << directive.get_value() << std::endl; + need_comment = true; + break; + + default: + break; + } + +#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS == 0 + return false; +#endif + } + + /////////////////////////////////////////////////////////////////////////// + // + // The function 'evaluated_conditional_expression' is called, whenever a + // conditional preprocessing expression was evaluated (the expression + // given to a #if, #elif, #ifdef or #ifndef directive) + // + // The parameter 'ctx' is a reference to the context object used for + // instantiating the preprocessing iterators by the user. + // + // The parameter 'expression' holds the non-expanded token sequence + // comprising the evaluated expression. + // + // The parameter expression_value contains the result of the evaluation of + // the expression in the current preprocessing context. + // + // The return value defines, whether the given expression has to be + // evaluated again, allowing to decide which of the conditional branches + // should be expanded. You need to return 'true' from this hook function + // to force the expression to be re-evaluated. + // + /////////////////////////////////////////////////////////////////////////// +#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0 + template <typename ContainerT> + bool + evaluated_conditional_expression( + ContainerT const& expression, bool expression_value) +#else + template <typename ContextT, typename TokenT, typename ContainerT> + bool + evaluated_conditional_expression(ContextT const &ctx, + TokenT const& directive, ContainerT const& expression, + bool expression_value) +#endif + { + // print the conditional expressions + std::cout << boost::wave::util::impl::as_string(expression) << std::endl; + need_comment = true; + return false; // ok to continue, do not re-evaluate expression + } + + /////////////////////////////////////////////////////////////////////////// + // + // The function 'skipped_token' is called, whenever a token is about to be + // skipped due to a false preprocessor condition (code fragments to be + // skipped inside the not evaluated conditional #if/#else/#endif branches). + // + // The parameter 'ctx' is a reference to the context object used for + // instantiating the preprocessing iterators by the user. + // + // The parameter 'token' refers to the token to be skipped. + // + /////////////////////////////////////////////////////////////////////////// +#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0 + template <typename TokenT> + void + skipped_token(TokenT const& token) +#else + template <typename ContextT, typename TokenT> + void + skipped_token(ContextT const& ctx, TokenT const& token) +#endif + { + // prepend a comment at the beginning of all skipped lines + using namespace boost::wave; + if (need_comment && token_id(token) != T_SPACE) { + std::cout << "// "; + need_comment = false; + } + std::cout << token.get_value(); + if (token_id(token) == T_NEWLINE || token_id(token) == T_CPPCOMMENT) + need_comment = true; + } + +private: + bool need_comment; +}; + +#endif // !defined(BOOST_WAVE_ADVANCED_PREPROCESSING_HOOKS_INCLUDED) diff --git a/src/boost/libs/wave/samples/advanced_hooks/build/Jamfile.v2 b/src/boost/libs/wave/samples/advanced_hooks/build/Jamfile.v2 new file mode 100644 index 00000000..aa0204b2 --- /dev/null +++ b/src/boost/libs/wave/samples/advanced_hooks/build/Jamfile.v2 @@ -0,0 +1,17 @@ +# Boost.Wave: A Standard compliant C++ preprocessor library +# +# Boost Wave Library Sample Build Jamfile (advanced_hooks) +# +# http://www.boost.org/ +# +# Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost +# Software License, Version 1.0. (See accompanying file +# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +exe advanced_hooks + : ../advanced_hooks.cpp + /boost/wave//boost_wave + /boost/thread//boost_thread + /boost/date_time//boost_date_time + ; + diff --git a/src/boost/libs/wave/samples/cpp_tokens/build/Jamfile.v2 b/src/boost/libs/wave/samples/cpp_tokens/build/Jamfile.v2 new file mode 100644 index 00000000..597c897d --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/build/Jamfile.v2 @@ -0,0 +1,38 @@ +# Boost.Wave: A Standard compliant C++ preprocessor library +# +# Boost Wave Library Sample Build Jamfile (cpp_tokens) +# +# http://www.boost.org/ +# +# Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost +# Software License, Version 1.0. (See accompanying file +# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +SOURCES = + ../cpp_tokens + ../instantiate_cpp_exprgrammar + ../instantiate_cpp_grammar + ../instantiate_cpp_literalgrs + ../instantiate_defined_grammar + ../instantiate_slex_lexer + ; + +exe cpp_tokens + : + $(SOURCES) + /boost/wave//boost_wave + /boost/program_options//boost_program_options + /boost/filesystem//boost_filesystem + /boost/system//boost_system + /boost/thread//boost_thread + /boost/date_time//boost_date_time + ; + +for local source in $(SOURCES) +{ + local requirements ; + # workaround for compiler bug + requirements += <toolset-msvc:version>7.1:<rtti>off ; + requirements += <toolset-msvc:version>7.1_stlport4:<rtti>off ; + obj $(source) : $(source).cpp : $(requirements) ; +} diff --git a/src/boost/libs/wave/samples/cpp_tokens/cpp_tokens.cpp b/src/boost/libs/wave/samples/cpp_tokens/cpp_tokens.cpp new file mode 100644 index 00000000..5e8ff5ed --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/cpp_tokens.cpp @@ -0,0 +1,140 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: Print out the preprocessed tokens returned by the Wave iterator + + This sample shows, how it is possible to use a custom lexer type and a + custom token type with the Wave library. + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "cpp_tokens.hpp" // global configuration + +/////////////////////////////////////////////////////////////////////////////// +// Include Wave itself +#include <boost/wave.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// The following files contain the custom lexer type to use +#include "slex_token.hpp" +#include "slex_iterator.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// include lexer specifics, import lexer names +#if !defined(BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION) +#include "slex/cpp_slex_lexer.hpp" +#endif // !defined(BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION) + +/////////////////////////////////////////////////////////////////////////////// +// import required names +using namespace boost::spirit::classic; + +using std::string; +using std::getline; +using std::ifstream; +using std::cout; +using std::cerr; +using std::endl; +using std::ostream; + +/////////////////////////////////////////////////////////////////////////////// +// main program +int +main(int argc, char *argv[]) +{ + if (2 != argc) { + cout << "Usage: cpp_tokens input_file" << endl; + return 1; + } + +// read the file to analyse into a std::string + ifstream infile(argv[1]); + string teststr; + if (infile.is_open()) { + infile.unsetf(std::ios::skipws); +#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) + // this is known to be very slow for large files on some systems + copy (std::istream_iterator<char>(infile), + std::istream_iterator<char>(), + std::inserter(teststr, teststr.end())); +#else + teststr = std::string(std::istreambuf_iterator<char>(infile.rdbuf()), + std::istreambuf_iterator<char>()); +#endif + } + else { + teststr = argv[1]; + } + +// The following typedef does the trick. It defines the context type to use, +// which depends on the lexer type (provided by the second template +// parameter). Our lexer type 'slex_iterator<>' depends on a custom token type +// 'slex_token<>'. Our custom token type differs from the original one provided +// by the Wave library only by defining an additional operator<<(), which is +// used to dump the token information carried by a given token (see loop +// below). + typedef boost::wave::cpplexer::slex_token<> token_type; + typedef boost::wave::cpplexer::slex::slex_iterator<token_type> lexer_type; + typedef boost::wave::context<std::string::iterator, lexer_type> + context_type; + +// The C++ preprocessor iterator shouldn't be constructed directly. It is to be +// generated through a boost::wave::context<> object. This object is +// additionally to be used to initialize and define different parameters of +// the actual preprocessing. +// The preprocessing of the input stream is done on the fly behind the scenes +// during iteration over the context_type::iterator_type stream. + context_type ctx (teststr.begin(), teststr.end(), argv[1]); + + ctx.set_language(boost::wave::support_cpp0x); + ctx.set_language(boost::wave::enable_preserve_comments(ctx.get_language())); + ctx.set_language(boost::wave::enable_prefer_pp_numbers(ctx.get_language())); + ctx.set_language(boost::wave::enable_emit_contnewlines(ctx.get_language())); + + context_type::iterator_type first = ctx.begin(); + context_type::iterator_type last = ctx.end(); + context_type::token_type current_token; + + try { + // Traverse over the tokens generated from the input and dump the token + // contents. + while (first != last) { + // retrieve next token + current_token = *first; + + // output token info + cout << "matched " << current_token << endl; + ++first; + } + } + catch (boost::wave::cpp_exception const& e) { + // some preprocessing error + cerr + << e.file_name() << "(" << e.line_no() << "): " + << e.description() << endl; + return 2; + } + catch (std::exception const& e) { + // use last recognized token to retrieve the error position + cerr + << current_token.get_position().get_file() + << "(" << current_token.get_position().get_line() << "): " + << "unexpected exception: " << e.what() + << endl; + return 3; + } + catch (...) { + // use last recognized token to retrieve the error position + cerr + << current_token.get_position().get_file() + << "(" << current_token.get_position().get_line() << "): " + << "unexpected exception." << endl; + return 4; + } + return 0; +} diff --git a/src/boost/libs/wave/samples/cpp_tokens/cpp_tokens.hpp b/src/boost/libs/wave/samples/cpp_tokens/cpp_tokens.hpp new file mode 100644 index 00000000..092c01e4 --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/cpp_tokens.hpp @@ -0,0 +1,38 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: Print out the preprocessed tokens returned by the Wave iterator + + This sample shows, how it is possible to use a custom lexer object and a + custom token type with the Wave library. + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(CPP_TOKENS_HPP_D6A31137_CE14_4869_9779_6357E2C43187_INCLUDED) +#define CPP_TOKENS_HPP_D6A31137_CE14_4869_9779_6357E2C43187_INCLUDED + +/////////////////////////////////////////////////////////////////////////////// +// include often used files from the stdlib +#include <iostream> +#include <fstream> +#include <string> + +/////////////////////////////////////////////////////////////////////////////// +// include boost config +#include <boost/config.hpp> // global configuration information + +/////////////////////////////////////////////////////////////////////////////// +// configure this app here (global configuration constants) +#include "cpp_tokens_config.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// include required boost libraries +#include <boost/assert.hpp> +#include <boost/pool/pool_alloc.hpp> + +#endif // !defined(CPP_TOKENS_HPP_D6A31137_CE14_4869_9779_6357E2C43187_INCLUDED) diff --git a/src/boost/libs/wave/samples/cpp_tokens/cpp_tokens_config.hpp b/src/boost/libs/wave/samples/cpp_tokens/cpp_tokens_config.hpp new file mode 100644 index 00000000..80fa5ac2 --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/cpp_tokens_config.hpp @@ -0,0 +1,55 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: Print out the preprocessed tokens returned by the Wave iterator + Configuration data + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(CPP_TOKENS_HPP_7C0F1F14_6ACA_4439_A073_32C61C0DB6C5_INCLUDED) +#define CPP_TOKENS_HPP_7C0F1F14_6ACA_4439_A073_32C61C0DB6C5_INCLUDED + +/////////////////////////////////////////////////////////////////////////////// +// Uncomment the following, if you need debug output, the +// BOOST_SPIRIT_DEBUG_FLAGS constants below help to fine control the amount of +// the generated debug output +//#define BOOST_SPIRIT_DEBUG + +#if defined(BOOST_SPIRIT_DEBUG) +/////////////////////////////////////////////////////////////////////////////// +// debug flags for the pp-iterator library, possible flags (defined in +// wave_config.hpp): +// +// #define BOOST_SPIRIT_DEBUG_FLAGS_CPP_GRAMMAR 0x0001 +// #define BOOST_SPIRIT_DEBUG_FLAGS_TIME_CONVERSION 0x0002 +// #define BOOST_SPIRIT_DEBUG_FLAGS_CPP_EXPR_GRAMMAR 0x0004 +// #define BOOST_SPIRIT_DEBUG_FLAGS_INTLIT_GRAMMAR 0x0008 +// #define BOOST_SPIRIT_DEBUG_FLAGS_CHLIT_GRAMMAR 0x0010 +// #define BOOST_SPIRIT_DEBUG_FLAGS_DEFINED_GRAMMAR 0x0020 +// #define BOOST_SPIRIT_DEBUG_FLAGS_PREDEF_MACROS_GRAMMAR 0x0040 + +#define BOOST_SPIRIT_DEBUG_FLAGS_CPP (\ + /* insert the required flags from above */ \ + ) \ + /**/ +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Include the configuration stuff for the Wave library itself +#include <boost/wave/wave_config.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// MSVC specific #pragma's +#if defined(BOOST_MSVC) +#pragma warning (disable: 4355) // 'this' used in base member initializer list +#pragma warning (disable: 4800) // forcing value to bool 'true' or 'false' +#pragma inline_depth(255) +#pragma inline_recursion(on) +#endif // defined(BOOST_MSVC) + +#endif // !defined(CPP_TOKENS_HPP_7C0F1F14_6ACA_4439_A073_32C61C0DB6C5_INCLUDED) diff --git a/src/boost/libs/wave/samples/cpp_tokens/instantiate_cpp_exprgrammar.cpp b/src/boost/libs/wave/samples/cpp_tokens/instantiate_cpp_exprgrammar.cpp new file mode 100644 index 00000000..0c4fa129 --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/instantiate_cpp_exprgrammar.cpp @@ -0,0 +1,42 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: prints out the preprocessed tokens returned by the pp iterator + Explicit instantiation of the cpp_expression_grammar parsing + function + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "cpp_tokens.hpp" // config data + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> + +#include "slex_token.hpp" +#include "slex_iterator.hpp" + +#include <boost/wave/grammars/cpp_expression_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the expression_grammar_gen template with the +// correct token type. This instantiates the corresponding parse function, +// which in turn instantiates the expression_grammar object (see +// wave/grammars/cpp_expression_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::cpplexer::slex_token<> token_type; + +template struct boost::wave::grammars::expression_grammar_gen<token_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/cpp_tokens/instantiate_cpp_grammar.cpp b/src/boost/libs/wave/samples/cpp_tokens/instantiate_cpp_grammar.cpp new file mode 100644 index 00000000..5781f83d --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/instantiate_cpp_grammar.cpp @@ -0,0 +1,45 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: prints out the preprocessed tokens returned by the pp iterator + Explicit instantiation of the cpp_grammar parsing function + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "cpp_tokens.hpp" // config data + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> +#include <list> + +#include <boost/wave/token_ids.hpp> + +#include "slex_token.hpp" +#include "slex_iterator.hpp" + +#include <boost/wave/grammars/cpp_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the cpp_grammar_gen template with the correct +// token type. This instantiates the corresponding pt_parse function, which +// in turn instantiates the cpp_grammar object +// (see wave/grammars/cpp_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::cpplexer::slex_token<> token_type; +typedef boost::wave::cpplexer::slex::slex_iterator<token_type> lexer_type; +typedef std::list<token_type, boost::fast_pool_allocator<token_type> > + token_sequence_type; + +template struct boost::wave::grammars::cpp_grammar_gen<lexer_type, token_sequence_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/cpp_tokens/instantiate_cpp_literalgrs.cpp b/src/boost/libs/wave/samples/cpp_tokens/instantiate_cpp_literalgrs.cpp new file mode 100644 index 00000000..48758679 --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/instantiate_cpp_literalgrs.cpp @@ -0,0 +1,47 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: prints out the preprocessed tokens returned by the pp iterator + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "cpp_tokens.hpp" // config data + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> + +#include "slex_token.hpp" +#include "slex_iterator.hpp" + +#include <boost/wave/grammars/cpp_literal_grammar_gen.hpp> +#include <boost/wave/grammars/cpp_intlit_grammar.hpp> +#include <boost/wave/grammars/cpp_chlit_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the intlit_grammar_gen, chlit_grammar_gen and +// floatlit_grammar_gen templates with the correct token type. This +// instantiates the corresponding parse function, which in turn instantiates +// the corresponding parser object. +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::cpplexer::slex_token<> token_type; + +template struct boost::wave::grammars::intlit_grammar_gen<token_type>; +#if BOOST_WAVE_WCHAR_T_SIGNEDNESS == BOOST_WAVE_WCHAR_T_AUTOSELECT || \ + BOOST_WAVE_WCHAR_T_SIGNEDNESS == BOOST_WAVE_WCHAR_T_FORCE_SIGNED +template struct boost::wave::grammars::chlit_grammar_gen<int, token_type>; +#endif +template struct boost::wave::grammars::chlit_grammar_gen<unsigned int, token_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/cpp_tokens/instantiate_defined_grammar.cpp b/src/boost/libs/wave/samples/cpp_tokens/instantiate_defined_grammar.cpp new file mode 100644 index 00000000..acec5c48 --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/instantiate_defined_grammar.cpp @@ -0,0 +1,39 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "cpp_tokens.hpp" // config data + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> + +#include "slex_token.hpp" +#include "slex_iterator.hpp" + +#include <boost/wave/grammars/cpp_defined_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the defined_grammar_gen template +// with the correct token type. This instantiates the corresponding parse +// function, which in turn instantiates the defined_grammar +// object (see wave/grammars/cpp_defined_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::cpplexer::slex::slex_iterator< + boost::wave::cpplexer::slex_token<> > + lexer_type; +template struct boost::wave::grammars::defined_grammar_gen<lexer_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/cpp_tokens/instantiate_slex_lexer.cpp b/src/boost/libs/wave/samples/cpp_tokens/instantiate_slex_lexer.cpp new file mode 100644 index 00000000..bbdcdd10 --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/instantiate_slex_lexer.cpp @@ -0,0 +1,47 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: Print out the preprocessed tokens returned by the Wave iterator + Explicit instantiation of the lex_functor generation function + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "cpp_tokens.hpp" // config data + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> + +#include "slex_token.hpp" +#include "slex_iterator.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// The following file needs to be included only once throughout the whole +// program. +#include "slex/cpp_slex_lexer.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// +// This instantiates the correct 'new_lexer' function, which generates the +// C++ lexer used in this sample. +// +// This is moved into a separate compilation unit to decouple the compilation +// of the C++ lexer from the compilation of the other modules, which helps to +// reduce compilation time. +// +// The template parameter(s) supplied should be identical to the parameters +// supplied while instantiating the context<> template. +// +/////////////////////////////////////////////////////////////////////////////// + +template struct boost::wave::cpplexer::slex::new_lexer_gen< + std::string::iterator>; + +#endif // BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 diff --git a/src/boost/libs/wave/samples/cpp_tokens/slex/cpp_slex_lexer.hpp b/src/boost/libs/wave/samples/cpp_tokens/slex/cpp_slex_lexer.hpp new file mode 100644 index 00000000..b37b21fb --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/slex/cpp_slex_lexer.hpp @@ -0,0 +1,827 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + SLex (Spirit Lex) based C++ lexer + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(SLEX_LEXER_HPP_5E8E1DF0_BB41_4938_B7E5_A4BB68222FF6_INCLUDED) +#define SLEX_LEXER_HPP_5E8E1DF0_BB41_4938_B7E5_A4BB68222FF6_INCLUDED + +#include <string> +#if defined(BOOST_SPIRIT_DEBUG) +#include <iostream> +#endif // defined(BOOST_SPIRIT_DEBUG) + +#include <boost/assert.hpp> +#include <boost/spirit/include/classic_core.hpp> + +#include <boost/wave/wave_config.hpp> +#include <boost/wave/language_support.hpp> +#include <boost/wave/token_ids.hpp> +#include <boost/wave/util/file_position.hpp> +#include <boost/wave/util/time_conversion_helper.hpp> +#include <boost/wave/cpplexer/validate_universal_char.hpp> +#include <boost/wave/cpplexer/convert_trigraphs.hpp> +#include <boost/wave/cpplexer/cpplexer_exceptions.hpp> +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 +#include <boost/wave/cpplexer/detect_include_guards.hpp> +#endif +#include <boost/wave/cpplexer/cpp_lex_interface.hpp> + +#include "../slex_interface.hpp" +#include "../slex_token.hpp" +#include "../slex_iterator.hpp" + +#include "lexer.hpp" // "spirit/lexer.hpp" + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace cpplexer { +namespace slex { +namespace lexer { + +/////////////////////////////////////////////////////////////////////////////// +// The following numbers are the array sizes of the token regex's which we +// need to specify to make the CW compiler happy (at least up to V9.5). +#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0 +#define INIT_DATA_SIZE 175 +#else +#define INIT_DATA_SIZE 158 +#endif +#define INIT_DATA_CPP_SIZE 15 +#define INIT_DATA_PP_NUMBER_SIZE 2 +#define INIT_DATA_CPP0X_SIZE 15 + +/////////////////////////////////////////////////////////////////////////////// +// +// encapsulation of the boost::spirit::classic::slex based cpp lexer +// +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// The following lexer_base class was necessary to workaround a CodeWarrior +// bug (at least up to CW V9.5). +template <typename IteratorT, typename PositionT> +class lexer_base +: public boost::spirit::classic::lexer< + boost::wave::util::position_iterator<IteratorT, PositionT> > +{ +protected: + typedef boost::wave::util::position_iterator<IteratorT, PositionT> + iterator_type; + typedef typename std::iterator_traits<IteratorT>::value_type char_type; + typedef boost::spirit::classic::lexer<iterator_type> base_type; + + lexer_base(); + +// initialization data (regular expressions for the token definitions) + struct lexer_data { + token_id tokenid; // token data + char_type const *tokenregex; // associated token to match + typename base_type::callback_t tokencb; // associated callback function + unsigned int lexerstate; // valid for lexer state + }; +}; + +/////////////////////////////////////////////////////////////////////////////// +template <typename IteratorT, typename PositionT> +class lexer +: public lexer_base<IteratorT, PositionT> +{ +public: + typedef boost::wave::cpplexer::slex_token<PositionT> token_type; + + void init_dfa(boost::wave::language_support language); + +// get time of last compilation + static std::time_t get_compilation_time() + { return compilation_time.get_time(); } + +// helper for calculation of the time of last compilation + static boost::wave::util::time_conversion_helper compilation_time; + +private: + typedef lexer_base<IteratorT, PositionT> base_type; + + static typename base_type::lexer_data const init_data[INIT_DATA_SIZE]; // common patterns + static typename base_type::lexer_data const init_data_cpp[INIT_DATA_CPP_SIZE]; // C++ only patterns + static typename base_type::lexer_data const init_data_pp_number[INIT_DATA_PP_NUMBER_SIZE]; // pp-number only patterns + static typename base_type::lexer_data const init_data_cpp0x[INIT_DATA_CPP0X_SIZE]; // C++0X only patterns +}; + +/////////////////////////////////////////////////////////////////////////////// +// data required for initialization of the lexer (token definitions) +#define OR "|" +#define Q(c) "\\" c +#define TRI(c) Q("?") Q("?") c + +// definition of some sub-token regexps to simplify the regex definitions +#define BLANK "[ \\t]" +#define CCOMMENT \ + Q("/") Q("*") "[^*]*" Q("*") "+" "(" "[^/*][^*]*" Q("*") "+" ")*" Q("/") + +#define PPSPACE "(" BLANK OR CCOMMENT ")*" + +#define OCTALDIGIT "[0-7]" +#define DIGIT "[0-9]" +#define HEXDIGIT "[0-9a-fA-F]" +#define OPTSIGN "[-+]?" +#define EXPSTART "[eE]" "[-+]" +#define EXPONENT "(" "[eE]" OPTSIGN "[0-9]+" ")" +#define NONDIGIT "[a-zA-Z_]" + +#define INTEGER \ + "(" "(0x|0X)" HEXDIGIT "+" OR "0" OCTALDIGIT "*" OR "[1-9]" DIGIT "*" ")" + +#define INTEGER_SUFFIX "(" "[uU][lL]?|[lL][uU]?" ")" +#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0 +#define LONGINTEGER_SUFFIX "(" "[uU]" "(" "[lL][lL]" ")" OR \ + "(" "[lL][lL]" ")" "[uU]" "?" OR \ + "i64" \ + ")" +#else +#define LONGINTEGER_SUFFIX "(" "[uU]" "(" "[lL][lL]" ")" OR \ + "(" "[lL][lL]" ")" "[uU]" "?" ")" +#endif +#define FLOAT_SUFFIX "(" "[fF][lL]?" OR "[lL][fF]?" ")" +#define CHAR_SPEC "L?" +#define EXTCHAR_SPEC "(" "[uU]" OR "u8" ")" + +#define BACKSLASH "(" Q("\\") OR TRI(Q("/")) ")" +#define ESCAPESEQ "(" BACKSLASH "(" \ + "[abfnrtv?'\"]" OR \ + BACKSLASH OR \ + "x" HEXDIGIT "+" OR \ + OCTALDIGIT OCTALDIGIT "?" OCTALDIGIT "?" \ + "))" +#define HEXQUAD "(" HEXDIGIT HEXDIGIT HEXDIGIT HEXDIGIT ")" +#define UNIVERSALCHAR "(" BACKSLASH "(" \ + "u" HEXQUAD OR \ + "U" HEXQUAD HEXQUAD \ + "))" + +#define POUNDDEF "(" "#" OR TRI("=") OR Q("%:") ")" +#define NEWLINEDEF "(" "\n" OR "\r" OR "\r\n" ")" + +#if BOOST_WAVE_SUPPORT_INCLUDE_NEXT != 0 +#define INCLUDEDEF "(include|include_next)" +#else +#define INCLUDEDEF "include" +#endif + +#define PP_NUMBERDEF Q(".") "?" DIGIT "(" DIGIT OR NONDIGIT OR EXPSTART OR Q(".") ")*" + +/////////////////////////////////////////////////////////////////////////////// +// lexer state constants +#define LEXER_STATE_NORMAL 0 +#define LEXER_STATE_PP 1 + +#define NUM_LEXER_STATES 1 + +// helper for initializing token data +#define TOKEN_DATA(id, regex) \ + { T_##id, regex, 0, LEXER_STATE_NORMAL } \ + /**/ + +#define TOKEN_DATA_EX(id, regex, callback) \ + { T_##id, regex, callback, LEXER_STATE_NORMAL } \ + /**/ + +/////////////////////////////////////////////////////////////////////////////// +// common C++/C99 token definitions +template <typename IteratorT, typename PositionT> +typename lexer_base<IteratorT, PositionT>::lexer_data const +lexer<IteratorT, PositionT>::init_data[INIT_DATA_SIZE] = +{ + TOKEN_DATA(AND, "&"), + TOKEN_DATA(ANDAND, "&&"), + TOKEN_DATA(ASSIGN, "="), + TOKEN_DATA(ANDASSIGN, "&="), + TOKEN_DATA(OR, Q("|")), + TOKEN_DATA(OR_TRIGRAPH, TRI("!")), + TOKEN_DATA(ORASSIGN, Q("|=")), + TOKEN_DATA(ORASSIGN_TRIGRAPH, TRI("!=")), + TOKEN_DATA(XOR, Q("^")), + TOKEN_DATA(XOR_TRIGRAPH, TRI("'")), + TOKEN_DATA(XORASSIGN, Q("^=")), + TOKEN_DATA(XORASSIGN_TRIGRAPH, TRI("'=")), + TOKEN_DATA(COMMA, ","), + TOKEN_DATA(COLON, ":"), + TOKEN_DATA(DIVIDEASSIGN, Q("/=")), + TOKEN_DATA(DIVIDE, Q("/")), + TOKEN_DATA(DOT, Q(".")), + TOKEN_DATA(ELLIPSIS, Q(".") Q(".") Q(".")), + TOKEN_DATA(EQUAL, "=="), + TOKEN_DATA(GREATER, ">"), + TOKEN_DATA(GREATEREQUAL, ">="), + TOKEN_DATA(LEFTBRACE, Q("{")), + TOKEN_DATA(LEFTBRACE_ALT, "<" Q("%")), + TOKEN_DATA(LEFTBRACE_TRIGRAPH, TRI("<")), + TOKEN_DATA(LESS, "<"), + TOKEN_DATA(LESSEQUAL, "<="), + TOKEN_DATA(LEFTPAREN, Q("(")), + TOKEN_DATA(LEFTBRACKET, Q("[")), + TOKEN_DATA(LEFTBRACKET_ALT, "<:"), + TOKEN_DATA(LEFTBRACKET_TRIGRAPH, TRI(Q("("))), + TOKEN_DATA(MINUS, Q("-")), + TOKEN_DATA(MINUSASSIGN, Q("-=")), + TOKEN_DATA(MINUSMINUS, Q("-") Q("-")), + TOKEN_DATA(PERCENT, Q("%")), + TOKEN_DATA(PERCENTASSIGN, Q("%=")), + TOKEN_DATA(NOT, "!"), + TOKEN_DATA(NOTEQUAL, "!="), + TOKEN_DATA(OROR, Q("|") Q("|")), + TOKEN_DATA(OROR_TRIGRAPH, TRI("!") Q("|") OR Q("|") TRI("!") OR TRI("!") TRI("!")), + TOKEN_DATA(PLUS, Q("+")), + TOKEN_DATA(PLUSASSIGN, Q("+=")), + TOKEN_DATA(PLUSPLUS, Q("+") Q("+")), + TOKEN_DATA(ARROW, Q("->")), + TOKEN_DATA(QUESTION_MARK, Q("?")), + TOKEN_DATA(RIGHTBRACE, Q("}")), + TOKEN_DATA(RIGHTBRACE_ALT, Q("%>")), + TOKEN_DATA(RIGHTBRACE_TRIGRAPH, TRI(">")), + TOKEN_DATA(RIGHTPAREN, Q(")")), + TOKEN_DATA(RIGHTBRACKET, Q("]")), + TOKEN_DATA(RIGHTBRACKET_ALT, ":>"), + TOKEN_DATA(RIGHTBRACKET_TRIGRAPH, TRI(Q(")"))), + TOKEN_DATA(SEMICOLON, ";"), + TOKEN_DATA(SHIFTLEFT, "<<"), + TOKEN_DATA(SHIFTLEFTASSIGN, "<<="), + TOKEN_DATA(SHIFTRIGHT, ">>"), + TOKEN_DATA(SHIFTRIGHTASSIGN, ">>="), + TOKEN_DATA(STAR, Q("*")), + TOKEN_DATA(COMPL, Q("~")), + TOKEN_DATA(COMPL_TRIGRAPH, TRI("-")), + TOKEN_DATA(STARASSIGN, Q("*=")), + TOKEN_DATA(ASM, "asm"), + TOKEN_DATA(AUTO, "auto"), + TOKEN_DATA(BOOL, "bool"), + TOKEN_DATA(FALSE, "false"), + TOKEN_DATA(TRUE, "true"), + TOKEN_DATA(BREAK, "break"), + TOKEN_DATA(CASE, "case"), + TOKEN_DATA(CATCH, "catch"), + TOKEN_DATA(CHAR, "char"), + TOKEN_DATA(CLASS, "class"), + TOKEN_DATA(CONST, "const"), + TOKEN_DATA(CONSTCAST, "const_cast"), + TOKEN_DATA(CONTINUE, "continue"), + TOKEN_DATA(DEFAULT, "default"), + TOKEN_DATA(DELETE, "delete"), + TOKEN_DATA(DO, "do"), + TOKEN_DATA(DOUBLE, "double"), + TOKEN_DATA(DYNAMICCAST, "dynamic_cast"), + TOKEN_DATA(ELSE, "else"), + TOKEN_DATA(ENUM, "enum"), + TOKEN_DATA(EXPLICIT, "explicit"), + TOKEN_DATA(EXPORT, "export"), + TOKEN_DATA(EXTERN, "extern"), + TOKEN_DATA(FLOAT, "float"), + TOKEN_DATA(FOR, "for"), + TOKEN_DATA(FRIEND, "friend"), + TOKEN_DATA(GOTO, "goto"), + TOKEN_DATA(IF, "if"), + TOKEN_DATA(INLINE, "inline"), + TOKEN_DATA(INT, "int"), + TOKEN_DATA(LONG, "long"), + TOKEN_DATA(MUTABLE, "mutable"), + TOKEN_DATA(NAMESPACE, "namespace"), + TOKEN_DATA(NEW, "new"), + TOKEN_DATA(OPERATOR, "operator"), + TOKEN_DATA(PRIVATE, "private"), + TOKEN_DATA(PROTECTED, "protected"), + TOKEN_DATA(PUBLIC, "public"), + TOKEN_DATA(REGISTER, "register"), + TOKEN_DATA(REINTERPRETCAST, "reinterpret_cast"), + TOKEN_DATA(RETURN, "return"), + TOKEN_DATA(SHORT, "short"), + TOKEN_DATA(SIGNED, "signed"), + TOKEN_DATA(SIZEOF, "sizeof"), + TOKEN_DATA(STATIC, "static"), + TOKEN_DATA(STATICCAST, "static_cast"), + TOKEN_DATA(STRUCT, "struct"), + TOKEN_DATA(SWITCH, "switch"), + TOKEN_DATA(TEMPLATE, "template"), + TOKEN_DATA(THIS, "this"), + TOKEN_DATA(THROW, "throw"), + TOKEN_DATA(TRY, "try"), + TOKEN_DATA(TYPEDEF, "typedef"), + TOKEN_DATA(TYPEID, "typeid"), + TOKEN_DATA(TYPENAME, "typename"), + TOKEN_DATA(UNION, "union"), + TOKEN_DATA(UNSIGNED, "unsigned"), + TOKEN_DATA(USING, "using"), + TOKEN_DATA(VIRTUAL, "virtual"), + TOKEN_DATA(VOID, "void"), + TOKEN_DATA(VOLATILE, "volatile"), + TOKEN_DATA(WCHART, "wchar_t"), + TOKEN_DATA(WHILE, "while"), + TOKEN_DATA(PP_DEFINE, POUNDDEF PPSPACE "define"), + TOKEN_DATA(PP_IF, POUNDDEF PPSPACE "if"), + TOKEN_DATA(PP_IFDEF, POUNDDEF PPSPACE "ifdef"), + TOKEN_DATA(PP_IFNDEF, POUNDDEF PPSPACE "ifndef"), + TOKEN_DATA(PP_ELSE, POUNDDEF PPSPACE "else"), + TOKEN_DATA(PP_ELIF, POUNDDEF PPSPACE "elif"), + TOKEN_DATA(PP_ENDIF, POUNDDEF PPSPACE "endif"), + TOKEN_DATA(PP_ERROR, POUNDDEF PPSPACE "error"), + TOKEN_DATA(PP_QHEADER, POUNDDEF PPSPACE \ + INCLUDEDEF PPSPACE Q("\"") "[^\\n\\r\"]+" Q("\"")), + TOKEN_DATA(PP_HHEADER, POUNDDEF PPSPACE \ + INCLUDEDEF PPSPACE "<" "[^\\n\\r>]+" ">"), + TOKEN_DATA(PP_INCLUDE, POUNDDEF PPSPACE \ + INCLUDEDEF PPSPACE), + TOKEN_DATA(PP_LINE, POUNDDEF PPSPACE "line"), + TOKEN_DATA(PP_PRAGMA, POUNDDEF PPSPACE "pragma"), + TOKEN_DATA(PP_UNDEF, POUNDDEF PPSPACE "undef"), + TOKEN_DATA(PP_WARNING, POUNDDEF PPSPACE "warning"), +#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0 + TOKEN_DATA(MSEXT_INT8, "__int8"), + TOKEN_DATA(MSEXT_INT16, "__int16"), + TOKEN_DATA(MSEXT_INT32, "__int32"), + TOKEN_DATA(MSEXT_INT64, "__int64"), + TOKEN_DATA(MSEXT_BASED, "_?" "_based"), + TOKEN_DATA(MSEXT_DECLSPEC, "_?" "_declspec"), + TOKEN_DATA(MSEXT_CDECL, "_?" "_cdecl"), + TOKEN_DATA(MSEXT_FASTCALL, "_?" "_fastcall"), + TOKEN_DATA(MSEXT_STDCALL, "_?" "_stdcall"), + TOKEN_DATA(MSEXT_TRY , "__try"), + TOKEN_DATA(MSEXT_EXCEPT, "__except"), + TOKEN_DATA(MSEXT_FINALLY, "__finally"), + TOKEN_DATA(MSEXT_LEAVE, "__leave"), + TOKEN_DATA(MSEXT_INLINE, "_?" "_inline"), + TOKEN_DATA(MSEXT_ASM, "_?" "_asm"), + TOKEN_DATA(MSEXT_PP_REGION, POUNDDEF PPSPACE "region"), + TOKEN_DATA(MSEXT_PP_ENDREGION, POUNDDEF PPSPACE "endregion"), +#endif // BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0 +// TOKEN_DATA(OCTALINT, "0" OCTALDIGIT "*" INTEGER_SUFFIX "?"), +// TOKEN_DATA(DECIMALINT, "[1-9]" DIGIT "*" INTEGER_SUFFIX "?"), +// TOKEN_DATA(HEXAINT, "(0x|0X)" HEXDIGIT "+" INTEGER_SUFFIX "?"), + TOKEN_DATA(LONGINTLIT, INTEGER LONGINTEGER_SUFFIX), + TOKEN_DATA(INTLIT, INTEGER INTEGER_SUFFIX "?"), + TOKEN_DATA(FLOATLIT, + "(" DIGIT "*" Q(".") DIGIT "+" OR DIGIT "+" Q(".") ")" + EXPONENT "?" FLOAT_SUFFIX "?" OR + DIGIT "+" EXPONENT FLOAT_SUFFIX "?"), + TOKEN_DATA(CCOMMENT, CCOMMENT), + TOKEN_DATA(CPPCOMMENT, Q("/") Q("/[^\\n\\r]*") NEWLINEDEF ), + TOKEN_DATA(CHARLIT, CHAR_SPEC "'" + "(" ESCAPESEQ OR UNIVERSALCHAR OR "[^\\n\\r\\\\']" ")+" "'"), + TOKEN_DATA(STRINGLIT, CHAR_SPEC Q("\"") + "(" ESCAPESEQ OR UNIVERSALCHAR OR "[^\\n\\r\\\\\"]" ")*" Q("\"")), +#if BOOST_WAVE_USE_STRICT_LEXER != 0 + TOKEN_DATA(IDENTIFIER, "([a-zA-Z_]" OR UNIVERSALCHAR ")([a-zA-Z0-9_]" OR UNIVERSALCHAR ")*"), +#else + TOKEN_DATA(IDENTIFIER, "([a-zA-Z_$]" OR UNIVERSALCHAR ")([a-zA-Z0-9_$]" OR UNIVERSALCHAR ")*"), +#endif + TOKEN_DATA(SPACE, "[ \t\v\f]+"), +// TOKEN_DATA(SPACE2, "[\\v\\f]+"), + TOKEN_DATA(CONTLINE, Q("\\") "\n"), + TOKEN_DATA(NEWLINE, NEWLINEDEF), + TOKEN_DATA(POUND_POUND, "##"), + TOKEN_DATA(POUND_POUND_ALT, Q("%:") Q("%:")), + TOKEN_DATA(POUND_POUND_TRIGRAPH, TRI("=") TRI("=")), + TOKEN_DATA(POUND, "#"), + TOKEN_DATA(POUND_ALT, Q("%:")), + TOKEN_DATA(POUND_TRIGRAPH, TRI("=")), + TOKEN_DATA(ANY_TRIGRAPH, TRI(Q("/"))), + TOKEN_DATA(ANY, "."), // this should be the last recognized token + { token_id(0) } // this should be the last entry +}; + +/////////////////////////////////////////////////////////////////////////////// +// C++ only token definitions +template <typename IteratorT, typename PositionT> +typename lexer_base<IteratorT, PositionT>::lexer_data const +lexer<IteratorT, PositionT>::init_data_cpp[INIT_DATA_CPP_SIZE] = +{ + TOKEN_DATA(AND_ALT, "bitand"), + TOKEN_DATA(ANDASSIGN_ALT, "and_eq"), + TOKEN_DATA(ANDAND_ALT, "and"), + TOKEN_DATA(OR_ALT, "bitor"), + TOKEN_DATA(ORASSIGN_ALT, "or_eq"), + TOKEN_DATA(OROR_ALT, "or"), + TOKEN_DATA(XORASSIGN_ALT, "xor_eq"), + TOKEN_DATA(XOR_ALT, "xor"), + TOKEN_DATA(NOTEQUAL_ALT, "not_eq"), + TOKEN_DATA(NOT_ALT, "not"), + TOKEN_DATA(COMPL_ALT, "compl"), +#if BOOST_WAVE_SUPPORT_IMPORT_KEYWORD != 0 + TOKEN_DATA(IMPORT, "import"), +#endif + TOKEN_DATA(ARROWSTAR, Q("->") Q("*")), + TOKEN_DATA(DOTSTAR, Q(".") Q("*")), + TOKEN_DATA(COLON_COLON, "::"), + { token_id(0) } // this should be the last entry +}; + +/////////////////////////////////////////////////////////////////////////////// +// C++ only token definitions +template <typename IteratorT, typename PositionT> +typename lexer_base<IteratorT, PositionT>::lexer_data const +lexer<IteratorT, PositionT>::init_data_pp_number[INIT_DATA_PP_NUMBER_SIZE] = +{ + TOKEN_DATA(PP_NUMBER, PP_NUMBERDEF), + { token_id(0) } // this should be the last entry +}; + +/////////////////////////////////////////////////////////////////////////////// +// C++ only token definitions + +#define T_EXTCHARLIT token_id(T_CHARLIT|AltTokenType) +#define T_EXTSTRINGLIT token_id(T_STRINGLIT|AltTokenType) +#define T_EXTRAWSTRINGLIT token_id(T_RAWSTRINGLIT|AltTokenType) + +template <typename IteratorT, typename PositionT> +typename lexer_base<IteratorT, PositionT>::lexer_data const +lexer<IteratorT, PositionT>::init_data_cpp0x[INIT_DATA_CPP0X_SIZE] = +{ + TOKEN_DATA(EXTCHARLIT, EXTCHAR_SPEC "'" + "(" ESCAPESEQ OR UNIVERSALCHAR OR "[^\\n\\r\\\\']" ")+" "'"), + TOKEN_DATA(EXTSTRINGLIT, EXTCHAR_SPEC Q("\"") + "(" ESCAPESEQ OR UNIVERSALCHAR OR "[^\\n\\r\\\\\"]" ")*" Q("\"")), + TOKEN_DATA(RAWSTRINGLIT, CHAR_SPEC "R" Q("\"") + "(" ESCAPESEQ OR UNIVERSALCHAR OR "[^\\\\\"]" ")*" Q("\"")), + TOKEN_DATA(EXTRAWSTRINGLIT, EXTCHAR_SPEC "R" Q("\"") + "(" ESCAPESEQ OR UNIVERSALCHAR OR "[^\\\\\"]" ")*" Q("\"")), + TOKEN_DATA(ALIGNAS, "alignas"), + TOKEN_DATA(ALIGNOF, "alignof"), + TOKEN_DATA(CHAR16_T, "char16_t"), + TOKEN_DATA(CHAR32_T, "char32_t"), + TOKEN_DATA(CONSTEXPR, "constexpr"), + TOKEN_DATA(DECLTYPE, "decltype"), + TOKEN_DATA(NOEXCEPT, "noexcept"), + TOKEN_DATA(NULLPTR, "nullptr"), + TOKEN_DATA(STATICASSERT, "static_assert"), + TOKEN_DATA(THREADLOCAL, "threadlocal"), + { token_id(0) } // this should be the last entry +}; + +/////////////////////////////////////////////////////////////////////////////// +// undefine macros, required for regular expression definitions +#undef INCLUDEDEF +#undef POUNDDEF +#undef CCOMMENT +#undef PPSPACE +#undef DIGIT +#undef OCTALDIGIT +#undef HEXDIGIT +#undef NONDIGIT +#undef OPTSIGN +#undef EXPSTART +#undef EXPONENT +#undef LONGINTEGER_SUFFIX +#undef INTEGER_SUFFIX +#undef INTEGER +#undef FLOAT_SUFFIX +#undef CHAR_SPEC +#undef BACKSLASH +#undef ESCAPESEQ +#undef HEXQUAD +#undef UNIVERSALCHAR +#undef PP_NUMBERDEF + +#undef Q +#undef TRI +#undef OR + +#undef TOKEN_DATA +#undef TOKEN_DATA_EX + +/////////////////////////////////////////////////////////////////////////////// +// initialize cpp lexer with token data +template <typename IteratorT, typename PositionT> +inline +lexer_base<IteratorT, PositionT>::lexer_base() +: base_type(NUM_LEXER_STATES) +{ +} + +template <typename IteratorT, typename PositionT> +inline void +lexer<IteratorT, PositionT>::init_dfa(boost::wave::language_support lang) +{ + if (this->has_compiled_dfa()) + return; + +// if pp-numbers should be preferred, insert the corresponding rule first + if (boost::wave::need_prefer_pp_numbers(lang)) { + for (int j = 0; 0 != init_data_pp_number[j].tokenid; ++j) { + this->register_regex(init_data_pp_number[j].tokenregex, + init_data_pp_number[j].tokenid, init_data_pp_number[j].tokencb, + init_data_pp_number[j].lexerstate); + } + } + +// if in C99 mode, some of the keywords are not valid + if (!boost::wave::need_c99(lang)) { + for (int j = 0; 0 != init_data_cpp[j].tokenid; ++j) { + this->register_regex(init_data_cpp[j].tokenregex, + init_data_cpp[j].tokenid, init_data_cpp[j].tokencb, + init_data_cpp[j].lexerstate); + } + } + +// if in C++0x mode, add all new keywords +#if BOOST_WAVE_SUPPORT_CPP0X != 0 + if (boost::wave::need_cpp0x(lang)) { + for (int j = 0; 0 != init_data_cpp0x[j].tokenid; ++j) { + this->register_regex(init_data_cpp0x[j].tokenregex, + init_data_cpp0x[j].tokenid, init_data_cpp0x[j].tokencb, + init_data_cpp0x[j].lexerstate); + } + } +#endif + + for (int i = 0; 0 != init_data[i].tokenid; ++i) { + this->register_regex(init_data[i].tokenregex, init_data[i].tokenid, + init_data[i].tokencb, init_data[i].lexerstate); + } +} + +/////////////////////////////////////////////////////////////////////////////// +// get time of last compilation of this file +template <typename IteratorT, typename PositionT> +boost::wave::util::time_conversion_helper + lexer<IteratorT, PositionT>::compilation_time(__DATE__ " " __TIME__); + +/////////////////////////////////////////////////////////////////////////////// +} // namespace lexer + +/////////////////////////////////////////////////////////////////////////////// +// +template <typename IteratorT, typename PositionT> +inline void +init_lexer (lexer::lexer<IteratorT, PositionT> &lexer, + boost::wave::language_support language, bool force_reinit = false) +{ + if (lexer.has_compiled_dfa()) + return; // nothing to do + + using std::ifstream; + using std::ofstream; + using std::ios; + using std::cerr; + using std::endl; + +ifstream dfa_in("wave_slex_lexer.dfa", ios::in|ios::binary); + + lexer.init_dfa(language); + if (force_reinit || !dfa_in.is_open() || + !lexer.load (dfa_in, (long)lexer.get_compilation_time())) + { +#if defined(BOOST_SPIRIT_DEBUG) + cerr << "Compiling regular expressions for slex ..."; +#endif // defined(BOOST_SPIRIT_DEBUG) + + dfa_in.close(); + lexer.create_dfa(); + + ofstream dfa_out ("wave_slex_lexer.dfa", ios::out|ios::binary|ios::trunc); + + if (dfa_out.is_open()) + lexer.save (dfa_out, (long)lexer.get_compilation_time()); + +#if defined(BOOST_SPIRIT_DEBUG) + cerr << " Done." << endl; +#endif // defined(BOOST_SPIRIT_DEBUG) + } +} + +/////////////////////////////////////////////////////////////////////////////// +// +// lex_functor +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename IteratorT, typename PositionT = wave::util::file_position_type> +class slex_functor +: public slex_input_interface< + typename lexer::lexer<IteratorT, PositionT>::token_type + > +{ +public: + + typedef boost::wave::util::position_iterator<IteratorT, PositionT> + iterator_type; + typedef typename std::iterator_traits<IteratorT>::value_type char_type; + typedef BOOST_WAVE_STRINGTYPE string_type; + typedef typename lexer::lexer<IteratorT, PositionT>::token_type token_type; + + slex_functor(IteratorT const &first_, IteratorT const &last_, + PositionT const &pos_, boost::wave::language_support language_) + : first(first_, last_, pos_), language(language_), at_eof(false) + { + // initialize lexer dfa tables + init_lexer(lexer, language_); + } + virtual ~slex_functor() {} + +// get the next token from the input stream + token_type& get(token_type& result) + { + if (!at_eof) { + do { + // generate and return the next token + std::string value; + PositionT pos = first.get_position(); // begin of token position + token_id id = token_id(lexer.next_token(first, last, &value)); + + if ((token_id)(-1) == id) + id = T_EOF; // end of input reached + + string_type token_val(value.c_str()); + + if (boost::wave::need_emit_contnewlines(language) || + T_CONTLINE != id) + { + // The cast should avoid spurious warnings about missing case labels + // for the other token ids's. + switch (id) { + case T_IDENTIFIER: + // test identifier characters for validity (throws if + // invalid chars found) + if (!boost::wave::need_no_character_validation(language)) { + using boost::wave::cpplexer::impl::validate_identifier_name; + validate_identifier_name(token_val, + pos.get_line(), pos.get_column(), pos.get_file()); + } + break; + + case T_EXTCHARLIT: + case T_EXTSTRINGLIT: + case T_EXTRAWSTRINGLIT: + id = token_id(id & ~AltTokenType); + BOOST_FALLTHROUGH; + + case T_CHARLIT: + case T_STRINGLIT: + case T_RAWSTRINGLIT: + // test literal characters for validity (throws if invalid + // chars found) + if (boost::wave::need_convert_trigraphs(language)) { + using boost::wave::cpplexer::impl::convert_trigraphs; + token_val = convert_trigraphs(token_val); + } + if (!boost::wave::need_no_character_validation(language)) { + using boost::wave::cpplexer::impl::validate_literal; + validate_literal(token_val, + pos.get_line(), pos.get_column(), pos.get_file()); + } + break; + + case T_LONGINTLIT: // supported in C99 and long_long mode + if (!boost::wave::need_long_long(language)) { + // syntax error: not allowed in C++ mode + BOOST_WAVE_LEXER_THROW( + boost::wave::cpplexer::lexing_exception, + invalid_long_long_literal, value.c_str(), + pos.get_line(), pos.get_column(), + pos.get_file().c_str()); + } + break; + +#if BOOST_WAVE_SUPPORT_INCLUDE_NEXT != 0 + case T_PP_HHEADER: + case T_PP_QHEADER: + case T_PP_INCLUDE: + // convert to the corresponding ..._next token, if appropriate + { + // Skip '#' and whitespace and see whether we find an + // 'include_next' here. + typename string_type::size_type start = value.find("include"); + if (0 == value.compare(start, 12, "include_next", 12)) + id = token_id(id | AltTokenType); + break; + } +#endif // BOOST_WAVE_SUPPORT_INCLUDE_NEXT != 0 + + case T_EOF: + // T_EOF is returned as a valid token, the next call will + // return T_EOI, i.e. the actual end of input + at_eof = true; + token_val.clear(); + break; + + case T_OR_TRIGRAPH: + case T_XOR_TRIGRAPH: + case T_LEFTBRACE_TRIGRAPH: + case T_RIGHTBRACE_TRIGRAPH: + case T_LEFTBRACKET_TRIGRAPH: + case T_RIGHTBRACKET_TRIGRAPH: + case T_COMPL_TRIGRAPH: + case T_POUND_TRIGRAPH: + case T_ANY_TRIGRAPH: + if (boost::wave::need_convert_trigraphs(language)) + { + using boost::wave::cpplexer::impl::convert_trigraph; + token_val = convert_trigraph(token_val); + } + break; + } + + result = token_type(id, token_val, pos); +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + return guards.detect_guard(result); +#else + return result; +#endif + } + + // skip the T_CONTLINE token + } while (true); + } + return result = token_type(); // return T_EOI + } + + void set_position(PositionT const &pos) + { + // set position has to change the file name and line number only + first.get_position().set_file(pos.get_file()); + first.get_position().set_line(pos.get_line()); + } + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + bool has_include_guards(std::string& guard_name) const + { return guards.detected(guard_name); } +#endif + +private: + iterator_type first; + iterator_type last; + boost::wave::language_support language; + static lexer::lexer<IteratorT, PositionT> lexer; // needed only once + + bool at_eof; + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + include_guards<token_type> guards; +#endif +}; + +template <typename IteratorT, typename PositionT> +lexer::lexer<IteratorT, PositionT> slex_functor<IteratorT, PositionT>::lexer; + +#undef T_EXTCHARLIT +#undef T_EXTSTRINGLIT +#undef T_EXTRAWSTRINGLIT + +/////////////////////////////////////////////////////////////////////////////// +// +// The 'new_lexer' function allows the opaque generation of a new lexer object. +// It is coupled to the iterator type to allow to decouple the lexer/iterator +// configurations at compile time. +// +// This function is declared inside the cpp_slex_token.hpp file, which is +// referenced by the source file calling the lexer and the source file, which +// instantiates the lex_functor. But it is defined here, so it will be +// instantiated only while compiling the source file, which instantiates the +// lex_functor. While the cpp_slex_token.hpp file may be included everywhere, +// this file (cpp_slex_lexer.hpp) should be included only once. This allows +// to decouple the lexer interface from the lexer implementation and reduces +// compilation time. +// +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// +// The new_lexer_gen<>::new_lexer function (declared in cpp_slex_token.hpp) +// should be defined inline, if the lex_functor shouldn't be instantiated +// separately from the lex_iterator. +// +// Separate (explicit) instantiation helps to reduce compilation time. +// +/////////////////////////////////////////////////////////////////////////////// + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 +#define BOOST_WAVE_SLEX_NEW_LEXER_INLINE +#else +#define BOOST_WAVE_SLEX_NEW_LEXER_INLINE inline +#endif + +template <typename IteratorT, typename PositionT> +BOOST_WAVE_SLEX_NEW_LEXER_INLINE +lex_input_interface<slex_token<PositionT> > * +new_lexer_gen<IteratorT, PositionT>::new_lexer(IteratorT const &first, + IteratorT const &last, PositionT const &pos, + boost::wave::language_support language) +{ + return new slex_functor<IteratorT, PositionT>(first, last, pos, + language); +} + +#undef BOOST_WAVE_SLEX_NEW_LEXER_INLINE + +/////////////////////////////////////////////////////////////////////////////// +} // namespace slex +} // namespace cpplexer +} // namespace wave +} // namespace boost + +#endif // !defined(SLEX_LEXER_HPP_5E8E1DF0_BB41_4938_B7E5_A4BB68222FF6_INCLUDED) diff --git a/src/boost/libs/wave/samples/cpp_tokens/slex/lexer.hpp b/src/boost/libs/wave/samples/cpp_tokens/slex/lexer.hpp new file mode 100644 index 00000000..32459cb4 --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/slex/lexer.hpp @@ -0,0 +1,2932 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Spirit based lexer + + http://www.boost.org/ + + Copyright (c) 2001, Daniel C. Nuffer. + Copyright (c) 2001-2012 Hartmut Kaiser. + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + TODO List: + X callback objects (called when a match is made.) + X callback passed first & last iterator, and + a reference to a lexercontrol object that supports some + operations on the lexer. + set state + terminate + state stack (push, pop, top) + set new token return value + ignore the current token + yymore + get length of matched token + get current lexer state + X DFA serialization to save recomputing the DFA. + + lexer states. + organize the file into hpp and ipp. arrange the classes in a logical order. + use buffering - iterator only needs be an input iterator, + lexer & callback are not templatized on iterator type, but char type. + next_token is templatized on iterator type. + beginning/ending contexts. + ^ and $ + DFA minimization. + DFA table compression. + +=============================================================================*/ +#ifndef BOOST_SPIRIT_LEXER_HPP +#define BOOST_SPIRIT_LEXER_HPP + +/////////////////////////////////////////////////////////////////////////////// +#include <boost/config.hpp> +#include <boost/throw_exception.hpp> + +#include <boost/spirit/include/classic_core.hpp> +#include <boost/spirit/include/classic_symbols.hpp> +#include <boost/spirit/include/classic_chset.hpp> +#include <boost/spirit/include/classic_escape_char.hpp> + +#include <set> +#include <map> +#include <memory> // for auto_ptr/unique_ptr +#include <vector> +#include <stack> +#include <utility> // for pair +#include <iostream> +#include <fstream> +#include <boost/assert.hpp> +#include <boost/limits.hpp> + +#if defined(BOOST_NO_STD_ITERATOR_TRAITS) +#define BOOST_SPIRIT_IT_NS impl +#else +#define BOOST_SPIRIT_IT_NS std +#endif + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace spirit { +namespace classic { + +typedef unsigned char uchar; +typedef unsigned int node_id_t; +const node_id_t invalid_node = node_id_t(-1); +typedef std::set<node_id_t> node_set; +typedef std::vector<uchar> uchar_vector; +typedef std::map<node_id_t, node_set> followpos_t; +typedef std::vector<uchar_vector> state_match_t; + +template <typename TokenT> +class lexer_control; + +class bad_regex : public std::exception +{ +}; + +namespace lexerimpl +{ + +class node +{ +public: + + virtual ~node() {} + + virtual node* clone() const = 0; + virtual bool nullable() const = 0; + virtual node_set firstpos() const = 0; + virtual node_set lastpos() const = 0; + virtual void compute_followpos(followpos_t& followpos) const = 0; + virtual void compute_state_match(state_match_t& state_match) const = 0; + virtual void get_eof_ids(node_set& eof_set) const = 0; + virtual void assign_node_ids(node_id_t& node_count) = 0; +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + virtual void dump(std::ostream& out) const = 0; +#endif + +}; + +class char_node : public node +{ + +public: + + char_node(const uchar c); + char_node(const char_node& x); + virtual ~char_node(){} + + virtual node* clone() const; + virtual bool nullable() const; + virtual node_set firstpos() const; + virtual node_set lastpos() const; + virtual void compute_followpos(followpos_t& followpos) const; + virtual void compute_state_match(state_match_t& state_match ) const; + virtual void get_eof_ids(node_set& eof_set) const; + virtual void assign_node_ids(node_id_t& node_count); +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + virtual void dump(std::ostream& out) const; +#endif + +private: + + uchar m_char; + node_id_t m_node_num; +}; + +inline +char_node::char_node(const uchar c) + : node() + , m_char(c) + , m_node_num(0) +{ +} + +inline +char_node::char_node(const char_node& x) + : node(x) + , m_char(x.m_char) + , m_node_num(x.m_node_num) +{ +} + +inline node * +char_node::clone() const +{ + return new char_node(*this); +} + +inline bool +char_node::nullable() const +{ + return false; +} + +inline node_set +char_node::firstpos() const +{ + node_set rval; + rval.insert(m_node_num); + return rval; +} + +inline node_set +char_node::lastpos() const +{ + return firstpos(); +} + +inline void +char_node::compute_followpos(followpos_t&) const +{ + return; +} + +inline void +char_node::compute_state_match(state_match_t& state_match) const +{ + if (state_match.size() < m_node_num + 1) + state_match.resize(m_node_num + 1); + state_match[m_node_num].resize(256); + state_match[m_node_num][m_char] = 1; +} + +inline void +char_node::get_eof_ids(node_set&) const +{ + return; +} + +inline void +char_node::assign_node_ids(node_id_t& node_count) +{ + m_node_num = node_count++; +} + +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) +inline void +char_node::dump(std::ostream& out) const +{ + out << "\nchar_node m_char = " << m_char; + out << " m_node_num = " << m_node_num; + out << " nullable() = " << (nullable() ? "true" : "false"); + out << " firstpos() = "; + node_set fp = firstpos(); + std::copy(fp.begin(), fp.end(), + std::ostream_iterator<node_id_t>(out, ",")); + + out << " lastpos() = "; + node_set lp = lastpos(); + std::copy(lp.begin(), lp.end(), + std::ostream_iterator<node_id_t>(out, ",")); +} +#endif + + +class epsilon_node : public node +{ + +public: + + epsilon_node(); + epsilon_node(const epsilon_node& x); + virtual ~epsilon_node(){} + + virtual node* clone() const; + virtual bool nullable() const; + virtual node_set firstpos() const; + virtual node_set lastpos() const; + virtual void compute_followpos(followpos_t& followpos) const; + virtual void compute_state_match(state_match_t& state_match ) const; + virtual void get_eof_ids(node_set& eof_set) const; + virtual void assign_node_ids(node_id_t& node_count); +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + virtual void dump(std::ostream& out) const; +#endif + +private: + + node_id_t m_node_num; +}; + +inline +epsilon_node::epsilon_node() + : node() + , m_node_num(0) +{ +} + +inline +epsilon_node::epsilon_node(const epsilon_node& x) + : node(x) + , m_node_num(x.m_node_num) +{ +} + +inline node * +epsilon_node::clone() const +{ + return new epsilon_node(*this); +} + +inline bool +epsilon_node::nullable() const +{ + return true; +} + +inline node_set +epsilon_node::firstpos() const +{ + return node_set(); +} + +inline node_set +epsilon_node::lastpos() const +{ + return node_set(); +} + +inline void +epsilon_node::compute_followpos(followpos_t&) const +{ + return; +} + +inline void +epsilon_node::compute_state_match(state_match_t& state_match) const +{ + if (state_match.size() < m_node_num + 1) + state_match.resize(m_node_num + 1); + state_match[m_node_num].resize(256, 1); +} + +inline void +epsilon_node::get_eof_ids(node_set&) const +{ + return; +} + +inline void +epsilon_node::assign_node_ids(node_id_t& node_count) +{ + m_node_num = node_count++; +} + +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) +inline void +epsilon_node::dump(std::ostream& out) const +{ + out << "\nepsilon_node"; + out << " m_node_num = " << m_node_num; + out << " nullable() = " << (nullable() ? "true" : "false"); + out << " firstpos() = "; + node_set fp = firstpos(); + std::copy(fp.begin(), fp.end(), + std::ostream_iterator<node_id_t>(out, ",")); + + out << " lastpos() = "; + node_set lp = lastpos(); + std::copy(lp.begin(), lp.end(), + std::ostream_iterator<node_id_t>(out, ",")); +} +#endif + + +class or_node : public node +{ + +public: + + or_node(node* left, node* right); + or_node(const or_node& x); + virtual ~or_node(){} + + virtual node* clone() const; + virtual bool nullable() const; + virtual node_set firstpos() const; + virtual node_set lastpos() const; + virtual void compute_followpos(followpos_t& followpos) const; + virtual void compute_state_match(state_match_t& state_match ) const; + virtual void get_eof_ids(node_set& eof_set) const; + virtual void assign_node_ids(node_id_t& node_count); +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + virtual void dump(std::ostream& out) const; +#endif + +private: + +#ifndef BOOST_NO_CXX11_SMART_PTR + std::unique_ptr<node> m_left; + std::unique_ptr<node> m_right; +#else + std::auto_ptr<node> m_left; + std::auto_ptr<node> m_right; +#endif +}; + +inline +or_node::or_node(node* left, node* right) + : node() + , m_left(left) + , m_right(right) +{ +} + +inline +or_node::or_node(const or_node& x) + : node(x) + , m_left(x.m_left->clone()) + , m_right(x.m_right->clone()) +{ +} + +inline node * +or_node::clone() const +{ + return new or_node(m_left->clone(), m_right->clone()); +} + +inline bool +or_node::nullable() const +{ + return m_left->nullable() || m_right->nullable(); +} + +inline node_set +or_node::firstpos() const +{ + node_set rval; + node_set l = m_left->firstpos(); + node_set r = m_right->firstpos(); + std::set_union(l.begin(), l.end(), r.begin(), r.end(), + std::inserter(rval, rval.begin())); + return rval; +} + +inline node_set +or_node::lastpos() const +{ + node_set rval; + node_set l = m_left->lastpos(); + node_set r = m_right->lastpos(); + std::set_union(l.begin(), l.end(), r.begin(), r.end(), + std::inserter(rval, rval.begin())); + return rval; +} + +inline void +or_node::compute_followpos(followpos_t& followpos) const +{ + m_left->compute_followpos(followpos); + m_right->compute_followpos(followpos); +} + +inline void +or_node::compute_state_match(state_match_t& state_match) const +{ + m_left->compute_state_match(state_match); + m_right->compute_state_match(state_match); +} + +inline void +or_node::get_eof_ids(node_set& eof_nodes) const +{ + m_left->get_eof_ids(eof_nodes); + m_right->get_eof_ids(eof_nodes); +} + +inline void +or_node::assign_node_ids(node_id_t& node_count) +{ + m_left->assign_node_ids(node_count); + m_right->assign_node_ids(node_count); +} + +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) +inline void +or_node::dump(std::ostream& out) const +{ + m_left->dump(out); + + out << "\nor_node"; + out << " nullable() = " << (nullable() ? "true" : "false"); + out << " firstpos() = "; + node_set fp = firstpos(); + std::copy(fp.begin(), fp.end(), + std::ostream_iterator<node_id_t>(out, ",")); + + out << " lastpos() = "; + node_set lp = lastpos(); + std::copy(lp.begin(), lp.end(), + std::ostream_iterator<node_id_t>(out, ",")); + + m_right->dump(out); +} +#endif + + +class cat_node : public node +{ + +public: + + cat_node(node* left, node* right); + cat_node(const cat_node& x); + virtual ~cat_node(){} + + virtual node* clone() const; + virtual bool nullable() const; + virtual node_set firstpos() const; + virtual node_set lastpos() const; + virtual void compute_followpos(followpos_t& followpos) const; + virtual void compute_state_match(state_match_t& state_match ) const; + virtual void get_eof_ids(node_set& eof_set) const; + virtual void assign_node_ids(node_id_t& node_count); +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + virtual void dump(std::ostream& out) const; +#endif + +private: + +#ifndef BOOST_NO_CXX11_SMART_PTR + std::unique_ptr<node> m_left; + std::unique_ptr<node> m_right; +#else + std::auto_ptr<node> m_left; + std::auto_ptr<node> m_right; +#endif +}; + +inline +cat_node::cat_node(node* left, node* right) + : node() + , m_left(left) + , m_right(right) +{ +} + +inline +cat_node::cat_node(const cat_node& x) + : node(x) + , m_left(x.m_left->clone()) + , m_right(x.m_right->clone()) +{ +} + +inline node * +cat_node::clone() const +{ + return new cat_node(m_left->clone(), m_right->clone()); +} + +inline bool +cat_node::nullable() const +{ + return m_left->nullable() && m_right->nullable(); +} + +inline node_set +cat_node::firstpos() const +{ + if (m_left->nullable()) + { + node_set rval; + node_set l = m_left->firstpos(); + node_set r = m_right->firstpos(); + std::set_union(l.begin(), l.end(), r.begin(), r.end(), + std::inserter(rval, rval.begin())); + return rval; + } + else + { + return m_left->firstpos(); + } +} + +inline node_set +cat_node::lastpos() const +{ + if (m_right->nullable()) + { + node_set rval; + node_set l = m_left->lastpos(); + node_set r = m_right->lastpos(); + std::set_union(l.begin(), l.end(), r.begin(), r.end(), + std::inserter(rval, rval.begin())); + return rval; + } + else + { + return m_right->lastpos(); + } +} + +inline void +cat_node::compute_followpos(followpos_t& followpos) const +{ + node_set l = m_left->lastpos(); + for (node_set::iterator i = l.begin(); + i != l.end(); + ++i) + { + node_set rf = m_right->firstpos(); + followpos[*i].insert(rf.begin(), rf.end()); + } + + m_left->compute_followpos(followpos); + m_right->compute_followpos(followpos); +} + +inline void +cat_node::compute_state_match(state_match_t& state_match) const +{ + m_left->compute_state_match(state_match); + m_right->compute_state_match(state_match); +} + +inline void +cat_node::get_eof_ids(node_set& eof_nodes) const +{ + m_left->get_eof_ids(eof_nodes); + m_right->get_eof_ids(eof_nodes); +} + +inline void +cat_node::assign_node_ids(node_id_t& node_count) +{ + m_left->assign_node_ids(node_count); + m_right->assign_node_ids(node_count); +} + +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) +inline void +cat_node::dump(std::ostream& out) const +{ + m_left->dump(out); + + out << "\ncat_node"; + out << " nullable() = " << (nullable() ? "true" : "false"); + out << " firstpos() = "; + node_set fp = firstpos(); + std::copy(fp.begin(), fp.end(), + std::ostream_iterator<node_id_t>(out, ",")); + + out << " lastpos() = "; + node_set lp = lastpos(); + std::copy(lp.begin(), lp.end(), + std::ostream_iterator<node_id_t>(out, ",")); + + m_right->dump(out); +} +#endif + + +class star_node : public node +{ + +public: + + star_node(node* left); + star_node(const star_node& x); + virtual ~star_node(){} + + virtual node* clone() const; + virtual bool nullable() const; + virtual node_set firstpos() const; + virtual node_set lastpos() const; + virtual void compute_followpos(followpos_t& followpos) const; + virtual void compute_state_match(state_match_t& state_match ) const; + virtual void get_eof_ids(node_set& eof_set) const; + virtual void assign_node_ids(node_id_t& node_count); +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + virtual void dump(std::ostream& out) const; +#endif + +private: + +#ifndef BOOST_NO_CXX11_SMART_PTR + std::unique_ptr<node> m_left; +#else + std::auto_ptr<node> m_left; +#endif +}; + +inline +star_node::star_node(node* left) + : node() + , m_left(left) +{ +} + +inline +star_node::star_node(const star_node& x) + : node(x) + , m_left(x.m_left->clone()) +{ +} + +inline node * +star_node::clone() const +{ + return new star_node(m_left->clone()); +} + +inline bool +star_node::nullable() const +{ + return true; +} + +inline node_set +star_node::firstpos() const +{ + return m_left->firstpos(); +} + +inline node_set +star_node::lastpos() const +{ + return m_left->lastpos(); +} + +inline void +star_node::compute_followpos(followpos_t& followpos) const +{ + node_set lp = this->lastpos(); + for (node_set::iterator i = lp.begin(); + i != lp.end(); + ++i) + { + node_set fp = this->firstpos(); + followpos[*i].insert(fp.begin(), fp.end()); + } + + m_left->compute_followpos(followpos); +} + +inline void +star_node::compute_state_match(state_match_t& state_match) const +{ + m_left->compute_state_match(state_match); +} + +inline void +star_node::get_eof_ids(node_set& eof_nodes) const +{ + m_left->get_eof_ids(eof_nodes); +} + +inline void +star_node::assign_node_ids(node_id_t& node_count) +{ + m_left->assign_node_ids(node_count); +} + +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) +inline void +star_node::dump(std::ostream& out) const +{ + m_left->dump(out); + + out << "\nstar_node"; + out << " nullable() = " << (nullable() ? "true" : "false"); + out << " firstpos() = "; + node_set fp = firstpos(); + std::copy(fp.begin(), fp.end(), + std::ostream_iterator<node_id_t>(out, ",")); + + out << " lastpos() = "; + node_set lp = lastpos(); + std::copy(lp.begin(), lp.end(), + std::ostream_iterator<node_id_t>(out, ",")); + +} +#endif + + +class eof_node : public node +{ + +public: + + eof_node(); + eof_node(const eof_node& x); + virtual ~eof_node(){} + + virtual node* clone() const; + virtual bool nullable() const; + virtual node_set firstpos() const; + virtual node_set lastpos() const; + virtual void compute_followpos(followpos_t& followpos) const; + virtual void compute_state_match(state_match_t& state_match ) const; + virtual void get_eof_ids(node_set& eof_set) const; + virtual void assign_node_ids(node_id_t& node_count); +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + virtual void dump(std::ostream& out) const; +#endif + +private: + + node_id_t m_node_num; +}; + +inline +eof_node::eof_node() + : node() + , m_node_num(0) +{ +} + +inline +eof_node::eof_node(const eof_node& x) + : node(x) + , m_node_num(x.m_node_num) +{ +} + +inline node * +eof_node::clone() const +{ + return new eof_node(*this); +} + +inline bool +eof_node::nullable() const +{ + return false; +} + +inline node_set +eof_node::firstpos() const +{ + node_set rval; + rval.insert(m_node_num); + return rval; +} + +inline node_set +eof_node::lastpos() const +{ + node_set rval; + rval.insert(m_node_num); + return rval; +} + +inline void +eof_node::compute_followpos(followpos_t&) const +{ + return; +} + +inline void +eof_node::compute_state_match(state_match_t& state_match) const +{ + if (state_match.size() < m_node_num + 1) + state_match.resize(m_node_num + 1); + state_match[m_node_num].resize(256, 0); +} + +inline void +eof_node::get_eof_ids(node_set& eof_nodes) const +{ + eof_nodes.insert(m_node_num); +} + +inline void +eof_node::assign_node_ids(node_id_t& node_count) +{ + m_node_num = node_count++; +} + +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) +inline void +eof_node::dump(std::ostream& out) const +{ + out << "\neof_node"; + out << " m_node_num = " << m_node_num; + out << " nullable() = " << (nullable() ? "true" : "false"); + out << " firstpos() = "; + node_set fp = firstpos(); + std::copy(fp.begin(), fp.end(), + std::ostream_iterator<node_id_t>(out, ",")); + + out << " lastpos() = "; + node_set lp = lastpos(); + std::copy(lp.begin(), lp.end(), + std::ostream_iterator<node_id_t>(out, ",")); +} +#endif + +class ccl_node : public node +{ + +public: + + ccl_node(const std::vector<uchar>& v); + ccl_node(const uchar c1, const uchar c2); + ccl_node(const ccl_node& x); + virtual ~ccl_node(){} + + virtual node* clone() const; + virtual bool nullable() const; + virtual node_set firstpos() const; + virtual node_set lastpos() const; + virtual void compute_followpos(followpos_t& followpos) const; + virtual void compute_state_match(state_match_t& state_match ) const; + virtual void get_eof_ids(node_set& eof_set) const; + virtual void assign_node_ids(node_id_t& node_count); +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + virtual void dump(std::ostream& out) const; +#endif + +private: + + std::vector<uchar> m_match; + node_id_t m_node_num; +}; + +inline +ccl_node::ccl_node(const std::vector<uchar>& v) + : node() + , m_match(v) + , m_node_num(0) +{ + m_match.resize(256); // make sure it's the right size +} + +inline +ccl_node::ccl_node(const uchar c1, const uchar c2) + : node() + , m_match(256, uchar(0)) + , m_node_num(0) +{ + BOOST_ASSERT(c1 < c2); + for (std::size_t i = c1; i <= std::size_t(c2); ++i) + { + m_match[i] = 1; + } +} + +inline +ccl_node::ccl_node(const ccl_node& x) + : node(x) + , m_match(x.m_match) + , m_node_num(x.m_node_num) +{ +} + +inline node * +ccl_node::clone() const +{ + return new ccl_node(*this); +} + +inline bool +ccl_node::nullable() const +{ + return false; +} + +inline node_set +ccl_node::firstpos() const +{ + node_set rval; + rval.insert(m_node_num); + return rval; +} + +inline node_set +ccl_node::lastpos() const +{ + return firstpos(); +} + +inline void +ccl_node::compute_followpos(followpos_t&) const +{ + return; +} + +inline void +ccl_node::compute_state_match(state_match_t& state_match) const +{ + if (state_match.size() < m_node_num + 1) + state_match.resize(m_node_num + 1); + state_match[m_node_num] = m_match; +} + +inline void +ccl_node::get_eof_ids(node_set&) const +{ + return; +} + +inline void +ccl_node::assign_node_ids(node_id_t& node_count) +{ + m_node_num = node_count++; +} + +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) +inline void +ccl_node::dump(std::ostream& out) const +{ + out << "\nccl_node m_match = "; + for (std::size_t i = 0; i < m_match.size(); ++i) + { + if (m_match[i]) + out << i << ", "; + } + out << " m_node_num = " << m_node_num; + out << " nullable() = " << (nullable() ? "true" : "false"); + out << " firstpos() = "; + node_set fp = firstpos(); + std::copy(fp.begin(), fp.end(), + std::ostream_iterator<node_id_t>(out, ",")); + + out << " lastpos() = "; + node_set lp = lastpos(); + std::copy(lp.begin(), lp.end(), + std::ostream_iterator<node_id_t>(out, ",")); +} +#endif + +template <typename ScannerT> +class make_concat +{ + typedef typename ScannerT::iterator_t iterator_type; + +public: + + make_concat(std::stack<node*>& the_stack) + : m_stack(the_stack) + {} + + void operator()(iterator_type const &, iterator_type const &) const + { + node* right = m_stack.top(); + m_stack.pop(); + node* left = m_stack.top(); + m_stack.pop(); + node* newnode = new cat_node(left, right); + m_stack.push(newnode); + } + + std::stack<node*>& m_stack; +}; + +template <int CharTSize> +struct get_byte_aux; + +template<> +struct get_byte_aux<1> +{ + template <typename CharT> + unsigned char operator()(CharT c, unsigned int byte) + { + BOOST_ASSERT(byte == 0); + return c; + } +}; + +template<> +struct get_byte_aux<2> +{ + template <typename CharT> + unsigned char operator()(CharT c, unsigned int byte) + { + static unsigned long mask[] = + { + 0xFF00, + 0x00FF + }; + + BOOST_ASSERT(byte < 2); + return (c & mask[byte]) >> ((sizeof(c) - 1 - byte) * 8); + } +}; + +template<> +struct get_byte_aux<4> +{ + template <typename CharT> + unsigned char operator()(CharT c, unsigned int byte) + { + static unsigned long mask[] = + { + 0xFF000000, + 0x00FF0000, + 0x0000FF00, + 0x000000FF + }; + + BOOST_ASSERT(byte < 4); + return (c & mask[byte]) >> ((sizeof(c) - 1 - byte) * 8); + } +}; + +template <typename CharT> +inline unsigned char +get_byte(CharT c, unsigned int byte) +{ + return get_byte_aux<sizeof(c)>()(c, byte); +} + +template <typename ScannerT> +class make_star +{ + typedef typename ScannerT::iterator_t iterator_type; + +public: + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<iterator_type>::value_type + char_t; + + make_star(std::stack<node*>& the_stack) + : m_stack(the_stack) + {} + + void operator()(const char_t) const + { + node* left = m_stack.top(); + m_stack.pop(); + node* newnode = new star_node(left); + m_stack.push(newnode); + } + + std::stack<node*>& m_stack; +}; + +template <typename ScannerT> +class make_or +{ + typedef typename ScannerT::iterator_t iterator_type; + +public: + + make_or(std::stack<node*>& the_stack) + : m_stack(the_stack) + {} + + void operator()(iterator_type const&, iterator_type const&) const + { + node* right = m_stack.top(); + m_stack.pop(); + node* left = m_stack.top(); + m_stack.pop(); + node* newnode = new or_node(left, right); + m_stack.push(newnode); + } + + std::stack<node*>& m_stack; +}; + +template <typename ScannerT> +class make_plus +{ + typedef typename ScannerT::iterator_t iterator_type; + +public: + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<iterator_type>::value_type + char_t; + + make_plus(std::stack<node*>& the_stack) + : m_stack(the_stack) + {} + + void operator()(const char_t) const + { + node* left = m_stack.top(); + m_stack.pop(); + + node* copy = left->clone(); + + node* new_star = new star_node(copy); + node* new_cat = new cat_node(left, new_star); + m_stack.push(new_cat); + } + + std::stack<node*>& m_stack; +}; + +template <typename ScannerT> +class make_optional +{ + typedef typename ScannerT::iterator_t iterator_type; + +public: + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<iterator_type>::value_type + char_t; + + make_optional(std::stack<node*>& the_stack) + : m_stack(the_stack) + {} + + void operator()(const char_t) const + { + node* left = m_stack.top(); + m_stack.pop(); + + node* new_or = new or_node(left, new epsilon_node()); + m_stack.push(new_or); + } + + std::stack<node*>& m_stack; +}; + +/////////////////////////////////////////////////////////////////////////////// +// utility function +template <typename CharT> +inline utility::impl::range<CharT> const& +full_range() +{ + static utility::impl::range<CharT> full((std::numeric_limits<CharT>::min)(), + (std::numeric_limits<CharT>::max)()); + return full; +} + +namespace ccl_utils +{ + template <typename char_t> + inline utility::impl::range_run<char_t> + negate_range_run( + const utility::impl::range_run<char_t>& rr) + { + utility::impl::range_run<char_t> newrr; + newrr.set(full_range<char_t>()); + for (typename utility::impl::range_run<char_t>::const_iterator iter = rr.begin(); + iter != rr.end(); ++iter) + newrr.clear(*iter); + return newrr; + } + + template <typename char_t> + inline node* + create_mb_node_seq(char_t c) + { + node* newnode = new char_node(get_byte(c, 0)); + for (unsigned int i = 1; i < sizeof(c); ++i) + { + node* cnode = new char_node(get_byte(c, i)); + node* top_node = new cat_node(newnode, cnode); + newnode = top_node; + } + return newnode; + } + + template <typename char_t> + inline void + handle_mb_char(char_t c, bool first_time, + std::stack<node*>& stack) + { + node* newnode = create_mb_node_seq(c); + + if (first_time) + { + stack.push(newnode); + } + else + { + node* top = stack.top(); + stack.pop(); + + node* newtop = new or_node(top, newnode); + stack.push(newtop); + } + } + + // forward decl only + template <typename char_t> + inline void + handle_mb_range(char_t c1, char_t c2, bool first_time, + std::stack<node*>& stack); + + template <typename char_t> + inline void + create_nodes(const utility::impl::range_run<char_t>& rr, + std::stack<node*>& stack) + { + + if (sizeof(char_t) == 1) + { + std::vector<uchar> ccl; + ccl.resize(256); + for (typename utility::impl::range_run<char_t>::const_iterator iter = rr.begin(); + iter != rr.end(); ++iter) + { + for (int i = iter->first; i <= iter->last; ++i) + { +// this is always true because of the limited datatype +// BOOST_ASSERT(uchar(i) < 256 && ccl.size() == 256); + ccl[uchar(i)] = 1; + } + } + + node* new_ccl = new ccl_node(ccl); + stack.push(new_ccl); + } + else + { + bool mb_first_time = true; + for (typename utility::impl::range_run<char_t>::const_iterator iter = rr.begin(); + iter != rr.end(); ++iter) + { + if (iter->first == iter->last) + { + handle_mb_char(iter->first, mb_first_time, stack); + } + else + { + handle_mb_range(iter->first, iter->last, mb_first_time, stack); + } + mb_first_time = false; + } + } + } + + template <typename char_t> + inline std::size_t + compute_differing_byte(char_t c1, char_t c2) + { + std::size_t rval = 0; + while (rval < sizeof(c1) && + get_byte(c1, (unsigned int)rval) == get_byte(c2, (unsigned int)rval)) + { + ++rval; + } + return rval; + } + + template <typename char_t> + inline node* + create_mb_node_type1(std::size_t j, char_t c1, char_t c2) + { + std::size_t diff = get_byte(c2, (unsigned int)j) - + get_byte(c1, (unsigned int)j); + if (diff == 1) { + return 0; + } + else if (diff == 2) { + return new char_node(get_byte(c1, (unsigned int)j)+1); + } + else { + return new ccl_node(get_byte(c1, (unsigned int)j)+1, + get_byte(c2, (unsigned int)j)-1); + } + } + + template <typename char_t> + inline node * + create_mb_node_for_byte(std::size_t i, std::size_t j, std::size_t sizem1, + std::size_t differing_byte, char_t c1, char_t c2, node* newnode) + { + node* cnode; + if (i == sizem1 && j == differing_byte && j != sizem1) + { + node* tmp = create_mb_node_type1(j, c1, c2); + if (tmp == 0) + { + delete newnode; + return 0; + } + else + cnode = tmp; + } + else if (i == differing_byte && j == sizem1) + { + if (i != sizem1) { + cnode = new ccl_node(get_byte(c1, (unsigned int)j), 0xFF); + } + else { + cnode = new ccl_node(get_byte(c1, (unsigned int)j), + get_byte(c2, (unsigned int)j)); + } + } + else if (i != differing_byte && i != sizem1 && + j == (sizem1 - i + differing_byte)) + { + cnode = new ccl_node(get_byte(c1, (unsigned int)j)+1, 0xFF); + } + else if (i + j - differing_byte > sizem1) { + cnode = new ccl_node(0, 0xFF); + } + else {//if (is plain) + cnode = new char_node(get_byte(c1, (unsigned int)j)); + } + + node* top_node = new cat_node(newnode, cnode); + return top_node; + } + +// On platforms, where wchar_t is a typedef for unsigned short, the +// comparision for a negative value is pointless + template <bool is_signed> + struct correct_char_aux { + }; + + template <> + struct correct_char_aux<true> { + + template <typename char_t> + static char_t correct(char_t c) { if (c < 0) c = 0; return c; } + }; + + template <> + struct correct_char_aux<false> { + + template <typename char_t> + static char_t correct(char_t c) { return c; } + }; + + template <typename char_t> + struct correct_char + { + static char_t correct(char_t c) + { + return correct_char_aux<std::numeric_limits<char_t>::is_signed >:: + correct(c); + } + }; + + template <typename char_t> + inline void + handle_mb_range(char_t c1, char_t c2, bool first_time, + std::stack<node*>& stack) + { + // The algorithm can't handle negative value chars, which don't make + // much sense anyway. This comparision is pointless for wchar_t's on + // platforms, where wchar_t is a typedef for unsigned short + + c1 = correct_char<char_t>::correct(c1); + //if (c1 < 0) + // c1 = 0; + + BOOST_ASSERT(c1 < c2); + node* newnode = 0; + node* savednode = 0; + const std::size_t differing_byte = compute_differing_byte(c1, c2); + const std::size_t sizem1 = sizeof(c1) - 1; + const std::size_t ndb = sizem1 - differing_byte; + for (std::size_t i = differing_byte; i < sizeof(c1); ++i) + { + // generate node for the first byte + if (differing_byte == 0 && i == ndb) + { + node* tmp = create_mb_node_type1(0, c1, c2); + if (tmp == 0) + continue; + else + newnode = tmp; + } + else + { + newnode = new char_node(get_byte(c1, 0)); + } + for (std::size_t j = 1; j < sizeof(c1); ++j) + { + newnode = create_mb_node_for_byte(i, j, sizem1, differing_byte, + c1, c2, newnode); + if (newnode == 0) + goto end_outer_for; + } + + // or together the various parts + if (savednode) + { + node* top_node = new or_node(savednode, newnode); + savednode = top_node; + } + else + { + savednode = newnode; + } +end_outer_for: + continue; + } + + for (std::size_t k = 0; k < ndb; ++k) + { + newnode = new char_node(get_byte(c2, 0)); + for (std::size_t j = 1; j < sizeof(c2); ++j) + { + node* cnode; + if (k == differing_byte && j == sizem1 && k != sizem1) + cnode = new ccl_node(0, get_byte(c2, (unsigned int)j)); + + else if (k != differing_byte && k != sizem1 && + j == (sizem1 - k + differing_byte)) + cnode = new ccl_node(0, get_byte(c2, (unsigned int)j)-1); + + else if (k + j - differing_byte > sizem1) + cnode = new ccl_node(0, 0xFF); + + else //if (is plain) + cnode = new char_node(get_byte(c2, (unsigned int)j)); + + + node* top_node = new cat_node(newnode, cnode); + newnode = top_node; + } + + // or together the various parts + if (savednode) + { + node* top_node = new or_node(savednode, newnode); + savednode = top_node; + } + else + { + savednode = newnode; + } + } + + + if (first_time) + { + stack.push(savednode); + } + else + { + node* top = stack.top(); + stack.pop(); + + node* newtop = new or_node(top, savednode); + stack.push(newtop); + } + } +} // namespace ccl_utils + +template <typename ScannerT> +class make_char +{ + typedef typename ScannerT::iterator_t iterator_type; + +public: + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<iterator_type>::value_type + char_t; + + make_char(std::stack<node*>& the_stack) + : m_stack(the_stack) + {} + + void operator()(iterator_type const& first, iterator_type const& last) const + { + const escape_char_parser<lex_escapes, char_t> lex_escape_ch = + escape_char_parser<lex_escapes, char_t>(); + char_t the_char; + iterator_type first_ = first; + ScannerT scan(first_, last); + lex_escape_ch[assign(the_char)].parse(scan); + node* newnode = ccl_utils::create_mb_node_seq(the_char); + m_stack.push(newnode); + } + + std::stack<node*>& m_stack; +}; + + +template <typename ScannerT> +class make_ccl +{ + typedef typename ScannerT::iterator_t iterator_type; + +public: + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<iterator_type>::value_type + char_t; + + make_ccl(std::stack<node*>& the_stack) + : m_stack(the_stack) + {} + + static bool is_equal_to_string(iterator_type first, + iterator_type const & last, const char* str) + { + while (first != last &&*str &&*first ==*str) + { + ++first; + ++str; + } + return*str == 0; + } + + template <typename ParserT> + static void fill_ccl(utility::impl::range_run<char_t>& rr, const ParserT& parser) + { + for (int i = 0; i < 256; ++i) + { + if (parser.test(static_cast<char_t>(uchar(i)))) + rr.set(utility::impl::range<char_t>(char_t(i), char_t(i))); + } + } + + void operator()(iterator_type const& first_, iterator_type const& last) const + { + BOOST_ASSERT(*first_ == '['); + + iterator_type first = first_; + ++first; // skip over '[' + bool negated_ccl = false; + if (*first == '^') + { + negated_ccl = true; + ++first; + } + + utility::impl::range_run<char_t> rr; + while (first != last &&*first != ']') + { + if (*first == '[') // it's a ccl_expr like [:space:] + { + // check for [:space:], etc. + if (is_equal_to_string(first, last, "[:alnum:]")) + { + fill_ccl(rr, alnum_p); + } + else if (is_equal_to_string(first, last, "[:alpha:]")) + { + fill_ccl(rr, alpha_p); + } + else if (is_equal_to_string(first, last, "[:blank:]")) + { + fill_ccl(rr, blank_p); + } + else if (is_equal_to_string(first, last, "[:cntrl:]")) + { + fill_ccl(rr, cntrl_p); + } + else if (is_equal_to_string(first, last, "[:digit:]")) + { + fill_ccl(rr, digit_p); + } + else if (is_equal_to_string(first, last, "[:graph:]")) + { + fill_ccl(rr, graph_p); + } + else if (is_equal_to_string(first, last, "[:lower:]")) + { + fill_ccl(rr, lower_p); + } + else if (is_equal_to_string(first, last, "[:print:]")) + { + fill_ccl(rr, print_p); + } + else if (is_equal_to_string(first, last, "[:punct:]")) + { + fill_ccl(rr, punct_p); + } + else if (is_equal_to_string(first, last, "[:space:]")) + { + fill_ccl(rr, space_p); + } + else if (is_equal_to_string(first, last, "[:upper:]")) + { + fill_ccl(rr, upper_p); + } + else if (is_equal_to_string(first, last, "[:xdigit:]")) + { + fill_ccl(rr, xdigit_p); + } + // this can't happen, because it's parsed before we get here. + //else + // throw bad_regex(); + + // Advance past the character class expression + while (first != last &&*first != ']') + ++first; + BOOST_ASSERT(*first == ']'); + ++first; + } + else { + const escape_char_parser<lex_escapes, char_t> lex_escape_ch = + escape_char_parser<lex_escapes, char_t>(); + + char_t c1; + ScannerT scan(first, last); + lex_escape_ch[assign(c1)].parse(scan); + if (*scan.first == '-') // insert a range + { + ++scan.first; + char_t c2; + lex_escape_ch[assign(c2)].parse(scan); + BOOST_ASSERT(c1 < c2); // Throw exception? + rr.set(utility::impl::range<char_t>(c1, c2)); + } + else // insert 1 char + { + rr.set(utility::impl::range<char_t>(c1, c1)); + } + } + } + + if (negated_ccl) + { + rr = ccl_utils::negate_range_run(rr); + } + + ccl_utils::create_nodes(rr, m_stack); + } + + std::stack<node*>& m_stack; +}; + +template <typename ScannerT> +class make_any_char +{ + typedef typename ScannerT::iterator_t iterator_type; + +public: + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<iterator_type>::value_type + char_t; + + std::stack<node*>& m_stack; + + make_any_char(std::stack<node*>& the_stack) + : m_stack(the_stack) + {} + + void operator()(const char_t c) const + { + BOOST_ASSERT(c == '.'); + do_any_char(); + } + + void do_any_char() const + { + static utility::impl::range_run<char_t> rr; + rr.set(full_range<char_t>()); + char_t newline = '\n'; + rr.clear(utility::impl::range<char_t>(newline, newline)); + + ccl_utils::create_nodes(rr, m_stack); + } +}; + +template <typename ScannerT> +class make_string +{ + typedef typename ScannerT::iterator_t iterator_type; + +public: + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<iterator_type>::value_type + char_t; + + std::stack<node*>& m_stack; + + make_string(std::stack<node*>& the_stack) + : m_stack(the_stack) + {} + + void operator()(iterator_type const& first, iterator_type const& last) const + { + BOOST_ASSERT(*first == '"'); + + iterator_type first_ = first; + ScannerT scan(first_, last); + ++scan.first; // skip over '"' + + // empty string not allowed + if (*scan.first == '"') + { + boost::throw_exception(bad_regex()); + } + + const escape_char_parser<lex_escapes, char_t> lex_escape_ch = + escape_char_parser<lex_escapes, char_t>(); + + char_t c; + lex_escape_ch[assign(c)].parse(scan); + node* top_node = ccl_utils::create_mb_node_seq(c); + + while (*scan.first != '"' && scan.first != scan.last) + { + lex_escape_ch[assign(c)].parse(scan); + node* cur_node = ccl_utils::create_mb_node_seq(c); + top_node = new cat_node(top_node, cur_node); + } + m_stack.push(top_node); + } +}; + +inline +node* repeat_node(node* n, int num) +{ + node* list_of_nodes = n; + for (int i = 1; i < num; ++i) + { + list_of_nodes = new cat_node(list_of_nodes, n->clone()); + } + return list_of_nodes; +} + +inline +node* optional_node(node* n) +{ + return new or_node(n, new epsilon_node()); +} + +template <typename ScannerT> +class make_rep1 +{ + typedef typename ScannerT::iterator_t iterator_type; + +public: + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<iterator_type>::value_type + char_t; + + std::stack<node*>& m_stack; + + make_rep1(std::stack<node*>& the_stack) + : m_stack(the_stack) + {} + + void operator()(iterator_type const& first, iterator_type const& last) const + { + BOOST_ASSERT(*first == '{'); + + iterator_type first_ = first; + ScannerT scan(first_, last); + ++scan.first; // skip over '{' + + unsigned int count; + uint_p[assign(count)].parse(scan); + if (count == 0) + boost::throw_exception(bad_regex()); + + node* top_node = m_stack.top(); + m_stack.pop(); + top_node = repeat_node(top_node, count); + m_stack.push(top_node); + } +}; + +template <typename ScannerT> +class make_rep2 +{ + typedef typename ScannerT::iterator_t iterator_type; + +public: + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<iterator_type>::value_type + char_t; + + std::stack<node*>& m_stack; + + make_rep2(std::stack<node*>& the_stack) + : m_stack(the_stack) + {} + + void operator()(iterator_type const& first, iterator_type const& last) const + { + BOOST_ASSERT(*first == '{'); + + iterator_type first_ = first; + ScannerT scan (first_, last); + ++scan.first; // skip over '{' + + unsigned int count; + uint_p[assign(count)].parse(scan); + if (count == 0) + boost::throw_exception(bad_regex()); + + node* top_node = m_stack.top(); + m_stack.pop(); + top_node = new cat_node(repeat_node(top_node, count), + new star_node(top_node->clone())); + m_stack.push(top_node); + + } +}; + +template <typename ScannerT> +class make_rep3 +{ + typedef typename ScannerT::iterator_t iterator_type; + +public: + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<iterator_type>::value_type + char_t; + + std::stack<node*>& m_stack; + + make_rep3(std::stack<node*>& the_stack) + : m_stack(the_stack) + {} + + void operator()(iterator_type const& first, iterator_type const& last) const + { + BOOST_ASSERT(*first == '{'); + + iterator_type first_ = first; + ScannerT scan(first_, last); + ++scan.first; // skip over '{' + + unsigned int count1, count2; + uint_p[assign(count1)].parse(scan); + if (count1 == 0) + boost::throw_exception(bad_regex()); + + ++scan.first; // skip over ',' + + uint_p[assign(count2)].parse(scan); + if (count2 <= count1) + boost::throw_exception(bad_regex()); + + node* top_node = m_stack.top(); + m_stack.pop(); + node* repeats = repeat_node(top_node, count1); + top_node = new cat_node(repeats, + repeat_node(optional_node(top_node->clone()), + count2 - count1)); + + m_stack.push(top_node); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// +// Lexer grammar +// +// Defines the grammar, which mandates the syntax of the understood +// lexeme definitions passed to lexer::register_regex. +// +/////////////////////////////////////////////////////////////////////////////// +class lexer_grammar : public boost::spirit::classic::grammar<lexer_grammar> +{ +public: + lexer_grammar(std::stack<node*> &node_stack_) + : node_stack(node_stack_) {} + + template <typename ScannerT> + struct definition + { + typedef rule<ScannerT> rule_t; + typedef typename ScannerT::iterator_t iterator_type; + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<iterator_type>::value_type + char_t; + + rule_t regex, re, series, singleton, singleton2, fullccl, ccl, string, + escseq, ccl_char; + symbols<> ccl_expr; + + definition(lexer_grammar const &self) + { + regex = + re >> !('/' >> re) >> !ch_p('$') + ; + + re = + series + >>*( ('|' >> series)[make_or<ScannerT>(self.node_stack)] ) + ; + + series = + singleton + >>*( singleton[make_concat<ScannerT>(self.node_stack)] ) + ; + + singleton = + ch_p('.')[make_any_char<ScannerT>(self.node_stack)] + >> singleton2 + | fullccl + >> singleton2 + | ('"' >> string >> '"') + [ + make_string<ScannerT>(self.node_stack) + ] + >> singleton2 + | '(' >> re >> ')' + >> singleton2 + | ((anychar_p - chset<>("/|*+?.(){}\\")) | escseq) + [ + make_char<ScannerT>(self.node_stack) + ] + >> singleton2 + ; + + singleton2 = + ch_p('*')[make_star<ScannerT>(self.node_stack)] + >> singleton2 + | ch_p('+')[make_plus<ScannerT>(self.node_stack)] + >> singleton2 + | ch_p('?')[make_optional<ScannerT>(self.node_stack)] + >> singleton2 + | ('{' >> uint_p >> '}') + [ + make_rep1<ScannerT>(self.node_stack) + ] + >> singleton2 + | ('{' >> uint_p >> ',' >> '}') + [ + make_rep2<ScannerT>(self.node_stack) + ] + >> singleton2 + | ('{' >> uint_p >> ',' >> uint_p >> '}') + [ + make_rep3<ScannerT>(self.node_stack) + ] + >> singleton2 + | epsilon_p + ; + + fullccl = + ('[' >> !ch_p('^') >> ccl >> ']') + [ + make_ccl<ScannerT>(self.node_stack) + ] + ; + + ccl = + *(ccl_expr | (ccl_char >> !('-' >> ccl_char))) + ; + + ccl_char = + ( (anychar_p - chset<>("\\\n]")) | escseq ) + ; + + ccl_expr = + "[:alnum:]", + "[:alpha:]", + "[:blank:]", + "[:cntrl:]", + "[:digit:]", + "[:graph:]", + "[:lower:]", + "[:print:]", + "[:punct:]", + "[:space:]", + "[:upper:]", + "[:xdigit:]" + ; + + string = + +( (anychar_p - chset<>("\"\\")) | escseq ) + ; + + typedef + uint_parser<char_t, 8, 1, + std::numeric_limits<char_t>::digits / 3 + 1 + > oct_parser_t; + typedef + uint_parser<char_t, 16, 1, + std::numeric_limits<char_t>::digits / 4 + 1 + > hex_parser_t; + + escseq = + ch_p('\\') + >> ( + oct_parser_t() + | as_lower_d['x'] >> hex_parser_t() + | (anychar_p - chset<>('\n')) + ) + ; + +#define BOOST_SLEX_DEBUG (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + + BOOST_SPIRIT_DEBUG_TRACE_RULE(regex, BOOST_SLEX_DEBUG); + BOOST_SPIRIT_DEBUG_TRACE_RULE(re, BOOST_SLEX_DEBUG); + BOOST_SPIRIT_DEBUG_TRACE_RULE(series, BOOST_SLEX_DEBUG); + BOOST_SPIRIT_DEBUG_TRACE_RULE(singleton, BOOST_SLEX_DEBUG); + BOOST_SPIRIT_DEBUG_TRACE_RULE(singleton2, BOOST_SLEX_DEBUG); + BOOST_SPIRIT_DEBUG_TRACE_RULE(fullccl, BOOST_SLEX_DEBUG); + BOOST_SPIRIT_DEBUG_TRACE_RULE(ccl, BOOST_SLEX_DEBUG); + BOOST_SPIRIT_DEBUG_TRACE_RULE(string, BOOST_SLEX_DEBUG); + BOOST_SPIRIT_DEBUG_TRACE_RULE(escseq, BOOST_SLEX_DEBUG); + BOOST_SPIRIT_DEBUG_TRACE_RULE(ccl_char, BOOST_SLEX_DEBUG); + +#undef BOOST_SLEX_DEBUG + } + + rule<ScannerT> const& + start() const { return regex; } + }; + + std::stack<node*> &node_stack; + +}; // class lexer_grammar + +template <typename StringT> +inline node * +parse(lexer_grammar& g, StringT const& str) +{ + typedef + scanner<typename StringT::const_iterator, scanner_policies<> > + scanner_t; + typedef typename rule<scanner_t>::template result<scanner_t>::type + result_t; + + typename StringT::const_iterator first = str.begin(); + typename StringT::const_iterator last = str.end(); + + scanner_t scan(first, last); +// typename rule<scanner_t>::result_t hit = g.parse(scan); + result_t hit = g.parse(scan); + if (!hit || !scan.at_end()) + { + while (g.node_stack.size()) + { + delete g.node_stack.top(); + g.node_stack.pop(); + } + return 0; + } + + BOOST_ASSERT(g.node_stack.size() == 1); + node* rval = g.node_stack.top(); + g.node_stack.pop(); + node* an_eof_node = new eof_node(); + rval = new cat_node(rval, an_eof_node); + return rval; +} + +inline +void make_case_insensitive(state_match_t& state_match) +{ + // TODO: Fix this. + // This doesn't take into account foreign languages, figure out how to + // do that. Also this approach is broken for this implementation of + // wide chars. + for (state_match_t::iterator iter = state_match.begin(); + iter != state_match.end(); ++iter) + { + int i, j; + for (i = 'A', j = 'a'; i <= 'Z'; ++i, ++j) + { + // if either is set, turn them both on + (*iter)[i] = (*iter)[j] = uchar((*iter)[i] | (*iter)[j]); + } + } +} + +template<bool wide_char> +struct regex_match_helper; + +template<> +struct regex_match_helper<false> // single byte char +{ + template <typename DfaT, typename IteratorT> + static bool + do_match(DfaT const& dfa, IteratorT &first, IteratorT const& last, + int& regex_index, + std::basic_string< + typename BOOST_SPIRIT_IT_NS::iterator_traits<IteratorT>::value_type + > *token) + { + typedef std::basic_string< + typename BOOST_SPIRIT_IT_NS::iterator_traits<IteratorT>::value_type + > string_type; + typedef typename string_type::size_type size_type; + + node_id_t s = 0; + node_id_t last_accepting_index = invalid_node; + IteratorT p = first; + IteratorT last_accepting_cpos = first; + while (p != last) + { + s = dfa.transition_table[s][(uchar)*p]; + if (s == invalid_node) + break; + if (token) token->append((size_type)1, *p); + ++p; + if (dfa.acceptance_index[s] != invalid_node) + { + last_accepting_index = s; + last_accepting_cpos = p; + } + } + if (last_accepting_index != invalid_node) + { +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + std::cout << "dfa.acceptance_index[" << last_accepting_index << "] = " << + dfa.acceptance_index[last_accepting_index] << '\n'; +#endif + + first = last_accepting_cpos; + regex_index = dfa.acceptance_index[last_accepting_index]; + return true; + } + else + return false; + } +}; + +template<> +struct regex_match_helper<true> // wide char +{ + template <typename DfaT, typename IteratorT> + static bool + do_match(DfaT const& dfa, IteratorT &first, IteratorT const& last, + int& regex_index, + std::basic_string< + typename BOOST_SPIRIT_IT_NS::iterator_traits<IteratorT>::value_type + > *token) + { + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<IteratorT>::value_type + char_t; + typedef std::basic_string<char_t> string_type; + typedef typename string_type::size_type size_type; + + node_id_t s = 0; + node_id_t last_accepting_index = invalid_node; + IteratorT wp = first; + IteratorT last_accepting_cpos = first; + + while (wp != last) + { + for (unsigned int i = 0; i < sizeof(char_t); ++i) + { + s = dfa.transition_table[s][get_byte(*wp,i)]; + if (s == invalid_node) + { + goto break_while; + } + } + if (token) token->append((size_type)1, *wp); + ++wp; + if (dfa.acceptance_index[s] != invalid_node) + { + last_accepting_index = s; + last_accepting_cpos = wp; + } + + } + + break_while: + if (last_accepting_index != invalid_node) + { +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + std::cout << "dfa.acceptance_index[" << last_accepting_index << "] = " << + dfa.acceptance_index[last_accepting_index] << '\n'; +#endif + first = last_accepting_cpos; + regex_index = dfa.acceptance_index[last_accepting_index]; + + return true; + } + else + return false; + } +}; + +template <typename DfaT, typename IteratorT, bool wide_char> +struct regex_match +{ + static bool + do_match(DfaT const& dfa, IteratorT &first, IteratorT const& last, + int& regex_index, + std::basic_string< + typename BOOST_SPIRIT_IT_NS::iterator_traits<IteratorT>::value_type + > *token) + { + return regex_match_helper<wide_char>::do_match( + dfa, first, last, regex_index, token); + } +}; + +} // namespace lexerimpl + +/////////////////////////////////////////////////////////////////////////////// +// +template <typename IteratorT = char const*, typename TokenT = int, + typename CallbackT = void(*)(IteratorT const &, + IteratorT &, + IteratorT const&, + TokenT const&, + lexer_control<TokenT> &)> +class lexer +{ +public: + typedef CallbackT callback_t; + typedef + typename BOOST_SPIRIT_IT_NS::iterator_traits<IteratorT>::value_type + char_t; + + struct regex_info + { + std::basic_string<char_t> str; + TokenT token; + CallbackT callback; + + regex_info(const std::basic_string<char_t>& _str, + const TokenT& _token, + const CallbackT& _callback) + : str(_str) + , token(_token) + , callback(_callback) + {} + + }; + + struct dfa_table + { + std::vector<std::vector<node_id_t> > transition_table; + std::vector<node_id_t> acceptance_index; + }; + typedef std::vector<node_id_t> node_table_t; + typedef std::vector<node_table_t> transition_table_t; + typedef std::vector<dfa_table> dfa_t; + + + lexer(unsigned int states = 1); + + void register_regex(const std::basic_string<char_t>& regex, + const TokenT& id, const CallbackT& cb = CallbackT(), + unsigned int state = 0); + + TokenT next_token(IteratorT &first, IteratorT const &last, + std::basic_string<char_t> *token = 0); + + void create_dfa(); + bool has_compiled_dfa() { return m_compiled_dfa; } + + void set_case_insensitive(bool insensitive); + +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + void dump(std::ostream& out); +#endif + typedef std::vector<std::vector<regex_info> > regex_list_t; + + bool load (std::ifstream &in, long unique_id = 0); + bool save (std::ofstream &out, long unique_id = 0); + enum { + SLEX_SIGNATURE = 0x58454C53, // "SLEX" + SLEX_VERSION_100 = 0x0100, // persistance version + SLEX_LAST_KNOWN_VERSION = SLEX_VERSION_100, + SLEX_MINOR_VERSION_MASK = 0xFF + }; + +private: + + void create_dfa_for_state(int state); + + static bool regex_match(const dfa_t& dfa, IteratorT& first, + IteratorT& last, int& regex_index); + + mutable std::stack<lexerimpl::node*> node_stack; + lexerimpl::lexer_grammar g; + + mutable bool m_compiled_dfa; + mutable dfa_t m_dfa; + + regex_list_t m_regex_list; + bool m_case_insensitive; + + unsigned int m_state; + std::stack<unsigned int> m_state_stack; + unsigned int m_num_states; +}; + + +template <typename IteratorT, typename TokenT, typename CallbackT> +inline +lexer<IteratorT, TokenT, CallbackT>::lexer(unsigned int states) + : g(node_stack) + , m_compiled_dfa(false) + , m_regex_list(states) + , m_case_insensitive(false) + , m_state(0) + , m_state_stack() + , m_num_states(states) +{ + BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME(g, "slex::lexer", + BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX); +} + +template <typename IteratorT, typename TokenT, typename CallbackT> +inline void +lexer<IteratorT, TokenT, CallbackT>::register_regex( + const std::basic_string<char_t>& regex, const TokenT& id, + const CallbackT& callback, unsigned int state) +{ + if (state > m_num_states) { + m_regex_list.resize(state); + m_num_states = state; + } + m_regex_list[state].push_back(regex_info(regex, id, callback)); +} + +template <typename IteratorT, typename TokenT, typename CallbackT> +inline TokenT +lexer<IteratorT, TokenT, CallbackT>::next_token( + IteratorT &first, IteratorT const& last, + std::basic_string< + typename BOOST_SPIRIT_IT_NS::iterator_traits<IteratorT>::value_type + > *token) +{ + if (!m_compiled_dfa) + { + create_dfa(); + } + + IteratorT saved = first; + int regex_index; + if (!lexerimpl::regex_match<dfa_table, IteratorT, (sizeof(char_t) > 1)>:: + do_match(m_dfa[m_state], first, last, regex_index, token)) + return -1; // TODO: can't return -1, need to return some invalid token. + // how to figure this out? We can use traits I guess. + else + { + regex_info regex = m_regex_list[m_state][regex_index]; + TokenT rval = regex.token; + if (regex.callback) + { + // execute corresponding callback + lexer_control<TokenT> controller(rval, m_state, m_state_stack); + regex.callback(saved, first, last, regex.token, controller); + if (controller.ignore_current_token_set()) { + if (token) + token->erase(); + return next_token(first, last, token); + } + } + return rval; + } +} + +namespace lexerimpl +{ + +inline +bool find_acceptance_state(const node_set& eof_node_ids, + const node_set& current_set, + node_id_t& acceptance_node_id) +{ + for(node_set::const_iterator nsi = eof_node_ids.begin(); + nsi != eof_node_ids.end(); ++nsi) + { + node_id_t eof_node_id =*nsi; + if (current_set.end() != current_set.find(eof_node_id)) + { + // store the first one we come to as the + // matched pattern + acceptance_node_id = eof_node_id; + // don't bother searching for more + return true; + } + } + return false; +} + +template <typename RegexListT, typename GrammarT> +#ifndef BOOST_NO_CXX11_SMART_PTR +inline std::unique_ptr<node> +#else +inline std::auto_ptr<node> +#endif +parse_regexes(const RegexListT& regex_list, GrammarT& g) +{ + // parse the expressions into a tree + if (regex_list.begin() == regex_list.end()) + boost::throw_exception(bad_regex()); + + typename RegexListT::const_iterator ri = regex_list.begin(); +#ifndef BOOST_NO_CXX11_SMART_PTR + std::unique_ptr<node> tree(lexerimpl::parse(g, (*ri).str)); +#else + std::auto_ptr<node> tree(lexerimpl::parse(g, (*ri).str)); +#endif + if (tree.get() == 0) + boost::throw_exception(bad_regex()); + + ++ri; + for (/**/; ri != regex_list.end(); ++ri) + { +#ifndef BOOST_NO_CXX11_SMART_PTR + std::unique_ptr<node> next_tree(lexerimpl::parse(g, (*ri).str)); +#else + std::auto_ptr<node> next_tree(lexerimpl::parse(g, (*ri).str)); +#endif + if (next_tree.get() == 0) + boost::throw_exception(bad_regex()); +#ifndef BOOST_NO_CXX11_SMART_PTR + tree = std::unique_ptr<node>(new or_node(tree.release(), next_tree.release())); +#else + tree = std::auto_ptr<node>(new or_node(tree.release(), next_tree.release())); +#endif + } + return tree; +} + +} //namespace lexerimpl + +template <typename IteratorT, typename TokenT, typename CallbackT> +inline void +lexer<IteratorT, TokenT, CallbackT>::create_dfa() +{ + m_dfa.resize(m_num_states); + for (unsigned int i = 0; i < m_num_states; ++i) + create_dfa_for_state(i); +} + +// Algorithm from Compilers: Principles, Techniques, and Tools p. 141 +template <typename IteratorT, typename TokenT, typename CallbackT> +inline void +lexer<IteratorT, TokenT, CallbackT>::create_dfa_for_state(int state) +{ + using lexerimpl::node; +#ifndef BOOST_NO_CXX11_SMART_PTR + std::unique_ptr<node> tree = lexerimpl::parse_regexes(m_regex_list[state], g); +#else + std::auto_ptr<node> tree = lexerimpl::parse_regexes(m_regex_list[state], g); +#endif + node_id_t dummy = 0; + tree->assign_node_ids(dummy); + +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) + tree->dump(std::cout); +#endif + + // compute followpos(root) + followpos_t followpos; + tree->compute_followpos(followpos); + + // the dfa states <-> nfa state groups + std::map<node_set, node_id_t> dstates1; + std::map<node_id_t, node_set> dstates2; + + // the dfa transitions + m_dfa[state].transition_table.push_back( + std::vector<node_id_t>(256, invalid_node)); + m_dfa[state].acceptance_index.push_back(invalid_node); + + // whether the dfa state has been processed yet + std::vector<node_id_t> marked; + + // used to give a unique id to each dfa state + node_id_t num_states = 0; + + // initially, the only unmarked state in Dstates is firstpos(root). + marked.push_back(0); + node_set fpr = tree->firstpos(); + dstates1[fpr] = 0; + dstates2[0] = fpr; + state_match_t state_match; + tree->compute_state_match(state_match); + + if (m_case_insensitive) + lexerimpl::make_case_insensitive(state_match); + + node_set eof_node_ids; + tree->get_eof_ids(eof_node_ids); + // translate the eof_node_ids into a 0-based index + std::map<node_id_t, node_id_t> eof_node_id_map; + unsigned int x = 0; + for (node_set::iterator node_id_it = eof_node_ids.begin(); + node_id_it != eof_node_ids.end(); + ++node_id_it) + { + eof_node_id_map[*node_id_it] = x++; + } + + // figure out if this is an acceptance state + node_id_t eof_node_id; + if (lexerimpl::find_acceptance_state(eof_node_ids, fpr, eof_node_id)) + { + m_dfa[state].acceptance_index[0] = eof_node_id_map[eof_node_id]; + } + + std::vector<node_id_t>::iterator i = std::find(marked.begin(), marked.end(), + node_id_t(0)); + while (marked.end() != i) + { + *i = 1; + node_id_t T = node_id_t(std::distance(marked.begin(), i)); + BOOST_ASSERT(T < dstates2.size()); + node_set Tstates = dstates2[T]; + for (node_id_t j = 0; j < 256; ++j) + { + node_set U; + for (node_set::iterator k = Tstates.begin(); + k != Tstates.end(); ++k) + { + node_id_t p =*k; + BOOST_ASSERT(p < state_match.size()); + BOOST_ASSERT(j < state_match[p].size()); + if (state_match[p][j]) + { + node_set fpp = followpos[p]; + U.insert(fpp.begin(), fpp.end()); + } + } + if (U.size() > 0) + { + std::map<node_set, node_id_t>::iterator l = dstates1.find(U); + node_id_t target_state; + if (l == dstates1.end()) // not in the states yet + { + ++num_states; + dstates1[U] = target_state = num_states; + dstates2[target_state] = U; + marked.push_back(0); + m_dfa[state].transition_table.push_back( + std::vector<node_id_t>(256, invalid_node)); + m_dfa[state].acceptance_index.push_back(invalid_node); + // figure out if this is an acceptance state + node_id_t eof_node_id; + if (lexerimpl::find_acceptance_state(eof_node_ids, U, eof_node_id)) + { + m_dfa[state].acceptance_index[target_state] = + eof_node_id_map[eof_node_id]; + } + } + else + { + target_state = dstates1[U]; + } + + BOOST_ASSERT(T < m_dfa[state].transition_table.size()); + BOOST_ASSERT(j < m_dfa[state].transition_table[T].size()); + m_dfa[state].transition_table[T][j] = target_state; + } + + } + + i = std::find(marked.begin(), marked.end(), node_id_t(0)); + } + m_compiled_dfa = true; +} + +template <typename IteratorT, typename TokenT, typename CallbackT> +inline void +lexer<IteratorT, TokenT, CallbackT>::set_case_insensitive(bool insensitive) +{ + m_case_insensitive = insensitive; +} + + +#if defined(BOOST_SPIRIT_DEBUG) && (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_SLEX) +template <typename IteratorT, typename TokenT, typename CallbackT> +inline void +lexer<IteratorT, TokenT, CallbackT>::dump(std::ostream& out) +{ + for (unsigned x = 0; x < m_dfa.size(); ++x) + { + out << "\nm_dfa[" << x << "] has " << m_dfa[x].transition_table.size() << " states\n"; + for (node_id_t i = 0; i < m_dfa[x].transition_table.size(); ++i) + { + out << "state " << i << ":"; + for (node_id_t j = 0; j < m_dfa[x].transition_table[i].size(); ++j) + { + if (m_dfa[x].transition_table[i][j] != invalid_node) + out << j << "->" << m_dfa[x].transition_table[i][j] << " "; + } + out << "\n"; + } + out << "acceptance states: "; + for(unsigned int k = 0; k < m_dfa[x].acceptance_index.size(); ++k) + { + if (m_dfa[x].acceptance_index[k] != invalid_node) + out << '<' << k << ',' << m_dfa[x].acceptance_index[k] << "> "; + } + out << endl; + } +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// load the lexer tables +#define slex_in(strm, val) \ + strm.read((char*)&val, sizeof(val)); \ + if (std::ios::goodbit != strm.rdstate()) return false + +template <typename IteratorT, typename TokenT, typename CallbackT> +inline bool +lexer<IteratorT, TokenT, CallbackT>::load (std::ifstream &in, long unique_id) +{ +// ensure correct signature and version +long signature = 0; + + slex_in (in, signature); + if (signature != SLEX_SIGNATURE) + return false; // not for us + +long version = 0; + + slex_in (in, version); + if ((version & ~SLEX_MINOR_VERSION_MASK) > SLEX_LAST_KNOWN_VERSION) + return false; // to new for us + +long uid = 0; + + slex_in (in, uid); + if (uid != unique_id) + return false; // not saved by us + +// load auxiliary members +int num_states = 0; + + slex_in (in, num_states); + +// load the dfa tables +dfa_t in_dfa; +std::size_t dfa_size = 0; + + slex_in (in, dfa_size); + in_dfa.resize(dfa_size); + for (std::size_t dfa = 0; dfa < dfa_size; ++dfa) + { + // load the transition tables + std::size_t tt_size = 0; + transition_table_t &tt_table = in_dfa[dfa].transition_table; + + slex_in (in, tt_size); + tt_table.resize(tt_size); + for (std::size_t tt = 0; tt < tt_size; ++tt) + { + std::size_t nt_size = 0; + node_table_t &nt_table = tt_table[tt]; + + slex_in (in, nt_size); + nt_table.resize(nt_size); + for (std::size_t nt = 0; nt < nt_size; ++nt) + { + slex_in (in, nt_table[nt]); + } + } + + // load the acceptance index table + std::size_t ai_size = 0; + node_table_t &ai_table = in_dfa[dfa].acceptance_index; + + slex_in (in, ai_size); + ai_table.resize(ai_size); + for (std::size_t ai = 0; ai < ai_size; ++ai) + { + slex_in (in, ai_table[ai]); + } + } + + m_dfa.swap(in_dfa); // success, swap in the read values + m_num_states = num_states; + + m_compiled_dfa = true; + return true; +} + +#undef slex_in + +/////////////////////////////////////////////////////////////////////////////// +// save the lexer tables +#define slex_out(strm, val) \ + strm.write((char*)&val, sizeof(val)); \ + if (std::ios::goodbit != strm.rdstate()) return false + +template <typename IteratorT, typename TokenT, typename CallbackT> +inline bool +lexer<IteratorT, TokenT, CallbackT>::save (std::ofstream &out, long unique_id) +{ +// save signature and version information +long out_long = SLEX_SIGNATURE; + + slex_out(out, out_long); + out_long = SLEX_VERSION_100; + slex_out(out, out_long); + slex_out(out, unique_id); + +// save auxiliary members + slex_out(out, m_num_states); + +// save the dfa tables + typedef typename dfa_t::const_iterator dfa_iter_t; + typedef transition_table_t::const_iterator transition_table_iter_t; + typedef node_table_t::const_iterator node_table_iter_t; + + std::size_t out_size_t = m_dfa.size(); + slex_out(out, out_size_t); + + dfa_iter_t end = m_dfa.end(); + for (dfa_iter_t it = m_dfa.begin(); it != end; ++it) + { + // save the transition table + out_size_t = (*it).transition_table.size(); + slex_out(out, out_size_t); + + transition_table_iter_t tt_end = (*it).transition_table.end(); + for (transition_table_iter_t tt_it = (*it).transition_table.begin(); + tt_it != tt_end; + ++tt_it) + { + out_size_t = (*tt_it).size(); + slex_out(out, out_size_t); + + node_table_iter_t nt_end = (*tt_it).end(); + for (node_table_iter_t nt_it = (*tt_it).begin(); + nt_it != nt_end; + ++nt_it) + { + slex_out(out, (*nt_it)); + } + } + + // save the acceptance index table + out_size_t = (*it).acceptance_index.size(); + slex_out(out, out_size_t); + + node_table_iter_t nt_end = (*it).acceptance_index.end(); + for (node_table_iter_t nt_it = (*it).acceptance_index.begin(); + nt_it != nt_end; + ++nt_it) + { + slex_out(out, (*nt_it)); + } + } + return true; +} + +#undef slex_out + +/* +a lexer_control object supports some operations on the lexer. + get current lexer state + set state + terminate + state stack (push, pop, top) + set new token return value + ignore the current token + yymore + get length of matched token +*/ +template <typename TokenT> +class lexer_control +{ +public: + + lexer_control(TokenT& token, unsigned int& current_state, + std::stack<unsigned int>& state_stack); + // functions dealing with the lexer state + + // set the state to state + void set_state(unsigned int state); + + // get the current state + unsigned int get_state(); + + // pushes the current state onto the top of the state stack and + // switches to new_state + void push_state(unsigned int new_state); + + // pops the top of the state stack and switches to it. + void pop_state(); + + // returns the top of the stack without altering the stack's contents. + unsigned int top_state(); + + // functions dealing with the token returned. + + // set a new TokenT return value, overriding that one that was + // registered via. register_regex() + void set_token(const TokenT& token); + + // tell the lexer to return an invalid token, signifying termination. + void terminate(); + + // ignore the current token, and move on to the next one. The current + // token will NOT be returned from next_token() + void ignore_current_token(); + + // returns true if ignore_current_token() has been called, + // false otherwise. + bool ignore_current_token_set(); + +private: + TokenT& m_token; + bool m_ignore_current_token; + unsigned int& m_current_state; + std::stack<unsigned int>& m_state_stack; +}; + +template <typename TokenT> +inline +lexer_control<TokenT>::lexer_control(TokenT& token, unsigned int& current_state, + std::stack<unsigned int>& state_stack) + : m_token(token) + , m_ignore_current_token(false) + , m_current_state(current_state) + , m_state_stack(state_stack) +{ +} + +template <typename TokenT> +inline void +lexer_control<TokenT>::set_state(unsigned int state) +{ + m_current_state = state; +} + +template <typename TokenT> +inline unsigned int +lexer_control<TokenT>::get_state() +{ + return m_current_state; +} + +template <typename TokenT> +inline void +lexer_control<TokenT>::push_state(unsigned int new_state) +{ + m_state_stack.push(m_current_state); + m_current_state = new_state; +} + +template <typename TokenT> +inline void +lexer_control<TokenT>::pop_state() +{ + m_current_state = m_state_stack.top(); + m_state_stack.pop(); +} + +template <typename TokenT> +inline unsigned int +lexer_control<TokenT>::top_state() +{ + return m_state_stack.top(); +} + +template <typename TokenT> +inline void +lexer_control<TokenT>::set_token(const TokenT& token) +{ + m_token = token; +} + +template <typename TokenT> +inline void +lexer_control<TokenT>::terminate() +{ + m_token = -1; // TOOD: fix this, need to be determined by traits +} + +template <typename TokenT> +inline void +lexer_control<TokenT>::ignore_current_token() +{ + m_ignore_current_token = true; +} + +template <typename TokenT> +inline bool +lexer_control<TokenT>::ignore_current_token_set() +{ + return m_ignore_current_token; +} + +} // namespace classic +} // namespace spirit +} // namespace boost + +#undef BOOST_SPIRIT_IT_NS + +#endif + diff --git a/src/boost/libs/wave/samples/cpp_tokens/slex_interface.hpp b/src/boost/libs/wave/samples/cpp_tokens/slex_interface.hpp new file mode 100644 index 00000000..c89c2e9a --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/slex_interface.hpp @@ -0,0 +1,88 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Definition of the abstract lexer interface + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(SLEX_INTERFACE_HPP_E83F52A4_90AC_4FBE_A9A7_B65F7F94C497_INCLUDED) +#define SLEX_INTERFACE_HPP_E83F52A4_90AC_4FBE_A9A7_B65F7F94C497_INCLUDED + +#include <boost/wave/language_support.hpp> +#include <boost/wave/util/file_position.hpp> +#include <boost/wave/cpplexer/cpp_lex_interface.hpp> + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace cpplexer { +namespace slex { + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 +#define BOOST_WAVE_NEW_LEXER_DECL BOOST_WAVE_DECL +#else +#define BOOST_WAVE_NEW_LEXER_DECL +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// new_lexer_gen: generates a new instance of the required C++ lexer +// +/////////////////////////////////////////////////////////////////////////////// +template < + typename IteratorT, + typename PositionT = boost::wave::util::file_position_type +> +struct BOOST_WAVE_NEW_LEXER_DECL new_lexer_gen +{ +// The NewLexer function allows the opaque generation of a new lexer object. +// It is coupled to the token type to allow to decouple the lexer/token +// configurations at compile time. + static lex_input_interface<slex_token<PositionT> > * + new_lexer(IteratorT const &first, IteratorT const &last, + PositionT const &pos, boost::wave::language_support language); +}; + +#undef BOOST_WAVE_NEW_LEXER_DECL + +/////////////////////////////////////////////////////////////////////////////// +// +// The slex_input_interface helps to instantiate a concrete lexer to be used +// by the Wave preprocessor module. +// This is done to allow compile time reduction. +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename TokenT> +struct slex_input_interface +: lex_input_interface<TokenT> +{ + typedef typename lex_input_interface<TokenT>::position_type position_type; + + ~slex_input_interface() {} + +// The new_lexer function allows the opaque generation of a new lexer object. +// It is coupled to the token type to allow to distinguish different +// lexer/token configurations at compile time. + template <typename IteratorT> + static lex_input_interface<TokenT> * + new_lexer(IteratorT const &first, IteratorT const &last, + position_type const &pos, boost::wave::language_support language) + { + return new_lexer_gen<IteratorT, position_type>::new_lexer (first, last, + pos, language); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +} // namespace slex +} // namespace cpplexer +} // namespace wave +} // namespace boost + +#endif // !defined(SLEX_INTERFACE_HPP_E83F52A4_90AC_4FBE_A9A7_B65F7F94C497_INCLUDED) diff --git a/src/boost/libs/wave/samples/cpp_tokens/slex_iterator.hpp b/src/boost/libs/wave/samples/cpp_tokens/slex_iterator.hpp new file mode 100644 index 00000000..1fe5ce93 --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/slex_iterator.hpp @@ -0,0 +1,232 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Definition of the lexer iterator + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(SLEX_ITERATOR_HPP_AF0C37E3_CBD8_4F33_A225_51CF576FA61F_INCLUDED) +#define SLEX_ITERATOR_HPP_AF0C37E3_CBD8_4F33_A225_51CF576FA61F_INCLUDED + +#include <string> +#include <iostream> + +#include <boost/assert.hpp> +#include <boost/shared_ptr.hpp> +#include <boost/spirit/include/support_multi_pass.hpp> + +#include <boost/wave/language_support.hpp> +#include <boost/wave/util/file_position.hpp> +#include <boost/wave/util/functor_input.hpp> + +#include "slex_interface.hpp" + +#if 0 != __COMO_VERSION__ || !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) +#define BOOST_WAVE_EOF_PREFIX static +#else +#define BOOST_WAVE_EOF_PREFIX +#endif + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace cpplexer { +namespace slex { +namespace impl { + +/////////////////////////////////////////////////////////////////////////////// +// +// lex_iterator_functor_shim +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename TokenT> +class slex_iterator_functor_shim +{ + typedef typename TokenT::position_type position_type; + +public: + slex_iterator_functor_shim() +#if /*0 != __DECCXX_VER || */defined(__PGI) + : eof() +#endif // 0 != __DECCXX_VER + {} + +// interface to the boost::spirit::classic::iterator_policies::functor_input +// policy + typedef TokenT result_type; + typedef slex_iterator_functor_shim unique; + typedef lex_input_interface<TokenT>* shared; + + BOOST_WAVE_EOF_PREFIX result_type const eof; + + template <typename MultiPass> + static result_type& get_next(MultiPass& mp, result_type& result) + { + return mp.shared()->ftor->get(result); + } + + // this will be called whenever the last reference to a multi_pass will + // be released + template <typename MultiPass> + static void destroy(MultiPass& mp) + { + delete mp.shared()->ftor; + } + + template <typename MultiPass> + static void set_position(MultiPass& mp, position_type const &pos) + { + mp.shared()->ftor->set_position(pos); + } + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + template <typename MultiPass> + static bool has_include_guards(MultiPass& mp, std::string& guard_name) + { + return mp.shared()->ftor->has_include_guards(guard_name); + } +#endif + +private: + boost::shared_ptr<lex_input_interface<TokenT> > functor_ptr; +}; + +#if 0 != __COMO_VERSION__ || !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) +/////////////////////////////////////////////////////////////////////////////// +// eof token +template <typename TokenT> +typename slex_iterator_functor_shim<TokenT>::result_type const + slex_iterator_functor_shim<TokenT>::eof = + typename slex_iterator_functor_shim<TokenT>::result_type(); +#endif // 0 != __COMO_VERSION__ + +/////////////////////////////////////////////////////////////////////////////// +} // namespace impl + +/////////////////////////////////////////////////////////////////////////////// +// +// slex_iterator +// +// A generic C++ lexer interface class, which allows to plug in different +// lexer implementations (template parameter LexT). The following +// requirement apply: +// +// - the lexer type should have a function implemented, which returnes +// the next lexed token from the input stream: +// typename LexT::token_type get(); +// - at the end of the input stream this function should return the +// eof token equivalent +// - the lexer should implement a constructor taking two iterators +// pointing to the beginning and the end of the input stream and +// a third parameter containing the name of the parsed input file, +// the 4th parameter contains the information about the mode the +// preprocessor is used in (C99/C++ mode etc.) +// +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Divide the given functor type into its components (unique and shared) +// and build a std::pair from these parts +template <typename FunctorData> +struct make_multi_pass +{ + typedef + std::pair<typename FunctorData::unique, typename FunctorData::shared> + functor_data_type; + typedef typename FunctorData::result_type result_type; + + typedef boost::spirit::iterator_policies::split_functor_input input_policy; + typedef boost::spirit::iterator_policies::ref_counted ownership_policy; +#if defined(BOOST_WAVE_DEBUG) + typedef boost::spirit::iterator_policies::buf_id_check check_policy; +#else + typedef boost::spirit::iterator_policies::no_check check_policy; +#endif + typedef boost::spirit::iterator_policies::split_std_deque storage_policy; + + typedef boost::spirit::iterator_policies::default_policy< + ownership_policy, check_policy, input_policy, storage_policy> + policy_type; + typedef boost::spirit::multi_pass<functor_data_type, policy_type> type; +}; + +/////////////////////////////////////////////////////////////////////////////// +template <typename TokenT> +class slex_iterator +: public make_multi_pass<impl::slex_iterator_functor_shim<TokenT> >::type +{ + typedef impl::slex_iterator_functor_shim<TokenT> input_policy_type; + + typedef typename make_multi_pass<input_policy_type>::type base_type; + typedef typename make_multi_pass<input_policy_type>::functor_data_type + functor_data_type; + + typedef typename input_policy_type::unique unique_functor_type; + typedef typename input_policy_type::shared shared_functor_type; + +public: + typedef TokenT token_type; + + slex_iterator() + {} + + template <typename IteratorT> + slex_iterator(IteratorT const &first, IteratorT const &last, + typename TokenT::position_type const &pos, + boost::wave::language_support language) + : base_type( + functor_data_type( + unique_functor_type(), + slex_input_interface<TokenT> + ::new_lexer(first, last, pos, language) + ) + ) + {} + + void set_position(typename TokenT::position_type const &pos) + { + typedef typename token_type::position_type position_type; + + // set the new position in the current token + token_type const& currtoken = this->base_type::dereference(*this); + position_type currpos = currtoken.get_position(); + + currpos.set_file(pos.get_file()); + currpos.set_line(pos.get_line()); + const_cast<token_type&>(currtoken).set_position(currpos); + + // set the new position for future tokens as well + if (token_type::string_type::npos != + currtoken.get_value().find_first_of('\n')) + { + currpos.set_line(pos.get_line() + 1); + } + unique_functor_type::set_position(*this, currpos); + } + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + // return, whether the current file has include guards + // this function returns meaningful results only if the file was scanned + // completely + bool has_include_guards(std::string& guard_name) const + { + return unique_functor_type::has_include_guards(*this, guard_name); + } +#endif +}; + +/////////////////////////////////////////////////////////////////////////////// +} // slex +} // namespace cpplexer +} // namespace wave +} // namespace boost + +#undef BOOST_WAVE_EOF_PREFIX + +#endif // !defined(SLEX_ITERATOR_HPP_AF0C37E3_CBD8_4F33_A225_51CF576FA61F_INCLUDED) diff --git a/src/boost/libs/wave/samples/cpp_tokens/slex_token.hpp b/src/boost/libs/wave/samples/cpp_tokens/slex_token.hpp new file mode 100644 index 00000000..8a54776d --- /dev/null +++ b/src/boost/libs/wave/samples/cpp_tokens/slex_token.hpp @@ -0,0 +1,145 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + A generic C++ lexer token definition + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(SLEX_TOKEN_HPP_53A13BD2_FBAA_444B_9B8B_FCB225C2BBA8_INCLUDED) +#define SLEX_TOKEN_HPP_53A13BD2_FBAA_444B_9B8B_FCB225C2BBA8_INCLUDED + +#include <iomanip> +#include <ios> + +#include <boost/wave/wave_config.hpp> +#include <boost/wave/token_ids.hpp> +#include <boost/wave/language_support.hpp> +#include <boost/wave/util/file_position.hpp> + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace cpplexer { + +/////////////////////////////////////////////////////////////////////////////// +// forward declaration of the token type +template <typename PositionT = boost::wave::util::file_position_type> +class slex_token; + +/////////////////////////////////////////////////////////////////////////////// +// +// lex_token +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename PositionT> +class slex_token +{ +public: + typedef BOOST_WAVE_STRINGTYPE string_type; + typedef PositionT position_type; + + slex_token() + : id(T_EOI) + {} + + // construct an invalid token + explicit slex_token(int) + : id(T_UNKNOWN) + {} + + slex_token(token_id id_, string_type const &value_, PositionT const &pos_) + : id(id_), value(value_), pos(pos_) + {} + +// accessors + operator token_id() const { return id; } + string_type const &get_value() const { return value; } + position_type const &get_position() const { return pos; } + bool is_eoi() const { return id == T_EOI; } + bool is_valid() const { return id != T_UNKNOWN; } + + void set_token_id (token_id id_) { id = id_; } + void set_value (string_type const &newval) { value = newval; } + void set_position (position_type const &pos_) { pos = pos_; } + + friend bool operator== (slex_token const& lhs, slex_token const& rhs) + { + // two tokens are considered equal even if they contain different + // positions + return (lhs.id == rhs.id && lhs.value == rhs.value) ? true : false; + } + +// debug support +#if BOOST_WAVE_DUMP_PARSE_TREE != 0 +// access functions for the tree_to_xml functionality + static int get_token_id(slex_token const &t) + { return ID_FROM_TOKEN(token_id(t)); } + static string_type get_token_value(slex_token const &t) + { return t.get_value(); } +#endif + +// print support + void print (std::ostream &stream) const + { + using namespace std; + using namespace boost::wave; + + stream << std::setw(16) + << std::left << boost::wave::get_token_name(id) << " (" + << "#" << token_id(BASEID_FROM_TOKEN(*this)) + << ") at " << get_position().get_file() << " (" + << std::setw(3) << std::right << get_position().get_line() << "/" + << std::setw(2) << std::right << get_position().get_column() + << "): >"; + + for (std::size_t i = 0; i < value.size(); ++i) { + switch (value[i]) { + case '\r': stream << "\\r"; break; + case '\n': stream << "\\n"; break; + case '\t': stream << "\\t"; break; + default: + stream << value[i]; + break; + } + } + stream << "<"; + } + +private: + boost::wave::token_id id; // the token id + string_type value; // the text, which was parsed into this token + PositionT pos; // the original file position +}; + +template <typename PositionT> +inline std::ostream & +operator<< (std::ostream &stream, slex_token<PositionT> const &object) +{ + object.print(stream); + return stream; +} + +/////////////////////////////////////////////////////////////////////////////// +// This overload is needed by the multi_pass/functor_input_policy to +// validate a token instance. It has to be defined in the same namespace +// as the token class itself to allow ADL to find it. +/////////////////////////////////////////////////////////////////////////////// +template <typename Position> +inline bool +token_is_valid(slex_token<Position> const& t) +{ + return t.is_valid(); +} + +/////////////////////////////////////////////////////////////////////////////// +} // namespace cpplexer +} // namespace wave +} // namespace boost + +#endif // !defined(SLEX_TOKEN_HPP_53A13BD2_FBAA_444B_9B8B_FCB225C2BBA8_INCLUDED) diff --git a/src/boost/libs/wave/samples/custom_directives/build/Jamfile.v2 b/src/boost/libs/wave/samples/custom_directives/build/Jamfile.v2 new file mode 100644 index 00000000..ea03b9e6 --- /dev/null +++ b/src/boost/libs/wave/samples/custom_directives/build/Jamfile.v2 @@ -0,0 +1,17 @@ +# Boost.Wave: A Standard compliant C++ preprocessor library +# +# Boost Wave Library Sample Build Jamfile (advanced_hooks) +# +# http://www.boost.org/ +# +# Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost +# Software License, Version 1.0. (See accompanying file +# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +exe custom_directives + : ../custom_directives.cpp + /boost/wave//boost_wave + /boost/thread//boost_thread + /boost/date_time//boost_date_time + ; + diff --git a/src/boost/libs/wave/samples/custom_directives/custom_directives.cpp b/src/boost/libs/wave/samples/custom_directives/custom_directives.cpp new file mode 100644 index 00000000..e2eddcd3 --- /dev/null +++ b/src/boost/libs/wave/samples/custom_directives/custom_directives.cpp @@ -0,0 +1,124 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Sample demonstrating the usage of advanced preprocessor hooks. + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <iostream> +#include <fstream> +#include <string> +#include <vector> + +/////////////////////////////////////////////////////////////////////////////// +// Include Wave itself +#include <boost/wave.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include the lexer stuff +#include <boost/wave/cpplexer/cpp_lex_token.hpp> // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer class + +#include "custom_directives.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// Main entry point +// +// This sample shows how to use the advanced hooks to output not only the +// preprocessed tokens but also the conditional directives found in the input +// file (these are commented out, tough) and the tokens from inside the +// conditional block which were not evaluated because the corresponding +// condition was false. These tokens are commented out as well. +// +int main(int argc, char *argv[]) +{ + if (2 != argc) { + std::cerr << "Usage: custom_directives infile" << std::endl; + return -1; + } + +// current file position is saved for exception handling +boost::wave::util::file_position_type current_position; + + try { + // Open and read in the specified input file. + std::ifstream instream(argv[1]); + std::string instring; + + if (!instream.is_open()) { + std::cerr << "Could not open input file: " << argv[1] << std::endl; + return -2; + } + instream.unsetf(std::ios::skipws); + instring = std::string(std::istreambuf_iterator<char>(instream.rdbuf()), + std::istreambuf_iterator<char>()); + + // The template boost::wave::cpplexer::lex_token<> is the token type to be + // used by the Wave library. + typedef boost::wave::cpplexer::lex_token<> token_type; + + // The template boost::wave::cpplexer::lex_iterator<> is the lexer type to + // be used by the Wave library. + typedef boost::wave::cpplexer::lex_iterator<token_type> lex_iterator_type; + + // This is the resulting context type to use. The first template parameter + // should match the iterator type to be used during construction of the + // corresponding context object (see below). + typedef boost::wave::context<std::string::iterator, lex_iterator_type, + boost::wave::iteration_context_policies::load_file_to_string, + custom_directives_hooks + > context_type; + + // The preprocessor iterator shouldn't be constructed directly. It is + // to be generated through a wave::context<> object. This wave:context<> + // object additionally may be used to initialize and define different + // parameters of the actual preprocessing (not done here). + // + // The preprocessing of the input stream is done on the fly behind the + // scenes during iteration over the context_type::iterator_type stream. + context_type ctx (instring.begin(), instring.end(), argv[1]); + + ctx.set_language(boost::wave::enable_long_long(ctx.get_language())); + ctx.set_language(boost::wave::enable_preserve_comments(ctx.get_language())); + ctx.set_language(boost::wave::enable_prefer_pp_numbers(ctx.get_language())); + + // analyze the input file, print out the preprocessed tokens + context_type::iterator_type first = ctx.begin(); + context_type::iterator_type last = ctx.end(); + + while (first != last) { + current_position = (*first).get_position(); + std::cout << (*first).get_value(); + ++first; + } + } + catch (boost::wave::cpp_exception const& e) { + // some preprocessing error + std::cerr + << e.file_name() << "(" << e.line_no() << "): " + << e.description() << std::endl; + return 2; + } + catch (std::exception const& e) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "exception caught: " << e.what() + << std::endl; + return 3; + } + catch (...) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "unexpected exception caught." << std::endl; + return 4; + } + return 0; +} diff --git a/src/boost/libs/wave/samples/custom_directives/custom_directives.hpp b/src/boost/libs/wave/samples/custom_directives/custom_directives.hpp new file mode 100644 index 00000000..c18a8ae2 --- /dev/null +++ b/src/boost/libs/wave/samples/custom_directives/custom_directives.hpp @@ -0,0 +1,86 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(BOOST_WAVE_CUSTOM_DIRECTIVES_HOOKS_INCLUDED) +#define BOOST_WAVE_CUSTOM_DIRECTIVES_HOOKS_INCLUDED + +#include <cstdio> +#include <ostream> +#include <string> +#include <algorithm> + +#include <boost/assert.hpp> +#include <boost/config.hpp> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/util/macro_helpers.hpp> +#include <boost/wave/preprocessing_hooks.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// The custom_directives_hooks policy class is used to register some +// of the more advanced (and probably more rarely used hooks with the Wave +// library. +// +// This policy type is used as a template parameter to the boost::wave::context<> +// object. +// +/////////////////////////////////////////////////////////////////////////////// +class custom_directives_hooks +: public boost::wave::context_policies::default_preprocessing_hooks +{ +public: + /////////////////////////////////////////////////////////////////////////// + // + // The function 'found_unknown_directive' is called, whenever an unknown + // preprocessor directive was encountered. + // + // The parameter 'ctx' is a reference to the context object used for + // instantiating the preprocessing iterators by the user. + // + // The parameter 'line' holds the tokens of the entire source line + // containing the unknown directive. + // + // The parameter 'pending' may be used to push tokens back into the input + // stream, which are to be used as the replacement text for the whole + // line containing the unknown directive. + // + // The return value defines, whether the given expression has been + // properly interpreted by the hook function or not. If this function + // returns 'false', the library will raise an 'ill_formed_directive' + // preprocess_exception. Otherwise the tokens pushed back into 'pending' + // are passed on to the user program. + // + /////////////////////////////////////////////////////////////////////////// + template <typename ContextT, typename ContainerT> + bool + found_unknown_directive(ContextT const& ctx, ContainerT const& line, + ContainerT& pending) + { + namespace wave = boost::wave; + + typedef typename ContainerT::const_iterator iterator_type; + iterator_type it = line.begin(); + wave::token_id id = wave::util::impl::skip_whitespace(it, line.end()); + + if (id != wave::T_IDENTIFIER) + return false; // nothing we could do + + if ((*it).get_value() == "version" || (*it).get_value() == "extension") + { + // handle #version and #extension directives + std::copy(line.begin(), line.end(), std::back_inserter(pending)); + return true; + } + + return false; // unknown directive + } +}; + +#endif // !defined(BOOST_WAVE_ADVANCED_PREPROCESSING_HOOKS_INCLUDED) diff --git a/src/boost/libs/wave/samples/custom_directives/custom_directives.input b/src/boost/libs/wave/samples/custom_directives/custom_directives.input new file mode 100644 index 00000000..be09bd6e --- /dev/null +++ b/src/boost/libs/wave/samples/custom_directives/custom_directives.input @@ -0,0 +1,8 @@ +// This example recognizes two additional preprocessor directives (as defined +// in GLSL - OpenGL Shader Language). + +#version 150 core +#extension all : require // trailing comment + +// the following directive is not supported, so it will trigger an exception +#not_supported_directive diff --git a/src/boost/libs/wave/samples/emit_custom_line_directives/build/Jamfile.v2 b/src/boost/libs/wave/samples/emit_custom_line_directives/build/Jamfile.v2 new file mode 100644 index 00000000..ef24b424 --- /dev/null +++ b/src/boost/libs/wave/samples/emit_custom_line_directives/build/Jamfile.v2 @@ -0,0 +1,17 @@ +# Boost.Wave: A Standard compliant C++ preprocessor library +# +# Boost Wave Library Sample Build Jamfile (advanced_hooks) +# +# http://www.boost.org/ +# +# Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost +# Software License, Version 1.0. (See accompanying file +# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +exe emit_custom_line_directives + : ../emit_custom_line_directives.cpp + /boost/wave//boost_wave + /boost/thread//boost_thread + /boost/date_time//boost_date_time + ; + diff --git a/src/boost/libs/wave/samples/emit_custom_line_directives/emit_custom_line_directives.cpp b/src/boost/libs/wave/samples/emit_custom_line_directives/emit_custom_line_directives.cpp new file mode 100644 index 00000000..3ccbbde1 --- /dev/null +++ b/src/boost/libs/wave/samples/emit_custom_line_directives/emit_custom_line_directives.cpp @@ -0,0 +1,124 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Sample demonstrating the usage of advanced preprocessor hooks. + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <iostream> +#include <fstream> +#include <string> +#include <vector> + +/////////////////////////////////////////////////////////////////////////////// +// Include Wave itself +#include <boost/wave.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include the lexer stuff +#include <boost/wave/cpplexer/cpp_lex_token.hpp> // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer class + +#include "emit_custom_line_directives.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// Main entry point +// +// This sample shows how to use the emit_line_directive preprocessing hooks +// to customize the format of any generated #line directive. The sample will +// emit #line directives formatted compatible with those generated by gcc: +// +// # <lineno> <rel_file_name> +// +int main(int argc, char *argv[]) +{ + if (2 != argc) { + std::cerr << "Usage: emit_custom_line_directives infile" << std::endl; + return -1; + } + +// current file position is saved for exception handling +boost::wave::util::file_position_type current_position; + + try { + // Open and read in the specified input file. + std::ifstream instream(argv[1]); + std::string instring; + + if (!instream.is_open()) { + std::cerr << "Could not open input file: " << argv[1] << std::endl; + return -2; + } + instream.unsetf(std::ios::skipws); + instring = std::string(std::istreambuf_iterator<char>(instream.rdbuf()), + std::istreambuf_iterator<char>()); + + // The template boost::wave::cpplexer::lex_token<> is the token type to be + // used by the Wave library. + typedef boost::wave::cpplexer::lex_token<> token_type; + + // The template boost::wave::cpplexer::lex_iterator<> is the lexer type to + // be used by the Wave library. + typedef boost::wave::cpplexer::lex_iterator<token_type> lex_iterator_type; + + // This is the resulting context type to use. The first template parameter + // should match the iterator type to be used during construction of the + // corresponding context object (see below). + typedef boost::wave::context<std::string::iterator, lex_iterator_type, + boost::wave::iteration_context_policies::load_file_to_string, + emit_custom_line_directives_hooks + > context_type; + + // The preprocessor iterator shouldn't be constructed directly. It is + // to be generated through a wave::context<> object. This wave:context<> + // object additionally may be used to initialize and define different + // parameters of the actual preprocessing (not done here). + // + // The preprocessing of the input stream is done on the fly behind the + // scenes during iteration over the context_type::iterator_type stream. + context_type ctx (instring.begin(), instring.end(), argv[1]); + + ctx.set_language(boost::wave::enable_long_long(ctx.get_language())); + ctx.set_language(boost::wave::enable_preserve_comments(ctx.get_language())); + ctx.set_language(boost::wave::enable_prefer_pp_numbers(ctx.get_language())); + + // analyze the input file, print out the preprocessed tokens + context_type::iterator_type first = ctx.begin(); + context_type::iterator_type last = ctx.end(); + + while (first != last) { + current_position = (*first).get_position(); + std::cout << (*first).get_value(); + ++first; + } + } + catch (boost::wave::cpp_exception const& e) { + // some preprocessing error + std::cerr + << e.file_name() << "(" << e.line_no() << "): " + << e.description() << std::endl; + return 2; + } + catch (std::exception const& e) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "exception caught: " << e.what() + << std::endl; + return 3; + } + catch (...) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "unexpected exception caught." << std::endl; + return 4; + } + return 0; +} diff --git a/src/boost/libs/wave/samples/emit_custom_line_directives/emit_custom_line_directives.hpp b/src/boost/libs/wave/samples/emit_custom_line_directives/emit_custom_line_directives.hpp new file mode 100644 index 00000000..2284a3c8 --- /dev/null +++ b/src/boost/libs/wave/samples/emit_custom_line_directives/emit_custom_line_directives.hpp @@ -0,0 +1,107 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(BOOST_WAVE_emit_custom_line_directives_HOOKS_INCLUDED) +#define BOOST_WAVE_emit_custom_line_directives_HOOKS_INCLUDED + +#include <cstdio> +#include <ostream> +#include <string> +#include <algorithm> + +#include <boost/assert.hpp> +#include <boost/config.hpp> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/util/macro_helpers.hpp> +#include <boost/wave/preprocessing_hooks.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// The emit_custom_line_directives_hooks policy class is used to register some +// of the more advanced (and probably more rarely used hooks with the Wave +// library. +// +// This policy type is used as a template parameter to the boost::wave::context<> +// object. +// +/////////////////////////////////////////////////////////////////////////////// +class emit_custom_line_directives_hooks +: public boost::wave::context_policies::default_preprocessing_hooks +{ +public: + /////////////////////////////////////////////////////////////////////////// + // + // The function 'emit_line_directive' is called whenever a #line directive + // has to be emitted into the generated output. + // + // The parameter 'ctx' is a reference to the context object used for + // instantiating the preprocessing iterators by the user. + // + // The parameter 'pending' may be used to push tokens back into the input + // stream, which are to be used instead of the default output generated + // for the #line directive. + // + // The parameter 'act_token' contains the actual #pragma token, which may + // be used for error output. The line number stored in this token can be + // used as the line number emitted as part of the #line directive. + // + // If the return value is 'false', a default #line directive is emitted + // by the library. A return value of 'true' will inhibit any further + // actions, the tokens contained in 'pending' will be copied verbatim + // to the output. + // + /////////////////////////////////////////////////////////////////////////// + template <typename ContextT, typename ContainerT> + bool + emit_line_directive(ContextT const& ctx, ContainerT &pending, + typename ContextT::token_type const& act_token) + { + // emit a #line directive showing the relative filename instead + typename ContextT::position_type pos = act_token.get_position(); + unsigned int column = 1; + + typedef typename ContextT::token_type result_type; + using namespace boost::wave; + + pos.set_column(column); + pending.push_back(result_type(T_POUND, "#", pos)); + + pos.set_column(++column); // account for '#' + pending.push_back(result_type(T_SPACE, " ", pos)); + + // 21 is the max required size for a 64 bit integer represented as a + // string + char buffer[22]; + + using namespace std; // for some systems sprintf is in namespace std + sprintf (buffer, "%d", pos.get_line()); + + pos.set_column(++column); // account for ' ' + pending.push_back(result_type(T_INTLIT, buffer, pos)); + pos.set_column(column += (unsigned int)strlen(buffer)); // account for <number> + pending.push_back(result_type(T_SPACE, " ", pos)); + pos.set_column(++column); // account for ' ' + + std::string file("\""); + boost::filesystem::path filename( + boost::wave::util::create_path(ctx.get_current_relative_filename().c_str())); + + using boost::wave::util::impl::escape_lit; + file += escape_lit(boost::wave::util::native_file_string(filename)) + "\""; + + pending.push_back(result_type(T_STRINGLIT, file.c_str(), pos)); + pos.set_column(column += (unsigned int)file.size()); // account for filename + pending.push_back(result_type(T_GENERATEDNEWLINE, "\n", pos)); + + return true; + } +}; + +#endif // !defined(BOOST_WAVE_ADVANCED_PREPROCESSING_HOOKS_INCLUDED) diff --git a/src/boost/libs/wave/samples/hannibal/build/Jamfile.v2 b/src/boost/libs/wave/samples/hannibal/build/Jamfile.v2 new file mode 100644 index 00000000..32a65d94 --- /dev/null +++ b/src/boost/libs/wave/samples/hannibal/build/Jamfile.v2 @@ -0,0 +1,20 @@ +# Boost.Wave: A Standard compliant C++ preprocessor library +# +# Boost Wave Library Sample Build Jamfile (Hannibal) +# +# http://www.boost.org/ +# +# Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost +# Software License, Version 1.0. (See accompanying file +# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +exe hannibal + : ../hannibal.cpp + /boost/wave//boost_wave + /boost/filesystem//boost_filesystem + /boost/program_options//boost_program_options + /boost/system//boost_system + /boost/thread//boost_thread + /boost/date_time//boost_date_time + ; + diff --git a/src/boost/libs/wave/samples/hannibal/hannibal.cpp b/src/boost/libs/wave/samples/hannibal/hannibal.cpp new file mode 100644 index 00000000..fa9e1f29 --- /dev/null +++ b/src/boost/libs/wave/samples/hannibal/hannibal.cpp @@ -0,0 +1,319 @@ +// Hannibal: partial C++ grammar to parse C++ type information +// Copyright (c) 2005-2006 Danny Havenith +// +// Boost.Wave: A Standard compliant C++ preprocessor +// Copyright (c) 2001-2010 Hartmut Kaiser +// +// http://www.boost.org/ +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#define HANNIBAL_DUMP_PARSE_TREE 1 +//#define HANNIBAL_TRACE_DECLARATIONS +//#define BOOST_SPIRIT_DEBUG + +#include <iostream> +#include <fstream> +#include <string> +#include <vector> + +#include <boost/spirit/include/classic_ast.hpp> +#include <boost/spirit/include/classic_tree_to_xml.hpp> +#include <boost/program_options.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include Wave itself +#include <boost/wave.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include the lexer stuff +#include <boost/wave/cpplexer/cpp_lex_token.hpp> // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer class + +/////////////////////////////////////////////////////////////////////////////// +// Include the Hannibal grammar +#include "translation_unit_parser.h" +#include "translation_unit_skipper.h" + +using std::vector; +using std::string; +namespace po = boost::program_options; + +#if HANNIBAL_DUMP_PARSE_TREE != 0 +/////////////////////////////////////////////////////////////////////////////// +namespace { + + /////////////////////////////////////////////////////////////////////////// + // helper routines needed to generate the parse tree XML dump + typedef boost::wave::cpplexer::lex_token<> token_type; + + token_type::string_type get_token_id(token_type const &t) + { + using namespace boost::wave; + return get_token_name(token_id(t)); // boost::wave::token_id(t); + } + + token_type::string_type get_token_value(token_type const &t) + { + return t.get_value(); + } + +/////////////////////////////////////////////////////////////////////////////// +} // unnamed namespace +#endif + +/////////////////////////////////////////////////////////////////////////////// +namespace { + + /////////////////////////////////////////////////////////////////////////// + // Parse the command line for input files and (system-) include paths + // Prints usage info if needed. + // returns true if program should continue, false if program must stop + bool parse_command_line( int argc, char *argv[], po::variables_map &vm) + { + // + // Setup command line structure + po::options_description visible("Usage: hannibal [options] file"); + visible.add_options() + ("help,h", "show this help message") + ("include,I", po::value<vector<string> >(), + "specify additional include directory") + ("sysinclude,S", po::value<vector<string> >(), + "specify additional system include directory") + ("define,D", po::value<vector<string> >()->composing(), + "specify a macro to define (as macro[=[value]])") + ("predefine,P", po::value<vector<string> >()->composing(), + "specify a macro to predefine (as macro[=[value]])") + ("undefine,U", po::value<vector<string> >()->composing(), + "specify a macro to undefine") + ; + + po::options_description hidden; + hidden.add_options() + ("input-file", "input file"); + + po::options_description desc; + desc.add( visible).add( hidden); + + po::positional_options_description p; + p.add("input-file", 1); + + // + // Parse + po::store(po::command_line_parser(argc, argv). + options(desc).positional(p).run(), vm); + po::notify(vm); + + // + // Print usage, if necessary + if (!vm.count( "input-file") || vm.count( "help")) + { + std::cout << visible << std::endl; + return false; + } + else + { + return true; + } + } + +/////////////////////////////////////////////////////////////////////////////// +} // unnamed namespace + +/////////////////////////////////////////////////////////////////////////////// +// main entry point +int main(int argc, char *argv[]) +{ + po::variables_map vm; + + if (!parse_command_line( argc, argv, vm)) + { + return -1; + } + + string inputfile = vm["input-file"].as< string>(); + +// current file position is saved for exception handling +boost::wave::util::file_position_type current_position; + + try { + // Open and read in the specified input file. + std::ifstream instream( inputfile.c_str()); + std::string instring; + + if (!instream.is_open()) { + std::cerr << "Hannibal: could not open input file: " << inputfile + << std::endl; + return -2; + } + instream.unsetf(std::ios::skipws); + instring = std::string(std::istreambuf_iterator<char>(instream.rdbuf()), + std::istreambuf_iterator<char>()); + + // The template boost::wave::cpplexer::lex_token<> is the token type to be + // used by the Wave library. + typedef boost::wave::cpplexer::lex_token<> token_type; + + // The template boost::wave::cpplexer::lex_iterator<> is the lexer type to + // be used by the Wave library. + typedef boost::wave::cpplexer::lex_iterator<token_type> lex_iterator_type; + + // This is the resulting context type to use. The first template parameter + // should match the iterator type to be used during construction of the + // corresponding context object (see below). + typedef boost::wave::context< + std::string::iterator, + lex_iterator_type, + boost::wave::iteration_context_policies::load_file_to_string + > context_type; + + // The preprocessor iterator shouldn't be constructed directly. It is + // to be generated through a wave::context<> object. This wave:context<> + // object is to be used additionally to initialize and define different + // parameters of the actual preprocessing (not done here). + // + // The preprocessing of the input stream is done on the fly behind the + // scenes during iteration over the context_type::iterator_type stream. + context_type ctx (instring.begin(), instring.end(), inputfile.c_str()); + + // add include directories to the include path + if (vm.count("include")) { + vector<string> const &paths = + vm["include"].as<vector<string> >(); + vector<string>::const_iterator end = paths.end(); + for (vector<string>::const_iterator cit = paths.begin(); + cit != end; ++cit) + { + ctx.add_include_path((*cit).c_str()); + } + } + + // add system include directories to the include path + if (vm.count("sysinclude")) { + vector<string> const &syspaths = + vm["sysinclude"].as<vector<string> >(); + vector<string>::const_iterator end = syspaths.end(); + for (vector<string>::const_iterator cit = syspaths.begin(); + cit != end; ++cit) + { + ctx.add_sysinclude_path((*cit).c_str()); + } + } + + // add additional defined macros + if (vm.count("define")) { + vector<string> const ¯os = vm["define"].as<vector<string> >(); + vector<string>::const_iterator end = macros.end(); + for (vector<string>::const_iterator cit = macros.begin(); + cit != end; ++cit) + { + ctx.add_macro_definition(*cit); + } + } + + // add additional predefined macros + if (vm.count("predefine")) { + vector<string> const &predefmacros = + vm["predefine"].as<vector<string> >(); + vector<string>::const_iterator end = predefmacros.end(); + for (vector<string>::const_iterator cit = predefmacros.begin(); + cit != end; ++cit) + { + ctx.add_macro_definition(*cit, true); + } + } + + // undefine specified macros + if (vm.count("undefine")) { + vector<string> const &undefmacros = + vm["undefine"].as<vector<string> >(); + vector<string>::const_iterator end = undefmacros.end(); + for (vector<string>::const_iterator cit = undefmacros.begin(); + cit != end; ++cit) + { + ctx.remove_macro_definition((*cit).c_str(), true); + } + } + + // analyze the input file + context_type::iterator_type first = ctx.begin(); + context_type::iterator_type last = ctx.end(); + + translation_unit_skipper s; + +#if HANNIBAL_DUMP_PARSE_TREE != 0 + typedef boost::spirit::classic::tree_parse_info<context_type::iterator_type> + result_type; + translation_unit_grammar::rule_map_type rule_map; + translation_unit_grammar g(&rule_map); + + // parse the input file + result_type pi = boost::spirit::classic::ast_parse(first, last, g, s); +#else + typedef boost::spirit::classic::parse_info<context_type::iterator_type> + result_type; + translation_unit_grammar g; + + // parse the input file + result_type pi = boost::spirit::classic::parse(first, last, g, s); +#endif + + if (pi.full) { + std::cout + << "Hannibal: parsed sucessfully: " << inputfile << std::endl; + +#if HANNIBAL_DUMP_PARSE_TREE != 0 + // generate xml dump from parse tree, if requested + boost::spirit::classic::tree_to_xml(std::cerr, pi.trees, "", rule_map, + &get_token_id, &get_token_value); +#endif + } + else { + std::cerr + << "Hannibal: parsing failed: " << inputfile << std::endl; + std::cerr + << "Hannibal: last recognized token was: " + << get_token_id(*pi.stop) << std::endl; + + using boost::wave::util::file_position_type; + file_position_type const& pos(pi.stop->get_position()); + std::cerr + << "Hannibal: at: " << pos.get_file() << "(" << pos.get_line() + << "," << pos.get_column() << ")" << std::endl; + return 1; + } + } + catch (boost::wave::cpp_exception const& e) { + // some preprocessing error + std::cerr + << e.file_name() << ":" << e.line_no() << ":" << e.column_no() + << ": " << e.description() << std::endl; + return 2; + } + catch (boost::wave::cpplexer::lexing_exception const& e) { + // some lexing error + std::cerr + << e.file_name() << ":" << e.line_no() << ":" << e.column_no() + << ": " << e.description() << std::endl; + return 2; + } + catch (std::exception const& e) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "exception caught: " << e.what() + << std::endl; + return 3; + } + catch (...) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "unexpected exception caught." << std::endl; + return 4; + } + return 0; +} diff --git a/src/boost/libs/wave/samples/hannibal/translation_unit_parser.h b/src/boost/libs/wave/samples/hannibal/translation_unit_parser.h new file mode 100644 index 00000000..48b9a032 --- /dev/null +++ b/src/boost/libs/wave/samples/hannibal/translation_unit_parser.h @@ -0,0 +1,1345 @@ +// Hannibal: partial C++ grammar to parse C++ type information +// Copyright (c) 2005-2006 Danny Havenith +// +// Boost.Wave: A Standard compliant C++ preprocessor +// Copyright (c) 2001-2009 Hartmut Kaiser +// +// http://www.boost.org/ +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#if !defined(HANNIBAL_TRANSLATION_UNIT_GRAMMAR_H_INCLUDED) +#define HANNIBAL_TRANSLATION_UNIT_GRAMMAR_H_INCLUDED + +#include <map> + +#include <boost/assert.hpp> +#include <boost/spirit/include/classic_core.hpp> +#include <boost/spirit/include/classic_confix.hpp> + +#include <boost/wave/wave_config.hpp> +#include <boost/wave/token_ids.hpp> +#include <boost/wave/util/pattern_parser.hpp> + +// +// If so required, trace every declaration and member-declaration. +// This can be a much faster alternative to BOOST_SPIRIT_DEBUG-type of +// debugging. +// +#ifdef HANNIBAL_TRACE_DECLARATIONS +struct trace_actor +{ + trace_actor( + const char rule_type[], + std::ostream &strm + ) + : strm_( strm), rule_type_( rule_type) + { + // nop + } + + template<typename PositionIterator> + void operator()(PositionIterator begin, PositionIterator end) const + { + typedef const boost::wave::cpplexer::lex_token<>::position_type + position_type; + //typedef pos_iterator_type::token_type::position_type position_type; + + position_type &begin_pos(begin->get_position()); + + strm_ << "Parsed " << rule_type_ << std::endl; + strm_ << " from: " << begin_pos.get_file() + << "(" << begin_pos.get_line() << ")" + << std::endl; + }; + +private: + std::ostream &strm_; + char const* const rule_type_; +}; + +#define HANNIBAL_TRACE_ACTION( type) [trace_actor( (type), std::cout)] +#else +#define HANNIBAL_TRACE_ACTION( type) +#endif + +/////////////////////////////////////////////////////////////////////////////// +#define HANNIBAL_TRACE_TRANSLATION_UNIT_GRAMMAR \ + bool(BOOST_SPIRIT_DEBUG_FLAGS_CPP & BOOST_SPIRIT_DEBUG_FLAGS_CPP_EXPR_GRAMMAR) \ + /**/ + +/////////////////////////////////////////////////////////////////////////////// +// Helper macro to register rules for debugging +#if HANNIBAL_DUMP_PARSE_TREE != 0 +#define HANNIBAL_REGISTER_RULE(r) \ + BOOST_SPIRIT_DEBUG_NODE(r); \ + self.declare_rule(r, #r) \ + /**/ +#else +#define HANNIBAL_REGISTER_RULE(r) \ + BOOST_SPIRIT_DEBUG_NODE(r) \ + /**/ +#endif + +/////////////////////////////////////////////////////////////////////////////// +struct dump_actor { + template<typename ForwardIterator> + void operator()(ForwardIterator begin, ForwardIterator end) + { + std::cerr << "*** COULD NOT PARSE THE FOLLOWING ***" << std::endl; + while (begin != end) + { + std::cerr << begin->get_value(); + ++begin; + } + } +} dump_a; + +/////////////////////////////////////////////////////////////////////////////// +struct translation_unit_grammar +: public boost::spirit::classic::grammar<translation_unit_grammar> +{ +#if HANNIBAL_DUMP_PARSE_TREE != 0 +// +// allow an external map with rule-id -> rule-name mappings. +// this map is external so it can be altered by the definition constructor, +// which receives a const grammar object. +// +// Please Note: the lifetime of the rule map should at least extend beyond the +// call of the definition constructor... +// + typedef std::map<boost::spirit::classic::parser_id, std::string> + rule_map_type; + + translation_unit_grammar(rule_map_type *rule_map_ptr_ = 0) + : rule_map_ptr(rule_map_ptr_) +#else + translation_unit_grammar() +#endif + { + BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME(*this, + "translation_unit_grammar", HANNIBAL_TRACE_TRANSLATION_UNIT_GRAMMAR); + } + + template <typename ScannerT> + struct definition + { + // declare non-terminals + typedef boost::spirit::classic::rule<ScannerT> rule_type; + + rule_type constant_expression; + rule_type logical_or_exp, logical_and_exp; + rule_type inclusive_or_exp, exclusive_or_exp, and_exp; + rule_type cmp_equality, cmp_relational; + rule_type shift_exp; + rule_type add_exp, multiply_exp; + rule_type unary_exp, primary_exp, constant; + + boost::spirit::classic::subrule<0> const_exp_subrule; + boost::spirit::classic::subrule<1> shift_exp_clos; + + rule_type simple_type_name, class_keywords; + rule_type storage_class_specifier, cv_qualifier, function_specifier; + rule_type access_specifier; + rule_type extension_type_decorator; + rule_type operator_sym; + rule_type class_key; + rule_type enumerator; + rule_type enumerator_list; + rule_type enumerator_definition; + rule_type member_declarator; + rule_type member_declarator_list; + rule_type member_declaration; + rule_type constant_initializer; + rule_type pure_specifier; + rule_type namespace_body; + rule_type type_id; + rule_type unnamed_namespace_definition; + rule_type extension_namespace_definition; + rule_type original_namespace_definition; + rule_type named_namespace_definition; + rule_type namespace_definition; + rule_type linkage_specification; + rule_type explicit_specialization; + rule_type using_directive; + rule_type using_declaration; + rule_type type_parameter; + rule_type template_parameter; + rule_type template_parameter_list; + rule_type template_declaration; + rule_type explicit_instantiation; + rule_type qualified_namespace_specifier; + rule_type namespace_alias_definition; + rule_type expression_list; + rule_type initializer_list; + rule_type initializer_clause; + rule_type initializer; + rule_type init_declarator; + rule_type init_declarator_list; + rule_type asm_definition; + rule_type simple_declaration; + rule_type block_declaration; + rule_type declaration; + rule_type declaration_seq; + rule_type translation_unit; + + rule_type function_definition, function_definition_helper, declarator; + rule_type direct_declarator, parameters_or_array_spec; + rule_type abstract_declarator, direct_abstract_declarator; + rule_type direct_abstract_declarator_helper; + rule_type parameter_declaration_clause, parameter_declaration_list; + rule_type parameter_declaration, assignment_expression, decimal_literal; + rule_type octal_literal, hexadecimal_literal; + rule_type declarator_id, id_expression, qualified_id, unqualified_id; + rule_type operator_function_id, conversion_function_id, conversion_type_id; + rule_type conversion_declarator, function_body; + rule_type compound_statement, ctor_initializer, ptr_operator; + rule_type decl_specifier, type_specifier; + rule_type type_specifier_seq, cv_qualifier_seq, enum_specifier; + rule_type enum_keyword, simple_type_specifier; + rule_type class_specifier, member_specification, class_head; + rule_type type_name, elaborated_type_specifier, template_argument_list; + rule_type template_argument, nested_name_specifier; + rule_type class_or_namespace_name, class_name, enum_name, typedef_name; + rule_type namespace_name, template_id; + rule_type decl_specifier_seq, no_type_decl_specifier; + rule_type function_try_block, handler_seq, handler; + rule_type exception_specification, template_name; + rule_type original_namespace_name, base_specifier; + rule_type base_specifier_list, base_clause; + rule_type odd_language_extension, mem_initializer_id; + rule_type mem_initializer, mem_initializer_list; + + + rule_type ta_expression_operator; + rule_type ta_logical_or_expression; + rule_type ta_expression; + rule_type ta_conditional_expression; + rule_type ta_throw_expression; + rule_type ta_assignment_expression; + rule_type postfix_expression_helper; + rule_type simple_postfix_expression; + rule_type pseudo_destructor_name; + rule_type direct_new_declarator; + rule_type new_declarator; + rule_type new_initializer; + rule_type new_type_id; + rule_type new_placement; + rule_type delete_expression; + rule_type new_expression; + rule_type unary_operator; + rule_type postfix_expression; + rule_type unary_expression; + rule_type expression_operator; + rule_type cast_expression; + rule_type throw_expression; + rule_type assignment_operator; + rule_type logical_or_expression; + rule_type conditional_expression; + rule_type boolean_literal; + rule_type string_literal; + rule_type floating_literal; + rule_type character_literal; + rule_type integer_literal; + rule_type expression; + rule_type literal; + rule_type primary_expression; + + // + // grammar definition. + + definition(translation_unit_grammar const& self) + { + using namespace boost::spirit::classic; + using namespace boost::wave; + using boost::wave::util::pattern_p; + + // + // First, a long list of expression rules. + // + HANNIBAL_REGISTER_RULE( primary_expression); + primary_expression + = literal + | ch_p(T_THIS) + | ch_p(T_COLON_COLON) >> ch_p(T_IDENTIFIER) + | ch_p(T_COLON_COLON) >> operator_function_id + | ch_p(T_COLON_COLON) >> qualified_id + | ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN) + | id_expression + ; + + HANNIBAL_REGISTER_RULE( literal); + literal + = integer_literal + | character_literal + | floating_literal + | string_literal + | boolean_literal + ; + + HANNIBAL_REGISTER_RULE( integer_literal); + integer_literal + = pattern_p( IntegerLiteralTokenType, TokenTypeMask) + ; + + HANNIBAL_REGISTER_RULE( character_literal); + character_literal + = pattern_p( CharacterLiteralTokenType, TokenTypeMask) + ; + + HANNIBAL_REGISTER_RULE( floating_literal); + floating_literal + = pattern_p( FloatingLiteralTokenType, TokenTypeMask) + ; + + HANNIBAL_REGISTER_RULE( string_literal); + string_literal + = pattern_p( StringLiteralTokenType, TokenTypeMask) + ; + + HANNIBAL_REGISTER_RULE( boolean_literal); + boolean_literal + = pattern_p( BoolLiteralTokenType, TokenTypeMask) + ; + + // + // TODO: separate assignment expression into a grammar of it's own + // + HANNIBAL_REGISTER_RULE( assignment_expression); + assignment_expression + = conditional_expression + | logical_or_expression >> assignment_operator >> assignment_expression + | throw_expression + ; + + // + // Have a separate assignment expression for template arguments. + // This is needed, because without it, an expression of the form + // template < a, b, c > x; + // would not parse, since the 'c > x' part would be taken by the + // assignment expression. + // + // Note that this ta_xxxxx duplication cascades all the way down to + // logical_or_expression. + // Both the previous example and a declaration of the form + // template < a, b, (c > d) > x; + // should parse fine now. + // + // + HANNIBAL_REGISTER_RULE( ta_assignment_expression); + ta_assignment_expression + = ta_conditional_expression + | ta_logical_or_expression >> assignment_operator >> ta_assignment_expression + | ta_throw_expression + ; + + HANNIBAL_REGISTER_RULE( throw_expression); + throw_expression + = ch_p(T_THROW) >> !assignment_expression + ; + + HANNIBAL_REGISTER_RULE( ta_throw_expression); + ta_throw_expression + = ch_p(T_THROW) >> !ta_assignment_expression + ; + + HANNIBAL_REGISTER_RULE( conditional_expression); + conditional_expression + = logical_or_expression + >> !( + ch_p(T_QUESTION_MARK) + >> expression + >> ch_p(T_COLON) + >> assignment_expression + ) + ; + + HANNIBAL_REGISTER_RULE( ta_conditional_expression); + ta_conditional_expression + = ta_logical_or_expression + >> !( + ch_p(T_QUESTION_MARK) + >> ta_expression + >> ch_p(T_COLON) + >> ta_assignment_expression + ) + ; + + HANNIBAL_REGISTER_RULE( expression); + expression + = assignment_expression % ch_p(T_COMMA); + + HANNIBAL_REGISTER_RULE( ta_expression); + ta_expression + = ta_assignment_expression % ch_p(T_COMMA); + + HANNIBAL_REGISTER_RULE( assignment_operator); + assignment_operator + = pp(T_ASSIGN) + | pp(T_ANDASSIGN) + | pp(T_ORASSIGN) + | pp(T_XORASSIGN) + | pp(T_DIVIDEASSIGN) + | pp(T_MINUSASSIGN) + | pp(T_PERCENTASSIGN) + | pp(T_PLUSASSIGN) + | pp(T_SHIFTLEFTASSIGN) + | pp(T_SHIFTRIGHTASSIGN) + | pp(T_STARASSIGN) + ; + + + // we skip quite a few rules here, since we're not interested in operator precedence + // just now. + HANNIBAL_REGISTER_RULE( logical_or_expression); + logical_or_expression + = cast_expression % expression_operator + ; + + HANNIBAL_REGISTER_RULE( ta_logical_or_expression); + ta_logical_or_expression + = cast_expression % ta_expression_operator + ; + + HANNIBAL_REGISTER_RULE( expression_operator ); + expression_operator + = ta_expression_operator | pp(T_GREATER) + ; + + HANNIBAL_REGISTER_RULE( ta_expression_operator ); + ta_expression_operator + = pp(T_OROR) + | pp(T_ANDAND) + | pp(T_OR) + | pp(T_XOR) + | pp(T_AND) + | pp(T_NOTEQUAL) + | pp(T_EQUAL) + | pp(T_GREATEREQUAL) + | pp(T_LESSEQUAL) + | pp(T_LESS) + | pp(T_SHIFTLEFT) + | pp(T_SHIFTRIGHT) + | pp(T_PLUS) + | pp(T_MINUS) + | pp(T_PERCENT) + | pp(T_DIVIDE) + | pp(T_STAR) + | pp(T_ARROWSTAR) + | pp(T_DOTSTAR) + ; + + HANNIBAL_REGISTER_RULE( cast_expression); + cast_expression + = ch_p(T_LEFTPAREN) >> type_id >> ch_p(T_RIGHTPAREN) + >> cast_expression + | unary_expression + ; + + HANNIBAL_REGISTER_RULE( unary_expression); + unary_expression + = postfix_expression + | ch_p(T_PLUSPLUS) >> cast_expression + | ch_p(T_MINUSMINUS) >> cast_expression + | unary_operator >> cast_expression + | ch_p(T_SIZEOF) >> unary_expression + | ch_p(T_SIZEOF) + >> ch_p(T_LEFTPAREN) >> type_id >> ch_p(T_RIGHTPAREN) + | new_expression + | delete_expression + ; + + HANNIBAL_REGISTER_RULE( unary_operator); + unary_operator + = ch_p(T_STAR) + | pp(T_AND) + | pp(T_PLUS) + | ch_p(T_MINUS) + | ch_p(T_NOT) + | pp(T_COMPL) + ; + + HANNIBAL_REGISTER_RULE( new_expression); + new_expression + = !ch_p(T_COLON_COLON) >> ch_p(T_NEW) >> !new_placement + >> ( + new_type_id >> !new_initializer + | ch_p(T_LEFTPAREN) >> type_id >> ch_p(T_RIGHTPAREN) >> !new_initializer + ) + ; + + HANNIBAL_REGISTER_RULE( new_placement); + new_placement + = ch_p(T_LEFTPAREN) >> expression_list >> ch_p(T_RIGHTPAREN) + ; + + HANNIBAL_REGISTER_RULE( new_type_id); + new_type_id + = type_specifier_seq >> !new_declarator + ; + + HANNIBAL_REGISTER_RULE( new_declarator); + new_declarator + = ptr_operator >> !new_declarator + | direct_new_declarator + ; + + HANNIBAL_REGISTER_RULE( direct_new_declarator); + direct_new_declarator + = *( pp(T_LEFTBRACKET) >> expression >> pp(T_RIGHTBRACKET) ) + >> pp(T_LEFTBRACKET) >> constant_expression >> pp(T_RIGHTBRACKET) + ; + + HANNIBAL_REGISTER_RULE( new_initializer); + new_initializer + = ch_p(T_LEFTPAREN) >> !expression_list >> ch_p(T_RIGHTPAREN) + ; + + HANNIBAL_REGISTER_RULE( delete_expression); + delete_expression + = !ch_p(T_COLON_COLON) >> ch_p(T_DELETE) >> cast_expression + | !ch_p(T_COLON_COLON) >> ch_p(T_DELETE) + >> pp(T_LEFTBRACKET) >> pp(T_RIGHTBRACKET) + >> cast_expression + ; + + HANNIBAL_REGISTER_RULE( postfix_expression); + postfix_expression + = simple_postfix_expression >> *postfix_expression_helper + ; + + HANNIBAL_REGISTER_RULE( simple_postfix_expression); + simple_postfix_expression + = primary_expression + | simple_type_specifier + >> ch_p(T_LEFTPAREN) >> !expression_list >> ch_p(T_RIGHTPAREN) + | ch_p(T_DYNAMICCAST) + >> ch_p(T_LESS) >> type_id >> ch_p(T_GREATER) + >> ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN) + | ch_p(T_STATICCAST) + >> ch_p(T_LESS) >> type_id >> ch_p(T_GREATER) + >> ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN) + | ch_p(T_REINTERPRETCAST) + >> ch_p(T_LESS) >> type_id >> ch_p(T_GREATER) + >> ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN) + | ch_p(T_CONSTCAST) + >> ch_p(T_LESS) >> type_id >> ch_p(T_GREATER) + >> ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN) + | ch_p(T_TYPEID) + >> ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN) + | ch_p(T_TYPEID) + >> ch_p(T_LEFTPAREN) >> type_id >> ch_p(T_RIGHTPAREN) + ; + + HANNIBAL_REGISTER_RULE( postfix_expression_helper ); + postfix_expression_helper + = pp(T_LEFTBRACKET) >> expression >> pp(T_RIGHTBRACKET) + | ch_p(T_LEFTPAREN) >> !expression_list >> ch_p(T_RIGHTPAREN) + | ch_p(T_DOT) >> !ch_p(T_TEMPLATE) >> !ch_p(T_COLON_COLON) >> id_expression + | ch_p(T_ARROW) >> !ch_p(T_TEMPLATE) >> !ch_p(T_COLON_COLON) >> id_expression + | ch_p(T_DOT) >> pseudo_destructor_name + | ch_p(T_ARROW) >> pseudo_destructor_name + | ch_p(T_PLUSPLUS) + | ch_p(T_MINUSMINUS) + ; + + HANNIBAL_REGISTER_RULE( pseudo_destructor_name); + pseudo_destructor_name + = !ch_p(T_COLON_COLON) >> !nested_name_specifier + >> ( + type_name >> ch_p(T_COLON_COLON) >> ch_p(T_COMPL) >> type_name + | ch_p(T_COMPL) >> type_name + ) + ; + + + HANNIBAL_REGISTER_RULE(constant_expression); + constant_expression + = conditional_expression + ; + + HANNIBAL_REGISTER_RULE(ctor_initializer); + ctor_initializer + = ch_p(T_COLON) >> mem_initializer_list + ; + + HANNIBAL_REGISTER_RULE(mem_initializer_list); + mem_initializer_list + = mem_initializer % ch_p(T_COMMA) + ; + + HANNIBAL_REGISTER_RULE(mem_initializer); + mem_initializer + = mem_initializer_id + >> comment_nest_p(ch_p(T_LEFTPAREN), ch_p(T_RIGHTPAREN)) + // TODO: restore after assignment expression has been implemented + //ch_p(T_LEFTPAREN) >> !expression_list >> ch_p(T_RIGHTPAREN) + ; + + HANNIBAL_REGISTER_RULE(mem_initializer_id); + mem_initializer_id + = !ch_p(T_COLON_COLON) >> !nested_name_specifier >> class_name + | ch_p(T_IDENTIFIER) + ; + + // + // the eps_p is added to allow skipping of trailing whitespace + // (post-skip) + // + HANNIBAL_REGISTER_RULE(translation_unit); + translation_unit + = !declaration_seq >> end_p; + ; + + HANNIBAL_REGISTER_RULE(odd_language_extension); + odd_language_extension // read: microsoft extensions + = extension_type_decorator + >> !comment_nest_p(ch_p(T_LEFTPAREN), ch_p(T_RIGHTPAREN)) + ; + + HANNIBAL_REGISTER_RULE(declaration_seq); + declaration_seq + = +declaration HANNIBAL_TRACE_ACTION( "declaration") + ; + + HANNIBAL_REGISTER_RULE(declaration); + declaration + = template_declaration + | explicit_instantiation + | explicit_specialization + | linkage_specification + | namespace_definition + | block_declaration + | function_definition + ; + + HANNIBAL_REGISTER_RULE(block_declaration); + block_declaration + = simple_declaration + | asm_definition + | namespace_alias_definition + | using_declaration + | using_directive + ; + + HANNIBAL_REGISTER_RULE(simple_declaration); + simple_declaration + = !decl_specifier_seq >> !init_declarator_list + >> ch_p(T_SEMICOLON) + ; + + HANNIBAL_REGISTER_RULE(asm_definition); + asm_definition + = ch_p(T_ASM) + >> ch_p(T_LEFTPAREN) >> ch_p(T_STRINGLIT) >> ch_p(T_RIGHTPAREN) + >> ch_p(T_SEMICOLON) + ; + + HANNIBAL_REGISTER_RULE(init_declarator_list); + init_declarator_list + = init_declarator % ch_p(T_COMMA) + ; + + HANNIBAL_REGISTER_RULE(init_declarator); + init_declarator + = declarator >> !initializer + ; + + HANNIBAL_REGISTER_RULE(initializer); + initializer + = ch_p(T_ASSIGN) >> initializer_clause + | ch_p(T_LEFTPAREN) >> expression_list >> ch_p(T_RIGHTPAREN) + ; + + HANNIBAL_REGISTER_RULE(initializer_clause); + initializer_clause + = assignment_expression + | ch_p(T_LEFTBRACE) >> initializer_list + >> !ch_p(T_COMMA) >> ch_p(T_RIGHTBRACE) + | ch_p(T_LEFTBRACE) >> ch_p(T_RIGHTBRACE) + ; + + HANNIBAL_REGISTER_RULE(initializer_list); + initializer_list + = initializer_clause % ch_p(T_COMMA) + ; + + HANNIBAL_REGISTER_RULE(expression_list); + expression_list + = assignment_expression % ch_p(T_COMMA) + ; + + HANNIBAL_REGISTER_RULE(namespace_alias_definition); + namespace_alias_definition + = ch_p(T_NAMESPACE) >> ch_p(T_IDENTIFIER) >> ch_p(T_ASSIGN) + >> qualified_namespace_specifier + >> ch_p(T_SEMICOLON) + ; + + HANNIBAL_REGISTER_RULE(qualified_namespace_specifier); + qualified_namespace_specifier + = !ch_p(T_COLON_COLON) >> !nested_name_specifier + >> namespace_name + ; + + HANNIBAL_REGISTER_RULE(explicit_instantiation); + explicit_instantiation + = template_declaration + ; + + HANNIBAL_REGISTER_RULE(template_declaration); + template_declaration + = !ch_p(T_EXPORT) >> ch_p(T_TEMPLATE) + >> ch_p(T_LESS) >> template_parameter_list >> ch_p(T_GREATER) + >> declaration + ; + + HANNIBAL_REGISTER_RULE(template_parameter_list); + template_parameter_list + = template_parameter % ch_p(T_COMMA) + ; + + HANNIBAL_REGISTER_RULE(template_parameter); + template_parameter + = type_parameter + | parameter_declaration + ; + + HANNIBAL_REGISTER_RULE(type_parameter); + type_parameter + = ch_p(T_CLASS) >> !ch_p(T_IDENTIFIER) + >> !(ch_p(T_ASSIGN) >> type_id) + | ch_p(T_TYPENAME) >> !ch_p(T_IDENTIFIER) + >> !(ch_p(T_ASSIGN) >> type_id) + | ch_p(T_TEMPLATE) + >> ch_p(T_LESS) >> template_parameter_list >> ch_p(T_GREATER) + >> ch_p(T_CLASS) >> !ch_p(T_IDENTIFIER) + >> !(ch_p(T_ASSIGN) >> template_name) + ; + + HANNIBAL_REGISTER_RULE(template_name); + template_name + = ch_p(T_IDENTIFIER) + ; + + HANNIBAL_REGISTER_RULE(using_declaration); + using_declaration // optimize? + = ch_p(T_USING) >> !ch_p(T_TYPENAME) >> !ch_p(T_COLON_COLON) + >> nested_name_specifier >> unqualified_id + >> ch_p(T_SEMICOLON) + | ch_p(T_USING) >> ch_p(T_COLON_COLON) >> unqualified_id + >> ch_p(T_SEMICOLON) + ; + + HANNIBAL_REGISTER_RULE(using_directive); + using_directive + = ch_p(T_USING) >> ch_p(T_NAMESPACE) >> !ch_p(T_COLON_COLON) + >> !nested_name_specifier >> namespace_name + >> ch_p(T_SEMICOLON) + ; + + HANNIBAL_REGISTER_RULE(explicit_specialization); + explicit_specialization + = ch_p(T_TEMPLATE) >> ch_p(T_LESS) >> ch_p(T_GREATER) + >> declaration + ; + + HANNIBAL_REGISTER_RULE(linkage_specification); + linkage_specification + = ch_p(T_EXTERN) >> ch_p(T_STRINGLIT) + >> ( ch_p(T_LEFTBRACE) >> !declaration_seq >> ch_p(T_RIGHTBRACE) + | declaration + ) + ; + + HANNIBAL_REGISTER_RULE(namespace_definition); + namespace_definition + = named_namespace_definition + | unnamed_namespace_definition // TODO: optimize? + ; + + HANNIBAL_REGISTER_RULE(named_namespace_definition); + named_namespace_definition + = original_namespace_definition + // | extension_namespace_definition // optimization: extension namespace is syntactically identical + ; + + HANNIBAL_REGISTER_RULE(original_namespace_definition); + original_namespace_definition + = ch_p(T_NAMESPACE) >> ch_p(T_IDENTIFIER) + >> ch_p(T_LEFTBRACE) >> namespace_body >> ch_p(T_RIGHTBRACE) + ; + + HANNIBAL_REGISTER_RULE(extension_namespace_definition); + extension_namespace_definition + = ch_p(T_NAMESPACE) >> original_namespace_name + >> ch_p(T_LEFTBRACE) >> namespace_body >> ch_p(T_RIGHTBRACE) + ; + + HANNIBAL_REGISTER_RULE(original_namespace_name); + original_namespace_name + = ch_p(T_IDENTIFIER) + ; + + HANNIBAL_REGISTER_RULE(unnamed_namespace_definition); + unnamed_namespace_definition + = ch_p(T_NAMESPACE) + >> ch_p(T_LEFTBRACE) >> namespace_body >> ch_p(T_RIGHTBRACE) + ; + + HANNIBAL_REGISTER_RULE(namespace_body); + namespace_body + = !declaration_seq + ; + + HANNIBAL_REGISTER_RULE(function_definition); + function_definition + = function_definition_helper + >> !ctor_initializer >> !function_body // removed semicolons + | decl_specifier_seq >> declarator >> function_try_block + | declarator >> function_try_block + ; + + HANNIBAL_REGISTER_RULE(function_definition_helper); + function_definition_helper + = decl_specifier_seq >> declarator + | +no_type_decl_specifier >> declarator + | declarator + ; + + HANNIBAL_REGISTER_RULE(function_try_block); + function_try_block + = ch_p(T_TRY) + >> !ctor_initializer >> function_body >> handler_seq + ; + + HANNIBAL_REGISTER_RULE(handler_seq); + handler_seq + = +handler + ; + + HANNIBAL_REGISTER_RULE(handler); + handler // TODO + = ch_p(T_CATCH) + >> comment_nest_p(ch_p(T_LEFTPAREN), ch_p(T_RIGHTPAREN)) + >> compound_statement + ; + + HANNIBAL_REGISTER_RULE(declarator); + declarator + = *( ptr_operator + | odd_language_extension + ) + >> direct_declarator + ; + + HANNIBAL_REGISTER_RULE(direct_declarator); + direct_declarator + = ( declarator_id + | ch_p(T_LEFTPAREN) >> declarator >> ch_p(T_RIGHTPAREN) + ) + >> *parameters_or_array_spec + ; + + HANNIBAL_REGISTER_RULE(parameters_or_array_spec); + parameters_or_array_spec + = ch_p(T_LEFTPAREN) >> parameter_declaration_clause >> ch_p(T_RIGHTPAREN) + >> !cv_qualifier_seq >> !exception_specification + | pp(T_LEFTBRACKET) >> !constant_expression >> pp(T_RIGHTBRACKET) + ; + + HANNIBAL_REGISTER_RULE(exception_specification); + exception_specification // TODO + = ch_p(T_THROW) + >> comment_nest_p(ch_p(T_LEFTPAREN), ch_p(T_RIGHTPAREN)) + ; + + HANNIBAL_REGISTER_RULE(abstract_declarator); + abstract_declarator + = +( ptr_operator + | odd_language_extension + ) + >> !direct_abstract_declarator + | direct_abstract_declarator + ; + + HANNIBAL_REGISTER_RULE(direct_abstract_declarator); + direct_abstract_declarator + = ch_p(T_LEFTPAREN) >> abstract_declarator >> ch_p(T_RIGHTPAREN) + >> *direct_abstract_declarator_helper + ; + + HANNIBAL_REGISTER_RULE(direct_abstract_declarator_helper); + direct_abstract_declarator_helper + = ch_p(T_LEFTPAREN) >> parameter_declaration_clause >> ch_p(T_RIGHTPAREN) + >> !cv_qualifier_seq >> !exception_specification + | pp(T_LEFTBRACKET) >> !constant_expression >> pp(T_RIGHTBRACKET) + ; + + HANNIBAL_REGISTER_RULE(parameter_declaration_clause); + parameter_declaration_clause + = parameter_declaration_list >> ch_p(T_COMMA) + >> ch_p(T_ELLIPSIS) + | !parameter_declaration_list >> !ch_p(T_ELLIPSIS) + ; + + HANNIBAL_REGISTER_RULE(parameter_declaration_list); + parameter_declaration_list + = parameter_declaration % ch_p(T_COMMA) + ; + + + HANNIBAL_REGISTER_RULE(parameter_declaration); + parameter_declaration + = decl_specifier_seq + >> !(declarator | abstract_declarator) + >> !(ch_p(T_ASSIGN) >> assignment_expression) + ; + + HANNIBAL_REGISTER_RULE(declarator_id); + declarator_id + = !ch_p(T_COLON_COLON) + >> ( id_expression + | !nested_name_specifier >> type_name + ) + ; + + HANNIBAL_REGISTER_RULE(id_expression); + id_expression + = qualified_id + | unqualified_id + ; + + HANNIBAL_REGISTER_RULE(qualified_id); + qualified_id + = nested_name_specifier >> !ch_p(T_TEMPLATE) >> unqualified_id + ; + + HANNIBAL_REGISTER_RULE(unqualified_id); + unqualified_id + = operator_function_id + | conversion_function_id + | ch_p(T_COMPL) >> class_name + | template_id + | ch_p(T_IDENTIFIER) + ; + + HANNIBAL_REGISTER_RULE(operator_function_id); + operator_function_id + = ch_p(T_OPERATOR) >> operator_sym // this is called 'operator' in the std grammar + ; + + HANNIBAL_REGISTER_RULE(operator_sym); + operator_sym + = ch_p(T_DELETE) >> !(pp(T_LEFTBRACKET) >> pp(T_RIGHTBRACKET)) + | ch_p(T_NEW) >> !(pp(T_LEFTBRACKET) >> pp(T_RIGHTBRACKET)) + | pp(T_LEFTBRACKET) >> pp(T_RIGHTBRACKET) + | ch_p(T_LEFTPAREN) >> ch_p(T_RIGHTPAREN) + | pattern_p(OperatorTokenType, TokenTypeMask) + ; + + HANNIBAL_REGISTER_RULE(conversion_function_id); + conversion_function_id + = ch_p(T_OPERATOR) >> conversion_type_id + ; + + HANNIBAL_REGISTER_RULE( conversion_type_id); + conversion_type_id + = type_specifier_seq >> !conversion_declarator + ; + + HANNIBAL_REGISTER_RULE(type_id); + type_id + = type_specifier_seq >> !abstract_declarator + ; + + + HANNIBAL_REGISTER_RULE(conversion_declarator); + conversion_declarator + = ptr_operator >> !conversion_declarator + ; + + HANNIBAL_REGISTER_RULE(function_body); + function_body + = compound_statement + ; + + HANNIBAL_REGISTER_RULE(compound_statement); + compound_statement + = comment_nest_p(ch_p(T_LEFTBRACE), ch_p(T_RIGHTBRACE)) + ; // TODO later + + + HANNIBAL_REGISTER_RULE(ptr_operator); + ptr_operator + = ch_p(T_STAR) >> !cv_qualifier_seq + | ch_p(T_AND) + | !ch_p(T_COLON_COLON) >> nested_name_specifier + >> ch_p(T_STAR) >> !cv_qualifier_seq + ; + + + HANNIBAL_REGISTER_RULE(decl_specifier); + decl_specifier + = no_type_decl_specifier + | type_specifier + ; + + HANNIBAL_REGISTER_RULE(no_type_decl_specifier); + no_type_decl_specifier + = storage_class_specifier + | function_specifier + | ch_p(T_FRIEND) + | ch_p(T_TYPEDEF) + | cv_qualifier + | odd_language_extension + ; + + HANNIBAL_REGISTER_RULE(type_specifier_seq); + type_specifier_seq + = +type_specifier + ; + + HANNIBAL_REGISTER_RULE(type_specifier); + type_specifier + = enum_specifier + | class_specifier + | elaborated_type_specifier + | simple_type_specifier + | cv_qualifier + ; + + HANNIBAL_REGISTER_RULE(cv_qualifier_seq); + cv_qualifier_seq + = cv_qualifier >> !cv_qualifier_seq + ; + + HANNIBAL_REGISTER_RULE(cv_qualifier); + cv_qualifier + = ch_p(T_CONST) + | ch_p(T_VOLATILE) + ; + + HANNIBAL_REGISTER_RULE(enum_specifier); + enum_specifier + = enum_keyword >> !ch_p(T_IDENTIFIER) + >> ch_p(T_LEFTBRACE) >> !enumerator_list >> ch_p(T_RIGHTBRACE) + ; + + HANNIBAL_REGISTER_RULE(enum_keyword); + enum_keyword + = ch_p(T_ENUM) + ; + + HANNIBAL_REGISTER_RULE(enumerator_list); + enumerator_list + = enumerator_definition % ch_p(T_COMMA) + >> !ch_p(T_COMMA) + // TODO find out if this last COMMA_T is an MS-"extension"? + // it seems not to be in the grammar but MSVC 7.0 accepts it. + ; + + HANNIBAL_REGISTER_RULE(enumerator_definition); + enumerator_definition + = enumerator >> !(ch_p(T_ASSIGN) >> constant_expression) + ; + + HANNIBAL_REGISTER_RULE(enumerator); + enumerator + = ch_p(T_IDENTIFIER) + ; + + + HANNIBAL_REGISTER_RULE(simple_type_specifier); + simple_type_specifier + = !ch_p(T_COLON_COLON) >> !nested_name_specifier + >> ch_p(T_TEMPLATE) >> template_id + | +simple_type_name + | !ch_p(T_COLON_COLON) >> !nested_name_specifier >> type_name + ; + + HANNIBAL_REGISTER_RULE(class_head); + class_head // DH changed the order because otherwise it would always parse the (!IDENTIFIER) part. + = !access_specifier >> *odd_language_extension + >> class_key >> *odd_language_extension + >> ( + !nested_name_specifier >> template_id + | nested_name_specifier >> ch_p(T_IDENTIFIER) + | !ch_p(T_IDENTIFIER) + ) + >> !base_clause + ; + + HANNIBAL_REGISTER_RULE(type_name); + type_name + = class_name + | enum_name + | typedef_name + ; + + HANNIBAL_REGISTER_RULE(elaborated_type_specifier); + elaborated_type_specifier + = class_key >> *odd_language_extension + >> !ch_p(T_COLON_COLON) + >> !nested_name_specifier + >> ( + !ch_p(T_TEMPLATE) >> template_id + | ch_p(T_IDENTIFIER) + ) + | ch_p(T_ENUM) >> !ch_p(T_COLON_COLON) + >> !nested_name_specifier + >> ch_p(T_IDENTIFIER) + | ch_p(T_TYPENAME) + >> !ch_p(T_COLON_COLON) + >> nested_name_specifier + >> ( + !ch_p(T_TEMPLATE) >> template_id + | ch_p(T_IDENTIFIER) + ) + ; + + HANNIBAL_REGISTER_RULE(template_argument_list); + template_argument_list + = template_argument % ch_p(T_COMMA) + ; + + HANNIBAL_REGISTER_RULE(template_argument); + template_argument + = longest_d + [ + type_id + | ta_assignment_expression + | template_name + ] + ; + + HANNIBAL_REGISTER_RULE(class_key); + class_key + = class_keywords + ; + + HANNIBAL_REGISTER_RULE(class_keywords); + class_keywords + = ch_p(T_CLASS) + | ch_p(T_STRUCT) + | ch_p(T_UNION) + ; + + HANNIBAL_REGISTER_RULE(nested_name_specifier); + nested_name_specifier + = class_or_namespace_name >> ch_p(T_COLON_COLON) + >> ch_p(T_TEMPLATE) >> nested_name_specifier + | class_or_namespace_name >> ch_p(T_COLON_COLON) + >> !nested_name_specifier + ; + + HANNIBAL_REGISTER_RULE(class_or_namespace_name); + class_or_namespace_name + = class_name + | namespace_name + ; + + HANNIBAL_REGISTER_RULE(class_name); + class_name + = template_id + | ch_p(T_IDENTIFIER) + ; + + HANNIBAL_REGISTER_RULE(enum_name); + enum_name + = ch_p(T_IDENTIFIER) + ; + + HANNIBAL_REGISTER_RULE(typedef_name); + typedef_name + = ch_p(T_IDENTIFIER) + ; + + HANNIBAL_REGISTER_RULE(namespace_name); + namespace_name // TODO + = ch_p(T_IDENTIFIER) + ; + + HANNIBAL_REGISTER_RULE(template_id); + template_id + = template_name + >> ch_p(T_LESS) >> template_argument_list >> ch_p(T_GREATER) + ; + + // + // This is kind of a HACK. We want to prevent the decl_specifier_seq + // from eating the whole declaration, including the ch_p(T_IDENTIFIER). + // Therefore in the sequence, we only allow one 'unknown' word + // (the type_specifier), the rest of the decl_specifier sequence + // must consist of known keywords or constructs (the + // no_type_decl_specifier). + // This means that a declaration like: + // MYDLL_EXPORT int f(); + // will not be accepted unless the MYDLL_EXPORT is properly + // expanded by the preprocessor first. + // + // This should not cause any problems normally, it just means that + // this rule is not very robust in the case where not all symbols + // are known. + // + HANNIBAL_REGISTER_RULE(decl_specifier_seq); + decl_specifier_seq + = *no_type_decl_specifier >> type_specifier >> *no_type_decl_specifier + ; + + // The following rule is more according to the standard grammar + // decl_specifier_seq // adapted + // = decl_specifier >> decl_specifier_seq + // | (decl_specifier - (declarator_id >> parameters_or_array_spec )) + // ; + + HANNIBAL_REGISTER_RULE( storage_class_specifier); + storage_class_specifier + = ch_p(T_AUTO) + | ch_p(T_REGISTER) + | ch_p(T_STATIC) + | ch_p(T_EXTERN) + | ch_p(T_MUTABLE) + ; + + HANNIBAL_REGISTER_RULE( function_specifier); + function_specifier + = ch_p(T_INLINE) + | ch_p(T_VIRTUAL) + | ch_p(T_EXPLICIT) + ; + + HANNIBAL_REGISTER_RULE(class_specifier); + class_specifier + = class_head + >> ch_p(T_LEFTBRACE) >> !member_specification >> ch_p(T_RIGHTBRACE) + ; + + HANNIBAL_REGISTER_RULE(member_specification); + member_specification + = +( access_specifier >> ch_p(T_COLON) + | member_declaration HANNIBAL_TRACE_ACTION("member declaration") + ) + ; + + // member_specification + // = access_specifier >> COLON_T >> !member_specification + // | member_declaration >> !member_specification + // ; + + HANNIBAL_REGISTER_RULE(member_declaration); + member_declaration + = using_declaration + | template_declaration + | !decl_specifier_seq >> !member_declarator_list + >> ch_p(T_SEMICOLON) + | function_definition >> + !ch_p(T_SEMICOLON) + | qualified_id + >> ch_p(T_SEMICOLON) + ; + + HANNIBAL_REGISTER_RULE(member_declarator_list); + member_declarator_list + = member_declarator % ch_p(T_COMMA) + ; + + HANNIBAL_REGISTER_RULE(member_declarator); + member_declarator + = !ch_p(T_IDENTIFIER) >> ch_p(T_COLON) >> constant_expression + | declarator >> !(pure_specifier | constant_initializer) + ; + + HANNIBAL_REGISTER_RULE(pure_specifier); + pure_specifier + = ch_p(T_ASSIGN) >> ch_p(T_INTLIT) + ; + + HANNIBAL_REGISTER_RULE(constant_initializer); + constant_initializer + = ch_p(T_ASSIGN) >> constant_expression + ; + + HANNIBAL_REGISTER_RULE(access_specifier); + access_specifier + = ch_p(T_PUBLIC) + | ch_p(T_PROTECTED) + | ch_p(T_PRIVATE) + ; + + HANNIBAL_REGISTER_RULE(base_clause); + base_clause + = ch_p(T_COLON) >> base_specifier_list + ; + + HANNIBAL_REGISTER_RULE(base_specifier_list); + base_specifier_list + = base_specifier % ch_p(T_COMMA) + ; + + HANNIBAL_REGISTER_RULE(base_specifier); + base_specifier + = ch_p(T_VIRTUAL) >> !access_specifier >> !ch_p(T_COLON_COLON) + >> !nested_name_specifier >> class_name + | access_specifier >> !ch_p(T_VIRTUAL) >> !ch_p(T_COLON_COLON) + >> !nested_name_specifier >> class_name + | !ch_p(T_COLON_COLON) >> !nested_name_specifier >> class_name + ; + + HANNIBAL_REGISTER_RULE(extension_type_decorator); + extension_type_decorator + = ch_p(T_MSEXT_CDECL) + | ch_p(T_MSEXT_DECLSPEC) + | ch_p(T_MSEXT_BASED) + | ch_p(T_MSEXT_FASTCALL) + | ch_p(T_MSEXT_INLINE) + ; + + HANNIBAL_REGISTER_RULE(simple_type_name); + simple_type_name + = ch_p(T_CHAR) + | ch_p(T_WCHART) + | ch_p(T_BOOL) + | ch_p(T_SHORT) + | ch_p(T_INT) + | ch_p(T_LONG) + | ch_p(T_UNSIGNED) + | ch_p(T_SIGNED) + | ch_p(T_FLOAT) + | ch_p(T_DOUBLE) + | ch_p(T_VOID) + | ch_p(T_MSEXT_INT64) + | ch_p(T_MSEXT_INT8) + | ch_p(T_MSEXT_INT16) + | ch_p(T_MSEXT_INT32) + ; + } + + rule_type const& start() const { return translation_unit; } + + // Helper function wrapping pattern_p + static inline boost::wave::util::pattern_and< boost::wave::token_id> + pp (boost::wave::token_id id) + { + using namespace boost::wave; + return util::pattern_p(id, MainTokenMask); + } + }; + +#if HANNIBAL_DUMP_PARSE_TREE != 0 +private: + template<typename Rule> + void declare_rule(Rule const& rule, std::string const& rule_name) const + { + if (rule_map_ptr) + (*rule_map_ptr)[rule.id()] = rule_name; + } + rule_map_type *rule_map_ptr; +#endif +}; + +#undef HANNIBAL_REGISTER_RULE +#undef HANNIBAL_TRACE_TRANSLATION_UNIT_GRAMMAR + +#endif // HANNIBAL_TRANSLATION_UNIT_GRAMMAR_H_INCLUDED diff --git a/src/boost/libs/wave/samples/hannibal/translation_unit_skipper.h b/src/boost/libs/wave/samples/hannibal/translation_unit_skipper.h new file mode 100644 index 00000000..4dc2e273 --- /dev/null +++ b/src/boost/libs/wave/samples/hannibal/translation_unit_skipper.h @@ -0,0 +1,51 @@ +// Hannibal: partial C++ grammar to parse C++ type information +// Copyright (c) 2005-2006 Danny Havenith +// +// Boost.Wave: A Standard compliant C++ preprocessor +// Copyright (c) 2001-2009 Hartmut Kaiser +// +// http://www.boost.org/ +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#if !defined(HANNIBAL_TRANSLATION_UNIT_SKIPPER_H_INCLUDED) +#define HANNIBAL_TRANSLATION_UNIT_SKIPPER_H_INCLUDED + +#include <boost/spirit/include/classic_core.hpp> +#include <boost/spirit/include/classic_confix.hpp> + +#include <boost/wave/wave_config.hpp> +#include <boost/wave/token_ids.hpp> +#include <boost/wave/util/pattern_parser.hpp> + +/////////////////////////////////////////////////////////////////////////////// +struct translation_unit_skipper +: public boost::spirit::classic::grammar<translation_unit_skipper> +{ + template <typename ScannerT> + struct definition + { + definition(translation_unit_skipper const& /*self*/) + { + using namespace boost::spirit::classic; + using namespace boost::wave; + using boost::wave::util::pattern_p; + + skip + = pattern_p(WhiteSpaceTokenType, TokenTypeMask) + | pattern_p(EOLTokenType, TokenTypeMask) + | pattern_p(EOFTokenType, TokenTypeMask) + | comment_p(pattern_p(PPTokenType, TokenTypeMask), + pattern_p(EOLTokenType, TokenTypeMask)) + ; + } + + boost::spirit::classic::rule<ScannerT> skip; + + boost::spirit::classic::rule<ScannerT> const& + start() const { return skip; } + }; +}; + +#endif // HANNIBAL_TRANSLATION_UNIT_SKIPPER_H_INCLUDED diff --git a/src/boost/libs/wave/samples/lexed_tokens/build/Jamfile.v2 b/src/boost/libs/wave/samples/lexed_tokens/build/Jamfile.v2 new file mode 100644 index 00000000..f834c9cd --- /dev/null +++ b/src/boost/libs/wave/samples/lexed_tokens/build/Jamfile.v2 @@ -0,0 +1,19 @@ +# Boost.Wave: A Standard compliant C++ preprocessor library +# +# Boost Wave Library Sample Build Jamfile (lexed_tokens) +# +# http://www.boost.org/ +# +# Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost +# Software License, Version 1.0. (See accompanying file +# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +exe lexed_tokens + : ../lexed_tokens.cpp + /boost/wave//boost_wave + /boost/filesystem//boost_filesystem + /boost/system//boost_system + /boost/thread//boost_thread + /boost/date_time//boost_date_time + ; + diff --git a/src/boost/libs/wave/samples/lexed_tokens/lexed_tokens.cpp b/src/boost/libs/wave/samples/lexed_tokens/lexed_tokens.cpp new file mode 100644 index 00000000..9f30aa01 --- /dev/null +++ b/src/boost/libs/wave/samples/lexed_tokens/lexed_tokens.cpp @@ -0,0 +1,151 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <iostream> +#include <iomanip> +#include <fstream> +#include <string> +#include <vector> + +/////////////////////////////////////////////////////////////////////////////// +// Include Wave itself +#include <boost/wave.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include the lexer stuff +#include <boost/wave/cpplexer/cpp_lex_token.hpp> // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer class + +/////////////////////////////////////////////////////////////////////////////// +// +// Special output operator for a lex_token. +// +// Note: this doesn't compile if BOOST_SPIRIT_DEBUG is defined. +// +/////////////////////////////////////////////////////////////////////////////// +template <typename PositionT> +inline std::ostream & +operator<< (std::ostream &stream, + boost::wave::cpplexer::lex_token<PositionT> const &t) +{ + using namespace std; + using namespace boost::wave; + + token_id id = token_id(t); + stream << setw(16) + << left << boost::wave::get_token_name(id) << " (" + << "#" << setw(3) << BASEID_FROM_TOKEN(id); + + if (ExtTokenTypeMask & id) { + // this is an extended token id + if (AltTokenType == (id & ExtTokenOnlyMask)) { + stream << ", AltTokenType"; + } + else if (TriGraphTokenType == (id & ExtTokenOnlyMask)) { + stream << ", TriGraphTokenType"; + } + else if (AltExtTokenType == (id & ExtTokenOnlyMask)){ + stream << ", AltExtTokenType"; + } + } + + stream + << ") at " << t.get_position().get_file() << " (" + << setw(3) << right << t.get_position().get_line() << "/" + << setw(2) << right << t.get_position().get_column() + << "): >"; + + typedef typename boost::wave::cpplexer::lex_token<PositionT>::string_type + string_type; + + string_type const& value = t.get_value(); + for (std::size_t i = 0; i < value.size(); ++i) { + switch (value[i]) { + case '\r': stream << "\\r"; break; + case '\n': stream << "\\n"; break; + case '\t': stream << "\\t"; break; + default: + stream << value[i]; + break; + } + } + stream << "<"; + + return stream; +} + +/////////////////////////////////////////////////////////////////////////////// +// main entry point +int main(int argc, char *argv[]) +{ + if (2 != argc) { + std::cerr << "Usage: lexed_tokens infile" << std::endl; + return -1; + } + +// current file position is saved for exception handling +boost::wave::util::file_position_type current_position; + + try { + // Open and read in the specified input file. + std::ifstream instream(argv[1]); + std::string instr; + + if (!instream.is_open()) { + std::cerr << "Could not open input file: " << argv[1] << std::endl; + return -2; + } + instream.unsetf(std::ios::skipws); + instr = std::string(std::istreambuf_iterator<char>(instream.rdbuf()), + std::istreambuf_iterator<char>()); + + // tokenize the input data into C++ tokens using the C++ lexer + typedef boost::wave::cpplexer::lex_token<> token_type; + typedef boost::wave::cpplexer::lex_iterator<token_type> lexer_type; + typedef token_type::position_type position_type; + + position_type pos(argv[1]); + lexer_type it = lexer_type(instr.begin(), instr.end(), pos, + boost::wave::language_support( + boost::wave::support_cpp|boost::wave::support_option_long_long)); + lexer_type end = lexer_type(); + + while (it != end) { + current_position = (*it).get_position(); // for error reporting + std::cout << *it << std::endl; // dump the tokenf info + ++it; + } + } + catch (boost::wave::cpplexer::lexing_exception const& e) { + // some lexing error + std::cerr + << e.file_name() << "(" << e.line_no() << "): " + << e.description() << std::endl; + return 2; + } + catch (std::exception const& e) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "exception caught: " << e.what() + << std::endl; + return 3; + } + catch (...) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "unexpected exception caught." << std::endl; + return 4; + } + return 0; +} diff --git a/src/boost/libs/wave/samples/list_includes/build/Jamfile.v2 b/src/boost/libs/wave/samples/list_includes/build/Jamfile.v2 new file mode 100644 index 00000000..08c26ed7 --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/build/Jamfile.v2 @@ -0,0 +1,38 @@ +# Boost.Wave: A Standard compliant C++ preprocessor library +# +# Boost Wave Library Sample Build Jamfile (list_includes) +# +# http://www.boost.org/ +# +# Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost +# Software License, Version 1.0. (See accompanying file +# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +SOURCES = + ../list_includes + ../instantiate_cpp_exprgrammar + ../instantiate_cpp_grammar + ../instantiate_cpp_literalgrs + ../instantiate_defined_grammar + ../instantiate_lexertl_lexer + ; + +exe list_includes + : + $(SOURCES) + /boost/wave//boost_wave + /boost/program_options//boost_program_options + /boost/filesystem//boost_filesystem + /boost/system//boost_system + /boost/thread//boost_thread + /boost/date_time//boost_date_time + ; + +for local source in $(SOURCES) +{ + local requirements ; + # workaround for compiler bug + requirements += <toolset-msvc:version>7.1:<rtti>off ; + requirements += <toolset-msvc:version>7.1_stlport4:<rtti>off ; + obj $(source) : $(source).cpp : $(requirements) ; +} diff --git a/src/boost/libs/wave/samples/list_includes/instantiate_cpp_exprgrammar.cpp b/src/boost/libs/wave/samples/list_includes/instantiate_cpp_exprgrammar.cpp new file mode 100644 index 00000000..112a5867 --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/instantiate_cpp_exprgrammar.cpp @@ -0,0 +1,40 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: List include dependencies of a given source file + Explicit instantiation of the cpp_expression_grammar parsing + function + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "list_includes.hpp" // config data + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/cpp_lex_token.hpp> + +#include <boost/wave/grammars/cpp_expression_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the expression_grammar_gen template with the +// correct token type. This instantiates the corresponding parse function, +// which in turn instantiates the expression_grammar object (see +// wave/grammars/cpp_expression_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::cpplexer::lex_token<> token_type; + +template struct boost::wave::grammars::expression_grammar_gen<token_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/list_includes/instantiate_cpp_grammar.cpp b/src/boost/libs/wave/samples/list_includes/instantiate_cpp_grammar.cpp new file mode 100644 index 00000000..30ce93fd --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/instantiate_cpp_grammar.cpp @@ -0,0 +1,45 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: List include dependencies of a given source file + Explicit instantiation of the cpp_grammar parsing function + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "list_includes.hpp" // config data + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> +#include <list> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/cpp_lex_token.hpp> + +#include "lexertl_iterator.hpp" + +#include <boost/wave/grammars/cpp_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the cpp_grammar_gen template with the correct +// token type. This instantiates the corresponding pt_parse function, which +// in turn instantiates the cpp_grammar object +// (see wave/grammars/cpp_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::cpplexer::lex_token<> token_type; +typedef boost::wave::cpplexer::lexertl::lex_iterator<token_type> lexer_type; +typedef std::list<token_type, boost::fast_pool_allocator<token_type> > + token_sequence_type; + +template struct boost::wave::grammars::cpp_grammar_gen<lexer_type, token_sequence_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/list_includes/instantiate_cpp_literalgrs.cpp b/src/boost/libs/wave/samples/list_includes/instantiate_cpp_literalgrs.cpp new file mode 100644 index 00000000..f87b99d6 --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/instantiate_cpp_literalgrs.cpp @@ -0,0 +1,47 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: List include dependencies of a given source file + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "list_includes.hpp" // config data + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/cpp_lex_token.hpp> + +#include <boost/wave/grammars/cpp_literal_grammar_gen.hpp> +#include <boost/wave/grammars/cpp_intlit_grammar.hpp> +#include <boost/wave/grammars/cpp_chlit_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the intlit_grammar_gen, chlit_grammar_gen and +// floatlit_grammar_gen templates with the correct token type. This +// instantiates the corresponding parse function, which in turn instantiates +// the corresponding parser object. +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::cpplexer::lex_token<> token_type; + +template struct boost::wave::grammars::intlit_grammar_gen<token_type>; +#if BOOST_WAVE_WCHAR_T_SIGNEDNESS == BOOST_WAVE_WCHAR_T_AUTOSELECT || \ + BOOST_WAVE_WCHAR_T_SIGNEDNESS == BOOST_WAVE_WCHAR_T_FORCE_SIGNED +template struct boost::wave::grammars::chlit_grammar_gen<int, token_type>; +#endif +template struct boost::wave::grammars::chlit_grammar_gen<unsigned int, token_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/list_includes/instantiate_defined_grammar.cpp b/src/boost/libs/wave/samples/list_includes/instantiate_defined_grammar.cpp new file mode 100644 index 00000000..c6dd2ab5 --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/instantiate_defined_grammar.cpp @@ -0,0 +1,41 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: List include dependencies of a given source file + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "list_includes.hpp" // config data + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/cpp_lex_token.hpp> + +#include "lexertl_iterator.hpp" + +#include <boost/wave/grammars/cpp_defined_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the defined_grammar_gen template +// with the correct token type. This instantiates the corresponding parse +// function, which in turn instantiates the defined_grammar +// object (see wave/grammars/cpp_defined_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::cpplexer::lexertl::lex_iterator< + boost::wave::cpplexer::lex_token<> > + lexer_type; +template struct boost::wave::grammars::defined_grammar_gen<lexer_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/list_includes/instantiate_lexertl_lexer.cpp b/src/boost/libs/wave/samples/list_includes/instantiate_lexertl_lexer.cpp new file mode 100644 index 00000000..9b27f667 --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/instantiate_lexertl_lexer.cpp @@ -0,0 +1,44 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "list_includes.hpp" // config data + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/cpp_lex_token.hpp> + +#include "lexertl_iterator.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// The following file needs to be included only once throughout the whole +// program. +#include "lexertl/lexertl_lexer.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// +// This instantiates the correct 'new_lexer' function, which generates the +// C++ lexer used in this sample. +// +// This is moved into a separate compilation unit to decouple the compilation +// of the C++ lexer from the compilation of the other modules, which helps to +// reduce compilation time. +// +// The template parameter(s) supplied should be identical to the parameters +// supplied while instantiating the context<> template. +// +/////////////////////////////////////////////////////////////////////////////// + +template struct boost::wave::cpplexer::lexertl::new_lexer_gen< + BOOST_WAVE_STRINGTYPE::iterator>; + +#endif // BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 diff --git a/src/boost/libs/wave/samples/list_includes/lexertl/lexertl_lexer.hpp b/src/boost/libs/wave/samples/list_includes/lexertl/lexertl_lexer.hpp new file mode 100644 index 00000000..259a25cf --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/lexertl/lexertl_lexer.hpp @@ -0,0 +1,809 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(BOOST_WAVE_LEXERTL_LEXER_HPP_INCLUDED) +#define BOOST_WAVE_LEXERTL_LEXER_HPP_INCLUDED + +#include <fstream> + +#include <boost/iterator/iterator_traits.hpp> + +#include <boost/wave/wave_config.hpp> +#include <boost/wave/language_support.hpp> +#include <boost/wave/token_ids.hpp> +#include <boost/wave/util/time_conversion_helper.hpp> + +#include <boost/wave/cpplexer/validate_universal_char.hpp> +#include <boost/wave/cpplexer/convert_trigraphs.hpp> +#include <boost/wave/cpplexer/cpplexer_exceptions.hpp> +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 +#include <boost/wave/cpplexer/detect_include_guards.hpp> +#endif + +#include "wave_lexertl_config.hpp" +#include "../lexertl_iterator.hpp" + +#if BOOST_WAVE_LEXERTL_USE_STATIC_TABLES != 0 +#include "wave_lexertl_tables.hpp" +#else +#include <boost/spirit/home/support/detail/lexer/generator.hpp> +#include <boost/spirit/home/support/detail/lexer/rules.hpp> +#include <boost/spirit/home/support/detail/lexer/state_machine.hpp> +#include <boost/spirit/home/support/detail/lexer/consts.hpp> +//#include "lexertl/examples/serialise.hpp> +// #if BOOST_WAVE_LEXERTL_GENERATE_CPP_CODE != 0 +// #include "lexertl/examples/cpp_code.hpp" +// #endif +#endif + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { namespace wave { namespace cpplexer { namespace lexertl +{ + +#if BOOST_WAVE_LEXERTL_USE_STATIC_TABLES == 0 +/////////////////////////////////////////////////////////////////////////////// +// The following numbers are the array sizes of the token regex's which we +// need to specify to make the CW compiler happy (at least up to V9.5). +#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0 +#define INIT_DATA_SIZE 176 +#else +#define INIT_DATA_SIZE 159 +#endif +#define INIT_DATA_CPP_SIZE 15 +#define INIT_DATA_PP_NUMBER_SIZE 2 +#define INIT_MACRO_DATA_SIZE 27 +#endif // #if BOOST_WAVE_LEXERTL_USE_STATIC_TABLES == 0 + +// this is just a hack to have a unique token id not otherwise used by Wave +#define T_ANYCTRL T_LAST_TOKEN_ID + +/////////////////////////////////////////////////////////////////////////////// +namespace lexer +{ + +/////////////////////////////////////////////////////////////////////////////// +// this is the wrapper for the lexertl lexer library +template <typename Iterator, typename Position> +class lexertl +{ +private: + typedef BOOST_WAVE_STRINGTYPE string_type; + typedef typename boost::detail::iterator_traits<Iterator>::value_type + char_type; + +public: + wave::token_id next_token(Iterator &first, Iterator const &last, + string_type& token_value); + +#if BOOST_WAVE_LEXERTL_USE_STATIC_TABLES != 0 + lexertl() {} + void init_dfa(wave::language_support lang, Position const& pos, + bool force_reinit = false) {} + bool is_initialized() const { return true; } +#else + lexertl() : has_compiled_dfa_(false) {} + bool init_dfa(wave::language_support lang, Position const& pos, + bool force_reinit = false); + bool is_initialized() const { return has_compiled_dfa_; } + +// get time of last compilation + static std::time_t get_compilation_time() + { return compilation_time.get_time(); } + + bool load (std::istream& instrm); + bool save (std::ostream& outstrm); + +private: + boost::lexer::state_machine state_machine_; + bool has_compiled_dfa_; + +// initialization data (regular expressions for the token definitions) + struct lexer_macro_data { + char_type const *name; // macro name + char_type const *macro; // associated macro definition + }; + static lexer_macro_data const init_macro_data[INIT_MACRO_DATA_SIZE]; // macro patterns + + struct lexer_data { + token_id tokenid; // token data + char_type const *tokenregex; // associated token to match + }; + static lexer_data const init_data[INIT_DATA_SIZE]; // common patterns + static lexer_data const init_data_cpp[INIT_DATA_CPP_SIZE]; // C++ only patterns + static lexer_data const init_data_pp_number[INIT_DATA_PP_NUMBER_SIZE]; // pp-number only patterns + +// helper for calculation of the time of last compilation + static boost::wave::util::time_conversion_helper compilation_time; +#endif // #if BOOST_WAVE_LEXERTL_USE_STATIC_TABLES == 0 +}; + +#if BOOST_WAVE_LEXERTL_USE_STATIC_TABLES == 0 +/////////////////////////////////////////////////////////////////////////////// +// get time of last compilation of this file +template <typename IteratorT, typename PositionT> +boost::wave::util::time_conversion_helper + lexertl<IteratorT, PositionT>::compilation_time(__DATE__ " " __TIME__); + +/////////////////////////////////////////////////////////////////////////////// +// token regex definitions + +// helper for initializing token data and macro definitions +#define Q(c) "\\" c +#define TRI(c) "{TRI}" c +#define OR "|" +#define MACRO_DATA(name, macro) { name, macro } +#define TOKEN_DATA(id, regex) { id, regex } + +// lexertl macro definitions +template <typename Iterator, typename Position> +typename lexertl<Iterator, Position>::lexer_macro_data const +lexertl<Iterator, Position>::init_macro_data[INIT_MACRO_DATA_SIZE] = +{ + MACRO_DATA("ANY", "[\t\v\f\r\n\\040-\\377]"), + MACRO_DATA("ANYCTRL", "[\\000-\\037]"), + MACRO_DATA("TRI", "\\?\\?"), + MACRO_DATA("BLANK", "[ \t\v\f]"), + MACRO_DATA("CCOMMENT", "\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\/"), + MACRO_DATA("PPSPACE", "(" "{BLANK}" OR "{CCOMMENT}" ")*"), + MACRO_DATA("OCTALDIGIT", "[0-7]"), + MACRO_DATA("DIGIT", "[0-9]"), + MACRO_DATA("HEXDIGIT", "[0-9a-fA-F]"), + MACRO_DATA("OPTSIGN", "[-+]?"), + MACRO_DATA("EXPSTART", "[eE][-+]"), + MACRO_DATA("EXPONENT", "([eE]{OPTSIGN}{DIGIT}+)"), + MACRO_DATA("NONDIGIT", "[a-zA-Z_]"), + MACRO_DATA("INTEGER", "(" "(0x|0X){HEXDIGIT}+" OR "0{OCTALDIGIT}*" OR "[1-9]{DIGIT}*" ")"), + MACRO_DATA("INTEGER_SUFFIX", "(" "[uU][lL]?" OR "[lL][uU]?" ")"), +#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0 + MACRO_DATA("LONGINTEGER_SUFFIX", "([uU]([lL][lL])|([lL][lL])[uU]?|i64)"), +#else + MACRO_DATA("LONGINTEGER_SUFFIX", "([uU]([lL][lL])|([lL][lL])[uU]?)"), +#endif + MACRO_DATA("FLOAT_SUFFIX", "(" "[fF][lL]?" OR "[lL][fF]?" ")"), + MACRO_DATA("CHAR_SPEC", "L?"), + MACRO_DATA("BACKSLASH", "(" Q("\\") OR TRI(Q("/")) ")"), + MACRO_DATA("ESCAPESEQ", "{BACKSLASH}([abfnrtv?'\"]|{BACKSLASH}|x{HEXDIGIT}+|{OCTALDIGIT}{1,3})"), + MACRO_DATA("HEXQUAD", "{HEXDIGIT}{4}"), + MACRO_DATA("UNIVERSALCHAR", "{BACKSLASH}(u{HEXQUAD}|U{HEXQUAD}{2})"), + MACRO_DATA("POUNDDEF", "(" "#" OR TRI("=") OR Q("%:") ")"), + MACRO_DATA("NEWLINEDEF", "(" "\\n" OR "\\r" OR "\\r\\n" ")"), +#if BOOST_WAVE_SUPPORT_INCLUDE_NEXT != 0 + MACRO_DATA("INCLUDEDEF", "(include|include_next)"), +#else + MACRO_DATA("INCLUDEDEF", "include"), +#endif + MACRO_DATA("PP_NUMBERDEF", "\\.?{DIGIT}({DIGIT}|{NONDIGIT}|{EXPSTART}|\\.)*"), + MACRO_DATA(NULL, NULL) // should be the last entry +}; + +// common C++/C99 token definitions +template <typename Iterator, typename Position> +typename lexertl<Iterator, Position>::lexer_data const +lexertl<Iterator, Position>::init_data[INIT_DATA_SIZE] = +{ + TOKEN_DATA(T_AND, "&"), + TOKEN_DATA(T_ANDAND, "&&"), + TOKEN_DATA(T_ASSIGN, "="), + TOKEN_DATA(T_ANDASSIGN, "&="), + TOKEN_DATA(T_OR, Q("|")), + TOKEN_DATA(T_OR_TRIGRAPH, "{TRI}!"), + TOKEN_DATA(T_ORASSIGN, Q("|=")), + TOKEN_DATA(T_ORASSIGN_TRIGRAPH, "{TRI}!="), + TOKEN_DATA(T_XOR, Q("^")), + TOKEN_DATA(T_XOR_TRIGRAPH, "{TRI}'"), + TOKEN_DATA(T_XORASSIGN, Q("^=")), + TOKEN_DATA(T_XORASSIGN_TRIGRAPH, "{TRI}'="), + TOKEN_DATA(T_COMMA, ","), + TOKEN_DATA(T_COLON, ":"), + TOKEN_DATA(T_DIVIDEASSIGN, Q("/=")), + TOKEN_DATA(T_DIVIDE, Q("/")), + TOKEN_DATA(T_DOT, Q(".")), + TOKEN_DATA(T_ELLIPSIS, Q(".") "{3}"), + TOKEN_DATA(T_EQUAL, "=="), + TOKEN_DATA(T_GREATER, ">"), + TOKEN_DATA(T_GREATEREQUAL, ">="), + TOKEN_DATA(T_LEFTBRACE, Q("{")), + TOKEN_DATA(T_LEFTBRACE_ALT, "<" Q("%")), + TOKEN_DATA(T_LEFTBRACE_TRIGRAPH, "{TRI}<"), + TOKEN_DATA(T_LESS, "<"), + TOKEN_DATA(T_LESSEQUAL, "<="), + TOKEN_DATA(T_LEFTPAREN, Q("(")), + TOKEN_DATA(T_LEFTBRACKET, Q("[")), + TOKEN_DATA(T_LEFTBRACKET_ALT, "<:"), + TOKEN_DATA(T_LEFTBRACKET_TRIGRAPH, "{TRI}" Q("(")), + TOKEN_DATA(T_MINUS, Q("-")), + TOKEN_DATA(T_MINUSASSIGN, Q("-=")), + TOKEN_DATA(T_MINUSMINUS, Q("-") "{2}"), + TOKEN_DATA(T_PERCENT, Q("%")), + TOKEN_DATA(T_PERCENTASSIGN, Q("%=")), + TOKEN_DATA(T_NOT, "!"), + TOKEN_DATA(T_NOTEQUAL, "!="), + TOKEN_DATA(T_OROR, Q("|") "{2}"), + TOKEN_DATA(T_OROR_TRIGRAPH, "{TRI}!\\||\\|{TRI}!|{TRI}!{TRI}!"), + TOKEN_DATA(T_PLUS, Q("+")), + TOKEN_DATA(T_PLUSASSIGN, Q("+=")), + TOKEN_DATA(T_PLUSPLUS, Q("+") "{2}"), + TOKEN_DATA(T_ARROW, Q("->")), + TOKEN_DATA(T_QUESTION_MARK, Q("?")), + TOKEN_DATA(T_RIGHTBRACE, Q("}")), + TOKEN_DATA(T_RIGHTBRACE_ALT, Q("%>")), + TOKEN_DATA(T_RIGHTBRACE_TRIGRAPH, "{TRI}>"), + TOKEN_DATA(T_RIGHTPAREN, Q(")")), + TOKEN_DATA(T_RIGHTBRACKET, Q("]")), + TOKEN_DATA(T_RIGHTBRACKET_ALT, ":>"), + TOKEN_DATA(T_RIGHTBRACKET_TRIGRAPH, "{TRI}" Q(")")), + TOKEN_DATA(T_SEMICOLON, ";"), + TOKEN_DATA(T_SHIFTLEFT, "<<"), + TOKEN_DATA(T_SHIFTLEFTASSIGN, "<<="), + TOKEN_DATA(T_SHIFTRIGHT, ">>"), + TOKEN_DATA(T_SHIFTRIGHTASSIGN, ">>="), + TOKEN_DATA(T_STAR, Q("*")), + TOKEN_DATA(T_COMPL, Q("~")), + TOKEN_DATA(T_COMPL_TRIGRAPH, "{TRI}-"), + TOKEN_DATA(T_STARASSIGN, Q("*=")), + TOKEN_DATA(T_ASM, "asm"), + TOKEN_DATA(T_AUTO, "auto"), + TOKEN_DATA(T_BOOL, "bool"), + TOKEN_DATA(T_FALSE, "false"), + TOKEN_DATA(T_TRUE, "true"), + TOKEN_DATA(T_BREAK, "break"), + TOKEN_DATA(T_CASE, "case"), + TOKEN_DATA(T_CATCH, "catch"), + TOKEN_DATA(T_CHAR, "char"), + TOKEN_DATA(T_CLASS, "class"), + TOKEN_DATA(T_CONST, "const"), + TOKEN_DATA(T_CONSTCAST, "const_cast"), + TOKEN_DATA(T_CONTINUE, "continue"), + TOKEN_DATA(T_DEFAULT, "default"), + TOKEN_DATA(T_DELETE, "delete"), + TOKEN_DATA(T_DO, "do"), + TOKEN_DATA(T_DOUBLE, "double"), + TOKEN_DATA(T_DYNAMICCAST, "dynamic_cast"), + TOKEN_DATA(T_ELSE, "else"), + TOKEN_DATA(T_ENUM, "enum"), + TOKEN_DATA(T_EXPLICIT, "explicit"), + TOKEN_DATA(T_EXPORT, "export"), + TOKEN_DATA(T_EXTERN, "extern"), + TOKEN_DATA(T_FLOAT, "float"), + TOKEN_DATA(T_FOR, "for"), + TOKEN_DATA(T_FRIEND, "friend"), + TOKEN_DATA(T_GOTO, "goto"), + TOKEN_DATA(T_IF, "if"), + TOKEN_DATA(T_INLINE, "inline"), + TOKEN_DATA(T_INT, "int"), + TOKEN_DATA(T_LONG, "long"), + TOKEN_DATA(T_MUTABLE, "mutable"), + TOKEN_DATA(T_NAMESPACE, "namespace"), + TOKEN_DATA(T_NEW, "new"), + TOKEN_DATA(T_OPERATOR, "operator"), + TOKEN_DATA(T_PRIVATE, "private"), + TOKEN_DATA(T_PROTECTED, "protected"), + TOKEN_DATA(T_PUBLIC, "public"), + TOKEN_DATA(T_REGISTER, "register"), + TOKEN_DATA(T_REINTERPRETCAST, "reinterpret_cast"), + TOKEN_DATA(T_RETURN, "return"), + TOKEN_DATA(T_SHORT, "short"), + TOKEN_DATA(T_SIGNED, "signed"), + TOKEN_DATA(T_SIZEOF, "sizeof"), + TOKEN_DATA(T_STATIC, "static"), + TOKEN_DATA(T_STATICCAST, "static_cast"), + TOKEN_DATA(T_STRUCT, "struct"), + TOKEN_DATA(T_SWITCH, "switch"), + TOKEN_DATA(T_TEMPLATE, "template"), + TOKEN_DATA(T_THIS, "this"), + TOKEN_DATA(T_THROW, "throw"), + TOKEN_DATA(T_TRY, "try"), + TOKEN_DATA(T_TYPEDEF, "typedef"), + TOKEN_DATA(T_TYPEID, "typeid"), + TOKEN_DATA(T_TYPENAME, "typename"), + TOKEN_DATA(T_UNION, "union"), + TOKEN_DATA(T_UNSIGNED, "unsigned"), + TOKEN_DATA(T_USING, "using"), + TOKEN_DATA(T_VIRTUAL, "virtual"), + TOKEN_DATA(T_VOID, "void"), + TOKEN_DATA(T_VOLATILE, "volatile"), + TOKEN_DATA(T_WCHART, "wchar_t"), + TOKEN_DATA(T_WHILE, "while"), + TOKEN_DATA(T_PP_DEFINE, "{POUNDDEF}{PPSPACE}define"), + TOKEN_DATA(T_PP_IF, "{POUNDDEF}{PPSPACE}if"), + TOKEN_DATA(T_PP_IFDEF, "{POUNDDEF}{PPSPACE}ifdef"), + TOKEN_DATA(T_PP_IFNDEF, "{POUNDDEF}{PPSPACE}ifndef"), + TOKEN_DATA(T_PP_ELSE, "{POUNDDEF}{PPSPACE}else"), + TOKEN_DATA(T_PP_ELIF, "{POUNDDEF}{PPSPACE}elif"), + TOKEN_DATA(T_PP_ENDIF, "{POUNDDEF}{PPSPACE}endif"), + TOKEN_DATA(T_PP_ERROR, "{POUNDDEF}{PPSPACE}error"), + TOKEN_DATA(T_PP_QHEADER, "{POUNDDEF}{PPSPACE}{INCLUDEDEF}{PPSPACE}" Q("\"") "[^\\n\\r\"]+" Q("\"")), + TOKEN_DATA(T_PP_HHEADER, "{POUNDDEF}{PPSPACE}{INCLUDEDEF}{PPSPACE}" "<" "[^\\n\\r>]+" ">"), + TOKEN_DATA(T_PP_INCLUDE, "{POUNDDEF}{PPSPACE}{INCLUDEDEF}{PPSPACE}"), + TOKEN_DATA(T_PP_LINE, "{POUNDDEF}{PPSPACE}line"), + TOKEN_DATA(T_PP_PRAGMA, "{POUNDDEF}{PPSPACE}pragma"), + TOKEN_DATA(T_PP_UNDEF, "{POUNDDEF}{PPSPACE}undef"), + TOKEN_DATA(T_PP_WARNING, "{POUNDDEF}{PPSPACE}warning"), +#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0 + TOKEN_DATA(T_MSEXT_INT8, "__int8"), + TOKEN_DATA(T_MSEXT_INT16, "__int16"), + TOKEN_DATA(T_MSEXT_INT32, "__int32"), + TOKEN_DATA(T_MSEXT_INT64, "__int64"), + TOKEN_DATA(T_MSEXT_BASED, "_?" "_based"), + TOKEN_DATA(T_MSEXT_DECLSPEC, "_?" "_declspec"), + TOKEN_DATA(T_MSEXT_CDECL, "_?" "_cdecl"), + TOKEN_DATA(T_MSEXT_FASTCALL, "_?" "_fastcall"), + TOKEN_DATA(T_MSEXT_STDCALL, "_?" "_stdcall"), + TOKEN_DATA(T_MSEXT_TRY , "__try"), + TOKEN_DATA(T_MSEXT_EXCEPT, "__except"), + TOKEN_DATA(T_MSEXT_FINALLY, "__finally"), + TOKEN_DATA(T_MSEXT_LEAVE, "__leave"), + TOKEN_DATA(T_MSEXT_INLINE, "_?" "_inline"), + TOKEN_DATA(T_MSEXT_ASM, "_?" "_asm"), + TOKEN_DATA(T_MSEXT_PP_REGION, "{POUNDDEF}{PPSPACE}region"), + TOKEN_DATA(T_MSEXT_PP_ENDREGION, "{POUNDDEF}{PPSPACE}endregion"), +#endif // BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0 + TOKEN_DATA(T_LONGINTLIT, "{INTEGER}{LONGINTEGER_SUFFIX}"), + TOKEN_DATA(T_INTLIT, "{INTEGER}{INTEGER_SUFFIX}?"), + TOKEN_DATA(T_FLOATLIT, + "(" "{DIGIT}*" Q(".") "{DIGIT}+" OR "{DIGIT}+" Q(".") "){EXPONENT}?{FLOAT_SUFFIX}?" OR + "{DIGIT}+{EXPONENT}{FLOAT_SUFFIX}?"), +#if BOOST_WAVE_USE_STRICT_LEXER != 0 + TOKEN_DATA(T_IDENTIFIER, + "(" "{NONDIGIT}" OR "{UNIVERSALCHAR}" ")" + "(" "{NONDIGIT}" OR "{DIGIT}" OR "{UNIVERSALCHAR}" ")*"), +#else + TOKEN_DATA(T_IDENTIFIER, + "(" "{NONDIGIT}" OR Q("$") OR "{UNIVERSALCHAR}" ")" + "(" "{NONDIGIT}" OR Q("$") OR "{DIGIT}" OR "{UNIVERSALCHAR}" ")*"), +#endif + TOKEN_DATA(T_CCOMMENT, "{CCOMMENT}"), + TOKEN_DATA(T_CPPCOMMENT, Q("/") Q("/[^\\n\\r]*") "{NEWLINEDEF}" ), + TOKEN_DATA(T_CHARLIT, + "{CHAR_SPEC}" "'" "({ESCAPESEQ}|[^\\n\\r']|{UNIVERSALCHAR})+" "'"), + TOKEN_DATA(T_STRINGLIT, + "{CHAR_SPEC}" Q("\"") "({ESCAPESEQ}|[^\\n\\r\"]|{UNIVERSALCHAR})*" Q("\"")), + TOKEN_DATA(T_SPACE, "{BLANK}+"), + TOKEN_DATA(T_CONTLINE, Q("\\") "\\n"), + TOKEN_DATA(T_NEWLINE, "{NEWLINEDEF}"), + TOKEN_DATA(T_POUND_POUND, "##"), + TOKEN_DATA(T_POUND_POUND_ALT, Q("%:") Q("%:")), + TOKEN_DATA(T_POUND_POUND_TRIGRAPH, "({TRI}=){2}"), + TOKEN_DATA(T_POUND, "#"), + TOKEN_DATA(T_POUND_ALT, Q("%:")), + TOKEN_DATA(T_POUND_TRIGRAPH, "{TRI}="), + TOKEN_DATA(T_ANY_TRIGRAPH, "{TRI}\\/"), + TOKEN_DATA(T_ANY, "{ANY}"), + TOKEN_DATA(T_ANYCTRL, "{ANYCTRL}"), // this should be the last recognized token + { token_id(0) } // this should be the last entry +}; + +// C++ only token definitions +template <typename Iterator, typename Position> +typename lexertl<Iterator, Position>::lexer_data const +lexertl<Iterator, Position>::init_data_cpp[INIT_DATA_CPP_SIZE] = +{ + TOKEN_DATA(T_AND_ALT, "bitand"), + TOKEN_DATA(T_ANDASSIGN_ALT, "and_eq"), + TOKEN_DATA(T_ANDAND_ALT, "and"), + TOKEN_DATA(T_OR_ALT, "bitor"), + TOKEN_DATA(T_ORASSIGN_ALT, "or_eq"), + TOKEN_DATA(T_OROR_ALT, "or"), + TOKEN_DATA(T_XORASSIGN_ALT, "xor_eq"), + TOKEN_DATA(T_XOR_ALT, "xor"), + TOKEN_DATA(T_NOTEQUAL_ALT, "not_eq"), + TOKEN_DATA(T_NOT_ALT, "not"), + TOKEN_DATA(T_COMPL_ALT, "compl"), +#if BOOST_WAVE_SUPPORT_IMPORT_KEYWORD != 0 + TOKEN_DATA(T_IMPORT, "import"), +#endif + TOKEN_DATA(T_ARROWSTAR, Q("->") Q("*")), + TOKEN_DATA(T_DOTSTAR, Q(".") Q("*")), + TOKEN_DATA(T_COLON_COLON, "::"), + { token_id(0) } // this should be the last entry +}; + +// pp-number specific token definitions +template <typename Iterator, typename Position> +typename lexertl<Iterator, Position>::lexer_data const +lexertl<Iterator, Position>::init_data_pp_number[INIT_DATA_PP_NUMBER_SIZE] = +{ + TOKEN_DATA(T_PP_NUMBER, "{PP_NUMBERDEF}"), + { token_id(0) } // this should be the last entry +}; + +#undef MACRO_DATA +#undef TOKEN_DATA +#undef OR +#undef TRI +#undef Q + +/////////////////////////////////////////////////////////////////////////////// +// initialize lexertl lexer from C++ token regex's +template <typename Iterator, typename Position> +inline bool +lexertl<Iterator, Position>::init_dfa(wave::language_support lang, + Position const& pos, bool force_reinit) +{ + if (has_compiled_dfa_) + return true; + +std::ifstream dfa_in("wave_lexertl_lexer.dfa", std::ios::in|std::ios::binary); + + if (force_reinit || !dfa_in.is_open() || !load (dfa_in)) + { + dfa_in.close(); + + state_machine_.clear(); + + // register macro definitions + boost::lexer::rules rules; + for (int k = 0; NULL != init_macro_data[k].name; ++k) { + rules.add_macro(init_macro_data[k].name, init_macro_data[k].macro); + } + + // if pp-numbers should be preferred, insert the corresponding rule first + if (wave::need_prefer_pp_numbers(lang)) { + for (int j = 0; 0 != init_data_pp_number[j].tokenid; ++j) { + rules.add(init_data_pp_number[j].tokenregex, + init_data_pp_number[j].tokenid); + } + } + + // if in C99 mode, some of the keywords are not valid + if (!wave::need_c99(lang)) { + for (int j = 0; 0 != init_data_cpp[j].tokenid; ++j) { + rules.add(init_data_cpp[j].tokenregex, + init_data_cpp[j].tokenid); + } + } + + for (int i = 0; 0 != init_data[i].tokenid; ++i) { + rules.add(init_data[i].tokenregex, init_data[i].tokenid); + } + + // generate minimized DFA + try { + boost::lexer::generator::build (rules, state_machine_); + boost::lexer::generator::minimise (state_machine_); + } + catch (std::runtime_error const& e) { + string_type msg("lexertl initialization error: "); + msg += e.what(); + BOOST_WAVE_LEXER_THROW(wave::cpplexer::lexing_exception, + unexpected_error, msg.c_str(), + pos.get_line(), pos.get_column(), pos.get_file().c_str()); + return false; + } + + std::ofstream dfa_out ("wave_lexertl_lexer.dfa", + std::ios::out|std::ios::binary|std::ios::trunc); + + if (dfa_out.is_open()) + save (dfa_out); + } + + has_compiled_dfa_ = true; + return true; +} +#endif // BOOST_WAVE_LEXERTL_USE_STATIC_TABLES == 0 + +/////////////////////////////////////////////////////////////////////////////// +// return next token from the input stream +template <typename Iterator, typename Position> +inline wave::token_id +lexertl<Iterator, Position>::next_token(Iterator &first, Iterator const &last, + string_type& token_value) +{ +#if BOOST_WAVE_LEXERTL_USE_STATIC_TABLES == 0 + size_t const* const lookup = &state_machine_.data()._lookup[0]->front (); + size_t const dfa_alphabet = state_machine_.data()._dfa_alphabet[0]; + + size_t const* dfa = &state_machine_.data()._dfa[0]->front(); + size_t const* ptr = dfa + dfa_alphabet + boost::lexer::dfa_offset; +#else + const std::size_t *ptr = dfa + dfa_offset; +#endif // BOOST_WAVE_LEXERTL_USE_STATIC_TABLES == 0 + + Iterator curr = first; + Iterator end_token = first; + bool end_state = (*ptr != 0); + size_t id = *(ptr + 1); + + while (curr != last) { + size_t const state = ptr[lookup[int(*curr)]]; + if (0 == state) + break; + ++curr; + +#if BOOST_WAVE_LEXERTL_USE_STATIC_TABLES == 0 + ptr = &dfa[state * (dfa_alphabet + boost::lexer::dfa_offset)]; +#else + ptr = &dfa[state * dfa_offset]; +#endif // BOOST_WAVE_LEXERTL_USE_STATIC_TABLES == 0 + + if (0 != *ptr) { + end_state = true; + id = *(ptr + 1); + end_token = curr; + } + } + + if (end_state) { + if (T_ANY == id) { + id = TOKEN_FROM_ID(*first, UnknownTokenType); + } + + // return longest match + string_type str(first, end_token); + token_value.swap(str); + first = end_token; + return wave::token_id(id); + } + return T_EOF; +} + +#if BOOST_WAVE_LEXERTL_USE_STATIC_TABLES == 0 +/////////////////////////////////////////////////////////////////////////////// +// load the DFA tables to/from a stream +template <typename Iterator, typename Position> +inline bool +lexertl<Iterator, Position>::load (std::istream& instrm) +{ +// #if !defined(BOOST_WAVE_LEXERTL_GENERATE_CPP_CODE) +// std::size_t version = 0; +// boost::lexer::serialise::load_as_binary(instrm, state_machine_, version); +// if (version != (std::size_t)get_compilation_time()) +// return false; // too new for us +// return instrm.good(); +// #else + return false; // always create the dfa when generating the C++ code +// #endif +} + +/////////////////////////////////////////////////////////////////////////////// +// save the DFA tables to/from a stream +template <typename Iterator, typename Position> +inline bool +lexertl<Iterator, Position>::save (std::ostream& outstrm) +{ +// #if defined(BOOST_WAVE_LEXERTL_GENERATE_CPP_CODE) +// cpp_code::generate(state_machine_, outstrm); +// #else +// boost::lexer::serialise::save_as_binary(state_machine_, outstrm, +// (std::size_t)get_compilation_time()); +// #endif + return outstrm.good(); +} +#endif // #if BOOST_WAVE_LEXERTL_USE_STATIC_TABLES == 0 + +/////////////////////////////////////////////////////////////////////////////// +} // namespace lexer + +/////////////////////////////////////////////////////////////////////////////// +template <typename Iterator, typename Position = wave::util::file_position_type> +class lexertl_functor +: public lexertl_input_interface<wave::cpplexer::lex_token<Position> > +{ +public: + typedef wave::util::position_iterator<Iterator, Position> iterator_type; + typedef typename boost::detail::iterator_traits<Iterator>::value_type + char_type; + typedef BOOST_WAVE_STRINGTYPE string_type; + typedef wave::cpplexer::lex_token<Position> token_type; + + lexertl_functor(Iterator const &first_, Iterator const &last_, + Position const &pos_, wave::language_support language) + : first(first_, last_, pos_), language(language), at_eof(false) + { + lexer_.init_dfa(language, pos_); + } + ~lexertl_functor() {} + +// get the next token from the input stream + token_type& get(token_type& result) + { + if (lexer_.is_initialized() && !at_eof) { + do { + // generate and return the next token + string_type token_val; + Position pos = first.get_position(); // begin of token position + wave::token_id id = lexer_.next_token(first, last, token_val); + + if (T_CONTLINE != id) { + // The cast should avoid spurious warnings about missing case labels + // for the other token ids's. + switch (id) { + case T_IDENTIFIER: + // test identifier characters for validity (throws if + // invalid chars found) + if (!wave::need_no_character_validation(language)) { + using wave::cpplexer::impl::validate_identifier_name; + validate_identifier_name(token_val, + pos.get_line(), pos.get_column(), pos.get_file()); + } + break; + + case T_STRINGLIT: + case T_CHARLIT: + // test literal characters for validity (throws if invalid + // chars found) + if (wave::need_convert_trigraphs(language)) { + using wave::cpplexer::impl::convert_trigraphs; + token_val = convert_trigraphs(token_val); + } + if (!wave::need_no_character_validation(language)) { + using wave::cpplexer::impl::validate_literal; + validate_literal(token_val, + pos.get_line(), pos.get_column(), pos.get_file()); + } + break; + + case T_LONGINTLIT: // supported in C99 and long_long mode + if (!wave::need_long_long(language)) { + // syntax error: not allowed in C++ mode + BOOST_WAVE_LEXER_THROW( + wave::cpplexer::lexing_exception, + invalid_long_long_literal, token_val.c_str(), + pos.get_line(), pos.get_column(), + pos.get_file().c_str()); + } + break; + +#if BOOST_WAVE_SUPPORT_INCLUDE_NEXT != 0 + case T_PP_HHEADER: + case T_PP_QHEADER: + case T_PP_INCLUDE: + // convert to the corresponding ..._next token, if appropriate + { + // Skip '#' and whitespace and see whether we find an + // 'include_next' here. + typename string_type::size_type start = token_val.find("include"); + if (0 == token_val.compare(start, 12, "include_next", 12)) + id = token_id(id | AltTokenType); + } + break; +#endif // BOOST_WAVE_SUPPORT_INCLUDE_NEXT != 0 + + case T_EOF: + // T_EOF is returned as a valid token, the next call will + // return T_EOI, i.e. the actual end of input + at_eof = true; + token_val.clear(); + break; + + case T_OR_TRIGRAPH: + case T_XOR_TRIGRAPH: + case T_LEFTBRACE_TRIGRAPH: + case T_RIGHTBRACE_TRIGRAPH: + case T_LEFTBRACKET_TRIGRAPH: + case T_RIGHTBRACKET_TRIGRAPH: + case T_COMPL_TRIGRAPH: + case T_POUND_TRIGRAPH: + case T_ANY_TRIGRAPH: + if (wave::need_convert_trigraphs(language)) + { + using wave::cpplexer::impl::convert_trigraph; + token_val = convert_trigraph(token_val); + } + break; + + case T_ANYCTRL: + // matched some unexpected character + { + // 21 is the max required size for a 64 bit integer + // represented as a string + char buffer[22]; + string_type msg("invalid character in input stream: '0x"); + + // for some systems sprintf is in namespace std + using namespace std; + sprintf(buffer, "%02x'", token_val[0]); + msg += buffer; + BOOST_WAVE_LEXER_THROW( + wave::cpplexer::lexing_exception, + generic_lexing_error, + msg.c_str(), pos.get_line(), pos.get_column(), + pos.get_file().c_str()); + } + break; + } + + result = token_type(id, token_val, pos); +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + return guards.detect_guard(result); +#else + return result; +#endif + } + } while (true); // skip the T_CONTLINE token + } + return result = token_type(); // return T_EOI + } + + void set_position(Position const &pos) + { + // set position has to change the file name and line number only + first.get_position().set_file(pos.get_file()); + first.get_position().set_line(pos.get_line()); + } + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + bool has_include_guards(std::string& guard_name) const + { return guards.detected(guard_name); } +#endif + +private: + iterator_type first; + iterator_type last; + + wave::language_support language; + bool at_eof; +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + include_guards<token_type> guards; +#endif + + static lexer::lexertl<iterator_type, Position> lexer_; +}; + +template <typename Iterator, typename Position> +lexer::lexertl< + typename lexertl_functor<Iterator, Position>::iterator_type, Position> + lexertl_functor<Iterator, Position>::lexer_; + +#undef INIT_DATA_SIZE +#undef INIT_DATA_CPP_SIZE +#undef INIT_DATA_PP_NUMBER_SIZE +#undef INIT_MACRO_DATA_SIZE +#undef T_ANYCTRL + +/////////////////////////////////////////////////////////////////////////////// +// +// The new_lexer_gen<>::new_lexer function (declared in lexertl_interface.hpp) +// should be defined inline, if the lex_functor shouldn't be instantiated +// separately from the lex_iterator. +// +// Separate (explicit) instantiation helps to reduce compilation time. +// +/////////////////////////////////////////////////////////////////////////////// + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 +#define BOOST_WAVE_FLEX_NEW_LEXER_INLINE +#else +#define BOOST_WAVE_FLEX_NEW_LEXER_INLINE inline +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// The 'new_lexer' function allows the opaque generation of a new lexer object. +// It is coupled to the iterator type to allow to decouple the lexer/iterator +// configurations at compile time. +// +// This function is declared inside the xlex_interface.hpp file, which is +// referenced by the source file calling the lexer and the source file, which +// instantiates the lex_functor. But it is defined here, so it will be +// instantiated only while compiling the source file, which instantiates the +// lex_functor. While the xlex_interface.hpp file may be included everywhere, +// this file (xlex_lexer.hpp) should be included only once. This allows +// to decouple the lexer interface from the lexer implementation and reduces +// compilation time. +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename Iterator, typename Position> +BOOST_WAVE_FLEX_NEW_LEXER_INLINE +wave::cpplexer::lex_input_interface<wave::cpplexer::lex_token<Position> > * +new_lexer_gen<Iterator, Position>::new_lexer(Iterator const &first, + Iterator const &last, Position const &pos, wave::language_support language) +{ + return new lexertl_functor<Iterator, Position>(first, last, pos, language); +} + +#undef BOOST_WAVE_FLEX_NEW_LEXER_INLINE + +/////////////////////////////////////////////////////////////////////////////// +}}}} // namespace boost::wave::cpplexer::lexertl + +#endif // !defined(BOOST_WAVE_LEXERTL_LEXER_HPP_INCLUDED) + diff --git a/src/boost/libs/wave/samples/list_includes/lexertl/wave_lexertl_config.hpp b/src/boost/libs/wave/samples/list_includes/lexertl/wave_lexertl_config.hpp new file mode 100644 index 00000000..919e3ffc --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/lexertl/wave_lexertl_config.hpp @@ -0,0 +1,35 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(BOOST_WAVE_WAVE_LEXERTL_CONFIG_HPP_INCLUDED) +#define BOOST_WAVE_WAVE_LEXERTL_CONFIG_HPP_INCLUDED + +/////////////////////////////////////////////////////////////////////////////// +// If the BOOST_WAVE_LEXERTL_USE_STATIC_TABLES constant is defined to be not +// equal to zero, the lexer will use static pre-compiled dfa tables (as +// included in the file: wave_lexertl_tables.hpp). Enabling the static tables +// makes the code compilable even without having the lexertl library +// available. +#if !defined(BOOST_WAVE_LEXERTL_USE_STATIC_TABLES) +#define BOOST_WAVE_LEXERTL_USE_STATIC_TABLES 0 +#endif + +/////////////////////////////////////////////////////////////////////////////// +// If the dfa tables have to be generated at runtime, and the constant +// BOOST_WAVE_LEXERTL_GENERATE_CPP_CODE is defined to be not equal to zero, +// the lexer will write C++ code for static DFA tables. This is useful for +// generating the static tables required for the +// BOOST_WAVE_LEXERTL_USE_STATIC_TABLES as described above. +#if BOOST_WAVE_LEXERTL_USE_STATIC_TABLES != 0 +#if !defined(BOOST_WAVE_LEXERTL_GENERATE_CPP_CODE) +#define BOOST_WAVE_LEXERTL_GENERATE_CPP_CODE 0 +#endif +#endif + +#endif // !BOOST_WAVE_WAVE_LEXERTL_CONFIG_HPP_INCLUDED diff --git a/src/boost/libs/wave/samples/list_includes/lexertl/wave_lexertl_tables.hpp b/src/boost/libs/wave/samples/list_includes/lexertl/wave_lexertl_tables.hpp new file mode 100644 index 00000000..494125bc --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/lexertl/wave_lexertl_tables.hpp @@ -0,0 +1,6598 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(BOOST_WAVE_WAVE_LEXERTL_TABLES_HPP_INCLUDED) +#define BOOST_WAVE_WAVE_LEXERTL_TABLES_HPP_INCLUDED + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { namespace wave { namespace cpplexer { namespace lexertl +{ +// this number was manually taken from the generated code +// here: const std::size_t *ptr_ = dfa_ + 81; + const int dfa_offset = 81; + +// Auto-generated by lexertl (http://www.benhanson.net/lexertl.html) + const std::size_t lookup[256] = {4, 4, 4, 4, 4, 4, 4, 4, + 4, 5, 7, 5, 5, 8, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, + 6, 9, 10, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 24, 23, 25, 26, + 27, 31, 32, 33, 34, 28, 35, 28, + 36, 29, 37, 38, 39, 40, 41, 42, + 80, 30, 30, 30, 30, 46, 47, 43, + 43, 43, 43, 43, 48, 43, 43, 43, + 43, 43, 43, 43, 43, 49, 43, 43, + 50, 43, 43, 51, 52, 53, 54, 55, + 80, 56, 12, 57, 58, 59, 13, 60, + 61, 62, 43, 63, 45, 64, 65, 66, + 67, 68, 69, 70, 71, 44, 11, 72, + 73, 74, 75, 76, 77, 78, 79, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80}; + const std::size_t dfa[52326] = {0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 59, 55, 55, + 56, 57, 24, 54, 44, 2, 32, 46, + 50, 23, 11, 53, 21, 27, 30, 25, + 8, 16, 9, 17, 48, 49, 49, 50, + 49, 49, 49, 49, 49, 49, 10, 29, + 20, 12, 18, 14, 50, 43, 38, 50, + 50, 52, 50, 50, 22, 51, 28, 15, + 47, 3, 7, 34, 35, 36, 50, 37, + 50, 39, 6, 4, 40, 50, 41, 42, + 33, 45, 5, 50, 50, 19, 13, 26, + 31, 58, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 60, 50, 50, 50, 61, 50, 50, 62, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 67, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 65, 50, 50, 50, + 50, 66, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 69, + 50, 68, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 70, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 72, 50, + 50, 73, 50, 50, 50, 50, 50, 50, + 71, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 77, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 75, + 50, 50, 50, 50, 76, 50, 50, 50, + 50, 74, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 805306647, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 80, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 79, 78, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 805306636, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 81, 0, + 0, 0, 82, 0, 83, 83, 83, 0, + 83, 83, 83, 83, 83, 83, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 805306633, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 84, + 0, 0, 0, 85, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 805306624, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 86, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 87, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 805306626, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 88, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 805306628, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 89, 0, 91, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 90, 0, 0, 0, 3, 805306660, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 805306630, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 93, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 805306632, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 805306634, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 95, 0, + 0, 0, 0, 96, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 94, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 805306640, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 97, 98, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 805306642, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 805306643, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 99, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 101, 0, 102, 100, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 805306645, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 805306646, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 805306650, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 105, 0, 0, 103, + 104, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 805306652, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 106, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 805306655, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 108, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 107, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 805306661, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 805306662, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 805306663, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 805306665, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 805306670, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 109, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 805306671, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 111, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 110, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 112, 50, 50, 113, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 115, 50, 116, 50, + 50, 50, 50, 50, 50, 50, 114, 50, + 50, 50, 50, 117, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 118, 50, 50, + 50, 50, 50, 50, 119, 50, 50, 50, + 50, 50, 50, 50, 120, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 121, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 122, 50, 50, 50, + 50, 50, 50, 50, 123, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 124, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 125, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 126, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 127, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 128, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 130, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 129, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 131, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 132, + 133, 50, 50, 50, 50, 50, 50, 50, + 50, 134, 135, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 136, 50, 50, 50, + 50, 137, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 138, 50, 50, 50, 139, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 140, 50, + 50, 50, 141, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 805306765, + 0, 0, 0, 142, 142, 0, 0, 0, + 0, 0, 0, 0, 152, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 143, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 149, 147, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 144, 146, 0, 0, 145, 0, 0, 0, + 0, 148, 0, 151, 0, 0, 150, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 154, 157, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 153, 160, + 156, 155, 50, 50, 50, 159, 50, 50, + 50, 50, 50, 50, 50, 158, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 1090519425, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 83, 0, 162, 162, 166, 0, 162, + 162, 162, 162, 162, 166, 0, 0, 0, + 0, 0, 0, 0, 163, 164, 167, 0, + 164, 163, 161, 0, 0, 0, 0, 0, + 0, 0, 0, 167, 0, 0, 165, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 161, 0, 0, 0, 0, 0, 0, + 0, 3, 1090519425, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 83, 0, 49, 49, 49, 0, + 49, 49, 49, 49, 49, 49, 0, 0, + 0, 0, 0, 0, 0, 163, 164, 167, + 0, 164, 163, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 167, 0, 0, 165, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 2684354958, 0, 0, 0, + 0, 0, 170, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 168, + 0, 0, 0, 0, 169, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 172, 50, + 50, 50, 0, 50, 0, 0, 171, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 2684354958, 0, + 0, 175, 175, 175, 0, 0, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 0, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 174, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 173, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 3, 2684354958, + 0, 0, 172, 172, 172, 0, 0, 172, + 178, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 177, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 176, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 3, + 3489661321, 0, 0, 0, 55, 55, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 2952790411, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 2952790411, 0, 0, 0, 0, 0, + 56, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 2684354958, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 536871335, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 179, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 180, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 181, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 168, 0, 0, 0, 0, + 169, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 182, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 183, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 184, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 185, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 810549534, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 186, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 187, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 188, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 189, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 190, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 191, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 192, 193, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 194, 195, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 196, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 197, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 805306658, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 198, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 805306648, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 805306649, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 805306637, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 199, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 1107296643, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 201, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 83, 83, + 83, 0, 83, 83, 83, 83, 83, 83, + 0, 0, 0, 0, 0, 0, 0, 0, + 202, 200, 201, 202, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 200, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 805306664, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 806355239, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 805306625, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 805306627, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 805306639, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 805306629, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 805306654, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 203, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 204, 0, 0, + 0, 0, 0, 0, 0, 0, 205, 207, + 209, 0, 0, 210, 0, 0, 212, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 206, 211, 208, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 805306631, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 805306635, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 213, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, + 0, 0, 0, 0, 96, 96, 96, 214, + 215, 96, 96, 96, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, 96, 96, + 96, 3, 805306641, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 805306668, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 216, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 806355218, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 805306644, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 806355222, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 805306666, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 217, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 805306651, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 806355237, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 806355341, 0, 0, 0, 142, 142, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 218, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 143, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 149, 147, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 144, 146, 0, 0, 145, + 0, 0, 0, 0, 148, 0, 151, 0, + 0, 150, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 805306653, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 805306656, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 805306657, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 805306672, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 219, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 220, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 221, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 222, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 223, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 224, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 225, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 226, 50, 50, 50, 50, 50, + 50, 227, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 228, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 229, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 230, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 536871233, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 231, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 232, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 233, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 234, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 235, 50, + 50, 50, 236, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 237, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871245, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 238, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 239, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 240, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 241, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 242, + 50, 50, 50, 243, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 244, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 245, + 50, 246, 50, 50, 50, 50, 50, 50, + 50, 50, 247, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 248, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 249, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 250, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 251, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 252, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 253, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 254, 50, + 50, 50, 50, 50, 50, 50, 255, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 256, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 257, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 259, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 258, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 260, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 261, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 142, 142, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 143, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 149, 147, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 144, 146, 0, 0, 145, 0, 0, 0, + 0, 148, 0, 151, 0, 0, 150, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 262, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 263, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 264, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 265, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 266, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 267, 0, 0, 0, 268, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 269, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 270, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 271, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 272, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 273, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 805306764, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 154, 275, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 278, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 160, 156, 155, 277, 50, 50, 274, + 50, 50, 50, 50, 50, 50, 50, 158, + 276, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 279, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 280, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 281, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 282, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 283, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 284, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 285, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 286, 286, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 286, 286, 286, 286, + 286, 286, 286, 286, 286, 286, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 286, + 286, 0, 0, 0, 0, 0, 0, 0, + 0, 286, 286, 286, 286, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 1090519425, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 83, 0, 162, 162, 166, + 0, 162, 162, 162, 162, 162, 166, 0, + 0, 0, 0, 0, 0, 0, 163, 164, + 167, 0, 164, 163, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 167, 0, 0, + 165, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 1090519425, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 287, 0, 0, 287, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 1090519425, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 289, 288, 0, 0, 288, 289, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 290, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 83, + 0, 166, 166, 166, 0, 166, 166, 166, + 166, 166, 166, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 167, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 167, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 291, 291, 0, + 0, 0, 292, 292, 292, 0, 292, 292, + 292, 292, 292, 292, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 293, 293, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 293, 293, 293, 293, 293, + 293, 293, 293, 293, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 293, 293, + 0, 0, 0, 0, 0, 0, 0, 0, + 293, 293, 293, 293, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 294, 294, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 294, 294, 294, 294, + 294, 294, 294, 294, 294, 294, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 294, + 294, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 294, 294, 294, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 2952790408, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 175, + 175, 175, 0, 0, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 0, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 174, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 173, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 0, 0, 0, 0, + 172, 172, 172, 0, 0, 172, 178, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 177, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 176, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 0, 0, 0, + 0, 175, 175, 175, 0, 0, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 295, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 297, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 296, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 298, 175, + 175, 175, 175, 175, 175, 175, 0, 0, + 0, 0, 175, 175, 175, 0, 0, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 300, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 299, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 296, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 0, + 0, 0, 0, 175, 175, 175, 0, 0, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 300, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 297, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 296, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 0, 0, 0, 0, 172, 172, 172, 0, + 0, 172, 301, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 177, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 176, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 302, 172, 172, 172, 172, 172, 172, + 172, 0, 0, 0, 0, 172, 172, 172, + 0, 0, 172, 178, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 303, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 176, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 3, 1124073863, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 304, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 305, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 306, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 307, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 63, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 810549505, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 308, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871217, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 309, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 310, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 311, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 810549510, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 312, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 810549532, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 313, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 314, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 536871251, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 315, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 316, + 317, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 318, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 319, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 320, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 321, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 805306659, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 805306638, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 322, 322, + 0, 0, 0, 323, 323, 323, 0, 323, + 323, 323, 323, 323, 323, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 1107296643, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 324, 0, + 0, 324, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 1107296643, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 324, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 324, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 325, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 807403780, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 326, 0, 91, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 325, 0, 0, 0, 3, 807403782, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 327, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 807403794, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 807403798, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 807403813, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 807403815, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 807403823, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 807403917, 0, 0, 0, + 142, 142, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 143, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 328, 0, 149, + 147, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 144, 146, 0, + 0, 145, 0, 0, 0, 0, 148, 0, + 151, 0, 0, 150, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 2686452110, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 168, 0, 0, 0, 0, 169, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 213, 329, 329, 329, 329, 330, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 3, 3490709893, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 3490709893, 0, 0, 0, 0, 0, 214, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 805306669, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 805306667, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 331, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 332, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 333, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871242, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 334, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 335, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871269, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 336, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 337, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 338, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 339, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 340, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 341, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 342, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 343, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 344, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 345, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 346, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 347, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 348, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 349, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 350, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 536871247, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 351, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 352, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 353, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 354, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 355, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 356, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 357, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 358, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 359, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 360, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 361, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 362, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 363, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 364, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 365, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 366, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 367, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 368, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 369, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 370, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 371, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 372, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 262, 262, 262, 262, 262, 262, + 262, 262, 262, 262, 262, 262, 262, 262, + 262, 262, 262, 373, 262, 262, 262, 262, + 262, 262, 262, 262, 262, 262, 262, 262, + 262, 262, 262, 262, 262, 262, 262, 262, + 262, 262, 262, 262, 262, 262, 262, 262, + 262, 262, 262, 262, 262, 262, 262, 262, + 262, 262, 262, 262, 262, 262, 262, 262, + 262, 262, 262, 262, 262, 262, 262, 262, + 262, 262, 262, 262, 262, 262, 262, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 374, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 1350566258, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 375, 0, 0, 0, 0, 0, + 0, 376, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 377, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 379, 0, 0, 0, 0, 0, 0, 0, + 378, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 380, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 381, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 382, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 383, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 384, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 385, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 386, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 387, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 282, 50, 50, 50, 50, + 50, 388, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 389, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 390, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 391, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 392, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 393, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 394, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 395, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 396, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 397, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 398, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 1090519425, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 286, 286, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 286, 286, 286, 286, 286, 286, 286, + 286, 286, 286, 0, 0, 0, 0, 0, + 0, 0, 163, 164, 286, 286, 164, 163, + 0, 0, 0, 0, 0, 0, 286, 286, + 286, 286, 0, 0, 165, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 1090519425, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 399, 0, 0, 399, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 1090519426, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 399, 0, 0, 0, + 0, 399, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 1090519425, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 399, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 292, 292, + 292, 0, 292, 292, 292, 292, 292, 292, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 1107296643, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 201, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 292, + 292, 292, 0, 292, 292, 292, 292, 292, + 292, 0, 0, 0, 0, 0, 0, 0, + 0, 202, 0, 201, 202, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 400, 400, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 400, 400, 400, 400, 400, 400, 400, 400, + 400, 400, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 400, 400, 0, 0, 0, + 0, 0, 0, 0, 0, 400, 400, 400, + 400, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 401, 401, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 401, 401, 401, 401, 401, 401, 401, + 401, 401, 401, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 401, 401, 0, 0, + 0, 0, 0, 0, 0, 0, 401, 401, + 401, 401, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 1140851078, 0, 0, 175, 175, 175, 0, 0, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 300, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 297, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 296, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 0, 0, 0, 0, 175, 175, 175, 0, + 0, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 295, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 297, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 296, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 402, 175, 175, 175, 175, 175, 175, + 175, 0, 0, 0, 0, 175, 175, 175, + 0, 0, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 300, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 403, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 296, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 0, 0, 0, 0, 175, 175, + 175, 0, 0, 175, 175, 175, 298, 298, + 175, 175, 175, 175, 300, 175, 175, 175, + 175, 175, 175, 175, 175, 298, 298, 298, + 298, 298, 298, 298, 298, 298, 298, 175, + 175, 175, 175, 175, 297, 175, 175, 175, + 298, 298, 175, 175, 175, 175, 296, 175, + 175, 175, 298, 298, 298, 298, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 0, 0, 0, 0, 175, + 175, 175, 0, 0, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 300, 175, 175, + 175, 175, 175, 175, 175, 173, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 403, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 296, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 3, 1140851078, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 1124073863, 0, + 0, 172, 172, 172, 0, 0, 172, 178, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 177, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 176, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 0, 0, + 0, 0, 172, 172, 172, 0, 0, 172, + 178, 172, 302, 302, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 302, 302, 302, 302, 302, 302, 302, + 302, 302, 302, 172, 172, 172, 172, 172, + 177, 172, 172, 172, 302, 302, 172, 172, + 172, 172, 176, 172, 172, 172, 302, 302, + 302, 302, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 0, + 0, 0, 0, 172, 172, 172, 0, 0, + 172, 178, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 176, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 303, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 176, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 404, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 405, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 536871219, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 406, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 407, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871218, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 408, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 409, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 410, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 411, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 412, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 413, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 414, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 415, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 536871223, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 416, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871225, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 417, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 323, 323, 323, + 0, 323, 323, 323, 323, 323, 323, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 1107296643, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 201, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 323, 323, + 323, 0, 323, 323, 323, 323, 323, 323, + 0, 0, 0, 0, 0, 0, 0, 0, + 202, 0, 201, 202, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 1107296643, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 807403806, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 807403781, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 807403783, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 418, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 419, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 3, 3490709892, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 806355340, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 420, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 421, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 422, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 1157628213, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 423, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 536871267, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 424, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 425, 50, 50, + 50, 426, 50, 50, 427, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 428, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 429, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 430, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 431, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871236, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 536871237, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 432, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 433, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 434, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871244, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 435, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 536871248, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 436, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 437, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 438, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 439, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 440, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 441, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 442, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 443, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 444, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 445, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 446, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 447, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 448, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 449, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 450, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 451, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 452, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 536871277, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 453, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 454, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 455, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 373, 456, 456, 456, 456, 142, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 457, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 458, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 459, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 460, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 461, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 462, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 463, 0, 0, 0, 0, 0, + 0, 464, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 465, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 466, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 467, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 468, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 469, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 470, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 397, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 471, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 472, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 473, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 474, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 475, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 476, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 477, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 478, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 479, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 480, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 481, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 536871331, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 1090519426, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 482, 482, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 482, 482, 482, 482, 482, + 482, 482, 482, 482, 482, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 482, 482, + 0, 0, 0, 0, 0, 0, 0, 0, + 482, 482, 482, 482, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 483, 483, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 483, 483, 483, 483, + 483, 483, 483, 483, 483, 483, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 483, + 483, 0, 0, 0, 0, 0, 0, 0, + 0, 483, 483, 483, 483, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 175, 175, + 175, 0, 0, 175, 175, 175, 402, 402, + 175, 175, 175, 175, 300, 175, 175, 175, + 175, 175, 175, 175, 175, 402, 402, 402, + 402, 402, 402, 402, 402, 402, 402, 175, + 175, 175, 175, 175, 297, 175, 175, 175, + 402, 402, 175, 175, 175, 175, 296, 175, + 175, 175, 402, 402, 402, 402, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 0, 0, 0, 0, 175, + 175, 175, 0, 0, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 300, 175, 175, + 175, 175, 175, 175, 175, 296, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 403, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 296, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 484, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 810549508, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 536871222, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 485, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 810549509, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 486, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 487, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 488, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 489, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 810549551, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 536871227, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 490, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 491, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871224, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 536871226, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 492, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 419, 329, 329, 329, 329, 330, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 3, 1157628212, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871241, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 493, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 494, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871268, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 495, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 496, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 497, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 498, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 499, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 500, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 501, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 502, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 503, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 504, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 505, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 506, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 507, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 508, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 509, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 510, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 511, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 512, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 536871259, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 513, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 514, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 515, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 516, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 517, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 536871273, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 518, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 536871275, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 519, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 520, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 521, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 536871280, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 522, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 523, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 524, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 525, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 526, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 1350566261, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 1350566262, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 527, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 528, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 529, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 1342177657, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 530, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 531, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 532, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 533, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 535, 50, + 536, 50, 537, 534, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 538, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 536871326, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 539, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 540, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 541, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 542, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 543, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 544, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 545, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 546, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 168, + 168, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 168, 168, + 168, 168, 168, 168, 168, 168, 168, 168, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 168, 168, 0, 0, 0, 0, 0, + 0, 0, 0, 168, 168, 168, 168, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 810549504, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 810549507, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 547, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 810549511, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 810549533, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 548, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 549, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 550, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 807403916, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 536871243, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 551, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 552, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871271, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 553, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 554, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 536871232, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 536871234, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 555, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 556, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 536871239, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871240, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 536871246, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 557, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 558, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 559, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871255, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 560, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 561, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871258, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 536871260, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 536871261, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 536871262, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 562, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 536871264, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871265, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 563, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 564, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 565, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 566, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 522, + 456, 456, 456, 456, 142, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 456, 456, 456, 456, 456, + 456, 456, 456, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 567, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 1350566259, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 568, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 569, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, + 1350566263, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 570, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 1342177656, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 571, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 1342177659, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 572, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 573, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 536871317, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 574, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 575, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 576, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 577, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 578, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 579, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871321, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 580, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 536871323, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 581, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 582, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 583, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 584, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 585, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 586, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 587, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 588, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871270, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 589, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 536871230, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 590, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 591, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871249, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 536871253, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 592, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 593, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 594, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 595, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 596, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 536871276, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 597, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 536871279, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 1342177649, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 1350566260, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 598, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 599, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 1342177658, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 600, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 1342177700, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 536871318, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 536871319, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871320, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 601, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 602, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 536871329, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 603, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 268435837, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 604, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 605, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 536871330, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871252, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 606, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 607, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 536871229, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 536871266, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871272, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 608, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 536871238, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 609, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 536871256, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 610, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 611, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 536871274, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871278, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 1342177679, + 0, 0, 0, 612, 612, 0, 0, 0, + 614, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 613, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 616, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 615, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 617, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 1342177660, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 618, 50, 0, 0, 0, + 0, 0, 3, 536871327, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 619, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 620, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871325, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 536871250, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 621, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 622, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 3, 536871254, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 3, 268435837, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 623, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 624, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 1342177679, 0, 0, + 0, 612, 612, 0, 0, 0, 614, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 613, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 616, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 625, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 626, 626, 626, 0, 0, 626, + 0, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 627, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 628, 628, 628, 0, + 0, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 0, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 629, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 536871328, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 0, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 64, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 63, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 3, 536871322, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 536871324, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871228, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 630, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 631, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 268435837, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 632, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 625, 625, 625, + 625, 625, 625, 625, 625, 625, 625, 625, + 625, 625, 625, 625, 625, 625, 633, 625, + 625, 625, 625, 625, 625, 625, 625, 625, + 625, 625, 625, 625, 625, 625, 625, 625, + 625, 625, 625, 625, 625, 625, 625, 625, + 625, 625, 625, 625, 625, 625, 625, 625, + 625, 625, 625, 625, 625, 625, 625, 625, + 625, 625, 625, 625, 625, 625, 625, 625, + 625, 625, 625, 625, 625, 625, 625, 625, + 625, 625, 0, 0, 0, 0, 626, 626, + 626, 0, 0, 626, 634, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 626, 626, 626, 626, 626, + 626, 626, 626, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 635, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 628, 628, 628, 0, 0, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 636, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 628, 628, 628, + 628, 628, 628, 628, 628, 3, 1342177701, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 637, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 3, + 268435837, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 64, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 63, 0, 0, 638, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 3, 536871263, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 64, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 63, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 633, 639, + 639, 639, 639, 612, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 3, 1342177680, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 640, 0, 0, 0, + 0, 0, 0, 0, 3, 1342177681, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 536871235, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 3, 268435837, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 0, 0, 0, 0, 0, + 64, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 63, 0, 0, 50, 50, 641, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 642, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 612, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 268435837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 0, + 50, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 0, + 0, 0, 0, 64, 50, 50, 50, 50, + 50, 50, 50, 50, 0, 63, 0, 0, + 50, 643, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 642, + 639, 639, 639, 639, 612, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 3, 268435837, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 0, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 64, 50, 50, + 50, 50, 50, 50, 50, 50, 0, 63, + 0, 0, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 644, 50, 50, 50, 50, 50, 0, + 0, 0, 0, 0, 3, 268435837, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 0, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0, 64, 50, + 50, 50, 50, 50, 50, 50, 50, 0, + 63, 0, 0, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 645, 50, 50, 50, 50, + 0, 0, 0, 0, 0, 3, 536871257, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 0, 0, 0, 0, 0, 64, + 50, 50, 50, 50, 50, 50, 50, 50, + 0, 63, 0, 0, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, + 50, 0, 0, 0, 0, 0}; + +/////////////////////////////////////////////////////////////////////////////// +}}}} // namespace boost::wave::cpplexer::lexertl + +#endif // !BOOST_WAVE_WAVE_LEXERTL_TABLES_HPP_INCLUDED diff --git a/src/boost/libs/wave/samples/list_includes/lexertl_interface.hpp b/src/boost/libs/wave/samples/list_includes/lexertl_interface.hpp new file mode 100644 index 00000000..5b29d9b9 --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/lexertl_interface.hpp @@ -0,0 +1,77 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Definition of the abstract lexer interface for the lexertl based C++ lexer + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(BOOST_WAVE_LEXERTL_INTERFACE_HPP_INCLUDED) +#define BOOST_WAVE_LEXERTL_INTERFACE_HPP_INCLUDED + +#include <boost/wave/language_support.hpp> +#include <boost/wave/util/file_position.hpp> +#include <boost/wave/cpplexer/cpp_lex_interface.hpp> + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { namespace wave { namespace cpplexer { namespace lexertl +{ + +/////////////////////////////////////////////////////////////////////////////// +// +// new_lexer_gen: generates a new instance of the required C++ lexer +// +/////////////////////////////////////////////////////////////////////////////// +template < + typename IteratorT, + typename PositionT = wave::util::file_position_type +> +struct new_lexer_gen +{ +// The NewLexer function allows the opaque generation of a new lexer object. +// It is coupled to the token type to allow to decouple the lexer/token +// configurations at compile time. + static wave::cpplexer::lex_input_interface< + wave::cpplexer::lex_token<PositionT> + > * + new_lexer(IteratorT const &first, IteratorT const &last, + PositionT const &pos, wave::language_support language); +}; + +/////////////////////////////////////////////////////////////////////////////// +// +// The lexertl_input_interface helps to instantiate a concrete lexer +// to be used by the Wave preprocessor module. +// This is done to allow compile time reduction by separation of the lexer +// iterator exposed to the Wave library and the lexer implementation. +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename TokenT> +struct lexertl_input_interface +: wave::cpplexer::lex_input_interface<TokenT> +{ + typedef typename wave::cpplexer::lex_input_interface<TokenT>::position_type + position_type; + +// The new_lexer function allows the opaque generation of a new lexer object. +// It is coupled to the token type to allow to distinguish different +// lexer/token configurations at compile time. + template <typename IteratorT> + static wave::cpplexer::lex_input_interface<TokenT> * + new_lexer(IteratorT const &first, IteratorT const &last, + position_type const &pos, wave::language_support language) + { + return new_lexer_gen<IteratorT, position_type>::new_lexer (first, last, + pos, language); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +}}}} // namespace boost::wave::cpplexer::lexertl + +#endif // !defined(BOOST_WAVE_LEXERTL_INTERFACE_HPP_INCLUDED) diff --git a/src/boost/libs/wave/samples/list_includes/lexertl_iterator.hpp b/src/boost/libs/wave/samples/list_includes/lexertl_iterator.hpp new file mode 100644 index 00000000..42d821f9 --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/lexertl_iterator.hpp @@ -0,0 +1,227 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Definition of the lexertl based lexer iterator + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(BOOST_WAVE_LEXERTL_ITERATOR_HPP_INCLUDED) +#define BOOST_WAVE_LEXERTL_ITERATOR_HPP_INCLUDED + +#include <string> + +#include <boost/assert.hpp> +#include <boost/shared_ptr.hpp> +#include <boost/spirit/include/support_multi_pass.hpp> + +#include <boost/wave/language_support.hpp> +#include <boost/wave/util/file_position.hpp> +#include <boost/wave/util/functor_input.hpp> + +#include "lexertl_interface.hpp" + +#if 0 != __COMO_VERSION__ || !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) +#define BOOST_WAVE_EOF_PREFIX static +#else +#define BOOST_WAVE_EOF_PREFIX +#endif + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { namespace wave { namespace cpplexer { namespace lexertl +{ + +/////////////////////////////////////////////////////////////////////////////// +namespace impl { + +/////////////////////////////////////////////////////////////////////////////// +// +// lex_iterator_functor_shim +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename TokenT> +class iterator_functor_shim +{ + typedef typename TokenT::position_type position_type; + +public: + iterator_functor_shim() +#if /*0 != __DECCXX_VER || */defined(__PGI) + , eof() +#endif // 0 != __DECCXX_VER + {} + +// interface to the boost::spirit::classic::iterator_policies::functor_input +// policy + typedef TokenT result_type; + typedef iterator_functor_shim unique; + typedef lex_input_interface<TokenT>* shared; + + BOOST_WAVE_EOF_PREFIX result_type const eof; + + template <typename MultiPass> + static result_type& get_next(MultiPass& mp, result_type& result) + { + return mp.shared()->ftor->get(result); + } + + // this will be called whenever the last reference to a multi_pass will + // be released + template <typename MultiPass> + static void destroy(MultiPass& mp) + { + delete mp.shared()->ftor; + } + + template <typename MultiPass> + static void set_position(MultiPass& mp, position_type const &pos) + { + mp.shared()->ftor->set_position(pos); + } + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + template <typename MultiPass> + static bool has_include_guards(MultiPass& mp, std::string& guard_name) + { + return mp.shared()->ftor->has_include_guards(guard_name); + } +#endif + +private: + boost::shared_ptr<lex_input_interface<TokenT> > functor_ptr; +}; + +#if 0 != __COMO_VERSION__ || !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) +/////////////////////////////////////////////////////////////////////////////// +// eof token +template <typename TokenT> +typename iterator_functor_shim<TokenT>::result_type const + iterator_functor_shim<TokenT>::eof = + typename iterator_functor_shim<TokenT>::result_type(); +#endif // 0 != __COMO_VERSION__ + +/////////////////////////////////////////////////////////////////////////////// +} // namespace impl + +/////////////////////////////////////////////////////////////////////////////// +// +// lexertl_iterator +// +// A generic C++ lexer interface class, which allows to plug in different +// lexer implementations (template parameter LexT). The following +// requirement apply: +// +// - the lexer type should have a function implemented, which returnes +// the next lexed token from the input stream: +// typename LexT::token_type get(); +// - at the end of the input stream this function should return the +// eof token equivalent +// - the lexer should implement a constructor taking two iterators +// pointing to the beginning and the end of the input stream and +// a third parameter containing the name of the parsed input file, +// the 4th parameter contains the information about the mode the +// preprocessor is used in (C99/C++ mode etc.) +// +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Divide the given functor type into its components (unique and shared) +// and build a std::pair from these parts +template <typename FunctorData> +struct make_multi_pass +{ + typedef + std::pair<typename FunctorData::unique, typename FunctorData::shared> + functor_data_type; + typedef typename FunctorData::result_type result_type; + + typedef boost::spirit::iterator_policies::split_functor_input input_policy; + typedef boost::spirit::iterator_policies::ref_counted ownership_policy; +#if defined(BOOST_WAVE_DEBUG) + typedef boost::spirit::iterator_policies::buf_id_check check_policy; +#else + typedef boost::spirit::iterator_policies::no_check check_policy; +#endif + typedef boost::spirit::iterator_policies::split_std_deque storage_policy; + + typedef boost::spirit::iterator_policies::default_policy< + ownership_policy, check_policy, input_policy, storage_policy> + policy_type; + typedef boost::spirit::multi_pass<functor_data_type, policy_type> type; +}; + +template <typename TokenT> +class lex_iterator +: public make_multi_pass<impl::iterator_functor_shim<TokenT> >::type +{ + typedef impl::iterator_functor_shim<TokenT> input_policy_type; + + typedef typename make_multi_pass<input_policy_type>::type base_type; + typedef typename make_multi_pass<input_policy_type>::functor_data_type + functor_data_type; + + typedef typename input_policy_type::unique unique_functor_type; + typedef typename input_policy_type::shared shared_functor_type; + +public: + typedef TokenT token_type; + + lex_iterator() + {} + + template <typename IteratorT> + lex_iterator(IteratorT const &first, IteratorT const &last, + typename TokenT::position_type const &pos, + boost::wave::language_support language) + : base_type( + functor_data_type( + unique_functor_type(), + lexertl_input_interface<TokenT> + ::new_lexer(first, last, pos, language) + ) + ) + {} + + void set_position(typename TokenT::position_type const &pos) + { + typedef typename TokenT::position_type position_type; + + // set the new position in the current token + token_type const& currtoken = this->base_type::dereference(*this); + position_type currpos = currtoken.get_position(); + + currpos.set_file(pos.get_file()); + currpos.set_line(pos.get_line()); + const_cast<token_type&>(currtoken).set_position(currpos); + + // set the new position for future tokens as well + if (token_type::string_type::npos != + currtoken.get_value().find_first_of('\n')) + { + currpos.set_line(pos.get_line() + 1); + } + unique_functor_type::set_position(*this, currpos); + } + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + // Return, whether the current file has include guards. This function + // returns meaningful results only if the file was scanned completely. + // For now we always return false, but this can be fixed easily later on. + bool has_include_guards(std::string& guard_name) const + { + return base_type::get_functor().has_include_guards(*this, guard_name); + } +#endif +}; + +/////////////////////////////////////////////////////////////////////////////// +}}}} // namespace boost::wave::cpplexer::lexertl + +#undef BOOST_WAVE_EOF_PREFIX + +#endif // !defined(BOOST_WAVE_LEXERTL_ITERATOR_HPP_INCLUDED) diff --git a/src/boost/libs/wave/samples/list_includes/list_includes.cpp b/src/boost/libs/wave/samples/list_includes/list_includes.cpp new file mode 100644 index 00000000..47c2b604 --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/list_includes.cpp @@ -0,0 +1,324 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: List include dependencies of a given source file + + The 'list_includes' sample shows a simple way, how to use the Wave C++ + preprocessor library to extract a list of included files from a given + source file. + To get a hint which commandline options are supported, call it with the + --help option. + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "list_includes.hpp" // config data + +/////////////////////////////////////////////////////////////////////////////// +// include required boost libraries +#include <boost/assert.hpp> +#include <boost/program_options.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include Wave itself +#include <boost/wave.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include the lexer stuff +#include <boost/wave/cpplexer/cpp_lex_token.hpp> // standard token type +#include "lexertl_iterator.hpp" // lexertl based lexer + +/////////////////////////////////////////////////////////////////////////////// +// Include the default context trace policies +#include <boost/wave/preprocessing_hooks.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// include lexer specifics, import lexer names +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION == 0 +#include <boost/wave/cpplexer/re2clex/cpp_re2c_lexer.hpp> +#endif + +/////////////////////////////////////////////////////////////////////////////// +// import required names +using namespace boost::spirit::classic; + +using std::string; +using std::vector; +using std::set; +using std::cout; +using std::cerr; +using std::endl; +using std::ifstream; +using std::ostream; +using std::istreambuf_iterator; + +namespace po = boost::program_options; + +/////////////////////////////////////////////////////////////////////////////// +namespace cmd_line_util { + + // predicate to extract all positional arguments from the command line + struct is_argument { + bool operator()(po::option const &opt) + { + return (opt.position_key == -1) ? true : false; + } + }; + +/////////////////////////////////////////////////////////////////////////////// +} + +/////////////////////////////////////////////////////////////////////////////// +// print the current version + +int print_version() +{ +// get time of last compilation of this file +boost::wave::util::time_conversion_helper compilation_time(__DATE__ " " __TIME__); + +// calculate the number of days since Jan 29 2003 +// (the day the list_includes project was started) +std::tm first_day; + + std::memset (&first_day, 0, sizeof(std::tm)); + first_day.tm_mon = 0; // Jan + first_day.tm_mday = 29; // 29 + first_day.tm_year = 103; // 2003 + +long seconds = long(std::difftime(compilation_time.get_time(), + std::mktime(&first_day))); + + cout + << LIST_INCLUDES_VERSION_MAJOR << '.' + << LIST_INCLUDES_VERSION_MINOR << '.' + << LIST_INCLUDES_VERSION_SUBMINOR << '.' + << seconds/(3600*24); // get number of days from seconds + return 1; // exit app +} + +/////////////////////////////////////////////////////////////////////////////// +// policy class +struct trace_include_files +: public boost::wave::context_policies::default_preprocessing_hooks +{ + trace_include_files(set<string> &files_) + : files(files_), include_depth(0) + {} + +#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0 + void + opened_include_file(string const &relname, string const &filename, + std::size_t /*include_depth*/, bool is_system_include) +#else + template <typename ContextT> + void + opened_include_file(ContextT const& ctx, std::string const& relname, + std::string const& filename, bool is_system_include) +#endif + { + set<string>::iterator it = files.find(filename); + if (it == files.end()) { + // print indented filename + for (std::size_t i = 0; i < include_depth; ++i) + cout << " "; + cout << filename << endl; + + files.insert(filename); + } + ++include_depth; + } + +#if BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0 + void returning_from_include_file() +#else + template <typename ContextT> + void returning_from_include_file(ContextT const& ctx) +#endif + { + --include_depth; + } + + set<string> &files; + std::size_t include_depth; +}; + +/////////////////////////////////////////////////////////////////////////////// +// +int +do_actual_work(vector<string> const &arguments, po::variables_map const &vm) +{ +// current file position is saved for exception handling +boost::wave::util::file_position_type current_position; + + try { + // list the included files for all arguments given + vector<string>::const_iterator lastfile = arguments.end(); + for (vector<string>::const_iterator file_it = arguments.begin(); + file_it != lastfile; ++file_it) + { + ifstream instream((*file_it).c_str()); + string instring; + + if (!instream.is_open()) { + cerr << "Could not open input file: " << *file_it << endl; + continue; + } + instream.unsetf(std::ios::skipws); + instring = string(istreambuf_iterator<char>(instream.rdbuf()), + istreambuf_iterator<char>()); + + // The template boost::wave::cpplexer::lex_token<> is the token type to be + // used by the Wave library. + typedef boost::wave::cpplexer::lexertl::lex_iterator< + boost::wave::cpplexer::lex_token<> > + lex_iterator_type; + typedef boost::wave::context< + std::string::iterator, lex_iterator_type, + boost::wave::iteration_context_policies::load_file_to_string, + trace_include_files + > context_type; + + set<string> files; + trace_include_files trace(files); + + // The preprocessor iterator shouldn't be constructed directly. It is + // to be generated through a wave::context<> object. This wave:context<> + // object is additionally to be used to initialize and define different + // parameters of the actual preprocessing. + // The preprocessing of the input stream is done on the fly behind the + // scenes during iteration over the context_type::iterator_type stream. + context_type ctx (instring.begin(), instring.end(), (*file_it).c_str(), trace); + + // add include directories to the include path + if (vm.count("include")) { + vector<string> const &paths = + vm["include"].as<vector<string> >(); + vector<string>::const_iterator end = paths.end(); + for (vector<string>::const_iterator cit = paths.begin(); + cit != end; ++cit) + { + ctx.add_include_path((*cit).c_str()); + } + } + + // add system include directories to the include path + if (vm.count("sysinclude")) { + vector<string> const &syspaths = + vm["sysinclude"].as<vector<string> >(); + vector<string>::const_iterator end = syspaths.end(); + for (vector<string>::const_iterator cit = syspaths.begin(); + cit != end; ++cit) + { + ctx.add_sysinclude_path((*cit).c_str()); + } + } + + // analyze the actual file + context_type::iterator_type first = ctx.begin(); + context_type::iterator_type last = ctx.end(); + + cout << "Printing dependency information for: " + << *file_it << endl; + + while (first != last) { + current_position = (*first).get_position(); + ++first; + } + + // prepend endl before next file + cout << endl; + } + } + catch (boost::wave::cpp_exception &e) { + // some preprocessing error + cerr + << e.file_name() << "(" << e.line_no() << "): " + << e.description() << endl; + return 2; + } + catch (std::exception &e) { + // use last recognized token to retrieve the error position + cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "exception caught: " << e.what() + << endl; + return 3; + } + catch (...) { + // use last recognized token to retrieve the error position + cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "unexpected exception caught." << endl; + return 4; + } + return 0; +} + +/////////////////////////////////////////////////////////////////////////////// +// here we go! +int +main (int argc, char *argv[]) +{ + try { + // analyze the command line options and arguments + vector<string> syspathes; + po::options_description desc("Usage: list_includes [options] file ..."); + + desc.add_options() + ("help,h", "print out program usage (this message)") + ("version,v", "print the version number") + ("include,I", po::value<vector<string> >(), + "specify additional include directory") + ("sysinclude,S", po::value<vector<string> >(), + "specify additional system include directory") + ; + + using namespace boost::program_options::command_line_style; + + po::parsed_options opts = po::parse_command_line(argc, argv, desc, unix_style); + po::variables_map vm; + + po::store(opts, vm); + po::notify(vm); + + if (vm.count("help")) { + cout << desc << endl; + return 1; + } + + if (vm.count("version")) { + return print_version(); + } + + // extract the arguments from the parsed command line + vector<po::option> arguments; + + std::remove_copy_if(opts.options.begin(), opts.options.end(), + inserter(arguments, arguments.end()), cmd_line_util::is_argument()); + + // if there is no input file given, then exit + if (0 == arguments.size() || 0 == arguments[0].value.size()) { + cerr << "list_includes: No input file given. " + << "Use --help to get a hint." << endl; + return 5; + } + + // iterate over all given input files + return do_actual_work(arguments[0].value , vm); + } + catch (std::exception &e) { + cout << "list_includes: exception caught: " << e.what() << endl; + return 6; + } + catch (...) { + cerr << "list_includes: unexpected exception caught." << endl; + return 7; + } +} + diff --git a/src/boost/libs/wave/samples/list_includes/list_includes.hpp b/src/boost/libs/wave/samples/list_includes/list_includes.hpp new file mode 100644 index 00000000..2a6277eb --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/list_includes.hpp @@ -0,0 +1,42 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: List include dependencies of a given source file + Configuration data + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(LIST_INCLUDES_HPP_843DB412_3AA8_4BCF_8081_AA4A5FDE0BE7_INCLUDED) +#define LIST_INCLUDES_HPP_843DB412_3AA8_4BCF_8081_AA4A5FDE0BE7_INCLUDED + +/////////////////////////////////////////////////////////////////////////////// +// include often used files from the stdlib +#include <iostream> +#include <fstream> +#include <string> +#include <vector> +#include <set> + +/////////////////////////////////////////////////////////////////////////////// +// include boost config +#include <boost/config.hpp> // global configuration information + +/////////////////////////////////////////////////////////////////////////////// +// build version +#include "list_includes_version.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// configure this app here (global configuration constants) +#include "list_includes_config.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// include required boost libraries +#include <boost/assert.hpp> +#include <boost/pool/pool_alloc.hpp> + +#endif // !defined(LIST_INCLUDES_HPP_843DB412_3AA8_4BCF_8081_AA4A5FDE0BE7_INCLUDED) diff --git a/src/boost/libs/wave/samples/list_includes/list_includes_config.hpp b/src/boost/libs/wave/samples/list_includes/list_includes_config.hpp new file mode 100644 index 00000000..59556af0 --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/list_includes_config.hpp @@ -0,0 +1,64 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Global application configuration of the list_includes sample + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(LIST_INCLUDES_CONFIG_HPP_0DE80E47_8D50_4DFA_9C1C_0EECAA8A934A_INCLUDED) +#define LIST_INCLUDES_CONFIG_HPP_0DE80E47_8D50_4DFA_9C1C_0EECAA8A934A_INCLUDED + +/////////////////////////////////////////////////////////////////////////////// +// Uncomment the following, if you need debug output, the +// BOOST_SPIRIT_DEBUG_FLAGS constants below help to fine control the amount of +// the generated debug output +//#define BOOST_SPIRIT_DEBUG + +/////////////////////////////////////////////////////////////////////////////// +// debug rules, subrules and grammars only, for possible flags see +// spirit/debug.hpp +#if defined(BOOST_SPIRIT_DEBUG) + +#define BOOST_SPIRIT_DEBUG_FLAGS ( \ + BOOST_SPIRIT_DEBUG_FLAGS_NODES | \ + BOOST_SPIRIT_DEBUG_FLAGS_CLOSURES \ + ) \ + /**/ + +/////////////////////////////////////////////////////////////////////////////// +// debug flags for the pp-iterator library, possible flags (defined in +// wave_config.hpp): +// +// #define BOOST_SPIRIT_DEBUG_FLAGS_CPP_GRAMMAR 0x0001 +// #define BOOST_SPIRIT_DEBUG_FLAGS_TIME_CONVERSION 0x0002 +// #define BOOST_SPIRIT_DEBUG_FLAGS_CPP_EXPR_GRAMMAR 0x0004 +// #define BOOST_SPIRIT_DEBUG_FLAGS_INTLIT_GRAMMAR 0x0008 +// #define BOOST_SPIRIT_DEBUG_FLAGS_CHLIT_GRAMMAR 0x0010 +// #define BOOST_SPIRIT_DEBUG_FLAGS_DEFINED_GRAMMAR 0x0020 +// #define BOOST_SPIRIT_DEBUG_FLAGS_PREDEF_MACROS_GRAMMAR 0x0040 + +#define BOOST_SPIRIT_DEBUG_FLAGS_CPP (\ + /* insert the required flags from above */ \ + ) \ + /**/ +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Now include the configuration stuff for the Wave library itself +#include <boost/wave/wave_config.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// MSVC specific #pragma's +#if defined(BOOST_MSVC) +#pragma warning (disable: 4355) // 'this' used in base member initializer list +#pragma warning (disable: 4800) // forcing value to bool 'true' or 'false' +#pragma inline_depth(255) +#pragma inline_recursion(on) +#endif // defined(BOOST_MSVC) + +#endif // !defined(LIST_INCLUDES_CONFIG_HPP_0DE80E47_8D50_4DFA_9C1C_0EECAA8A934A_INCLUDED) diff --git a/src/boost/libs/wave/samples/list_includes/list_includes_version.hpp b/src/boost/libs/wave/samples/list_includes/list_includes_version.hpp new file mode 100644 index 00000000..8f517e08 --- /dev/null +++ b/src/boost/libs/wave/samples/list_includes/list_includes_version.hpp @@ -0,0 +1,20 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: List include dependencies of a given source file version number + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(LIST_INCLUDES_VERSION_HPP_FF662D6C_C3E6_4BEC_A062_5D9BD7415EBF_INCLUDED) +#define LIST_INCLUDES_VERSION_HPP_FF662D6C_C3E6_4BEC_A062_5D9BD7415EBF_INCLUDED + +#define LIST_INCLUDES_VERSION_MAJOR 0 +#define LIST_INCLUDES_VERSION_MINOR 4 +#define LIST_INCLUDES_VERSION_SUBMINOR 0 + +#endif // !defined(LIST_INCLUDES_VERSION_HPP_FF662D6C_C3E6_4BEC_A062_5D9BD7415EBF_INCLUDED) diff --git a/src/boost/libs/wave/samples/preprocess_pragma_output/build/Jamfile.v2 b/src/boost/libs/wave/samples/preprocess_pragma_output/build/Jamfile.v2 new file mode 100644 index 00000000..237ffc95 --- /dev/null +++ b/src/boost/libs/wave/samples/preprocess_pragma_output/build/Jamfile.v2 @@ -0,0 +1,22 @@ +# Boost.Wave: A Standard compliant C++ preprocessor library +# +# Boost Wave Library Sample Build Jamfile (preprocess_pragma_output) +# +# http://www.boost.org/ +# +# Copyright (c) 2001-2008 Hartmut Kaiser. Distributed under the Boost +# Software License, Version 1.0. (See accompanying file +# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +exe preprocess_pragma_output + : ../preprocess_pragma_output.cpp + /boost/wave//boost_wave + /boost/thread//boost_thread + /boost/date_time//boost_date_time + /boost/filesystem//boost_filesystem + /boost/system//boost_system + : + <toolset>msvc-8.0:<define>_SCL_SECURE_NO_DEPRECATE + <toolset>msvc-8.0:<define>_CRT_SECURE_NO_DEPRECATE + ; + diff --git a/src/boost/libs/wave/samples/preprocess_pragma_output/example.cpp b/src/boost/libs/wave/samples/preprocess_pragma_output/example.cpp new file mode 100644 index 00000000..5c39e9cf --- /dev/null +++ b/src/boost/libs/wave/samples/preprocess_pragma_output/example.cpp @@ -0,0 +1,24 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Example demonstrating how to preprocess the token stream generated by a + #pragma directive + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +/////////////////////////////////////////////////////////////////////////////// +// This special pragma is implemented by the interpret_pragma hook function +// provided in the preprocess_pragma_output_hooks policy class. This +// #pragma preprocesses the provided arguments in the current context. +#pragma wave pp ( \ + "#define A() \"some text\" and more\n" \ + "#define B() 1.0\n" \ + ) \ + /**/ + +A() // this should produce: "some text" and more +B() // and this expands to 1.0 diff --git a/src/boost/libs/wave/samples/preprocess_pragma_output/preprocess_pragma_output.cpp b/src/boost/libs/wave/samples/preprocess_pragma_output/preprocess_pragma_output.cpp new file mode 100644 index 00000000..063eadda --- /dev/null +++ b/src/boost/libs/wave/samples/preprocess_pragma_output/preprocess_pragma_output.cpp @@ -0,0 +1,115 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Example demonstrating how to preprocess the token stream generated by a + #pragma directive + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <iostream> +#include <fstream> +#include <string> +#include <vector> + +/////////////////////////////////////////////////////////////////////////////// +// Include Wave itself +#include <boost/wave.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include the lexer stuff +#include <boost/wave/cpplexer/cpp_lex_token.hpp> // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer class + +/////////////////////////////////////////////////////////////////////////////// +// Include special preprocessing hooks +#include "preprocess_pragma_output.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// main entry point +int main(int argc, char *argv[]) +{ + if (2 != argc) { + std::cerr << "Usage: preprocess_pragma_output infile" << std::endl; + return -1; + } + +// current file position is saved for exception handling +boost::wave::util::file_position_type current_position; + + try { + // Open and read in the specified input file. + std::ifstream instream(argv[1]); + std::string instring; + + if (!instream.is_open()) { + std::cerr << "Could not open input file: " << argv[1] << std::endl; + return -2; + } + instream.unsetf(std::ios::skipws); + instring = std::string(std::istreambuf_iterator<char>(instream.rdbuf()), + std::istreambuf_iterator<char>()); + + // The template boost::wave::cpplexer::lex_token<> is the token type to be + // used by the Wave library. + typedef boost::wave::cpplexer::lex_token<> token_type; + + // The template boost::wave::cpplexer::lex_iterator<> is the lexer type to + // be used by the Wave library. + typedef boost::wave::cpplexer::lex_iterator<token_type> lex_iterator_type; + + // This is the resulting context type to use. + typedef boost::wave::context< + std::string::iterator, lex_iterator_type, + boost::wave::iteration_context_policies::load_file_to_string, + preprocess_pragma_output_hooks> + context_type; + + // The preprocessor iterator shouldn't be constructed directly. It is + // to be generated through a wave::context<> object. This wave:context<> + // object is to be used additionally to initialize and define different + // parameters of the actual preprocessing (not done here). + // + // The preprocessing of the input stream is done on the fly behind the + // scenes during iteration over the context_type::iterator_type stream. + context_type ctx (instring.begin(), instring.end(), argv[1]); + + // analyze the input file + context_type::iterator_type first = ctx.begin(); + context_type::iterator_type last = ctx.end(); + + while (first != last) { + current_position = (*first).get_position(); + std::cout << (*first).get_value(); + ++first; + } + } + catch (boost::wave::cpp_exception const& e) { + // some preprocessing error + std::cerr + << e.file_name() << "(" << e.line_no() << "): " + << e.description() << std::endl; + return 2; + } + catch (std::exception const& e) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "exception caught: " << e.what() + << std::endl; + return 3; + } + catch (...) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "unexpected exception caught." << std::endl; + return 4; + } + return 0; +} diff --git a/src/boost/libs/wave/samples/preprocess_pragma_output/preprocess_pragma_output.hpp b/src/boost/libs/wave/samples/preprocess_pragma_output/preprocess_pragma_output.hpp new file mode 100644 index 00000000..1fe1051e --- /dev/null +++ b/src/boost/libs/wave/samples/preprocess_pragma_output/preprocess_pragma_output.hpp @@ -0,0 +1,167 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Example demonstrating how to preprocess the token stream generated by a + #pragma directive + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(BOOST_WAVE_SAMPLE_PREPROCESS_PRAGMA_OUTPUT_APR_03_2008_0813AM) +#define BOOST_WAVE_SAMPLE_PREPROCESS_PRAGMA_OUTPUT_APR_03_2008_0813AM + +template <typename String, typename Iterator> +inline String +as_unescaped_string(Iterator it, Iterator const& end) +{ + using namespace boost::wave; + + String result; + for (/**/; it != end; ++it) + { + switch (token_id(*it)) { + case T_STRINGLIT: + { + string val (util::impl::unescape_lit((*it).get_value()).c_str()); + val.erase(val.size()-1); + val.erase(0, 1); + result += val; + } + break; + + default: // just skip everything else (hey it's a sample) + break; + } + } + return result; +} + +// return the string representation of a token sequence +template <typename String, typename Container> +inline String +as_unescaped_string(Container const &token_sequence) +{ + return as_unescaped_string<String>(token_sequence.begin(), + token_sequence.end()); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// The preprocess_pragma_output_hooks policy class is used implement a special +// #pragma wave pp("some C++ code") directive allowing to insert preprocessed +// code into the output sequence generated by the tool. +// +// This policy type is used as a template parameter to the boost::wave::context<> +// object. +// +/////////////////////////////////////////////////////////////////////////////// +class preprocess_pragma_output_hooks +: public boost::wave::context_policies::default_preprocessing_hooks +{ +public: + preprocess_pragma_output_hooks() {} + + template <typename Context> + struct reset_language_support + { + reset_language_support(Context& ctx) + : ctx_(ctx), lang_(ctx.get_language()) + { + ctx.set_language(boost::wave::enable_single_line(lang_), false); + } + ~reset_language_support() + { + ctx_.set_language(lang_, false); + } + + Context& ctx_; + boost::wave::language_support lang_; + }; + + /////////////////////////////////////////////////////////////////////////// + // + // The function 'interpret_pragma' is called, whenever a #pragma command + // directive is found which isn't known to the core Wave library, where + // command is the value defined as the BOOST_WAVE_PRAGMA_KEYWORD constant + // which defaults to "wave". + // + // The parameter 'ctx' is a reference to the context object used for + // instantiating the preprocessing iterators by the user. + // + // The parameter 'pending' may be used to push tokens back into the input + // stream, which are to be used as the replacement text for the whole + // #pragma directive. + // + // The parameter 'option' contains the name of the interpreted pragma. + // + // The parameter 'values' holds the values of the parameter provided to + // the pragma operator. + // + // The parameter 'act_token' contains the actual #pragma token, which may + // be used for error output. + // + // If the return value is 'false', the whole #pragma directive is + // interpreted as unknown and a corresponding error message is issued. A + // return value of 'true' signs a successful interpretation of the given + // #pragma. + // + /////////////////////////////////////////////////////////////////////////// + template <typename Context, typename Container> + bool + interpret_pragma(Context& ctx, Container &pending, + typename Context::token_type const& option, + Container const& values, typename Context::token_type const& act_token) + { + typedef typename Context::token_type token_type; + typedef typename Context::iterator_type iterator_type; + + if (option.get_value() == "pp") { + // Concatenate the string(s) passed as the options to this pragma, + // preprocess the result using the current context and insert the + // generated token sequence in place of the pragma directive into the + // output stream. + + try { + // We're explicitly using a std::string here since the type of the + // iterators passed to the ctx.begin() below must match the types + // of the iterator the original context instance has been created + // with. + std::string s (as_unescaped_string<std::string>(values)); + reset_language_support<Context> lang(ctx); + + using namespace boost::wave; + + // The expanded token sequence is stored in the 'pragma' container + // to ensure consistency in the output in the case of an error + // while preprocessing the pragma option strings. + Container pragma; + iterator_type end = ctx.end(); + for (iterator_type it = ctx.begin(s.begin(), s.end()); + it != end && token_id(*it) != T_EOF; ++it) + { + pragma.push_back(*it); + it++; + } + + // prepend the newly generated token sequence to the 'pending' + // container + pending.splice(pending.begin(), pragma); + } + catch (boost::wave::preprocess_exception const& /*e*/) { + // the library will report an 'ill_formed_pragma_option' for us + return false; + } + return true; + } + + // we don't know anything about this #pragma wave directive + return false; + } +}; + + +#endif + diff --git a/src/boost/libs/wave/samples/quick_start/build/Jamfile.v2 b/src/boost/libs/wave/samples/quick_start/build/Jamfile.v2 new file mode 100644 index 00000000..0ee14dfa --- /dev/null +++ b/src/boost/libs/wave/samples/quick_start/build/Jamfile.v2 @@ -0,0 +1,18 @@ +# Boost.Wave: A Standard compliant C++ preprocessor library +# +# Boost Wave Library Sample Build Jamfile (quick_start) +# +# http://www.boost.org/ +# +# Copyright (c) 2001-2011 Hartmut Kaiser. Distributed under the Boost +# Software License, Version 1.0. (See accompanying file +# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +exe quick_start + : ../quick_start.cpp + /boost/wave//boost_wave + /boost/system//boost_system + /boost/thread//boost_thread + /boost/date_time//boost_date_time + ; + diff --git a/src/boost/libs/wave/samples/quick_start/quick_start.cpp b/src/boost/libs/wave/samples/quick_start/quick_start.cpp new file mode 100644 index 00000000..ac31001b --- /dev/null +++ b/src/boost/libs/wave/samples/quick_start/quick_start.cpp @@ -0,0 +1,119 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + http://www.boost.org/ + + Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <iostream> +#include <fstream> +#include <string> +#include <vector> + +/////////////////////////////////////////////////////////////////////////////// +// Include Wave itself +#include <boost/wave.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include the lexer stuff +#include <boost/wave/cpplexer/cpp_lex_token.hpp> // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer class + +/////////////////////////////////////////////////////////////////////////////// +// main entry point +int main(int argc, char *argv[]) +{ + if (2 != argc) { + std::cerr << "Usage: quick_start infile" << std::endl; + return -1; + } + +// current file position is saved for exception handling +boost::wave::util::file_position_type current_position; + + try { +//[quick_start_main + // The following preprocesses the input file given by argv[1]. + // Open and read in the specified input file. + std::ifstream instream(argv[1]); + std::string instring; + + if (!instream.is_open()) { + std::cerr << "Could not open input file: " << argv[1] << std::endl; + return -2; + } + instream.unsetf(std::ios::skipws); + instring = std::string(std::istreambuf_iterator<char>(instream.rdbuf()), + std::istreambuf_iterator<char>()); + + // This token type is one of the central types used throughout the library. + // It is a template parameter to some of the public classes and instances + // of this type are returned from the iterators. + typedef boost::wave::cpplexer::lex_token<> token_type; + + // The template boost::wave::cpplexer::lex_iterator<> is the lexer type to + // to use as the token source for the preprocessing engine. It is + // parametrized with the token type. + typedef boost::wave::cpplexer::lex_iterator<token_type> lex_iterator_type; + + // This is the resulting context type. The first template parameter should + // match the iterator type used during construction of the context + // instance (see below). It is the type of the underlying input stream. + typedef boost::wave::context<std::string::iterator, lex_iterator_type> + context_type; + + // The preprocessor iterator shouldn't be constructed directly. It is + // generated through a wave::context<> object. This wave:context<> object + // is additionally used to initialize and define different parameters of + // the actual preprocessing (not done here). + // + // The preprocessing of the input stream is done on the fly behind the + // scenes during iteration over the range of context_type::iterator_type + // instances. + context_type ctx (instring.begin(), instring.end(), argv[1]); + + // Get the preprocessor iterators and use them to generate the token + // sequence. + context_type::iterator_type first = ctx.begin(); + context_type::iterator_type last = ctx.end(); + + // The input stream is preprocessed for you while iterating over the range + // [first, last). The dereferenced iterator returns tokens holding + // information about the preprocessed input stream, such as token type, + // token value, and position. + while (first != last) { + current_position = (*first).get_position(); + std::cout << (*first).get_value(); + ++first; + } +//] + } + catch (boost::wave::cpp_exception const& e) { + // some preprocessing error + std::cerr + << e.file_name() << "(" << e.line_no() << "): " + << e.description() << std::endl; + return 2; + } + catch (std::exception const& e) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "exception caught: " << e.what() + << std::endl; + return 3; + } + catch (...) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "unexpected exception caught." << std::endl; + return 4; + } + return 0; +} diff --git a/src/boost/libs/wave/samples/real_positions/build/Jamfile.v2 b/src/boost/libs/wave/samples/real_positions/build/Jamfile.v2 new file mode 100644 index 00000000..7373fae4 --- /dev/null +++ b/src/boost/libs/wave/samples/real_positions/build/Jamfile.v2 @@ -0,0 +1,25 @@ +# Boost.Wave: A Standard compliant C++ preprocessor library +# +# Boost Wave Library Sample Build Jamfile (real_positions) +# +# http://www.boost.org/ +# +# Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost +# Software License, Version 1.0. (See accompanying file +# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +exe real_positions + : ../real_positions.cpp + ../instantiate_cpp_exprgrammar.cpp + ../instantiate_cpp_grammar.cpp + ../instantiate_cpp_literalgrs.cpp + ../instantiate_defined_grammar.cpp + ../instantiate_re2c_lexer.cpp + ../instantiate_re2c_lexer_str.cpp + /boost/wave//boost_wave + /boost/filesystem//boost_filesystem + /boost/system//boost_system + /boost/thread//boost_thread + /boost/date_time//boost_date_time + ; + diff --git a/src/boost/libs/wave/samples/real_positions/correct_token_positions.hpp b/src/boost/libs/wave/samples/real_positions/correct_token_positions.hpp new file mode 100644 index 00000000..e42fd08c --- /dev/null +++ b/src/boost/libs/wave/samples/real_positions/correct_token_positions.hpp @@ -0,0 +1,126 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(CORRECT_TOKEN_POSITIONS_HK_061106_INCLUDED) +#define CORRECT_TOKEN_POSITIONS_HK_061106_INCLUDED + +#include <boost/iterator/transform_iterator.hpp> + +/////////////////////////////////////////////////////////////////////////////// +namespace detail +{ + // count the newlines in a C style comment + template <typename String> + unsigned count_newlines(String const& str) + { + unsigned newlines = 0; + typename String::size_type p = str.find_first_of('\n'); + while (p != String::npos) + { + ++newlines; + p = str.find_first_of('\n', p+1); + } + return newlines; + } + + // return the length of the last line in a C style comment + template <typename String> + unsigned last_line_length(String const& str) + { + unsigned len = str.size(); + typename String::size_type p = str.find_last_of('\n'); + if (p != String::npos) + len -= p; + return len; + } +} + +/////////////////////////////////////////////////////////////////////////////// +// This is the position correcting functor +template <typename Token> +struct correct_token_position +: public boost::wave::context_policies::eat_whitespace<Token> +{ + correct_token_position(typename Token::string_type filename) + : pos(filename) {} + + /////////////////////////////////////////////////////////////////////////// + // + // The function 'generated_token' will be called by the library whenever a + // token is about to be returned from the library. + // + // The parameter 'ctx' is a reference to the context object used for + // instantiating the preprocessing iterators by the user. + // + // The parameter 't' is the token about to be returned from the library. + // This function may alter the token, but in this case it must be + // implemented with a corresponding signature: + // + // TokenT const& + // generated_token(ContextT const& ctx, TokenT& t); + // + // which makes it possible to modify the token in place. + // + // The default behavior is to return the token passed as the parameter + // without modification. + // + /////////////////////////////////////////////////////////////////////////// + template <typename Context> + Token const& + generated_token(Context const& ctx, Token& token) + { + typedef typename Token::string_type string_type; + typedef typename Token::position_type position_type; + + using namespace boost::wave; + + // adjust the current position + position_type current_pos(pos); + + token_id id = token_id(token); + string_type const& v (token.get_value()); + + switch (id) { + case T_NEWLINE: + case T_CPPCOMMENT: + pos.set_line(current_pos.get_line()+1); + pos.set_column(1); + break; + + case T_CCOMMENT: + { + unsigned lines = detail::count_newlines(v); + if (lines > 0) { + pos.set_line(current_pos.get_line() + lines); + pos.set_column(detail::last_line_length(v)); + } + else { + pos.set_column(current_pos.get_column() + + detail::last_line_length(v)); + } + } + break; + + default: + pos.set_column(current_pos.get_column() + v.size()); + break; + } + + // set the new position in the token to be returned + token.set_corrected_position(current_pos); + return token; + } + + typename Token::position_type pos; +}; + +/////////////////////////////////////////////////////////////////////////////// + +#endif diff --git a/src/boost/libs/wave/samples/real_positions/instantiate_cpp_exprgrammar.cpp b/src/boost/libs/wave/samples/real_positions/instantiate_cpp_exprgrammar.cpp new file mode 100644 index 00000000..69c59d42 --- /dev/null +++ b/src/boost/libs/wave/samples/real_positions/instantiate_cpp_exprgrammar.cpp @@ -0,0 +1,41 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Example: real_positions + + Explicit instantiation of the cpp_expression_grammar parsing function + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <boost/wave/wave_config.hpp> + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> + +#include "real_position_token.hpp" // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer type + +#include <boost/wave/grammars/cpp_expression_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the expression_grammar_gen template with the +// correct token type. This instantiates the corresponding parse function, +// which in turn instantiates the expression_grammar object (see +// wave/grammars/cpp_expression_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef lex_token<> token_type; + +template struct boost::wave::grammars::expression_grammar_gen<token_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/real_positions/instantiate_cpp_grammar.cpp b/src/boost/libs/wave/samples/real_positions/instantiate_cpp_grammar.cpp new file mode 100644 index 00000000..2b4436c8 --- /dev/null +++ b/src/boost/libs/wave/samples/real_positions/instantiate_cpp_grammar.cpp @@ -0,0 +1,45 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Example: real_positions + + Explicit instantiation of the cpp_grammar parsing function + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <boost/wave/wave_config.hpp> + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> +#include <list> + +#include <boost/wave/token_ids.hpp> + +#include "real_position_token.hpp" // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer type + +#include <boost/wave/grammars/cpp_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the cpp_grammar_gen template with the correct +// token type. This instantiates the corresponding pt_parse function, which +// in turn instantiates the cpp_grammar object +// (see wave/grammars/cpp_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef lex_token<> token_type; +typedef boost::wave::cpplexer::lex_iterator<token_type> lexer_type; +typedef std::list<token_type, boost::fast_pool_allocator<token_type> > + token_sequence_type; + +template struct boost::wave::grammars::cpp_grammar_gen<lexer_type, token_sequence_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/real_positions/instantiate_cpp_literalgrs.cpp b/src/boost/libs/wave/samples/real_positions/instantiate_cpp_literalgrs.cpp new file mode 100644 index 00000000..422a3197 --- /dev/null +++ b/src/boost/libs/wave/samples/real_positions/instantiate_cpp_literalgrs.cpp @@ -0,0 +1,46 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Example: real_positions + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <boost/wave/wave_config.hpp> + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> + +#include "real_position_token.hpp" // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer type + +#include <boost/wave/grammars/cpp_literal_grammar_gen.hpp> +#include <boost/wave/grammars/cpp_intlit_grammar.hpp> +#include <boost/wave/grammars/cpp_chlit_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the intlit_grammar_gen, chlit_grammar_gen and +// floatlit_grammar_gen templates with the correct token type. This +// instantiates the corresponding parse function, which in turn instantiates +// the corresponding parser object. +// +/////////////////////////////////////////////////////////////////////////////// + +typedef lex_token<> token_type; + +template struct boost::wave::grammars::intlit_grammar_gen<token_type>; +#if BOOST_WAVE_WCHAR_T_SIGNEDNESS == BOOST_WAVE_WCHAR_T_AUTOSELECT || \ + BOOST_WAVE_WCHAR_T_SIGNEDNESS == BOOST_WAVE_WCHAR_T_FORCE_SIGNED +template struct boost::wave::grammars::chlit_grammar_gen<int, token_type>; +#endif +template struct boost::wave::grammars::chlit_grammar_gen<unsigned int, token_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/real_positions/instantiate_defined_grammar.cpp b/src/boost/libs/wave/samples/real_positions/instantiate_defined_grammar.cpp new file mode 100644 index 00000000..2f6bd50d --- /dev/null +++ b/src/boost/libs/wave/samples/real_positions/instantiate_defined_grammar.cpp @@ -0,0 +1,39 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Example: real_positions + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <boost/wave/wave_config.hpp> + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> + +#include "real_position_token.hpp" // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer type + +#include <boost/wave/grammars/cpp_defined_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the defined_grammar_gen template +// with the correct token type. This instantiates the corresponding parse +// function, which in turn instantiates the defined_grammar +// object (see wave/grammars/cpp_defined_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::cpplexer::lex_iterator<lex_token<> > lexer_type; + +template struct boost::wave::grammars::defined_grammar_gen<lexer_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/real_positions/instantiate_re2c_lexer.cpp b/src/boost/libs/wave/samples/real_positions/instantiate_re2c_lexer.cpp new file mode 100644 index 00000000..f1de6b1b --- /dev/null +++ b/src/boost/libs/wave/samples/real_positions/instantiate_re2c_lexer.cpp @@ -0,0 +1,62 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Explicit instantiation of the lex_functor generation function + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <boost/wave/wave_config.hpp> // configuration data + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> + +#include "real_position_token.hpp" // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer type + +/////////////////////////////////////////////////////////////////////////////// +// The following file needs to be included only once throughout the whole +// program. +#include <boost/wave/cpplexer/re2clex/cpp_re2c_lexer.hpp> + +// this must occur after all of the includes and before any code appears +#ifdef BOOST_HAS_ABI_HEADERS +#include BOOST_ABI_PREFIX +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// This instantiates the correct 'new_lexer' function, which generates the +// C++ lexer used in this sample. You will have to instantiate the +// new_lexer_gen<> template with the same iterator type, as you have used for +// instantiating the boost::wave::context<> object. +// +// This is moved into a separate compilation unit to decouple the compilation +// of the C++ lexer from the compilation of the other modules, which helps to +// reduce compilation time. +// +// The template parameter(s) supplied should be identical to the first +// parameter supplied while instantiating the boost::wave::context<> template +// (see the file cpp.cpp). +// +/////////////////////////////////////////////////////////////////////////////// + +template struct boost::wave::cpplexer::new_lexer_gen< + BOOST_WAVE_STRINGTYPE::iterator, boost::wave::util::file_position_type, + lex_token<boost::wave::util::file_position_type> >; +template struct boost::wave::cpplexer::new_lexer_gen< + BOOST_WAVE_STRINGTYPE::const_iterator, boost::wave::util::file_position_type, + lex_token<boost::wave::util::file_position_type> >; + +// the suffix header occurs after all of the code +#ifdef BOOST_HAS_ABI_HEADERS +#include BOOST_ABI_SUFFIX +#endif + +#endif // BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 diff --git a/src/boost/libs/wave/samples/real_positions/instantiate_re2c_lexer_str.cpp b/src/boost/libs/wave/samples/real_positions/instantiate_re2c_lexer_str.cpp new file mode 100644 index 00000000..e2affaf5 --- /dev/null +++ b/src/boost/libs/wave/samples/real_positions/instantiate_re2c_lexer_str.cpp @@ -0,0 +1,61 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Explicit instantiation of the lex_functor generation function + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#define BOOST_WAVE_SOURCE 1 +#include <boost/wave/wave_config.hpp> // configuration data + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> + +#include "real_position_token.hpp" // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// The following file needs to be included only once throughout the whole +// program. +#include <boost/wave/cpplexer/re2clex/cpp_re2c_lexer.hpp> + +// this must occur after all of the includes and before any code appears +#ifdef BOOST_HAS_ABI_HEADERS +#include BOOST_ABI_PREFIX +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// If you've used another iterator type than std::string::iterator, you have to +// instantiate the new_lexer_gen<> template for this iterator type too. +// The reason is, that the library internally uses the new_lexer_gen<> +// template with a std::string::iterator. +// +// This is moved into a separate compilation unit to decouple the compilation +// of the C++ lexer from the compilation of the other modules, which helps to +// reduce compilation time. +// +// The template parameter(s) supplied should be identical to the first +// parameter supplied while instantiating the boost::wave::context<> template +// (see the file cpp.cpp). +// +/////////////////////////////////////////////////////////////////////////////// + +#if !defined(BOOST_WAVE_STRINGTYPE_USE_STDSTRING) +template struct boost::wave::cpplexer::new_lexer_gen<std::string::iterator>; +template struct boost::wave::cpplexer::new_lexer_gen<std::string::const_iterator>; +#endif + +// the suffix header occurs after all of the code +#ifdef BOOST_HAS_ABI_HEADERS +#include BOOST_ABI_SUFFIX +#endif + +#endif // BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 diff --git a/src/boost/libs/wave/samples/real_positions/real_position_token.hpp b/src/boost/libs/wave/samples/real_positions/real_position_token.hpp new file mode 100644 index 00000000..dc4c25b8 --- /dev/null +++ b/src/boost/libs/wave/samples/real_positions/real_position_token.hpp @@ -0,0 +1,210 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + A C++ lexer token definition for the real_positions example + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(REAL_POSITION_TOKEN_HPP_HK_061109_INCLUDED) +#define REAL_POSITION_TOKEN_HPP_HK_061109_INCLUDED + +#include <boost/wave/wave_config.hpp> +#include <boost/wave/util/file_position.hpp> +#include <boost/wave/token_ids.hpp> +#include <boost/wave/language_support.hpp> +#include <boost/detail/atomic_count.hpp> + +/////////////////////////////////////////////////////////////////////////////// +namespace impl { + +template <typename StringTypeT, typename PositionT> +class token_data +{ +public: + typedef StringTypeT string_type; + typedef PositionT position_type; + + token_data() + : id(boost::wave::T_EOI), refcnt(1) + {} + + // construct an invalid token + explicit token_data(int) + : id(T_UNKNOWN), refcnt(1) + {} + + token_data(boost::wave::token_id id_, string_type const &value_, + position_type const &pos_) + : id(id_), value(value_), pos(pos_), corrected_pos(pos_), refcnt(1) + {} + + token_data(token_data const& rhs) + : id(rhs.id), value(rhs.value), pos(rhs.pos), + corrected_pos(rhs.corrected_pos), refcnt(1) + {} + + ~token_data() + {} + + std::size_t addref() { return ++refcnt; } + std::size_t release() { return --refcnt; } + std::size_t get_refcnt() const { return refcnt; } + +// accessors + operator boost::wave::token_id() const { return id; } + string_type const &get_value() const { return value; } + position_type const &get_position() const { return pos; } + position_type const &get_corrected_position() const + { return corrected_pos; } + bool is_eoi() const { id == T_EOI; } + + void set_token_id (boost::wave::token_id id_) { id = id_; } + void set_value (string_type const &value_) { value = value_; } + void set_position (position_type const &pos_) { pos = pos_; } + void set_corrected_position (position_type const &pos_) + { corrected_pos = pos_; } + + friend bool operator== (token_data const& lhs, token_data const& rhs) + { + // two tokens are considered equal even if they refer to different + // positions + return (lhs.id == rhs.id && lhs.value == rhs.value) ? true : false; + } + +private: + boost::wave::token_id id; // the token id + string_type value; // the text, which was parsed into this token + position_type pos; // the original file position + position_type corrected_pos; // the original file position + boost::detail::atomic_count refcnt; +}; + +/////////////////////////////////////////////////////////////////////////////// +} // namespace impl + +/////////////////////////////////////////////////////////////////////////////// +// forward declaration of the token type +template <typename PositionT = boost::wave::util::file_position_type> +class lex_token; + +/////////////////////////////////////////////////////////////////////////////// +// +// lex_token +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename PositionT> +class lex_token +{ +public: + typedef BOOST_WAVE_STRINGTYPE string_type; + typedef PositionT position_type; + + lex_token() + : data(new impl::token_data<string_type, position_type>()) + {} + + // construct an invalid token + explicit lex_token(int) + : data(new data_type(0)) + {} + + lex_token(lex_token const& rhs) + : data(rhs.data) + { + data->addref(); + } + + lex_token(boost::wave::token_id id_, string_type const &value_, + PositionT const &pos_) + : data(new impl::token_data<string_type, position_type>(id_, value_, pos_)) + {} + + ~lex_token() + { + if (0 == data->release()) + delete data; + data = 0; + } + + lex_token& operator=(lex_token const& rhs) + { + if (&rhs != this) { + if (0 == data->release()) + delete data; + + data = rhs.data; + data->addref(); + } + return *this; + } + +// accessors + operator boost::wave::token_id() const + { return boost::wave::token_id(*data); } + string_type const &get_value() const + { return data->get_value(); } + position_type const &get_position() const + { return data->get_position(); } + position_type const &get_corrected_position() const + { return data->get_corrected_position(); } + bool is_valid() const { return 0 != data && token_id(*data) != T_UNKNOWN; } + + void set_token_id (boost::wave::token_id id_) + { make_unique(); data->set_token_id(id_); } + void set_value (string_type const &value_) + { make_unique(); data->set_value(value_); } + void set_position (position_type const &pos_) + { make_unique(); data->set_position(pos_); } + void set_corrected_position (position_type const &pos_) + { make_unique(); data->set_corrected_position(pos_); } + + friend bool operator== (lex_token const& lhs, lex_token const& rhs) + { + return *(lhs.data) == *(rhs.data); + } + +// debug support +#if BOOST_WAVE_DUMP_PARSE_TREE != 0 +// access functions for the tree_to_xml functionality + static int get_token_id(lex_token const &t) + { return token_id(t); } + static string_type get_token_value(lex_token const &t) + { return t.get_value(); } +#endif + +private: + // make a unique copy of the current object + void make_unique() + { + if (1 == data->get_refcnt()) + return; + + impl::token_data<string_type, position_type> *newdata = + new impl::token_data<string_type, position_type>(*data); + + data->release(); // release this reference, can't get zero + data = newdata; + } + + impl::token_data<string_type, position_type> *data; +}; + +/////////////////////////////////////////////////////////////////////////////// +// This overload is needed by the multi_pass/functor_input_policy to +// validate a token instance. It has to be defined in the same namespace +// as the token class itself to allow ADL to find it. +/////////////////////////////////////////////////////////////////////////////// +template <typename Position> +inline bool +token_is_valid(lex_token<Position> const& t) +{ + return t.is_valid(); +} + +#endif // !defined(REAL_POSITION_TOKEN_HPP_HK_061109_INCLUDED) diff --git a/src/boost/libs/wave/samples/real_positions/real_positions.cpp b/src/boost/libs/wave/samples/real_positions/real_positions.cpp new file mode 100644 index 00000000..3039af3c --- /dev/null +++ b/src/boost/libs/wave/samples/real_positions/real_positions.cpp @@ -0,0 +1,183 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample showing how to correct the positions inside the returned tokens in + a way that these appear to be consecutive (ignoring positions from macro + definitions). + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <iostream> +#include <fstream> +#include <iomanip> +#include <string> +#include <vector> + +/////////////////////////////////////////////////////////////////////////////// +// Include Wave itself +#include <boost/wave.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include the lexer stuff +#include "real_position_token.hpp" // token class +#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer type + +#include "correct_token_positions.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// +// Special output operator for a lex_token. +// +// Note: this doesn't compile if BOOST_SPIRIT_DEBUG is defined. +// +/////////////////////////////////////////////////////////////////////////////// +template <typename PositionT> +inline std::ostream & +operator<< (std::ostream &stream, lex_token<PositionT> const &t) +{ + using namespace std; + using namespace boost::wave; + + token_id id = token_id(t); + stream << setw(16) + << left << boost::wave::get_token_name(id) << " (" + << "#" << setw(3) << BASEID_FROM_TOKEN(id); + + if (ExtTokenTypeMask & id) { + // this is an extended token id + if (AltTokenType == (id & ExtTokenOnlyMask)) { + stream << ", AltTokenType"; + } + else if (TriGraphTokenType == (id & ExtTokenOnlyMask)) { + stream << ", TriGraphTokenType"; + } + else if (AltExtTokenType == (id & ExtTokenOnlyMask)){ + stream << ", AltExtTokenType"; + } + } + + stream << "): >"; + + typedef typename lex_token<PositionT>::string_type string_type; + + string_type const& value = t.get_value(); + for (std::size_t i = 0; i < value.size(); ++i) { + switch (value[i]) { + case '\r': stream << "\\r"; break; + case '\n': stream << "\\n"; break; + case '\t': stream << "\\t"; break; + default: + stream << value[i]; + break; + } + } + stream << "<" << std::endl; + stream << " at: " << t.get_position().get_file() << " (" + << setw(3) << right << t.get_position().get_line() << "/" + << setw(2) << right << t.get_position().get_column() + << ")" << std::endl; + stream << " and: " << t.get_corrected_position().get_file() << " (" + << setw(3) << right << t.get_corrected_position().get_line() << "/" + << setw(2) << right << t.get_corrected_position().get_column() + << ")"; + + return stream; +} + +/////////////////////////////////////////////////////////////////////////////// +// main entry point +int main(int argc, char *argv[]) +{ + if (2 != argc) { + std::cerr << "Usage: real_positions infile" << std::endl; + return -1; + } + +// current file position is saved for exception handling +boost::wave::util::file_position_type current_position; + + try { + // Open and read in the specified input file. + std::ifstream instream(argv[1]); + std::string instring; + + if (!instream.is_open()) { + std::cerr << "Could not open input file: " << argv[1] << std::endl; + return -2; + } + instream.unsetf(std::ios::skipws); + instring = std::string(std::istreambuf_iterator<char>(instream.rdbuf()), + std::istreambuf_iterator<char>()); + + // The template real_positions::lex_token<> is the token type to be + // used by the Wave library. + typedef lex_token<> token_type; + + // The template boost::wave::cpplexer::lex_iterator<> is the lexer type to + // be used by the Wave library. + typedef boost::wave::cpplexer::lex_iterator<token_type> + lex_iterator_type; + + // This is the resulting context type to use. The first template parameter + // should match the iterator type to be used during construction of the + // corresponding context object (see below). + typedef boost::wave::context< + std::string::iterator, lex_iterator_type, + boost::wave::iteration_context_policies::load_file_to_string, + correct_token_position<token_type> > + context_type; + + // This preprocessor hooks are used to correct the file positions inside + // the tokens returned from the library + correct_token_position<token_type> hooks(argv[1]); + + // The preprocessor iterator shouldn't be constructed directly. It is + // to be generated through a wave::context<> object. This wave:context<> + // object is to be used additionally to initialize and define different + // parameters of the actual preprocessing (not done here). + // + // The preprocessing of the input stream is done on the fly behind the + // scenes during iteration over the context_type::iterator_type stream. + context_type ctx (instring.begin(), instring.end(), argv[1], hooks); + + // analyze the input file + context_type::iterator_type first = ctx.begin(); + context_type::iterator_type last = ctx.end(); + + while (first != last) { + current_position = (*first).get_position(); + std::cout << *first << std::endl; + ++first; + } + } + catch (boost::wave::cpp_exception const& e) { + // some preprocessing error + std::cerr + << e.file_name() << "(" << e.line_no() << "): " + << e.description() << std::endl; + return 2; + } + catch (std::exception const& e) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "exception caught: " << e.what() + << std::endl; + return 3; + } + catch (...) { + // use last recognized token to retrieve the error position + std::cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "unexpected exception caught." << std::endl; + return 4; + } + return 0; +} diff --git a/src/boost/libs/wave/samples/token_statistics/build/Jamfile.v2 b/src/boost/libs/wave/samples/token_statistics/build/Jamfile.v2 new file mode 100644 index 00000000..8bf6d975 --- /dev/null +++ b/src/boost/libs/wave/samples/token_statistics/build/Jamfile.v2 @@ -0,0 +1,36 @@ +# Boost.Wave: A Standard compliant C++ preprocessor library +# +# Boost Wave Library Sample Build Jamfile (token_statistics) +# +# http://www.boost.org/ +# +# Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost +# Software License, Version 1.0. (See accompanying file +# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +SOURCES = + ../token_statistics + ../instantiate_xlex_lexer + ../instantiate_cpp_grammar + ../instantiate_defined_grammar + ; + +exe token_statistics + : + $(SOURCES) + /boost/wave//boost_wave + /boost/program_options//boost_program_options + /boost/filesystem//boost_filesystem + /boost/system//boost_system + /boost/thread//boost_thread + /boost/date_time//boost_date_time + ; + +for local source in $(SOURCES) +{ + local requirements ; + requirements += <toolset-msvc:version>7.1:<rtti>off ; # workaround for compiler bug + requirements += <toolset-msvc:version>7.1_stlport4:<rtti>off ; + obj $(source) : $(source).cpp : $(requirements) ; +} + diff --git a/src/boost/libs/wave/samples/token_statistics/collect_token_statistics.hpp b/src/boost/libs/wave/samples/token_statistics/collect_token_statistics.hpp new file mode 100644 index 00000000..815cf0e3 --- /dev/null +++ b/src/boost/libs/wave/samples/token_statistics/collect_token_statistics.hpp @@ -0,0 +1,71 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: Collect token statistics from the analysed files + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(COLLECT_TOKEN_STATISTICS_VERSION_HPP) +#define COLLECT_TOKEN_STATISTICS_VERSION_HPP + +#include <algorithm> +#include <map> + +#include <boost/assert.hpp> +#include <boost/wave/token_ids.hpp> + +/////////////////////////////////////////////////////////////////////////////// +class collect_token_statistics +{ + enum { + count = boost::wave::T_LAST_TOKEN - boost::wave::T_FIRST_TOKEN + }; + +public: + collect_token_statistics() + { + std::fill(&token_count[0], &token_count[count], 0); + } + + // account for the given token type + template <typename Token> + void operator() (Token const& token) + { + using boost::wave::token_id; + + int id = token_id(token) - boost::wave::T_FIRST_TOKEN; + BOOST_ASSERT(id < count); + ++token_count[id]; + } + + // print out the token statistics in descending order + void print() const + { + using namespace boost::wave; + typedef std::multimap<int, token_id> ids_type; + + ids_type ids; + for (unsigned int i = 0; i < count; ++i) + { + ids.insert(ids_type::value_type( + token_count[i], token_id(i + T_FIRST_TOKEN))); + } + + ids_type::reverse_iterator rend = ids.rend(); + for(ids_type::reverse_iterator rit = ids.rbegin(); rit != rend; ++rit) + { + std::cout << boost::wave::get_token_name((*rit).second) << ": " + << (*rit).first << std::endl; + } + } + +private: + int token_count[count]; +}; + +#endif // !defined(COLLECT_TOKEN_STATISTICS_VERSION_HPP) diff --git a/src/boost/libs/wave/samples/token_statistics/instantiate_cpp_grammar.cpp b/src/boost/libs/wave/samples/token_statistics/instantiate_cpp_grammar.cpp new file mode 100644 index 00000000..14cabab6 --- /dev/null +++ b/src/boost/libs/wave/samples/token_statistics/instantiate_cpp_grammar.cpp @@ -0,0 +1,45 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: Collect token statistics + Explicit instantiation of the cpp_grammar template + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "token_statistics.hpp" + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> +#include <list> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/cpp_lex_token.hpp> + +#include "xlex_iterator.hpp" + +#include <boost/wave/grammars/cpp_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the cpp_grammar_gen template with the correct +// token type. This instantiates the corresponding pt_parse function, which +// in turn instantiates the cpp_grammar object +// (see wave/grammars/cpp_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::cpplexer::lex_token<> token_type; +typedef boost::wave::cpplexer::xlex::xlex_iterator<token_type> lexer_type; +typedef std::list<token_type, boost::fast_pool_allocator<token_type> > + token_sequence_type; + +template struct boost::wave::grammars::cpp_grammar_gen<lexer_type, token_sequence_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/token_statistics/instantiate_defined_grammar.cpp b/src/boost/libs/wave/samples/token_statistics/instantiate_defined_grammar.cpp new file mode 100644 index 00000000..c54b9f9e --- /dev/null +++ b/src/boost/libs/wave/samples/token_statistics/instantiate_defined_grammar.cpp @@ -0,0 +1,42 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: Collect token statistics + Explicit instantiation of the defined_grammar template + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "token_statistics.hpp" + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/cpp_lex_token.hpp> + +#include "xlex_iterator.hpp" + +#include <boost/wave/grammars/cpp_defined_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the defined_grammar_gen template +// with the correct token type. This instantiates the corresponding parse +// function, which in turn instantiates the defined_grammar +// object (see wave/grammars/cpp_defined_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::cpplexer::xlex::xlex_iterator< + boost::wave::cpplexer::lex_token<> > + lexer_type; +template struct boost::wave::grammars::defined_grammar_gen<lexer_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/token_statistics/instantiate_xlex_lexer.cpp b/src/boost/libs/wave/samples/token_statistics/instantiate_xlex_lexer.cpp new file mode 100644 index 00000000..a217feac --- /dev/null +++ b/src/boost/libs/wave/samples/token_statistics/instantiate_xlex_lexer.cpp @@ -0,0 +1,45 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: Explicit instantiation of the xlex_functor generation function + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <boost/wave.hpp> + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> + +#include <boost/wave/cpplexer/cpp_lex_token.hpp> +#include "xlex_iterator.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// The following file needs to be included only once throughout the whole +// program. +#include "xlex/xlex_lexer.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// +// This instantiates the correct 'new_lexer' function, which generates the +// C++ lexer used in this sample. +// +// This is moved into a separate compilation unit to decouple the compilation +// of the C++ lexer from the compilation of the other modules, which helps to +// reduce compilation time. +// +// The template parameter(s) supplied should be identical to the parameters +// supplied while instantiating the context<> template. +// +/////////////////////////////////////////////////////////////////////////////// + +template struct boost::wave::cpplexer::xlex::new_lexer_gen<std::string::iterator>; + +#endif // BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 diff --git a/src/boost/libs/wave/samples/token_statistics/token_statistics.cpp b/src/boost/libs/wave/samples/token_statistics/token_statistics.cpp new file mode 100644 index 00000000..dc2ecdd3 --- /dev/null +++ b/src/boost/libs/wave/samples/token_statistics/token_statistics.cpp @@ -0,0 +1,259 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "token_statistics.hpp" // config data + +/////////////////////////////////////////////////////////////////////////////// +// include required boost libraries +#include <boost/assert.hpp> +#include <boost/program_options.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include Wave itself +#include <boost/wave.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include the lexer stuff +#include <boost/wave/cpplexer/cpp_lex_token.hpp> // token class +#include "xlex_iterator.hpp" // lexer class + +#include "collect_token_statistics.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// import required names +using namespace boost::spirit::classic; + +using std::string; +using std::vector; +using std::cout; +using std::cerr; +using std::endl; +using std::ifstream; +using std::ostream; +using std::istreambuf_iterator; + +namespace po = boost::program_options; + +/////////////////////////////////////////////////////////////////////////////// +namespace cmd_line_util { + + // predicate to extract all positional arguments from the command line + struct is_argument { + + bool operator()(po::option const &opt) + { + return (opt.position_key == -1) ? true : false; + } + }; + +/////////////////////////////////////////////////////////////////////////////// +} + +/////////////////////////////////////////////////////////////////////////////// +// print the current version + +int print_version() +{ +// get time of last compilation of this file +boost::wave::util::time_conversion_helper compilation_time(__DATE__ " " __TIME__); + +// calculate the number of days since May 9 2005 +// (the day the token_statistics project was started) +std::tm first_day; + + std::memset (&first_day, 0, sizeof(std::tm)); + first_day.tm_mon = 4; // May + first_day.tm_mday = 9; // 09 + first_day.tm_year = 105; // 2005 + +long seconds = long(std::difftime(compilation_time.get_time(), + std::mktime(&first_day))); + + cout + << TOKEN_STATISTICS_VERSION_MAJOR << '.' + << TOKEN_STATISTICS_VERSION_MINOR << '.' + << TOKEN_STATISTICS_VERSION_SUBMINOR << '.' + << seconds/(3600*24); // get number of days from seconds + return 1; // exit app +} + +/////////////////////////////////////////////////////////////////////////////// +// +int +do_actual_work(vector<string> const &arguments, po::variables_map const &vm) +{ +// current file position is saved for exception handling +boost::wave::util::file_position_type current_position; + + try { + // this object keeps track of all the statistics + collect_token_statistics stats; + + // collect the token statistics for all arguments given + vector<string>::const_iterator lastfile = arguments.end(); + for (vector<string>::const_iterator file_it = arguments.begin(); + file_it != lastfile; ++file_it) + { + ifstream instream((*file_it).c_str()); + string instring; + + if (!instream.is_open()) { + cerr << "token_statistics: could not open input file: " + << *file_it << endl; + continue; + } + instream.unsetf(std::ios::skipws); + instring = string(istreambuf_iterator<char>(instream.rdbuf()), + istreambuf_iterator<char>()); + + // The template boost::wave::cpplexer::lex_token<> is the token type to be + // used by the Wave library. + typedef boost::wave::cpplexer::xlex::xlex_iterator< + boost::wave::cpplexer::lex_token<> > + lexer_type; + typedef boost::wave::context< + std::string::iterator, lexer_type + > context_type; + + // The preprocessor iterator shouldn't be constructed directly. It is + // to be generated through a wave::context<> object. This wave:context<> + // object is additionally to be used to initialize and define different + // parameters of the actual preprocessing. + // The preprocessing of the input stream is done on the fly behind the + // scenes during iteration over the context_type::iterator_type stream. + context_type ctx (instring.begin(), instring.end(), (*file_it).c_str()); + + // add include directories to the include path + if (vm.count("include")) { + vector<string> const &paths = + vm["include"].as<vector<string> >(); + vector<string>::const_iterator end = paths.end(); + for (vector<string>::const_iterator cit = paths.begin(); + cit != end; ++cit) + { + ctx.add_include_path((*cit).c_str()); + } + } + + // add system include directories to the include path + if (vm.count("sysinclude")) { + vector<string> const &syspaths = + vm["sysinclude"].as<vector<string> >(); + vector<string>::const_iterator end = syspaths.end(); + for (vector<string>::const_iterator cit = syspaths.begin(); + cit != end; ++cit) + { + ctx.add_sysinclude_path((*cit).c_str()); + } + } + + // analyze the actual file + context_type::iterator_type first = ctx.begin(); + context_type::iterator_type last = ctx.end(); + + while (first != last) { + current_position = (*first).get_position(); + stats(*first); + ++first; + } + } + + // print out the collected statistics + stats.print(); + } + catch (boost::wave::cpp_exception const& e) { + // some preprocessing error + cerr + << e.file_name() << "(" << e.line_no() << "): " + << e.description() << endl; + return 2; + } + catch (std::exception const& e) { + // use last recognized token to retrieve the error position + cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "exception caught: " << e.what() + << endl; + return 3; + } + catch (...) { + // use last recognized token to retrieve the error position + cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "unexpected exception caught." << endl; + return 4; + } + return 0; +} + +/////////////////////////////////////////////////////////////////////////////// +// here we go! +int +main (int argc, char *argv[]) +{ + try { + // analyze the command line options and arguments + vector<string> syspathes; + po::options_description desc("Usage: token_statistics [options] file ..."); + + desc.add_options() + ("help,h", "print out program usage (this message)") + ("version,v", "print the version number") + ("include,I", po::value<vector<string> >(), + "specify additional include directory") + ("sysinclude,S", po::value<vector<string> >(), + "specify additional system include directory") + ; + + using namespace boost::program_options::command_line_style; + + po::parsed_options opts = po::parse_command_line(argc, argv, desc, unix_style); + po::variables_map vm; + + po::store(opts, vm); + po::notify(vm); + + if (vm.count("help")) { + cout << desc << endl; + return 1; + } + + if (vm.count("version")) { + return print_version(); + } + + // extract the arguments from the parsed command line + vector<po::option> arguments; + + std::remove_copy_if(opts.options.begin(), opts.options.end(), + inserter(arguments, arguments.end()), cmd_line_util::is_argument()); + + // if there is no input file given, then exit + if (0 == arguments.size() || 0 == arguments[0].value.size()) { + cerr << "token_statistics: No input file given. " + << "Use --help to get a hint." << endl; + return 5; + } + + // iterate over all given input files + return do_actual_work(arguments[0].value , vm); + } + catch (std::exception const& e) { + cout << "token_statistics: exception caught: " << e.what() << endl; + return 6; + } + catch (...) { + cerr << "token_statistics: unexpected exception caught." << endl; + return 7; + } +} + diff --git a/src/boost/libs/wave/samples/token_statistics/token_statistics.hpp b/src/boost/libs/wave/samples/token_statistics/token_statistics.hpp new file mode 100644 index 00000000..bd84a6ad --- /dev/null +++ b/src/boost/libs/wave/samples/token_statistics/token_statistics.hpp @@ -0,0 +1,49 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: Collect token statistics from the analysed files + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(TOKEN_STATISTICS_HPP) +#define TOKEN_STATISTICS_HPP + +/////////////////////////////////////////////////////////////////////////////// +// include often used files from the stdlib +#include <iostream> +#include <fstream> +#include <string> +#include <vector> + +/////////////////////////////////////////////////////////////////////////////// +// include boost config +#include <boost/config.hpp> // global configuration information +#include <boost/assert.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// build version +#include "token_statistics_version.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// Now include the configuration stuff for the Wave library itself +#include <boost/wave/wave_config.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// MSVC specific #pragma's +#if defined(BOOST_MSVC) +#pragma warning (disable: 4355) // 'this' used in base member initializer list +#pragma warning (disable: 4800) // forcing value to bool 'true' or 'false' +#pragma inline_depth(255) +#pragma inline_recursion(on) +#endif // defined(BOOST_MSVC) + +/////////////////////////////////////////////////////////////////////////////// +// include required boost libraries +#include <boost/pool/pool_alloc.hpp> + +#endif // !defined(TOKEN_STATISTICS_HPP) diff --git a/src/boost/libs/wave/samples/token_statistics/token_statistics_version.hpp b/src/boost/libs/wave/samples/token_statistics/token_statistics_version.hpp new file mode 100644 index 00000000..5092a9e6 --- /dev/null +++ b/src/boost/libs/wave/samples/token_statistics/token_statistics_version.hpp @@ -0,0 +1,20 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: Collect token statistics from the analysed files + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(TOKEN_STATISTICS_VERSION_HPP) +#define TOKEN_STATISTICS_VERSION_HPP + +#define TOKEN_STATISTICS_VERSION_MAJOR 0 +#define TOKEN_STATISTICS_VERSION_MINOR 1 +#define TOKEN_STATISTICS_VERSION_SUBMINOR 0 + +#endif // !defined(TOKEN_STATISTICS_VERSION_HPP) diff --git a/src/boost/libs/wave/samples/token_statistics/xlex/xlex_lexer.hpp b/src/boost/libs/wave/samples/token_statistics/xlex/xlex_lexer.hpp new file mode 100644 index 00000000..c9e8c4cd --- /dev/null +++ b/src/boost/libs/wave/samples/token_statistics/xlex/xlex_lexer.hpp @@ -0,0 +1,588 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Xpressive based C++ lexer + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(XLEX_LEXER_HPP) +#define XLEX_LEXER_HPP + +#include <string> +#include <cstdio> +#include <cstdarg> +#if defined(BOOST_SPIRIT_DEBUG) +#include <iostream> +#endif // defined(BOOST_SPIRIT_DEBUG) + +#include <boost/concept_check.hpp> +#include <boost/assert.hpp> +#include <boost/spirit/include/classic_core.hpp> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/language_support.hpp> +#include <boost/wave/util/file_position.hpp> +#include <boost/wave/cpplexer/validate_universal_char.hpp> +#include <boost/wave/cpplexer/cpplexer_exceptions.hpp> +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 +#include <boost/wave/cpplexer/detect_include_guards.hpp> +#endif +#include <boost/wave/cpplexer/cpp_lex_interface.hpp> + +// reuse the default token type +#include "../xlex_iterator.hpp" + +// include the xpressive headers +#include "xpressive_lexer.hpp" + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace cpplexer { +namespace xlex { +namespace lexer { + +/////////////////////////////////////////////////////////////////////////////// +// +// encapsulation of the xpressive based C++ lexer +// +/////////////////////////////////////////////////////////////////////////////// + +template < + typename Iterator, + typename Position = boost::wave::util::file_position_type +> +class lexer +{ +public: + typedef char char_type; + typedef boost::wave::cpplexer::lex_token<Position> token_type; + typedef typename token_type::string_type string_type; + + lexer(Iterator const &first, Iterator const &last, + Position const &pos, boost::wave::language_support language); + ~lexer() {} + + token_type& get(token_type& t); + void set_position(Position const &pos) + { + // set position has to change the file name and line number only + filename = pos.get_file(); + line = pos.get_line(); + } + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + bool has_include_guards(std::string& guard_name) const + { return guards.detected(guard_name); } +#endif + +private: + typedef xpressive_lexer<Iterator, token_id> lexer_type; + typedef typename lexer_type::callback_type callback_type; + + lexer_type xlexer; + Iterator first; + Iterator last; + + string_type filename; + int line; + bool at_eof; + boost::wave::language_support language; + +// initialization data (regular expressions for the token definitions) + struct lexer_data { + token_id tokenid; // token data + char_type const *tokenregex; // associated token to match + callback_type tokencb; // associated callback function + }; + + static lexer_data const init_data[]; // common patterns + static lexer_data const init_data_cpp[]; // C++ only patterns + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + boost::wave::cpplexer::include_guards<token_type> guards; +#endif +}; + +/////////////////////////////////////////////////////////////////////////////// +// helper for initializing token data +#define TOKEN_DATA(id, regex) \ + { id, regex, 0 } + +#define TOKEN_DATA_EX(id, regex, callback) \ + { id, regex, callback } + +/////////////////////////////////////////////////////////////////////////////// +// data required for initialization of the lexer (token definitions) +#define OR "|" +#define Q(c) "\\" c +#define TRI(c) Q("?") Q("?") c + +// definition of some subtoken regexps to simplify the regex definitions +#define BLANK "[ \t]" +#define CCOMMENT Q("/") Q("*") ".*?" Q("*") Q("/") + +#define PPSPACE "(" BLANK OR CCOMMENT ")*" + +#define OCTALDIGIT "[0-7]" +#define DIGIT "[0-9]" +#define HEXDIGIT "[0-9a-fA-F]" +#define SIGN "[-+]?" +#define EXPONENT "(" "[eE]" SIGN "[0-9]+" ")" + +#define INTEGER "(" \ + "(0x|0X)" HEXDIGIT "+" OR \ + "0" OCTALDIGIT "*" OR \ + "[1-9]" DIGIT "*" \ + ")" + +#define INTEGER_SUFFIX "(" "[uU][lL]?|[lL][uU]?" ")" +#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0 +#define LONGINTEGER_SUFFIX "(" "[uU]" "(" "[lL][lL]" ")" OR \ + "(" "[lL][lL]" ")" "[uU]" "?" OR \ + "i64" \ + ")" +#else +#define LONGINTEGER_SUFFIX "(" "[uU]" "(" "[lL][lL]" ")" OR \ + "(" "[lL][lL]" ")" "[uU]" "?" ")" +#endif +#define FLOAT_SUFFIX "(" "[fF][lL]?|[lL][fF]?" ")" +#define CHAR_SPEC "L?" + +#define BACKSLASH "(" Q("\\") OR TRI(Q("/")) ")" +#define ESCAPESEQ BACKSLASH "(" \ + "[abfnrtv?'\"]" OR \ + BACKSLASH OR \ + "x" HEXDIGIT "+" OR \ + OCTALDIGIT OCTALDIGIT "?" OCTALDIGIT "?" \ + ")" +#define HEXQUAD HEXDIGIT HEXDIGIT HEXDIGIT HEXDIGIT +#define UNIVERSALCHAR BACKSLASH "(" \ + "u" HEXQUAD OR \ + "U" HEXQUAD HEXQUAD \ + ")" + +#define POUNDDEF "(" "#" OR TRI("=") OR Q("%:") ")" +#define NEWLINEDEF "(" "\n" OR "\r\n" OR "\r" ")" + +#if BOOST_WAVE_SUPPORT_INCLUDE_NEXT != 0 +#define INCLUDEDEF "(include_next|include)" +#else +#define INCLUDEDEF "include" +#endif + +/////////////////////////////////////////////////////////////////////////////// +// common C++/C99 token definitions +template <typename Iterator, typename Position> +typename lexer<Iterator, Position>::lexer_data const +lexer<Iterator, Position>::init_data[] = +{ + TOKEN_DATA(T_CCOMMENT, CCOMMENT), + TOKEN_DATA(T_CPPCOMMENT, Q("/") Q("/.*?") NEWLINEDEF ), + TOKEN_DATA(T_CHARLIT, CHAR_SPEC "'" + "(" ESCAPESEQ OR "[^\n\r']" OR UNIVERSALCHAR ")+" "'"), + TOKEN_DATA(T_STRINGLIT, CHAR_SPEC Q("\"") + "(" ESCAPESEQ OR "[^\n\r\"]" OR UNIVERSALCHAR ")*" Q("\"")), + TOKEN_DATA(T_ANDAND, "&&"), + TOKEN_DATA(T_ANDASSIGN, "&="), + TOKEN_DATA(T_AND, "&"), + TOKEN_DATA(T_EQUAL, "=="), + TOKEN_DATA(T_ASSIGN, "="), + TOKEN_DATA(T_ORASSIGN, Q("|=")), + TOKEN_DATA(T_ORASSIGN_TRIGRAPH, TRI("!=")), + TOKEN_DATA(T_OROR, Q("|") Q("|")), + TOKEN_DATA(T_OROR_TRIGRAPH, TRI("!") Q("|") OR Q("|") TRI("!") OR TRI("!") TRI("!")), + TOKEN_DATA(T_OR, Q("|")), + TOKEN_DATA(T_OR_TRIGRAPH, TRI("!")), + TOKEN_DATA(T_XORASSIGN, Q("^=")), + TOKEN_DATA(T_XORASSIGN_TRIGRAPH, TRI("'=")), + TOKEN_DATA(T_XOR, Q("^")), + TOKEN_DATA(T_XOR_TRIGRAPH, TRI("'")), + TOKEN_DATA(T_COMMA, ","), + TOKEN_DATA(T_RIGHTBRACKET_ALT, ":>"), + TOKEN_DATA(T_COLON, ":"), + TOKEN_DATA(T_DIVIDEASSIGN, Q("/=")), + TOKEN_DATA(T_DIVIDE, Q("/")), + TOKEN_DATA(T_ELLIPSIS, Q(".") Q(".") Q(".")), + TOKEN_DATA(T_SHIFTRIGHTASSIGN, ">>="), + TOKEN_DATA(T_SHIFTRIGHT, ">>"), + TOKEN_DATA(T_GREATEREQUAL, ">="), + TOKEN_DATA(T_GREATER, ">"), + TOKEN_DATA(T_LEFTBRACE, Q("{")), + TOKEN_DATA(T_SHIFTLEFTASSIGN, "<<="), + TOKEN_DATA(T_SHIFTLEFT, "<<"), + TOKEN_DATA(T_LEFTBRACE_ALT, "<" Q("%")), + TOKEN_DATA(T_LESSEQUAL, "<="), + TOKEN_DATA(T_LEFTBRACKET_ALT, "<:"), + TOKEN_DATA(T_LESS, "<"), + TOKEN_DATA(T_LEFTBRACE_TRIGRAPH, TRI("<")), + TOKEN_DATA(T_LEFTPAREN, Q("(")), + TOKEN_DATA(T_LEFTBRACKET, Q("[")), + TOKEN_DATA(T_LEFTBRACKET_TRIGRAPH, TRI(Q("("))), + TOKEN_DATA(T_MINUSMINUS, Q("-") Q("-")), + TOKEN_DATA(T_MINUSASSIGN, Q("-=")), + TOKEN_DATA(T_ARROW, Q("->")), + TOKEN_DATA(T_MINUS, Q("-")), + TOKEN_DATA(T_POUND_POUND_ALT, Q("%:") Q("%:")), + TOKEN_DATA(T_PERCENTASSIGN, Q("%=")), + TOKEN_DATA(T_RIGHTBRACE_ALT, Q("%>")), + TOKEN_DATA(T_POUND_ALT, Q("%:")), + TOKEN_DATA(T_PERCENT, Q("%")), + TOKEN_DATA(T_NOTEQUAL, "!="), + TOKEN_DATA(T_NOT, "!"), + TOKEN_DATA(T_PLUSASSIGN, Q("+=")), + TOKEN_DATA(T_PLUSPLUS, Q("+") Q("+")), + TOKEN_DATA(T_PLUS, Q("+")), + TOKEN_DATA(T_RIGHTBRACE, Q("}")), + TOKEN_DATA(T_RIGHTBRACE_TRIGRAPH, TRI(">")), + TOKEN_DATA(T_RIGHTPAREN, Q(")")), + TOKEN_DATA(T_RIGHTBRACKET, Q("]")), + TOKEN_DATA(T_RIGHTBRACKET_TRIGRAPH, TRI(Q(")"))), + TOKEN_DATA(T_SEMICOLON, ";"), + TOKEN_DATA(T_STARASSIGN, Q("*=")), + TOKEN_DATA(T_STAR, Q("*")), + TOKEN_DATA(T_COMPL, Q("~")), + TOKEN_DATA(T_COMPL_TRIGRAPH, TRI("-")), + TOKEN_DATA(T_ASM, "asm"), + TOKEN_DATA(T_AUTO, "auto"), + TOKEN_DATA(T_BOOL, "bool"), + TOKEN_DATA(T_FALSE, "false"), + TOKEN_DATA(T_TRUE, "true"), + TOKEN_DATA(T_BREAK, "break"), + TOKEN_DATA(T_CASE, "case"), + TOKEN_DATA(T_CATCH, "catch"), + TOKEN_DATA(T_CHAR, "char"), + TOKEN_DATA(T_CLASS, "class"), + TOKEN_DATA(T_CONSTCAST, "const_cast"), + TOKEN_DATA(T_CONST, "const"), + TOKEN_DATA(T_CONTINUE, "continue"), + TOKEN_DATA(T_DEFAULT, "default"), + TOKEN_DATA(T_DELETE, "delete"), + TOKEN_DATA(T_DOUBLE, "double"), + TOKEN_DATA(T_DO, "do"), + TOKEN_DATA(T_DYNAMICCAST, "dynamic_cast"), + TOKEN_DATA(T_ELSE, "else"), + TOKEN_DATA(T_ENUM, "enum"), + TOKEN_DATA(T_EXPLICIT, "explicit"), + TOKEN_DATA(T_EXPORT, "export"), + TOKEN_DATA(T_EXTERN, "extern"), + TOKEN_DATA(T_FLOAT, "float"), + TOKEN_DATA(T_FOR, "for"), + TOKEN_DATA(T_FRIEND, "friend"), + TOKEN_DATA(T_GOTO, "goto"), + TOKEN_DATA(T_IF, "if"), + TOKEN_DATA(T_INLINE, "inline"), + TOKEN_DATA(T_INT, "int"), + TOKEN_DATA(T_LONG, "long"), + TOKEN_DATA(T_MUTABLE, "mutable"), + TOKEN_DATA(T_NAMESPACE, "namespace"), + TOKEN_DATA(T_NEW, "new"), + TOKEN_DATA(T_OPERATOR, "operator"), + TOKEN_DATA(T_PRIVATE, "private"), + TOKEN_DATA(T_PROTECTED, "protected"), + TOKEN_DATA(T_PUBLIC, "public"), + TOKEN_DATA(T_REGISTER, "register"), + TOKEN_DATA(T_REINTERPRETCAST, "reinterpret_cast"), + TOKEN_DATA(T_RETURN, "return"), + TOKEN_DATA(T_SHORT, "short"), + TOKEN_DATA(T_SIGNED, "signed"), + TOKEN_DATA(T_SIZEOF, "sizeof"), + TOKEN_DATA(T_STATICCAST, "static_cast"), + TOKEN_DATA(T_STATIC, "static"), + TOKEN_DATA(T_STRUCT, "struct"), + TOKEN_DATA(T_SWITCH, "switch"), + TOKEN_DATA(T_TEMPLATE, "template"), + TOKEN_DATA(T_THIS, "this"), + TOKEN_DATA(T_THROW, "throw"), + TOKEN_DATA(T_TRY, "try"), + TOKEN_DATA(T_TYPEDEF, "typedef"), + TOKEN_DATA(T_TYPEID, "typeid"), + TOKEN_DATA(T_TYPENAME, "typename"), + TOKEN_DATA(T_UNION, "union"), + TOKEN_DATA(T_UNSIGNED, "unsigned"), + TOKEN_DATA(T_USING, "using"), + TOKEN_DATA(T_VIRTUAL, "virtual"), + TOKEN_DATA(T_VOID, "void"), + TOKEN_DATA(T_VOLATILE, "volatile"), + TOKEN_DATA(T_WCHART, "wchar_t"), + TOKEN_DATA(T_WHILE, "while"), +#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0 + TOKEN_DATA(T_MSEXT_INT8, "__int8"), + TOKEN_DATA(T_MSEXT_INT16, "__int16"), + TOKEN_DATA(T_MSEXT_INT32, "__int32"), + TOKEN_DATA(T_MSEXT_INT64, "__int64"), + TOKEN_DATA(T_MSEXT_BASED, "_?" "_based"), + TOKEN_DATA(T_MSEXT_DECLSPEC, "_?" "_declspec"), + TOKEN_DATA(T_MSEXT_CDECL, "_?" "_cdecl"), + TOKEN_DATA(T_MSEXT_FASTCALL, "_?" "_fastcall"), + TOKEN_DATA(T_MSEXT_STDCALL, "_?" "_stdcall"), + TOKEN_DATA(T_MSEXT_TRY , "__try"), + TOKEN_DATA(T_MSEXT_EXCEPT, "__except"), + TOKEN_DATA(T_MSEXT_FINALLY, "__finally"), + TOKEN_DATA(T_MSEXT_LEAVE, "__leave"), + TOKEN_DATA(T_MSEXT_INLINE, "_?" "_inline"), + TOKEN_DATA(T_MSEXT_ASM, "_?" "_asm"), + TOKEN_DATA(T_MSEXT_PP_REGION, POUNDDEF PPSPACE "region"), + TOKEN_DATA(T_MSEXT_PP_ENDREGION, POUNDDEF PPSPACE "endregion"), +#endif // BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0 + TOKEN_DATA(T_PP_DEFINE, POUNDDEF PPSPACE "define"), + TOKEN_DATA(T_PP_IFDEF, POUNDDEF PPSPACE "ifdef"), + TOKEN_DATA(T_PP_IFNDEF, POUNDDEF PPSPACE "ifndef"), + TOKEN_DATA(T_PP_IF, POUNDDEF PPSPACE "if"), + TOKEN_DATA(T_PP_ELSE, POUNDDEF PPSPACE "else"), + TOKEN_DATA(T_PP_ELIF, POUNDDEF PPSPACE "elif"), + TOKEN_DATA(T_PP_ENDIF, POUNDDEF PPSPACE "endif"), + TOKEN_DATA(T_PP_ERROR, POUNDDEF PPSPACE "error"), + TOKEN_DATA(T_PP_QHEADER, POUNDDEF PPSPACE \ + INCLUDEDEF PPSPACE Q("\"") "[^\n\r\"]+" Q("\"")), + TOKEN_DATA(T_PP_HHEADER, POUNDDEF PPSPACE \ + INCLUDEDEF PPSPACE "<" "[^\n\r>]+" ">"), + TOKEN_DATA(T_PP_INCLUDE, POUNDDEF PPSPACE \ + INCLUDEDEF PPSPACE), + TOKEN_DATA(T_PP_LINE, POUNDDEF PPSPACE "line"), + TOKEN_DATA(T_PP_PRAGMA, POUNDDEF PPSPACE "pragma"), + TOKEN_DATA(T_PP_UNDEF, POUNDDEF PPSPACE "undef"), + TOKEN_DATA(T_PP_WARNING, POUNDDEF PPSPACE "warning"), + TOKEN_DATA(T_FLOATLIT, + "(" DIGIT "*" Q(".") DIGIT "+" OR DIGIT "+" Q(".") ")" + EXPONENT "?" FLOAT_SUFFIX "?" OR + DIGIT "+" EXPONENT FLOAT_SUFFIX "?"), + TOKEN_DATA(T_LONGINTLIT, INTEGER LONGINTEGER_SUFFIX), + TOKEN_DATA(T_INTLIT, INTEGER INTEGER_SUFFIX "?"), +#if BOOST_WAVE_USE_STRICT_LEXER != 0 + TOKEN_DATA(T_IDENTIFIER, "([a-zA-Z_]" OR UNIVERSALCHAR ")([a-zA-Z0-9_]" OR UNIVERSALCHAR ")*"), +#else + TOKEN_DATA(T_IDENTIFIER, "([a-zA-Z_$]" OR UNIVERSALCHAR ")([a-zA-Z0-9_$]" OR UNIVERSALCHAR ")*"), +#endif + TOKEN_DATA(T_SPACE, BLANK "+"), + TOKEN_DATA(T_SPACE2, "[\v\f]+"), + TOKEN_DATA(T_CONTLINE, Q("\\") "\n"), + TOKEN_DATA(T_NEWLINE, NEWLINEDEF), + TOKEN_DATA(T_POUND_POUND, "##"), + TOKEN_DATA(T_POUND_POUND_TRIGRAPH, TRI("=") TRI("=")), + TOKEN_DATA(T_POUND, "#"), + TOKEN_DATA(T_POUND_TRIGRAPH, TRI("=")), + TOKEN_DATA(T_ANY_TRIGRAPH, TRI(Q("/"))), + TOKEN_DATA(T_QUESTION_MARK, Q("?")), + TOKEN_DATA(T_DOT, Q(".")), + TOKEN_DATA(T_ANY, "."), + { token_id(0) } // this should be the last entry +}; + +/////////////////////////////////////////////////////////////////////////////// +// C++ only token definitions +template <typename Iterator, typename Position> +typename lexer<Iterator, Position>::lexer_data const +lexer<Iterator, Position>::init_data_cpp[] = +{ + TOKEN_DATA(T_AND_ALT, "bitand"), + TOKEN_DATA(T_ANDASSIGN_ALT, "and_eq"), + TOKEN_DATA(T_ANDAND_ALT, "and"), + TOKEN_DATA(T_OR_ALT, "bitor"), + TOKEN_DATA(T_ORASSIGN_ALT, "or_eq"), + TOKEN_DATA(T_OROR_ALT, "or"), + TOKEN_DATA(T_XORASSIGN_ALT, "xor_eq"), + TOKEN_DATA(T_XOR_ALT, "xor"), + TOKEN_DATA(T_NOTEQUAL_ALT, "not_eq"), + TOKEN_DATA(T_NOT_ALT, "not"), + TOKEN_DATA(T_COMPL_ALT, "compl"), + TOKEN_DATA(T_ARROWSTAR, Q("->") Q("*")), + TOKEN_DATA(T_DOTSTAR, Q(".") Q("*")), + TOKEN_DATA(T_COLON_COLON, "::"), + { token_id(0) } // this should be the last entry +}; + +/////////////////////////////////////////////////////////////////////////////// +// undefine macros, required for regular expression definitions +#undef INCLUDEDEF +#undef POUNDDEF +#undef CCOMMENT +#undef PPSPACE +#undef DIGIT +#undef OCTALDIGIT +#undef HEXDIGIT +#undef SIGN +#undef EXPONENT +#undef LONGINTEGER_SUFFIX +#undef INTEGER_SUFFIX +#undef INTEGER +#undef FLOAT_SUFFIX +#undef CHAR_SPEC +#undef BACKSLASH +#undef ESCAPESEQ +#undef HEXQUAD +#undef UNIVERSALCHAR + +#undef Q +#undef TRI +#undef OR + +#undef TOKEN_DATA +#undef TOKEN_DATA_EX + +/////////////////////////////////////////////////////////////////////////////// +// initialize cpp lexer +template <typename Iterator, typename Position> +inline +lexer<Iterator, Position>::lexer(Iterator const &first, + Iterator const &last, Position const &pos, + boost::wave::language_support language) +: first(first), last(last), + filename(pos.get_file()), line(0), at_eof(false), language(language) +{ +// if in C99 mode, some of the keywords/operators are not valid + if (!boost::wave::need_c99(language)) { + for (int j = 0; 0 != init_data_cpp[j].tokenid; ++j) { + xlexer.register_regex(init_data_cpp[j].tokenregex, + init_data_cpp[j].tokenid, init_data_cpp[j].tokencb); + } + } + +// tokens valid for C++ and C99 + for (int i = 0; 0 != init_data[i].tokenid; ++i) { + xlexer.register_regex(init_data[i].tokenregex, init_data[i].tokenid, + init_data[i].tokencb); + } +} + +/////////////////////////////////////////////////////////////////////////////// +// get the next token from the input stream +template <typename Iterator, typename Position> +inline boost::wave::cpplexer::lex_token<Position>& +lexer<Iterator, Position>::get(boost::wave::cpplexer::lex_token<Position>& t) +{ + using namespace boost::wave; // to import token ids to this scope + + if (at_eof) + return t = cpplexer::lex_token<Position>(); // return T_EOI + + std::string tokval; + token_id id = xlexer.next_token(first, last, tokval); + string_type value = tokval.c_str(); + + if ((token_id)(-1) == id) + id = T_EOF; // end of input reached + + if (T_IDENTIFIER == id) { + // test identifier characters for validity (throws if invalid chars found) + if (!boost::wave::need_no_character_validation(language)) { + cpplexer::impl::validate_identifier_name(value, line, -1, filename); + } + } + else if (T_STRINGLIT == id || T_CHARLIT == id) { + // test literal characters for validity (throws if invalid chars found) + if (!boost::wave::need_no_character_validation(language)) { + cpplexer::impl::validate_literal(value, line, -1, filename); + } + } + else if (T_EOF == id) { + // T_EOF is returned as a valid token, the next call will return T_EOI, + // i.e. the actual end of input + at_eof = true; + value.clear(); + } + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + cpplexer::lex_token<Position> tok(id, value, Position(filename, line, -1)); + return t = guards.detect_guard(tok); +#else + return t = cpplexer::lex_token<Position>(id, value, + Position(filename, line, -1)); +#endif +} + +/////////////////////////////////////////////////////////////////////////////// +// +// lex_functor +// +/////////////////////////////////////////////////////////////////////////////// +template < + typename Iterator, + typename Position = boost::wave::util::file_position_type +> +class xlex_functor +: public xlex_input_interface<typename lexer<Iterator, Position>::token_type> +{ +public: + + typedef typename lexer<Iterator, Position>::token_type token_type; + + xlex_functor(Iterator const &first, Iterator const &last, + Position const &pos, boost::wave::language_support language) + : lexer_(first, last, pos, language) + {} + virtual ~xlex_functor() {} + +// get the next token from the input stream + token_type& get(token_type& t) { return lexer_.get(t); } + void set_position(Position const &pos) { lexer_.set_position(pos); } + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + bool has_include_guards(std::string& guard_name) const + { return lexer_.has_include_guards(guard_name); } +#endif + +private: + lexer<Iterator, Position> lexer_; +}; + +} // namespace lexer + +/////////////////////////////////////////////////////////////////////////////// +// +// The new_lexer_gen<>::new_lexer function (declared in cpp_slex_token.hpp) +// should be defined inline, if the lex_functor shouldn't be instantiated +// separately from the lex_iterator. +// +// Separate (explicit) instantiation helps to reduce compilation time. +// +/////////////////////////////////////////////////////////////////////////////// + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 +#define BOOST_WAVE_XLEX_NEW_LEXER_INLINE +#else +#define BOOST_WAVE_XLEX_NEW_LEXER_INLINE inline +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// The 'new_lexer' function allows the opaque generation of a new lexer object. +// It is coupled to the iterator type to allow to decouple the lexer/iterator +// configurations at compile time. +// +// This function is declared inside the xlex_interface.hpp file, which is +// referenced by the source file calling the lexer and the source file, which +// instantiates the lex_functor. But it is defined here, so it will be +// instantiated only while compiling the source file, which instantiates the +// lex_functor. While the xlex_interface.hpp file may be included everywhere, +// this file (xlex_lexer.hpp) should be included only once. This allows +// to decouple the lexer interface from the lexer implementation and reduces +// compilation time. +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename Iterator, typename Position> +BOOST_WAVE_XLEX_NEW_LEXER_INLINE +lex_input_interface<boost::wave::cpplexer::lex_token<Position> > * +new_lexer_gen<Iterator, Position>::new_lexer(Iterator const &first, + Iterator const &last, Position const &pos, + wave::language_support language) +{ + return new lexer::xlex_functor<Iterator, Position>( + first, last, pos, language); +} + +#undef BOOST_WAVE_XLEX_NEW_LEXER_INLINE + +/////////////////////////////////////////////////////////////////////////////// +} // namespace xlex +} // namespace cpplexer +} // namespace wave +} // namespace boost + +#endif // !defined(XLEX_LEXER_HPP) diff --git a/src/boost/libs/wave/samples/token_statistics/xlex/xpressive_lexer.hpp b/src/boost/libs/wave/samples/token_statistics/xlex/xpressive_lexer.hpp new file mode 100644 index 00000000..e6d08453 --- /dev/null +++ b/src/boost/libs/wave/samples/token_statistics/xlex/xpressive_lexer.hpp @@ -0,0 +1,135 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Xpressive based generic lexer + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(XPRESSIVE_LEXER_HPP) +#define XPRESSIVE_LEXER_HPP + +#include <string> +#include <vector> +#include <utility> +#include <algorithm> + +#include <boost/detail/iterator.hpp> +#include <boost/xpressive/xpressive.hpp> + +namespace boost { +namespace wave { +namespace cpplexer { +namespace xlex { + +/////////////////////////////////////////////////////////////////////////////// +template < + typename Iterator = char const*, + typename Token = int, + typename Callback = bool (*)( + Iterator const&, Iterator&, Iterator const&, Token const&) +> +class xpressive_lexer +{ +private: + typedef typename boost::detail::iterator_traits<Iterator>::value_type + char_type; + typedef std::basic_string<char_type> string_type; + + // this represents a single token to match + struct regex_info + { + typedef boost::xpressive::basic_regex<Iterator> regex_type; + + string_type str; + Token token; + regex_type regex; + Callback callback; + + regex_info(string_type const& str, Token const& token, + Callback const& callback) + : str(str), token(token), + regex(regex_type::compile(str)), + callback(callback) + {} + + // these structures are to be ordered by the token id + friend bool operator< (regex_info const& lhs, regex_info const& rhs) + { + return lhs.token < rhs.token; + } + }; + + typedef std::vector<regex_info> regex_list_type; + +public: + typedef Callback callback_type; + + xpressive_lexer() {} + + // register a the regex with the lexer + void register_regex(string_type const& regex, Token const& id, + Callback const& cb = Callback()); + + // match the given input and return the next recognized token + Token next_token(Iterator &first, Iterator const& last, string_type& token); + +private: + regex_list_type regex_list; +}; + +/////////////////////////////////////////////////////////////////////////////// +template <typename Iterator, typename Token, typename Callback> +inline void +xpressive_lexer<Iterator, Token, Callback>::register_regex( + string_type const& regex, Token const& id, Callback const& cb) +{ + regex_list.push_back(regex_info(regex, id, cb)); +} + +/////////////////////////////////////////////////////////////////////////////// +template <typename Iterator, typename Token, typename Callback> +inline Token +xpressive_lexer<Iterator, Token, Callback>::next_token( + Iterator &first, Iterator const& last, string_type& token) +{ + typedef typename regex_list_type::iterator iterator; + + xpressive::match_results<Iterator> regex_result; + for (iterator it = regex_list.begin(), end = regex_list.end(); it != end; ++it) + { + namespace xpressive = boost::xpressive; + +// regex_info const& curr_regex = *it; +// xpressive::match_results<Iterator> regex_result; + if (xpressive::regex_search(first, last, regex_result, (*it).regex, + xpressive::regex_constants::match_continuous)) + { + Iterator saved = first; + Token rval = (*it).token; + + std::advance(first, regex_result.length()); + token = string_type(saved, first); + + if (NULL != (*it).callback) { + // execute corresponding callback + if ((*it).callback(saved, first, last, (*it).token)) + rval = next_token(first, last, token); + } + + return rval; + } + } + return Token(-1); // TODO: change this to use token_traits<Token> +} + +/////////////////////////////////////////////////////////////////////////////// +}}}} // boost::wave::cpplexer::xlex + +#endif // !defined(XPRESSIVE_LEXER_HPP) + + diff --git a/src/boost/libs/wave/samples/token_statistics/xlex_interface.hpp b/src/boost/libs/wave/samples/token_statistics/xlex_interface.hpp new file mode 100644 index 00000000..a1edabd8 --- /dev/null +++ b/src/boost/libs/wave/samples/token_statistics/xlex_interface.hpp @@ -0,0 +1,89 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Definition of the abstract lexer interface for the xpressive lexer + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(XLEX_INTERFACE_HPP) +#define XLEX_INTERFACE_HPP + +#include <boost/wave/language_support.hpp> +#include <boost/wave/util/file_position.hpp> +#include <boost/wave/cpplexer/cpp_lex_interface.hpp> + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace cpplexer { +namespace xlex { + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 +#define BOOST_WAVE_NEW_LEXER_DECL BOOST_WAVE_DECL +#else +#define BOOST_WAVE_NEW_LEXER_DECL +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// new_lexer_gen: generates a new instance of the required C++ lexer +// +/////////////////////////////////////////////////////////////////////////////// +template < + typename IteratorT, + typename PositionT = wave::util::file_position_type +> +struct BOOST_WAVE_NEW_LEXER_DECL new_lexer_gen +{ +// The NewLexer function allows the opaque generation of a new lexer object. +// It is coupled to the token type to allow to decouple the lexer/token +// configurations at compile time. + static wave::cpplexer::lex_input_interface<wave::cpplexer::lex_token<PositionT> > * + new_lexer(IteratorT const &first, IteratorT const &last, + PositionT const &pos, wave::language_support language); +}; + +#undef BOOST_WAVE_NEW_LEXER_DECL + +/////////////////////////////////////////////////////////////////////////////// +// +// The xlex_input_interface helps to instantiate a concrete lexer to be used +// by the Wave preprocessor module. +// This is done to allow compile time reduction. +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename TokenT> +struct xlex_input_interface +: lex_input_interface<TokenT> +{ + typedef typename wave::cpplexer::lex_input_interface<TokenT>::position_type + position_type; + + ~xlex_input_interface() {} + +// The new_lexer function allows the opaque generation of a new lexer object. +// It is coupled to the token type to allow to distinguish different +// lexer/token configurations at compile time. + template <typename IteratorT> + static wave::cpplexer::lex_input_interface<TokenT> * + new_lexer(IteratorT const &first, IteratorT const &last, + position_type const &pos, wave::language_support language) + { + return new_lexer_gen<IteratorT, position_type>::new_lexer (first, last, + pos, language); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +} // namespace xlex +} // namespace cpplexer +} // namespace wave +} // namespace boost + +#endif // !defined(XLEX_INTERFACE_HPP) diff --git a/src/boost/libs/wave/samples/token_statistics/xlex_iterator.hpp b/src/boost/libs/wave/samples/token_statistics/xlex_iterator.hpp new file mode 100644 index 00000000..d0e46109 --- /dev/null +++ b/src/boost/libs/wave/samples/token_statistics/xlex_iterator.hpp @@ -0,0 +1,232 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Definition of the lexer iterator for the xpressive lexer + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(XLEX_ITERATOR_HPP) +#define XLEX_ITERATOR_HPP + +#include <string> +#include <iostream> + +#include <boost/assert.hpp> +#include <boost/shared_ptr.hpp> +#include <boost/spirit/include/support_multi_pass.hpp> + +#include <boost/wave/language_support.hpp> +#include <boost/wave/util/file_position.hpp> +#include <boost/wave/util/functor_input.hpp> + +#include "xlex_interface.hpp" + +#if 0 != __COMO_VERSION__ || !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) +#define BOOST_WAVE_EOF_PREFIX static +#else +#define BOOST_WAVE_EOF_PREFIX +#endif + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace cpplexer { +namespace xlex { +namespace impl { + +/////////////////////////////////////////////////////////////////////////////// +// +// lex_iterator_functor_shim +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename TokenT> +class xlex_iterator_functor_shim +{ + typedef typename TokenT::position_type position_type; + +public: + xlex_iterator_functor_shim() +#if /*0 != __DECCXX_VER || */defined(__PGI) + : eof() +#endif // 0 != __DECCXX_VER + {} + +// interface to the boost::spirit::classic::iterator_policies::functor_input +// policy + typedef TokenT result_type; + + BOOST_WAVE_EOF_PREFIX result_type const eof; + typedef xlex_iterator_functor_shim unique; + typedef lex_input_interface<TokenT>* shared; + + template <typename MultiPass> + static result_type& get_next(MultiPass& mp, result_type& result) + { + return mp.shared()->ftor->get(result); + } + + // this will be called whenever the last reference to a multi_pass will + // be released + template <typename MultiPass> + static void destroy(MultiPass& mp) + { + delete mp.shared()->ftor; + } + + template <typename MultiPass> + static void set_position(MultiPass& mp, position_type const &pos) + { + mp.shared()->ftor->set_position(pos); + } + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + template <typename MultiPass> + static bool has_include_guards(MultiPass& mp, std::string& guard_name) + { + return mp.shared()->ftor->has_include_guards(guard_name); + } +#endif + +private: + boost::shared_ptr<lex_input_interface<TokenT> > functor_ptr; +}; + +#if 0 != __COMO_VERSION__ || !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) +/////////////////////////////////////////////////////////////////////////////// +// eof token +template <typename TokenT> +typename xlex_iterator_functor_shim<TokenT>::result_type const + xlex_iterator_functor_shim<TokenT>::eof = + typename xlex_iterator_functor_shim<TokenT>::result_type(); +#endif // 0 != __COMO_VERSION__ + +/////////////////////////////////////////////////////////////////////////////// +} // namespace impl + +/////////////////////////////////////////////////////////////////////////////// +// +// xlex_iterator +// +// A generic C++ lexer interface class, which allows to plug in different +// lexer implementations (template parameter LexT). The following +// requirement apply: +// +// - the lexer type should have a function implemented, which returns +// the next lexed token from the input stream: +// typename LexT::token_type get(); +// - at the end of the input stream this function should return the +// eof token equivalent +// - the lexer should implement a constructor taking two iterators +// pointing to the beginning and the end of the input stream and +// a third parameter containing the name of the parsed input file, +// the 4th parameter contains the information about the mode the +// preprocessor is used in (C99/C++ mode etc.) +// +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Divide the given functor type into its components (unique and shared) +// and build a std::pair from these parts +template <typename FunctorData> +struct make_multi_pass +{ + typedef + std::pair<typename FunctorData::unique, typename FunctorData::shared> + functor_data_type; + typedef typename FunctorData::result_type result_type; + + typedef boost::spirit::iterator_policies::split_functor_input input_policy; + typedef boost::spirit::iterator_policies::ref_counted ownership_policy; +#if defined(BOOST_WAVE_DEBUG) + typedef boost::spirit::iterator_policies::buf_id_check check_policy; +#else + typedef boost::spirit::iterator_policies::no_check check_policy; +#endif + typedef boost::spirit::iterator_policies::split_std_deque storage_policy; + + typedef boost::spirit::iterator_policies::default_policy< + ownership_policy, check_policy, input_policy, storage_policy> + policy_type; + typedef boost::spirit::multi_pass<functor_data_type, policy_type> type; +}; + +/////////////////////////////////////////////////////////////////////////////// +template <typename TokenT> +class xlex_iterator +: public make_multi_pass<impl::xlex_iterator_functor_shim<TokenT> >::type +{ + typedef impl::xlex_iterator_functor_shim<TokenT> input_policy_type; + + typedef typename make_multi_pass<input_policy_type>::type base_type; + typedef typename make_multi_pass<input_policy_type>::functor_data_type + functor_data_type; + + typedef typename input_policy_type::unique unique_functor_type; + typedef typename input_policy_type::shared shared_functor_type; + +public: + typedef TokenT token_type; + + xlex_iterator() + {} + + template <typename IteratorT> + xlex_iterator(IteratorT const &first, IteratorT const &last, + typename TokenT::position_type const &pos, + boost::wave::language_support language) + : base_type( + functor_data_type( + unique_functor_type(), + xlex_input_interface<TokenT> + ::new_lexer(first, last, pos, language) + ) + ) + {} + + void set_position(typename TokenT::position_type const &pos) + { + typedef typename token_type::position_type position_type; + + // set the new position in the current token + token_type const& currtoken = this->base_type::dereference(*this); + position_type currpos = currtoken.get_position(); + + currpos.set_file(pos.get_file()); + currpos.set_line(pos.get_line()); + const_cast<token_type&>(currtoken).set_position(currpos); + + // set the new position for future tokens as well + if (token_type::string_type::npos != + currtoken.get_value().find_first_of('\n')) + { + currpos.set_line(pos.get_line() + 1); + } + unique_functor_type::set_position(*this, currpos); + } + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + // return, whether the current file has include guards + // this function returns meaningful results only if the file was scanned + // completely + bool has_include_guards(std::string& guard_name) const + { + return unique_functor_type::has_include_guards(*this, guard_name); + } +#endif +}; + +/////////////////////////////////////////////////////////////////////////////// +} // namespace xlex +} // namespace cpplexer +} // namespace wave +} // namespace boost + +#undef BOOST_WAVE_EOF_PREFIX + +#endif // !defined(XLEX_ITERATOR_HPP) diff --git a/src/boost/libs/wave/samples/waveidl/build/Jamfile.v2 b/src/boost/libs/wave/samples/waveidl/build/Jamfile.v2 new file mode 100644 index 00000000..a98c729e --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/build/Jamfile.v2 @@ -0,0 +1,39 @@ +# Boost.Wave: A Standard compliant C++ preprocessor library +# +# Boost Wave Library Sample Build Jamfile (waveidl) +# +# http://www.boost.org/ +# +# Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost +# Software License, Version 1.0. (See accompanying file +# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +SOURCES = + ../idl + ../instantiate_cpp_grammar + ../instantiate_defined_grammar + ../instantiate_predef_macros + ../instantiate_re2c_lexer + ../instantiate_re2c_lexer_str + ../idllexer/idl_re + ; + +exe waveidl + : + $(SOURCES) + /boost/wave//boost_wave + /boost/program_options//boost_program_options + /boost/system//boost_system + /boost/thread//boost_thread + /boost/date_time//boost_date_time + ; + +for local source in $(SOURCES) +{ + local requirements ; + # workaround for compiler bug + requirements += <toolset-msvc:version>7.1:<rtti>off ; + requirements += <toolset-msvc:version>7.1_stlport4:<rtti>off ; + obj $(source) : $(source).cpp : $(requirements) ; +} + diff --git a/src/boost/libs/wave/samples/waveidl/idl.cpp b/src/boost/libs/wave/samples/waveidl/idl.cpp new file mode 100644 index 00000000..333e3ce5 --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/idl.cpp @@ -0,0 +1,538 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: IDL oriented preprocessor + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "idl.hpp" // global configuration + +#include <boost/assert.hpp> +#include <boost/program_options.hpp> +#include <boost/filesystem/path.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include Wave itself +#include <boost/wave.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// Include the lexer related stuff +#include <boost/wave/cpplexer/cpp_lex_token.hpp> // token type +#include "idllexer/idl_lex_iterator.hpp" // lexer type + +/////////////////////////////////////////////////////////////////////////////// +// include lexer specifics, import lexer names +// +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION == 0 +#include "idllexer/idl_re2c_lexer.hpp" +#endif + +/////////////////////////////////////////////////////////////////////////////// +// include the grammar definitions, if these shouldn't be compiled separately +// (ATTENTION: _very_ large compilation times!) +// +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION == 0 +#include <boost/wave/grammars/cpp_intlit_grammar.hpp> +#include <boost/wave/grammars/cpp_chlit_grammar.hpp> +#include <boost/wave/grammars/cpp_grammar.hpp> +#include <boost/wave/grammars/cpp_expression_grammar.hpp> +#include <boost/wave/grammars/cpp_predef_macros_grammar.hpp> +#include <boost/wave/grammars/cpp_defined_grammar.hpp> +#endif + +/////////////////////////////////////////////////////////////////////////////// +// import required names +using namespace boost::spirit::classic; + +using std::string; +using std::pair; +using std::vector; +using std::getline; +using std::ifstream; +using std::cout; +using std::cerr; +using std::endl; +using std::ostream; +using std::istreambuf_iterator; + +namespace po = boost::program_options; +namespace fs = boost::filesystem; + +/////////////////////////////////////////////////////////////////////////////// +// print the current version +int print_version() +{ + typedef boost::wave::idllexer::lex_iterator< + boost::wave::cpplexer::lex_token<> > + lex_iterator_type; + typedef boost::wave::context<std::string::iterator, lex_iterator_type> + context_type; + + string version (context_type::get_version_string()); + cout + << version.substr(1, version.size()-2) // strip quotes + << " (" << IDL_VERSION_DATE << ")" // add date + << endl; + return 0; // exit app +} + +/////////////////////////////////////////////////////////////////////////////// +// print the copyright statement +int print_copyright() +{ + char const *copyright[] = { + "", + "Sample: IDL oriented preprocessor", + "Based on: Wave, A Standard conformant C++ preprocessor library", + "It is hosted by http://www.boost.org/.", + "", + "Copyright (c) 2001-2010 Hartmut Kaiser, Distributed under the Boost", + "Software License, Version 1.0. (See accompanying file", + "LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)", + 0 + }; + + for (int i = 0; 0 != copyright[i]; ++i) + cout << copyright[i] << endl; + + return 0; // exit app +} + +/////////////////////////////////////////////////////////////////////////////// +namespace cmd_line_util { + + // Additional command line parser which interprets '@something' as an + // option "config-file" with the value "something". + pair<string, string> at_option_parser(string const&s) + { + if ('@' == s[0]) + return std::make_pair(string("config-file"), s.substr(1)); + else + return pair<string, string>(); + } + + // class, which keeps include file information read from the command line + class include_paths { + public: + include_paths() : seen_separator(false) {} + + vector<string> paths; // stores user paths + vector<string> syspaths; // stores system paths + bool seen_separator; // command line contains a '-I-' option + + // Function which validates additional tokens from command line. + static void + validate(boost::any &v, vector<string> const &tokens) + { + if (v.empty()) + v = boost::any(include_paths()); + + include_paths *p = boost::any_cast<include_paths>(&v); + + BOOST_ASSERT(p); + // Assume only one path per '-I' occurrence. + string t = tokens[0]; + if (t == "-") { + // found -I- option, so switch behaviour + p->seen_separator = true; + } + else if (p->seen_separator) { + // store this path as a system path + p->syspaths.push_back(t); + } + else { + // store this path as an user path + p->paths.push_back(t); + } + } + }; + + // Read all options from a given config file, parse and add them to the + // given variables_map + void read_config_file_options(string const &filename, + po::options_description const &desc, po::variables_map &vm, + bool may_fail = false) + { + ifstream ifs(filename.c_str()); + + if (!ifs.is_open()) { + if (!may_fail) { + cerr << filename + << ": command line warning: config file not found" + << endl; + } + return; + } + + vector<string> options; + string line; + + while (std::getline(ifs, line)) { + // skip empty lines + string::size_type pos = line.find_first_not_of(" \t"); + if (pos == string::npos) + continue; + + // skip comment lines + if ('#' != line[pos]) + options.push_back(line); + } + + if (options.size() > 0) { + using namespace boost::program_options::command_line_style; + po::store(po::command_line_parser(options) + .options(desc).style(unix_style).run(), vm); + po::notify(vm); + } + } + + // predicate to extract all positional arguments from the command line + struct is_argument { + bool operator()(po::option const &opt) + { + return (opt.position_key == -1) ? true : false; + } + }; + +/////////////////////////////////////////////////////////////////////////////// +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Special validator overload, which allows to handle the -I- syntax for +// switching the semantics of an -I option. +// +/////////////////////////////////////////////////////////////////////////////// +namespace boost { namespace program_options { + + void validate(boost::any &v, std::vector<std::string> const &s, + cmd_line_util::include_paths *, int) + { + cmd_line_util::include_paths::validate(v, s); + } + +}} // namespace boost::program_options + +/////////////////////////////////////////////////////////////////////////////// +// do the actual preprocessing +int +do_actual_work (std::string file_name, po::variables_map const &vm) +{ +// current file position is saved for exception handling +boost::wave::util::file_position_type current_position; + + try { + // process the given file + ifstream instream(file_name.c_str()); + string instring; + + if (!instream.is_open()) { + cerr << "waveidl: could not open input file: " << file_name << endl; + return -1; + } + instream.unsetf(std::ios::skipws); + +#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) + // this is known to be very slow for large files on some systems + copy (istream_iterator<char>(instream), + istream_iterator<char>(), + inserter(instring, instring.end())); +#else + instring = string(istreambuf_iterator<char>(instream.rdbuf()), + istreambuf_iterator<char>()); +#endif + + // This sample uses the lex_token type predefined in the Wave library, but + // but uses a custom lexer type. + typedef boost::wave::idllexer::lex_iterator< + boost::wave::cpplexer::lex_token<> > + lex_iterator_type; + typedef boost::wave::context<std::string::iterator, lex_iterator_type> + context_type; + + // The C++ preprocessor iterators shouldn't be constructed directly. They + // are to be generated through a boost::wave::context<> object. This + // boost::wave::context object is additionally to be used to initialize and + // define different parameters of the actual preprocessing. + // The preprocessing of the input stream is done on the fly behind the + // scenes during iteration over the context_type::iterator_type stream. + context_type ctx (instring.begin(), instring.end(), file_name.c_str()); + + // add include directories to the system include search paths + if (vm.count("sysinclude")) { + vector<string> const &syspaths = + vm["sysinclude"].as<vector<string> >(); + vector<string>::const_iterator end = syspaths.end(); + for (vector<string>::const_iterator cit = syspaths.begin(); + cit != end; ++cit) + { + ctx.add_sysinclude_path((*cit).c_str()); + } + } + + // add include directories to the include search paths + if (vm.count("include")) { + cmd_line_util::include_paths const &ip = + vm["include"].as<cmd_line_util::include_paths>(); + vector<string>::const_iterator end = ip.paths.end(); + + for (vector<string>::const_iterator cit = ip.paths.begin(); + cit != end; ++cit) + { + ctx.add_include_path((*cit).c_str()); + } + + // if on the command line was given -I- , this has to be propagated + if (ip.seen_separator) + ctx.set_sysinclude_delimiter(); + + // add system include directories to the include path + vector<string>::const_iterator sysend = ip.syspaths.end(); + for (vector<string>::const_iterator syscit = ip.syspaths.begin(); + syscit != sysend; ++syscit) + { + ctx.add_sysinclude_path((*syscit).c_str()); + } + } + + // add additional defined macros + if (vm.count("define")) { + vector<string> const ¯os = vm["define"].as<vector<string> >(); + vector<string>::const_iterator end = macros.end(); + for (vector<string>::const_iterator cit = macros.begin(); + cit != end; ++cit) + { + ctx.add_macro_definition(*cit); + } + } + + // add additional predefined macros + if (vm.count("predefine")) { + vector<string> const &predefmacros = + vm["predefine"].as<vector<string> >(); + vector<string>::const_iterator end = predefmacros.end(); + for (vector<string>::const_iterator cit = predefmacros.begin(); + cit != end; ++cit) + { + ctx.add_macro_definition(*cit, true); + } + } + + // undefine specified macros + if (vm.count("undefine")) { + vector<string> const &undefmacros = + vm["undefine"].as<vector<string> >(); + vector<string>::const_iterator end = undefmacros.end(); + for (vector<string>::const_iterator cit = undefmacros.begin(); + cit != end; ++cit) + { + ctx.remove_macro_definition((*cit).c_str(), true); + } + } + + // open the output file + std::ofstream output; + + if (vm.count("output")) { + // try to open the file, where to put the preprocessed output + string out_file (vm["output"].as<string>()); + + output.open(out_file.c_str()); + if (!output.is_open()) { + cerr << "waveidl: could not open output file: " << out_file + << endl; + return -1; + } + } + else { + // output the preprocessed result to std::cout + output.copyfmt(cout); + output.clear(cout.rdstate()); + static_cast<std::basic_ios<char> &>(output).rdbuf(cout.rdbuf()); + } + + // analyze the input file + context_type::iterator_type first = ctx.begin(); + context_type::iterator_type last = ctx.end(); + + // loop over all generated tokens outputing the generated text + while (first != last) { + // print out the string representation of this token (skip comments) + using namespace boost::wave; + + // store the last known good token position + current_position = (*first).get_position(); + + token_id id = token_id(*first); + + if (T_CPPCOMMENT == id || T_NEWLINE == id) { + // C++ comment tokens contain the trailing newline + output << endl; + } + else if (id != T_CCOMMENT) { + // print out the current token value + output << (*first).get_value(); + } + ++first; // advance to the next token + } + } + catch (boost::wave::cpp_exception const& e) { + // some preprocessing error + cerr + << e.file_name() << "(" << e.line_no() << "): " + << e.description() << endl; + return 1; + } + catch (boost::wave::cpplexer::lexing_exception const& e) { + // some lexing error + cerr + << e.file_name() << "(" << e.line_no() << "): " + << e.description() << endl; + return 2; + } + catch (std::exception const& e) { + // use last recognized token to retrieve the error position + cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "exception caught: " << e.what() + << endl; + return 3; + } + catch (...) { + // use last recognized token to retrieve the error position + cerr + << current_position.get_file() + << "(" << current_position.get_line() << "): " + << "unexpected exception caught." << endl; + return 4; + } + return 0; +} + +/////////////////////////////////////////////////////////////////////////////// +// main entry point +int +main (int argc, char *argv[]) +{ + try { + // analyze the command line options and arguments + + // declare the options allowed from the command line only + po::options_description desc_cmdline ("Options allowed on the command line only"); + + desc_cmdline.add_options() + ("help,h", "print out program usage (this message)") + ("version,v", "print the version number") + ("copyright,c", "print out the copyright statement") + ("config-file", po::value<vector<string> >(), + "specify a config file (alternatively: @filepath)") + ; + + // declare the options allowed on command line and in config files + po::options_description desc_generic ("Options allowed additionally in a config file"); + + desc_generic.add_options() + ("output,o", po::value<string>()->composing(), + "specify a file to use for output instead of stdout") + ("include,I", po::value<cmd_line_util::include_paths>()->composing(), + "specify an additional include directory") + ("sysinclude,S", po::value<vector<string> >()->composing(), + "specify an additional system include directory") + ("define,D", po::value<vector<string> >()->composing(), + "specify a macro to define (as macro[=[value]])") + ("predefine,P", po::value<vector<string> >()->composing(), + "specify a macro to predefine (as macro[=[value]])") + ("undefine,U", po::value<vector<string> >()->composing(), + "specify a macro to undefine") + ; + + // combine the options for the different usage schemes + po::options_description desc_overall_cmdline; + po::options_description desc_overall_cfgfile; + + desc_overall_cmdline.add(desc_cmdline).add(desc_generic); + desc_overall_cfgfile.add(desc_generic); + + // parse command line and store results + using namespace boost::program_options::command_line_style; + + po::parsed_options opts = po::parse_command_line(argc, argv, + desc_overall_cmdline, unix_style, cmd_line_util::at_option_parser); + po::variables_map vm; + + po::store(opts, vm); + po::notify(vm); + + // Try to find a waveidl.cfg in the same directory as the executable was + // started from. If this exists, treat it as a wave config file + fs::path filename(argv[0], fs::native); + + filename = filename.branch_path() / "waveidl.cfg"; + cmd_line_util::read_config_file_options(filename.string(), + desc_overall_cfgfile, vm, true); + + // if there is specified at least one config file, parse it and add the + // options to the main variables_map + if (vm.count("config-file")) { + vector<string> const &cfg_files = + vm["config-file"].as<vector<string> >(); + vector<string>::const_iterator end = cfg_files.end(); + for (vector<string>::const_iterator cit = cfg_files.begin(); + cit != end; ++cit) + { + // parse a single config file and store the results + cmd_line_util::read_config_file_options(*cit, + desc_overall_cfgfile, vm); + } + } + + // ... act as required + if (vm.count("help")) { + po::options_description desc_help ( + "Usage: waveidl [options] [@config-file(s)] file"); + + desc_help.add(desc_cmdline).add(desc_generic); + cout << desc_help << endl; + return 1; + } + + if (vm.count("version")) { + return print_version(); + } + + if (vm.count("copyright")) { + return print_copyright(); + } + + // extract the arguments from the parsed command line + vector<po::option> arguments; + + std::remove_copy_if(opts.options.begin(), opts.options.end(), + inserter(arguments, arguments.end()), cmd_line_util::is_argument()); + + // if there is no input file given, then exit + if (0 == arguments.size() || 0 == arguments[0].value.size()) { + cerr << "waveidl: no input file given, " + << "use --help to get a hint." << endl; + return 5; + } + + // preprocess the given input file + return do_actual_work(arguments[0].value[0], vm); + } + catch (std::exception const& e) { + cout << "waveidl: exception caught: " << e.what() << endl; + return 6; + } + catch (...) { + cerr << "waveidl: unexpected exception caught." << endl; + return 7; + } +} + diff --git a/src/boost/libs/wave/samples/waveidl/idl.hpp b/src/boost/libs/wave/samples/waveidl/idl.hpp new file mode 100644 index 00000000..a0a3f573 --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/idl.hpp @@ -0,0 +1,45 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: IDL oriented preprocessor + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(IDL_HPP_FC7EE131_5CE9_43F2_A713_8D9BBC3C8477_INCLUDED) +#define IDL_HPP_FC7EE131_5CE9_43F2_A713_8D9BBC3C8477_INCLUDED + +/////////////////////////////////////////////////////////////////////////////// +// This file may be used as a precompiled header (if applicable) + +/////////////////////////////////////////////////////////////////////////////// +// include often used files from the stdlib +#include <iostream> +#include <fstream> +#include <string> +#include <vector> +#include <algorithm> +#include <iterator> + +/////////////////////////////////////////////////////////////////////////////// +// include boost config +#include <boost/config.hpp> // global configuration information + +/////////////////////////////////////////////////////////////////////////////// +// build version +#include "idl_version.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// configure this app here (global configuration constants) +#include "idl_config.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// include required boost libraries +#include <boost/assert.hpp> +#include <boost/pool/pool_alloc.hpp> + +#endif // !defined(IDL_HPP_FC7EE131_5CE9_43F2_A713_8D9BBC3C8477_INCLUDED) diff --git a/src/boost/libs/wave/samples/waveidl/idl_config.hpp b/src/boost/libs/wave/samples/waveidl/idl_config.hpp new file mode 100644 index 00000000..a7314fb3 --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/idl_config.hpp @@ -0,0 +1,65 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: IDL oriented preprocessor + Global application configuration of the Wave driver command + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(IDL_CONFIG_HPP_012D7524_FF3F_482F_9123_91966C72F4EA_INCLUDED) +#define IDL_CONFIG_HPP_012D7524_FF3F_482F_9123_91966C72F4EA_INCLUDED + +/////////////////////////////////////////////////////////////////////////////// +// Uncomment the following, if you need debug output, the +// BOOST_SPIRIT_DEBUG_FLAGS constants below help to fine control the amount of +// the generated debug output +//#define BOOST_SPIRIT_DEBUG + +/////////////////////////////////////////////////////////////////////////////// +// debug rules, subrules and grammars only, for possible flags see +// spirit/debug.hpp +#if defined(BOOST_SPIRIT_DEBUG) + +#define BOOST_SPIRIT_DEBUG_FLAGS ( \ + BOOST_SPIRIT_DEBUG_FLAGS_NODES | \ + BOOST_SPIRIT_DEBUG_FLAGS_CLOSURES \ + ) \ + /**/ + +/////////////////////////////////////////////////////////////////////////////// +// debug flags for the pp-iterator library, possible flags (defined in +// wave_config.hpp): +// +// #define BOOST_SPIRIT_DEBUG_FLAGS_CPP_GRAMMAR 0x0001 +// #define BOOST_SPIRIT_DEBUG_FLAGS_TIME_CONVERSION 0x0002 +// #define BOOST_SPIRIT_DEBUG_FLAGS_CPP_EXPR_GRAMMAR 0x0004 +// #define BOOST_SPIRIT_DEBUG_FLAGS_INTLIT_GRAMMAR 0x0008 +// #define BOOST_SPIRIT_DEBUG_FLAGS_CHLIT_GRAMMAR 0x0010 +// #define BOOST_SPIRIT_DEBUG_FLAGS_DEFINED_GRAMMAR 0x0020 +// #define BOOST_SPIRIT_DEBUG_FLAGS_PREDEF_MACROS_GRAMMAR 0x0040 + +#define BOOST_SPIRIT_DEBUG_FLAGS_CPP (\ + /* insert the required flags from above */ \ + ) \ + /**/ +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Now include the cofiguration stuff for the Wave library itself +#include <boost/wave/wave_config.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// MSVC specific #pragma's +#if defined(BOOST_MSVC) +#pragma warning (disable: 4355) // 'this' used in base member initializer list +#pragma warning (disable: 4800) // forcing value to bool 'true' or 'false' +#pragma inline_depth(255) +#pragma inline_recursion(on) +#endif // defined(BOOST_MSVC) + +#endif // !defined(IDL_CONFIG_HPP_012D7524_FF3F_482F_9123_91966C72F4EA_INCLUDED) diff --git a/src/boost/libs/wave/samples/waveidl/idl_version.hpp b/src/boost/libs/wave/samples/waveidl/idl_version.hpp new file mode 100644 index 00000000..3ab6ade3 --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/idl_version.hpp @@ -0,0 +1,23 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: IDL oriented preprocessor + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(IDL_VERSION_HPP_780C1190_3107_440B_B303_B687A449749B_INCLUDED) +#define IDL_VERSION_HPP_780C1190_3107_440B_B303_B687A449749B_INCLUDED + +#include <boost/wave/wave_version.hpp> + +#define IDL_VERSION_MAJOR BOOST_WAVE_VERSION_MAJOR +#define IDL_VERSION_MINOR BOOST_WAVE_VERSION_MINOR +#define IDL_VERSION_SUBMINOR BOOST_WAVE_VERSION_SUBMINOR +#define IDL_VERSION_DATE 20050117L + +#endif // !defined(IDL_VERSION_HPP_780C1190_3107_440B_B303_B687A449749B_INCLUDED) diff --git a/src/boost/libs/wave/samples/waveidl/idllexer/idl.re b/src/boost/libs/wave/samples/waveidl/idllexer/idl.re new file mode 100644 index 00000000..62cc3e61 --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/idllexer/idl.re @@ -0,0 +1,588 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: IDL lexer + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <ctime> +#include <cstdlib> +#include <cstdio> +#include <cstring> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> + +#include <boost/config.hpp> + +#if defined(BOOST_HAS_UNISTD_H) +#include <unistd.h> +#else +#include <io.h> +#endif + +#include <boost/assert.hpp> +#include <boost/detail/workaround.hpp> + +// reuse the token ids and re2c helper functions from the default C++ lexer +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/re2clex/aq.hpp> +#include <boost/wave/cpplexer/re2clex/scanner.hpp> +#include <boost/wave/cpplexer/cpplexer_exceptions.hpp> + +#include "idl_re.hpp" + +#if defined(_MSC_VER) && !defined(__COMO__) +#pragma warning (disable: 4101) // 'foo' : unreferenced local variable +#pragma warning (disable: 4102) // 'foo' : unreferenced label +#endif + +#define BOOST_WAVE_BSIZE 196608 + +#define YYCTYPE uchar +#define YYCURSOR cursor +#define YYLIMIT s->lim +#define YYMARKER s->ptr +#define YYFILL(n) {cursor = fill(s, cursor);} + +//#define BOOST_WAVE_RET(i) {s->cur = cursor; return (i);} +#define BOOST_WAVE_RET(i) \ + { \ + s->line += count_backslash_newlines(s, cursor); \ + s->cur = cursor; \ + return (i); \ + } \ + /**/ + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace idllexer { +namespace re2clex { + +#define RE2C_ASSERT BOOST_ASSERT + +int +get_one_char(boost::wave::cpplexer::re2clex::Scanner *s) +{ + using namespace boost::wave::cpplexer::re2clex; + if (0 != s->act) { + RE2C_ASSERT(s->first != 0 && s->last != 0); + RE2C_ASSERT(s->first <= s->act && s->act <= s->last); + if (s->act < s->last) + return *(s->act)++; + } + return -1; +} + +std::ptrdiff_t +rewind_stream (boost::wave::cpplexer::re2clex::Scanner *s, int cnt) +{ + if (0 != s->act) { + RE2C_ASSERT(s->first != 0 && s->last != 0); + s->act += cnt; + RE2C_ASSERT(s->first <= s->act && s->act <= s->last); + return s->act - s->first; + } + return 0; +} + +std::size_t +get_first_eol_offset(boost::wave::cpplexer::re2clex::Scanner* s) +{ + if (!AQ_EMPTY(s->eol_offsets)) + { + return s->eol_offsets->queue[s->eol_offsets->head]; + } + else + { + return (unsigned int)-1; + } +} + +void +adjust_eol_offsets(boost::wave::cpplexer::re2clex::Scanner* s, + std::size_t adjustment) +{ + boost::wave::cpplexer::re2clex::aq_queue q; + std::size_t i; + + if (!s->eol_offsets) + s->eol_offsets = boost::wave::cpplexer::re2clex::aq_create(); + + q = s->eol_offsets; + + if (AQ_EMPTY(q)) + return; + + i = q->head; + while (i != q->tail) + { + if (adjustment > q->queue[i]) + q->queue[i] = 0; + else + q->queue[i] -= adjustment; + ++i; + if (i == q->max_size) + i = 0; + } + if (adjustment > q->queue[i]) + q->queue[i] = 0; + else + q->queue[i] -= adjustment; +} + +int +count_backslash_newlines(boost::wave::cpplexer::re2clex::Scanner *s, + boost::wave::cpplexer::re2clex::uchar *cursor) +{ + using namespace boost::wave::cpplexer::re2clex; + + std::size_t diff, offset; + int skipped = 0; + + /* figure out how many backslash-newlines skipped over unknowingly. */ + diff = cursor - s->bot; + offset = get_first_eol_offset(s); + while (offset <= diff && offset != (unsigned int)-1) + { + skipped++; + boost::wave::cpplexer::re2clex::aq_pop(s->eol_offsets); + offset = get_first_eol_offset(s); + } + return skipped; +} + +bool is_backslash( + boost::wave::cpplexer::re2clex::uchar *p, + boost::wave::cpplexer::re2clex::uchar *end, int &len) +{ + if (*p == '\\') { + len = 1; + return true; + } + else if (*p == '?' && *(p+1) == '?' && (p+2 < end && *(p+2) == '/')) { + len = 3; + return true; + } + return false; +} + +boost::wave::cpplexer::re2clex::uchar * +fill(boost::wave::cpplexer::re2clex::Scanner *s, + boost::wave::cpplexer::re2clex::uchar *cursor) +{ + using namespace std; // some systems have memcpy etc. in namespace std + using namespace boost::wave::cpplexer::re2clex; + + if(!s->eof) + { + uchar* p; + std::ptrdiff_t cnt = s->tok - s->bot; + if(cnt) + { + memcpy(s->bot, s->tok, s->lim - s->tok); + s->tok = s->bot; + s->ptr -= cnt; + cursor -= cnt; + s->lim -= cnt; + adjust_eol_offsets(s, cnt); + } + + if((s->top - s->lim) < BOOST_WAVE_BSIZE) + { + uchar *buf = (uchar*) malloc(((s->lim - s->bot) + BOOST_WAVE_BSIZE)*sizeof(uchar)); + if (buf == 0) + { + using namespace std; // some systems have printf in std + if (0 != s->error_proc) { + (*s->error_proc)(s, + cpplexer::lexing_exception::unexpected_error, + "Out of memory!"); + } + else + printf("Out of memory!\n"); + + /* get the scanner to stop */ + *cursor = 0; + return cursor; + } + + memcpy(buf, s->tok, s->lim - s->tok); + s->tok = buf; + s->ptr = &buf[s->ptr - s->bot]; + cursor = &buf[cursor - s->bot]; + s->lim = &buf[s->lim - s->bot]; + s->top = &s->lim[BOOST_WAVE_BSIZE]; + free(s->bot); + s->bot = buf; + } + + if (s->act != 0) { + cnt = s->last - s->act; + if (cnt > BOOST_WAVE_BSIZE) + cnt = BOOST_WAVE_BSIZE; + memcpy(s->lim, s->act, cnt); + s->act += cnt; + if (cnt != BOOST_WAVE_BSIZE) + { + s->eof = &s->lim[cnt]; *(s->eof)++ = '\0'; + } + } + + /* backslash-newline erasing time */ + + /* first scan for backslash-newline and erase them */ + for (p = s->lim; p < s->lim + cnt - 2; ++p) + { + int len = 0; + if (is_backslash(p, s->lim + cnt, len)) + { + if (*(p+len) == '\n') + { + int offset = len + 1; + memmove(p, p + offset, s->lim + cnt - p - offset); + cnt -= offset; + --p; + aq_enqueue(s->eol_offsets, p - s->bot + 1); + } + else if (*(p+len) == '\r') + { + if (*(p+len+1) == '\n') + { + int offset = len + 2; + memmove(p, p + offset, s->lim + cnt - p - offset); + cnt -= offset; + --p; + } + else + { + int offset = len + 1; + memmove(p, p + offset, s->lim + cnt - p - offset); + cnt -= offset; + --p; + } + aq_enqueue(s->eol_offsets, p - s->bot + 1); + } + } + } + + /* FIXME: the following code should be fixed to recognize correctly the + trigraph backslash token */ + + /* check to see if what we just read ends in a backslash */ + if (cnt >= 2) + { + uchar last = s->lim[cnt-1]; + uchar last2 = s->lim[cnt-2]; + /* check \ EOB */ + if (last == '\\') + { + int next = get_one_char(s); + /* check for \ \n or \ \r or \ \r \n straddling the border */ + if (next == '\n') + { + --cnt; /* chop the final \, we've already read the \n. */ + boost::wave::cpplexer::re2clex::aq_enqueue(s->eol_offsets, + cnt + (s->lim - s->bot)); + } + else if (next == '\r') + { + int next2 = get_one_char(s); + if (next2 == '\n') + { + --cnt; /* skip the backslash */ + } + else + { + /* rewind one, and skip one char */ + rewind_stream(s, -1); + --cnt; + } + boost::wave::cpplexer::re2clex::aq_enqueue(s->eol_offsets, + cnt + (s->lim - s->bot)); + } + else if (next != -1) /* -1 means end of file */ + { + /* next was something else, so rewind the stream */ + rewind_stream(s, -1); + } + } + /* check \ \r EOB */ + else if (last == '\r' && last2 == '\\') + { + int next = get_one_char(s); + if (next == '\n') + { + cnt -= 2; /* skip the \ \r */ + } + else + { + /* rewind one, and skip two chars */ + rewind_stream(s, -1); + cnt -= 2; + } + boost::wave::cpplexer::re2clex::aq_enqueue(s->eol_offsets, + cnt + (s->lim - s->bot)); + } + /* check \ \n EOB */ + else if (last == '\n' && last2 == '\\') + { + cnt -= 2; + boost::wave::cpplexer::re2clex::aq_enqueue(s->eol_offsets, + cnt + (s->lim - s->bot)); + } + } + + s->lim += cnt; + if (s->eof) /* eof needs adjusting if we erased backslash-newlines */ + { + s->eof = s->lim; + *(s->eof)++ = '\0'; + } + } + return cursor; +} + +boost::wave::token_id +scan(boost::wave::cpplexer::re2clex::Scanner *s) +{ + using namespace boost::wave::cpplexer::re2clex; + + uchar *cursor = s->tok = s->cur; + +/*!re2c +re2c:indent:string = " "; +any = [\t\v\f\r\n\040-\377]; +anyctrl = [\000-\377]; +OctalDigit = [0-7]; +Digit = [0-9]; +HexDigit = [a-fA-F0-9]; +ExponentPart = [Ee] [+-]? Digit+; +FractionalConstant = (Digit* "." Digit+) | (Digit+ "."); +FloatingSuffix = [fF][lL]?|[lL][fF]?; +IntegerSuffix = [uU][lL]?|[lL][uU]?; +FixedPointSuffix = [dD]; +Backslash = [\\]|"??/"; +EscapeSequence = Backslash ([abfnrtv?'"] | Backslash | "x" HexDigit+ | OctalDigit OctalDigit? OctalDigit?); +HexQuad = HexDigit HexDigit HexDigit HexDigit; +UniversalChar = Backslash ("u" HexQuad | "U" HexQuad HexQuad); +Newline = "\r\n" | "\n" | "\r"; +PPSpace = ([ \t]|("/*"(any\[*]|Newline|("*"+(any\[*/]|Newline)))*"*"+"/"))*; +Pound = "#" | "??=" | "%:"; +*/ + +/*!re2c + "/*" { goto ccomment; } + "//" { goto cppcomment; } + + "TRUE" { BOOST_WAVE_RET(T_TRUE); } + "FALSE" { BOOST_WAVE_RET(T_FALSE); } + + "{" { BOOST_WAVE_RET(T_LEFTBRACE); } + "}" { BOOST_WAVE_RET(T_RIGHTBRACE); } + "[" { BOOST_WAVE_RET(T_LEFTBRACKET); } + "]" { BOOST_WAVE_RET(T_RIGHTBRACKET); } + "#" { BOOST_WAVE_RET(T_POUND); } + "##" { BOOST_WAVE_RET(T_POUND_POUND); } + "(" { BOOST_WAVE_RET(T_LEFTPAREN); } + ")" { BOOST_WAVE_RET(T_RIGHTPAREN); } + ";" { BOOST_WAVE_RET(T_SEMICOLON); } + ":" { BOOST_WAVE_RET(T_COLON); } + "?" { BOOST_WAVE_RET(T_QUESTION_MARK); } + "." { BOOST_WAVE_RET(T_DOT); } + "+" { BOOST_WAVE_RET(T_PLUS); } + "-" { BOOST_WAVE_RET(T_MINUS); } + "*" { BOOST_WAVE_RET(T_STAR); } + "/" { BOOST_WAVE_RET(T_DIVIDE); } + "%" { BOOST_WAVE_RET(T_PERCENT); } + "^" { BOOST_WAVE_RET(T_XOR); } + "&" { BOOST_WAVE_RET(T_AND); } + "|" { BOOST_WAVE_RET(T_OR); } + "~" { BOOST_WAVE_RET(T_COMPL); } + "!" { BOOST_WAVE_RET(T_NOT); } + "=" { BOOST_WAVE_RET(T_ASSIGN); } + "<" { BOOST_WAVE_RET(T_LESS); } + ">" { BOOST_WAVE_RET(T_GREATER); } + "<<" { BOOST_WAVE_RET(T_SHIFTLEFT); } + ">>" { BOOST_WAVE_RET(T_SHIFTRIGHT); } + "==" { BOOST_WAVE_RET(T_EQUAL); } + "!=" { BOOST_WAVE_RET(T_NOTEQUAL); } + "<=" { BOOST_WAVE_RET(T_LESSEQUAL); } + ">=" { BOOST_WAVE_RET(T_GREATEREQUAL); } + "&&" { BOOST_WAVE_RET(T_ANDAND); } + "||" { BOOST_WAVE_RET(T_OROR); } + "++" { BOOST_WAVE_RET(T_PLUSPLUS); } + "--" { BOOST_WAVE_RET(T_MINUSMINUS); } + "," { BOOST_WAVE_RET(T_COMMA); } + + ([a-zA-Z_] | UniversalChar) ([a-zA-Z_0-9] | UniversalChar)* + { BOOST_WAVE_RET(T_IDENTIFIER); } + + (("0" [xX] HexDigit+) | ("0" OctalDigit*) | ([1-9] Digit*)) IntegerSuffix? + { BOOST_WAVE_RET(T_INTLIT); } + + ((FractionalConstant ExponentPart?) | (Digit+ ExponentPart)) FloatingSuffix? + { BOOST_WAVE_RET(T_FLOATLIT); } + + (FractionalConstant | Digit+) FixedPointSuffix + { BOOST_WAVE_RET(T_FIXEDPOINTLIT); } + + "L"? (['] (EscapeSequence|any\[\n\r\\']|UniversalChar)+ [']) + { BOOST_WAVE_RET(T_CHARLIT); } + + "L"? (["] (EscapeSequence|any\[\n\r\\"]|UniversalChar)* ["]) + { BOOST_WAVE_RET(T_STRINGLIT); } + + + Pound PPSpace "include" PPSpace "<" (any\[\n\r>])+ ">" + { BOOST_WAVE_RET(T_PP_HHEADER); } + + Pound PPSpace "include" PPSpace "\"" (any\[\n\r"])+ "\"" + { BOOST_WAVE_RET(T_PP_QHEADER); } + + Pound PPSpace "include" PPSpace + { BOOST_WAVE_RET(T_PP_INCLUDE); } + + Pound PPSpace "if" { BOOST_WAVE_RET(T_PP_IF); } + Pound PPSpace "ifdef" { BOOST_WAVE_RET(T_PP_IFDEF); } + Pound PPSpace "ifndef" { BOOST_WAVE_RET(T_PP_IFNDEF); } + Pound PPSpace "else" { BOOST_WAVE_RET(T_PP_ELSE); } + Pound PPSpace "elif" { BOOST_WAVE_RET(T_PP_ELIF); } + Pound PPSpace "endif" { BOOST_WAVE_RET(T_PP_ENDIF); } + Pound PPSpace "define" { BOOST_WAVE_RET(T_PP_DEFINE); } + Pound PPSpace "undef" { BOOST_WAVE_RET(T_PP_UNDEF); } + Pound PPSpace "line" { BOOST_WAVE_RET(T_PP_LINE); } + Pound PPSpace "error" { BOOST_WAVE_RET(T_PP_ERROR); } + Pound PPSpace "pragma" { BOOST_WAVE_RET(T_PP_PRAGMA); } + + Pound PPSpace "warning" { BOOST_WAVE_RET(T_PP_WARNING); } + + [ \t\v\f]+ + { BOOST_WAVE_RET(T_SPACE); } + + Newline + { + s->line++; + BOOST_WAVE_RET(T_NEWLINE); + } + + "\000" + { + if(cursor != s->eof) + { + using namespace std; // some systems have printf in std + if (0 != s->error_proc) { + (*s->error_proc)(s, + cpplexer::lexing_exception::generic_lexing_error, + "'\\000' in input stream"); + } + else + printf("Error: 0 in file\n"); + } + BOOST_WAVE_RET(T_EOF); + } + + anyctrl + { + BOOST_WAVE_RET(TOKEN_FROM_ID(*s->tok, UnknownTokenType)); + } +*/ + +ccomment: +/*!re2c + "*/" { BOOST_WAVE_RET(T_CCOMMENT); } + Newline + { + /*if(cursor == s->eof) BOOST_WAVE_RET(T_EOF);*/ + /*s->tok = cursor; */ + s->line += count_backslash_newlines(s, cursor) +1; + goto ccomment; + } + + any { goto ccomment; } + + "\000" + { + using namespace std; // some systems have printf in std + if(cursor == s->eof) + { + if (s->error_proc) + (*s->error_proc)(s, + cpplexer::lexing_exception::generic_lexing_warning, + "Unterminated comment"); + else + printf("Error: Unterminated comment\n"); + } + else + { + if (s->error_proc) + (*s->error_proc)(s, + cpplexer::lexing_exception::generic_lexing_error, + "'\\000' in input stream"); + else + printf("Error: 0 in file"); + } + /* adjust cursor such next call returns T_EOF */ + --YYCURSOR; + /* the comment is unterminated, but nevertheless its a comment */ + BOOST_WAVE_RET(T_CCOMMENT); + } + + anyctrl + { + if (s->error_proc) + (*s->error_proc)(s, + cpplexer::lexing_exception::generic_lexing_error, + "invalid character in input stream"); + else + printf("Error: 0 in file"); + } + +*/ + +cppcomment: +/*!re2c + Newline + { + /*if(cursor == s->eof) BOOST_WAVE_RET(T_EOF); */ + /*s->tok = cursor; */ + s->line++; + BOOST_WAVE_RET(T_CPPCOMMENT); + } + + any { goto cppcomment; } + + "\000" + { + using namespace std; // some systems have printf in std + if(cursor != s->eof) + { + if (s->error_proc) + (*s->error_proc)(s, + cpplexer::lexing_exception::generic_lexing_error, + "'\\000' in input stream"); + else + printf("Error: 0 in file"); + } + /* adjust cursor such next call returns T_EOF */ + --YYCURSOR; + /* the comment is unterminated, but nevertheless its a comment */ + BOOST_WAVE_RET(T_CPPCOMMENT); + } +*/ + +} /* end of scan */ + +#undef RE2C_ASSERT + +/////////////////////////////////////////////////////////////////////////////// +} // namespace re2clex +} // namespace idllexer +} // namespace wave +} // namespace boost diff --git a/src/boost/libs/wave/samples/waveidl/idllexer/idl_lex_interface.hpp b/src/boost/libs/wave/samples/waveidl/idllexer/idl_lex_interface.hpp new file mode 100644 index 00000000..3ee295d8 --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/idllexer/idl_lex_interface.hpp @@ -0,0 +1,78 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Definition of the abstract lexer interface + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(IDL_LEX_INTERFACE_HPP_INCLUDED) +#define IDL_LEX_INTERFACE_HPP_INCLUDED + +#include <boost/wave/util/file_position.hpp> +#include <boost/wave/language_support.hpp> +#include <boost/wave/cpplexer/cpp_lex_interface_generator.hpp> + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace idllexer { + +/////////////////////////////////////////////////////////////////////////////// +// +// new_lexer_gen: generates a new instance of the required C++ lexer +// +/////////////////////////////////////////////////////////////////////////////// +template < + typename IteratorT, + typename PositionT = boost::wave::util::file_position_type +> +struct new_lexer_gen +{ +// The NewLexer function allows the opaque generation of a new lexer object. +// It is coupled to the token type to allow to decouple the lexer/token +// configurations at compile time. + static cpplexer::lex_input_interface< + cpplexer::lex_token<PositionT> + > * + new_lexer(IteratorT const &first, IteratorT const &last, + PositionT const &pos, boost::wave::language_support language); +}; + +/////////////////////////////////////////////////////////////////////////////// +// +// The lex_input_interface decouples the lex_iterator_shim from the actual +// lexer. This is done to allow compile time reduction. +// Thanks to JCAB for having this idea. +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename TokenT> +struct lex_input_interface_generator +: cpplexer::lex_input_interface<TokenT> +{ + typedef typename cpplexer::lex_input_interface<TokenT>::position_type position_type; + +// The new_lexer function allows the opaque generation of a new lexer object. +// It is coupled to the token type to allow to distinguish different +// lexer/token configurations at compile time. + template <typename IteratorT> + static cpplexer::lex_input_interface<TokenT> * + new_lexer(IteratorT const &first, IteratorT const &last, + position_type const &pos, boost::wave::language_support language) + { + return new_lexer_gen<IteratorT, position_type>::new_lexer (first, last, + pos, language); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +} // namespace cpplexer +} // namespace wave +} // namespace boost + +#endif // !defined(IDL_LEX_INTERFACE_HPP_INCLUDED) diff --git a/src/boost/libs/wave/samples/waveidl/idllexer/idl_lex_iterator.hpp b/src/boost/libs/wave/samples/waveidl/idllexer/idl_lex_iterator.hpp new file mode 100644 index 00000000..42f9ae05 --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/idllexer/idl_lex_iterator.hpp @@ -0,0 +1,210 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: Re2C based IDL lexer + Definition of the lexer iterator + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(IDL_LEX_ITERATOR_HPP_7926F865_E02F_4950_9EB5_5F453C9FF953_INCLUDED) +#define IDL_LEX_ITERATOR_HPP_7926F865_E02F_4950_9EB5_5F453C9FF953_INCLUDED + +#include <string> +#include <iostream> + +#include <boost/assert.hpp> +#include <boost/shared_ptr.hpp> +#include <boost/spirit/include/support_multi_pass.hpp> + +#include <boost/wave/language_support.hpp> +#include <boost/wave/util/file_position.hpp> +#include <boost/wave/util/functor_input.hpp> + +#include "idl_lex_interface.hpp" + +#if 0 != __COMO_VERSION__ || !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) +#define BOOST_WAVE_EOF_PREFIX static +#else +#define BOOST_WAVE_EOF_PREFIX +#endif + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace idllexer { +namespace impl { + +/////////////////////////////////////////////////////////////////////////////// +// +// lex_iterator_functor_shim +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename TokenT> +class lex_iterator_functor_shim +{ + typedef typename TokenT::position_type position_type; + +public: + lex_iterator_functor_shim() +#if /*0 != __DECCXX_VER || */defined(__PGI) + : eof() +#endif // 0 != __DECCXX_VER + {} + +// interface to the boost::spirit::classic::iterator_policies::functor_input +// policy + typedef TokenT result_type; + + BOOST_WAVE_EOF_PREFIX result_type const eof; + typedef lex_iterator_functor_shim unique; + typedef cpplexer::lex_input_interface<TokenT>* shared; + + template <typename MultiPass> + static result_type& get_next(MultiPass& mp, result_type& result) + { + return mp.shared()->ftor->get(result); + } + + // this will be called whenever the last reference to a multi_pass will + // be released + template <typename MultiPass> + static void destroy(MultiPass& mp) + { + delete mp.shared()->ftor; + } + + template <typename MultiPass> + static void set_position(MultiPass& mp, position_type const &pos) + { + mp.shared()->ftor->set_position(pos); + } + +private: + boost::shared_ptr<cpplexer::lex_input_interface<TokenT> > functor_ptr; +}; + +#if 0 != __COMO_VERSION__ || !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) +/////////////////////////////////////////////////////////////////////////////// +// eof token +template <typename TokenT> +typename lex_iterator_functor_shim<TokenT>::result_type const + lex_iterator_functor_shim<TokenT>::eof = + typename lex_iterator_functor_shim<TokenT>::result_type(); +#endif // 0 != __COMO_VERSION__ + +/////////////////////////////////////////////////////////////////////////////// +} // namespace impl + +/////////////////////////////////////////////////////////////////////////////// +// +// lex_iterator +// +// A generic C++ lexer interface class, which allows to plug in different +// lexer implementations (template parameter LexT). The following +// requirement apply: +// +// - the lexer type should have a function implemented, which returnes +// the next lexed token from the input stream: +// typename LexT::token_type get(); +// - at the end of the input stream this function should return the +// eof token equivalent +// - the lexer should implement a constructor taking two iterators +// pointing to the beginning and the end of the input stream and +// a third parameter containing the name of the parsed input file +// +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Divide the given functor type into its components (unique and shared) +// and build a std::pair from these parts +template <typename FunctorData> +struct make_multi_pass +{ + typedef + std::pair<typename FunctorData::unique, typename FunctorData::shared> + functor_data_type; + typedef typename FunctorData::result_type result_type; + + typedef boost::spirit::iterator_policies::split_functor_input input_policy; + typedef boost::spirit::iterator_policies::ref_counted ownership_policy; +#if defined(BOOST_WAVE_DEBUG) + typedef boost::spirit::iterator_policies::buf_id_check check_policy; +#else + typedef boost::spirit::iterator_policies::no_check check_policy; +#endif + typedef boost::spirit::iterator_policies::split_std_deque storage_policy; + + typedef boost::spirit::iterator_policies::default_policy< + ownership_policy, check_policy, input_policy, storage_policy> + policy_type; + typedef boost::spirit::multi_pass<functor_data_type, policy_type> type; +}; + +/////////////////////////////////////////////////////////////////////////////// +template <typename TokenT> +class lex_iterator +: public make_multi_pass<impl::lex_iterator_functor_shim<TokenT> >::type +{ + typedef impl::lex_iterator_functor_shim<TokenT> input_policy_type; + + typedef typename make_multi_pass<input_policy_type>::type base_type; + typedef typename make_multi_pass<input_policy_type>::functor_data_type + functor_data_type; + + typedef typename input_policy_type::unique unique_functor_type; + typedef typename input_policy_type::shared shared_functor_type; + +public: + typedef TokenT token_type; + + lex_iterator() + {} + + template <typename IteratorT> + lex_iterator(IteratorT const &first, IteratorT const &last, + typename TokenT::position_type const &pos, + boost::wave::language_support language) + : base_type( + functor_data_type( + unique_functor_type(), + cpplexer::lex_input_interface_generator<TokenT> + ::new_lexer(first, last, pos, language) + ) + ) + {} + + void set_position(typename TokenT::position_type const &pos) + { + typedef typename TokenT::position_type position_type; + + // set the new position in the current token + token_type const& currtoken = this->base_type::dereference(*this); + position_type currpos = currtoken.get_position(); + currpos.set_file(pos.get_file()); + currpos.set_line(pos.get_line()); + const_cast<token_type&>(currtoken).set_position(currpos); + + // set the new position for future tokens as well + unique_functor_type::set_position(*this, currpos); + } + +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + // this sample does no include guard detection + bool has_include_guards(std::string&) const { return false; } +#endif +}; + +/////////////////////////////////////////////////////////////////////////////// +} // namespace idllexer +} // namespace wave +} // namespace boost + +#undef BOOST_WAVE_EOF_PREFIX + +#endif // !defined(IDL_LEX_ITERATOR_HPP_7926F865_E02F_4950_9EB5_5F453C9FF953_INCLUDED) diff --git a/src/boost/libs/wave/samples/waveidl/idllexer/idl_re.cpp b/src/boost/libs/wave/samples/waveidl/idllexer/idl_re.cpp new file mode 100644 index 00000000..ff8bf446 --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/idllexer/idl_re.cpp @@ -0,0 +1,3755 @@ +/* Generated by re2c 0.13.5 on Fri May 22 17:28:34 2009 */ +#line 1 "idl.re" +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: IDL lexer + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include <ctime> +#include <cstdlib> +#include <cstdio> +#include <cstring> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> + +#include <boost/config.hpp> + +#if defined(BOOST_HAS_UNISTD_H) +#include <unistd.h> +#else +#include <io.h> +#endif + +#include <boost/assert.hpp> +#include <boost/detail/workaround.hpp> + +// reuse the token ids and re2c helper functions from the default C++ lexer +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/re2clex/aq.hpp> +#include <boost/wave/cpplexer/re2clex/scanner.hpp> +#include <boost/wave/cpplexer/cpplexer_exceptions.hpp> + +#include "idl_re.hpp" + +#if defined(_MSC_VER) && !defined(__COMO__) +#pragma warning (disable: 4101) // 'foo' : unreferenced local variable +#pragma warning (disable: 4102) // 'foo' : unreferenced label +#endif + +#define BOOST_WAVE_BSIZE 196608 + +#define YYCTYPE uchar +#define YYCURSOR cursor +#define YYLIMIT s->lim +#define YYMARKER s->ptr +#define YYFILL(n) {cursor = fill(s, cursor);} + +//#define BOOST_WAVE_RET(i) {s->cur = cursor; return (i);} +#define BOOST_WAVE_RET(i) \ + { \ + s->line += count_backslash_newlines(s, cursor); \ + s->cur = cursor; \ + return (i); \ + } \ + /**/ + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace idllexer { +namespace re2clex { + +#define RE2C_ASSERT BOOST_ASSERT + +int +get_one_char(boost::wave::cpplexer::re2clex::Scanner *s) +{ + using namespace boost::wave::cpplexer::re2clex; + if (0 != s->act) { + RE2C_ASSERT(s->first != 0 && s->last != 0); + RE2C_ASSERT(s->first <= s->act && s->act <= s->last); + if (s->act < s->last) + return *(s->act)++; + } + return -1; +} + +std::ptrdiff_t +rewind_stream (boost::wave::cpplexer::re2clex::Scanner *s, int cnt) +{ + if (0 != s->act) { + RE2C_ASSERT(s->first != 0 && s->last != 0); + s->act += cnt; + RE2C_ASSERT(s->first <= s->act && s->act <= s->last); + return s->act - s->first; + } + return 0; +} + +std::size_t +get_first_eol_offset(boost::wave::cpplexer::re2clex::Scanner* s) +{ + if (!AQ_EMPTY(s->eol_offsets)) + { + return s->eol_offsets->queue[s->eol_offsets->head]; + } + else + { + return (unsigned int)-1; + } +} + +void +adjust_eol_offsets(boost::wave::cpplexer::re2clex::Scanner* s, + std::size_t adjustment) +{ + boost::wave::cpplexer::re2clex::aq_queue q; + std::size_t i; + + if (!s->eol_offsets) + s->eol_offsets = boost::wave::cpplexer::re2clex::aq_create(); + + q = s->eol_offsets; + + if (AQ_EMPTY(q)) + return; + + i = q->head; + while (i != q->tail) + { + if (adjustment > q->queue[i]) + q->queue[i] = 0; + else + q->queue[i] -= adjustment; + ++i; + if (i == q->max_size) + i = 0; + } + if (adjustment > q->queue[i]) + q->queue[i] = 0; + else + q->queue[i] -= adjustment; +} + +int +count_backslash_newlines(boost::wave::cpplexer::re2clex::Scanner *s, + boost::wave::cpplexer::re2clex::uchar *cursor) +{ + using namespace boost::wave::cpplexer::re2clex; + + std::size_t diff, offset; + int skipped = 0; + + /* figure out how many backslash-newlines skipped over unknowingly. */ + diff = cursor - s->bot; + offset = get_first_eol_offset(s); + while (offset <= diff && offset != (unsigned int)-1) + { + skipped++; + boost::wave::cpplexer::re2clex::aq_pop(s->eol_offsets); + offset = get_first_eol_offset(s); + } + return skipped; +} + +bool is_backslash( + boost::wave::cpplexer::re2clex::uchar *p, + boost::wave::cpplexer::re2clex::uchar *end, int &len) +{ + if (*p == '\\') { + len = 1; + return true; + } + else if (*p == '?' && *(p+1) == '?' && (p+2 < end && *(p+2) == '/')) { + len = 3; + return true; + } + return false; +} + +boost::wave::cpplexer::re2clex::uchar * +fill(boost::wave::cpplexer::re2clex::Scanner *s, + boost::wave::cpplexer::re2clex::uchar *cursor) +{ + using namespace std; // some systems have memcpy etc. in namespace std + using namespace boost::wave::cpplexer::re2clex; + + if(!s->eof) + { + uchar* p; + std::ptrdiff_t cnt = s->tok - s->bot; + if(cnt) + { + memcpy(s->bot, s->tok, s->lim - s->tok); + s->tok = s->bot; + s->ptr -= cnt; + cursor -= cnt; + s->lim -= cnt; + adjust_eol_offsets(s, cnt); + } + + if((s->top - s->lim) < BOOST_WAVE_BSIZE) + { + uchar *buf = (uchar*) malloc(((s->lim - s->bot) + BOOST_WAVE_BSIZE)*sizeof(uchar)); + if (buf == 0) + { + using namespace std; // some systems have printf in std + if (0 != s->error_proc) { + (*s->error_proc)(s, + cpplexer::lexing_exception::unexpected_error, + "Out of memory!"); + } + else + printf("Out of memory!\n"); + + /* get the scanner to stop */ + *cursor = 0; + return cursor; + } + + memcpy(buf, s->tok, s->lim - s->tok); + s->tok = buf; + s->ptr = &buf[s->ptr - s->bot]; + cursor = &buf[cursor - s->bot]; + s->lim = &buf[s->lim - s->bot]; + s->top = &s->lim[BOOST_WAVE_BSIZE]; + free(s->bot); + s->bot = buf; + } + + if (s->act != 0) { + cnt = s->last - s->act; + if (cnt > BOOST_WAVE_BSIZE) + cnt = BOOST_WAVE_BSIZE; + memcpy(s->lim, s->act, cnt); + s->act += cnt; + if (cnt != BOOST_WAVE_BSIZE) + { + s->eof = &s->lim[cnt]; *(s->eof)++ = '\0'; + } + } + + /* backslash-newline erasing time */ + + /* first scan for backslash-newline and erase them */ + for (p = s->lim; p < s->lim + cnt - 2; ++p) + { + int len = 0; + if (is_backslash(p, s->lim + cnt, len)) + { + if (*(p+len) == '\n') + { + int offset = len + 1; + memmove(p, p + offset, s->lim + cnt - p - offset); + cnt -= offset; + --p; + aq_enqueue(s->eol_offsets, p - s->bot + 1); + } + else if (*(p+len) == '\r') + { + if (*(p+len+1) == '\n') + { + int offset = len + 2; + memmove(p, p + offset, s->lim + cnt - p - offset); + cnt -= offset; + --p; + } + else + { + int offset = len + 1; + memmove(p, p + offset, s->lim + cnt - p - offset); + cnt -= offset; + --p; + } + aq_enqueue(s->eol_offsets, p - s->bot + 1); + } + } + } + + /* FIXME: the following code should be fixed to recognize correctly the + trigraph backslash token */ + + /* check to see if what we just read ends in a backslash */ + if (cnt >= 2) + { + uchar last = s->lim[cnt-1]; + uchar last2 = s->lim[cnt-2]; + /* check \ EOB */ + if (last == '\\') + { + int next = get_one_char(s); + /* check for \ \n or \ \r or \ \r \n straddling the border */ + if (next == '\n') + { + --cnt; /* chop the final \, we've already read the \n. */ + boost::wave::cpplexer::re2clex::aq_enqueue(s->eol_offsets, + cnt + (s->lim - s->bot)); + } + else if (next == '\r') + { + int next2 = get_one_char(s); + if (next2 == '\n') + { + --cnt; /* skip the backslash */ + } + else + { + /* rewind one, and skip one char */ + rewind_stream(s, -1); + --cnt; + } + boost::wave::cpplexer::re2clex::aq_enqueue(s->eol_offsets, + cnt + (s->lim - s->bot)); + } + else if (next != -1) /* -1 means end of file */ + { + /* next was something else, so rewind the stream */ + rewind_stream(s, -1); + } + } + /* check \ \r EOB */ + else if (last == '\r' && last2 == '\\') + { + int next = get_one_char(s); + if (next == '\n') + { + cnt -= 2; /* skip the \ \r */ + } + else + { + /* rewind one, and skip two chars */ + rewind_stream(s, -1); + cnt -= 2; + } + boost::wave::cpplexer::re2clex::aq_enqueue(s->eol_offsets, + cnt + (s->lim - s->bot)); + } + /* check \ \n EOB */ + else if (last == '\n' && last2 == '\\') + { + cnt -= 2; + boost::wave::cpplexer::re2clex::aq_enqueue(s->eol_offsets, + cnt + (s->lim - s->bot)); + } + } + + s->lim += cnt; + if (s->eof) /* eof needs adjusting if we erased backslash-newlines */ + { + s->eof = s->lim; + *(s->eof)++ = '\0'; + } + } + return cursor; +} + +boost::wave::token_id +scan(boost::wave::cpplexer::re2clex::Scanner *s) +{ + using namespace boost::wave::cpplexer::re2clex; + + uchar *cursor = s->tok = s->cur; + +#line 378 "idl.re" + + + +#line 366 "idl_re.cpp" +{ + YYCTYPE yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + /* table 1 .. 8: 0 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 60, 32, 56, 56, 64, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 60, 56, 40, 56, 56, 56, 56, 56, + 56, 56, 152, 56, 56, 56, 56, 56, + 59, 59, 59, 59, 59, 59, 59, 59, + 58, 58, 56, 56, 56, 56, 48, 56, + 56, 58, 58, 58, 58, 58, 58, 58, + 58, 58, 58, 58, 58, 58, 58, 58, + 58, 58, 58, 58, 58, 58, 58, 58, + 58, 58, 58, 56, 56, 56, 56, 58, + 56, 58, 58, 58, 58, 58, 58, 58, + 58, 58, 58, 58, 58, 58, 58, 58, + 58, 58, 58, 58, 58, 58, 58, 58, + 58, 58, 58, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, + /* table 9 .. 15: 256 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 70, 0, 70, 70, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 70, 68, 64, 68, 68, 68, 68, 4, + 68, 68, 68, 68, 68, 68, 68, 68, + 204, 204, 204, 204, 204, 204, 204, 204, + 204, 204, 68, 68, 68, 68, 68, 16, + 68, 76, 76, 76, 76, 76, 76, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 32, 68, 68, 68, + 68, 76, 76, 76, 76, 76, 76, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, + }; + + if ((YYLIMIT - YYCURSOR) < 12) YYFILL(12); + yych = *YYCURSOR; + switch (yych) { + case 0x00: goto yy69; + case '\t': + case '\v': + case '\f': + case ' ': goto yy64; + case '\n': goto yy66; + case '\r': goto yy68; + case '!': goto yy45; + case '"': goto yy63; + case '#': goto yy15; + case '%': goto yy35; + case '&': goto yy39; + case '\'': goto yy62; + case '(': goto yy17; + case ')': goto yy19; + case '*': goto yy33; + case '+': goto yy29; + case ',': goto yy53; + case '-': goto yy31; + case '.': goto yy27; + case '/': goto yy2; + case '0': goto yy59; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': goto yy61; + case ':': goto yy23; + case ';': goto yy21; + case '<': goto yy49; + case '=': goto yy47; + case '>': goto yy51; + case '?': goto yy25; + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'G': + case 'H': + case 'I': + case 'J': + case 'K': + case 'M': + case 'N': + case 'O': + case 'P': + case 'Q': + case 'R': + case 'S': + case 'U': + case 'V': + case 'W': + case 'X': + case 'Y': + case 'Z': + case '_': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'g': + case 'h': + case 'i': + case 'j': + case 'k': + case 'l': + case 'm': + case 'n': + case 'o': + case 'p': + case 'q': + case 'r': + case 's': + case 't': + case 'u': + case 'v': + case 'w': + case 'x': + case 'y': + case 'z': goto yy55; + case 'F': goto yy6; + case 'L': goto yy56; + case 'T': goto yy4; + case '[': goto yy11; + case '\\': goto yy57; + case ']': goto yy13; + case '^': goto yy37; + case '{': goto yy7; + case '|': goto yy41; + case '}': goto yy9; + case '~': goto yy43; + default: goto yy71; + } +yy2: + ++YYCURSOR; + if ((yych = *YYCURSOR) == '*') goto yy356; + if (yych == '/') goto yy354; +#line 402 "idl.re" + { BOOST_WAVE_RET(T_DIVIDE); } +#line 548 "idl_re.cpp" +yy4: + yyaccept = 0; + yych = *(YYMARKER = ++YYCURSOR); + if (yych == 'R') goto yy350; + goto yy202; +yy5: +#line 425 "idl.re" + { BOOST_WAVE_RET(T_IDENTIFIER); } +#line 557 "idl_re.cpp" +yy6: + yyaccept = 0; + yych = *(YYMARKER = ++YYCURSOR); + if (yych == 'A') goto yy345; + goto yy202; +yy7: + ++YYCURSOR; +#line 387 "idl.re" + { BOOST_WAVE_RET(T_LEFTBRACE); } +#line 567 "idl_re.cpp" +yy9: + ++YYCURSOR; +#line 388 "idl.re" + { BOOST_WAVE_RET(T_RIGHTBRACE); } +#line 572 "idl_re.cpp" +yy11: + ++YYCURSOR; +#line 389 "idl.re" + { BOOST_WAVE_RET(T_LEFTBRACKET); } +#line 577 "idl_re.cpp" +yy13: + ++YYCURSOR; +#line 390 "idl.re" + { BOOST_WAVE_RET(T_RIGHTBRACKET); } +#line 582 "idl_re.cpp" +yy15: + yyaccept = 1; + yych = *(YYMARKER = ++YYCURSOR); + if (yych <= 'e') { + if (yych <= '"') { + if (yych <= '\t') { + if (yych >= '\t') goto yy239; + } else { + if (yych == ' ') goto yy239; + } + } else { + if (yych <= '.') { + if (yych <= '#') goto yy343; + } else { + if (yych <= '/') goto yy239; + if (yych >= 'd') goto yy239; + } + } + } else { + if (yych <= 'o') { + if (yych <= 'i') { + if (yych >= 'i') goto yy239; + } else { + if (yych == 'l') goto yy239; + } + } else { + if (yych <= 'u') { + if (yych <= 'p') goto yy239; + if (yych >= 'u') goto yy239; + } else { + if (yych == 'w') goto yy239; + } + } + } +yy16: +#line 391 "idl.re" + { BOOST_WAVE_RET(T_POUND); } +#line 620 "idl_re.cpp" +yy17: + ++YYCURSOR; +#line 393 "idl.re" + { BOOST_WAVE_RET(T_LEFTPAREN); } +#line 625 "idl_re.cpp" +yy19: + ++YYCURSOR; +#line 394 "idl.re" + { BOOST_WAVE_RET(T_RIGHTPAREN); } +#line 630 "idl_re.cpp" +yy21: + ++YYCURSOR; +#line 395 "idl.re" + { BOOST_WAVE_RET(T_SEMICOLON); } +#line 635 "idl_re.cpp" +yy23: + ++YYCURSOR; +#line 396 "idl.re" + { BOOST_WAVE_RET(T_COLON); } +#line 640 "idl_re.cpp" +yy25: + yyaccept = 2; + yych = *(YYMARKER = ++YYCURSOR); + if (yych == '?') goto yy341; +yy26: +#line 397 "idl.re" + { BOOST_WAVE_RET(T_QUESTION_MARK); } +#line 648 "idl_re.cpp" +yy27: + ++YYCURSOR; + if ((yych = *YYCURSOR) <= '/') goto yy28; + if (yych <= '9') goto yy168; +yy28: +#line 398 "idl.re" + { BOOST_WAVE_RET(T_DOT); } +#line 656 "idl_re.cpp" +yy29: + ++YYCURSOR; + if ((yych = *YYCURSOR) == '+') goto yy339; +#line 399 "idl.re" + { BOOST_WAVE_RET(T_PLUS); } +#line 662 "idl_re.cpp" +yy31: + ++YYCURSOR; + if ((yych = *YYCURSOR) == '-') goto yy337; +#line 400 "idl.re" + { BOOST_WAVE_RET(T_MINUS); } +#line 668 "idl_re.cpp" +yy33: + ++YYCURSOR; +#line 401 "idl.re" + { BOOST_WAVE_RET(T_STAR); } +#line 673 "idl_re.cpp" +yy35: + yyaccept = 3; + yych = *(YYMARKER = ++YYCURSOR); + if (yych == ':') goto yy238; +yy36: +#line 403 "idl.re" + { BOOST_WAVE_RET(T_PERCENT); } +#line 681 "idl_re.cpp" +yy37: + ++YYCURSOR; +#line 404 "idl.re" + { BOOST_WAVE_RET(T_XOR); } +#line 686 "idl_re.cpp" +yy39: + ++YYCURSOR; + if ((yych = *YYCURSOR) == '&') goto yy236; +#line 405 "idl.re" + { BOOST_WAVE_RET(T_AND); } +#line 692 "idl_re.cpp" +yy41: + ++YYCURSOR; + if ((yych = *YYCURSOR) == '|') goto yy234; +#line 406 "idl.re" + { BOOST_WAVE_RET(T_OR); } +#line 698 "idl_re.cpp" +yy43: + ++YYCURSOR; +#line 407 "idl.re" + { BOOST_WAVE_RET(T_COMPL); } +#line 703 "idl_re.cpp" +yy45: + ++YYCURSOR; + if ((yych = *YYCURSOR) == '=') goto yy232; +#line 408 "idl.re" + { BOOST_WAVE_RET(T_NOT); } +#line 709 "idl_re.cpp" +yy47: + ++YYCURSOR; + if ((yych = *YYCURSOR) == '=') goto yy230; +#line 409 "idl.re" + { BOOST_WAVE_RET(T_ASSIGN); } +#line 715 "idl_re.cpp" +yy49: + ++YYCURSOR; + if ((yych = *YYCURSOR) <= ';') goto yy50; + if (yych <= '<') goto yy228; + if (yych <= '=') goto yy226; +yy50: +#line 410 "idl.re" + { BOOST_WAVE_RET(T_LESS); } +#line 724 "idl_re.cpp" +yy51: + ++YYCURSOR; + if ((yych = *YYCURSOR) <= '<') goto yy52; + if (yych <= '=') goto yy222; + if (yych <= '>') goto yy224; +yy52: +#line 411 "idl.re" + { BOOST_WAVE_RET(T_GREATER); } +#line 733 "idl_re.cpp" +yy53: + ++YYCURSOR; +#line 422 "idl.re" + { BOOST_WAVE_RET(T_COMMA); } +#line 738 "idl_re.cpp" +yy55: + yyaccept = 0; + yych = *(YYMARKER = ++YYCURSOR); + goto yy202; +yy56: + yyaccept = 0; + yych = *(YYMARKER = ++YYCURSOR); + if (yybm[0+yych] & 2) { + goto yy201; + } + if (yych <= '\'') { + if (yych == '"') goto yy75; + if (yych <= '&') goto yy5; + goto yy221; + } else { + if (yych <= '?') { + if (yych <= '>') goto yy5; + goto yy204; + } else { + if (yych == '\\') goto yy203; + goto yy5; + } + } +yy57: + yyaccept = 4; + yych = *(YYMARKER = ++YYCURSOR); + if (yych == 'U') goto yy193; + if (yych == 'u') goto yy192; +yy58: +#line 492 "idl.re" + { + BOOST_WAVE_RET(TOKEN_FROM_ID(*s->tok, UnknownTokenType)); + } +#line 772 "idl_re.cpp" +yy59: + yyaccept = 5; + yych = *(YYMARKER = ++YYCURSOR); + if (yybm[0+yych] & 1) { + goto yy185; + } + if (yych <= 'U') { + if (yych <= 'C') { + if (yych <= '.') { + if (yych >= '.') goto yy168; + } else { + if (yych <= '/') goto yy60; + if (yych <= '9') goto yy187; + } + } else { + if (yych <= 'K') { + if (yych <= 'D') goto yy164; + if (yych <= 'E') goto yy171; + } else { + if (yych <= 'L') goto yy173; + if (yych >= 'U') goto yy172; + } + } + } else { + if (yych <= 'k') { + if (yych <= 'c') { + if (yych == 'X') goto yy189; + } else { + if (yych <= 'd') goto yy164; + if (yych <= 'e') goto yy171; + } + } else { + if (yych <= 'u') { + if (yych <= 'l') goto yy173; + if (yych >= 'u') goto yy172; + } else { + if (yych == 'x') goto yy189; + } + } + } +yy60: +#line 428 "idl.re" + { BOOST_WAVE_RET(T_INTLIT); } +#line 816 "idl_re.cpp" +yy61: + yyaccept = 5; + yych = *(YYMARKER = ++YYCURSOR); + if (yybm[256+yych] & 128) { + goto yy166; + } + if (yych <= 'T') { + if (yych <= 'D') { + if (yych == '.') goto yy168; + if (yych <= 'C') goto yy60; + goto yy164; + } else { + if (yych <= 'E') goto yy171; + if (yych == 'L') goto yy173; + goto yy60; + } + } else { + if (yych <= 'e') { + if (yych <= 'U') goto yy172; + if (yych <= 'c') goto yy60; + if (yych <= 'd') goto yy164; + goto yy171; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy60; + goto yy173; + } else { + if (yych == 'u') goto yy172; + goto yy60; + } + } + } +yy62: + yyaccept = 4; + yych = *(YYMARKER = ++YYCURSOR); + if (yych <= '\f') { + if (yych == '\t') goto yy121; + if (yych <= '\n') goto yy58; + goto yy121; + } else { + if (yych <= 0x1F) goto yy58; + if (yych == '\'') goto yy58; + goto yy121; + } +yy63: + yyaccept = 4; + yych = *(YYMARKER = ++YYCURSOR); + if (yych <= '\n') { + if (yych == '\t') goto yy76; + goto yy58; + } else { + if (yych <= '\f') goto yy76; + if (yych <= 0x1F) goto yy58; + goto yy76; + } +yy64: + ++YYCURSOR; + yych = *YYCURSOR; + goto yy74; +yy65: +#line 467 "idl.re" + { BOOST_WAVE_RET(T_SPACE); } +#line 879 "idl_re.cpp" +yy66: + ++YYCURSOR; +yy67: +#line 470 "idl.re" + { + s->line++; + BOOST_WAVE_RET(T_NEWLINE); + } +#line 888 "idl_re.cpp" +yy68: + yych = *++YYCURSOR; + if (yych == '\n') goto yy72; + goto yy67; +yy69: + ++YYCURSOR; +#line 476 "idl.re" + { + if(cursor != s->eof) + { + using namespace std; // some systems have printf in std + if (0 != s->error_proc) { + (*s->error_proc)(s, + cpplexer::lexing_exception::generic_lexing_error, + "'\\000' in input stream"); + } + else + printf("Error: 0 in file\n"); + } + BOOST_WAVE_RET(T_EOF); + } +#line 910 "idl_re.cpp" +yy71: + yych = *++YYCURSOR; + goto yy58; +yy72: + yych = *++YYCURSOR; + goto yy67; +yy73: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; +yy74: + if (yybm[256+yych] & 2) { + goto yy73; + } + goto yy65; +yy75: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; +yy76: + if (yybm[256+yych] & 4) { + goto yy75; + } + if (yych <= '!') goto yy77; + if (yych <= '"') goto yy80; + if (yych <= '[') goto yy78; + goto yy79; +yy77: + YYCURSOR = YYMARKER; + if (yyaccept <= 6) { + if (yyaccept <= 3) { + if (yyaccept <= 1) { + if (yyaccept <= 0) { + goto yy5; + } else { + goto yy16; + } + } else { + if (yyaccept <= 2) { + goto yy26; + } else { + goto yy36; + } + } + } else { + if (yyaccept <= 5) { + if (yyaccept <= 4) { + goto yy58; + } else { + goto yy60; + } + } else { + goto yy81; + } + } + } else { + if (yyaccept <= 9) { + if (yyaccept <= 8) { + if (yyaccept <= 7) { + goto yy131; + } else { + goto yy170; + } + } else { + goto yy294; + } + } else { + if (yyaccept <= 11) { + if (yyaccept <= 10) { + goto yy302; + } else { + goto yy349; + } + } else { + goto yy353; + } + } + } +yy78: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 4) { + goto yy75; + } + if (yych <= '!') goto yy77; + if (yych <= '"') goto yy80; + if (yych <= '[') goto yy91; +yy79: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '`') { + if (yych <= '7') { + if (yych <= '&') { + if (yych == '"') goto yy75; + goto yy77; + } else { + if (yych <= '\'') goto yy75; + if (yych <= '/') goto yy77; + goto yy86; + } + } else { + if (yych <= 'T') { + if (yych == '?') goto yy84; + goto yy77; + } else { + if (yych <= 'U') goto yy83; + if (yych == '\\') goto yy75; + goto yy77; + } + } + } else { + if (yych <= 'r') { + if (yych <= 'f') { + if (yych <= 'b') goto yy75; + if (yych <= 'e') goto yy77; + goto yy75; + } else { + if (yych == 'n') goto yy75; + if (yych <= 'q') goto yy77; + goto yy75; + } + } else { + if (yych <= 'u') { + if (yych <= 's') goto yy77; + if (yych <= 't') goto yy75; + goto yy82; + } else { + if (yych <= 'v') goto yy75; + if (yych == 'x') goto yy85; + goto yy77; + } + } + } +yy80: + ++YYCURSOR; +yy81: +#line 440 "idl.re" + { BOOST_WAVE_RET(T_STRINGLIT); } +#line 1051 "idl_re.cpp" +yy82: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy117; + goto yy77; + } else { + if (yych <= 'F') goto yy117; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy117; + goto yy77; + } +yy83: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy110; + goto yy77; + } else { + if (yych <= 'F') goto yy110; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy110; + goto yy77; + } +yy84: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 4) { + goto yy75; + } + if (yych <= '!') goto yy77; + if (yych <= '"') goto yy80; + if (yych <= '[') goto yy90; + goto yy79; +yy85: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 8) { + goto yy88; + } + goto yy77; +yy86: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '"') { + if (yych <= '\n') { + if (yych == '\t') goto yy75; + goto yy77; + } else { + if (yych <= '\f') goto yy75; + if (yych <= 0x1F) goto yy77; + if (yych <= '!') goto yy75; + goto yy80; + } + } else { + if (yych <= '>') { + if (yych <= '/') goto yy75; + if (yych >= '8') goto yy75; + } else { + if (yych <= '?') goto yy78; + if (yych == '\\') goto yy79; + goto yy75; + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 4) { + goto yy75; + } + if (yych <= '!') goto yy77; + if (yych <= '"') goto yy80; + if (yych <= '[') goto yy78; + goto yy79; +yy88: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 8) { + goto yy88; + } + if (yych <= '!') { + if (yych <= '\n') { + if (yych == '\t') goto yy75; + goto yy77; + } else { + if (yych <= '\f') goto yy75; + if (yych <= 0x1F) goto yy77; + goto yy75; + } + } else { + if (yych <= '?') { + if (yych <= '"') goto yy80; + if (yych <= '>') goto yy75; + goto yy78; + } else { + if (yych == '\\') goto yy79; + goto yy75; + } + } +yy90: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 4) { + goto yy75; + } + if (yych <= '!') goto yy77; + if (yych <= '"') goto yy80; + if (yych >= '\\') goto yy79; +yy91: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 16) { + goto yy91; + } + if (yych <= '!') { + if (yych <= '\n') { + if (yych == '\t') goto yy75; + goto yy77; + } else { + if (yych <= '\f') goto yy75; + if (yych <= 0x1F) goto yy77; + goto yy75; + } + } else { + if (yych <= '/') { + if (yych <= '"') goto yy80; + if (yych <= '.') goto yy75; + } else { + if (yych == '\\') goto yy79; + goto yy75; + } + } +yy93: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 32) { + goto yy93; + } + if (yych <= '7') { + if (yych <= '\f') { + if (yych == '\t') goto yy75; + if (yych <= '\n') goto yy77; + goto yy75; + } else { + if (yych <= '!') { + if (yych <= 0x1F) goto yy77; + goto yy75; + } else { + if (yych <= '"') goto yy97; + if (yych <= '/') goto yy75; + goto yy86; + } + } + } else { + if (yych <= 'U') { + if (yych == '?') goto yy98; + if (yych <= 'T') goto yy75; + goto yy96; + } else { + if (yych <= 'u') { + if (yych <= 't') goto yy75; + } else { + if (yych == 'x') goto yy88; + goto yy75; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy75; + if (yych <= '\n') goto yy77; + goto yy75; + } else { + if (yych <= '!') { + if (yych <= 0x1F) goto yy77; + goto yy75; + } else { + if (yych <= '"') goto yy80; + if (yych <= '/') goto yy75; + goto yy107; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy78; + if (yych <= '@') goto yy75; + goto yy107; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy75; + goto yy79; + } else { + if (yych <= '`') goto yy75; + if (yych <= 'f') goto yy107; + goto yy75; + } + } + } +yy96: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy75; + if (yych <= '\n') goto yy77; + goto yy75; + } else { + if (yych <= '!') { + if (yych <= 0x1F) goto yy77; + goto yy75; + } else { + if (yych <= '"') goto yy80; + if (yych <= '/') goto yy75; + goto yy100; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy78; + if (yych <= '@') goto yy75; + goto yy100; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy75; + goto yy79; + } else { + if (yych <= '`') goto yy75; + if (yych <= 'f') goto yy100; + goto yy75; + } + } + } +yy97: + yyaccept = 6; + YYMARKER = ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 4) { + goto yy75; + } + if (yych <= '!') goto yy81; + if (yych <= '"') goto yy80; + if (yych <= '[') goto yy78; + goto yy79; +yy98: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 4) { + goto yy75; + } + if (yych <= '!') goto yy77; + if (yych <= '"') goto yy80; + if (yych >= '\\') goto yy79; + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 16) { + goto yy91; + } + if (yych <= '!') { + if (yych <= '\n') { + if (yych == '\t') goto yy75; + goto yy77; + } else { + if (yych <= '\f') goto yy75; + if (yych <= 0x1F) goto yy77; + goto yy75; + } + } else { + if (yych <= '/') { + if (yych <= '"') goto yy80; + if (yych <= '.') goto yy75; + goto yy93; + } else { + if (yych == '\\') goto yy79; + goto yy75; + } + } +yy100: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy75; + if (yych <= '\n') goto yy77; + goto yy75; + } else { + if (yych <= '!') { + if (yych <= 0x1F) goto yy77; + goto yy75; + } else { + if (yych <= '"') goto yy80; + if (yych <= '/') goto yy75; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy78; + if (yych <= '@') goto yy75; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy75; + goto yy79; + } else { + if (yych <= '`') goto yy75; + if (yych >= 'g') goto yy75; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy75; + if (yych <= '\n') goto yy77; + goto yy75; + } else { + if (yych <= '!') { + if (yych <= 0x1F) goto yy77; + goto yy75; + } else { + if (yych <= '"') goto yy80; + if (yych <= '/') goto yy75; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy78; + if (yych <= '@') goto yy75; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy75; + goto yy79; + } else { + if (yych <= '`') goto yy75; + if (yych >= 'g') goto yy75; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy75; + if (yych <= '\n') goto yy77; + goto yy75; + } else { + if (yych <= '!') { + if (yych <= 0x1F) goto yy77; + goto yy75; + } else { + if (yych <= '"') goto yy80; + if (yych <= '/') goto yy75; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy78; + if (yych <= '@') goto yy75; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy75; + goto yy79; + } else { + if (yych <= '`') goto yy75; + if (yych >= 'g') goto yy75; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy75; + if (yych <= '\n') goto yy77; + goto yy75; + } else { + if (yych <= '!') { + if (yych <= 0x1F) goto yy77; + goto yy75; + } else { + if (yych <= '"') goto yy80; + if (yych <= '/') goto yy75; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy78; + if (yych <= '@') goto yy75; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy75; + goto yy79; + } else { + if (yych <= '`') goto yy75; + if (yych >= 'g') goto yy75; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy75; + if (yych <= '\n') goto yy77; + goto yy75; + } else { + if (yych <= '!') { + if (yych <= 0x1F) goto yy77; + goto yy75; + } else { + if (yych <= '"') goto yy80; + if (yych <= '/') goto yy75; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy78; + if (yych <= '@') goto yy75; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy75; + goto yy79; + } else { + if (yych <= '`') goto yy75; + if (yych >= 'g') goto yy75; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy75; + if (yych <= '\n') goto yy77; + goto yy75; + } else { + if (yych <= '!') { + if (yych <= 0x1F) goto yy77; + goto yy75; + } else { + if (yych <= '"') goto yy80; + if (yych <= '/') goto yy75; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy78; + if (yych <= '@') goto yy75; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy75; + goto yy79; + } else { + if (yych <= '`') goto yy75; + if (yych >= 'g') goto yy75; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 4) { + goto yy75; + } + if (yych <= '!') goto yy77; + if (yych <= '"') goto yy80; + if (yych <= '[') goto yy78; + goto yy79; +yy107: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy75; + if (yych <= '\n') goto yy77; + goto yy75; + } else { + if (yych <= '!') { + if (yych <= 0x1F) goto yy77; + goto yy75; + } else { + if (yych <= '"') goto yy80; + if (yych <= '/') goto yy75; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy78; + if (yych <= '@') goto yy75; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy75; + goto yy79; + } else { + if (yych <= '`') goto yy75; + if (yych >= 'g') goto yy75; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy75; + if (yych <= '\n') goto yy77; + goto yy75; + } else { + if (yych <= '!') { + if (yych <= 0x1F) goto yy77; + goto yy75; + } else { + if (yych <= '"') goto yy80; + if (yych <= '/') goto yy75; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy78; + if (yych <= '@') goto yy75; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy75; + goto yy79; + } else { + if (yych <= '`') goto yy75; + if (yych >= 'g') goto yy75; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 4) { + goto yy75; + } + if (yych <= '!') goto yy77; + if (yych <= '"') goto yy80; + if (yych <= '[') goto yy78; + goto yy79; +yy110: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy111; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy111: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy112; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy112: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy113; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy113: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy114; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy114: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy115; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy115: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy116; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy116: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy75; + goto yy77; + } else { + if (yych <= 'F') goto yy75; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy75; + goto yy77; + } +yy117: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy118; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy118: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy119; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy119: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy75; + goto yy77; + } else { + if (yych <= 'F') goto yy75; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy75; + goto yy77; + } +yy120: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; +yy121: + if (yybm[256+yych] & 64) { + goto yy120; + } + if (yych <= '&') goto yy77; + if (yych <= '\'') goto yy130; + if (yych >= '\\') goto yy123; +yy122: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 64) { + goto yy120; + } + if (yych <= '&') goto yy77; + if (yych <= '\'') goto yy130; + if (yych <= '[') goto yy135; +yy123: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '`') { + if (yych <= '7') { + if (yych <= '&') { + if (yych == '"') goto yy120; + goto yy77; + } else { + if (yych <= '\'') goto yy120; + if (yych <= '/') goto yy77; + goto yy128; + } + } else { + if (yych <= 'T') { + if (yych == '?') goto yy126; + goto yy77; + } else { + if (yych <= 'U') goto yy125; + if (yych == '\\') goto yy120; + goto yy77; + } + } + } else { + if (yych <= 'r') { + if (yych <= 'f') { + if (yych <= 'b') goto yy120; + if (yych <= 'e') goto yy77; + goto yy120; + } else { + if (yych == 'n') goto yy120; + if (yych <= 'q') goto yy77; + goto yy120; + } + } else { + if (yych <= 'u') { + if (yych <= 's') goto yy77; + if (yych <= 't') goto yy120; + } else { + if (yych <= 'v') goto yy120; + if (yych == 'x') goto yy127; + goto yy77; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy161; + goto yy77; + } else { + if (yych <= 'F') goto yy161; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy161; + goto yy77; + } +yy125: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy154; + goto yy77; + } else { + if (yych <= 'F') goto yy154; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy154; + goto yy77; + } +yy126: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 64) { + goto yy120; + } + if (yych <= '&') goto yy77; + if (yych <= '\'') goto yy130; + if (yych <= '[') goto yy134; + goto yy123; +yy127: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy132; + goto yy77; + } else { + if (yych <= 'F') goto yy132; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy132; + goto yy77; + } +yy128: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '\'') { + if (yych <= '\n') { + if (yych == '\t') goto yy120; + goto yy77; + } else { + if (yych <= '\f') goto yy120; + if (yych <= 0x1F) goto yy77; + if (yych <= '&') goto yy120; + goto yy130; + } + } else { + if (yych <= '>') { + if (yych <= '/') goto yy120; + if (yych >= '8') goto yy120; + } else { + if (yych <= '?') goto yy122; + if (yych == '\\') goto yy123; + goto yy120; + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 64) { + goto yy120; + } + if (yych <= '&') goto yy77; + if (yych <= '\'') goto yy130; + if (yych <= '[') goto yy122; + goto yy123; +yy130: + ++YYCURSOR; +yy131: +#line 437 "idl.re" + { BOOST_WAVE_RET(T_CHARLIT); } +#line 1898 "idl_re.cpp" +yy132: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy120; + if (yych <= '\n') goto yy77; + goto yy120; + } else { + if (yych <= '&') { + if (yych <= 0x1F) goto yy77; + goto yy120; + } else { + if (yych <= '\'') goto yy130; + if (yych <= '/') goto yy120; + goto yy132; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy122; + if (yych <= '@') goto yy120; + goto yy132; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy120; + goto yy123; + } else { + if (yych <= '`') goto yy120; + if (yych <= 'f') goto yy132; + goto yy120; + } + } + } +yy134: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 64) { + goto yy120; + } + if (yych <= '&') goto yy77; + if (yych <= '\'') goto yy130; + if (yych >= '\\') goto yy123; +yy135: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '\'') { + if (yych <= '\n') { + if (yych == '\t') goto yy120; + goto yy77; + } else { + if (yych <= '\f') goto yy120; + if (yych <= 0x1F) goto yy77; + if (yych <= '&') goto yy120; + goto yy130; + } + } else { + if (yych <= '>') { + if (yych != '/') goto yy120; + } else { + if (yych <= '?') goto yy135; + if (yych == '\\') goto yy123; + goto yy120; + } + } +yy137: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '>') { + if (yych <= 0x1F) { + if (yych <= '\t') { + if (yych <= 0x08) goto yy77; + goto yy120; + } else { + if (yych <= '\n') goto yy77; + if (yych <= '\f') goto yy120; + goto yy77; + } + } else { + if (yych <= '\'') { + if (yych <= '&') goto yy120; + goto yy141; + } else { + if (yych <= '/') goto yy120; + if (yych <= '7') goto yy128; + goto yy120; + } + } + } else { + if (yych <= '\\') { + if (yych <= 'T') { + if (yych <= '?') goto yy142; + goto yy120; + } else { + if (yych <= 'U') goto yy140; + if (yych <= '[') goto yy120; + goto yy137; + } + } else { + if (yych <= 'u') { + if (yych <= 't') goto yy120; + } else { + if (yych == 'x') goto yy132; + goto yy120; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy120; + if (yych <= '\n') goto yy77; + goto yy120; + } else { + if (yych <= '&') { + if (yych <= 0x1F) goto yy77; + goto yy120; + } else { + if (yych <= '\'') goto yy130; + if (yych <= '/') goto yy120; + goto yy151; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy122; + if (yych <= '@') goto yy120; + goto yy151; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy120; + goto yy123; + } else { + if (yych <= '`') goto yy120; + if (yych <= 'f') goto yy151; + goto yy120; + } + } + } +yy140: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy120; + if (yych <= '\n') goto yy77; + goto yy120; + } else { + if (yych <= '&') { + if (yych <= 0x1F) goto yy77; + goto yy120; + } else { + if (yych <= '\'') goto yy130; + if (yych <= '/') goto yy120; + goto yy144; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy122; + if (yych <= '@') goto yy120; + goto yy144; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy120; + goto yy123; + } else { + if (yych <= '`') goto yy120; + if (yych <= 'f') goto yy144; + goto yy120; + } + } + } +yy141: + yyaccept = 7; + YYMARKER = ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 64) { + goto yy120; + } + if (yych <= '&') goto yy131; + if (yych <= '\'') goto yy130; + if (yych <= '[') goto yy122; + goto yy123; +yy142: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 64) { + goto yy120; + } + if (yych <= '&') goto yy77; + if (yych <= '\'') goto yy130; + if (yych >= '\\') goto yy123; + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '\'') { + if (yych <= '\n') { + if (yych == '\t') goto yy120; + goto yy77; + } else { + if (yych <= '\f') goto yy120; + if (yych <= 0x1F) goto yy77; + if (yych <= '&') goto yy120; + goto yy130; + } + } else { + if (yych <= '>') { + if (yych == '/') goto yy137; + goto yy120; + } else { + if (yych <= '?') goto yy135; + if (yych == '\\') goto yy123; + goto yy120; + } + } +yy144: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy120; + if (yych <= '\n') goto yy77; + goto yy120; + } else { + if (yych <= '&') { + if (yych <= 0x1F) goto yy77; + goto yy120; + } else { + if (yych <= '\'') goto yy130; + if (yych <= '/') goto yy120; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy122; + if (yych <= '@') goto yy120; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy120; + goto yy123; + } else { + if (yych <= '`') goto yy120; + if (yych >= 'g') goto yy120; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy120; + if (yych <= '\n') goto yy77; + goto yy120; + } else { + if (yych <= '&') { + if (yych <= 0x1F) goto yy77; + goto yy120; + } else { + if (yych <= '\'') goto yy130; + if (yych <= '/') goto yy120; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy122; + if (yych <= '@') goto yy120; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy120; + goto yy123; + } else { + if (yych <= '`') goto yy120; + if (yych >= 'g') goto yy120; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy120; + if (yych <= '\n') goto yy77; + goto yy120; + } else { + if (yych <= '&') { + if (yych <= 0x1F) goto yy77; + goto yy120; + } else { + if (yych <= '\'') goto yy130; + if (yych <= '/') goto yy120; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy122; + if (yych <= '@') goto yy120; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy120; + goto yy123; + } else { + if (yych <= '`') goto yy120; + if (yych >= 'g') goto yy120; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy120; + if (yych <= '\n') goto yy77; + goto yy120; + } else { + if (yych <= '&') { + if (yych <= 0x1F) goto yy77; + goto yy120; + } else { + if (yych <= '\'') goto yy130; + if (yych <= '/') goto yy120; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy122; + if (yych <= '@') goto yy120; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy120; + goto yy123; + } else { + if (yych <= '`') goto yy120; + if (yych >= 'g') goto yy120; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy120; + if (yych <= '\n') goto yy77; + goto yy120; + } else { + if (yych <= '&') { + if (yych <= 0x1F) goto yy77; + goto yy120; + } else { + if (yych <= '\'') goto yy130; + if (yych <= '/') goto yy120; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy122; + if (yych <= '@') goto yy120; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy120; + goto yy123; + } else { + if (yych <= '`') goto yy120; + if (yych >= 'g') goto yy120; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy120; + if (yych <= '\n') goto yy77; + goto yy120; + } else { + if (yych <= '&') { + if (yych <= 0x1F) goto yy77; + goto yy120; + } else { + if (yych <= '\'') goto yy130; + if (yych <= '/') goto yy120; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy122; + if (yych <= '@') goto yy120; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy120; + goto yy123; + } else { + if (yych <= '`') goto yy120; + if (yych >= 'g') goto yy120; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 64) { + goto yy120; + } + if (yych <= '&') goto yy77; + if (yych <= '\'') goto yy130; + if (yych <= '[') goto yy122; + goto yy123; +yy151: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy120; + if (yych <= '\n') goto yy77; + goto yy120; + } else { + if (yych <= '&') { + if (yych <= 0x1F) goto yy77; + goto yy120; + } else { + if (yych <= '\'') goto yy130; + if (yych <= '/') goto yy120; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy122; + if (yych <= '@') goto yy120; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy120; + goto yy123; + } else { + if (yych <= '`') goto yy120; + if (yych >= 'g') goto yy120; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '9') { + if (yych <= '\f') { + if (yych == '\t') goto yy120; + if (yych <= '\n') goto yy77; + goto yy120; + } else { + if (yych <= '&') { + if (yych <= 0x1F) goto yy77; + goto yy120; + } else { + if (yych <= '\'') goto yy130; + if (yych <= '/') goto yy120; + } + } + } else { + if (yych <= 'F') { + if (yych == '?') goto yy122; + if (yych <= '@') goto yy120; + } else { + if (yych <= '\\') { + if (yych <= '[') goto yy120; + goto yy123; + } else { + if (yych <= '`') goto yy120; + if (yych >= 'g') goto yy120; + } + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[256+yych] & 64) { + goto yy120; + } + if (yych <= '&') goto yy77; + if (yych <= '\'') goto yy130; + if (yych <= '[') goto yy122; + goto yy123; +yy154: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy155; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy155: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy156; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy156: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy157; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy157: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy158; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy158: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy159; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy159: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy160; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy160: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy120; + goto yy77; + } else { + if (yych <= 'F') goto yy120; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy120; + goto yy77; + } +yy161: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy162; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy162: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy163; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy163: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy120; + goto yy77; + } else { + if (yych <= 'F') goto yy120; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy120; + goto yy77; + } +yy164: + ++YYCURSOR; +#line 434 "idl.re" + { BOOST_WAVE_RET(T_FIXEDPOINTLIT); } +#line 2522 "idl_re.cpp" +yy166: + yyaccept = 5; + YYMARKER = ++YYCURSOR; + if ((YYLIMIT - YYCURSOR) < 3) YYFILL(3); + yych = *YYCURSOR; + if (yybm[256+yych] & 128) { + goto yy166; + } + if (yych <= 'T') { + if (yych <= 'D') { + if (yych == '.') goto yy168; + if (yych <= 'C') goto yy60; + goto yy164; + } else { + if (yych <= 'E') goto yy171; + if (yych == 'L') goto yy173; + goto yy60; + } + } else { + if (yych <= 'e') { + if (yych <= 'U') goto yy172; + if (yych <= 'c') goto yy60; + if (yych <= 'd') goto yy164; + goto yy171; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy60; + goto yy173; + } else { + if (yych == 'u') goto yy172; + goto yy60; + } + } + } +yy168: + yyaccept = 8; + YYMARKER = ++YYCURSOR; + if ((YYLIMIT - YYCURSOR) < 3) YYFILL(3); + yych = *YYCURSOR; + if (yych <= 'K') { + if (yych <= 'C') { + if (yych <= '/') goto yy170; + if (yych <= '9') goto yy168; + } else { + if (yych <= 'D') goto yy164; + if (yych <= 'E') goto yy181; + if (yych <= 'F') goto yy178; + } + } else { + if (yych <= 'e') { + if (yych <= 'L') goto yy179; + if (yych <= 'c') goto yy170; + if (yych <= 'd') goto yy164; + goto yy181; + } else { + if (yych <= 'f') goto yy178; + if (yych == 'l') goto yy179; + } + } +yy170: +#line 431 "idl.re" + { BOOST_WAVE_RET(T_FLOATLIT); } +#line 2585 "idl_re.cpp" +yy171: + yych = *++YYCURSOR; + if (yych <= ',') { + if (yych == '+') goto yy175; + goto yy77; + } else { + if (yych <= '-') goto yy175; + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy176; + goto yy77; + } +yy172: + yych = *++YYCURSOR; + if (yych == 'L') goto yy174; + if (yych == 'l') goto yy174; + goto yy60; +yy173: + yych = *++YYCURSOR; + if (yych == 'U') goto yy174; + if (yych != 'u') goto yy60; +yy174: + yych = *++YYCURSOR; + goto yy60; +yy175: + yych = *++YYCURSOR; + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; +yy176: + ++YYCURSOR; + if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2); + yych = *YYCURSOR; + if (yych <= 'K') { + if (yych <= '9') { + if (yych <= '/') goto yy170; + goto yy176; + } else { + if (yych != 'F') goto yy170; + } + } else { + if (yych <= 'f') { + if (yych <= 'L') goto yy179; + if (yych <= 'e') goto yy170; + } else { + if (yych == 'l') goto yy179; + goto yy170; + } + } +yy178: + yych = *++YYCURSOR; + if (yych == 'L') goto yy180; + if (yych == 'l') goto yy180; + goto yy170; +yy179: + yych = *++YYCURSOR; + if (yych == 'F') goto yy180; + if (yych != 'f') goto yy170; +yy180: + yych = *++YYCURSOR; + goto yy170; +yy181: + yych = *++YYCURSOR; + if (yych <= ',') { + if (yych != '+') goto yy77; + } else { + if (yych <= '-') goto yy182; + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy183; + goto yy77; + } +yy182: + yych = *++YYCURSOR; + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; +yy183: + ++YYCURSOR; + if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2); + yych = *YYCURSOR; + if (yych <= 'K') { + if (yych <= '9') { + if (yych <= '/') goto yy170; + goto yy183; + } else { + if (yych == 'F') goto yy178; + goto yy170; + } + } else { + if (yych <= 'f') { + if (yych <= 'L') goto yy179; + if (yych <= 'e') goto yy170; + goto yy178; + } else { + if (yych == 'l') goto yy179; + goto yy170; + } + } +yy185: + yyaccept = 5; + YYMARKER = ++YYCURSOR; + if ((YYLIMIT - YYCURSOR) < 3) YYFILL(3); + yych = *YYCURSOR; + if (yybm[0+yych] & 1) { + goto yy185; + } + if (yych <= 'L') { + if (yych <= '9') { + if (yych == '.') goto yy168; + if (yych <= '/') goto yy60; + } else { + if (yych <= 'D') { + if (yych <= 'C') goto yy60; + goto yy164; + } else { + if (yych <= 'E') goto yy171; + if (yych <= 'K') goto yy60; + goto yy173; + } + } + } else { + if (yych <= 'e') { + if (yych <= 'U') { + if (yych <= 'T') goto yy60; + goto yy172; + } else { + if (yych <= 'c') goto yy60; + if (yych <= 'd') goto yy164; + goto yy171; + } + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy60; + goto yy173; + } else { + if (yych == 'u') goto yy172; + goto yy60; + } + } + } +yy187: + ++YYCURSOR; + if ((YYLIMIT - YYCURSOR) < 3) YYFILL(3); + yych = *YYCURSOR; + if (yych <= 'C') { + if (yych <= '.') { + if (yych <= '-') goto yy77; + goto yy168; + } else { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy187; + goto yy77; + } + } else { + if (yych <= 'c') { + if (yych <= 'D') goto yy164; + if (yych <= 'E') goto yy171; + goto yy77; + } else { + if (yych <= 'd') goto yy164; + if (yych <= 'e') goto yy171; + goto yy77; + } + } +yy189: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy190; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy190: + ++YYCURSOR; + if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2); + yych = *YYCURSOR; + if (yych <= 'T') { + if (yych <= '@') { + if (yych <= '/') goto yy60; + if (yych <= '9') goto yy190; + goto yy60; + } else { + if (yych <= 'F') goto yy190; + if (yych == 'L') goto yy173; + goto yy60; + } + } else { + if (yych <= 'k') { + if (yych <= 'U') goto yy172; + if (yych <= '`') goto yy60; + if (yych <= 'f') goto yy190; + goto yy60; + } else { + if (yych <= 'l') goto yy173; + if (yych == 'u') goto yy172; + goto yy60; + } + } +yy192: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy218; + goto yy77; + } else { + if (yych <= 'F') goto yy218; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy218; + goto yy77; + } +yy193: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy194; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy194: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy195; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy195: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy196; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy196: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy197; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy197: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy198; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy198: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy199; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy199: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy200; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy200: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy201; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy201: + yyaccept = 0; + YYMARKER = ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; +yy202: + if (yybm[0+yych] & 2) { + goto yy201; + } + if (yych == '?') goto yy204; + if (yych != '\\') goto yy5; +yy203: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych == 'U') goto yy207; + if (yych == 'u') goto yy206; + goto yy77; +yy204: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych != '?') goto yy77; + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych == '/') goto yy203; + goto yy77; +yy206: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy215; + goto yy77; + } else { + if (yych <= 'F') goto yy215; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy215; + goto yy77; + } +yy207: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy208; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy208: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy209; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy209: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy210; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy210: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy211; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy211: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy212; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy212: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy213; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy213: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy214; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy214: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy201; + goto yy77; + } else { + if (yych <= 'F') goto yy201; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy201; + goto yy77; + } +yy215: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy216; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy216: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy217; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy217: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy201; + goto yy77; + } else { + if (yych <= 'F') goto yy201; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy201; + goto yy77; + } +yy218: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy219; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy219: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych >= ':') goto yy77; + } else { + if (yych <= 'F') goto yy220; + if (yych <= '`') goto yy77; + if (yych >= 'g') goto yy77; + } +yy220: + yych = *++YYCURSOR; + if (yych <= '@') { + if (yych <= '/') goto yy77; + if (yych <= '9') goto yy201; + goto yy77; + } else { + if (yych <= 'F') goto yy201; + if (yych <= '`') goto yy77; + if (yych <= 'f') goto yy201; + goto yy77; + } +yy221: + yych = *++YYCURSOR; + if (yych == '\'') goto yy77; + goto yy121; +yy222: + ++YYCURSOR; +#line 417 "idl.re" + { BOOST_WAVE_RET(T_GREATEREQUAL); } +#line 3093 "idl_re.cpp" +yy224: + ++YYCURSOR; +#line 413 "idl.re" + { BOOST_WAVE_RET(T_SHIFTRIGHT); } +#line 3098 "idl_re.cpp" +yy226: + ++YYCURSOR; +#line 416 "idl.re" + { BOOST_WAVE_RET(T_LESSEQUAL); } +#line 3103 "idl_re.cpp" +yy228: + ++YYCURSOR; +#line 412 "idl.re" + { BOOST_WAVE_RET(T_SHIFTLEFT); } +#line 3108 "idl_re.cpp" +yy230: + ++YYCURSOR; +#line 414 "idl.re" + { BOOST_WAVE_RET(T_EQUAL); } +#line 3113 "idl_re.cpp" +yy232: + ++YYCURSOR; +#line 415 "idl.re" + { BOOST_WAVE_RET(T_NOTEQUAL); } +#line 3118 "idl_re.cpp" +yy234: + ++YYCURSOR; +#line 419 "idl.re" + { BOOST_WAVE_RET(T_OROR); } +#line 3123 "idl_re.cpp" +yy236: + ++YYCURSOR; +#line 418 "idl.re" + { BOOST_WAVE_RET(T_ANDAND); } +#line 3128 "idl_re.cpp" +yy238: + ++YYCURSOR; + if ((YYLIMIT - YYCURSOR) < 7) YYFILL(7); + yych = *YYCURSOR; +yy239: + if (yybm[0+yych] & 4) { + goto yy238; + } + if (yych <= 'k') { + if (yych <= 'd') { + if (yych == '/') goto yy240; + if (yych <= 'c') goto yy77; + goto yy243; + } else { + if (yych <= 'e') goto yy242; + if (yych == 'i') goto yy241; + goto yy77; + } + } else { + if (yych <= 't') { + if (yych <= 'l') goto yy245; + if (yych == 'p') goto yy246; + goto yy77; + } else { + if (yych <= 'u') goto yy244; + if (yych == 'w') goto yy247; + goto yy77; + } + } +yy240: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych == '*') goto yy330; + goto yy77; +yy241: + yych = *++YYCURSOR; + if (yych == 'f') goto yy293; + if (yych == 'n') goto yy295; + goto yy77; +yy242: + yych = *++YYCURSOR; + if (yych <= 'm') { + if (yych == 'l') goto yy278; + goto yy77; + } else { + if (yych <= 'n') goto yy277; + if (yych == 'r') goto yy276; + goto yy77; + } +yy243: + yych = *++YYCURSOR; + if (yych == 'e') goto yy270; + goto yy77; +yy244: + yych = *++YYCURSOR; + if (yych == 'n') goto yy265; + goto yy77; +yy245: + yych = *++YYCURSOR; + if (yych == 'i') goto yy261; + goto yy77; +yy246: + yych = *++YYCURSOR; + if (yych == 'r') goto yy255; + goto yy77; +yy247: + yych = *++YYCURSOR; + if (yych != 'a') goto yy77; + yych = *++YYCURSOR; + if (yych != 'r') goto yy77; + yych = *++YYCURSOR; + if (yych != 'n') goto yy77; + yych = *++YYCURSOR; + if (yych != 'i') goto yy77; + yych = *++YYCURSOR; + if (yych != 'n') goto yy77; + yych = *++YYCURSOR; + if (yych != 'g') goto yy77; + ++YYCURSOR; +#line 464 "idl.re" + { BOOST_WAVE_RET(T_PP_WARNING); } +#line 3211 "idl_re.cpp" +yy255: + yych = *++YYCURSOR; + if (yych != 'a') goto yy77; + yych = *++YYCURSOR; + if (yych != 'g') goto yy77; + yych = *++YYCURSOR; + if (yych != 'm') goto yy77; + yych = *++YYCURSOR; + if (yych != 'a') goto yy77; + ++YYCURSOR; +#line 462 "idl.re" + { BOOST_WAVE_RET(T_PP_PRAGMA); } +#line 3224 "idl_re.cpp" +yy261: + yych = *++YYCURSOR; + if (yych != 'n') goto yy77; + yych = *++YYCURSOR; + if (yych != 'e') goto yy77; + ++YYCURSOR; +#line 460 "idl.re" + { BOOST_WAVE_RET(T_PP_LINE); } +#line 3233 "idl_re.cpp" +yy265: + yych = *++YYCURSOR; + if (yych != 'd') goto yy77; + yych = *++YYCURSOR; + if (yych != 'e') goto yy77; + yych = *++YYCURSOR; + if (yych != 'f') goto yy77; + ++YYCURSOR; +#line 459 "idl.re" + { BOOST_WAVE_RET(T_PP_UNDEF); } +#line 3244 "idl_re.cpp" +yy270: + yych = *++YYCURSOR; + if (yych != 'f') goto yy77; + yych = *++YYCURSOR; + if (yych != 'i') goto yy77; + yych = *++YYCURSOR; + if (yych != 'n') goto yy77; + yych = *++YYCURSOR; + if (yych != 'e') goto yy77; + ++YYCURSOR; +#line 458 "idl.re" + { BOOST_WAVE_RET(T_PP_DEFINE); } +#line 3257 "idl_re.cpp" +yy276: + yych = *++YYCURSOR; + if (yych == 'r') goto yy289; + goto yy77; +yy277: + yych = *++YYCURSOR; + if (yych == 'd') goto yy285; + goto yy77; +yy278: + yych = *++YYCURSOR; + if (yych == 'i') goto yy280; + if (yych != 's') goto yy77; + yych = *++YYCURSOR; + if (yych == 'e') goto yy283; + goto yy77; +yy280: + yych = *++YYCURSOR; + if (yych != 'f') goto yy77; + ++YYCURSOR; +#line 456 "idl.re" + { BOOST_WAVE_RET(T_PP_ELIF); } +#line 3279 "idl_re.cpp" +yy283: + ++YYCURSOR; +#line 455 "idl.re" + { BOOST_WAVE_RET(T_PP_ELSE); } +#line 3284 "idl_re.cpp" +yy285: + yych = *++YYCURSOR; + if (yych != 'i') goto yy77; + yych = *++YYCURSOR; + if (yych != 'f') goto yy77; + ++YYCURSOR; +#line 457 "idl.re" + { BOOST_WAVE_RET(T_PP_ENDIF); } +#line 3293 "idl_re.cpp" +yy289: + yych = *++YYCURSOR; + if (yych != 'o') goto yy77; + yych = *++YYCURSOR; + if (yych != 'r') goto yy77; + ++YYCURSOR; +#line 461 "idl.re" + { BOOST_WAVE_RET(T_PP_ERROR); } +#line 3302 "idl_re.cpp" +yy293: + yyaccept = 9; + yych = *(YYMARKER = ++YYCURSOR); + if (yych == 'd') goto yy321; + if (yych == 'n') goto yy322; +yy294: +#line 452 "idl.re" + { BOOST_WAVE_RET(T_PP_IF); } +#line 3311 "idl_re.cpp" +yy295: + yych = *++YYCURSOR; + if (yych != 'c') goto yy77; + yych = *++YYCURSOR; + if (yych != 'l') goto yy77; + yych = *++YYCURSOR; + if (yych != 'u') goto yy77; + yych = *++YYCURSOR; + if (yych != 'd') goto yy77; + yych = *++YYCURSOR; + if (yych != 'e') goto yy77; +yy300: + yyaccept = 10; + YYMARKER = ++YYCURSOR; + if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2); + yych = *YYCURSOR; + if (yych <= '!') { + if (yych <= '\t') { + if (yych >= '\t') goto yy300; + } else { + if (yych == ' ') goto yy300; + } + } else { + if (yych <= '/') { + if (yych <= '"') goto yy304; + if (yych >= '/') goto yy303; + } else { + if (yych == '<') goto yy305; + } + } +yy302: +#line 450 "idl.re" + { BOOST_WAVE_RET(T_PP_INCLUDE); } +#line 3345 "idl_re.cpp" +yy303: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych == '*') goto yy314; + goto yy77; +yy304: + yych = *++YYCURSOR; + if (yych == '"') goto yy77; + goto yy311; +yy305: + yych = *++YYCURSOR; + if (yych == '>') goto yy77; + goto yy307; +yy306: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; +yy307: + if (yybm[0+yych] & 8) { + goto yy306; + } + if (yych <= '=') goto yy77; + ++YYCURSOR; +#line 444 "idl.re" + { BOOST_WAVE_RET(T_PP_HHEADER); } +#line 3372 "idl_re.cpp" +yy310: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; +yy311: + if (yybm[0+yych] & 16) { + goto yy310; + } + if (yych <= '!') goto yy77; + ++YYCURSOR; +#line 447 "idl.re" + { BOOST_WAVE_RET(T_PP_QHEADER); } +#line 3385 "idl_re.cpp" +yy314: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[0+yych] & 32) { + goto yy314; + } + if (yych == '\r') goto yy316; + if (yych <= ')') goto yy77; + goto yy318; +yy316: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[0+yych] & 32) { + goto yy314; + } + if (yych == '\r') goto yy316; + if (yych <= ')') goto yy77; +yy318: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[0+yych] & 128) { + goto yy318; + } + if (yych <= '\r') { + if (yych <= 0x08) goto yy77; + if (yych <= '\f') goto yy314; + } else { + if (yych <= 0x1F) goto yy77; + if (yych == '/') goto yy300; + goto yy314; + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yybm[0+yych] & 32) { + goto yy314; + } + if (yych == '\r') goto yy316; + if (yych <= ')') goto yy77; + goto yy318; +yy321: + yych = *++YYCURSOR; + if (yych == 'e') goto yy327; + goto yy77; +yy322: + yych = *++YYCURSOR; + if (yych != 'd') goto yy77; + yych = *++YYCURSOR; + if (yych != 'e') goto yy77; + yych = *++YYCURSOR; + if (yych != 'f') goto yy77; + ++YYCURSOR; +#line 454 "idl.re" + { BOOST_WAVE_RET(T_PP_IFNDEF); } +#line 3443 "idl_re.cpp" +yy327: + yych = *++YYCURSOR; + if (yych != 'f') goto yy77; + ++YYCURSOR; +#line 453 "idl.re" + { BOOST_WAVE_RET(T_PP_IFDEF); } +#line 3450 "idl_re.cpp" +yy330: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '\r') { + if (yych <= 0x08) goto yy77; + if (yych <= '\f') goto yy330; + } else { + if (yych <= 0x1F) goto yy77; + if (yych == '*') goto yy334; + goto yy330; + } +yy332: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '\r') { + if (yych <= 0x08) goto yy77; + if (yych <= '\f') goto yy330; + goto yy332; + } else { + if (yych <= 0x1F) goto yy77; + if (yych != '*') goto yy330; + } +yy334: + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy77; + if (yych <= '\f') goto yy330; + if (yych >= 0x0E) goto yy77; + } else { + if (yych <= '*') { + if (yych <= ')') goto yy330; + goto yy334; + } else { + if (yych == '/') goto yy238; + goto yy330; + } + } + ++YYCURSOR; + if (YYLIMIT <= YYCURSOR) YYFILL(1); + yych = *YYCURSOR; + if (yych <= '\r') { + if (yych <= 0x08) goto yy77; + if (yych <= '\f') goto yy330; + goto yy332; + } else { + if (yych <= 0x1F) goto yy77; + if (yych == '*') goto yy334; + goto yy330; + } +yy337: + ++YYCURSOR; +#line 421 "idl.re" + { BOOST_WAVE_RET(T_MINUSMINUS); } +#line 3508 "idl_re.cpp" +yy339: + ++YYCURSOR; +#line 420 "idl.re" + { BOOST_WAVE_RET(T_PLUSPLUS); } +#line 3513 "idl_re.cpp" +yy341: + yych = *++YYCURSOR; + if (yych == '/') goto yy342; + if (yych == '=') goto yy238; + goto yy77; +yy342: + yych = *++YYCURSOR; + if (yych == 'U') goto yy193; + if (yych == 'u') goto yy192; + goto yy77; +yy343: + ++YYCURSOR; +#line 392 "idl.re" + { BOOST_WAVE_RET(T_POUND_POUND); } +#line 3528 "idl_re.cpp" +yy345: + yyaccept = 0; + yych = *(YYMARKER = ++YYCURSOR); + if (yych != 'L') goto yy202; + yyaccept = 0; + yych = *(YYMARKER = ++YYCURSOR); + if (yych != 'S') goto yy202; + yyaccept = 0; + yych = *(YYMARKER = ++YYCURSOR); + if (yych != 'E') goto yy202; + yyaccept = 11; + yych = *(YYMARKER = ++YYCURSOR); + if (yybm[0+yych] & 2) { + goto yy201; + } + if (yych == '?') goto yy204; + if (yych == '\\') goto yy203; +yy349: +#line 385 "idl.re" + { BOOST_WAVE_RET(T_FALSE); } +#line 3549 "idl_re.cpp" +yy350: + yyaccept = 0; + yych = *(YYMARKER = ++YYCURSOR); + if (yych != 'U') goto yy202; + yyaccept = 0; + yych = *(YYMARKER = ++YYCURSOR); + if (yych != 'E') goto yy202; + yyaccept = 12; + yych = *(YYMARKER = ++YYCURSOR); + if (yybm[0+yych] & 2) { + goto yy201; + } + if (yych == '?') goto yy204; + if (yych == '\\') goto yy203; +yy353: +#line 384 "idl.re" + { BOOST_WAVE_RET(T_TRUE); } +#line 3567 "idl_re.cpp" +yy354: + ++YYCURSOR; +#line 382 "idl.re" + { goto cppcomment; } +#line 3572 "idl_re.cpp" +yy356: + ++YYCURSOR; +#line 381 "idl.re" + { goto ccomment; } +#line 3577 "idl_re.cpp" +} +#line 495 "idl.re" + + +ccomment: + +#line 3584 "idl_re.cpp" +{ + YYCTYPE yych; + if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2); + yych = *YYCURSOR; + if (yych <= '\f') { + if (yych <= 0x08) { + if (yych <= 0x00) goto yy366; + goto yy368; + } else { + if (yych == '\n') goto yy362; + goto yy365; + } + } else { + if (yych <= 0x1F) { + if (yych <= '\r') goto yy364; + goto yy368; + } else { + if (yych != '*') goto yy365; + } + } + ++YYCURSOR; + if ((yych = *YYCURSOR) == '/') goto yy371; +yy361: +#line 508 "idl.re" + { goto ccomment; } +#line 3610 "idl_re.cpp" +yy362: + ++YYCURSOR; +yy363: +#line 501 "idl.re" + { + /*if(cursor == s->eof) BOOST_WAVE_RET(T_EOF);*/ + /*s->tok = cursor; */ + s->line += count_backslash_newlines(s, cursor) +1; + goto ccomment; + } +#line 3621 "idl_re.cpp" +yy364: + yych = *++YYCURSOR; + if (yych == '\n') goto yy370; + goto yy363; +yy365: + yych = *++YYCURSOR; + goto yy361; +yy366: + ++YYCURSOR; +#line 511 "idl.re" + { + using namespace std; // some systems have printf in std + if(cursor == s->eof) + { + if (s->error_proc) + (*s->error_proc)(s, + cpplexer::lexing_exception::generic_lexing_warning, + "Unterminated comment"); + else + printf("Error: Unterminated comment\n"); + } + else + { + if (s->error_proc) + (*s->error_proc)(s, + cpplexer::lexing_exception::generic_lexing_error, + "'\\000' in input stream"); + else + printf("Error: 0 in file"); + } + /* adjust cursor such next call returns T_EOF */ + --YYCURSOR; + /* the comment is unterminated, but nevertheless its a comment */ + BOOST_WAVE_RET(T_CCOMMENT); + } +#line 3657 "idl_re.cpp" +yy368: + ++YYCURSOR; +#line 538 "idl.re" + { + if (s->error_proc) + (*s->error_proc)(s, + cpplexer::lexing_exception::generic_lexing_error, + "invalid character in input stream"); + else + printf("Error: 0 in file"); + } +#line 3669 "idl_re.cpp" +yy370: + yych = *++YYCURSOR; + goto yy363; +yy371: + ++YYCURSOR; +#line 499 "idl.re" + { BOOST_WAVE_RET(T_CCOMMENT); } +#line 3677 "idl_re.cpp" +} +#line 547 "idl.re" + + +cppcomment: + +#line 3684 "idl_re.cpp" +{ + YYCTYPE yych; + if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2); + yych = *YYCURSOR; + if (yych <= '\n') { + if (yych <= 0x00) goto yy381; + if (yych <= 0x08) goto yy375; + if (yych <= '\t') goto yy379; + goto yy376; + } else { + if (yych <= '\f') goto yy379; + if (yych <= '\r') goto yy378; + if (yych >= ' ') goto yy379; + } +yy375: +yy376: + ++YYCURSOR; +yy377: +#line 552 "idl.re" + { + /*if(cursor == s->eof) BOOST_WAVE_RET(T_EOF); */ + /*s->tok = cursor; */ + s->line++; + BOOST_WAVE_RET(T_CPPCOMMENT); + } +#line 3710 "idl_re.cpp" +yy378: + yych = *++YYCURSOR; + if (yych == '\n') goto yy383; + goto yy377; +yy379: + ++YYCURSOR; +#line 559 "idl.re" + { goto cppcomment; } +#line 3719 "idl_re.cpp" +yy381: + ++YYCURSOR; +#line 562 "idl.re" + { + using namespace std; // some systems have printf in std + if(cursor != s->eof) + { + if (s->error_proc) + (*s->error_proc)(s, + cpplexer::lexing_exception::generic_lexing_error, + "'\\000' in input stream"); + else + printf("Error: 0 in file"); + } + /* adjust cursor such next call returns T_EOF */ + --YYCURSOR; + /* the comment is unterminated, but nevertheless its a comment */ + BOOST_WAVE_RET(T_CPPCOMMENT); + } +#line 3739 "idl_re.cpp" +yy383: + ++YYCURSOR; + yych = *YYCURSOR; + goto yy377; +} +#line 578 "idl.re" + + +} /* end of scan */ + +#undef RE2C_ASSERT + +/////////////////////////////////////////////////////////////////////////////// +} // namespace re2clex +} // namespace idllexer +} // namespace wave +} // namespace boost diff --git a/src/boost/libs/wave/samples/waveidl/idllexer/idl_re.hpp b/src/boost/libs/wave/samples/waveidl/idllexer/idl_re.hpp new file mode 100644 index 00000000..d91d6b6f --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/idllexer/idl_re.hpp @@ -0,0 +1,35 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: Re2C based IDL lexer + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(IDL_RE_HPP_BD62775D_1659_4684_872C_03C02543C9A5_INCLUDED) +#define IDL_RE_HPP_BD62775D_1659_4684_872C_03C02543C9A5_INCLUDED + +#include <boost/wave/token_ids.hpp> + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace idllexer { +namespace re2clex { + +/////////////////////////////////////////////////////////////////////////////// +// The scanner function to call whenever a new token is requested +boost::wave::token_id scan( + boost::wave::cpplexer::re2clex::Scanner *s); + +/////////////////////////////////////////////////////////////////////////////// +} // namespace re2clex +} // namespace idllexer +} // namespace wave +} // namespace boost + +#endif // !defined(IDL_RE_HPP_BD62775D_1659_4684_872C_03C02543C9A5_INCLUDED) diff --git a/src/boost/libs/wave/samples/waveidl/idllexer/idl_re2c_lexer.hpp b/src/boost/libs/wave/samples/waveidl/idllexer/idl_re2c_lexer.hpp new file mode 100644 index 00000000..9f4457b3 --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/idllexer/idl_re2c_lexer.hpp @@ -0,0 +1,276 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Re2C based IDL lexer + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#if !defined(IDL_RE2C_LEXER_HPP_B81A2629_D5B1_4944_A97D_60254182B9A8_INCLUDED) +#define IDL_RE2C_LEXER_HPP_B81A2629_D5B1_4944_A97D_60254182B9A8_INCLUDED + +#include <string> +#include <cstdio> +#include <cstdarg> +#if defined(BOOST_SPIRIT_DEBUG) +#include <iostream> +#endif // defined(BOOST_SPIRIT_DEBUG) + +#include <boost/concept_check.hpp> +#include <boost/assert.hpp> +#include <boost/spirit/include/classic_core.hpp> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/language_support.hpp> +#include <boost/wave/util/file_position.hpp> +#include <boost/wave/cpplexer/validate_universal_char.hpp> +#include <boost/wave/cpplexer/cpplexer_exceptions.hpp> + +// reuse the default token type and re2c lexer helpers +#include <boost/wave/cpplexer/cpp_lex_token.hpp> +#include <boost/wave/cpplexer/cpp_lex_interface.hpp> +#include <boost/wave/cpplexer/re2clex/scanner.hpp> + +#include "idl_re.hpp" + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { +namespace wave { +namespace idllexer { +namespace re2clex { + +/////////////////////////////////////////////////////////////////////////////// +// +// encapsulation of the re2c based idl lexer +// +/////////////////////////////////////////////////////////////////////////////// + +template < + typename IteratorT, + typename PositionT = boost::wave::util::file_position_type +> +class lexer +{ + typedef boost::wave::cpplexer::re2clex::Scanner scanner_t; + +public: + + typedef char char_t; + typedef boost::wave::cpplexer::re2clex::Scanner base_t; + typedef boost::wave::cpplexer::lex_token<PositionT> token_type; + typedef typename token_type::string_type string_type; + + lexer(IteratorT const &first, IteratorT const &last, + PositionT const &pos, boost::wave::language_support language); + ~lexer(); + + token_type& get(token_type& t); + void set_position(PositionT const &pos) + { + // set position has to change the file name and line number only + filename = pos.get_file(); + scanner.line = pos.get_line(); + scanner.file_name = filename.c_str(); + } + +// error reporting from the re2c generated lexer + static int report_error(scanner_t const *s, int code, char const *, ...); + +private: + static char const *tok_names[]; + + scanner_t scanner; + string_type filename; + bool at_eof; + boost::wave::language_support language; +}; + +/////////////////////////////////////////////////////////////////////////////// +// initialize cpp lexer +template <typename IteratorT, typename PositionT> +inline +lexer<IteratorT, PositionT>::lexer(IteratorT const &first, + IteratorT const &last, PositionT const &pos, + boost::wave::language_support language) +: filename(pos.get_file()), at_eof(false), language(language) +{ + using namespace std; // some systems have memset in std + using namespace boost::wave::cpplexer::re2clex; + + memset(&scanner, '\0', sizeof(scanner_t)); + scanner.eol_offsets = aq_create(); + scanner.first = scanner.act = (uchar *)&(*first); + scanner.last = scanner.first + std::distance(first, last); + scanner.line = pos.get_line(); + scanner.error_proc = report_error; + scanner.file_name = filename.c_str(); + +// not used by the lexer + scanner.enable_ms_extensions = 0; + scanner.act_in_c99_mode = 0; + + boost::ignore_unused_variable_warning(language); +} + +template <typename IteratorT, typename PositionT> +inline +lexer<IteratorT, PositionT>::~lexer() +{ + boost::wave::cpplexer::re2clex::aq_terminate(scanner.eol_offsets); + free(scanner.bot); +} + +/////////////////////////////////////////////////////////////////////////////// +// get the next token from the input stream +template <typename IteratorT, typename PositionT> +inline boost::wave::cpplexer::lex_token<PositionT>& +lexer<IteratorT, PositionT>::get(boost::wave::cpplexer::lex_token<PositionT>& t) +{ + using namespace boost::wave; // to import token ids to this scope + + if (at_eof) + return t = boost::wave::cpplexer::lex_token<PositionT>(); // return T_EOI + + token_id id = token_id(scan(&scanner)); + string_type value((char const *)scanner.tok, scanner.cur-scanner.tok); + + if (T_IDENTIFIER == id) { + // test identifier characters for validity (throws if invalid chars found) + if (!boost::wave::need_no_character_validation(language)) { + boost::wave::cpplexer::impl::validate_identifier_name(value, + scanner.line, -1, filename); + } + } + else if (T_STRINGLIT == id || T_CHARLIT == id) { + // test literal characters for validity (throws if invalid chars found) + if (!boost::wave::need_no_character_validation(language)) { + boost::wave::cpplexer::impl::validate_literal(value, scanner.line, + -1, filename); + } + } + else if (T_EOF == id) { + // T_EOF is returned as a valid token, the next call will return T_EOI, + // i.e. the actual end of input + at_eof = true; + value.clear(); + } + return t = boost::wave::cpplexer::lex_token<PositionT>(id, value, + PositionT(filename, scanner.line, -1)); +} + +template <typename IteratorT, typename PositionT> +inline int +lexer<IteratorT, PositionT>::report_error(scanner_t const *s, int errcode, + char const* msg, ...) +{ + BOOST_ASSERT(0 != s); + BOOST_ASSERT(0 != msg); + + using namespace std; // some system have vsprintf in namespace std + + char buffer[200]; // should be large enough + va_list params; + va_start(params, msg); + vsprintf(buffer, msg, params); + va_end(params); + + BOOST_WAVE_LEXER_THROW_VAR(boost::wave::cpplexer::lexing_exception, + errcode, buffer, s->line, -1, s->file_name); + return 0; +} + +/////////////////////////////////////////////////////////////////////////////// +// +// lex_functor +// +/////////////////////////////////////////////////////////////////////////////// + +template < + typename IteratorT, + typename PositionT = boost::wave::util::file_position_type +> +class lex_functor +: public lex_input_interface_generator< + typename lexer<IteratorT, PositionT>::token_type + > +{ +public: + + typedef typename lexer<IteratorT, PositionT>::token_type token_type; + + lex_functor(IteratorT const &first, IteratorT const &last, + PositionT const &pos, boost::wave::language_support language) + : lexer(first, last, pos, language) + {} + virtual ~lex_functor() {} + +// get the next token from the input stream + token_type& get(token_type& t) { return lexer.get(t); } + void set_position(PositionT const &pos) + { lexer.set_position(pos); } +#if BOOST_WAVE_SUPPORT_PRAGMA_ONCE != 0 + bool has_include_guards(std::string&) const { return false; } +#endif + +private: + lexer<IteratorT, PositionT> lexer; +}; + +} // namespace re2clex + +/////////////////////////////////////////////////////////////////////////////// +// +// The new_lexer_gen<>::new_lexer function (declared in cpp_slex_token.hpp) +// should be defined inline, if the lex_functor shouldn't be instantiated +// separately from the lex_iterator. +// +// Separate (explicit) instantiation helps to reduce compilation time. +// +/////////////////////////////////////////////////////////////////////////////// + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 +#define BOOST_WAVE_RE2C_NEW_LEXER_INLINE +#else +#define BOOST_WAVE_RE2C_NEW_LEXER_INLINE inline +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// The 'new_lexer' function allows the opaque generation of a new lexer object. +// It is coupled to the iterator type to allow to decouple the lexer/iterator +// configurations at compile time. +// +// This function is declared inside the cpp_slex_token.hpp file, which is +// referenced by the source file calling the lexer and the source file, which +// instantiates the lex_functor. But it is defined here, so it will be +// instantiated only while compiling the source file, which instantiates the +// lex_functor. While the cpp_re2c_token.hpp file may be included everywhere, +// this file (cpp_re2c_lexer.hpp) should be included only once. This allows +// to decouple the lexer interface from the lexer implementation and reduces +// compilation time. +// +/////////////////////////////////////////////////////////////////////////////// + +template <typename IteratorT, typename PositionT> +BOOST_WAVE_RE2C_NEW_LEXER_INLINE +cpplexer::lex_input_interface<cpplexer::lex_token<PositionT> > * +new_lexer_gen<IteratorT, PositionT>::new_lexer(IteratorT const &first, + IteratorT const &last, PositionT const &pos, + wave::language_support language) +{ + return new re2clex::lex_functor<IteratorT, PositionT>(first, last, pos, + language); +} + +#undef BOOST_WAVE_RE2C_NEW_LEXER_INLINE + +/////////////////////////////////////////////////////////////////////////////// +} // namespace idllexer +} // namespace wave +} // namespace boost + +#endif // !defined(IDL_RE2C_LEXER_HPP_B81A2629_D5B1_4944_A97D_60254182B9A8_INCLUDED) diff --git a/src/boost/libs/wave/samples/waveidl/instantiate_cpp_grammar.cpp b/src/boost/libs/wave/samples/waveidl/instantiate_cpp_grammar.cpp new file mode 100644 index 00000000..5647a44d --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/instantiate_cpp_grammar.cpp @@ -0,0 +1,45 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: IDL oriented preprocessor + Explicit instantiation of the cpp_grammar template + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "idl.hpp" + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> +#include <list> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/cpp_lex_token.hpp> + +#include "idllexer/idl_lex_iterator.hpp" + +#include <boost/wave/grammars/cpp_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the cpp_grammar_gen template with the correct +// token type. This instantiates the corresponding pt_parse function, which +// in turn instantiates the cpp_grammar object +// (see wave/grammars/cpp_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::cpplexer::lex_token<> token_type; +typedef boost::wave::idllexer::lex_iterator<token_type> lexer_type; +typedef std::list<token_type, boost::fast_pool_allocator<token_type> > + token_sequence_type; + +template struct boost::wave::grammars::cpp_grammar_gen<lexer_type, token_sequence_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/waveidl/instantiate_defined_grammar.cpp b/src/boost/libs/wave/samples/waveidl/instantiate_defined_grammar.cpp new file mode 100644 index 00000000..89db2dd6 --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/instantiate_defined_grammar.cpp @@ -0,0 +1,42 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: IDL oriented preprocessor + Explicit instantiation of the defined_grammar template + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "idl.hpp" + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/cpp_lex_token.hpp> + +#include "idllexer/idl_lex_iterator.hpp" + +#include <boost/wave/grammars/cpp_defined_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the defined_grammar_gen template +// with the correct token type. This instantiates the corresponding parse +// function, which in turn instantiates the defined_grammar +// object (see wave/grammars/cpp_defined_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::idllexer::lex_iterator< + boost::wave::cpplexer::lex_token<> > + lexer_type; +template struct boost::wave::grammars::defined_grammar_gen<lexer_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/waveidl/instantiate_predef_macros.cpp b/src/boost/libs/wave/samples/waveidl/instantiate_predef_macros.cpp new file mode 100644 index 00000000..904f77bf --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/instantiate_predef_macros.cpp @@ -0,0 +1,42 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: IDL oriented preprocessor + Explicit instantiation of the predefined_macros_grammar template + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "idl.hpp" + +#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/cpp_lex_token.hpp> + +#include "idllexer/idl_lex_iterator.hpp" + +#include <boost/wave/grammars/cpp_predef_macros_grammar.hpp> + +/////////////////////////////////////////////////////////////////////////////// +// +// Explicit instantiation of the predefined_macros_grammar_gen template +// with the correct token type. This instantiates the corresponding pt_parse +// function, which in turn instantiates the cpp_predefined_macros_grammar +// object (see wave/grammars/cpp_predef_macros_grammar.hpp) +// +/////////////////////////////////////////////////////////////////////////////// + +typedef boost::wave::idllexer::lex_iterator< + boost::wave::cpplexer::lex_token<> > + lexer_type; +template struct boost::wave::grammars::predefined_macros_grammar_gen<lexer_type>; + +#endif // #if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0 + diff --git a/src/boost/libs/wave/samples/waveidl/instantiate_re2c_lexer.cpp b/src/boost/libs/wave/samples/waveidl/instantiate_re2c_lexer.cpp new file mode 100644 index 00000000..bc0873a4 --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/instantiate_re2c_lexer.cpp @@ -0,0 +1,50 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: IDL oriented preprocessor + Explicit instantiation of the lex_functor generation function + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "idl.hpp" + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/cpp_lex_token.hpp> + +#include "idllexer/idl_lex_iterator.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// The following file needs to be included only once throughout the whole +// program. +#include "idllexer/idl_re2c_lexer.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// +// This instantiates the correct 'new_lexer' function, which generates the +// C++ lexer used in this sample. You will have to instantiate the +// new_lexer_gen<> template with the same iterator type, as you have used for +// instantiating the boost::wave::context<> object. +// +// This is moved into a separate compilation unit to decouple the compilation +// of the C++ lexer from the compilation of the other modules, which helps to +// reduce compilation time. +// +// The template parameter(s) supplied should be identical to the first +// parameter supplied while instantiating the boost::wave::context<> template +// (see the file cpp.cpp). +// +/////////////////////////////////////////////////////////////////////////////// + +template struct boost::wave::idllexer::new_lexer_gen< + BOOST_WAVE_STRINGTYPE::iterator>; + +#endif // BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 diff --git a/src/boost/libs/wave/samples/waveidl/instantiate_re2c_lexer_str.cpp b/src/boost/libs/wave/samples/waveidl/instantiate_re2c_lexer_str.cpp new file mode 100644 index 00000000..7f902908 --- /dev/null +++ b/src/boost/libs/wave/samples/waveidl/instantiate_re2c_lexer_str.cpp @@ -0,0 +1,50 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + + Sample: IDL oriented preprocessor + Explicit instantiation of the lex_functor generation function + + http://www.boost.org/ + + Copyright (c) 2001-2010 Hartmut Kaiser. Distributed under the Boost + Software License, Version 1.0. (See accompanying file + LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +=============================================================================*/ + +#include "idl.hpp" + +#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 + +#include <string> + +#include <boost/wave/token_ids.hpp> +#include <boost/wave/cpplexer/cpp_lex_token.hpp> + +#include "idllexer/idl_lex_iterator.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// The following file needs to be included only once throughout the whole +// program. +#include "idllexer/idl_re2c_lexer.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// +// If you've used another iterator type as std::string::iterator, you have to +// instantiate the new_lexer_gen<> template for this iterator type too. +// The reason is, that the library internally uses the new_lexer_gen<> +// template with a std::string::iterator. (You just have to undefine the +// following line.) +// +// This is moved into a separate compilation unit to decouple the compilation +// of the C++ lexer from the compilation of the other modules, which helps to +// reduce compilation time. +// +// The template parameter(s) supplied should be identical to the first +// parameter supplied while instantiating the boost::wave::context<> template +// (see the file cpp.cpp). +// +/////////////////////////////////////////////////////////////////////////////// + +template struct boost::wave::idllexer::new_lexer_gen<std::string::iterator>; + +#endif // BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION != 0 |