bool generate_bookshelf_pl(OutputIterator &sink, const BookshelfPls &pls) {
using karma::generate;
using karma::lit;
using karma::stream;
using karma::eol;
bool r = generate(
sink,
lit("UCLA pl 1.0\n") << stream % eol,
pls.data
);
return r;
};
generator() : generator::base_type(start)
{
using standard::char_;
using standard::string;
using karma::bool_generator;
using karma::uint_generator;
using karma::double_;
using karma::int_;
using karma::lit;
using karma::right_align;
uint_generator<unsigned char, 16> hex2;
bool_generator<bool, bool_output_policies> boolean;
start = nil_
| double_
| int_
| boolean
| utf8
| symbol
| binary
| list
| ref_;
ref_ = start;
list = '(' << -(start % ' ') << ')';
utf8 = '"' << *(&char_('"') << "\\\"" | char_) << '"';
symbol = string;
binary = '#' << *right_align(2, '0')[hex2] << '#';
nil_ = karma::attr_cast(lit("nil"));
start.name("sexpr");
ref_.name("ref");
list.name("list");
utf8.name("string");
symbol.name("symbol");
binary.name("binary");
nil_.name("nil");
}
matrix_grammar()
: matrix_grammar::base_type(matrix)
{
using karma::int_;
using karma::right_align;
using karma::eol;
element = right_align(10)[int_];
row = '|' << *element << '|';
matrix = row % eol;
}
int main(int argc, char **argv)
{
int count(5);
if (argc > 1) {
if (!qi::parse(
argv[1], argv[1] + strlen(argv[1]), qi_repo::uint_,
count
)) return -1;
}
result1.reserve(count);
result2.reserve(count);
make_numbers(numbers, count, std::string(", "));
numbers.push_back(0);
std::cout << "Numbers to test: " << &numbers.front() << '\n';
BOOST_SPIRIT_TEST_BENCHMARK(1000, (qi_uint_test)(qi_repo_uint_test));
using karma::lit;
using karma::uint_;
karma::generate(
std::ostream_iterator<char>(std::cout),
lit("result1: ") << (uint_ % lit(", ")) << lit('\n'),
result1
);
karma::generate(
std::ostream_iterator<char>(std::cout),
lit("result2: ") << (uint_ % lit(", ")) << lit('\n'),
result2
);
return test::live_code != 0;
}
not_implemented_method_generator()
: not_implemented_method_generator::base_type(start)
{
using karma::_1;
using karma::_a;
using karma::_r1;
using karma::_val;
using karma::big_word;
using karma::byte_;
using karma::eps;
using karma::repeat;
namespace phoenix = boost::phoenix;
using phoenix::val;
start =
big_word[_1 = phoenix::size(_val)]
<< repeat(phoenix::size(_val))
[
byte_(1)
<< byte_(1)
<< big_word(_a * 2 + _r1)
<< big_word(_a * 2 + _r1 + 1)
<< big_word(0)
<< eps[++_a]
]
;
}
int main(int argc, char **argv)
{
int count(5);
if (argc > 1) {
if (!qi::parse(
argv[1], argv[1] + strlen(argv[1]), qi_repo::uint_,
count
)) return -1;
}
result1.reserve(count);
result2.reserve(count);
numbers = make_numbers<double>()(count, std::string(", "));
std::cout << "Numbers to test: " << numbers << '\n';
BOOST_SPIRIT_TEST_BENCHMARK(1, (strtod_test)(qi_repo_double_test));
using karma::lit;
using karma::double_;
karma::generate(
std::ostream_iterator<char>(std::cout),
lit("result1: ") << (double_ % lit(", ")) << lit('\n'),
result1
);
karma::generate(
std::ostream_iterator<char>(std::cout),
lit("result2: ") << (double_ % lit(", ")) << lit('\n'),
result2
);
return test::live_code != 0;
}
int main(int argc, char **argv)
{
using karma::uint_;
using karma::lit;
int count(5);
std::vector<char> rnd_str;
make_numbers(rnd_str, count, std::string(", "));
std::vector<unsigned int> res1, res2;
res1.reserve(count);
res2.reserve(count);
test_vector<unsigned int>(res1, rnd_str);
test_vector_ref<unsigned int>(res2, rnd_str);
rnd_str.push_back(0);
std::cout << "in: " << &rnd_str.front() << '\n';
karma::generate(
std::ostream_iterator<char>(std::cout),
lit("o1: ") << (uint_ % lit(", ")) << lit('\n'),
res1
);
karma::generate(
std::ostream_iterator<char>(std::cout),
lit("o2: ") << (uint_ % lit(", ")) << lit('\n'),
res2
);
return 0;
}
DescriptionFormatter() : DescriptionFormatter::base_type(start)
{
using namespace karma::labels;
using karma::lit;
using karma::uint_;
start =
lit("Nonogram {") <<
line_vector(std::string("Rows")) <<
line_vector(std::string("Columns")) <<
lit('}');
line_vector = lit(_r1) << lit('{') << +line << lit('}');
line = lit('[') << *uint_ << lit(']');
}
void make_numbers(
std::vector<T> &out, size_t count,
std::basic_string<T> const &delim
)
{
using karma::uint_;
using karma::lit;
random_device r;
karma::generate(
std::back_inserter(out),
uint_ % lit(delim),
boost::make_iterator_range(
boost::make_function_input_iterator(r, size_t(0)),
boost::make_function_input_iterator(r, count)
)
);
}
fields_generator() : fields_generator::base_type(start)
{
using karma::_1;
using karma::_r1;
using karma::_r2;
using karma::_a;
using karma::_val;
using karma::big_word;
using karma::eps;
using karma::repeat;
namespace phoenix = boost::phoenix;
using phoenix::val;
start =
repeat(phoenix::size(_val))
[
big_word[_1 = _r2] // u2 access_flags
<< big_word[_1 = _a*2 + _r1] // u2 name_index
<< big_word[_1 = _a*2 + _r1 + 1] // u2 descriptor_index
<< big_word[_1 = 0] // u2 attributes_count
<< eps[++_a]
]
;
}
int
main()
{
{
using karma::columns;
using karma::int_;
std::vector<int> v;
for (int i = 0; i < 11; ++i)
v.push_back(i);
BOOST_TEST(test("01234\n56789\n10\n", columns[*int_], v));
BOOST_TEST(test_delimited("0 1 2 3 4 \n5 6 7 8 9 \n10 \n", columns[*int_]
, v, karma::space));
}
{
using karma::columns;
using karma::int_;
std::vector<int> v;
for (int i = 0; i < 11; ++i)
v.push_back(i);
BOOST_TEST(test("012\n345\n678\n910\n", columns(3)[*int_], v));
BOOST_TEST(test_delimited("0 1 2 \n3 4 5 \n6 7 8 \n9 10 \n"
, columns(3)[*int_], v, karma::space));
}
{
using karma::columns;
using karma::int_;
using boost::phoenix::ref;
std::vector<int> v;
for (int i = 0; i < 11; ++i)
v.push_back(i);
int count = 3;
BOOST_TEST(test("012\n345\n678\n910\n", columns(ref(count))[*int_], v));
BOOST_TEST(test_delimited("0 1 2 \n3 4 5 \n6 7 8 \n9 10 \n"
, columns(val(ref(count)))[*int_], v, karma::space));
}
{
using karma::columns;
using karma::int_;
using karma::lit;
std::vector<int> v;
for (int i = 0; i < 11; ++i)
v.push_back(i);
BOOST_TEST(test("01234\t56789\t10\t", columns(lit('\t'))[*int_], v));
BOOST_TEST(test_delimited("0 1 2 3 4 \t5 6 7 8 9 \t10 \t"
, columns(lit('\t'))[*int_], v, karma::space));
}
{
using karma::columns;
using karma::int_;
using karma::lit;
std::vector<int> v;
for (int i = 0; i < 11; ++i)
v.push_back(i);
BOOST_TEST(test("012\t345\t678\t910\t", columns(3, lit('\t'))[*int_], v));
BOOST_TEST(test_delimited("0 1 2 \t3 4 5 \t6 7 8 \t9 10 \t"
, columns(3, lit('\t'))[*int_], v, karma::space));
}
return boost::report_errors();
}
int main()
{
using namespace boost;
using namespace boost::spirit;
using namespace boost::spirit::ascii;
typedef spirit_test::output_iterator<char>::type outiter_type;
{
karma::rule<outiter_type, void(char, int, double)> start;
fusion::vector<char, int, double> vec('a', 10, 12.4);
start = char_[_1 = _r1] << int_[_1 = _r2] << double_[_1 = _r3];
BOOST_TEST(test("a1012.4", start('a', 10, 12.4)));
start = (char_ << int_ << double_)[_1 = _r1, _2 = _r2, _3 = _r3];
BOOST_TEST(test("a1012.4", start('a', 10, 12.4)));
karma::rule<outiter_type, void(char)> a;
karma::rule<outiter_type, void(int)> b;
karma::rule<outiter_type, void(double)> c;
a = char_[_1 = _r1];
b = int_[_1 = _r1];
c = double_[_1 = _r1];
start = a(_r1) << b(_r2) << c(_r3);
BOOST_TEST(test("a1012.4", start('a', 10, 12.4)));
}
{
karma::rule<outiter_type, space_type, void(char, int, double)> start;
fusion::vector<char, int, double> vec('a', 10, 12.4);
start = char_[_1 = _r1] << int_[_1 = _r2] << double_[_1 = _r3];
BOOST_TEST(test_delimited("a 10 12.4 ", start('a', 10, 12.4), space));
start = (char_ << int_ << double_)[_1 = _r1, _2 = _r2, _3 = _r3];
BOOST_TEST(test_delimited("a 10 12.4 ", start('a', 10, 12.4), space));
karma::rule<outiter_type, space_type, void(char)> a;
karma::rule<outiter_type, space_type, void(int)> b;
karma::rule<outiter_type, space_type, void(double)> c;
a = char_[_1 = _r1];
b = int_[_1 = _r1];
c = double_[_1 = _r1];
start = a(_r1) << b(_r2) << c(_r3);
BOOST_TEST(test_delimited("a 10 12.4 ", start('a', 10, 12.4), space));
}
// copy tests
{
karma::rule<outiter_type> a, b, c, start;
a = 'a';
b = int_(10);
c = double_(12.4);
// The FF is the dynamic equivalent of start = a << b << c;
start = a;
start = start.copy() << b;
start = start.copy() << c;
start = start.copy();
BOOST_TEST(test("a1012.4", start));
}
{
karma::rule<outiter_type, space_type> a, b, c, start;
a = 'a';
b = int_(10);
c = double_(12.4);
// The FF is the dynamic equivalent of start = a << b << c;
start = a;
start = start.copy() << b;
start = start.copy() << c;
start = start.copy();
BOOST_TEST(test_delimited("a 10 12.4 ", start, space));
}
{ // specifying the encoding
using karma::lower;
using karma::upper;
using karma::string;
typedef boost::spirit::char_encoding::iso8859_1 iso8859_1;
karma::rule<outiter_type, iso8859_1> r;
r = lower['\xE1'];
BOOST_TEST(test("\xE1", r));
r = lower[char_('\xC1')];
BOOST_TEST(test("\xE1", r));
r = upper['\xE1'];
BOOST_TEST(test("\xC1", r));
r = upper[char_('\xC1')];
BOOST_TEST(test("\xC1", r));
r = lower["\xE1\xC1"];
BOOST_TEST(test("\xE1\xE1", r));
r = lower[lit("\xE1\xC1")];
BOOST_TEST(test("\xE1\xE1", r));
r = lower[string("\xE1\xC1")];
BOOST_TEST(test("\xE1\xE1", r));
r = upper["\xE1\xC1"];
BOOST_TEST(test("\xC1\xC1", r));
r = upper[lit("\xE1\xC1")];
BOOST_TEST(test("\xC1\xC1", r));
r = upper[string("\xE1\xC1")];
BOOST_TEST(test("\xC1\xC1", r));
}
return boost::report_errors();
}
class_file_generator() : class_file_generator::base_type(start)
{
using karma::_1;
using karma::_a; using karma::_b; using karma::_c;
using karma::_val;
using karma::_r1;
using karma::big_word;
using karma::big_dword;
using karma::eps;
using boost::spirit::byte_;
using boost::phoenix::size;
using boost::phoenix::at_c;
static const unsigned int constant_class_info = 7;
static const unsigned int constant_utf8_info = 1;
// static const unsigned int acc_public = 0x0001;
// // static const unsigned int acc_final = 0x0010;
// static const unsigned int acc_super = 0x0020;
// // static const unsigned int acc_interface = 0x0200;
// // static const unsigned int acc_abstract = 0x0400;
static const unsigned int static_fields_index = 0;
static const unsigned int fields_index = 1;
static const unsigned int not_implemented_method_index = 2;
static const unsigned int name_index = 4;
static const unsigned int extends_name_index = 5;
// _a = offset of constants for not implemented methods
// _b = offset of constants for static fields
// _c = offset of constants for fields
start =
big_dword(0xCAFEBABEU)
<< karma::eps(size(at_c<not_implemented_method_index>(_val)) >= 1u)
<< big_word(0x00U)
<< big_word(0x2EU)
<< ( // constant pool
big_word
[
_1 = 2*size(at_c<not_implemented_method_index>(_val))
+ 2*size(at_c<static_fields_index>(_val))
+ 2*size(at_c<fields_index>(_val))
+ 5
]
<< class_info_constant[_1 = 2]
<< utf8_info_constant[_1 = at_c<name_index>(_val)]
<< class_info_constant[_1 = 4]
<< utf8_info_constant[_1 = at_c<extends_name_index>(_val)]
<< eps[ _c = _b = _a = 5 ]
<< (*name_descriptor)[_1 = at_c<not_implemented_method_index>(_val)]
<< eps[ _c = (_b += size(at_c<not_implemented_method_index>(_val))*2) ]
<< (*name_descriptor)[_1 = at_c<static_fields_index>(_val)]
<< eps[ _c += size(at_c<static_fields_index>(_val))*2 ]
<< (*name_descriptor)[_1 = at_c<fields_index>(_val)]
)
<< big_word(_r1) // access flags
<< big_word(1) // constant index for class_info_constant 1
<< big_word(3) // constant index for class_info_constant 3
<< big_word(0) // 0 interfaces
<< big_word[_1 = size(at_c<static_fields_index>(_val))
+ size(at_c<fields_index>(_val))
]
<< fields(_b, 2 + 8)[_1 = at_c<static_fields_index>(_val)]
<< fields(_c, 2 /*+ 8*/)[_1 = at_c<fields_index>(_val)]
<< not_implemented_method(_a)[_1 = at_c<not_implemented_method_index>(_val)]
<< big_word(0) // attributes_count 0
;
name_descriptor %=
utf8_info_constant
<< utf8_info_constant
;
utf8_info_constant =
byte_(constant_utf8_info)
<< big_word[_1 = size(_val)]
<< karma::string[_1 = _val]
;
class_info_constant %=
byte_(constant_class_info)
<< big_word // constant_index
;
}
int main()
{
using namespace boost;
using namespace boost::spirit;
using namespace boost::spirit::ascii;
typedef spirit_test::output_iterator<char>::type outiter_type;
{
karma::rule<outiter_type, void(char, int, double)> start;
fusion::vector<char, int, double> vec('a', 10, 12.4);
start = char_[_1 = _r1] << int_[_1 = _r2] << double_[_1 = _r3];
BOOST_TEST(test("a1012.4", start('a', 10, 12.4)));
start = (char_ << int_ << double_)[_1 = _r1, _2 = _r2, _3 = _r3];
BOOST_TEST(test("a1012.4", start('a', 10, 12.4)));
karma::rule<outiter_type, void(char)> a;
karma::rule<outiter_type, void(int)> b;
karma::rule<outiter_type, void(double)> c;
a = char_[_1 = _r1];
b = int_[_1 = _r1];
c = double_[_1 = _r1];
start = a(_r1) << b(_r2) << c(_r3);
BOOST_TEST(test("a1012.4", start('a', 10, 12.4)));
}
{
karma::rule<outiter_type, space_type, void(char, int, double)> start;
fusion::vector<char, int, double> vec('a', 10, 12.4);
start = char_[_1 = _r1] << int_[_1 = _r2] << double_[_1 = _r3];
BOOST_TEST(test_delimited("a 10 12.4 ", start('a', 10, 12.4), space));
start = (char_ << int_ << double_)[_1 = _r1, _2 = _r2, _3 = _r3];
BOOST_TEST(test_delimited("a 10 12.4 ", start('a', 10, 12.4), space));
karma::rule<outiter_type, space_type, void(char)> a;
karma::rule<outiter_type, space_type, void(int)> b;
karma::rule<outiter_type, space_type, void(double)> c;
a = char_[_1 = _r1];
b = int_[_1 = _r1];
c = double_[_1 = _r1];
start = a(_r1) << b(_r2) << c(_r3);
BOOST_TEST(test_delimited("a 10 12.4 ", start('a', 10, 12.4), space));
}
// copy tests
{
typedef variant<char, int, double> var_type;
karma::rule<outiter_type> a, b, c, start;
a = 'a';
b = int_(10);
c = double_(12.4);
// The FF is the dynamic equivalent of start = a << b << c;
start = a;
start = start.copy() << b;
start = start.copy() << c;
start = start.copy();
BOOST_TEST(test("a1012.4", start));
}
{
typedef variant<char, int, double> var_type;
karma::rule<outiter_type, space_type> a, b, c, start;
a = 'a';
b = int_(10);
c = double_(12.4);
// The FF is the dynamic equivalent of start = a << b << c;
start = a;
start = start.copy() << b;
start = start.copy() << c;
start = start.copy();
BOOST_TEST(test_delimited("a 10 12.4 ", start, space));
}
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
#pragma setlocale("french")
#endif
{ // specifying the encoding
using karma::lower;
using karma::upper;
using karma::string;
typedef boost::spirit::char_encoding::iso8859_1 iso8859_1;
karma::rule<outiter_type, iso8859_1> r;
r = lower['с'];
BOOST_TEST(test("с", r));
r = lower[char_('┴')];
BOOST_TEST(test("с", r));
r = upper['с'];
BOOST_TEST(test("┴", r));
r = upper[char_('┴')];
BOOST_TEST(test("┴", r));
r = lower["с┴"];
BOOST_TEST(test("сс", r));
r = lower[lit("с┴")];
BOOST_TEST(test("сс", r));
r = lower[string("с┴")];
BOOST_TEST(test("сс", r));
r = upper["с┴"];
BOOST_TEST(test("┴┴", r));
r = upper[lit("с┴")];
BOOST_TEST(test("┴┴", r));
r = upper[string("с┴")];
BOOST_TEST(test("┴┴", r));
}
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
#pragma setlocale("")
#endif
return boost::report_errors();
}
