conf4cpp-0.0.3/0000755002370600234200000000000011103752641012260 5ustar hattoriispconf4cpp-0.0.3/ChangeLog0000644002370600234200000000131211103753177014034 0ustar hattoriisp2008-11-04 Kenta HATTORI * conf4cpp-0.0.3 リリース * BOOST_SPIRIT_FILEITERATOR_STDを定義し，std_file_iteratorを使用す るようにした * time型，ipv4addr型, ipv6addr型を追加 2008-10-31 Kenta HATTORI * uint型を追加 2008-10-26 Kenta HATTORI * ジェネレータのエラー処理の実装をリファクタ * enum定義のパースエラー時にredefined symbolエラーというメッセージ が表示されるバグを修正 2008-10-18 Kenta HATTORI * デフォルト値を設定できるように定義ファイルの文法解析部分の処理を 修正 conf4cpp-0.0.3/inc/0000755002370600234200000000000011103752641013031 5ustar hattoriispconf4cpp-0.0.3/inc/conf4cpp.hpp0000644002370600234200000000104211103752523015252 0ustar hattoriisp/*============================================================================= * * conf4cpp : Configuration file library for C++. * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef CONF4CPP_HPP #define CONF4CPP_HPP #define BOOST_SPIRIT_FILEITERATOR_STD #include #include #include #include #include #include #endif /* CONF4CPP_HPP */ conf4cpp-0.0.3/inc/conf4cpp/0000755002370600234200000000000011103752641014545 5ustar hattoriispconf4cpp-0.0.3/inc/conf4cpp/var.hpp0000644002370600234200000000434011103052251016035 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef VAR_HPP #define VAR_HPP #include #include #include #include #include #include using namespace std; namespace conf4cpp { typedef boost::make_recursive_variant< bool, int, unsigned int, double, string, struct tm, struct in_addr, struct in6_addr, pair, vector >::type var_t; enum { IS_BOOL, IS_INT, IS_UINT, IS_DOUBLE, IS_STRING, IS_TIME, IS_IPV4ADDR, IS_IPV6ADDR, IS_PAIR, IS_VECTOR, }; inline bool is_bool (const var_t& v) { return v.which() == IS_BOOL; } inline bool is_int (const var_t& v) { return v.which() == IS_INT; } inline bool is_uint (const var_t& v) { return v.which() == IS_UINT; } inline bool is_double (const var_t& v) { return v.which() == IS_DOUBLE; } inline bool is_string (const var_t& v) { return v.which() == IS_STRING; } inline bool is_time (const var_t& v) { return v.which() == IS_TIME; } inline bool is_ipv4addr (const var_t& v) { return v.which() == IS_IPV4ADDR; } inline bool is_ipv6addr (const var_t& v) { return v.which() == IS_IPV6ADDR; } inline bool is_pair (const var_t& v) { return v.which() == IS_PAIR; } inline bool is_vector (const var_t& v) { return v.which() == IS_VECTOR; } template const T& var2(const var_t &v) { return boost::get(v); } inline struct in_addr to_in_addr(in_addr_t n) { struct in_addr addr = {n}; return addr; } inline struct in6_addr to_in6_addr(uint8_t n1, uint8_t n2, uint8_t n3, uint8_t n4, uint8_t n5, uint8_t n6, uint8_t n7, uint8_t n8, uint8_t n9, uint8_t n10,uint8_t n11,uint8_t n12, uint8_t n13,uint8_t n14,uint8_t n15,uint8_t n16) { struct in6_addr addr = {{{n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16}}}; return addr; } } #endif /* VAR_HPP */ conf4cpp-0.0.3/inc/conf4cpp/type.hpp0000644002370600234200000000702311102345743016241 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef TYPE_HPP #define TYPE_HPP #include #include #include #include #include #include #include using namespace std; using namespace boost::spirit; namespace conf4cpp { enum ti_atomic_t { TI_BOOL, TI_INT, TI_UINT, TI_DOUBLE, TI_STRING, TI_TIME, TI_IPV4ADDR, TI_IPV6ADDR, }; struct ti_enum_t { ti_enum_t(const string& eid_) : eid(eid_) {} string eid; }; typedef boost::make_recursive_variant< ti_atomic_t, ti_enum_t, // enum type pair, // vector type vector // tuple type >::type type_t; enum { IS_ATOM_T, IS_ENUM_T, IS_VECT_T, IS_TUPLE_T }; inline bool is_atomic_type(const type_t& typ) { return typ.which() == IS_ATOM_T; } inline bool is_enum_type(const type_t& typ) { return typ.which() == IS_ENUM_T; } inline bool is_vector_type(const type_t& typ) { return typ.which() == IS_VECT_T; } inline bool is_tuple_type(const type_t& typ) { return typ.which() == IS_TUPLE_T; } inline bool is_prim_type(const type_t& typ) { return typ.which() < 2; } inline bool is_comp_type(const type_t& typ) { return !is_prim_type(typ); } class type_checker : public boost::static_visitor { public: type_checker(const var_t& v) : v_(v) {} error_t operator() (ti_atomic_t ta) const { switch (ta) { case TI_BOOL: if (is_bool(v_)) return error_none; break; case TI_INT: if (is_int(v_)||(is_uint(v_) && boost::get(v_) <= INT_MAX)) return error_none; break; case TI_UINT: if (is_uint(v_)) return error_none; break; case TI_DOUBLE: if (is_double(v_)) return error_none; break; case TI_STRING: if (is_string(v_)) return error_none; break; case TI_TIME: if (is_time(v_)) return error_none; break; case TI_IPV4ADDR: if (is_ipv4addr(v_)) return error_none; break; case TI_IPV6ADDR: if (is_ipv6addr(v_)) return error_none; break; default: assert(false); } return type_mismatch; } error_t operator() (ti_enum_t te) const { if (!is_pair(v_)) return type_mismatch; pair p = var2 >(v_); if (p.first != te.eid) return type_mismatch; return error_none; } error_t operator() (pair tp) const { if (!is_vector(v_)) return type_mismatch; vector vec = var2 >(v_); if (tp.first > 0 && tp.first != vec.size()) return invalid_length; for (unsigned int i = 0; i < vec.size(); i++) { error_t err; if ((err = apply_visitor(type_checker(vec[i]), tp.second)) != error_none) return err; } return error_none; } error_t operator() (vector tv) const { if (!is_vector(v_)) return type_mismatch; vector vec = var2 >(v_); if (vec.size() != tv.size()) return type_mismatch; for (unsigned int i = 0; i < tv.size(); i++) { error_t err; if ((err = apply_visitor(type_checker(vec[i]), tv[i])) != error_none) return err; } return error_none; } private: var_t v_; }; } #endif /* TYPE_HPP */ conf4cpp-0.0.3/inc/conf4cpp/error.hpp0000644002370600234200000000267511102345743016421 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef ERROR_HPP #define ERROR_HPP #include #include #include using namespace std; namespace conf4cpp { enum error_t { error_none, file_error, parse_error, invalid_length, type_mismatch, item_redefined, item_undefined, invalid_time, invalid_addr, }; class error : public exception { public: error(error_t err) throw() : msg_(err2str(err)) {} error(error_t err, int line) throw() : msg_(string(err2str(err)) + " at line: " + boost::lexical_cast(line)) {} error(error_t err, string item) throw() : msg_(string(err2str(err)) + ": " + item) {} virtual ~error() throw() {} const char* what() const throw() { return msg_.c_str(); } private: const string msg_; static const char *err2str(error_t err) { static const char* tbl[] = { "no error", "file error", "parse error", "invalid length", "type mismatch", "item redefined", "item undefined", "invalid time format", "invalid address format", }; return tbl[err]; } }; } #endif /* ERROR_HPP */ conf4cpp-0.0.3/inc/conf4cpp/config.hpp0000644002370600234200000000272411074640565016540 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef CONFIG_HPP #define CONFIG_HPP #include #include namespace conf4cpp { template class base_config { public: base_config(const string& fname) { derived_config_parser_T g(vm_); parse_config(fname, g); } protected: value_map_t vm_; private: void parse_config(const string& fname, const derived_config_parser_T& g) { typedef file_iterator file_iterator_t; file_iterator_t first(fname); if (!first) throw error(file_error); file_iterator_t last = first.make_end(); typedef position_iterator position_iterator_t; position_iterator_t begin(first, last, fname); position_iterator_t end; begin.set_tabchars(8); try { parse_info pinfo = parse(begin, end, g, eol_p|space_p|comment_p("#")); if (!pinfo.full) throw error(parse_error, pinfo.stop.get_position().line); } catch (boost::spirit::parser_error& e) { throw error(e.descriptor, e.where.get_position().line); } for (unsigned int i = 0; i < g.reqs.size(); i++) { if (vm_.find(g.reqs[i]) == vm_.end()) throw error(item_undefined, g.reqs[i]); } } }; } #endif /* CONFIG_HPP */ conf4cpp-0.0.3/inc/conf4cpp/version.hpp0000644002370600234200000000054411101365747016753 0ustar hattoriisp/*============================================================================= * * conf4cpp : Configuration file library for C++. * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef VERSION_HPP #define VERSION_HPP #define CONF4CPP_VERSION "0.0.3" #endif /* VERSION_HPP */ conf4cpp-0.0.3/inc/conf4cpp/parser.hpp0000644002370600234200000001577211103573172016566 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef PARSER_HPP #define PARSER_HPP #include #include #include #include #include #include using namespace std; using namespace boost::spirit; namespace conf4cpp { typedef map tyinfo_map_t; typedef map value_map_t; class store_value { public: typedef error_t result_type; store_value(const tyinfo_map_t& tm, value_map_t& vm) : tm_(tm), vm_(vm) {} error_t operator()(const string& kw, const var_t& v) { vector vec = var2 >(v); type_t typ = tm_[kw]; error_t err; if (is_prim_type(typ)) { if (vec.size() != 1) return type_mismatch; if ((err = apply_visitor(type_checker(vec[0]), typ)) != error_none) return err; if (vm_.find(kw) != vm_.end()) return item_redefined; vm_[kw] = vec[0]; } else { if (vec.size() == 1 && is_vector(vec[0])) { if ((err = apply_visitor(type_checker(vec[0]), typ)) != error_none) return err; if (vm_.find(kw) != vm_.end()) return item_redefined; vm_[kw] = vec[0]; } else { if ((err = apply_visitor(type_checker(v), typ)) != error_none) return err; if (vm_.find(kw) != vm_.end()) return item_redefined; vm_[kw] = v; } } return error_none; } private: tyinfo_map_t tm_; value_map_t& vm_; }; struct check_value { typedef void result_type; template void operator()(error_t err, const IteratorT& where) { if (err != error_none) throw_(where, err); } }; struct variant_val : closure { member1 val; }; struct string_val : closure { member1 val; }; struct item_val : closure { member1 kwid; member2 err;}; template struct base_config_parser : public grammar > { base_config_parser(value_map_t& vm) : vmap(vm) {} static var_t add_value(var_t& v1, const var_t& v2) { vector v = var2 >(v1); v.push_back(v2); return v; } template static InAddrT str2addr(const IteratorT& first, const IteratorT& last) { string s(first, last); InAddrT ret; if (inet_pton(af, s.c_str(), &ret) != 1) throw_(first, invalid_addr); return ret; } template static struct tm str2time(const char *fmt, const IteratorT& first, const IteratorT& last) { string s(first, last); struct tm ret = {0}; char *p = strptime(s.c_str(), fmt, &ret); if (p == NULL || *p != '\0') throw_(first, invalid_time); return ret; } vector reqs; tyinfo_map_t timap; value_map_t& vmap; template struct definition { rule config_r; rule value_r, atomic_value_r, bool_r, datetime_r; rule string_r; rule item_r; rule date_r, time_r, ipv4addr_r, ipv6addr_r; typename derived_T::keywords keywords_p; typename derived_T::constvals constvals_p; definition(base_config_parser const& self) { using phoenix::arg1; using phoenix::arg2; using phoenix::construct_; config_r = *item_r >> end_p; item_r = keywords_p[item_r.kwid = arg1] >> '=' >> value_r[item_r.err = phoenix::bind(store_value(self.timap,self.vmap))(item_r.kwid,arg1)] >> eps_p[phoenix::bind(check_value())(item_r.err,arg1)] >> ';'; value_r = atomic_value_r[value_r.val = construct_ >(1,arg1)] >> *(',' >> atomic_value_r[value_r.val = phoenix::bind(&add_value)(value_r.val,arg1)]); atomic_value_r = lexeme_d[(str_p("0x")|"0X") >> hex_p[atomic_value_r.val = arg1]] | datetime_r[atomic_value_r.val = arg1] | ipv4addr_r[atomic_value_r.val = phoenix::bind(&str2addr)(arg1,arg2)] | ipv6addr_r[atomic_value_r.val = phoenix::bind(&str2addr)(arg1,arg2)] | strict_real_p[atomic_value_r.val = arg1] | uint_p [atomic_value_r.val = arg1] | int_p [atomic_value_r.val = arg1] | bool_r [atomic_value_r.val = arg1] | string_r [atomic_value_r.val = arg1] | ch_p('{')[atomic_value_r.val = construct_ >()] >> !value_r[atomic_value_r.val = arg1] >> '}' // | '{' >> *item_r >> '}' | constvals_p [atomic_value_r.val = arg1]; bool_r = str_p("true") [bool_r.val = true ] | str_p("false")[bool_r.val = false]; string_r = confix_p('"', (*c_escape_ch_p)[string_r.val = construct_(arg1,arg2)], '"'); datetime_r = (date_r >> time_r)[datetime_r.val = phoenix::bind(&str2time)("%Y/%m/%d %T",arg1,arg2)] | date_r[datetime_r.val = phoenix::bind(&str2time)("%Y/%m/%d",arg1,arg2)]; date_r = lexeme_d[repeat_p(1,4)[digit_p] >> "/" >> repeat_p(1,2)[digit_p] >> "/" >> repeat_p(1,2)[digit_p]]; time_r = lexeme_d[repeat_p(1,2)[digit_p] >> ":" >> repeat_p(1,2)[digit_p] >> ":" >> repeat_p(1,2)[digit_p]]; ipv4addr_r = lexeme_d[repeat_p(3)[repeat_p(1,3)[digit_p] >> "."] >> repeat_p(1,3)[digit_p]]; ipv6addr_r = lexeme_d[repeat_p(7)[repeat_p(1,4)[xdigit_p] >> ":"] >> repeat_p(1,4)[xdigit_p]] | lexeme_d[(repeat_p(1,7)[repeat_p(1,4)[xdigit_p] >> ":"] | ":") >> (repeat_p(1,7)[":" >> repeat_p(1,4)[xdigit_p]] | ":")]; } rule const& start() const { return config_r; } }; }; } #endif /* PARSER_HPP */ conf4cpp-0.0.3/src/0000755002370600234200000000000011103752641013047 5ustar hattoriispconf4cpp-0.0.3/src/confgen.cpp0000644002370600234200000002603611103733674015206 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #include "confgen.hpp" void confgen::output_interface_header(ostream& os) { os << "// conf4cpp : interface definition" << endl; output_file_header(os); os << "#include " << endl << "#include " << endl << "using boost::tuple;" << endl; } void confgen::output_implementation_header(ostream& os, const string& incfile) { os << "// conf4cpp : implementation file" << endl; output_file_header(os); os << "#include " << endl << "#include " << endl << "#include " << endl; os << "#include \"" << incfile << "\"" << endl << "using namespace conf4cpp;" << endl; } void confgen::output_file_header(ostream& os) { os << "// This code has been automatically generated by conf4cpp." << endl; } // // output_interface: // output interface part of config file class // // --- // class XXX_parser; // class XXX : public base_config { // public: // // definitions of enumeration type // enum xxx { ... }; // enum yyy { ... }; // XXX(const string& fname); // // // definitions of accessor methods // const xxx_t& xxx() const { return xxx_; } // bool has_xxx() const { return has_xxx_; } // // private: // // definitions of members // xxx_t xxx_; // bool has_xxx_t_; // }; // void confgen::output_interface(ostream& os) { os << "//=============================================================================" << endl << "// [" << conf_name_ << "]" << endl << "//" << endl; os << "struct " << conf_name_ << "_parser;" << endl; os << "class " << conf_name_ << " : public conf4cpp::base_config<" << conf_name_ << "_parser>" << endl; os << "{" << endl; os << "public:" << endl; os << "\t" << conf_name_ << "(const string& fname);" << endl; output_interface_enumdefs(os); output_interface_accessors(os); os << "\tvoid dump(ostream& os);" << endl; for (map >::const_iterator iter = enumelem_map_.begin(); iter != enumelem_map_.end(); ++iter) { os << "\tstatic const char* enum2str(" << iter->first << " e);" << endl; } os << "private:" << endl; output_interface_members(os); os << "};" << endl; } void confgen::output_interface_enumdefs(ostream& os) { os << "\t// definitions of enum type" << endl; for (map >::const_iterator iter = enumelem_map_.begin(); iter != enumelem_map_.end(); ++iter) { os << "\tenum " << iter->first << " { "; for (unsigned int i = 0; i < iter->second.size(); i++) { os << iter->second[i] << ", "; } os << "};" << endl; } } void confgen::output_interface_accessors(ostream& os) { os << "\t// definitions of accessors" << endl; for (map >::const_iterator iter = itemtypvar_map_.begin(); iter != itemtypvar_map_.end(); ++iter) { os << "\tconst " << get_typestr(iter->second.first) << "& " << iter->first << "() const { return " << iter->first << "_; }" << endl; if (!itemreq_map_.find(iter->first)->second) os << "\tbool has_" << iter->first << "() const { return has_" << iter->first << "_; }" << endl; } } void confgen::output_interface_members(ostream& os) { os << "\t// definitions of members" << endl; for (map >::const_iterator iter = itemtypvar_map_.begin(); iter != itemtypvar_map_.end(); ++iter) { os << "\t" << get_typestr(iter->second.first) << " " << iter->first << "_;" << endl; if (!itemreq_map_.find(iter->first)->second) os << "\tbool has_" << iter->first << "_;" << endl; } } // // output_implementation: // output implementation part of config file class // // --- // #include "XXX.out.hpp" // struct XXX_parser : public base_config_parser { // }; // void confgen::output_implementation(ostream& os) { os << "//=============================================================================" << endl << "// [" << conf_name_ << "_parser]" << endl << "//" << endl; os << "struct " << conf_name_ << "_parser : public base_config_parser<" << conf_name_ << "_parser>" << endl; os << "{" << endl; output_implementation_keywords(os); output_implementation_constvals(os); output_implementation_parser_constructor(os); os << "};" << endl; output_implementation_config_constructor(os); output_implementation_config_enum2str(os); output_implementation_config_dump(os); } void confgen::output_implementation_keywords(ostream& os) { os << "\tstruct keywords : symbols" << endl; os << "\t{" << endl; os << "\t\tkeywords() {" << endl; if (itemtypvar_map_.begin() != itemtypvar_map_.end()) { os << "\t\t\tadd" << endl; for (map >::const_iterator iter = itemtypvar_map_.begin(); iter != itemtypvar_map_.end(); ++iter) { os << "\t\t\t(\"" << iter->first << "\", \"" << iter->first << "\")" << endl; } os << "\t\t\t;" << endl; } os << "\t\t}" << endl; os << "\t};" << endl; } void confgen::output_implementation_constvals(ostream& os) { os << "\tstruct constvals : symbols >" << endl; os << "\t{" << endl; os << "\t\tconstvals() {" << endl; if (enumelem_map_.begin() != enumelem_map_.end()) { os << "\t\t\tadd" << endl; for (map >::const_iterator iter = enumelem_map_.begin(); iter != enumelem_map_.end(); ++iter) { for (unsigned int i = 0; i < enumelem_map_.find(iter->first)->second.size(); i++) { os << "\t\t\t(\"" << enumelem_map_.find(iter->first)->second[i] << "\", make_pair(string(\"" << iter->first << "\"), " << conf_name_ << "::" << enumelem_map_.find(iter->first)->second[i] << "))" << endl; } } os << "\t\t\t;" << endl; } os << "\t\t}" << endl; os << "\t};" << endl; } // // XXX_parser(value_map_t& vmap_) : base_config_parser(vmap_) // { // } // void confgen::output_implementation_parser_constructor(ostream& os) { os << "\t" << conf_name_ << "_parser(value_map_t& vm) : base_config_parser<" << conf_name_ << "_parser>(vm)" << endl; os << "\t{" << endl; // set required items os << "\t\t// set required items" << endl; for (map::const_iterator iter = itemreq_map_.begin(); iter != itemreq_map_.end(); ++iter) { if (iter->second) os << "\t\treqs.push_back(\"" << iter->first << "\");" << endl; } // set item type os << "\t\t// set item type" << endl; os << "\t\tvector > tvv;" << endl << "\t\tvector tv;" << endl; for (map >::const_iterator iter = itemtypvar_map_.begin(); iter != itemtypvar_map_.end(); ++iter) { os << "\t\ttimap[\"" << iter->first << "\"] = " << get_tsetstr(iter->second.first, 1) << ";" << endl; } os << "\t}" << endl; } // // XXX::XXX(const string& fname) : base_config(fname) // { // xxx_ = var2int(vm_["xxx"]); // has_xxx_ = true; // yyy_ = var2bool(vm_["yyy"]); // yas_zzz_ = false; // ... // } // void confgen::output_implementation_config_constructor(ostream& os) { os << "// definition config constructor" << endl; os << conf_name_ << "::" << conf_name_ << "(const string& fname) : base_config<" << conf_name_ << "_parser>(fname)" << endl; os << "{" << endl; os << "\tusing boost::make_tuple;" << endl << "\tvar_t v_ __attribute__((unused));" << endl << "\ttime_t t_ __attribute__((unused));" << endl; for (map >::const_iterator iter = itemtypvar_map_.begin(); iter != itemtypvar_map_.end(); ++iter) { if (!itemreq_map_.find(iter->first)->second) { // オプション項目 os << "\tif (vm_.find(\"" << iter->first << "\")!=vm_.end()) {" << endl; os << "\t\tv_ = vm_[\"" << iter->first << "\"];" << endl; os << "\t\t" << get_vsetstr(iter->second.first, iter->first+"_", "v_", 3) << endl; os << "\t\thas_" << iter->first << "_ = true;" << endl << "\t}" << endl << "\telse {" << endl << "\t\thas_" << iter->first << "_ = false;" << endl << "\t\t" << iter->first << "_ = " << get_defvstr(iter->second.first, iter->second.second) << ";" << endl << "\t}" << endl; } else { // 必須項目 os << "\tv_ = vm_[\"" << iter->first << "\"];" << endl; os << "\t" << get_vsetstr(iter->second.first, iter->first+"_", "v_", 2) << endl; } } os << "}" << endl; } void confgen::output_implementation_config_enum2str(ostream& os) { os << "// definition config enum2str" << endl; for (map >::const_iterator iter = enumelem_map_.begin(); iter != enumelem_map_.end(); ++iter) { os << "const char* " << conf_name_ << "::enum2str(" << iter->first << " e) {" << endl; os << "\tstatic const char* enumelem_tbl[] = {"; for (unsigned int i = 0; i < iter->second.size(); i++) { os << "\"" << iter->second[i] << "\", "; } os << "};" << endl; os << "\treturn enumelem_tbl[e];" << endl; os << "}" << endl; } } void confgen::output_implementation_config_dump(ostream& os) { os << "// definition config dump" << endl; os << "void " << conf_name_ << "::dump(ostream& os) {" << endl; os << "\tchar buf[BUFSIZ] __attribute__((unused));" << endl; os << "\tos << \"[" << conf_name_ << "]\\n{\" << endl;" << endl; for (map >::const_iterator iter = itemtypvar_map_.begin(); iter != itemtypvar_map_.end(); ++iter) { if (!itemreq_map_.find(iter->first)->second) { // // os << "option: xxx = " << .... << ";" << endl; // os << "option: xxx = NONE" << .... << ";" << endl; os << "\tif (has_" << iter->first << "_) {" << endl; os << "\t\tos << \"\\toptional: " << iter->first << " = \";" << endl << get_dumpstr(iter->first, iter->second.first, 2) << "\t\tos << \";\" << endl;" << endl; os << "\t} else {" << endl; os << "\t\tos << \"\\toptional: " << iter->first << " = [DEFAULT]\";" << endl << get_dumpstr(iter->first, iter->second.first, 2) << "\t\tos << \";\" << endl;" << endl; os << "\t}" << endl; } else { os << "\tos << \"\\trequired: " << iter->first << " = \";" << endl << get_dumpstr(iter->first, iter->second.first, 1) << "\tos << \";\" << endl;" << endl; } } os << "\tos << \"}\" << endl;" << endl; os << "}" << endl; } conf4cpp-0.0.3/src/confgen.hpp0000644002370600234200000003256511103573172015212 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef CONFGEN_HPP #define CONFGEN_HPP #include #include #include #include #include #include #include "confdef_g.hpp" using namespace std; using namespace conf4cpp; class confgen { public: confgen(confdef_g& g) : conf_name_(g.conf_name), itemtypvar_map_(g.itemtypvar_map), itemreq_map_(g.itemreq_map), enumelem_map_(g.enumelem_map) {} void output_interface(ostream& os); void output_implementation(ostream& os); static void output_interface_header(ostream& os); static void output_implementation_header(ostream& os, const string& incfile); private: // // format string for type variant // struct type_string : public boost::static_visitor { string operator() (ti_atomic_t ta) const { switch (ta) { case TI_BOOL: return "bool"; case TI_INT: return "int"; case TI_UINT: return "unsigned int"; case TI_DOUBLE: return "double"; case TI_STRING: return "string"; case TI_TIME: return "struct tm"; case TI_IPV4ADDR: return "struct in_addr"; case TI_IPV6ADDR: return "struct in6_addr"; } assert(false); return "???"; } string operator() (ti_enum_t te) const { return te.eid; } string operator() (pair tp) const { return string("vector<") + apply_visitor(type_string(),tp.second) + " >"; } string operator() (vector tv) const { string ret("tuple<"); for (unsigned int i = 0; i < tv.size()-1; i++) { ret += apply_visitor(type_string(),tv[i]) + ","; } ret += apply_visitor(type_string(),tv.back()) + " >"; return ret; } }; // // format string for type information // struct tset_string : public boost::static_visitor { tset_string(unsigned int lv_) : lv(lv_) {} string operator() (ti_atomic_t ta) const { switch (ta) { case TI_BOOL: return "TI_BOOL"; case TI_INT: return "TI_INT"; case TI_UINT: return "TI_UINT"; case TI_DOUBLE: return "TI_DOUBLE"; case TI_STRING: return "TI_STRING"; case TI_TIME: return "TI_TIME"; case TI_IPV4ADDR: return "TI_IPV4ADDR"; case TI_IPV6ADDR: return "TI_IPV6ADDR"; } assert(false); return "???"; } string operator() (ti_enum_t te) const { return string("ti_enum_t(\"") + boost::lexical_cast(te.eid) + "\")"; } string operator() (pair tp) const { return string("make_pair(") + boost::lexical_cast(tp.first) + "," + apply_visitor(tset_string(lv+1),tp.second) + ")"; } string operator() (vector tv) const { string ret("(\n" + indent(lv)); ret += "tvv.push_back(vector()),\n" + indent(lv); for (unsigned int i = 0; i < tv.size()-1; i++) { ret += "tvv.back().push_back(" + apply_visitor(tset_string(lv+1),tv[i]) + "),\n" + indent(lv); } ret += "tvv.back().push_back(" + apply_visitor(tset_string(lv+1),tv.back()) + "),\n" + indent(lv); ret += "tv=tvv.back(),tvv.pop_back(),tv)"; return ret; } unsigned int lv; }; struct vset_string : public boost::static_visitor { vset_string(const map >& eem_, const string& lhs_, const string& rhs_, unsigned int lv_) : eem(eem_), lhs(lhs_), rhs(rhs_), lv(lv_) {} string operator() (ti_atomic_t ta) const { switch (ta) { case TI_BOOL: return lhs + " = var2(" + rhs + ");"; case TI_INT: return lhs + " = is_int(" + rhs + ") ? var2(" + rhs + ") : var2(" + rhs + ");"; case TI_UINT: return lhs + " = var2(" + rhs + ");"; case TI_DOUBLE: return lhs + " = var2(" + rhs + ");"; case TI_STRING: return lhs + " = var2(" + rhs + ");"; case TI_TIME: return lhs + " = var2(" + rhs + ");"; case TI_IPV4ADDR: return lhs + " = var2(" + rhs + ");"; case TI_IPV6ADDR: return lhs + " = var2(" + rhs + ");"; } assert(false); return "???"; } string operator() (ti_enum_t te) const { if (eem.find(te.eid) == eem.end()) { assert(false); } return lhs + " = " + te.eid + "(var2 >(" + rhs + ").second);"; } string operator() (pair tp) const { string istr = "i"+boost::lexical_cast(lv); string ret("vector " + lhs + "v = var2 >(" + rhs + ");\n" + indent(lv-1)); ret += "for (unsigned int "+istr+" = 0; "+istr+" < " + lhs + "v.size(); "+istr+"++) {\n" + indent(lv); ret += apply_visitor(type_string(),tp.second) + " " + lhs + "iv;\n" + indent(lv); ret += apply_visitor(vset_string(eem,lhs+"iv",lhs+"v["+istr+"]",lv+1),tp.second) + "\n" + indent(lv); ret += lhs + ".push_back(" + lhs + "iv);\n" + indent(lv-1); ret += "}"; return ret; } string operator() (vector tv) const { string ret; for (unsigned int i = 0; i < tv.size(); i++) { string tystr = apply_visitor(type_string(), tv[i]); string istr = boost::lexical_cast(i); ret += tystr + " " + lhs + istr + ";\n" + indent(lv-1); ret += apply_visitor(vset_string(eem,lhs+istr,"var2 >("+rhs+")["+istr+"]",lv),tv[i]) + "\n" + indent(lv-1); } ret += lhs + " = make_tuple("; for (unsigned int i = 0; i < tv.size()-1; i++) { ret += lhs + boost::lexical_cast(i) + ","; } ret += lhs + boost::lexical_cast(tv.size()-1) + ");"; return ret; } const map >& eem; const string& lhs; const string& rhs; unsigned int lv; }; // // format string for default value setting // struct defv_string : public boost::static_visitor { defv_string(const var_t& dv_) : dv(dv_) {} string operator() (ti_atomic_t ta) const { switch (ta) { case TI_BOOL: return var2(dv) ? "true" : "false"; case TI_INT: if (is_uint(dv)) return boost::lexical_cast(var2(dv)); else return boost::lexical_cast(var2(dv)); case TI_UINT: return boost::lexical_cast(var2(dv)) + "U"; case TI_DOUBLE: return boost::lexical_cast(var2(dv)); case TI_STRING: return "\"" + var2(dv) + "\""; case TI_TIME: { struct tm t = var2(dv); string ret("*localtime((t_="); ret += boost::lexical_cast(mktime(&t)) + ",&t_))"; return ret; } case TI_IPV4ADDR: return "to_in_addr("+ boost::lexical_cast(var2(dv).s_addr) + ")"; case TI_IPV6ADDR: { struct in6_addr addr = var2(dv); unsigned int i; string ret("to_in6_addr("); for (i = 0; i < sizeof(addr.s6_addr)-1; i++) { ret += boost::lexical_cast(int(addr.s6_addr[i])) + ","; } ret += boost::lexical_cast(int(addr.s6_addr[i])) + ")"; return ret; } } assert(false); return "???"; } string operator() (ti_enum_t te) const { if (is_int(dv)) { return te.eid + "(0)"; } return var2(dv); } string operator() (pair tp) const { if (tp.first == 0) { return string("vector<") + apply_visitor(type_string(),tp.second) + " >()"; } else { return string("vector<") + apply_visitor(type_string(),tp.second) + " >(" + boost::lexical_cast(tp.first) + "," + apply_visitor(defv_string(dv),tp.second) + ")"; } } string operator() (vector tv) const { string ret("make_tuple("); vector vec = boost::get >(dv); for (unsigned int i = 0; i < tv.size()-1; i++) { ret += apply_visitor(defv_string(vec[i]), tv[i]) + ","; } ret += apply_visitor(defv_string(vec.back()), tv.back()) + ")"; return ret; } const var_t& dv; }; // // format string for value dump // struct dump_string : public boost::static_visitor { dump_string(const string& kw_, unsigned int lv_) : kw(kw_), lv(lv_) {} string operator() (ti_atomic_t ta) const { switch (ta) { case TI_BOOL: return indent(lv) + "os << (" + kw + " ? \"true\" : \"false\");\n"; case TI_INT: case TI_UINT: case TI_DOUBLE: return indent(lv) + "os << " + kw + ";\n"; case TI_STRING: return indent(lv) + "os << \"\\\"\" << " + kw + " << \"\\\"\";\n"; case TI_TIME: return indent(lv) + "os << " + "(strftime(buf,sizeof(buf),\"\%Y/\%m/\%d \%T\",&" + kw + "),buf);\n"; case TI_IPV4ADDR: return indent(lv) + "os << " + "inet_ntop(AF_INET, &" + kw + ", buf, INET_ADDRSTRLEN);\n"; case TI_IPV6ADDR: return indent(lv) + "os << " + "inet_ntop(AF_INET6, &" + kw + ", buf, INET6_ADDRSTRLEN);\n"; } return "???"; } string operator() (ti_enum_t te) const { return indent(lv) + "os << enum2str(" + kw + ");\n"; } string operator() (pair tp) const { // os << "{ "; // unsigned int i#lv; // for (i#lv = 0; i#lv < #kw.size()-1; i++) { // apply_visitor(dump_string(#kw[i#lv], lv+1), tp.second); // os << ","; // } // apply_visitor(dump_string(#kw[i#lv]}, lv+1), tp.second); // os << "}"; string ret; string istr = "i" + boost::lexical_cast(lv); ret += indent(lv) + "os << \"{\";\n"; ret += indent(lv) + "for (unsigned int " + istr + " = 0; " + istr + " < " + kw + ".size(); " + istr + "++) {\n"; ret += apply_visitor(dump_string(kw+"["+istr+"]",lv+1),tp.second); ret += indent(lv+1) + "if (" + istr + " < " + kw + ".size()-1) os << \",\";\n"; ret += indent(lv) + "}\n"; ret += indent(lv) + "os << \"}\";\n"; return ret; } string operator() (vector tv) const { string ret; ret += indent(lv) + "os << \"{\";\n"; unsigned int i; for (i = 0; i < tv.size()-1; i++) { ret += apply_visitor(dump_string("boost::get<"+boost::lexical_cast(i)+">("+kw+")",lv),tv[i]); ret += indent(lv) + "os << \",\";\n"; } ret += apply_visitor(dump_string("boost::get<"+boost::lexical_cast(i)+">("+kw+")",lv),tv[i]); ret += indent(lv) + "os << \"}\";\n"; return ret; } const string& kw; unsigned int lv; }; string get_typestr(const type_t& ty) { return apply_visitor(type_string(), ty); } string get_tsetstr(const type_t& ty, unsigned int lv) { return apply_visitor(tset_string(lv), ty); } string get_vsetstr(const type_t& ty, const string& lhs, const string& rhs, unsigned int lv) { return apply_visitor(vset_string(enumelem_map_,lhs,rhs,lv), ty); } string get_defvstr(const type_t& ty, const var_t& dv) { return apply_visitor(defv_string(dv), ty); } string get_dumpstr(const string& kw, const type_t& ty, unsigned int lv) { return apply_visitor(dump_string(kw+"_", lv), ty); } static string indent(unsigned int lv) { string ret; for (unsigned int i = 0; i < lv; i++) ret += "\t"; return ret; } static void output_file_header(ostream& os); void output_interface_enumdefs(ostream& os); void output_interface_accessors(ostream& os); void output_interface_members(ostream& os); void output_implementation_keywords(ostream& os); void output_implementation_constvals(ostream& os); void output_implementation_parser_constructor(ostream& os); void output_implementation_config_constructor(ostream& os); void output_implementation_config_enum2str(ostream& os); void output_implementation_config_dump(ostream& os); const string conf_name_; const map > itemtypvar_map_; const map itemreq_map_; const map > enumelem_map_; }; #endif /* CONFGEN_HPP */ conf4cpp-0.0.3/src/confdef_g.hpp0000644002370600234200000004025211103717707015501 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef CONFDEF_HPP #define CONFDEF_HPP #include #include #include #include #include #include using namespace std; using namespace boost::spirit; using namespace conf4cpp; struct confdef_g : public grammar { struct typvar_val : closure >{ member1 val; }; struct typvar_uint_val : closure, unsigned int> { member1 val; member2 len; }; struct typvars_val : closure > > { member1 val; }; struct uint_val : closure { member1 val; }; struct bool_val : closure { member1 val; }; struct string_val : closure { member1 val; }; struct strvec_val : closure > { member1 val; }; enum symtype_t { SYM_RESERVED, SYM_TYPENAME, SYM_CONFIG, SYM_ENUM, SYM_ELEM, SYM_ITEM, }; struct sym_s : symbols > { sym_s() { add ("enum" , make_pair(SYM_RESERVED, TI_BOOL)) ("config" , make_pair(SYM_RESERVED, TI_BOOL)) ("required" , make_pair(SYM_RESERVED, TI_BOOL)) ("optional" , make_pair(SYM_RESERVED, TI_BOOL)) ("bool" , make_pair(SYM_TYPENAME, TI_BOOL)) ("real" , make_pair(SYM_TYPENAME, TI_DOUBLE)) ("int" , make_pair(SYM_TYPENAME, TI_INT)) ("uint" , make_pair(SYM_TYPENAME, TI_UINT)) ("string" , make_pair(SYM_TYPENAME, TI_STRING)) ("time" , make_pair(SYM_TYPENAME, TI_TIME)) ("ipv4addr" , make_pair(SYM_TYPENAME, TI_IPV4ADDR)) ("ipv6addr" , make_pair(SYM_TYPENAME, TI_IPV6ADDR)) ("list" , make_pair(SYM_TYPENAME, TI_BOOL)) ; } }; template struct add_sym { sym_s& sym; add_sym(sym_s &sym_) : sym(sym_) {} template void operator() (const IteratorT& first, const IteratorT& last) const { string key(first, last); sym.add(key.c_str(), make_pair(styp, TI_BOOL)); } }; struct add_enumsym { sym_s& sym; add_enumsym(sym_s &sym_) : sym(sym_) {} template void operator() (const IteratorT& first, const IteratorT& last) const { string key(first, last); sym.add(key.c_str(), make_pair(SYM_ENUM, ti_enum_t(key))); } }; struct add_elemsym { sym_s& sym; string en; add_elemsym(sym_s &sym_, const string& en_) : sym(sym_), en(en_) {} template void operator() (const IteratorT& first, const IteratorT& last) const { string key(first, last); sym.add(key.c_str(), make_pair(SYM_ELEM, ti_enum_t(en))); } }; struct chk_defval { typedef void result_type; const type_t &te; const var_t &v; chk_defval(const type_t& te_, const var_t& v_) : te(te_), v(v_) {} template void operator() (const IteratorT& first, const IteratorT& last) const { ti_atomic_t ta = boost::get(te); switch (ta) { case TI_DOUBLE: if (is_double(v)) return; break; case TI_INT: if (is_int(v)||(is_uint(v) && boost::get(v) <= INT_MAX)) return; break; case TI_UINT: if (is_uint(v)) return; break; case TI_STRING: if (is_string(v)) return; break; case TI_BOOL: if (is_bool(v)) return; break; case TI_TIME: if (is_time(v)) return; break; case TI_IPV4ADDR: if (is_ipv4addr(v)) return; break; case TI_IPV6ADDR: if (is_ipv6addr(v)) return; break; } throw_(first, string("type mismatch")); } }; struct chk_enumelem { typedef void result_type; const map >& eem; const type_t &te; chk_enumelem(const map >&eem_, const type_t& te_) : eem(eem_), te(te_) {} template void operator() (const IteratorT& first, const IteratorT& last) const { string key(first, last); if (!is_enum_type(te)) throw_(first, string("type mismatch")); string eid = boost::get(te).eid; if (eem.find(eid) == eem.end()) throw_(first, string("type mismatch")); for (unsigned int i = 0; i < eem.find(eid)->second.size(); i++) { if (eem.find(eid)->second[i] == key) return; } throw_(first, string("type mismatch")); } }; // (uint,pair) -> pair,var_t> static pair make_typvar(unsigned int l, const pair& typvar) { return make_pair(make_pair(l,typvar.first),typvar.second); } // vector> -> pair static pair split_typvars(const vector >& typvars) { vector typs; vector vars; for (vector >::const_iterator iter = typvars.begin(); iter != typvars.end(); ++iter) { typs.push_back(iter->first); vars.push_back(iter->second); } return make_pair(typs,vars); } struct strip_typvar { typedef pair result_type; result_type operator()(const vector >& tvs) { if (tvs.size() == 1) return tvs.front(); return split_typvars(tvs); } }; static void add_typvar(vector >& tvs, const pair& tv) { tvs.push_back(tv); } static var_t def_value(const type_t& ty) { if (is_atomic_type(ty)) { ti_atomic_t ta = boost::get(ty); switch (ta) { case TI_BOOL: return bool(false); case TI_INT: return int(0); case TI_UINT: return (unsigned int)(0); case TI_DOUBLE: return double(0.0); case TI_STRING: return string(""); case TI_TIME: { time_t t = 0; struct tm ret = *localtime(&t); return ret; } case TI_IPV4ADDR: { struct in_addr ret = {0}; return ret; } case TI_IPV6ADDR: { struct in6_addr ret = {{{0}}}; return ret; } } } else if (is_enum_type(ty)) { return 0; } assert(false); return false; // return dummy value } template static InAddrT str2addr(const IteratorT& first, const IteratorT& last) { string s(first, last); InAddrT ret; if (inet_pton(af, s.c_str(), &ret) != 1) throw_(first, string("invalid address format")); return ret; } template static struct tm str2time(const char *fmt, const IteratorT& first, const IteratorT& last) { string s(first, last); struct tm ret = {0}; char *p = strptime(s.c_str(), fmt, &ret); if (p == NULL || *p != '\0') throw_(first, string("invalid time format")); return ret; } template struct definition { rule config_r, spec_r, itemdef_r, enumdef_r; rule texp_r, atomic_texp_r; rule postfix_texp_r ; rule compound_texp_r; rule list_type_r; rule value_r, datetime_r; rule mandatory_r, constraints_r; rule new_sym, id_r; rule date_r, time_r, ipv4addr_r, ipv6addr_r; rule elemseq_r; rule newconf_sym, newitem_sym, newenum_sym, newelem_sym; rule string_r; rule bool_r; sym_s sym_p; definition(confdef_g const& self) { assertion expect_elem("no enum element"); assertion rsvwd_redef("reserved word redefined"); assertion typnm_redef("type name redefined"); assertion symbol_redef("symbol redefined"); assertion type_mismatch("type mismatch"); assertion parse_failed("parser error"); using phoenix::arg1; using phoenix::arg2; using phoenix::var; using phoenix::val; using phoenix::bind; using phoenix::construct_; using phoenix::static_cast_; // // ::= config { * } // ::= | // ::= ? : ; // ::= enum { (, )* } // ::= required | optional // config_r = lexeme_d[str_p("config") >> blank_p] >> newconf_sym[var(self.conf_name)=arg1] >> '{' >> *spec_r >> '}' >> end_p; spec_r = (enumdef_r | itemdef_r); itemdef_r = eps_p[var(self.cur_req)=true] >> !mandatory_r >> newitem_sym[var(self.cur_sym)=arg1][insert_key_a(self.itemreq_map,self.cur_req)] >> ':' >> texp_r[insert_at_a(self.itemtypvar_map,self.cur_sym)] >> ';'; enumdef_r = lexeme_d[str_p("enum") >> blank_p] >> (( newenum_sym[var(self.cur_sym)=arg1] >> '{' >> expect_elem(elemseq_r[insert_at_a(self.enumelem_map,self.cur_sym)]) >> '}' ) | parse_failed(nothing_p)); mandatory_r = lexeme_d[str_p("required") >> blank_p] | lexeme_d[str_p("optional") >> blank_p][var(self.cur_req)=false]; // // ::= (, )* // ::= list ([ ])? < > // | (< >)? // ::= | bool | int | real | string // texp_r = compound_texp_r[texp_r.val=bind(strip_typvar())(arg1)]; compound_texp_r = postfix_texp_r[compound_texp_r.val=construct_ > >(1,arg1)] >> *(',' >> postfix_texp_r[bind(&add_typvar)(compound_texp_r.val,arg1)] ); postfix_texp_r = list_type_r[postfix_texp_r.len=arg1] >> '<' >> texp_r[postfix_texp_r.val=bind(&make_typvar)(postfix_texp_r.len,arg1)] >> '>' // >> !( '(' >> uint_p >> ')' ) | atomic_texp_r[postfix_texp_r.val=arg1] >> !('[' >> constraints_r >> ']'); list_type_r = str_p("list")[list_type_r.val=0] >> !('[' >> uint_p[list_type_r.val=arg1] >> ']'); atomic_texp_r = sym_p[var(self.cur_type)=arg1] >> eps_p(var(self.cur_type.first)==SYM_TYPENAME) [atomic_texp_r.val=construct_ >(var(self.cur_type.second),bind(&def_value)(var(self.cur_type.second)))] >> !( '(' >> ( value_r[var(self.cur_val)=arg1][atomic_texp_r.val=construct_ >(var(self.cur_type.second),arg1)] | ( sym_p[var(self.cur_type2)=arg1] >> eps_p(var(self.cur_type2.first)==SYM_ELEM) >> type_mismatch(nothing_p) ) ) >> eps_p[bind(chk_defval(self.cur_type.second,self.cur_val))(arg1,arg2)] >> ')' ) | sym_p[var(self.cur_type)=arg1] >> eps_p(var(self.cur_type.first)==SYM_ENUM) [atomic_texp_r.val=construct_ >(var(self.cur_type.second),bind(&def_value)(var(self.cur_type.second)))] >> !( '(' >> ( ( sym_p[var(self.cur_type2)=arg1] >> eps_p(var(self.cur_type2.first)==SYM_ELEM) ) [bind(chk_enumelem(self.enumelem_map,self.cur_type.second))(arg1,arg2)] [atomic_texp_r.val=construct_ >(var(self.cur_type.second),construct_(arg1,arg2))] | ( value_r >> type_mismatch(nothing_p) ) ) >> ')' ) | '(' >> compound_texp_r[atomic_texp_r.val=bind(&split_typvars)(arg1)] >> ')'; value_r = lexeme_d[((str_p("0x")|"0X") >> hex_p[value_r.val=arg1])] | datetime_r[value_r.val=arg1] | ipv4addr_r[value_r.val=phoenix::bind(&str2addr)(arg1,arg2)] | ipv6addr_r[value_r.val=phoenix::bind(&str2addr)(arg1,arg2)] | strict_real_p[value_r.val=arg1] | uint_p [value_r.val=arg1] | int_p [value_r.val=arg1] | bool_r [value_r.val=arg1] | string_r [value_r.val=arg1]; bool_r = str_p("true") [bool_r.val=true] | str_p("false")[bool_r.val=false]; string_r = confix_p('"', (*c_escape_ch_p)[string_r.val = construct_(arg1,arg2)], '"'); datetime_r = (date_r >> time_r)[datetime_r.val=phoenix::bind(&str2time)("%Y/%m/%d %T",arg1,arg2)] | date_r[datetime_r.val=phoenix::bind(&str2time)("%Y/%m/%d",arg1,arg2)]; date_r = lexeme_d[repeat_p(1,4)[digit_p] >> "/" >> repeat_p(1,2)[digit_p] >> "/" >> repeat_p(1,2)[digit_p]]; time_r = lexeme_d[repeat_p(1,2)[digit_p] >> ":" >> repeat_p(1,2)[digit_p] >> ":" >> repeat_p(1,2)[digit_p]]; ipv4addr_r = lexeme_d[repeat_p(3)[repeat_p(1,3)[digit_p] >> "."] >> repeat_p(1,3)[digit_p]]; ipv6addr_r = lexeme_d[repeat_p(7)[repeat_p(1,4)[xdigit_p] >> ":"] >> repeat_p(1,4)[xdigit_p]] | lexeme_d[(repeat_p(1,7)[repeat_p(1,4)[xdigit_p] >> ":"] | ":") >> (repeat_p(1,7)[":" >> repeat_p(1,4)[xdigit_p]] | ":")]; // not yet implemented constraints_r = eps_p; id_r = lexeme_d[(alpha_p|'_') >> +(alnum_p|'_')]; new_sym = (id_r - sym_p) | ( sym_p[var(self.cur_type)=arg1] >> ( ( eps_p(var(self.cur_type.first)==SYM_RESERVED) >> rsvwd_redef(nothing_p) ) | ( eps_p(var(self.cur_type.first)==SYM_TYPENAME) >> typnm_redef(nothing_p) ) | symbol_redef(nothing_p) ) ); newconf_sym = new_sym[add_sym(sym_p)][newconf_sym.val=construct_(arg1,arg2)]; newitem_sym = new_sym[add_sym(sym_p)][newitem_sym.val=construct_(arg1,arg2)]; newenum_sym = new_sym[add_enumsym(sym_p)][newenum_sym.val=construct_(arg1,arg2)]; newelem_sym = new_sym[add_elemsym(sym_p,self.cur_sym)][newelem_sym.val=construct_(arg1,arg2)]; elemseq_r = newelem_sym[var(self.elem_list)=construct_ >(1,arg1)] >> *(',' >> newelem_sym[push_back_a(self.elem_list)]) >> eps_p[elemseq_r.val=var(self.elem_list)]; } rule const& start() const { return config_r; } }; mutable string cur_sym; mutable bool cur_req; mutable pair cur_type, cur_type2; mutable var_t cur_val; mutable vector elem_list; mutable map > itemtypvar_map; mutable map > enumelem_map; mutable map itemreq_map; mutable string conf_name; }; #endif /* CONFDEF_HPP */ conf4cpp-0.0.3/src/Makefile0000644002370600234200000000105311074643517014516 0ustar hattoriispTARGET = conf4cpp SRCS = \ conf4cpp.cpp \ confgen.cpp CXXFLAGS= -Wall #CPPFLAGS= -I../inc CPPFLAGS= -I/usr/include/boost-1_33_1 -I../inc LIBS = OBJS = $(SRCS:.cpp=.o) DEPS = $(SRCS:.cpp=.d) %.o : %.cpp $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $< $(TARGET) : $(OBJS) $(CXX) $(CXXFLAGS) -o $@ $(OBJS) $(LIBS) .PHONY: clean clean : rm -fr $(OBJS) $(TARGET) $(DEPS) %.d : %.cpp @echo "generating dependency file: $@" @$(SHELL) -ec '$(CXX) -MM $(CPPFLAGS) $< \ | sed "s/\($*\)\.o[ :]*/\1.o $@ : /g" > $@; \ [ -s $@ ] || rm -f $@' -include $(DEPS) conf4cpp-0.0.3/src/conf4cpp.cpp0000644002370600234200000000776311103752523015303 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #include #include #include #include #include #include #include "confdef_g.hpp" #include "confgen.hpp" using namespace std; static const char* version = CONF4CPP_VERSION; static const char* program = "conf4cpp"; static void print_version() { fprintf(stdout, "%s %s\n", program, version); } static void print_usage() { fprintf(stderr, "Usage: %s [options] files...\n", program); fprintf(stderr, "options:\n" " -h, --help display this message\n" " -v, --version display version information\n" " -o, --output=name specify output file prefix name\n"); } int main(int argc, char* argv[]) { char *output_file_prefix = "conf.out"; for (;;) { static struct option long_options[] = { {"help", no_argument, NULL, 'h'}, {"version", no_argument, NULL, 'v'}, {"output", no_argument, NULL, 'o'}, {0,0,0,0} }; int option_index = 0; int c = getopt_long(argc, argv, "hvo:", long_options, &option_index); if (c == -1) break; switch (c) { case 'h': print_usage(); return 0; case 'v': print_version(); return 0; case 'o': output_file_prefix = optarg; break; case '?': print_usage(); return 0; default: fprintf(stderr, "?? getopt returned character code 0%o ??\n", c); } } if (optind >= argc) { fprintf(stderr, "%s: no input files\n", program); return -1; } string interface_file_name = string(output_file_prefix) + ".hpp"; string implementation_file_name = string(output_file_prefix) + ".cpp"; char tmp_hpp[] = ".hppXXXXXX"; char tmp_cpp[] = ".cppXXXXXX"; int hpp_fd = mkstemp(tmp_hpp); if (hpp_fd < 0) { fprintf(stderr, "cannot create temporary file\n"); return -1; } close(hpp_fd); int cpp_fd = mkstemp(tmp_cpp); if (cpp_fd < 0) { fprintf(stderr, "cannot create temporary file\n"); return -1; } close(cpp_fd); ofstream ofs_hpp(tmp_hpp); ofstream ofs_cpp(tmp_cpp); confgen::output_interface_header(ofs_hpp); confgen::output_implementation_header(ofs_cpp, interface_file_name); while (optind < argc) { const char* input_file = argv[optind++]; typedef file_iterator<> file_iterator_t; file_iterator_t first(input_file); if (!first) { fprintf(stderr, "%s: unable to open file\n", input_file); goto error_return; } file_iterator_t last = first.make_end(); typedef position_iterator position_iterator_t; position_iterator_t begin(first, last, input_file); position_iterator_t end; begin.set_tabchars(8); confdef_g g; try { parse_info pinfo = parse(begin, end, g, eol_p|space_p|comment_p("#")); if (!pinfo.full) { fprintf(stderr, "%s: %d: parse error\n", input_file, pinfo.stop.get_position().line); goto error_return; } } catch (boost::spirit::parser_error& e) { fprintf(stderr, "%s: %d: %s\n", input_file, e.where.get_position().line, e.descriptor.c_str()); goto error_return; } confgen gen(g); gen.output_interface(ofs_hpp); gen.output_implementation(ofs_cpp); } if (rename(tmp_hpp, interface_file_name.c_str()) < 0) { fprintf(stderr, "cannot create %s\n", interface_file_name.c_str()); goto error_return; } if (rename(tmp_cpp, implementation_file_name.c_str()) < 0) { fprintf(stderr, "cannot create %s\n", implementation_file_name.c_str()); ofs_hpp.close(); remove(interface_file_name.c_str()); goto error_return2; } return 0; error_return: ofs_hpp.close(); remove(tmp_hpp); error_return2: ofs_cpp.close(); remove(tmp_cpp); return -1; } conf4cpp-0.0.3/test/0000755002370600234200000000000011103752641013237 5ustar hattoriispconf4cpp-0.0.3/test/conf_no_items/0000755002370600234200000000000011103752641016061 5ustar hattoriispconf4cpp-0.0.3/test/conf_no_items/no_items.conf0000644002370600234200000000000011074107245020534 0ustar hattoriispconf4cpp-0.0.3/test/conf_no_items/Makefile0000644002370600234200000000067111074107245017526 0ustar hattoriispTARGET = conf_no_items SRCS = \ conf.out.cpp \ conf_no_items.cpp CONF4CPP= ../../src/conf4cpp CXXFLAGS= -Wall CPPFLAGS= -I/usr/include/boost-1_33_1 -I../../inc LIBS = OBJS = $(SRCS:.cpp=.o) %.o : %.cpp $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $< $(TARGET) : $(OBJS) $(CXX) $(CXXFLAGS) -o $@ $(OBJS) $(LIBS) conf.out.cpp : no_items.conf.def $(CONF4CPP) $< .PHONY: clean clean : rm -fr $(OBJS) $(TARGET) $(DEPS) conf.out.cpp conf.out.hpp conf4cpp-0.0.3/test/conf_no_items/no_items.conf.def0000644002370600234200000000003111074107245021275 0ustar hattoriispconfig conf_no_items { } conf4cpp-0.0.3/test/conf_no_items/conf_no_items.cpp0000644002370600234200000000033611074107245021412 0ustar hattoriisp#include #include "conf.out.hpp" int main(int argc, char* args[]) { if (argc < 2) { cout << "no input file.\n"; return -1; } conf_no_items conf(args[1]); conf.dump(cout); return 0; } conf4cpp-0.0.3/test/test_conf.cpp0000644002370600234200000001044211103573172015730 0ustar hattoriisp#include #include #include #include #include #include "conf.out.hpp" static bool tm_equal(const struct tm& t1, const struct tm& t2) { /* printf("tm_sec: %d,%d\n", t1.tm_sec, t2.tm_sec); printf("tm_min: %d,%d\n", t1.tm_min, t2.tm_min); printf("tm_hour: %d,%d\n", t1.tm_hour, t2.tm_hour); printf("tm_mday: %d,%d\n", t1.tm_mday, t2.tm_mday); printf("tm_mon: %d,%d\n", t1.tm_mon, t2.tm_mon); printf("tm_year: %d,%d\n", t1.tm_year, t2.tm_year); */ return t1.tm_sec == t2.tm_sec /* 秒 */ && t1.tm_min == t2.tm_min /* 分 */ && t1.tm_hour == t2.tm_hour /* 時間 */ && t1.tm_mday == t2.tm_mday /* 日 */ && t1.tm_mon == t2.tm_mon /* 月 */ && t1.tm_year == t2.tm_year; /* 年 */ } static bool ipv6_equal(const struct in6_addr& a1, const struct in6_addr& a2) { return memcmp(a1.s6_addr, a2.s6_addr, 16) == 0; } int main(int argc, char* args[]) { if (argc < 2) { cout << "no input file.\n"; return -1; } test_conf conf(args[1]); assert(!conf.has_string_val()); assert(conf.has_real_val()); assert(conf.real_val()==-32134.5643); assert(conf.string_list().size()==3); assert(conf.string_list()[0]=="foo"); assert(conf.string_list()[1]=="bar"); assert(conf.string_list()[2]=="baz"); assert(conf.string0_list().size()==0); assert(conf.int1_list().size()==1); assert(conf.int1_list()[0]==10); assert(conf.bool9_list().size()==9); assert(conf.bool9_list()[8]==true); assert(conf.real_llist().size()==5); assert(conf.real_llist()[3].size()==0); assert(conf.real_llist()[4][2]==1323.0); assert(boost::get<1>(conf.stri_list()[1])==-1234); assert(boost::get<0>(conf.rib_tuple())==1.234); assert(boost::get<1>(conf.rib_tuple())==5); assert(boost::get<2>(conf.rib_tuple())==true); assert(boost::get<0>(boost::get<0>(conf.string_tuple()))=="hoge"); assert(boost::get<0>(conf.week_fruits())==test_conf::MON); assert(boost::get<1>(conf.week_fruits()).size()==4); assert(boost::get<1>(conf.week_fruits())[0]==test_conf::Apple); assert(!conf.has_int_defval()); assert(!conf.has_int_defval2()); assert(conf.int_defval()==5); assert(conf.int_defval2()==0); assert(conf.bool_defval()==true); assert(conf.bool_defval2()==false); assert(conf.string_defval()=="hello"); assert(conf.string_defval2()==""); assert(conf.real_defval()==1.0123); assert(conf.real_defval2()==0.0); assert(boost::get<0>(conf.rib_tuple_def())==-3.14); assert(boost::get<1>(conf.rib_tuple_def())==5); assert(boost::get<2>(conf.rib_tuple_def())==false); assert(conf.stri_list_def().size()==3); assert(boost::get<0>(conf.stri_list_def()[1])=="hoge"); assert(boost::get<1>(conf.stri_list_def()[2])==1234); time_t t_ = 0; struct tm t = *localtime(&t_); assert(tm_equal(t,conf.date_value())); t.tm_year = 2003-1900; t.tm_mon = 12-1; t.tm_mday = 31; t.tm_hour = 0; t.tm_min = 0; t.tm_sec = 0; assert(tm_equal(t,conf.date_value2())); t.tm_year = 2008-1900; t.tm_mon = 1-1; t.tm_mday = 3; t.tm_hour = 17; t.tm_min = 20; t.tm_sec = 0; assert(tm_equal(t,conf.date_value3())); t.tm_year = 1972-1900; t.tm_mon = 9-1; t.tm_mday = 24; t.tm_hour = 5; t.tm_min = 12; t.tm_sec = 30; assert(tm_equal(t,conf.date_value4())); assert(conf.ipv4_value().s_addr==0); assert(conf.ipv4_value2().s_addr==inet_addr("192.168.0.1")); assert(conf.ipv4_value3().s_addr==inet_addr("4.3.2.1")); struct in6_addr ipv6 = {{{0}}}; assert(ipv6_equal(ipv6,conf.ipv6_value())); inet_pton(AF_INET6, "dead:beaf::1", &ipv6); assert(ipv6_equal(ipv6,conf.ipv6_value2())); inet_pton(AF_INET6, "dead:1234:ffff:ffff:2311:1111:0000:0232", &ipv6); assert(ipv6_equal(ipv6,conf.ipv6_value3())); inet_pton(AF_INET6, "::", &ipv6); assert(ipv6_equal(ipv6,conf.ipv6_value4())); inet_pton(AF_INET6, "::1", &ipv6); assert(ipv6_equal(ipv6,conf.ipv6_value5())); inet_pton(AF_INET6, "1:2:3::", &ipv6); assert(ipv6_equal(ipv6,conf.ipv6_value6())); inet_pton(AF_INET6, "1:2:3:4:5:6:7:8", &ipv6); assert(ipv6_equal(ipv6,conf.ipv6_value7())); conf.dump(cout); return 0; } conf4cpp-0.0.3/test/compile_error/0000755002370600234200000000000011103752641016100 5ustar hattoriispconf4cpp-0.0.3/test/compile_error/empty.conf.def0000644002370600234200000000000011100770172020624 0ustar hattoriispconf4cpp-0.0.3/test/compile_error/redefined.conf.2.def0000644002370600234200000000007011100615663021565 0ustar hattoriispconfig redefined_conf { enum foo_t { FOO, BAR, FOO } } conf4cpp-0.0.3/test/compile_error/redefined.conf.4.def0000644002370600234200000000006111100615663021567 0ustar hattoriispconfig redefined_conf { redefined_conf : int; } conf4cpp-0.0.3/test/compile_error/redefined.conf.1.def0000644002370600234200000000006311100615663021566 0ustar hattoriispconfig redefined_conf { foo : int; foo : bool; } conf4cpp-0.0.3/test/compile_error/typemismatch.conf.5.def0000644002370600234200000000013111100615663022350 0ustar hattoriispconfig type_mismatch_conf { enum foo_t { FOO } enum bar_t { BAR } foo : foo_t(BAR); } conf4cpp-0.0.3/test/compile_error/typemismatch.conf.1.def0000644002370600234200000000006211100615663022347 0ustar hattoriispconfig type_mismatch_conf { foo : int("hoge"); } conf4cpp-0.0.3/test/compile_error/typemismatch.conf.3.def0000644002370600234200000000011511100615663022350 0ustar hattoriispconfig type_mismatch_conf { enum foo_t { FOO, BAR, BAZ } foo : int(FOO); } conf4cpp-0.0.3/test/compile_error/compile_error.sh0000644002370600234200000000101311103731067021267 0ustar hattoriisp#!/bin/sh CONF4CPP=../../src/conf4cpp pass=0 total=0 for fname in *.def do $CONF4CPP $fname if test $? -ne 255 then echo "failed test case: $fname" else pass=`expr $pass + 1` fi total=`expr $total + 1` done echo if test $pass -eq $total then echo "******************************************" echo " all test case passed: $pass/$total " echo "******************************************" else echo "**************************" echo " $pass/$total passed " echo "**************************" fi conf4cpp-0.0.3/test/compile_error/noelement.conf.def0000644002370600234200000000005211100615663021466 0ustar hattoriispconfig redefined_conf { enum foo_t { } } conf4cpp-0.0.3/test/compile_error/typemismatch.conf.6.def0000644002370600234200000000006311102330675022354 0ustar hattoriispconfig type_mismatch_conf { foo : uint_t(-123); } conf4cpp-0.0.3/test/compile_error/typemismatch.conf.8.def0000644002370600234200000000006611102330675022361 0ustar hattoriispconfig type_mismatch_conf { foo : int(0xdeadbeef); } conf4cpp-0.0.3/test/compile_error/redefined.conf.3.def0000644002370600234200000000010211100615663021562 0ustar hattoriispconfig redefined_conf { enum foo_t { FOO } enum foo_t { BAR } } conf4cpp-0.0.3/test/compile_error/typemismatch.conf.7.def0000644002370600234200000000006611102330675022360 0ustar hattoriispconfig type_mismatch_conf { foo : int(2147483648); } conf4cpp-0.0.3/test/compile_error/redefined.conf.5.def0000644002370600234200000000010411100615663021566 0ustar hattoriispconfig redefined_conf { enum foo_t { foo, bar, baz } foo : int; } conf4cpp-0.0.3/test/compile_error/redefined.conf.6.def0000644002370600234200000000002211100615663021566 0ustar hattoriispconfig config { } conf4cpp-0.0.3/test/compile_error/typemismatch.conf.4.def0000644002370600234200000000012211100615663022347 0ustar hattoriispconfig type_mismatch_conf { enum foo_t { FOO, BAR, BAZ } foo : foo_t("hoge"); } conf4cpp-0.0.3/test/compile_error/typemismatch.conf.2.def0000644002370600234200000000005611100615663022353 0ustar hattoriispconfig type_mismatch_conf { foo : real(1); } conf4cpp-0.0.3/test/compile_error/redefined.conf.7.def0000644002370600234200000000004611100615663021575 0ustar hattoriispconfig redefined_conf { int : int; } conf4cpp-0.0.3/test/test.conf0000644002370600234200000000132711103573172015070 0ustar hattoriisp# # test.conf # int_val = -123; bool_val = false; real_val = -32134.5643; week_val = SUN; string_list = "foo","bar","baz"; string0_list = {}; int1_list = 10; bool9_list = true,true,true,true,false,false,false,false,true; real_llist = {1.0,2.0}, {3.0,4.0}, {5.0}, {}, {10.1234,20.3432,1323.0} ; ## # stri_list = {"hattori",1234},{"kenta",-1234}; rib_tuple = 1.234, 5, true; string_tuple = {{"hoge"}}; #string_val = "foo"; week_fruits = MON,{Apple,Orange,Orange,Lemon}; uint_defval = 0x05; date_value4 = 1972/9/24 5:12:30; ipv4_value3 = 4.3.2.1; ipv6_value7 = 1:2:3:4:5:6:7:8; netaddr_val = {10.0.0.0,8}; net6addr_val = {1:2:3::,24}; datadrstr_vals = {1924/5/30 5:20:1,10.11.3.2,"hattori"},{1911/11/3,32.21.45.8,"foo"}; conf4cpp-0.0.3/test/config_error/0000755002370600234200000000000011103752641015715 5ustar hattoriispconf4cpp-0.0.3/test/config_error/unclosedstr.conf0000644002370600234200000000006611103731067021132 0ustar hattoriispreq_int_val = 0; string_val = "hogehoge; uint_val = 5;conf4cpp-0.0.3/test/config_error/typemismatch.7.conf0000644002370600234200000000004611103731067021437 0ustar hattoriispreq_int_val = 0; fruit_val = "Apple"; conf4cpp-0.0.3/test/config_error/typemismatch.9.conf0000644002370600234200000000004111103731067021434 0ustar hattoriispreq_int_val = 0; ipv4_val = ::1; conf4cpp-0.0.3/test/config_error/invaliddate.7.conf0000644002370600234200000000006111103731067021211 0ustar hattoriispreq_int_val = 0; date_val = 2009/12/31 23:59:69; conf4cpp-0.0.3/test/config_error/typemismatch.3.conf0000644002370600234200000000005011103731067021426 0ustar hattoriispreq_int_val = 3; bool_val = false,true; conf4cpp-0.0.3/test/config_error/typemismatch.10.conf0000644002370600234200000000004511103731067021510 0ustar hattoriispreq_int_val = 0; ipv6_val = 1.2.3.4; conf4cpp-0.0.3/test/config_error/invalidipaddr.1.conf0000644002370600234200000000004311103731067021531 0ustar hattoriispreq_int_val = 0; ipv4_val = 0.0.0; conf4cpp-0.0.3/test/config_error/invalidipaddr.2.conf0000644002370600234200000000004711103731067021536 0ustar hattoriispreq_int_val = 0; ipv4_val = 1.2.3.4.5; conf4cpp-0.0.3/test/config_error/invalidipaddr.5.conf0000644002370600234200000000005711103731067021542 0ustar hattoriispreq_int_val = 0; ipv6_val = ::1:2:3:4:5:6:7:8; conf4cpp-0.0.3/test/config_error/invalidipaddr.4.conf0000644002370600234200000000005711103731067021541 0ustar hattoriispreq_int_val = 0; ipv6_val = 1:2:3:4:5:6:7:8::; conf4cpp-0.0.3/test/config_error/invaliddate.2.conf0000644002370600234200000000004611103731067021207 0ustar hattoriispreq_int_val = 0; date_val = 2009/13/3;conf4cpp-0.0.3/test/config_error/typemismatch.6.conf0000644002370600234200000000004311103731067021433 0ustar hattoriispreq_int_val = 0; week_val = Apple; conf4cpp-0.0.3/test/config_error/typemismatch.1.conf0000644002370600234200000000002511103731067021426 0ustar hattoriispreq_int_val = "foo"; conf4cpp-0.0.3/test/config_error/parseerror.1.conf0000644002370600234200000000000211103731067021076 0ustar hattoriisp3 conf4cpp-0.0.3/test/config_error/emptyfile.conf0000644002370600234200000000000011103731067020547 0ustar hattoriispconf4cpp-0.0.3/test/config_error/typemismatch.14.conf0000644002370600234200000000007111103731067021513 0ustar hattoriispreq_int_val = 0; fruitsreal_val = {Apple,Banana},Orange; conf4cpp-0.0.3/test/config_error/invalidlength.conf0000644002370600234200000000005511103731067021413 0ustar hattoriispreq_int_val = 0; strlist3_val = "foo","bar"; conf4cpp-0.0.3/test/config_error/typemismatch.12.conf0000644002370600234200000000004611103731067021513 0ustar hattoriispreq_int_val = 0; strlist_val = 3,4,5; conf4cpp-0.0.3/test/config_error/invaliddate.5.conf0000644002370600234200000000005711103731067021214 0ustar hattoriispreq_int_val = 0; date_val = 2009/12/31 25:1:30;conf4cpp-0.0.3/test/config_error/typemismatch.8.conf0000644002370600234200000000004611103731067021440 0ustar hattoriispreq_int_val = 0; date_val = 1:2:3::4; conf4cpp-0.0.3/test/config_error/typemismatch.4.conf0000644002370600234200000000004311103731067021431 0ustar hattoriispreq_int_val = 3; string_val = MON; conf4cpp-0.0.3/test/config_error/invalidipaddr.6.conf0000644002370600234200000000005011103731067021534 0ustar hattoriispreq_int_val = 0; ipv6_val = 1::2::3::4; conf4cpp-0.0.3/test/config_error/Makefile0000644002370600234200000000066511103731067017363 0ustar hattoriispTARGET = conf_error SRCS = \ conf.out.cpp \ conf_error.cpp CONF4CPP= ../../src/conf4cpp CXXFLAGS= -Wall CPPFLAGS= -I/usr/include/boost-1_33_1 -I../../inc LIBS = OBJS = $(SRCS:.cpp=.o) %.o : %.cpp $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $< $(TARGET) : $(OBJS) $(CXX) $(CXXFLAGS) -o $@ $(OBJS) $(LIBS) conf.out.cpp : conf_error.conf.def $(CONF4CPP) $< .PHONY: clean clean : rm -fr $(OBJS) $(TARGET) $(DEPS) conf.out.cpp conf.out.hpp conf4cpp-0.0.3/test/config_error/invaliddate.1.conf0000644002370600234200000000004511103731067021205 0ustar hattoriispreq_int_val = 0; date_val = 10:30:10;conf4cpp-0.0.3/test/config_error/typemismatch.11.conf0000644002370600234200000000005311103731067021510 0ustar hattoriispreq_int_val = 0; ipv4net_val = 1.2.3.4,-3; conf4cpp-0.0.3/test/config_error/typemismatch.15.conf0000644002370600234200000000005211103731067021513 0ustar hattoriispreq_int_val = 0; weekbi_val = MON,true,3; conf4cpp-0.0.3/test/config_error/parseerror.2.conf0000644002370600234200000000001711103731067021105 0ustar hattoriispuint _val = 0; conf4cpp-0.0.3/test/config_error/undefined.conf0000644002370600234200000000001611103731067020521 0ustar hattoriispuint_val = 3; conf4cpp-0.0.3/test/config_error/conf_error.cpp0000644002370600234200000000047111103731067020560 0ustar hattoriisp#include #include "conf.out.hpp" int main(int argc, char* args[]) { if (argc < 2) { cout << "no input file.\n"; return -1; } try { conf_error conf(args[1]); } catch (const conf4cpp::error& e) { cout << e.what() << endl; return -1; } return 0; } conf4cpp-0.0.3/test/config_error/conf_error.sh0000644002370600234200000000103111103731067020401 0ustar hattoriisp#!/bin/sh CONFERR=./conf_error pass=0 total=0 for fname in *.conf do echo -n "$fname: " ; $CONFERR $fname if test $? -ne 255 then echo "failed test case: $fname" else pass=`expr $pass + 1` fi total=`expr $total + 1` done echo if test $pass -eq $total then echo "******************************************" echo " all test case passed: $pass/$total " echo "******************************************" else echo "**************************" echo " $pass/$total passed " echo "**************************" fi conf4cpp-0.0.3/test/config_error/invaliddate.4.conf0000644002370600234200000000005011103731067021204 0ustar hattoriispreq_int_val = 0; date_val = 2009/12/32; conf4cpp-0.0.3/test/config_error/typemismatch.5.conf0000644002370600234200000000004011103731067021427 0ustar hattoriispreq_int_val = 0; real_val = -3; conf4cpp-0.0.3/test/config_error/parseerror.3.conf0000644002370600234200000000002011103731067021100 0ustar hattoriispuint_val = 0 #; conf4cpp-0.0.3/test/config_error/invaliddate.3.conf0000644002370600234200000000004611103731067021210 0ustar hattoriispreq_int_val = 0; date_val = 2009/0/30;conf4cpp-0.0.3/test/config_error/conf_error.conf.def0000644002370600234200000000123711103731067021461 0ustar hattoriispconfig conf_error { enum week_t { MON, TUE, WED, THU, FRI, SAT, SUN } enum fruit_t { Apple, Banana, Orange, Peach, Lemon } required req_int_val : int; optional uint_val : uint; optional bool_val : bool; optional string_val : string; optional real_val : real; optional week_val : week_t; optional fruit_val : fruit_t; optional date_val : time; optional ipv4_val : ipv4addr; optional ipv6_val : ipv6addr; optional ipv4net_val : ipv4addr,uint; optional strlist_val : list; optional strlist3_val : list[3]; optional intbools_val : list; optional fruitsreal_val : list,real; optional weekbi_val : (week_t,bool),int; } conf4cpp-0.0.3/test/config_error/invaliddate.6.conf0000644002370600234200000000006011103731067021207 0ustar hattoriispreq_int_val = 0; date_val = 2009/12/31 23:69:30;conf4cpp-0.0.3/test/config_error/typemismatch.2.conf0000644002370600234200000000004211103731067021426 0ustar hattoriispreq_int_val = 0; uint_val = -123; conf4cpp-0.0.3/test/config_error/redefined.conf0000644002370600234200000000004711103731067020511 0ustar hattoriispreq_int_val = 123; req_int_val = -322; conf4cpp-0.0.3/test/config_error/typemismatch.13.conf0000644002370600234200000000006511103731067021515 0ustar hattoriispreq_int_val = 0; intbools_val = {3,true},{{3,true}}; conf4cpp-0.0.3/test/config_error/invalidipaddr.3.conf0000644002370600234200000000006311103731067021535 0ustar hattoriispreq_int_val = 0; ipv6_val = 1:2:3:4:5:6:7::8:9:10; conf4cpp-0.0.3/test/Makefile0000644002370600234200000000064711074113210014674 0ustar hattoriispTARGET = test_conf SRCS = \ conf.out.cpp \ test_conf.cpp CONF4CPP= ../src/conf4cpp CXXFLAGS= -Wall CPPFLAGS= -I/usr/include/boost-1_33_1 -I../inc LIBS = OBJS = $(SRCS:.cpp=.o) %.o : %.cpp $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $< $(TARGET) : $(OBJS) $(CXX) $(CXXFLAGS) -o $@ $(OBJS) $(LIBS) conf.out.cpp : test.conf.def $(CONF4CPP) $< .PHONY: clean clean : rm -fr $(OBJS) $(TARGET) $(DEPS) conf.out.cpp conf.out.hpp conf4cpp-0.0.3/test/test.conf.def0000644002370600234200000000360511103573172015626 0ustar hattoriispconfig test_conf { enum week_t { MON, TUE, WED, THU, FRI, SAT, SUN } enum fruit_t { Apple, Orange, Peach, Lemon } required int_val : int; required bool_val : bool; required week_val : week_t; optional string_val : string; optional real_val : real; required string_list : list; required string0_list : list[0]; required int1_list : list[1]; required bool9_list : list[9]; required real_llist : list>; stri_list : list; rib_tuple : real,int,bool; string_tuple : ((string)); week_fruits : week_t,list; optional int_defval : int(5); optional int_defval2 : int; optional uint_defval : uint(123); optional uint_defval2 : uint; optional uint_defval3 : uint(0xffffffff); optional bool_defval : bool(true); optional bool_defval2 : bool; optional string_defval : string("hello"); optional string_defval2 : string; optional real_defval : real(1.0123); optional real_defval2 : real; optional fruit_def : fruit_t(Orange); # optional fruit_baddef : fruit_t(FRI); optional fruit_def2 : fruit_t; optional rib_tuple_def : real(-3.14),int(5),bool; optional stri_list_def : list[3]; optional date_value : time; optional date_value2 : time(2003/12/31); optional date_value3 : time(2008/1/3 17:20:00); optional date_value4 : time; optional ipv4_value : ipv4addr; optional ipv4_value2 : ipv4addr(192.168.0.1); optional ipv4_value3 : ipv4addr(1.2.3.4); optional ipv6_value : ipv6addr; optional ipv6_value2 : ipv6addr(dead:beaf::1); optional ipv6_value3 : ipv6addr(dead:1234:ffff:ffff:2311:1111:0000:0232); optional ipv6_value4 : ipv6addr(::); optional ipv6_value5 : ipv6addr(::1); optional ipv6_value6 : ipv6addr(1:2:3::); optional ipv6_value7 : ipv6addr; optional netaddr_val : ipv4addr,int(24); optional net6addr_val : ipv6addr,int; optional datadrstr_vals : list; } conf4cpp-0.0.3/Makefile0000644002370600234200000000036211074643517013731 0ustar hattoriispPREFIX = /usr/local TARGET = conf4cpp all : $(TARGET) $(TARGET): $(MAKE) -C src/ .PHONY: install install : $(TARGET) cp -r inc/* $(PREFIX)/include/ cp src/$(TARGET) $(PREFIX)/bin/$(TARGET) .PHONY : clean clean : $(MAKE) -C src clean conf4cpp-0.0.3/sample/0000755002370600234200000000000011103752641013541 5ustar hattoriispconf4cpp-0.0.3/sample/sample.conf0000644002370600234200000000210611073375267015703 0ustar hattoriisp#はコメント foo = 1; #foo = {1}; #foo = "1"; #foo = 23; #foo = 0; bar = true; #bar = false; #bar = {true}; baz = "hogehoge"; #baz = "hogehoge"; #baz = "hattori"; #poo = 1,false; #poo = {1,true}; #pom = {}; pom = "hoge", "bar"; #pom = {"hoge", "bar"}; #pom = {"hoge"}; #pom = "hoge"; por = 5,6,7,8,9; #por = {}; #por = 1,2,3,4,5,6,7; #por = {1,2,7,8,9}; #por = {1,2,7,8,{9}}; #por = {{1,2,7,8,9}}; #por = "hoge"; far = {"hoge", "bar"}, {1,"foo"}, false; #far = {{"hoge", "bar"}, {1,"foo"}, false}; #far = "hoge",{3,"bar"}, true; #far = {"hoge",{3,"bar"}, true}; #far = {{"hoge"},{3,"bar"}, true}; #far = {"hoge"},{3,"bar"}, true; #far = {"hoge"},{3,"bar"}, {true}; #far = {{{"hoge", "bar"}, {1,"foo"}, {false}}}; hoo = UDP; #hoo = 3; #hoo = FOO; #hoo = HOGE; haz = BAR,UDP; #haz = {FOO,TCP}; #haz = {FOO,TCP,FOO}; #haz = {FOO,0}; #haz = TCP, FOO; vaa = {1,2,3,4},{5,6,8},{9},{}, {18,10}; vas = {{"hoge"},{}}, {{}}, {{"foo"},{"foo","bar","baz"}}; var = {5,true,{{"hoge",3},{"ba",3}},{false,FOO}}, {1,false,{},{false,BAZ}}, {4,true,{{"foo",2}},{true,BAR}}; #var = {}; conf4cpp-0.0.3/sample/Makefile0000644002370600234200000000064311073673122015206 0ustar hattoriispTARGET = sample SRCS = \ conf.out.cpp \ sample.cpp CONF4CPP= ../src/conf4cpp CXXFLAGS= -Wall CPPFLAGS= -I/usr/include/boost-1_33_1 -I../inc LIBS = OBJS = $(SRCS:.cpp=.o) %.o : %.cpp $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $< $(TARGET) : $(OBJS) $(CXX) $(CXXFLAGS) -o $@ $(OBJS) $(LIBS) conf.out.cpp : sample.conf.def $(CONF4CPP) $< .PHONY: clean clean : rm -fr $(OBJS) $(TARGET) $(DEPS) conf.out.cpp conf.out.hpp conf4cpp-0.0.3/sample/sample.cpp0000644002370600234200000000033411073673122015530 0ustar hattoriisp#include #include "conf.out.hpp" int main(int argc, char* args[]) { if (argc < 2) { cout << "no input file.\n"; return -1; } sample_conf conf(args[1]); conf.dump(cout); return 0; } conf4cpp-0.0.3/sample/sample.conf.def0000644002370600234200000000134111100777063016427 0ustar hattoriispconfig sample_conf #config config #configsample_conf { enum proto_t { TCP, UDP, ICMP, RTP } # enum proto_t { enum, UDP, ICMP, RTP } enum foo_t { FOO, BAR, BAZ } # enum bar_t { UDP } # required required : int; required foo : int; required bar : bool; # required bar : bool; required baz : string; optional poo : int,bool; optional por : list[5]; optional pom : list; optional far : list,(int,string),bool; optional vaa : list>; optional vas : list>>; optional var : list,(bool,foo_t)>; optional hoo : proto_t; optional haz : foo_t,proto_t; # optional har : optional; optional has : foo_t; optional hashas : foo_t; optional hoge : foo_t(BAR); } conf4cpp-0.0.3/README0000644002370600234200000000443111074117775013154 0ustar hattoriisp******************************************************************************* [conf4cpp] README ******************************************************************************* conf4cppは設定ファイルの定義ファイルから，その設定ファイルを読み込んで 値を取得するためのC++のコードを自動生成します．conf4cppを使えば，アプ リケーションごとに何度も設定ファイルを読み込むための独自のコードを作成 する手間を省くことができます． 【インストール方法】 makeしてからmake installを実行してください． % make # make install デフォルトでは，/usr/local/include/conf4cppの下にヘッダファイル， /usr/local/binの下にconf4cppプログラムがコピーされます． 【動作環境】 Boost 1.33.1 以上が必要です． 【簡単な例】 以下のような設定ファイル(sample.conf)の書式を例に取り上げます． myname = "hattori"; age = 36; coutry = "Japan"; friends = "yamada", "suzuki", "ohtake"; このような設定ファイルの書式に対応する定義は，たとえば以下のように記述 することができます． config sample_conf { required myname : string; required age : int; optional country : string; optional friends : list; } この定義ファイルをconf4cppでコンパイルすると，conf.out.hppと conf.out.cppファイルが生成されます． あなたのプログラムからconf.out.hppをインクルードして，conf.out.cppとリ ンクするだけで，簡単に設定ファイルを読み込んで，設定項目を参照すること ができます．例を以下に示します． #include "conf.out.hpp" ... sample_conf conf("sample.conf"); // sample.confを読み込む cout << "myname is " << conf.myname() << endl; cout << "age is " << conf.age() << endl; if (conf.has_contry()) { cout << "country is " << conf.country() << endl; } if (conf.has_friends()) { for (unsigned int i = 0; i < conf.friends().size(); i++) { cout << "friends " << conf.friends()[i] << endl; } } ... より詳しくはconf4cppのマニュアルを参照してください． -- Copyright (c) 2008 Kenta Hattori, All rights reserved. $Id$