conf4cpp-0.0.6/0000755000076400007640000000000011121200454013135 5ustar hattorihattoriconf4cpp-0.0.6/Makefile0000644000076400007640000000036211074643517014620 0ustar hattorihattoriPREFIX = /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.6/src/0000755000076400007640000000000011121200453013723 5ustar hattorihattoriconf4cpp-0.0.6/src/conf4cpp.cpp0000644000076400007640000001020111111272623016144 0ustar hattorihattori/*============================================================================= * * 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, interface_file_name); 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); } confgen::output_interface_footer(ofs_hpp); confgen::output_implementation_footer(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.6/src/confdef_g.hpp0000644000076400007640000003277111121170437016370 0ustar hattorihattori/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef CONFDEF_HPP #define CONFDEF_HPP #include #include #include #include #include #include #include using namespace std; using namespace boost::spirit; using namespace conf4cpp; typedef map > enum_map_t; struct confdef_g : public grammar { struct type_val : closure { member1 val; }; struct typs_val : closure > { member1 val; }; struct typuint_val : closure { member1 val; member2 len; }; struct pairvar_val : closure > { member1 val; }; struct int_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 { typedef void result_type; sym_s& sym; enum_sym_t& elemsym; int& num; add_elemsym(sym_s &sym_, enum_sym_t& elemsym_, int &num_) : sym(sym_), elemsym(elemsym_), num(num_) {} template result_type operator() (const string& en, const IteratorT& first, const IteratorT& last) const { string key(first, last); sym.add(key.c_str(), make_pair(SYM_ELEM, ti_enum_t(en))); elemsym.add(key.c_str(), make_pair(en, num++)); } }; static bool chk_range(const ti_atomic_t& atyp) { switch (atyp.t) { case TI_INT: if (is_int(atyp.c->first) && is_int(atyp.c->second)) return boost::get(atyp.c->first) <= boost::get(atyp.c->second); break; case TI_UINT: if (is_uint(atyp.c->first) && is_uint(atyp.c->second)) return boost::get(atyp.c->first) <= boost::get(atyp.c->second); break; case TI_DOUBLE: if (is_double(atyp.c->first) && is_double(atyp.c->second)) return boost::get(atyp.c->first) <= boost::get(atyp.c->second); break; default: assert(false); } return true; } static bool chk_rantype(ti_atomic_t& atyp) { switch (atyp.t) { case TI_INT: // normalize to int if (is_uint(atyp.c->first) && boost::get(atyp.c->first) <= INT_MAX) atyp.c->first = int(boost::get(atyp.c->first)); if (is_uint(atyp.c->second) && boost::get(atyp.c->second) <= INT_MAX) atyp.c->second = int(boost::get(atyp.c->second)); return !(is_bool(atyp.c->first) && is_bool(atyp.c->second)) && (is_bool(atyp.c->first) || is_int(atyp.c->first)) && (is_bool(atyp.c->second) || is_int(atyp.c->second)); case TI_UINT: return !(is_bool(atyp.c->first) && is_bool(atyp.c->second)) && (is_bool(atyp.c->first) || is_uint(atyp.c->first)) && (is_bool(atyp.c->second) || is_uint(atyp.c->second)); case TI_DOUBLE: return !(is_bool(atyp.c->first) && is_bool(atyp.c->second)) && (is_bool(atyp.c->first) || is_double(atyp.c->first)) && (is_bool(atyp.c->second) || is_double(atyp.c->second)); default: return false; } } static type_t strip_type(const vector& typs) { if (typs.size() == 1) return typs.front(); return typs; } static void add_type(vector& typs, const type_t& ty) { typs.push_back(ty); } template struct definition { rule config_r, spec_r, itemdef_r, enumdef_r; rule texp_r, atomic_texp_r; rule compound_texp_r; rule postfix_texp_r ; rule list_type_r; rule constraints_r; rule mandatory_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_e("no enum element"); assertion rsvwd_redef_e("reserved word redefined"); assertion typnm_redef_e("type name redefined"); assertion symbol_redef_e("symbol redefined"); assertion invalid_range_e("invalid range"); assertion invalid_rantype_e("invalid range type"); assertion defval_typemismatch_e("default value is type mismatch"); assertion defval_outofrange_e("default value is out of range"); assertion parse_failed_e("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.itemtyp_map,self.cur_sym)] >> !('=' >> value_p[var(value_p.val)=bind(&normalize)(var(self.itemtyp_map),var(self.cur_sym),var(value_p.val))] [insert_at_a(self.itemdef_map,self.cur_sym,value_p.val)] >> defval_typemismatch_e(eps_p(bind(&type_mismatch)(var(self.itemtyp_map),var(self.itemdef_map),var(self.cur_sym))==false)) >> defval_outofrange_e(eps_p(bind(&out_of_range)(var(self.itemtyp_map),var(self.itemdef_map),var(self.cur_sym))==false)) ) >> ';'; enumdef_r = lexeme_d[str_p("enum") >> blank_p] >> (( newenum_sym[var(self.cur_sym)=arg1] >> '{' >> expect_elem_e(elemseq_r[insert_at_a(self.enumelem_map,self.cur_sym)]) >> '}' ) | parse_failed_e(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_type)(arg1)]; compound_texp_r = postfix_texp_r[compound_texp_r.val=construct_ >(1,arg1)] >> *(',' >> postfix_texp_r[bind(&add_type)(compound_texp_r.val,arg1)] ); postfix_texp_r = list_type_r[postfix_texp_r.len=arg1] >> '<' >> texp_r[postfix_texp_r.val=bind(&make_pair)(postfix_texp_r.len,arg1)] >> '>' // >> !( '(' >> uint_p >> ')' ) | atomic_texp_r[postfix_texp_r.val=arg1]; list_type_r = str_p("list")[list_type_r.val=VAR_VECTOR] >> !('[' >> uint_p[list_type_r.val=static_cast_(arg1)] >> ']'); atomic_texp_r = sym_p[var(self.cur_type)=arg1] >> eps_p(var(self.cur_type.first)==SYM_TYPENAME)[var(self.cur_atyp)=bind(&get_atom)(var(self.cur_type.second))] >> !('[' >> constraints_r[var(self.cur_atyp)=construct_(var(self.cur_atyp.t),arg1)] >> (eps_p(bind(&chk_rantype)(var(self.cur_atyp))) | invalid_rantype_e(nothing_p)) >> ']' >> (eps_p(bind(&chk_range)(var(self.cur_atyp))) | invalid_range_e(nothing_p)) ) >> eps_p[atomic_texp_r.val=var(self.cur_atyp)] | sym_p[var(self.cur_type)=arg1] >> eps_p(var(self.cur_type.first)==SYM_ENUM)[atomic_texp_r.val=var(self.cur_type.second)] | '(' >> compound_texp_r[atomic_texp_r.val=arg1] >> ')'; constraints_r = eps_p[var(self.cur_range)=construct_ >(false,false)] >> !( strict_real_p[var(self.cur_range.first)=arg1] | uint_p[var(self.cur_range.first)=arg1] | int_p[var(self.cur_range.first)=arg1] ) >> '~' >> !( strict_real_p[var(self.cur_range.second)=arg1] | uint_p[var(self.cur_range.second)=arg1] | int_p[var(self.cur_range.second)=arg1] ) >> eps_p[constraints_r.val=var(self.cur_range)]; 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_e(nothing_p) ) | ( eps_p(var(self.cur_type.first)==SYM_TYPENAME) >> typnm_redef_e(nothing_p) ) | symbol_redef_e(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[bind(add_elemsym(sym_p,value_p.constvals_p,self.cur_num))(var(self.cur_sym),arg1,arg2)] [newelem_sym.val=construct_(arg1,arg2)] ; elemseq_r = eps_p[var(self.cur_num)=0] >> 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 int cur_num; mutable bool cur_req, cur_con; mutable pair cur_type; mutable ti_atomic_t cur_atyp; mutable pair cur_range; mutable vector elem_list; mutable tyinfo_map_t itemtyp_map; mutable value_map_t itemdef_map; mutable enum_map_t enumelem_map; mutable map itemreq_map, itemcon_map; mutable string conf_name; }; #endif /* CONFDEF_HPP */ conf4cpp-0.0.6/src/Makefile0000644000076400007640000000105611117242740015377 0ustar hattorihattoriTARGET = conf4cpp SRCS = \ conf4cpp.cpp \ confgen.cpp CXXFLAGS= -Wall -g #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.6/src/confgen.hpp0000644000076400007640000000433411120442257016070 0ustar hattorihattori/*============================================================================= * * 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), itemtyp_map_(g.itemtyp_map), itemdef_map_(g.itemdef_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, const string& incfile); static void output_interface_footer(ostream& os); static void output_implementation_header(ostream& os, const string& incfile); static void output_implementation_footer(ostream& os); private: static void output_file_header(ostream& os); void output_interface_enumdefs(ostream& os); void output_interface_accessors(ostream& os); void output_interface_initializers(ostream& os); void output_interface_setters(ostream& os); void output_interface_rngchks(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_accessors(ostream& os); void output_implementation_config_initializers(ostream& os); void output_implementation_config_setters(ostream& os); void output_implementation_config_rngchks(ostream& os); void output_implementation_config_enum2str(ostream& os); void output_implementation_config_dump(ostream& os); const string conf_name_; const tyinfo_map_t itemtyp_map_; const value_map_t itemdef_map_; const map itemreq_map_, itemcon_map_; const enum_map_t enumelem_map_; }; #endif /* CONFGEN_HPP */ conf4cpp-0.0.6/src/confgen.cpp0000644000076400007640000010241711121176471016067 0ustar hattorihattori/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #include #include "confgen.hpp" using boost::lexical_cast; static string get_typestr(const type_t& ty); template static T near_zero(T a, T b) { assert(a <= b); if (a > 0) return a; if (b < 0) return b; return T(0); } static string indent(unsigned int lv) { string ret; for (unsigned int i = 0; i < lv; i++) ret += "\t"; return ret; } static string to_cchar(const string& name) { string ret; for (string::const_iterator iter = name.begin(); iter != name.end(); ++iter) { if (isalnum(*iter)) ret += toupper(*iter); else ret += '_'; } return ret; } 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: if (ta.c) { if (is_int(ta.c->first) && is_int(ta.c->second)) return near_zero(boost::get(ta.c->first),boost::get(ta.c->second)); if (is_int(ta.c->first) && boost::get(ta.c->first) > 0) return boost::get(ta.c->first); if (is_int(ta.c->second) && boost::get(ta.c->second) < 0) return boost::get(ta.c->second); } return int(0); case TI_UINT: if (ta.c && is_uint(ta.c->first)) return boost::get(ta.c->first); return (unsigned int)(0); case TI_DOUBLE: if (ta.c) { if (is_double(ta.c->first) && is_double(ta.c->second)) return near_zero(boost::get(ta.c->first),boost::get(ta.c->second)); if (is_double(ta.c->first) && boost::get(ta.c->first) > 0.0) return boost::get(ta.c->first); if (is_double(ta.c->second) && boost::get(ta.c->second) < 0.0) return boost::get(ta.c->second); } 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 } // // 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() (ti_vect_t tp) const { return string("vector<") + apply_visitor(type_string(),tp.second) + " >"; } string operator() (ti_tuple_t 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 range_string(const string& ta_name, ti_atomic_t ta) const { if (!ta.c) return ta_name; return "ti_atomic_t(" + ta_name + ",make_pair(" + to_str(ta.c->first) + "," + to_str(ta.c->second) + "))"; } string operator() (ti_atomic_t ta) const { switch (ta) { case TI_BOOL: return "TI_BOOL"; case TI_INT: return range_string("TI_INT",ta); case TI_UINT: return range_string("TI_UINT",ta); case TI_DOUBLE: return range_string("TI_DOUBLE",ta); 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(\"") + lexical_cast(te.eid) + "\")"; } string operator() (ti_vect_t tp) const { return string("make_pair(") + lexical_cast(tp.first) + "," + apply_visitor(tset_string(lv+1),tp.second) + ")"; } string operator() (ti_tuple_t tv) const { string ret("(\n" + indent(lv)); ret += "tvv.push_back(ti_tuple_t()),\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; }; // // value setter string // struct vset_string : public boost::static_visitor { vset_string(const enum_map_t& 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 + " = boost::get(" + rhs + ");"; case TI_INT: return lhs + " = boost::get(" + rhs + ");"; case TI_UINT: return lhs + " = boost::get(" + rhs + ");"; case TI_DOUBLE: return lhs + " = boost::get(" + rhs + ");"; case TI_STRING: return lhs + " = boost::get(" + rhs + ");"; case TI_TIME: return lhs + " = boost::get(" + rhs + ");"; case TI_IPV4ADDR: return lhs + " = boost::get(" + rhs + ");"; case TI_IPV6ADDR: return lhs + " = boost::get(" + rhs + ");"; } assert(false); return "???"; } string operator() (ti_enum_t te) const { if (eem.find(te.eid) == eem.end()) { assert(false); } return lhs + " = " + te.eid + "(boost::get >(" + rhs + ").second);"; } string operator() (ti_vect_t tp) const { string istr = "i"+lexical_cast(lv); string ret("vector " + lhs + "v = boost::get >(" + rhs + ");\n" + indent(lv-1)); ret += "for (unsigned int "+istr+" = 0; "+istr+" < " + lhs + "v.size(); "+istr+"++) {\n" + indent(lv); ret += get_typestr(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() (ti_tuple_t tv) const { string ret; for (unsigned int i = 0; i < tv.size(); i++) { string tystr = get_typestr(tv[i]); string istr = lexical_cast(i); ret += tystr + " " + lhs + istr + ";\n" + indent(lv-1); ret += apply_visitor(vset_string(eem,lhs+istr,"boost::get >("+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 + lexical_cast(i) + ","; } ret += lhs + lexical_cast(tv.size()-1) + ");"; return ret; } const enum_map_t& eem; const string& lhs; const string& rhs; unsigned int lv; }; // // format string for range check // template static string range_check(const string& v, const var_t& a, const var_t& b) { string ret; if (is_(a) && is_(b)) ret = "if (" + v + " < " + lexical_cast(boost::get(a)) + " || " + v + " > " + lexical_cast(boost::get(b)) + ") return false;"; else if (is_(a)) ret = "if (" + v + " < " + lexical_cast(boost::get(a)) + ") return false;"; else if (is_(b)) ret = "if (" + v + " > " + lexical_cast(boost::get(b)) + ") return false;"; return ret; } struct rchk_string : public boost::static_visitor { rchk_string(const string& rhs_, unsigned int lv_) : rhs(rhs_), lv(lv_) {} const string& rhs; unsigned int lv; string operator() (ti_atomic_t ta) const { if (!ta.c) return ""; switch (ta) { case TI_BOOL: break; case TI_INT: return range_check (rhs, ta.c->first, ta.c->second); case TI_UINT: return range_check(rhs, ta.c->first, ta.c->second); case TI_DOUBLE: return range_check (rhs, ta.c->first, ta.c->second); case TI_STRING: break; case TI_TIME: break; case TI_IPV4ADDR: break; case TI_IPV6ADDR: break; } assert(false); return "???"; } string operator() (ti_enum_t te) const { return ""; } string operator() (ti_vect_t tp) const { string ret; if (tp.first >= 0) { ret += "if (" + rhs + ".size() != " + lexical_cast(tp.first) + ") return false;\n" + indent(lv); } string istr = "i"+lexical_cast(lv); string rchk = apply_visitor(rchk_string(istr+"v",lv+1),tp.second); if (rchk == "") return ret; ret += "for (unsigned int "+istr+" = 0; "+istr+" < " + rhs + ".size(); "+istr+"++) {\n" + indent(lv+1); ret += get_typestr(tp.second) + " " + istr + "v = " + rhs + "[" + istr + "];\n" + indent(lv+1); ret += rchk + "\n" + indent(lv); ret += "}"; return ret; } string operator() (ti_tuple_t tv) const { string ret; for (unsigned i = 0; i < tv.size(); i++) { string rchk = apply_visitor(rchk_string("boost::get<"+lexical_cast(i)+">("+rhs+")",lv+1),tv[i]); if (rchk == "") continue; ret += rchk + "\n" + indent(lv); } return ret; } }; // // 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() (ti_vect_t 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" + 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() (ti_tuple_t 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<"+lexical_cast(i)+">("+kw+")",lv),tv[i]); ret += indent(lv) + "os << \",\";\n"; } ret += apply_visitor(dump_string("boost::get<"+lexical_cast(i)+">("+kw+")",lv),tv[i]); ret += indent(lv) + "os << \"}\";\n"; return ret; } const string& kw; unsigned int lv; }; // // format string for default value setting // struct defv_string : public boost::static_visitor { defv_string(const string& lhs_, const var_t& dv_, unsigned int lv_) : lhs(lhs_), dv(dv_), lv(lv_) {} string operator() (ti_atomic_t ta) const { if (is_nil(dv)) { dv = def_value(ta); } switch (ta) { case TI_BOOL: return lhs + " = " + (boost::get(dv) ? "true" : "false") + ";"; case TI_INT: return lhs + " = " + lexical_cast(boost::get(dv)) + ";"; case TI_UINT: return lhs + " = " + lexical_cast(boost::get(dv)) + "U;"; case TI_DOUBLE: return lhs + " = " + lexical_cast(boost::get(dv)) + ";"; case TI_STRING: return lhs + " = \"" + boost::get(dv) + "\";"; case TI_TIME: { struct tm t = boost::get(dv); string ret("*localtime((t_="); ret += lexical_cast(mktime(&t)) + ",&t_))"; return lhs + " = " + ret + ";"; } case TI_IPV4ADDR: return lhs + " = to_in_addr(" + lexical_cast(boost::get(dv).s_addr) + ");"; case TI_IPV6ADDR: { struct in6_addr addr = boost::get(dv); unsigned int i; string ret("to_in6_addr("); for (i = 0; i < sizeof(addr.s6_addr)-1; i++) { ret += lexical_cast(int(addr.s6_addr[i])) + ","; } ret += lexical_cast(int(addr.s6_addr[i])) + ")"; return lhs + " = " + ret + ";"; } } assert(false); return "???"; } string operator() (ti_enum_t te) const { if (is_nil(dv)) { return lhs + " = " + te.eid + "(0);"; } return lhs + " = " + boost::get >(dv).first + "(" + lexical_cast(boost::get >(dv).second) + ");"; } string operator() (ti_vect_t tp) const { if (tp.first < 0 && is_nil(dv)) { return lhs + " = vector<" + get_typestr(tp.second) + " >();"; } string ret(get_typestr(tp.second) + " " + lhs + "iv;\n"); if (is_nil(dv)) { for (int i = 0; i < tp.first; i++) { ret += indent(lv-1) + apply_visitor(defv_string(lhs+"iv",dv,lv+1),tp.second) + "\n" + indent(lv-1); ret += indent(lv-1) + lhs + ".push_back(" + lhs + "iv);\n" + indent(lv-1); } } else { vector dvv = boost::get >(dv); for (unsigned int i = 0; i < dvv.size(); i++) { ret += indent(lv-1) + apply_visitor(defv_string(lhs+"iv",dvv[i],lv+1),tp.second) + "\n"; ret += indent(lv-1) + lhs + ".push_back(" + lhs + "iv);\n"; } } return ret; } string operator() (ti_tuple_t tv) const { string ret; ret += "{\n" + indent(lv-1); for (unsigned int i = 0; i < tv.size(); i++) { string tystr = get_typestr(tv[i]); string istr = lexical_cast(i); ret += tystr + " " + lhs + istr + ";\n" + indent(lv-1); if (is_nil(dv)) { ret += apply_visitor(defv_string(lhs+istr,dv,lv),tv[i]) + "\n" + indent(lv-1); } else { ret += apply_visitor(defv_string(lhs+istr,boost::get >(dv)[i],lv),tv[i]) + "\n" + indent(lv-1); } } ret += lhs + " = make_tuple("; for (unsigned int i = 0; i < tv.size()-1; i++) { ret += lhs + lexical_cast(i) + ","; } ret += lhs + lexical_cast(tv.size()-1) + ");"; ret += "}\n" + indent(lv-1); return ret; } const string& lhs; mutable var_t dv; unsigned int lv; }; static inline string get_typestr(const type_t& ty) { return apply_visitor(type_string(), ty); } static inline string get_tsetstr(const type_t& ty, unsigned int lv) { return apply_visitor(tset_string(lv), ty); } static inline string get_vsetstr(const type_t& ty, const string& lhs, const string& rhs, unsigned int lv, const enum_map_t& enumelem_map) { return apply_visitor(vset_string(enumelem_map,lhs,rhs,lv), ty); } static inline string get_defvstr(const type_t& ty, const string& lhs, const var_t& dv, unsigned int lv) { return apply_visitor(defv_string(lhs,dv,lv), ty); } static inline string get_rchkstr(const type_t& ty, const string& rhs, unsigned int lv) { return apply_visitor(rchk_string(rhs,lv), ty); } static inline string get_dumpstr(const string& kw, const type_t& ty, unsigned int lv) { return apply_visitor(dump_string(kw+"_", lv), ty); } void confgen::output_interface_header(ostream& os, const string& incfile) { os << "// conf4cpp : interface definition" << endl; output_file_header(os); os << "#ifndef " << to_cchar(incfile) << endl << "#define " << to_cchar(incfile) << endl << endl; os << "#include " << endl << "#include " << endl << "using boost::tuple;" << endl; } void confgen::output_interface_footer(ostream& os) { os << "#endif" << 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_implementation_footer(ostream& os) { } 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 private setter // // 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; // output public members 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 (enum_map_t::const_iterator iter = enumelem_map_.begin(); iter != enumelem_map_.end(); ++iter) { os << "\tstatic const char* enum2str(" << iter->first << " e);" << endl; } // output private members os << "private:" << endl; os << "\t// prohibit copy constructor and assign operation" << endl; os << "\t" << conf_name_ << "(const " << conf_name_ << "&);" << endl; os << "\t" << conf_name_ << "& operator=(const " << conf_name_ << "&);" << endl; output_interface_initializers(os); output_interface_setters(os); output_interface_rngchks(os); output_interface_members(os); os << "};" << endl; } void confgen::output_interface_enumdefs(ostream& os) { os << "\t// definitions of enum type" << endl; for (enum_map_t::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; os << "\tbool set(const string& itemdef);" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_map_.end(); ++iter) { os << "\tconst " << get_typestr(iter->second) << "& " << 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 << "\tbool set_" << iter->first << "(const " << get_typestr(iter->second) << "& v);" << endl; } } void confgen::output_interface_initializers(ostream& os) { os << "\t// definitions of private initializers" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_map_.end(); ++iter) { if (!itemreq_map_.find(iter->first)->second) os << "\tvoid init_" << iter->first << "_();" << endl; } } void confgen::output_interface_setters(ostream& os) { os << "\t// definitions of private setters" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_map_.end(); ++iter) { os << "\tvoid set_" << iter->first << "_(const conf4cpp::var_t& v_);" << endl; } } void confgen::output_interface_rngchks(ostream& os) { os << "\t// definitions of private range checkers" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_map_.end(); ++iter) { if (!itemcon_map_.find(iter->first)->second) { os << "\tbool rngchk_" << iter->first << "_(const " << get_typestr(iter->second) << "& v_);" << endl; } } } void confgen::output_interface_members(ostream& os) { os << "\t// definitions of members" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_map_.end(); ++iter) { os << "\t" << get_typestr(iter->second) << " " << 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; os << "namespace conf4cpp {" << endl << "\ttemplate<> base_config<" << conf_name_ << "_parser>::~base_config() { delete p; }" << endl << "\ttemplate<> bool base_config<" << conf_name_ << "_parser>::set(const string& itemdef) { return parse_itemdef(itemdef.c_str()); }" << endl << "}" << endl; output_implementation_config_constructor(os); output_implementation_config_accessors(os); output_implementation_config_initializers(os); output_implementation_config_setters(os); output_implementation_config_rngchks(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 (itemtyp_map_.begin() != itemtyp_map_.end()) { os << "\t\t\tadd" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_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 (enum_map_t::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()" << 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\tti_tuple_t tv;" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_map_.end(); ++iter) { os << "\t\ttimap[\"" << iter->first << "\"] = " << get_tsetstr(iter->second, 2) << ";" << 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 << "using boost::make_tuple;" << endl; os << "// definition config constructor" << endl; os << conf_name_ << "::" << conf_name_ << "(const string& fname) : base_config<" << conf_name_ << "_parser>(fname)" << endl; os << "{" << endl; os << "\ttime_t t_ __attribute__((unused));" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_map_.end(); ++iter) { if (!itemreq_map_.find(iter->first)->second) { // オプション項目 os << "\tif (p->vmap.find(\"" << iter->first << "\")!=p->vmap.end()) {" << endl; os << "\t\tset_" << iter->first << "_(p->vmap[\"" << iter->first << "\"]);" << endl << "\t} else {" << endl << "\t\thas_" << iter->first << "_ = false;" << endl << "\t\tinit_" << iter->first << "_();" << endl << "\t}" << endl; } else { // 必須項目 os << "\tset_" << iter->first << "_(p->vmap[\"" << iter->first << "\"]);" << endl; } } os << "}" << endl; } void confgen::output_implementation_config_accessors(ostream& os) { os << "// definitions of accessors" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_map_.end(); ++iter) { if (!itemcon_map_.find(iter->first)->second) { type_t t = iter->second; os << "bool " << conf_name_ << "::set_" << iter->first << "(const " << get_typestr(t) << "& v) { "; os << "if (rngchk_" << iter->first << "_(v)) { " << iter->first << "_ = v; return true; } else return false; }" << endl; } } os << "bool " << conf_name_ << "::set(const string& itemdef) {" << endl; os << "\tif (!base_config<" << conf_name_ << "_parser>::set(itemdef)) return false;" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_map_.end(); ++iter) { string key = iter->first; if (!itemcon_map_.find(key)->second) { os << "\tif (p->vmap.find(\"" << key << "\")!=p->vmap.end()) set_" << key << "_(p->vmap[\"" << key << "\"]);" << endl; } else { os << "\tif (p->vmap.find(\"" << key << "\")!= p->vmap.end()) return false;" << endl; } } os << "\treturn true;" << endl; os << "}" << endl; } void confgen::output_implementation_config_initializers(ostream& os) { os << "// definitions of private initializers" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_map_.end(); ++iter) { if (!itemreq_map_.find(iter->first)->second) { value_map_t::const_iterator di = itemdef_map_.find(iter->first); os << "void " << conf_name_ << "::init_" << iter->first << "_() {" << endl; os << "\ttime_t t_ __attribute__((unused));" << endl; os << "\t" << get_defvstr(iter->second, iter->first+"_", di == itemdef_map_.end() ? boost::spirit::nil_t() : di->second, 2) << endl; os << "}" << endl; } } } void confgen::output_implementation_config_setters(ostream& os) { os << "// definitions of private setters" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_map_.end(); ++iter) { os << "void " << conf_name_ << "::set_" << iter->first << "_(const var_t& v_) {" << endl; if (!itemreq_map_.find(iter->first)->second) { os << "\thas_" << iter->first << "_ = true;" << endl; } os << "\t" << get_vsetstr(iter->second, iter->first+"_", "v_", 2, enumelem_map_) << endl; os << "}" << endl; } } void confgen::output_implementation_config_rngchks(ostream& os) { os << "// definitions of private range checkers" << endl; for (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_map_.end(); ++iter) { if (!itemcon_map_.find(iter->first)->second) { os << "bool " << conf_name_ << "::rngchk_" << iter->first << "_(const " << get_typestr(iter->second) << "& v_) {" << endl; os << "\t" << get_rchkstr(iter->second, "v_", 1) << endl; os << "\treturn true;" << endl; os << "}" << endl; } } } void confgen::output_implementation_config_enum2str(ostream& os) { os << "// definition config enum2str" << endl; for (enum_map_t::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 (tyinfo_map_t::const_iterator iter = itemtyp_map_.begin(); iter != itemtyp_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, 2) << "\t\tos << \";\" << endl;" << endl; os << "\t} else {" << endl; os << "\t\tos << \"\\toptional: " << iter->first << " = [DEFAULT]\";" << endl << get_dumpstr(iter->first, iter->second, 2) << "\t\tos << \";\" << endl;" << endl; os << "\t}" << endl; } else { os << "\tos << \"\\trequired: " << iter->first << " = \";" << endl << get_dumpstr(iter->first, iter->second, 1) << "\tos << \";\" << endl;" << endl; } } os << "\tos << \"}\" << endl;" << endl; os << "}" << endl; } conf4cpp-0.0.6/ChangeLog0000644000076400007640000000414311121177627014730 0ustar hattorihattori2008-12-14 Kenta HATTORI * conf4cpp-0.0.6 リリース * 生成コードのコピーコンストラクタ，代入演算子をプライベートとした * int型におけるuintの処理を簡単にするためパース直後に正規化処理を 行なうにした 2008-12-11 Kenta HATTORI * 範囲型に対する未指定のデフォルト値が範囲内に収まるようにした * デフォルト値の指定書式を変更 2008-11-21 Kenta HATTORI * conf4cpp-0.0.5 リリース * 生成コードのインデントのズレを修正 * 汎用setter関数の定義を追加a * インクルードガードを生成するようにした * mutableとmandatoryの順序に関するバグを修正 * setter関数の戻り値をbool型にし，範囲チェックを追加 2008-11-20 Kenta HATTORI * int, uint, real型の値に範囲指定を実装 * インクルードガードの出力を追加 2008-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.6/test/0000755000076400007640000000000011121200453014113 5ustar hattorihattoriconf4cpp-0.0.6/test/test.conf0000644000076400007640000000170711121170437015756 0ustar hattorihattori# # 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},{"hoge",3}; 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"}; real_ranval = 33.23; real_ranval2 = 5.3; real_ranval3 = 50.0; int_ranval = -11; int_ranval2 = 5; int_ranval3 = 33; uint_ranval = 100; uint_ranval2 = 100; uint_ranval3 = 120; ;#range_vals = 32.5,122,-303 ;; ranval_list = 3,-4; conf4cpp-0.0.6/test/Makefile0000644000076400007640000000065211111313350015556 0ustar hattorihattoriTARGET = test_conf SRCS = \ conf.out.cpp \ test_conf.cpp CONF4CPP= ../src/conf4cpp CXXFLAGS= -Wall -g 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.6/test/compile_guard/0000755000076400007640000000000011121200453016725 5ustar hattorihattoriconf4cpp-0.0.6/test/compile_guard/Makefile0000644000076400007640000000070111121176471020377 0ustar hattorihattoriTARGET = compile_guard SRCS = \ conf.out.cpp \ compile_guard.cpp CONF4CPP= ../../src/conf4cpp CXXFLAGS= -Wall -g 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 : compile_guard.conf.def $(CONF4CPP) $< .PHONY: clean clean : rm -fr $(OBJS) $(TARGET) $(DEPS) conf.out.cpp conf.out.hpp conf4cpp-0.0.6/test/compile_guard/compile_guard.conf.def0000644000076400007640000000010011121176471023146 0ustar hattorihattoriconfig compile_guard_conf { foo : int; bar : string; } conf4cpp-0.0.6/test/compile_guard/compile_guard.cpp0000644000076400007640000000055411121176471022263 0ustar hattorihattori#include #include "conf.out.hpp" int main(int argc, char* args[]) { if (argc < 2) { cout << "no input file.\n"; return -1; } compile_guard_conf conf(args[1]); compile_guard_conf conf2(conf); compile_guard_conf conf3 = conf; compile_guard_conf conf4(args[1]); conf4 = conf; conf.dump(cout); return 0; } conf4cpp-0.0.6/test/test.conf.def0000644000076400007640000000530411120442257016511 0ustar hattorihattoriconfig test_conf { enum week_t { MON, TUE, WED, THU, FRI, SAT, SUN } enum fruit_t { Apple, Orange, Peach, Lemon } required mutable int_val: int[-1000~10000]; required const bool_val : bool; required week_val : week_t; optional mutable string_val: string; optional const real_val : real; required string_list : list; mutable required string0_list : list[0]; mutable 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,int,bool = {-3.14,5,false}; optional rib_tuple_def2 : real,int,bool; mutable optional stri_list_def : list[3] = {"hoge",1234},{"hoge",1234},{"hoge",1234}; 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 = 0.0.0.0,24; optional net6addr_val : ipv6addr,int; optional datadrstr_vals : list; optional real_ranval : real[32.5~100.3]; optional real_ranval2 : real[1.0~]; optional real_ranval3 : real[~50.0]; optional int_ranval : int[-32 ~ -10]; optional int_ranval2 : int[-32~ 100]; optional int_ranval3 : int[3~ 100]; optional int_ranval4 : int[3~ 100]; # default is 3 optional int_ranval5 : int[-3~ 100]; # default is 0 optional int_ranval6 : int[-30~-10]; # default is -10 optional uint_ranval : uint[32~100]; optional uint_ranval2 : uint[~100]; mutable optional uint_ranval3 : uint[100 ~ ]; mutable optional range_vals : real[32.5~100.3],uint[100 ~ ],int[~-10] = 32.5, 100, -30; required mutable ranval_list : list[2]; } conf4cpp-0.0.6/test/config_error/0000755000076400007640000000000011121200453016571 5ustar hattorihattoriconf4cpp-0.0.6/test/config_error/invaliddate.4.conf0000644000076400007640000000005011103731067022073 0ustar hattorihattorireq_int_val = 0; date_val = 2009/12/32; conf4cpp-0.0.6/test/config_error/outofrange.2.conf0000644000076400007640000000004411111007723021753 0ustar hattorihattorireq_int_val = 10; intran_val = -11; conf4cpp-0.0.6/test/config_error/parseerror.3.conf0000644000076400007640000000002011103731067021767 0ustar hattorihattoriuint_val = 0 #; conf4cpp-0.0.6/test/config_error/Makefile0000644000076400007640000000066511103731067020252 0ustar hattorihattoriTARGET = 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.6/test/config_error/invaliddate.6.conf0000644000076400007640000000006011103731067022076 0ustar hattorihattorireq_int_val = 0; date_val = 2009/12/31 23:69:30;conf4cpp-0.0.6/test/config_error/typemismatch.6.conf0000644000076400007640000000004311103731067022322 0ustar hattorihattorireq_int_val = 0; week_val = Apple; conf4cpp-0.0.6/test/config_error/invalidipaddr.6.conf0000644000076400007640000000005011103731067022423 0ustar hattorihattorireq_int_val = 0; ipv6_val = 1::2::3::4; conf4cpp-0.0.6/test/config_error/invalidipaddr.5.conf0000644000076400007640000000005711103731067022431 0ustar hattorihattorireq_int_val = 0; ipv6_val = ::1:2:3:4:5:6:7:8; conf4cpp-0.0.6/test/config_error/typemismatch.7.conf0000644000076400007640000000004611103731067022326 0ustar hattorihattorireq_int_val = 0; fruit_val = "Apple"; conf4cpp-0.0.6/test/config_error/outofrange.1.conf0000644000076400007640000000004311111007723021751 0ustar hattorihattorireq_int_val = 10; intran_val = 11; conf4cpp-0.0.6/test/config_error/unclosedstr.conf0000644000076400007640000000006611103731067022021 0ustar hattorihattorireq_int_val = 0; string_val = "hogehoge; uint_val = 5;conf4cpp-0.0.6/test/config_error/outofrange.4.conf0000644000076400007640000000004711111007723021760 0ustar hattorihattorireq_int_val = 10; realran_val = -11.0; conf4cpp-0.0.6/test/config_error/typemismatch.5.conf0000644000076400007640000000004011103731067022316 0ustar hattorihattorireq_int_val = 0; real_val = -3; conf4cpp-0.0.6/test/config_error/typemismatch.14.conf0000644000076400007640000000007111103731067022402 0ustar hattorihattorireq_int_val = 0; fruitsreal_val = {Apple,Banana},Orange; conf4cpp-0.0.6/test/config_error/typemismatch.3.conf0000644000076400007640000000005011103731067022315 0ustar hattorihattorireq_int_val = 3; bool_val = false,true; conf4cpp-0.0.6/test/config_error/invaliddate.2.conf0000644000076400007640000000004611103731067022076 0ustar hattorihattorireq_int_val = 0; date_val = 2009/13/3;conf4cpp-0.0.6/test/config_error/parseerror.2.conf0000644000076400007640000000001711103731067021774 0ustar hattorihattoriuint _val = 0; conf4cpp-0.0.6/test/config_error/conf_error.sh0000644000076400007640000000104111121170437021267 0ustar hattorihattori#!/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.6/test/config_error/typemismatch.11.conf0000644000076400007640000000005311103731067022377 0ustar hattorihattorireq_int_val = 0; ipv4net_val = 1.2.3.4,-3; conf4cpp-0.0.6/test/config_error/emptyfile.conf0000644000076400007640000000000011103731067021436 0ustar hattorihattoriconf4cpp-0.0.6/test/config_error/typemismatch.1.conf0000644000076400007640000000002511103731067022315 0ustar hattorihattorireq_int_val = "foo"; conf4cpp-0.0.6/test/config_error/typemismatch.4.conf0000644000076400007640000000004311103731067022320 0ustar hattorihattorireq_int_val = 3; string_val = MON; conf4cpp-0.0.6/test/config_error/invalidipaddr.3.conf0000644000076400007640000000006311103731067022424 0ustar hattorihattorireq_int_val = 0; ipv6_val = 1:2:3:4:5:6:7::8:9:10; conf4cpp-0.0.6/test/config_error/conf_error.cpp0000644000076400007640000000047111103731067021447 0ustar hattorihattori#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.6/test/config_error/outofrange.3.conf0000644000076400007640000000004511111007723021755 0ustar hattorihattorireq_int_val = 10; uintran_val = 110; conf4cpp-0.0.6/test/config_error/conf_error.conf.def0000644000076400007640000000141411111007723022337 0ustar hattorihattoriconfig 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; optional intran_val : int[-10~10]; optional uintran_val : uint[~100]; optional realran_val : real[1.0~]; } conf4cpp-0.0.6/test/config_error/typemismatch.15.conf0000644000076400007640000000005211103731067022402 0ustar hattorihattorireq_int_val = 0; weekbi_val = MON,true,3; conf4cpp-0.0.6/test/config_error/parseerror.1.conf0000644000076400007640000000000211103731067021765 0ustar hattorihattori3 conf4cpp-0.0.6/test/config_error/typemismatch.2.conf0000644000076400007640000000004211103731067022315 0ustar hattorihattorireq_int_val = 0; uint_val = -123; conf4cpp-0.0.6/test/config_error/invalidipaddr.4.conf0000644000076400007640000000005711103731067022430 0ustar hattorihattorireq_int_val = 0; ipv6_val = 1:2:3:4:5:6:7:8::; conf4cpp-0.0.6/test/config_error/invaliddate.3.conf0000644000076400007640000000004611103731067022077 0ustar hattorihattorireq_int_val = 0; date_val = 2009/0/30;conf4cpp-0.0.6/test/config_error/redefined.conf0000644000076400007640000000004711103731067021400 0ustar hattorihattorireq_int_val = 123; req_int_val = -322; conf4cpp-0.0.6/test/config_error/invalidipaddr.2.conf0000644000076400007640000000004711103731067022425 0ustar hattorihattorireq_int_val = 0; ipv4_val = 1.2.3.4.5; conf4cpp-0.0.6/test/config_error/typemismatch.10.conf0000644000076400007640000000004511103731067022377 0ustar hattorihattorireq_int_val = 0; ipv6_val = 1.2.3.4; conf4cpp-0.0.6/test/config_error/typemismatch.9.conf0000644000076400007640000000004111103731067022323 0ustar hattorihattorireq_int_val = 0; ipv4_val = ::1; conf4cpp-0.0.6/test/config_error/typemismatch.8.conf0000644000076400007640000000004611103731067022327 0ustar hattorihattorireq_int_val = 0; date_val = 1:2:3::4; conf4cpp-0.0.6/test/config_error/typemismatch.12.conf0000644000076400007640000000004611103731067022402 0ustar hattorihattorireq_int_val = 0; strlist_val = 3,4,5; conf4cpp-0.0.6/test/config_error/invaliddate.5.conf0000644000076400007640000000005711103731067022103 0ustar hattorihattorireq_int_val = 0; date_val = 2009/12/31 25:1:30;conf4cpp-0.0.6/test/config_error/invalidlength.conf0000644000076400007640000000005511103731067022302 0ustar hattorihattorireq_int_val = 0; strlist3_val = "foo","bar"; conf4cpp-0.0.6/test/config_error/invaliddate.1.conf0000644000076400007640000000004511103731067022074 0ustar hattorihattorireq_int_val = 0; date_val = 10:30:10;conf4cpp-0.0.6/test/config_error/undefined.conf0000644000076400007640000000001611103731067021410 0ustar hattorihattoriuint_val = 3; conf4cpp-0.0.6/test/config_error/typemismatch.13.conf0000644000076400007640000000006511103731067022404 0ustar hattorihattorireq_int_val = 0; intbools_val = {3,true},{{3,true}}; conf4cpp-0.0.6/test/config_error/invaliddate.7.conf0000644000076400007640000000006111103731067022100 0ustar hattorihattorireq_int_val = 0; date_val = 2009/12/31 23:59:69; conf4cpp-0.0.6/test/config_error/invalidipaddr.1.conf0000644000076400007640000000004311103731067022420 0ustar hattorihattorireq_int_val = 0; ipv4_val = 0.0.0; conf4cpp-0.0.6/test/test_conf.cpp0000644000076400007640000001523011120442257016615 0ustar hattorihattori#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"); vector string0_list_val(1,"foo"); assert(conf.set_string0_list(string0_list_val)==false); assert(conf.string0_list().size()==0); vector int1_list_val(5); assert(conf.set_int1_list(int1_list_val)==false); 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"); assert(conf.set_uint_ranval3(123)==true); assert(conf.uint_ranval3()==123); assert(conf.set_uint_ranval3(11)==false); assert(conf.uint_ranval3()==123); vector > stri_list_def_val; assert(conf.set_stri_list_def(stri_list_def_val)==false); assert(conf.stri_list_def().size()==3); // test general setter assert(conf.set("uint_ranval3 = 200;")==true); assert(conf.uint_ranval3()==200); assert(conf.set("uint_ranval3 = 150; string_val = \"foo\"")==true); assert(conf.uint_ranval3()==150); assert(conf.string_val()=="foo"); assert(conf.set("int_val=1;")==true); assert(conf.int_val()==1); // 範囲外のデータはセットできない assert(conf.set("uint_ranval3 = 0; int_val=-123;")==false); assert(conf.uint_ranval3()==150); assert(conf.int_val()==1); // const項目はsetできない assert(conf.set("ipv4_value=1.2.3.4")==false); assert(conf.ipv4_value().s_addr==0); // default値のチェック assert(conf.int_ranval4()==3); assert(conf.int_ranval5()==0); assert(conf.int_ranval6()==-10); // range_vals: real[32.5~100.3],uint[100 ~ ],int[~-10] = 32.5, 100, -30; assert(boost::get<0>(conf.range_vals())==32.5); assert(boost::get<1>(conf.range_vals())==100); assert(boost::get<2>(conf.range_vals())==-30); assert(conf.set_range_vals(boost::make_tuple(double(0.0),(unsigned int)100,int(-20)))==false); // ranval_list:list[2] { vector ranval_list_val = conf.ranval_list(); assert(ranval_list_val.size()==2); assert(ranval_list_val[0] = 3); assert(ranval_list_val[1] = -4); ranval_list_val[1] = 100; // 配列要素の範囲違反 assert(conf.set_ranval_list(ranval_list_val)==false); } { // 配列の長さが違反 vector ranval_list_val(3); assert(conf.set_ranval_list(ranval_list_val)==false); } conf.dump(cout); return 0; } conf4cpp-0.0.6/test/compile_error/0000755000076400007640000000000011121200453016754 5ustar hattorihattoriconf4cpp-0.0.6/test/compile_error/typemismatch.conf.2.def0000644000076400007640000000005711120226346023241 0ustar hattorihattoriconfig type_mismatch_conf { foo : real = 1; } conf4cpp-0.0.6/test/compile_error/noelement.conf.def0000644000076400007640000000005211100615663022355 0ustar hattorihattoriconfig redefined_conf { enum foo_t { } } conf4cpp-0.0.6/test/compile_error/redefined.conf.3.def0000644000076400007640000000010211100615663022451 0ustar hattorihattoriconfig redefined_conf { enum foo_t { FOO } enum foo_t { BAR } } conf4cpp-0.0.6/test/compile_error/redefined.conf.1.def0000644000076400007640000000006311100615663022455 0ustar hattorihattoriconfig redefined_conf { foo : int; foo : bool; } conf4cpp-0.0.6/test/compile_error/typemismatch.conf.5.def0000644000076400007640000000013211120226346023236 0ustar hattorihattoriconfig type_mismatch_conf { enum foo_t { FOO } enum bar_t { BAR } foo : foo_t = BAR; } conf4cpp-0.0.6/test/compile_error/redefined.conf.5.def0000644000076400007640000000010411100615663022455 0ustar hattorihattoriconfig redefined_conf { enum foo_t { foo, bar, baz } foo : int; } conf4cpp-0.0.6/test/compile_error/badconfname.conf.def0000644000076400007640000000004011111272606022617 0ustar hattorihattoriconfig 123_conf { foo : int; } conf4cpp-0.0.6/test/compile_error/redefined.conf.2.def0000644000076400007640000000007011100615663022454 0ustar hattorihattoriconfig redefined_conf { enum foo_t { FOO, BAR, FOO } } conf4cpp-0.0.6/test/compile_error/typemismatch.conf.6.def0000644000076400007640000000006411120226346023243 0ustar hattorihattoriconfig type_mismatch_conf { foo : uint_t = -123; } conf4cpp-0.0.6/test/compile_error/compile_error.sh0000644000076400007640000000105111120226346022156 0ustar hattorihattori#!/bin/sh CONF4CPP=../../src/conf4cpp pass=0 total=0 for fname in *.def do $CONF4CPP $fname if test $? -ne 255 then echo "!!!" echo "!!! failed test case: $fname" echo "!!!" 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.6/test/compile_error/baditemname.conf.def0000644000076400007640000000005111111272606022632 0ustar hattorihattoriconfig bad_item_conf { 123item : int; } conf4cpp-0.0.6/test/compile_error/lengthmismatch.conf.1.def0000644000076400007640000000013211120440634023530 0ustar hattorihattoriconfig length_mismatch_conf { optional vector_val : list[3] = { true, true }; } conf4cpp-0.0.6/test/compile_error/invalidrange.conf.4.def0000644000076400007640000000006511110014577023176 0ustar hattorihattoriconfig invalid_range_conf { foo : uint[-100~]; } conf4cpp-0.0.6/test/compile_error/outofrange.conf.1.def0000644000076400007640000000007111120226346022676 0ustar hattorihattoriconfig out_of_range_conf { foo : uint[0~10] = 100; } conf4cpp-0.0.6/test/compile_error/redefined.conf.4.def0000644000076400007640000000006111100615663022456 0ustar hattorihattoriconfig redefined_conf { redefined_conf : int; } conf4cpp-0.0.6/test/compile_error/redefined.conf.6.def0000644000076400007640000000002211100615663022455 0ustar hattorihattoriconfig config { } conf4cpp-0.0.6/test/compile_error/illegaldate.conf.def0000644000076400007640000000007311120226346022637 0ustar hattorihattoriconfig illegal_date_conf { dateval : time = 2004/13/32; } conf4cpp-0.0.6/test/compile_error/typemismatch.conf.3.def0000644000076400007640000000011611120226346023236 0ustar hattorihattoriconfig type_mismatch_conf { enum foo_t { FOO, BAR, BAZ } foo : int = FOO; } conf4cpp-0.0.6/test/compile_error/typemismatch.conf.7.def0000644000076400007640000000006711120226346023247 0ustar hattorihattoriconfig type_mismatch_conf { foo : int = 2147483648; } conf4cpp-0.0.6/test/compile_error/illegaladdr.conf.def0000644000076400007640000000010411120226346022627 0ustar hattorihattoriconfig illegal_addr_conf { ipv4val : ipv4addr = 256.256.256.256; } conf4cpp-0.0.6/test/compile_error/typemismatch.conf.4.def0000644000076400007640000000012311120226346023235 0ustar hattorihattoriconfig type_mismatch_conf { enum foo_t { FOO, BAR, BAZ } foo : foo_t = "hoge"; } conf4cpp-0.0.6/test/compile_error/invalidrange.conf.6.def0000644000076400007640000000007711110014577023203 0ustar hattorihattoriconfig invalid_range_conf { foo : real[-100.34~-100.35]; } conf4cpp-0.0.6/test/compile_error/invalidrange.conf.3.def0000644000076400007640000000007111110014577023172 0ustar hattorihattoriconfig invalid_range_conf { foo : int[-100~100.5]; } conf4cpp-0.0.6/test/compile_error/typemismatch.conf.10.def0000644000076400007640000000006011121177122023310 0ustar hattorihattoriconfig type_mismatch_conf { foo : int = 1,4; } conf4cpp-0.0.6/test/compile_error/invalidrange.conf.5.def0000644000076400007640000000006711110014577023201 0ustar hattorihattoriconfig invalid_range_conf { foo : real[-100~10]; } conf4cpp-0.0.6/test/compile_error/typemismatch.conf.9.def0000644000076400007640000000007711120226346023252 0ustar hattorihattoriconfig type_mismatch_conf { ipv4val : ipv4addr = 1:3:4:5::; } conf4cpp-0.0.6/test/compile_error/typemismatch.conf.8.def0000644000076400007640000000006711120226346023250 0ustar hattorihattoriconfig type_mismatch_conf { foo : int = 0xdeadbeef; } conf4cpp-0.0.6/test/compile_error/empty.conf.def0000644000076400007640000000000011100770172021513 0ustar hattorihattoriconf4cpp-0.0.6/test/compile_error/invalidrange.conf.2.def0000644000076400007640000000006611110014577023175 0ustar hattorihattoriconfig invalid_range_conf { foo : int[100~-10]; } conf4cpp-0.0.6/test/compile_error/lengthmismatch.conf.2.def0000644000076400007640000000012311120440634023531 0ustar hattorihattoriconfig length_mismatch_conf { optional vector_val : list[0] = { 3, 4 }; } conf4cpp-0.0.6/test/compile_error/invalidrange.conf.1.def0000644000076400007640000000006611110014577023174 0ustar hattorihattoriconfig invalid_range_conf { optional foo : int[~]; } conf4cpp-0.0.6/test/compile_error/redefined.conf.7.def0000644000076400007640000000004611100615663022464 0ustar hattorihattoriconfig redefined_conf { int : int; } conf4cpp-0.0.6/test/compile_error/typemismatch.conf.1.def0000644000076400007640000000006311120226346023235 0ustar hattorihattoriconfig type_mismatch_conf { foo : int = "hoge"; } conf4cpp-0.0.6/test/conf_no_items/0000755000076400007640000000000011121200453016735 5ustar hattorihattoriconf4cpp-0.0.6/test/conf_no_items/Makefile0000644000076400007640000000067111074107245020415 0ustar hattorihattoriTARGET = 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.6/test/conf_no_items/no_items.conf0000644000076400007640000000000011074107245021423 0ustar hattorihattoriconf4cpp-0.0.6/test/conf_no_items/no_items.conf.def0000644000076400007640000000003111074107245022164 0ustar hattorihattoriconfig conf_no_items { } conf4cpp-0.0.6/test/conf_no_items/conf_no_items.cpp0000644000076400007640000000033611074107245022301 0ustar hattorihattori#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.6/sample/0000755000076400007640000000000011121200453014415 5ustar hattorihattoriconf4cpp-0.0.6/sample/Makefile0000644000076400007640000000064311073673122016075 0ustar hattorihattoriTARGET = 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.6/sample/sample.conf0000644000076400007640000000210611073375267016572 0ustar hattorihattori#はコメント 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.6/sample/sample.conf.def0000644000076400007640000000134211121177362017316 0ustar hattorihattoriconfig 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.6/sample/sample.cpp0000644000076400007640000000033411073673122016417 0ustar hattorihattori#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.6/inc/0000755000076400007640000000000011121200453013705 5ustar hattorihattoriconf4cpp-0.0.6/inc/conf4cpp/0000755000076400007640000000000011121200454015422 5ustar hattorihattoriconf4cpp-0.0.6/inc/conf4cpp/parser.hpp0000644000076400007640000000520711121170437017442 0ustar hattorihattori/*============================================================================= * * 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 { template struct base_config_parser : public grammar > { static bool item_redefined(set& ss, const string& key) { if (ss.find(key) != ss.end()) return true; ss.insert(key); return false; } template struct definition { rule config_r, item_r; typename derived_T::keywords keywords_p; typename derived_T::constvals constvals_p; value_parser value_p; definition(base_config_parser const& self) : value_p(constvals_p) { assertion item_redefined_e("item redefined"); assertion type_mismatch_e("type mismatch"); assertion out_of_range_e("out of range"); using phoenix::arg1; using phoenix::construct_; using phoenix::var; using phoenix::bind; config_r = !item_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)) >> '=' >> value_p[var(value_p.val)=bind(&normalize)(var(self.timap),var(self.current_keywd),var(value_p.val))] [insert_at_a(self.vmap,self.current_keywd,value_p.val)] >> type_mismatch_e(eps_p(bind(&type_mismatch)(var(self.timap),var(self.vmap),var(self.current_keywd))==false)) >> out_of_range_e(eps_p(bind(&out_of_range)(var(self.timap),var(self.vmap),var(self.current_keywd))==false)); } 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; void init() { vmap.clear(); defined_symbols.clear(); } }; } #endif /* PARSER_HPP */ conf4cpp-0.0.6/inc/conf4cpp/type.hpp0000644000076400007640000001733211121170437017131 0ustar hattorihattori/*============================================================================= * * 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 atomic_t { TI_BOOL, TI_INT, TI_UINT, TI_DOUBLE, TI_STRING, TI_TIME, TI_IPV4ADDR, TI_IPV6ADDR, }; struct ti_atomic_t { ti_atomic_t() : t(TI_BOOL) {} ti_atomic_t(atomic_t t_) : t(t_) {} ti_atomic_t(atomic_t t_, pair c_) : t(t_), c(c_) {} operator atomic_t() const { return t; } atomic_t t; boost::optional >c; }; 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 }; const int VAR_VECTOR = -1; typedef pair ti_vect_t; typedef vector ti_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); } inline ti_atomic_t get_atom(const type_t& typ) { return boost::get(typ); } // // 必要に応じて，uint型の値をint型に正規化する // class var_normalizer : public boost::static_visitor { public: var_normalizer(const var_t& v) : v_(v) {} var_t operator() (ti_atomic_t ta) const { if (ta == TI_INT && is_uint(v_) && boost::get(v_) <= INT_MAX) { return int(boost::get(v_)); } return v_; } var_t operator() (ti_enum_t te) const { return v_; } var_t operator() (ti_vect_t tp) const { if (!is_vector(v_)) return v_; vector vec = boost::get >(v_); vector result; for (unsigned int i = 0; i < vec.size(); i++) { result.push_back(apply_visitor(var_normalizer(vec[i]), tp.second)); } return result; } var_t operator() (ti_tuple_t tv) const { if (!is_vector(v_)) return v_; vector vec = boost::get >(v_); if (vec.size() != tv.size()) return v_; vector result; for (unsigned int i = 0; i < tv.size(); i++) { result.push_back(apply_visitor(var_normalizer(vec[i]), tv[i])); } return result; } private: var_t v_; }; 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_)) 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 = boost::get >(v_); if (p.first != te.eid) return false; return true; } bool operator() (ti_vect_t tp) const { if (!is_vector(v_)) return false; vector vec = boost::get >(v_); if (tp.first >= 0 && tp.first != static_cast(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() (ti_tuple_t tv) const { if (!is_vector(v_)) return false; vector vec = boost::get >(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_; }; class range_checker : public boost::static_visitor { public: range_checker(const var_t& v) : v_(v) {} bool operator() (ti_atomic_t ta) const { if (!ta.c) return true; switch (ta) { case TI_BOOL: return true; case TI_INT: assert(is_int(v_)); return (is_bool(ta.c->first) || boost::get(ta.c->first) <= boost::get(v_)) && (is_bool(ta.c->second) || boost::get(ta.c->second) >= boost::get(v_)); case TI_UINT: assert(is_uint(v_)); return (is_bool(ta.c->first) || boost::get(ta.c->first) <= boost::get(v_)) && (is_bool(ta.c->second) || boost::get(ta.c->second) >= boost::get(v_)); case TI_DOUBLE: assert(is_double(v_)); return (is_bool(ta.c->first) || boost::get(ta.c->first) <= boost::get(v_)) && (is_bool(ta.c->second) || boost::get(ta.c->second) >= boost::get(v_)); case TI_STRING: return true; case TI_TIME: return true; case TI_IPV4ADDR: return true; case TI_IPV6ADDR: return true; default: assert(false); } return false; } bool operator() (ti_enum_t te) const { return true; } bool operator() (ti_vect_t tp) const { vector vec = boost::get >(v_); if (tp.first >= 0 && tp.first != static_cast(vec.size())) return false; for (unsigned int i = 0; i < vec.size(); i++) { if (!apply_visitor(range_checker(vec[i]), tp.second)) return false; } return true; } bool operator() (ti_tuple_t tv) const { vector vec = boost::get >(v_); for (unsigned int i = 0; i < tv.size(); i++) { if (!apply_visitor(range_checker(vec[i]), tv[i])) return false; } return true; } private: var_t v_; }; typedef map tyinfo_map_t; typedef map value_map_t; static var_t normalize(tyinfo_map_t& tm, const string& key, const var_t& v) { vector vec = boost::get >(v); type_t typ = tm[key]; // {{a,b,c}}や{{a}}, {{}}のケースか，primitive型で{a}などのケース if (vec.size() == 1 && (is_prim_type(typ) || is_vector(vec[0]))) { return apply_visitor(var_normalizer(vec[0]), typ); } // {a}, {a,b,c}, {{a},{b}}のケース return apply_visitor(var_normalizer(v), typ); } static bool type_mismatch(tyinfo_map_t& tm, value_map_t& vm, const string& key) { return !apply_visitor(type_checker(vm[key]), tm[key]); } static bool out_of_range(tyinfo_map_t& tm, value_map_t& vm, const string& key) { return !apply_visitor(range_checker(vm[key]), tm[key]); } } #endif /* TYPE_HPP */ conf4cpp-0.0.6/inc/conf4cpp/version.hpp0000644000076400007640000000054411113674006017634 0ustar hattorihattori/*============================================================================= * * conf4cpp : Configuration file library for C++. * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef VERSION_HPP #define VERSION_HPP #define CONF4CPP_VERSION "0.0.6" #endif /* VERSION_HPP */ conf4cpp-0.0.6/inc/conf4cpp/config.hpp0000644000076400007640000000350211111421261017400 0ustar hattorihattori/*============================================================================= * * 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) { p = new derived_config_parser_T(); parse_config(fname); } virtual ~base_config(); bool set(const string& itemdef); protected: derived_config_parser_T* p; private: void parse_config(const string& fname) { 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 { p->init(); parse_info pinfo = parse(begin, end, *p, 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 < p->reqs.size(); i++) { if (p->vmap.find(p->reqs[i]) == p->vmap.end()) throw error("item undefined", p->reqs[i]); } } bool parse_itemdef(const string& itemdef) { try { p->init(); parse_info<> pinfo = parse(itemdef.c_str(), *p, eol_p|space_p); if (!pinfo.full) return false; } catch (boost::spirit::parser_error& e) { return false; } return true; } }; } #endif /* CONFIG_HPP */ conf4cpp-0.0.6/inc/conf4cpp/error.hpp0000644000076400007640000000147311106211660017275 0ustar hattorihattori/*============================================================================= * * 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.6/inc/conf4cpp/var.hpp0000644000076400007640000002444611120442257016745 0ustar hattorihattori/*============================================================================= * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef VAR_HPP #define VAR_HPP #include #include #include #include #include #include #include #include #include #include using namespace std; using boost::spirit::nil_t; namespace conf4cpp { typedef boost::make_recursive_variant< nil_t, bool, int, unsigned int, double, string, struct tm, struct in_addr, struct in6_addr, pair, // enum type vector // list or vector type >::type var_t; enum type_id_t { IS_NIL, IS_BOOL, IS_INT, IS_UINT, IS_DOUBLE, IS_STRING, IS_TIME, IS_IPV4ADDR, IS_IPV6ADDR, IS_PAIR, IS_VECTOR, }; //　バリアント型のトレイツ定義（型と型IDの対応を定義） template struct vtype_traits { }; template <> struct vtype_traits { typedef nil_t variant_type; static type_id_t type_id() { return IS_NIL; } }; template <> struct vtype_traits { typedef bool variant_type; static type_id_t type_id() { return IS_BOOL; } }; template <> struct vtype_traits { typedef int variant_type; static type_id_t type_id() { return IS_INT; } }; template <> struct vtype_traits { typedef unsigned int variant_type; static type_id_t type_id() { return IS_UINT; } }; template <> struct vtype_traits { typedef double variant_type; static type_id_t type_id() { return IS_DOUBLE; } }; template <> struct vtype_traits { typedef string variant_type; static type_id_t type_id() { return IS_STRING; } }; template <> struct vtype_traits { typedef struct tm variant_type; static type_id_t type_id() { return IS_TIME; } }; template <> struct vtype_traits { typedef struct in_addr variant_type; static type_id_t type_id() { return IS_IPV4ADDR; } }; template <> struct vtype_traits { typedef struct in6_addr variant_type; static type_id_t type_id() { return IS_IPV6ADDR; } }; template <> struct vtype_traits > { typedef pair variant_type; static type_id_t type_id() { return IS_PAIR; } }; template <> struct vtype_traits > { typedef vector variant_type; static type_id_t type_id() { return IS_VECTOR; } }; // バリアント型の判定関数定義 template bool is_(const var_t& v) { return v.which() == vtype_traits::type_id(); } inline bool is_nil (const var_t& v) { return is_(v); } inline bool is_bool (const var_t& v) { return is_(v); } inline bool is_int (const var_t& v) { return is_(v); } inline bool is_uint (const var_t& v) { return is_(v); } inline bool is_double (const var_t& v) { return is_(v); } inline bool is_string (const var_t& v) { return is_(v); } inline bool is_time (const var_t& v) { return is_(v); } inline bool is_ipv4addr (const var_t& v) { return is_(v); } inline bool is_ipv6addr (const var_t& v) { return is_(v); } inline bool is_pair (const var_t& v) { return is_ >(v); } inline bool is_vector (const var_t& v) { return is_ >(v); } inline string to_str(const var_t& v) { switch(v.which()) { case IS_BOOL: return boost::get(v) ? "true" : "false"; case IS_INT: return "(int)" + boost::lexical_cast(boost::get(v)); case IS_UINT: return "(unsigned int)" + boost::lexical_cast(boost::get(v)); case IS_DOUBLE: return "(double)" + boost::lexical_cast(boost::get(v)); case IS_STRING: return "\"" + boost::get(v) + "\""; case IS_TIME: case IS_IPV4ADDR: case IS_IPV6ADDR: case IS_PAIR: case IS_VECTOR: case IS_NIL: assert(false); } return "???"; } 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; }; typedef symbols > enum_sym_t; struct variant_val : closure { member1 val; }; struct value_parser : public grammar { static var_t add_value(var_t& v1, const var_t& v2) { vector v = boost::get >(v1); v.push_back(v2); return v; } value_parser(const enum_sym_t& constvals) : constvals_p(constvals) {} value_parser() {} template struct definition { typedef rule rule_t; rule_t top; rule values_r, atomic_value_r; datetime_parser datetime_r; ipv4addr_parser ipv4addr_r; ipv6addr_parser ipv6addr_r; definition(value_parser const& self) { top = values_r[var(self.val)=arg1]; 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 = lexeme_d[((str_p("0x")|"0X") >> hex_p[atomic_value_r.val=arg1])] | datetime_r[atomic_value_r.val=var(datetime_r.val)] | ipv4addr_r[atomic_value_r.val=var(ipv4addr_r.val)] | ipv6addr_r[atomic_value_r.val=var(ipv6addr_r.val)] | strict_real_p[atomic_value_r.val=arg1] | uint_p[atomic_value_r.val=arg1] | int_p[atomic_value_r.val=arg1] | str_p("true")[atomic_value_r.val=true] | str_p("false")[atomic_value_r.val=false] | confix_p('"', (*c_escape_ch_p)[atomic_value_r.val=construct_(arg1,arg2)], '"') | ch_p('{')[atomic_value_r.val=construct_ >()] >> !values_r[atomic_value_r.val=arg1] >> '}' | self.constvals_p[atomic_value_r.val=arg1]; } rule_t const& start() const { return top; } }; mutable var_t val; mutable enum_sym_t constvals_p; }; } #endif /* VAR_HPP */ conf4cpp-0.0.6/inc/conf4cpp.hpp0000644000076400007640000000104211103752523016141 0ustar hattorihattori/*============================================================================= * * 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.6/README0000644000076400007640000000443111074117775014043 0ustar hattorihattori******************************************************************************* [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$