void colvarparse::add_keyword(char const *key) { for (std::list<std::string>::iterator ki = allowed_keywords.begin(); ki != allowed_keywords.end(); ki++) { if (to_lower_cppstr(std::string(key)) == *ki) return; } // not found in the list // if (cvm::debug()) // cvm::log("Registering a new keyword, \""+std::string (key)+"\".\n"); allowed_keywords.push_back(to_lower_cppstr(std::string(key))); }
void colvarparse::mark_key_set_default(std::string const &key_str, TYPE const &def_value, Parse_Mode const &parse_mode) { key_set_modes[to_lower_cppstr(key_str)] = key_set_default; if (parse_mode & parse_echo_default) { cvm::log("# "+key_str+" = "+cvm::to_str(def_value)+ " [default]\n", cvm::log_default_params()); } }
void colvarparse::mark_key_set_user(std::string const &key_str, TYPE const &value, Parse_Mode const &parse_mode) { key_set_modes[to_lower_cppstr(key_str)] = key_set_user; if (parse_mode & parse_echo) { cvm::log("# "+key_str+" = "+cvm::to_str(value)+"\n", cvm::log_user_params()); } }
int colvarparse::check_keywords(std::string &conf, char const *key) { if (cvm::debug()) cvm::log("Configuration string for \""+std::string(key)+ "\": \"\n"+conf+"\".\n"); strip_values(conf); // after stripping, the config string has either empty lines, or // lines beginning with a keyword std::string line; std::istringstream is(conf); while (std::getline(is, line)) { if (line.size() == 0) continue; if (line.find_first_not_of(white_space) == std::string::npos) continue; std::string uk; std::istringstream line_is(line); line_is >> uk; // if (cvm::debug()) // cvm::log ("Checking the validity of \""+uk+"\" from line:\n" + line); uk = to_lower_cppstr(uk); bool found_keyword = false; for (std::list<std::string>::iterator ki = allowed_keywords.begin(); ki != allowed_keywords.end(); ki++) { if (uk == *ki) { found_keyword = true; break; } } if (!found_keyword) { cvm::log("Error: keyword \""+uk+"\" is not supported, " "or not recognized in this context.\n"); cvm::set_error_bits(INPUT_ERROR); return COLVARS_ERROR; } } clear_keyword_registry(); return COLVARS_OK; }
bool colvarparse::key_lookup(std::string const &conf, char const *key_in, std::string &data, size_t &save_pos) { // add this keyword to the register (in its camelCase version) add_keyword(key_in); // use the lowercase version from now on std::string const key(to_lower_cppstr(key_in)); // "conf_lower" is only used to lookup the keyword, but its value // will be read from "conf", in order not to mess up file names std::string const conf_lower(to_lower_cppstr(conf)); // by default, there is no value, unless we found one data = ""; // when the function is invoked without save_pos, ensure that we // start from zero colvarparse::dummy_pos = 0; // start from the first occurrence of key size_t pos = conf_lower.find(key, save_pos); // iterate over all instances until it finds the isolated keyword while (true) { if (pos == std::string::npos) { // no valid instance of the keyword has been found return false; } bool b_isolated_left = true, b_isolated_right = true; if (pos > 0) { if ( std::string("\n"+white_space+ "}").find(conf[pos-1]) == std::string::npos ) { // none of the valid delimiting characters is on the left of key b_isolated_left = false; } } if (pos < conf.size()-key.size()-1) { if ( std::string("\n"+white_space+ "{").find(conf[pos+key.size()]) == std::string::npos ) { // none of the valid delimiting characters is on the right of key b_isolated_right = false; } } // check that there are matching braces between here and the end of conf bool const b_not_within_block = brace_check(conf, pos); bool const b_isolated = (b_isolated_left && b_isolated_right && b_not_within_block); if (b_isolated) { // found it break; } else { // try the next occurrence of key pos = conf_lower.find(key, pos+key.size()); } } // save the pointer for a future call (when iterating over multiple // valid instances of the same keyword) save_pos = pos + key.size(); // get the remainder of the line size_t pl = conf.rfind("\n", pos); size_t line_begin = (pl == std::string::npos) ? 0 : pos; size_t nl = conf.find("\n", pos); size_t line_end = (nl == std::string::npos) ? conf.size() : nl; std::string line(conf, line_begin, (line_end-line_begin)); size_t data_begin = (to_lower_cppstr(line)).find(key) + key.size(); data_begin = line.find_first_not_of(white_space, data_begin+1); // size_t data_begin_absolute = data_begin + line_begin; // size_t data_end_absolute = data_begin; if (data_begin != std::string::npos) { size_t data_end = line.find_last_not_of(white_space) + 1; data_end = (data_end == std::string::npos) ? line.size() : data_end; // data_end_absolute = data_end + line_begin; if (line.find('{', data_begin) != std::string::npos) { size_t brace_count = 1; size_t brace = line.find('{', data_begin); // start from the first opening brace while (brace_count > 0) { // find the matching closing brace brace = line.find_first_of("{}", brace+1); while (brace == std::string::npos) { // add a new line if (line_end >= conf.size()) { cvm::fatal_error("Parse error: reached the end while " "looking for closing brace; until now " "the following was parsed: \"\n"+ line+"\".\n"); return false; } size_t const old_end = line.size(); // data_end_absolute += old_end+1; line_begin = line_end; nl = conf.find('\n', line_begin+1); if (nl == std::string::npos) line_end = conf.size(); else line_end = nl; line.append(conf, line_begin, (line_end-line_begin)); brace = line.find_first_of("{}", old_end); } if (line[brace] == '{') brace_count++; if (line[brace] == '}') brace_count--; } // set data_begin after the opening brace data_begin = line.find_first_of('{', data_begin) + 1; data_begin = line.find_first_not_of(white_space, data_begin); // set data_end before the closing brace data_end = brace; data_end = line.find_last_not_of(white_space+"}", data_end) + 1; // data_end_absolute = line_end; if (data_end > line.size()) data_end = line.size(); } data.append(line, data_begin, (data_end-data_begin)); if (data.size() && save_delimiters) { data_begin_pos.push_back(conf.find(data, pos+key.size())); data_end_pos.push_back(data_begin_pos.back()+data.size()); // std::cerr << "key = " << key << ", data = \"" // << data << "\", data_begin, data_end = " // << data_begin_pos.back() << ", " << data_end_pos.back() // << "\n"; } } save_pos = line_end; return true; }