conf4cpp-0.0.7/0000755000076400007640000000000011124355430013146 5ustar hattorihattoriconf4cpp-0.0.7/Makefile0000644000076400007640000000036211074643517014621 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.7/src/0000755000076400007640000000000011124355430013735 5ustar hattorihattoriconf4cpp-0.0.7/src/conf4cpp.cpp0000644000076400007640000001020111111272623016145 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.7/src/confdef_g.hpp0000644000076400007640000003534611123205535016372 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_TYPENAME, SYM_ENUM, SYM_ELEM, SYM_ITEM }; struct sym_s : symbols > { sym_s() { add ("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: // normalize to double if (is_uint(atyp.c->first)) atyp.c->first = double(boost::get(atyp.c->first)); else if (is_int(atyp.c->first)) atyp.c->first = double(boost::get(atyp.c->first)); if (is_uint(atyp.c->second)) atyp.c->second = double(boost::get(atyp.c->second)); else if (is_int(atyp.c->second)) atyp.c->second = double(boost::get(atyp.c->second)); 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, confname_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 conf_sym, newitem_sym, newenum_sym, newelem_sym; value_parser value_p; symbols<> rsvwd_s; 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_; rsvwd_s = "config", "enum", "required", "optional", "const", "mutable", "true", "false", "bool", "real", "int", "uint", "string", "time", "ipv4addr", "ipv6addr", "list", // C++ reserved words "asm", /*bool*/ "break", "case", "catch", "char", "class", /*const*/ "const_cast", "continue", "default", "delete", "do", /*double*/ "dynamic_cast", "else", /*enum*/ "explicit", "export", "extern", /*false*/ "float", "for", "friend", "goto", "if", "inline", /*int*/ "long", /*mutable*/ "namespace", "new", "operator", "private", "protected", "public", "register", "reinterpret_cast", "return", "short", "signed", "sizeof", "static", "static_cast", "struct", "switch", "template", "this", "throw", /*true*/ "try", "typedef", "typeid", "typename", "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t", "while" ; // // ::= { config ::{ * } // ::= | // ::= ? ? ; // ::= enum { (, )* } // ::= required | optional // config_r = lexeme_d[str_p("config") >> blank_p] >> confname_r >> '{' >> *spec_r >> '}' >> end_p; confname_r = conf_sym[push_front_a(self.conf_name)] >> *( lexeme_d[str_p("::")] >> conf_sym[push_front_a(self.conf_name)] ); 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|'_')] - rsvwd_s ) | ( rsvwd_s >> rsvwd_redef_e(nothing_p) ); new_sym = (id_r - sym_p) | ( sym_p[var(self.cur_type)=arg1] >> ( ( eps_p(var(self.cur_type.first)==SYM_TYPENAME) >> typnm_redef_e(nothing_p) ) | symbol_redef_e(nothing_p) ) ); conf_sym = id_r[conf_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 deque conf_name; }; #endif /* CONFDEF_HPP */ conf4cpp-0.0.7/src/Makefile0000644000076400007640000000105611117242740015400 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.7/src/confgen.hpp0000644000076400007640000000470511124352772016101 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[0]), namespace_(++g.conf_name.begin(), g.conf_name.end()), 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_namespace_begin(ostream& os); void output_namespace_end(ostream& os); string get_namespace_qualifier(); 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 vector namespace_; 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.7/src/confgen.cpp0000644000076400007640000010444111124352772016072 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 += lhs + ".clear();\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; } 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 << "namespace conf4cpp { struct " << conf_name_ << "_parser; }" << endl; output_namespace_begin(os); os << "class " << conf_name_ << " : public conf4cpp::base_config" << 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; output_namespace_end(os); } 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) { // namespace conf4cpp os << "namespace conf4cpp {" << endl; 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 << "\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; // user defined namespace output_namespace_begin(os); os << "using namespace conf4cpp;" << endl; os << "using boost::make_tuple;" << 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); output_namespace_end(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 << "\"), " << get_namespace_qualifier() << 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 << "// 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; } void confgen::output_namespace_begin(ostream& os) { for (vector::const_reverse_iterator iter = namespace_.rbegin(); iter != namespace_.rend(); ++iter) { os << "namespace " << *iter << " { "; } os << endl; } void confgen::output_namespace_end(ostream& os) { for (vector::const_reverse_iterator iter = namespace_.rbegin(); iter != namespace_.rend(); ++iter) { os << "} /*" << *iter << "*/ "; } os << endl; } string confgen::get_namespace_qualifier() { string ret; for (vector::const_reverse_iterator iter = namespace_.rbegin(); iter != namespace_.rend(); ++iter) { ret += *iter + "::"; } return ret; } conf4cpp-0.0.7/ChangeLog0000644000076400007640000000471311124355177014735 0ustar hattorihattori2008-12-24 Kenta HATTORI * conf4cpp-0.0.7リリース * C++の予約語の使用チェックを追加 * リスト型設定項目に対するset()操作のバグを修正 2008-12-20 Kenta HATTORI * 名前空間をサポート * uintからdouble, intからdoubleへの暗黙の型変換を追加 2008-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.7/test/0000755000076400007640000000000011124355430014125 5ustar hattorihattoriconf4cpp-0.0.7/test/test.conf0000644000076400007640000000170711121170437015757 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.7/test/Makefile0000644000076400007640000000065211111313350015557 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.7/test/compile_guard/0000755000076400007640000000000011124355430016737 5ustar hattorihattoriconf4cpp-0.0.7/test/compile_guard/Makefile0000644000076400007640000000070111121176471020400 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.7/test/compile_guard/compile_guard.conf.def0000644000076400007640000000010011121176471023147 0ustar hattorihattoriconfig compile_guard_conf { foo : int; bar : string; } conf4cpp-0.0.7/test/compile_guard/compile_guard.cpp0000644000076400007640000000055411121176471022264 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.7/test/test.conf.def0000644000076400007640000000532611124352772016524 0ustar hattorihattoriconfig test::inner_test::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.7/test/config_error/0000755000076400007640000000000011124355430016603 5ustar hattorihattoriconf4cpp-0.0.7/test/config_error/invaliddate.4.conf0000644000076400007640000000005011103731067022074 0ustar hattorihattorireq_int_val = 0; date_val = 2009/12/32; conf4cpp-0.0.7/test/config_error/outofrange.2.conf0000644000076400007640000000004411111007723021754 0ustar hattorihattorireq_int_val = 10; intran_val = -11; conf4cpp-0.0.7/test/config_error/parseerror.3.conf0000644000076400007640000000002011103731067021770 0ustar hattorihattoriuint_val = 0 #; conf4cpp-0.0.7/test/config_error/Makefile0000644000076400007640000000066511103731067020253 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.7/test/config_error/invaliddate.6.conf0000644000076400007640000000006011103731067022077 0ustar hattorihattorireq_int_val = 0; date_val = 2009/12/31 23:69:30;conf4cpp-0.0.7/test/config_error/typemismatch.6.conf0000644000076400007640000000004311103731067022323 0ustar hattorihattorireq_int_val = 0; week_val = Apple; conf4cpp-0.0.7/test/config_error/invalidipaddr.6.conf0000644000076400007640000000005011103731067022424 0ustar hattorihattorireq_int_val = 0; ipv6_val = 1::2::3::4; conf4cpp-0.0.7/test/config_error/invalidipaddr.5.conf0000644000076400007640000000005711103731067022432 0ustar hattorihattorireq_int_val = 0; ipv6_val = ::1:2:3:4:5:6:7:8; conf4cpp-0.0.7/test/config_error/typemismatch.7.conf0000644000076400007640000000004611103731067022327 0ustar hattorihattorireq_int_val = 0; fruit_val = "Apple"; conf4cpp-0.0.7/test/config_error/outofrange.1.conf0000644000076400007640000000004311111007723021752 0ustar hattorihattorireq_int_val = 10; intran_val = 11; conf4cpp-0.0.7/test/config_error/unclosedstr.conf0000644000076400007640000000006611103731067022022 0ustar hattorihattorireq_int_val = 0; string_val = "hogehoge; uint_val = 5;conf4cpp-0.0.7/test/config_error/outofrange.4.conf0000644000076400007640000000004711111007723021761 0ustar hattorihattorireq_int_val = 10; realran_val = -11.0; conf4cpp-0.0.7/test/config_error/typemismatch.5.conf0000644000076400007640000000004411124352772022330 0ustar hattorihattorireq_int_val = 0; real_val = -3,2.5; conf4cpp-0.0.7/test/config_error/typemismatch.14.conf0000644000076400007640000000007111103731067022403 0ustar hattorihattorireq_int_val = 0; fruitsreal_val = {Apple,Banana},Orange; conf4cpp-0.0.7/test/config_error/typemismatch.3.conf0000644000076400007640000000005011103731067022316 0ustar hattorihattorireq_int_val = 3; bool_val = false,true; conf4cpp-0.0.7/test/config_error/invaliddate.2.conf0000644000076400007640000000004611103731067022077 0ustar hattorihattorireq_int_val = 0; date_val = 2009/13/3;conf4cpp-0.0.7/test/config_error/parseerror.2.conf0000644000076400007640000000001711103731067021775 0ustar hattorihattoriuint _val = 0; conf4cpp-0.0.7/test/config_error/conf_error.sh0000644000076400007640000000104111121170437021270 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.7/test/config_error/typemismatch.11.conf0000644000076400007640000000005311103731067022400 0ustar hattorihattorireq_int_val = 0; ipv4net_val = 1.2.3.4,-3; conf4cpp-0.0.7/test/config_error/emptyfile.conf0000644000076400007640000000000011103731067021437 0ustar hattorihattoriconf4cpp-0.0.7/test/config_error/typemismatch.1.conf0000644000076400007640000000002511103731067022316 0ustar hattorihattorireq_int_val = "foo"; conf4cpp-0.0.7/test/config_error/typemismatch.4.conf0000644000076400007640000000004311103731067022321 0ustar hattorihattorireq_int_val = 3; string_val = MON; conf4cpp-0.0.7/test/config_error/invalidipaddr.3.conf0000644000076400007640000000006311103731067022425 0ustar hattorihattorireq_int_val = 0; ipv6_val = 1:2:3:4:5:6:7::8:9:10; conf4cpp-0.0.7/test/config_error/conf_error.cpp0000644000076400007640000000047111103731067021450 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.7/test/config_error/outofrange.3.conf0000644000076400007640000000004511111007723021756 0ustar hattorihattorireq_int_val = 10; uintran_val = 110; conf4cpp-0.0.7/test/config_error/conf_error.conf.def0000644000076400007640000000141411111007723022340 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.7/test/config_error/typemismatch.15.conf0000644000076400007640000000005211103731067022403 0ustar hattorihattorireq_int_val = 0; weekbi_val = MON,true,3; conf4cpp-0.0.7/test/config_error/parseerror.1.conf0000644000076400007640000000000211103731067021766 0ustar hattorihattori3 conf4cpp-0.0.7/test/config_error/typemismatch.2.conf0000644000076400007640000000004211103731067022316 0ustar hattorihattorireq_int_val = 0; uint_val = -123; conf4cpp-0.0.7/test/config_error/invalidipaddr.4.conf0000644000076400007640000000005711103731067022431 0ustar hattorihattorireq_int_val = 0; ipv6_val = 1:2:3:4:5:6:7:8::; conf4cpp-0.0.7/test/config_error/invaliddate.3.conf0000644000076400007640000000004611103731067022100 0ustar hattorihattorireq_int_val = 0; date_val = 2009/0/30;conf4cpp-0.0.7/test/config_error/redefined.conf0000644000076400007640000000004711103731067021401 0ustar hattorihattorireq_int_val = 123; req_int_val = -322; conf4cpp-0.0.7/test/config_error/invalidipaddr.2.conf0000644000076400007640000000004711103731067022426 0ustar hattorihattorireq_int_val = 0; ipv4_val = 1.2.3.4.5; conf4cpp-0.0.7/test/config_error/typemismatch.10.conf0000644000076400007640000000004511103731067022400 0ustar hattorihattorireq_int_val = 0; ipv6_val = 1.2.3.4; conf4cpp-0.0.7/test/config_error/typemismatch.9.conf0000644000076400007640000000004111103731067022324 0ustar hattorihattorireq_int_val = 0; ipv4_val = ::1; conf4cpp-0.0.7/test/config_error/typemismatch.8.conf0000644000076400007640000000004611103731067022330 0ustar hattorihattorireq_int_val = 0; date_val = 1:2:3::4; conf4cpp-0.0.7/test/config_error/typemismatch.12.conf0000644000076400007640000000004611103731067022403 0ustar hattorihattorireq_int_val = 0; strlist_val = 3,4,5; conf4cpp-0.0.7/test/config_error/invaliddate.5.conf0000644000076400007640000000005711103731067022104 0ustar hattorihattorireq_int_val = 0; date_val = 2009/12/31 25:1:30;conf4cpp-0.0.7/test/config_error/invalidlength.conf0000644000076400007640000000005511103731067022303 0ustar hattorihattorireq_int_val = 0; strlist3_val = "foo","bar"; conf4cpp-0.0.7/test/config_error/invaliddate.1.conf0000644000076400007640000000004511103731067022075 0ustar hattorihattorireq_int_val = 0; date_val = 10:30:10;conf4cpp-0.0.7/test/config_error/undefined.conf0000644000076400007640000000001611103731067021411 0ustar hattorihattoriuint_val = 3; conf4cpp-0.0.7/test/config_error/typemismatch.13.conf0000644000076400007640000000006511103731067022405 0ustar hattorihattorireq_int_val = 0; intbools_val = {3,true},{{3,true}}; conf4cpp-0.0.7/test/config_error/invaliddate.7.conf0000644000076400007640000000006111103731067022101 0ustar hattorihattorireq_int_val = 0; date_val = 2009/12/31 23:59:69; conf4cpp-0.0.7/test/config_error/invalidipaddr.1.conf0000644000076400007640000000004311103731067022421 0ustar hattorihattorireq_int_val = 0; ipv4_val = 0.0.0; conf4cpp-0.0.7/test/test_conf.cpp0000644000076400007640000001603411124352772016627 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::inner_test::test_conf conf(args[1]); assert(conf.int_val()==-123); assert(conf.bool_val()==false); assert(conf.week_val()==test::inner_test::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); vector int1_list_val2; int1_list_val2.push_back(3); assert(conf.set_int1_list(int1_list_val2)==true); assert(conf.int1_list().size()==1); assert(conf.int1_list()[0]==3); assert(conf.set("int1_list={1}")==true); assert(conf.int1_list().size()==1); assert(conf.int1_list()[0]==1); 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::inner_test::test_conf::MON); assert(boost::get<1>(conf.week_fruits()).size()==4); assert(boost::get<1>(conf.week_fruits())[0]==test::inner_test::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.7/test/compile_error/0000755000076400007640000000000011124355430016766 5ustar hattorihattoriconf4cpp-0.0.7/test/compile_error/typemismatch.conf.2.def0000644000076400007640000000010011124333362023230 0ustar hattorihattoriconfig type_mismatch_conf { foo : list[3] = {0,2,3,4}; } conf4cpp-0.0.7/test/compile_error/noelement.conf.def0000644000076400007640000000005211100615663022356 0ustar hattorihattoriconfig redefined_conf { enum foo_t { } } conf4cpp-0.0.7/test/compile_error/redefined.conf.3.def0000644000076400007640000000010211100615663022452 0ustar hattorihattoriconfig redefined_conf { enum foo_t { FOO } enum foo_t { BAR } } conf4cpp-0.0.7/test/compile_error/redefined.conf.1.def0000644000076400007640000000006311100615663022456 0ustar hattorihattoriconfig redefined_conf { foo : int; foo : bool; } conf4cpp-0.0.7/test/compile_error/typemismatch.conf.5.def0000644000076400007640000000013211120226346023237 0ustar hattorihattoriconfig type_mismatch_conf { enum foo_t { FOO } enum bar_t { BAR } foo : foo_t = BAR; } conf4cpp-0.0.7/test/compile_error/redefined.conf.5.def0000644000076400007640000000010411100615663022456 0ustar hattorihattoriconfig redefined_conf { enum foo_t { foo, bar, baz } foo : int; } conf4cpp-0.0.7/test/compile_error/badconfname.conf.def0000644000076400007640000000004011111272606022620 0ustar hattorihattoriconfig 123_conf { foo : int; } conf4cpp-0.0.7/test/compile_error/redefined.conf.2.def0000644000076400007640000000007011100615663022455 0ustar hattorihattoriconfig redefined_conf { enum foo_t { FOO, BAR, FOO } } conf4cpp-0.0.7/test/compile_error/typemismatch.conf.6.def0000644000076400007640000000006411120226346023244 0ustar hattorihattoriconfig type_mismatch_conf { foo : uint_t = -123; } conf4cpp-0.0.7/test/compile_error/compile_error.sh0000644000076400007640000000105111120226346022157 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.7/test/compile_error/baditemname.conf.def0000644000076400007640000000005111111272606022633 0ustar hattorihattoriconfig bad_item_conf { 123item : int; } conf4cpp-0.0.7/test/compile_error/lengthmismatch.conf.1.def0000644000076400007640000000013211120440634023531 0ustar hattorihattoriconfig length_mismatch_conf { optional vector_val : list[3] = { true, true }; } conf4cpp-0.0.7/test/compile_error/invalidrange.conf.4.def0000644000076400007640000000006511110014577023177 0ustar hattorihattoriconfig invalid_range_conf { foo : uint[-100~]; } conf4cpp-0.0.7/test/compile_error/outofrange.conf.1.def0000644000076400007640000000007111120226346022677 0ustar hattorihattoriconfig out_of_range_conf { foo : uint[0~10] = 100; } conf4cpp-0.0.7/test/compile_error/redefined.conf.4.def0000644000076400007640000000005611124333362022462 0ustar hattorihattoriconfig static_cast { redefined_conf : int; } conf4cpp-0.0.7/test/compile_error/redefined.conf.6.def0000644000076400007640000000002211100615663022456 0ustar hattorihattoriconfig config { } conf4cpp-0.0.7/test/compile_error/illegaldate.conf.def0000644000076400007640000000007311120226346022640 0ustar hattorihattoriconfig illegal_date_conf { dateval : time = 2004/13/32; } conf4cpp-0.0.7/test/compile_error/typemismatch.conf.3.def0000644000076400007640000000011611120226346023237 0ustar hattorihattoriconfig type_mismatch_conf { enum foo_t { FOO, BAR, BAZ } foo : int = FOO; } conf4cpp-0.0.7/test/compile_error/typemismatch.conf.7.def0000644000076400007640000000006711120226346023250 0ustar hattorihattoriconfig type_mismatch_conf { foo : int = 2147483648; } conf4cpp-0.0.7/test/compile_error/illegaladdr.conf.def0000644000076400007640000000010411120226346022630 0ustar hattorihattoriconfig illegal_addr_conf { ipv4val : ipv4addr = 256.256.256.256; } conf4cpp-0.0.7/test/compile_error/typemismatch.conf.4.def0000644000076400007640000000012311120226346023236 0ustar hattorihattoriconfig type_mismatch_conf { enum foo_t { FOO, BAR, BAZ } foo : foo_t = "hoge"; } conf4cpp-0.0.7/test/compile_error/invalidrange.conf.3.def0000644000076400007640000000007111110014577023173 0ustar hattorihattoriconfig invalid_range_conf { foo : int[-100~100.5]; } conf4cpp-0.0.7/test/compile_error/typemismatch.conf.10.def0000644000076400007640000000006011121177122023311 0ustar hattorihattoriconfig type_mismatch_conf { foo : int = 1,4; } conf4cpp-0.0.7/test/compile_error/invalidrange.conf.5.def0000644000076400007640000000007711124333143023201 0ustar hattorihattoriconfig invalid_range_conf { foo : real[-100.34~-100.35]; } conf4cpp-0.0.7/test/compile_error/badnamespace.conf.def0000644000076400007640000000004011124352772022775 0ustar hattorihattoriconfig ::bad_namespace_conf { } conf4cpp-0.0.7/test/compile_error/typemismatch.conf.9.def0000644000076400007640000000007711120226346023253 0ustar hattorihattoriconfig type_mismatch_conf { ipv4val : ipv4addr = 1:3:4:5::; } conf4cpp-0.0.7/test/compile_error/typemismatch.conf.8.def0000644000076400007640000000006711120226346023251 0ustar hattorihattoriconfig type_mismatch_conf { foo : int = 0xdeadbeef; } conf4cpp-0.0.7/test/compile_error/empty.conf.def0000644000076400007640000000000011100770172021514 0ustar hattorihattoriconf4cpp-0.0.7/test/compile_error/invalidrange.conf.2.def0000644000076400007640000000006611110014577023176 0ustar hattorihattoriconfig invalid_range_conf { foo : int[100~-10]; } conf4cpp-0.0.7/test/compile_error/lengthmismatch.conf.2.def0000644000076400007640000000012311120440634023532 0ustar hattorihattoriconfig length_mismatch_conf { optional vector_val : list[0] = { 3, 4 }; } conf4cpp-0.0.7/test/compile_error/invalidrange.conf.1.def0000644000076400007640000000006611110014577023175 0ustar hattorihattoriconfig invalid_range_conf { optional foo : int[~]; } conf4cpp-0.0.7/test/compile_error/redefined.conf.7.def0000644000076400007640000000004611100615663022465 0ustar hattorihattoriconfig redefined_conf { int : int; } conf4cpp-0.0.7/test/compile_error/typemismatch.conf.1.def0000644000076400007640000000006311120226346023236 0ustar hattorihattoriconfig type_mismatch_conf { foo : int = "hoge"; } conf4cpp-0.0.7/test/conf_no_items/0000755000076400007640000000000011124355430016747 5ustar hattorihattoriconf4cpp-0.0.7/test/conf_no_items/Makefile0000644000076400007640000000067111074107245020416 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.7/test/conf_no_items/no_items.conf0000644000076400007640000000000011074107245021424 0ustar hattorihattoriconf4cpp-0.0.7/test/conf_no_items/no_items.conf.def0000644000076400007640000000003111074107245022165 0ustar hattorihattoriconfig conf_no_items { } conf4cpp-0.0.7/test/conf_no_items/conf_no_items.cpp0000644000076400007640000000033611074107245022302 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.7/sample/0000755000076400007640000000000011124355430014427 5ustar hattorihattoriconf4cpp-0.0.7/sample/Makefile0000644000076400007640000000064311073673122016076 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.7/sample/sample.conf0000644000076400007640000000210611073375267016573 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.7/sample/sample.conf.def0000644000076400007640000000135211124352772017323 0ustar hattorihattoriconfig sample::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.7/sample/sample.cpp0000644000076400007640000000034411124352772016423 0ustar hattorihattori#include #include "conf.out.hpp" int main(int argc, char* args[]) { if (argc < 2) { cout << "no input file.\n"; return -1; } sample::sample_conf conf(args[1]); conf.dump(cout); return 0; } conf4cpp-0.0.7/inc/0000755000076400007640000000000011124355430013717 5ustar hattorihattoriconf4cpp-0.0.7/inc/conf4cpp/0000755000076400007640000000000011124355430015433 5ustar hattorihattoriconf4cpp-0.0.7/inc/conf4cpp/parser.hpp0000644000076400007640000000520711121170437017443 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.7/inc/conf4cpp/type.hpp0000644000076400007640000001771211123205535017134 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_)); } if (ta == TI_DOUBLE && is_uint(v_)) { return double(boost::get(v_)); } if (ta == TI_DOUBLE && is_int(v_)) { return double(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.7/inc/conf4cpp/version.hpp0000644000076400007640000000054411123205535017633 0ustar hattorihattori/*============================================================================= * * conf4cpp : Configuration file library for C++. * * Copyright (c) 2008- Kenta Hattori * *===========================================================================*/ #ifndef VERSION_HPP #define VERSION_HPP #define CONF4CPP_VERSION "0.0.7" #endif /* VERSION_HPP */ conf4cpp-0.0.7/inc/conf4cpp/config.hpp0000644000076400007640000000350211111421261017401 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.7/inc/conf4cpp/error.hpp0000644000076400007640000000147311106211660017276 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.7/inc/conf4cpp/var.hpp0000644000076400007640000002444611120442257016746 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.7/inc/conf4cpp.hpp0000644000076400007640000000104211103752523016142 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.7/README0000644000076400007640000000443111074117775014044 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$