conf4cpp-0.0.4/0000755002370600234200000000000011106211531012250 5ustar hattoriispconf4cpp-0.0.4/ChangeLog0000644002370600234200000000213211106212033014016 0ustar hattoriisp2008-11-11 Kenta Hattori * conf4cpp-0.0.4 リリース * エラーまわりの処理を整理，簡素化 2008-11-10 Kenta HATTORI * datetime, ipv4addr, ipv6addrのパーサー定義を共通化 2008-11-05 Kenta HATTORI * mutable, constキーワードの追加と，set_メンバー関数出力部の追加 2008-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.4/inc/0000755002370600234200000000000011106211531013021 5ustar hattoriispconf4cpp-0.0.4/inc/conf4cpp.hpp0000644002370600234200000000104211103752523015253 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.4/inc/conf4cpp/0000755002370600234200000000000011106211531014535 5ustar hattoriispconf4cpp-0.0.4/inc/conf4cpp/var.hpp0000644002370600234200000001511211106211660016041 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef VAR_HPP #define VAR_HPP #include #include #include #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; } using namespace boost::spirit; using phoenix::arg1; using phoenix::arg2; using phoenix::bind; using phoenix::var; using phoenix::construct_; // // 時刻パーサ定義 // template inline 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; } struct datetime_parser : public grammar { template struct definition { typedef rule rule_t; rule_t top, date_r, time_r; definition(datetime_parser const& self) { top = (date_r >> time_r)[var(self.val)=bind(&str2time)("%Y/%m/%d %T",arg1,arg2)] | date_r[var(self.val)=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]]; } rule_t const& start() const { return top; } }; mutable struct tm val; }; // // IPアドレスパーサ定義 // template inline 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 IP address format")); return ret; } struct ipv4addr_parser : public grammar { template struct definition { typedef rule rule_t; rule_t top; definition(ipv4addr_parser const& self) { top = lexeme_d[(repeat_p(3)[repeat_p(1,3)[digit_p] >> "."] >> repeat_p(1,3)[digit_p])] [var(self.val)=bind(&str2addr)(arg1,arg2)]; } rule_t const& start() const { return top; } }; mutable struct in_addr val; }; struct ipv6addr_parser : public grammar { template struct definition { typedef rule rule_t; rule_t top; definition(ipv6addr_parser const& self) { top = ( 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]] | ":")]) [var(self.val)=bind(&str2addr)(arg1,arg2)]; } rule_t const& start() const { return top; } }; mutable struct in6_addr val; }; struct value_parser : public grammar { template struct definition { typedef rule rule_t; rule_t top; datetime_parser datetime_r; ipv4addr_parser ipv4addr_r; ipv6addr_parser ipv6addr_r; definition(value_parser const& self) { top = lexeme_d[((str_p("0x")|"0X") >> hex_p[var(self.val)=arg1])] | datetime_r[var(self.val)=var(datetime_r.val)] | ipv4addr_r[var(self.val)=var(ipv4addr_r.val)] | ipv6addr_r[var(self.val)=var(ipv6addr_r.val)] | strict_real_p[var(self.val)=arg1] | uint_p[var(self.val)=arg1] | int_p[var(self.val)=arg1] | str_p("true")[var(self.val)=true] | str_p("false")[var(self.val)=false] | confix_p('"', (*c_escape_ch_p)[var(self.val)=construct_(arg1,arg2)], '"'); } rule_t const& start() const { return top; } }; mutable var_t val; }; } #endif /* VAR_HPP */ conf4cpp-0.0.4/inc/conf4cpp/type.hpp0000644002370600234200000000643311106211660016240 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef TYPE_HPP #define TYPE_HPP #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) {} bool operator() (ti_atomic_t ta) const { switch (ta) { case TI_BOOL: if (is_bool(v_)) return true; break; case TI_INT: if (is_int(v_)||(is_uint(v_) && boost::get(v_) <= INT_MAX)) return true; break; case TI_UINT: if (is_uint(v_)) return true; break; case TI_DOUBLE: if (is_double(v_)) return true; break; case TI_STRING: if (is_string(v_)) return true; break; case TI_TIME: if (is_time(v_)) return true; break; case TI_IPV4ADDR: if (is_ipv4addr(v_)) return true; break; case TI_IPV6ADDR: if (is_ipv6addr(v_)) return true; break; default: assert(false); } return false; } bool operator() (ti_enum_t te) const { if (!is_pair(v_)) return false; pair p = var2 >(v_); if (p.first != te.eid) return false; return true; } bool operator() (pair tp) const { if (!is_vector(v_)) return false; vector vec = var2 >(v_); if (tp.first > 0 && tp.first != vec.size()) return false; for (unsigned int i = 0; i < vec.size(); i++) { if (!apply_visitor(type_checker(vec[i]), tp.second)) return false; } return true; } bool operator() (vector tv) const { if (!is_vector(v_)) return false; vector vec = var2 >(v_); if (vec.size() != tv.size()) return false; for (unsigned int i = 0; i < tv.size(); i++) { if (!apply_visitor(type_checker(vec[i]), tv[i])) return false; } return true; } private: var_t v_; }; } #endif /* TYPE_HPP */ conf4cpp-0.0.4/inc/conf4cpp/error.hpp0000644002370600234200000000147311106211660016407 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef ERROR_HPP #define ERROR_HPP #include #include #include using namespace std; namespace conf4cpp { class error : public exception { public: error(const string& msg) throw() : msg_(msg) {} error(const string& msg, unsigned int line) throw() : msg_(msg + " at line: " + boost::lexical_cast(line)) {} error(const string& msg, const string& item) throw() : msg_(msg + ": " + item) {} virtual ~error() throw() {} const char* what() const throw() { return msg_.c_str(); } private: const string msg_; }; } #endif /* ERROR_HPP */ conf4cpp-0.0.4/inc/conf4cpp/config.hpp0000644002370600234200000000274311106211660016524 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("could not open file"); 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.4/inc/conf4cpp/version.hpp0000644002370600234200000000054411104312723016741 0ustar hattoriisp/*============================================================================= * * conf4cpp : Configuration file library for C++. * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef VERSION_HPP #define VERSION_HPP #define CONF4CPP_VERSION "0.0.4" #endif /* VERSION_HPP */ conf4cpp-0.0.4/inc/conf4cpp/parser.hpp0000644002370600234200000001001511106211660016542 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef PARSER_HPP #define PARSER_HPP #include #include #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; struct variant_val : closure { member1 val; }; 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; } static bool item_redefined(set& ss, const string& key) { if (ss.find(key) != ss.end()) return true; ss.insert(key); return false; } static bool type_mismatch(tyinfo_map_t& tm, value_map_t& vm, const string& key) { vector vec = var2 >(vm[key]); type_t typ = tm[key]; if (is_prim_type(typ)) { if (vec.size() != 1) return true; if (!apply_visitor(type_checker(vec[0]), typ)) return true; vm[key] = vec[0]; } else { if (vec.size() == 1 && is_vector(vec[0])) { if (!apply_visitor(type_checker(vec[0]), typ)) return true; vm[key] = vec[0]; } else { if (!apply_visitor(type_checker(vm[key]), typ)) return true; } } return false; } template struct definition { rule config_r, item_r; rule values_r, atomic_value_r; symbols<> sym_p; value_parser value_p; typename derived_T::keywords keywords_p; typename derived_T::constvals constvals_p; definition(base_config_parser const& self) { assertion item_redefined_e("item redefined"); assertion type_mismatch_e("type mismatch"); using phoenix::arg1; using phoenix::construct_; using phoenix::var; using phoenix::bind; config_r = *item_r >> end_p; item_r = keywords_p[var(self.current_keywd)=arg1] >> item_redefined_e(eps_p(bind(&item_redefined)(var(self.defined_symbols),var(self.current_keywd))==false)) >> '=' >> values_r[insert_at_a(self.vmap,self.current_keywd)] >> type_mismatch_e(eps_p(bind(&type_mismatch)(var(self.timap),var(self.vmap),var(self.current_keywd))==false)) >> ';'; values_r = atomic_value_r[values_r.val=construct_ >(1,arg1)] >> *(',' >> atomic_value_r[values_r.val=bind(&add_value)(values_r.val,arg1)]); atomic_value_r = value_p[atomic_value_r.val=var(value_p.val)] | ch_p('{')[atomic_value_r.val=construct_ >()] >> !values_r[atomic_value_r.val=arg1] >> '}' // | '{' >> *item_r >> '}' | constvals_p[atomic_value_r.val=arg1]; } rule const& start() const { return config_r; } }; mutable string current_keywd; mutable set defined_symbols; mutable tyinfo_map_t timap; mutable value_map_t& vmap; vector reqs; }; } #endif /* PARSER_HPP */ conf4cpp-0.0.4/src/0000755002370600234200000000000011106211531013037 5ustar hattoriispconf4cpp-0.0.4/src/confgen.cpp0000644002370600234200000002633111104317234015174 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; if (!itemcon_map_.find(iter->first)->second) os << "\tvoid set_" << iter->first << "(const " << get_typestr(iter->second.first) << "& v) { " << iter->first << "_ = v; }" << 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.4/src/confgen.hpp0000644002370600234200000003265211104317234015204 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), itemcon_map_(g.itemcon_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_, itemcon_map_; const map > enumelem_map_; }; #endif /* CONFGEN_HPP */ conf4cpp-0.0.4/src/confdef_g.hpp0000644002370600234200000003365511106165571015512 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 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)) ("const" , make_pair(SYM_RESERVED, TI_BOOL)) ("mutable" , 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 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 mandatory_r, constraints_r, qualifier_r; rule new_sym, id_r; rule elemseq_r; rule newconf_sym, newitem_sym, newenum_sym, newelem_sym; value_parser value_p; 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::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][var(self.cur_con)=true] >> ((!mandatory_r >> !qualifier_r) | (!qualifier_r >> !mandatory_r)) >> newitem_sym[var(self.cur_sym)=arg1][insert_key_a(self.itemreq_map,self.cur_req)][insert_key_a(self.itemcon_map,self.cur_con)] >> ':' >> 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]; qualifier_r = lexeme_d[str_p("const") >> blank_p] | lexeme_d[str_p("mutable") >> blank_p][var(self.cur_con)=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_p[var(self.cur_val)=var(value_p.val)][atomic_texp_r.val=construct_ >(var(self.cur_type.second),var(value_p.val))] | ( 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_p >> type_mismatch(nothing_p) ) ) >> ')' ) | '(' >> compound_texp_r[atomic_texp_r.val=bind(&split_typvars)(arg1)] >> ')'; // 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, cur_con; 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, itemcon_map; mutable string conf_name; }; #endif /* CONFDEF_HPP */ conf4cpp-0.0.4/src/Makefile0000644002370600234200000000105311074643517014517 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.4/src/conf4cpp.cpp0000644002370600234200000001001111106165571015264 0ustar hattoriisp/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #include #include #include #include #include #include #include "confdef_g.hpp" #include "confgen.hpp" using namespace std; using namespace boost::spirit; 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 (const 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.4/test/0000755002370600234200000000000011106211530013226 5ustar hattoriispconf4cpp-0.0.4/test/conf_no_items/0000755002370600234200000000000011106211530016050 5ustar hattoriispconf4cpp-0.0.4/test/conf_no_items/no_items.conf0000644002370600234200000000000011074107245020535 0ustar hattoriispconf4cpp-0.0.4/test/conf_no_items/Makefile0000644002370600234200000000067111074107245017527 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.4/test/conf_no_items/no_items.conf.def0000644002370600234200000000003111074107245021276 0ustar hattoriispconfig conf_no_items { } conf4cpp-0.0.4/test/conf_no_items/conf_no_items.cpp0000644002370600234200000000033611074107245021413 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.4/test/test_conf.cpp0000644002370600234200000001112111105033747015725 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.int_val()==-123); assert(conf.bool_val()==false); assert(conf.week_val()==test_conf::SUN); 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())); // test set method conf.set_int_val(321); assert(conf.int_val()==321); assert(conf.string_val()==""); conf.set_string_val("hoge"); assert(conf.string_val()=="hoge"); conf.dump(cout); return 0; } conf4cpp-0.0.4/test/compile_error/0000755002370600234200000000000011106211530016067 5ustar hattoriispconf4cpp-0.0.4/test/compile_error/empty.conf.def0000644002370600234200000000000011100770172020625 0ustar hattoriispconf4cpp-0.0.4/test/compile_error/redefined.conf.2.def0000644002370600234200000000007011100615663021566 0ustar hattoriispconfig redefined_conf { enum foo_t { FOO, BAR, FOO } } conf4cpp-0.0.4/test/compile_error/redefined.conf.4.def0000644002370600234200000000006111100615663021570 0ustar hattoriispconfig redefined_conf { redefined_conf : int; } conf4cpp-0.0.4/test/compile_error/redefined.conf.1.def0000644002370600234200000000006311100615663021567 0ustar hattoriispconfig redefined_conf { foo : int; foo : bool; } conf4cpp-0.0.4/test/compile_error/typemismatch.conf.5.def0000644002370600234200000000013111100615663022351 0ustar hattoriispconfig type_mismatch_conf { enum foo_t { FOO } enum bar_t { BAR } foo : foo_t(BAR); } conf4cpp-0.0.4/test/compile_error/typemismatch.conf.1.def0000644002370600234200000000006211100615663022350 0ustar hattoriispconfig type_mismatch_conf { foo : int("hoge"); } conf4cpp-0.0.4/test/compile_error/typemismatch.conf.3.def0000644002370600234200000000011511100615663022351 0ustar hattoriispconfig type_mismatch_conf { enum foo_t { FOO, BAR, BAZ } foo : int(FOO); } conf4cpp-0.0.4/test/compile_error/compile_error.sh0000644002370600234200000000101311103731067021270 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.4/test/compile_error/noelement.conf.def0000644002370600234200000000005211100615663021467 0ustar hattoriispconfig redefined_conf { enum foo_t { } } conf4cpp-0.0.4/test/compile_error/typemismatch.conf.6.def0000644002370600234200000000006311102330675022355 0ustar hattoriispconfig type_mismatch_conf { foo : uint_t(-123); } conf4cpp-0.0.4/test/compile_error/typemismatch.conf.8.def0000644002370600234200000000006611102330675022362 0ustar hattoriispconfig type_mismatch_conf { foo : int(0xdeadbeef); } conf4cpp-0.0.4/test/compile_error/redefined.conf.3.def0000644002370600234200000000010211100615663021563 0ustar hattoriispconfig redefined_conf { enum foo_t { FOO } enum foo_t { BAR } } conf4cpp-0.0.4/test/compile_error/typemismatch.conf.7.def0000644002370600234200000000006611102330675022361 0ustar hattoriispconfig type_mismatch_conf { foo : int(2147483648); } conf4cpp-0.0.4/test/compile_error/redefined.conf.5.def0000644002370600234200000000010411100615663021567 0ustar hattoriispconfig redefined_conf { enum foo_t { foo, bar, baz } foo : int; } conf4cpp-0.0.4/test/compile_error/redefined.conf.6.def0000644002370600234200000000002211100615663021567 0ustar hattoriispconfig config { } conf4cpp-0.0.4/test/compile_error/typemismatch.conf.4.def0000644002370600234200000000012211100615663022350 0ustar hattoriispconfig type_mismatch_conf { enum foo_t { FOO, BAR, BAZ } foo : foo_t("hoge"); } conf4cpp-0.0.4/test/compile_error/typemismatch.conf.2.def0000644002370600234200000000005611100615663022354 0ustar hattoriispconfig type_mismatch_conf { foo : real(1); } conf4cpp-0.0.4/test/compile_error/redefined.conf.7.def0000644002370600234200000000004611100615663021576 0ustar hattoriispconfig redefined_conf { int : int; } conf4cpp-0.0.4/test/test.conf0000644002370600234200000000132711103573172015071 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.4/test/config_error/0000755002370600234200000000000011106211531015705 5ustar hattoriispconf4cpp-0.0.4/test/config_error/unclosedstr.conf0000644002370600234200000000006611103731067021133 0ustar hattoriispreq_int_val = 0; string_val = "hogehoge; uint_val = 5;conf4cpp-0.0.4/test/config_error/typemismatch.7.conf0000644002370600234200000000004611103731067021440 0ustar hattoriispreq_int_val = 0; fruit_val = "Apple"; conf4cpp-0.0.4/test/config_error/typemismatch.9.conf0000644002370600234200000000004111103731067021435 0ustar hattoriispreq_int_val = 0; ipv4_val = ::1; conf4cpp-0.0.4/test/config_error/invaliddate.7.conf0000644002370600234200000000006111103731067021212 0ustar hattoriispreq_int_val = 0; date_val = 2009/12/31 23:59:69; conf4cpp-0.0.4/test/config_error/typemismatch.3.conf0000644002370600234200000000005011103731067021427 0ustar hattoriispreq_int_val = 3; bool_val = false,true; conf4cpp-0.0.4/test/config_error/typemismatch.10.conf0000644002370600234200000000004511103731067021511 0ustar hattoriispreq_int_val = 0; ipv6_val = 1.2.3.4; conf4cpp-0.0.4/test/config_error/invalidipaddr.1.conf0000644002370600234200000000004311103731067021532 0ustar hattoriispreq_int_val = 0; ipv4_val = 0.0.0; conf4cpp-0.0.4/test/config_error/invalidipaddr.2.conf0000644002370600234200000000004711103731067021537 0ustar hattoriispreq_int_val = 0; ipv4_val = 1.2.3.4.5; conf4cpp-0.0.4/test/config_error/invalidipaddr.5.conf0000644002370600234200000000005711103731067021543 0ustar hattoriispreq_int_val = 0; ipv6_val = ::1:2:3:4:5:6:7:8; conf4cpp-0.0.4/test/config_error/invalidipaddr.4.conf0000644002370600234200000000005711103731067021542 0ustar hattoriispreq_int_val = 0; ipv6_val = 1:2:3:4:5:6:7:8::; conf4cpp-0.0.4/test/config_error/invaliddate.2.conf0000644002370600234200000000004611103731067021210 0ustar hattoriispreq_int_val = 0; date_val = 2009/13/3;conf4cpp-0.0.4/test/config_error/typemismatch.6.conf0000644002370600234200000000004311103731067021434 0ustar hattoriispreq_int_val = 0; week_val = Apple; conf4cpp-0.0.4/test/config_error/typemismatch.1.conf0000644002370600234200000000002511103731067021427 0ustar hattoriispreq_int_val = "foo"; conf4cpp-0.0.4/test/config_error/parseerror.1.conf0000644002370600234200000000000211103731067021077 0ustar hattoriisp3 conf4cpp-0.0.4/test/config_error/emptyfile.conf0000644002370600234200000000000011103731067020550 0ustar hattoriispconf4cpp-0.0.4/test/config_error/typemismatch.14.conf0000644002370600234200000000007111103731067021514 0ustar hattoriispreq_int_val = 0; fruitsreal_val = {Apple,Banana},Orange; conf4cpp-0.0.4/test/config_error/invalidlength.conf0000644002370600234200000000005511103731067021414 0ustar hattoriispreq_int_val = 0; strlist3_val = "foo","bar"; conf4cpp-0.0.4/test/config_error/typemismatch.12.conf0000644002370600234200000000004611103731067021514 0ustar hattoriispreq_int_val = 0; strlist_val = 3,4,5; conf4cpp-0.0.4/test/config_error/invaliddate.5.conf0000644002370600234200000000005711103731067021215 0ustar hattoriispreq_int_val = 0; date_val = 2009/12/31 25:1:30;conf4cpp-0.0.4/test/config_error/typemismatch.8.conf0000644002370600234200000000004611103731067021441 0ustar hattoriispreq_int_val = 0; date_val = 1:2:3::4; conf4cpp-0.0.4/test/config_error/typemismatch.4.conf0000644002370600234200000000004311103731067021432 0ustar hattoriispreq_int_val = 3; string_val = MON; conf4cpp-0.0.4/test/config_error/invalidipaddr.6.conf0000644002370600234200000000005011103731067021535 0ustar hattoriispreq_int_val = 0; ipv6_val = 1::2::3::4; conf4cpp-0.0.4/test/config_error/Makefile0000644002370600234200000000066511103731067017364 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.4/test/config_error/invaliddate.1.conf0000644002370600234200000000004511103731067021206 0ustar hattoriispreq_int_val = 0; date_val = 10:30:10;conf4cpp-0.0.4/test/config_error/typemismatch.11.conf0000644002370600234200000000005311103731067021511 0ustar hattoriispreq_int_val = 0; ipv4net_val = 1.2.3.4,-3; conf4cpp-0.0.4/test/config_error/typemismatch.15.conf0000644002370600234200000000005211103731067021514 0ustar hattoriispreq_int_val = 0; weekbi_val = MON,true,3; conf4cpp-0.0.4/test/config_error/parseerror.2.conf0000644002370600234200000000001711103731067021106 0ustar hattoriispuint _val = 0; conf4cpp-0.0.4/test/config_error/undefined.conf0000644002370600234200000000001611103731067020522 0ustar hattoriispuint_val = 3; conf4cpp-0.0.4/test/config_error/conf_error.cpp0000644002370600234200000000047111103731067020561 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.4/test/config_error/conf_error.sh0000644002370600234200000000103111103731067020402 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.4/test/config_error/invaliddate.4.conf0000644002370600234200000000005011103731067021205 0ustar hattoriispreq_int_val = 0; date_val = 2009/12/32; conf4cpp-0.0.4/test/config_error/typemismatch.5.conf0000644002370600234200000000004011103731067021430 0ustar hattoriispreq_int_val = 0; real_val = -3; conf4cpp-0.0.4/test/config_error/parseerror.3.conf0000644002370600234200000000002011103731067021101 0ustar hattoriispuint_val = 0 #; conf4cpp-0.0.4/test/config_error/invaliddate.3.conf0000644002370600234200000000004611103731067021211 0ustar hattoriispreq_int_val = 0; date_val = 2009/0/30;conf4cpp-0.0.4/test/config_error/conf_error.conf.def0000644002370600234200000000123711103731067021462 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.4/test/config_error/invaliddate.6.conf0000644002370600234200000000006011103731067021210 0ustar hattoriispreq_int_val = 0; date_val = 2009/12/31 23:69:30;conf4cpp-0.0.4/test/config_error/typemismatch.2.conf0000644002370600234200000000004211103731067021427 0ustar hattoriispreq_int_val = 0; uint_val = -123; conf4cpp-0.0.4/test/config_error/redefined.conf0000644002370600234200000000004711103731067020512 0ustar hattoriispreq_int_val = 123; req_int_val = -322; conf4cpp-0.0.4/test/config_error/typemismatch.13.conf0000644002370600234200000000006511103731067021516 0ustar hattoriispreq_int_val = 0; intbools_val = {3,true},{{3,true}}; conf4cpp-0.0.4/test/config_error/invalidipaddr.3.conf0000644002370600234200000000006311103731067021536 0ustar hattoriispreq_int_val = 0; ipv6_val = 1:2:3:4:5:6:7::8:9:10; conf4cpp-0.0.4/test/Makefile0000644002370600234200000000064711074113210014675 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.4/test/test.conf.def0000644002370600234200000000363711104317234015630 0ustar hattoriispconfig test_conf { enum week_t { MON, TUE, WED, THU, FRI, SAT, SUN } enum fruit_t { Apple, Orange, Peach, Lemon } required mutable int_val: int; required const bool_val : bool; required week_val : week_t; optional mutable string_val: string; optional const 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.4/Makefile0000644002370600234200000000036211074643517013732 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.4/sample/0000755002370600234200000000000011106211531013531 5ustar hattoriispconf4cpp-0.0.4/sample/sample.conf0000644002370600234200000000210611073375267015704 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.4/sample/Makefile0000644002370600234200000000064311073673122015207 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.4/sample/sample.cpp0000644002370600234200000000033411073673122015531 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.4/sample/sample.conf.def0000644002370600234200000000134111100777063016430 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.4/README0000644002370600234200000000443111074117775013155 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$