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(); }