From ee6eae6c84b95088fa58d4eb38ae56e4150176ec Mon Sep 17 00:00:00 2001 From: rakshasa Date: Sun, 25 Mar 2007 18:03:07 +0000 Subject: [PATCH] * Working on new infrastructure for parseing commands. It now passes a list instead of a string when calling a multi-parameter command, which handles escaped spaces, commas and quotes correctly. git-svn-id: svn://rakshasa.no/libtorrent/trunk/rtorrent@877 e378c898-3ddf-0310-93e7-cc216c733640 --- src/command_scheduler.cc | 22 +-- src/command_scheduler.h | 2 +- src/main.cc | 4 +- src/option_handler_rules.cc | 251 +++++++++++++++------------------- src/utils/Makefile.am | 2 + src/utils/parse.cc | 227 ++++++++++++++++++++++++++++++ src/utils/parse.h | 66 +++++++++ src/utils/variable_generic.cc | 30 ++++ src/utils/variable_generic.h | 30 ++++ src/utils/variable_map.cc | 120 ++++------------ 10 files changed, 506 insertions(+), 248 deletions(-) create mode 100644 src/utils/parse.cc create mode 100644 src/utils/parse.h diff --git a/src/command_scheduler.cc b/src/command_scheduler.cc index 1f0daba0..04e9183d 100644 --- a/src/command_scheduler.cc +++ b/src/command_scheduler.cc @@ -116,21 +116,21 @@ CommandScheduler::call_item(value_type item) { } void -CommandScheduler::parse(const std::string& arg) { - char key[21]; - char bufAbsolute[21]; - char bufInterval[21]; - char command[2048]; +CommandScheduler::parse(const std::string& key, const std::string& bufAbsolute, const std::string& bufInterval, const std::string& command) { +// char key[21]; +// char bufAbsolute[21]; +// char bufInterval[21]; +// char command[2048]; - if (std::sscanf(arg.c_str(), "%20[^,],%20[^,],%20[^,],%2047[^\n]", key, bufAbsolute, bufInterval, command) != 4) - throw torrent::input_error("Invalid arguments to command."); +// if (std::sscanf(arg.c_str(), "%20[^,],%20[^,],%20[^,],%2047[^\n]", key, bufAbsolute, bufInterval, command) != 4) +// throw torrent::input_error("Invalid arguments to command."); - uint32_t absolute = parse_absolute(bufAbsolute); - uint32_t interval = parse_interval(bufInterval); + uint32_t absolute = parse_absolute(bufAbsolute.c_str()); + uint32_t interval = parse_interval(bufInterval.c_str()); - CommandSchedulerItem* item = *insert(rak::trim(std::string(key))); + CommandSchedulerItem* item = *insert(key); - item->set_command(rak::trim(std::string(command))); + item->set_command(command); item->set_interval(interval); item->enable((cachedTime + rak::timer::from_seconds(absolute)).round_seconds()); diff --git a/src/command_scheduler.h b/src/command_scheduler.h index be0ceea0..c72f7c0a 100644 --- a/src/command_scheduler.h +++ b/src/command_scheduler.h @@ -70,7 +70,7 @@ public: void erase(iterator itr); void erase(const std::string& key) { erase(find(key)); } - void parse(const std::string& arg); + void parse(const std::string& key, const std::string& bufAbsolute, const std::string& bufInterval, const std::string& command); static uint32_t parse_absolute(const char* str); static uint32_t parse_interval(const char* str); diff --git a/src/main.cc b/src/main.cc index 0b0cc55b..9057c50a 100644 --- a/src/main.cc +++ b/src/main.cc @@ -212,8 +212,8 @@ main(int argc, char** argv) { "view_sort_new = seeding,state_changed\n" "view_sort_current = seeding,state_changed_reverse\n" - "schedule = view_main,10,10,view_sort=main,20\n" - "schedule = view_name,10,10,view_sort=name,20\n" + "schedule = view_main,10,10,\"view_sort=main,20\"\n" + "schedule = view_name,10,10,\"view_sort=name,20\"\n" // "schedule = view_started,10,10,view_sort=started,5\n" // "schedule = view_stopped,10,10,view_sort=stopped,5\n" // "schedule = view_complete,10,10,view_sort=complete,5\n" diff --git a/src/option_handler_rules.cc b/src/option_handler_rules.cc index 17f16d97..bdcb5a52 100644 --- a/src/option_handler_rules.cc +++ b/src/option_handler_rules.cc @@ -66,6 +66,7 @@ #include "core/view_manager.h" #include "ui/root.h" #include "utils/directory.h" +#include "utils/parse.h" #include "utils/variable_generic.h" #include "utils/variable_map.h" @@ -90,15 +91,8 @@ namespace core { // variables->insert("tracker_dump", new utils::VariableAny(std::string())); // } -void -apply_hash_read_ahead(int arg) { - torrent::set_hash_read_ahead(arg << 20); -} - -void -apply_hash_interval(int arg) { - torrent::set_hash_interval(arg * 1000); -} +void apply_hash_read_ahead(int arg) { torrent::set_hash_read_ahead(arg << 20); } +void apply_hash_interval(int arg) { torrent::set_hash_interval(arg * 1000); } // The arg string *must* have been checked with validate_port_range // first. @@ -111,25 +105,10 @@ apply_port_range(const std::string& arg) { control->core()->set_port_range(a, b); } -void -apply_load(const std::string& arg) { - control->core()->try_create_download_expand(arg, false, false, true); -} - -void -apply_load_verbose(const std::string& arg) { - control->core()->try_create_download_expand(arg, false, true, true); -} - -void -apply_load_start(const std::string& arg) { - control->core()->try_create_download_expand(arg, true, false, true); -} - -void -apply_load_start_verbose(const std::string& arg) { - control->core()->try_create_download_expand(arg, true, true, true); -} +void apply_load(const std::string& arg) { control->core()->try_create_download_expand(arg, false, false, true); } +void apply_load_verbose(const std::string& arg) { control->core()->try_create_download_expand(arg, false, true, true); } +void apply_load_start(const std::string& arg) { control->core()->try_create_download_expand(arg, true, false, true); } +void apply_load_start_verbose(const std::string& arg) { control->core()->try_create_download_expand(arg, true, true, true); } void apply_start_tied() { @@ -200,20 +179,18 @@ apply_close_low_diskspace(int64_t arg) { } void -apply_stop_on_ratio(const std::string& arg) { - int64_t minRatio = 0; // first argument: minimum ratio to reach - int64_t minUpload = 0; // second argument: minimum upload amount to reach [optional] - int64_t maxRatio = 0; // third argument: maximum ratio to reach [optional] +apply_stop_on_ratio(const torrent::Object::list_type& args) { + if (args.empty()) + throw torrent::input_error("Too few arguments."); - rak::split_iterator_t sitr = rak::split_iterator(arg, ','); + torrent::Object::list_type::const_iterator argItr = args.begin(); - utils::Variable::string_to_value_unit(rak::trim(*sitr).c_str(), &minRatio, 0, 1); - - if (++sitr != rak::split_iterator(arg)) - utils::Variable::string_to_value_unit(rak::trim(*sitr).c_str(), &minUpload, 0, 1); - - if (++sitr != rak::split_iterator(arg)) - utils::Variable::string_to_value_unit(rak::trim(*sitr).c_str(), &maxRatio, 0, 1); + // first argument: minimum ratio to reach + // second argument: minimum upload amount to reach [optional] + // third argument: maximum ratio to reach [optional] + int64_t minRatio = utils::convert_to_value(*argItr++); + int64_t minUpload = argItr != args.end() ? utils::convert_to_value(*argItr++) : 0; + int64_t maxRatio = argItr != args.end() ? utils::convert_to_value(*argItr++) : 0; core::Manager::DListItr itr = control->core()->download_list()->begin(); @@ -221,7 +198,8 @@ apply_stop_on_ratio(const std::string& arg) { int64_t totalUpload = (*itr)->download()->up_rate()->total(); int64_t totalDone = (*itr)->download()->bytes_done(); - if ((totalUpload >= minUpload && totalUpload * 100 >= totalDone * minRatio) || (maxRatio > 0 && totalUpload * 100 > totalDone * maxRatio)) { + if ((totalUpload >= minUpload && totalUpload * 100 >= totalDone * minRatio) || + (maxRatio > 0 && totalUpload * 100 > totalDone * maxRatio)) { control->core()->download_list()->stop_try(*itr); (*itr)->set("ignore_commands", (int64_t)1); } @@ -231,19 +209,19 @@ apply_stop_on_ratio(const std::string& arg) { } void -apply_on_state_change(core::DownloadList::slot_map* slotMap, const std::string& arg) { - std::string::const_iterator itr = std::find(arg.begin(), arg.end(), ','); +apply_on_state_change(core::DownloadList::slot_map* slotMap, const torrent::Object::list_type& args) { + if (args.size() != 2) + throw torrent::input_error("Too few arguments."); - std::string key = rak::trim(std::string(arg.begin(), itr)); - std::string value = rak::trim(std::string(itr != arg.end() ? itr + 1 : itr, arg.end())); - - if (key.empty()) + if (args.front().as_string().empty()) throw torrent::input_error("Empty key."); - if (value.empty()) - slotMap->erase("1_start_" + key); + std::string key = "1_state_" + args.front().as_string(); + + if (args.back().as_string().empty()) + slotMap->erase(key); else - (*slotMap)["1_start_" + key] = sigc::bind(sigc::mem_fun(control->download_variables(), &utils::VariableMap::process_d_std_single), value); + (*slotMap)[key] = sigc::bind(sigc::mem_fun(control->download_variables(), &utils::VariableMap::process_d_std_single), args.back().as_string()); } void @@ -252,13 +230,11 @@ apply_encoding_list(const std::string& arg) { } void -apply_encryption(const std::string& arg) { - rak::split_iterator_t sitr = rak::split_iterator(arg, ','); +apply_encryption(const torrent::Object::list_type& args) { uint32_t options_mask = torrent::ConnectionManager::encryption_none; - while (sitr != rak::split_iterator(arg)) { - std::string opt = rak::trim(*sitr); - ++sitr; + for (torrent::Object::list_type::const_iterator itr = args.begin(), last = args.end(); itr != last; itr++) { + const std::string& opt = itr->as_string(); if (opt == "none") options_mask = torrent::ConnectionManager::encryption_none; @@ -282,7 +258,7 @@ apply_encryption(const std::string& arg) { } void -apply_enable_trackers(__UNUSED const std::string& arg) { +apply_enable_trackers(const std::string& arg) { bool state = (arg != "no"); for (core::Manager::DListItr itr = control->core()->download_list()->begin(), last = control->core()->download_list()->end(); itr != last; ++itr) { @@ -327,110 +303,91 @@ apply_tos(const std::string& arg) { } void -apply_view_filter(const std::string& arg) { - rak::split_iterator_t itr = rak::split_iterator(arg, ','); +apply_view_filter(const torrent::Object::list_type& args) { + if (args.size() < 1) + throw torrent::input_error("Too few arguments."); - std::string name = rak::trim(*itr); + const std::string& name = args.front().as_string(); if (name.empty()) throw torrent::input_error("First argument must be a string."); core::ViewManager::filter_args filterArgs; - while (++itr != rak::split_iterator(arg)) { - filterArgs.push_back(rak::trim(*itr)); - - if (filterArgs.back().empty()) - throw torrent::input_error("One of the arguments is empty."); - } + for (torrent::Object::list_type::const_iterator itr = ++args.begin(), last = args.end(); itr != last; itr++) + filterArgs.push_back(itr->as_string()); control->view_manager()->set_filter(name, filterArgs); } void -apply_view_filter_on(const std::string& arg) { - rak::split_iterator_t itr = rak::split_iterator(arg, ','); +apply_view_filter_on(const torrent::Object::list_type& args) { + if (args.size() < 1) + throw torrent::input_error("Too few arguments."); - std::string name = rak::trim(*itr); + const std::string& name = args.front().as_string(); if (name.empty()) throw torrent::input_error("First argument must be a string."); core::ViewManager::filter_args filterArgs; - while (++itr != rak::split_iterator(arg)) { - filterArgs.push_back(rak::trim(*itr)); - - if (filterArgs.back().empty()) - throw torrent::input_error("One of the arguments is empty."); - } + for (torrent::Object::list_type::const_iterator itr = ++args.begin(), last = args.end(); itr != last; itr++) + filterArgs.push_back(itr->as_string()); control->view_manager()->set_filter_on(name, filterArgs); } void -apply_view_sort(const std::string& arg) { - rak::split_iterator_t itr = rak::split_iterator(arg, ','); +apply_view_sort(const torrent::Object::list_type& args) { + if (args.size() <= 0 || args.size() > 2) + throw torrent::input_error("Wrong argument count."); - std::string name = rak::trim(*itr); - ++itr; + const std::string& name = args.front().as_string(); if (name.empty()) throw torrent::input_error("First argument must be a string."); - // Need some generic tools for this, rather than hacking up - // something every time... - std::string arg1; int32_t value = 0; - if (itr != rak::split_iterator(arg) && !(arg1 = *itr).empty()) { - char* endPtr; + if (args.size() == 2) + value = utils::convert_to_value(args.back()); - if ((value = strtol(arg1.c_str(), &endPtr, 0)) < 0 || *endPtr != '\0') - throw torrent::input_error("Second argument must be a value."); - } - control->view_manager()->sort(name, value); } void -apply_view_sort_current(const std::string& arg) { - rak::split_iterator_t itr = rak::split_iterator(arg, ','); +apply_view_sort_current(const torrent::Object::list_type& args) { + if (args.size() < 1) + throw torrent::input_error("Too few arguments."); - std::string name = rak::trim(*itr); + const std::string& name = args.front().as_string(); if (name.empty()) throw torrent::input_error("First argument must be a string."); core::ViewManager::sort_args sortArgs; - while (++itr != rak::split_iterator(arg)) { - sortArgs.push_back(rak::trim(*itr)); - - if (sortArgs.back().empty()) - throw torrent::input_error("One of the arguments is empty."); - } + for (torrent::Object::list_type::const_iterator itr = ++args.begin(), last = args.end(); itr != last; itr++) + sortArgs.push_back(itr->as_string()); control->view_manager()->set_sort_current(name, sortArgs); } void -apply_view_sort_new(const std::string& arg) { - rak::split_iterator_t itr = rak::split_iterator(arg, ','); +apply_view_sort_new(const torrent::Object::list_type& args) { + if (args.size() < 1) + throw torrent::input_error("Too few arguments."); - std::string name = rak::trim(*itr); + const std::string& name = args.front().as_string(); if (name.empty()) throw torrent::input_error("First argument must be a string."); core::ViewManager::sort_args sortArgs; - while (++itr != rak::split_iterator(arg)) { - sortArgs.push_back(rak::trim(*itr)); - - if (sortArgs.back().empty()) - throw torrent::input_error("One of the arguments is empty."); - } + for (torrent::Object::list_type::const_iterator itr = ++args.begin(), last = args.end(); itr != last; itr++) + sortArgs.push_back(itr->as_string()); control->view_manager()->set_sort_new(name, sortArgs); } @@ -447,6 +404,21 @@ apply_try_import(const std::string& path) { control->core()->push_log("Could not read resource file: " + path); } +void +apply_schedule(const torrent::Object::list_type& args) { + if (args.size() != 4) + throw torrent::input_error("Wrong argument count."); + + torrent::Object::list_type::const_iterator itr = args.begin(); + + const std::string& arg1 = (itr++)->as_string(); + const std::string& arg2 = (itr++)->as_string(); + const std::string& arg3 = (itr++)->as_string(); + const std::string& arg4 = (itr++)->as_string(); + + control->command_scheduler()->parse(arg1, arg2, arg3, arg4); +} + void initialize_variables() { utils::VariableMap* variables = control->variable(); @@ -514,18 +486,17 @@ initialize_variables() { variables->insert("try_import", new utils::VariableStringSlot(NULL, rak::ptr_fn(&apply_try_import))); variables->insert("view_add", new utils::VariableStringSlot(NULL, rak::mem_fn(control->view_manager(), &core::ViewManager::insert_throw))); - variables->insert("view_filter", new utils::VariableStringSlot(NULL, rak::ptr_fn(&apply_view_filter))); - variables->insert("view_filter_on", new utils::VariableStringSlot(NULL, rak::ptr_fn(&apply_view_filter_on))); + variables->insert("view_filter", new utils::VariableListSlot(rak::ptr_fn(&apply_view_filter))); + variables->insert("view_filter_on", new utils::VariableListSlot(rak::ptr_fn(&apply_view_filter_on))); - variables->insert("view_sort", new utils::VariableStringSlot(NULL, rak::ptr_fn(&apply_view_sort))); - variables->insert("view_sort_new", new utils::VariableStringSlot(NULL, rak::ptr_fn(&apply_view_sort_new))); - variables->insert("view_sort_current", new utils::VariableStringSlot(NULL, rak::ptr_fn(&apply_view_sort_current))); + variables->insert("view_sort", new utils::VariableListSlot(rak::ptr_fn(&apply_view_sort))); + variables->insert("view_sort_new", new utils::VariableListSlot(rak::ptr_fn(&apply_view_sort_new))); + variables->insert("view_sort_current", new utils::VariableListSlot(rak::ptr_fn(&apply_view_sort_current))); variables->insert("key_layout", new utils::VariableAny(std::string("qwerty"))); - variables->insert("schedule", new utils::VariableStringSlot(NULL, rak::mem_fn(control->command_scheduler(), &CommandScheduler::parse))); - variables->insert("schedule_remove", new utils::VariableStringSlot(NULL, - rak::mem_fn(control->command_scheduler(), &CommandScheduler::erase))); + variables->insert("schedule", new utils::VariableListSlot(rak::ptr_fn(&apply_schedule))); + variables->insert("schedule_remove", new utils::VariableStringSlot(NULL, rak::mem_fn(control->command_scheduler(), &CommandScheduler::erase))); variables->insert("download_scheduler", new utils::VariableVoidSlot(rak::mem_fn(control->scheduler(), &core::Scheduler::update))); @@ -581,23 +552,23 @@ initialize_variables() { variables->insert("remove_untied", new utils::VariableVoidSlot(rak::ptr_fn(&apply_remove_untied))); variables->insert("close_low_diskspace", new utils::VariableValueSlot(rak::value_fn(int64_t()), rak::ptr_fn(&apply_close_low_diskspace))); - variables->insert("stop_on_ratio", new utils::VariableStringSlot(NULL, rak::ptr_fn(&apply_stop_on_ratio))); + variables->insert("stop_on_ratio", new utils::VariableListSlot(rak::ptr_fn(&apply_stop_on_ratio))); - variables->insert("on_insert", new utils::VariableStringSlot(NULL, rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_insert()))); - variables->insert("on_erase", new utils::VariableStringSlot(NULL, rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_erase()))); - variables->insert("on_open", new utils::VariableStringSlot(NULL, rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_open()))); - variables->insert("on_close", new utils::VariableStringSlot(NULL, rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_close()))); - variables->insert("on_start", new utils::VariableStringSlot(NULL, rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_start()))); - variables->insert("on_stop", new utils::VariableStringSlot(NULL, rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_stop()))); - variables->insert("on_hash_queued", new utils::VariableStringSlot(NULL, rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_hash_queued()))); - variables->insert("on_hash_removed", new utils::VariableStringSlot(NULL, rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_hash_removed()))); - variables->insert("on_hash_done", new utils::VariableStringSlot(NULL, rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_hash_done()))); - variables->insert("on_finished", new utils::VariableStringSlot(NULL, rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_finished()))); + variables->insert("on_insert", new utils::VariableListSlot(rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_insert()))); + variables->insert("on_erase", new utils::VariableListSlot(rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_erase()))); + variables->insert("on_open", new utils::VariableListSlot(rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_open()))); + variables->insert("on_close", new utils::VariableListSlot(rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_close()))); + variables->insert("on_start", new utils::VariableListSlot(rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_start()))); + variables->insert("on_stop", new utils::VariableListSlot(rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_stop()))); + variables->insert("on_hash_queued", new utils::VariableListSlot(rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_hash_queued()))); + variables->insert("on_hash_removed", new utils::VariableListSlot(rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_hash_removed()))); + variables->insert("on_hash_done", new utils::VariableListSlot(rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_hash_done()))); + variables->insert("on_finished", new utils::VariableListSlot(rak::bind_ptr_fn(&apply_on_state_change, &control->core()->download_list()->slot_map_finished()))); variables->insert("enable_trackers", new utils::VariableStringSlot(NULL, rak::ptr_fn(&apply_enable_trackers))); variables->insert("encoding_list", new utils::VariableStringSlot(NULL, rak::ptr_fn(&apply_encoding_list))); - variables->insert("encryption", new utils::VariableStringSlot(NULL, rak::ptr_fn(&apply_encryption))); + variables->insert("encryption", new utils::VariableListSlot(rak::ptr_fn(&apply_encryption))); variables->insert("handshake_log", new utils::VariableBool(false)); } @@ -622,12 +593,15 @@ var_d2_get_value(Target target, GetFunc getFunc) { } void -apply_d_create_link(core::Download* download, const std::string& args) { - rak::split_iterator_t itr = rak::split_iterator(args, ','); +apply_d_create_link(core::Download* download, const torrent::Object::list_type& args) { + if (args.size() != 3) + throw torrent::input_error("Wrong argument count."); - std::string type = rak::trim(*itr); ++itr; - std::string prefix = rak::trim(*itr); ++itr; - std::string postfix = rak::trim(*itr); ++itr; + torrent::Object::list_type::const_iterator itr = args.begin(); + + const std::string& type = (itr++)->as_string(); + const std::string& prefix = (itr++)->as_string(); + const std::string& postfix = (itr++)->as_string(); if (type.empty()) throw torrent::input_error("Invalid arguments."); @@ -663,12 +637,15 @@ apply_d_create_link(core::Download* download, const std::string& args) { } void -apply_d_delete_link(core::Download* download, const std::string& args) { - rak::split_iterator_t itr = rak::split_iterator(args, ','); +apply_d_delete_link(core::Download* download, const torrent::Object::list_type& args) { + if (args.size() != 3) + throw torrent::input_error("Wrong argument count."); - std::string type = rak::trim(*itr); ++itr; - std::string prefix = rak::trim(*itr); ++itr; - std::string postfix = rak::trim(*itr); ++itr; + torrent::Object::list_type::const_iterator itr = args.begin(); + + const std::string& type = (itr++)->as_string(); + const std::string& prefix = (itr++)->as_string(); + const std::string& postfix = (itr++)->as_string(); if (type.empty()) throw torrent::input_error("Invalid arguments."); @@ -782,6 +759,6 @@ initialize_download_variables() { // Hmm... do we need dupicates? variables->insert("print", new utils::VariableStringSlot(NULL, rak::mem_fn(control->core(), &core::Manager::push_log))); - variables->insert("create_link", new utils::VariableDownloadStringSlot(NULL, rak::ptr_fn(&apply_d_create_link))); - variables->insert("delete_link", new utils::VariableDownloadStringSlot(NULL, rak::ptr_fn(&apply_d_delete_link))); + variables->insert("create_link", new utils::VariableDownloadListSlot(rak::ptr_fn(&apply_d_create_link))); + variables->insert("delete_link", new utils::VariableDownloadListSlot(rak::ptr_fn(&apply_d_delete_link))); } diff --git a/src/utils/Makefile.am b/src/utils/Makefile.am index 07f5b5fb..c05ad06a 100644 --- a/src/utils/Makefile.am +++ b/src/utils/Makefile.am @@ -6,6 +6,8 @@ libsub_utils_a_SOURCES = \ list_focus.h \ lockfile.cc \ lockfile.h \ + parse.cc \ + parse.h \ variable.cc \ variable.h \ variable_generic.cc \ diff --git a/src/utils/parse.cc b/src/utils/parse.cc new file mode 100644 index 00000000..711738fd --- /dev/null +++ b/src/utils/parse.cc @@ -0,0 +1,227 @@ +// rTorrent - BitTorrent client +// Copyright (C) 2006, Jari Sundell +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// In addition, as a special exception, the copyright holders give +// permission to link the code of portions of this program with the +// OpenSSL library under certain conditions as described in each +// individual source file, and distribute linked combinations +// including the two. +// +// You must obey the GNU General Public License in all respects for +// all of the code used other than OpenSSL. If you modify file(s) +// with this exception, you may extend this exception to your version +// of the file(s), but you are not obligated to do so. If you do not +// wish to do so, delete this exception statement from your version. +// If you delete this exception statement from all source files in the +// program, then also delete it here. +// +// Contact: Jari Sundell +// +// Skomakerveien 33 +// 3185 Skoppum, NORWAY + +#include "config.h" + +#include +#include + +#include "parse.h" + +namespace utils { + +const char* +parse_skip_wspace(const char* first, const char* last) { + while (first != last && std::iswspace(*first)) + first++; + + return first; +} + +const char* +parse_string(const char* first, const char* last, std::string* dest) { + if (first == last) + return first; + + bool quoted = parse_is_quote(*first); + + if (quoted) + first++; + + while (first != last) { + if (quoted) { + if (parse_is_quote(*first)) + return ++first; + + } else { + if (parse_is_seperator(*first) || std::iswspace(*first)) + return first; + } + + if (parse_is_escape(*first)) + if (++first == last) + throw torrent::input_error("Escape character at end of input."); + + dest->push_back(*first); + first++; + } + + if (quoted) + throw torrent::input_error("Missing closing quote."); + + return first; +} + +const char* +parse_whole_string(const char* first, const char* last, std::string* dest) { + first = parse_skip_wspace(first, last); + first = parse_string(first, last, dest); + first = parse_skip_wspace(first, last); + + if (first != last) + throw torrent::input_error("Junk at end of input."); + + return first; +} + +const char* +parse_value(const char* src, int64_t* value, int base, int unit) { + if (unit <= 0) + throw torrent::input_error("Variable::string_to_value_unit(...) received unit <= 0."); + + char* last; + *value = strtoll(src, &last, base); + + if (last == src) { + if (strcasecmp(src, "no") == 0) { *value = 0; return src + strlen("no"); } + if (strcasecmp(src, "yes") == 0) { *value = 1; return src + strlen("yes"); } + if (strcasecmp(src, "true") == 0) { *value = 1; return src + strlen("true"); } + if (strcasecmp(src, "false") == 0) { *value = 0; return src + strlen("false"); } + + throw torrent::input_error("Could not convert string to value."); + } + + switch (*last) { + case 'b': + case 'B': ++last; break; + case 'k': + case 'K': *value = *value << 10; ++last; break; + case 'm': + case 'M': *value = *value << 20; ++last; break; + case 'g': + case 'G': *value = *value << 30; ++last; break; +// case ' ': +// case '\0': *value = *value * unit; break; +// default: throw torrent::input_error("Could not parse value."); + default: *value = *value * unit; break; + } + + return last; +} + +const char* +parse_list(const char* first, const char* last, torrent::Object* dest) { + if (!dest->is_list()) + throw torrent::internal_error("parse_list(...) !dest->is_list()."); + + while (true) { + std::string str; + + first = parse_skip_wspace(first, last); + first = parse_string(first, last, &str); + first = parse_skip_wspace(first, last); + + dest->as_list().push_back(str); + + if (first == last || !parse_is_seperator(*first)) + break; + + first++; + } + + return first; +} + +const char* +parse_whole_list(const char* first, const char* last, torrent::Object* dest) { + std::string str; + + first = parse_skip_wspace(first, last); + first = parse_string(first, last, &str); + first = parse_skip_wspace(first, last); + + if (first != last && parse_is_seperator(*first)) { + *dest = torrent::Object(torrent::Object::TYPE_LIST); + + dest->as_list().push_back(str); + first = parse_list(++first, last, dest); + + } else { + *dest = str; + } + + if (first != last) + throw torrent::input_error("Junk at end of input."); + + return first; +} + +std::string +convert_list_to_string(const torrent::Object& src) { + if (!src.is_list()) + throw torrent::internal_error("convert_list_to_string(...) !src->is_list()."); + + std::string dest; + + for (torrent::Object::list_type::const_iterator itr = src.as_list().begin(), last = src.as_list().end(); itr != last; itr++) { + if (!itr->is_string()) + throw torrent::input_error("Could not convert non-string list element to string."); + + // Meh. + if (!dest.empty()) + dest += ","; + + dest += itr->as_string(); + } + + return dest; +} + +int64_t +convert_to_value(const torrent::Object& src, int base, int unit) { + const torrent::Object& unpacked = (src.is_list() && src.as_list().size() == 1) ? src.as_list().front() : src; + + switch (unpacked.type()) { + case torrent::Object::TYPE_VALUE: + return unpacked.as_value(); + + case torrent::Object::TYPE_STRING: + int64_t tmp; + + if (parse_skip_wspace(parse_value(unpacked.as_string().c_str(), &tmp, base, unit), + unpacked.as_string().c_str() + unpacked.as_string().size()) != unpacked.as_string().c_str() + unpacked.as_string().size()) + throw torrent::input_error("Junk at end of value."); + + return tmp; + + case torrent::Object::TYPE_NONE: + return 0; + default: + throw torrent::input_error("Not convertible to a value."); + } +} + +} diff --git a/src/utils/parse.h b/src/utils/parse.h new file mode 100644 index 00000000..0b2a9e94 --- /dev/null +++ b/src/utils/parse.h @@ -0,0 +1,66 @@ +// rTorrent - BitTorrent client +// Copyright (C) 2006, Jari Sundell +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// In addition, as a special exception, the copyright holders give +// permission to link the code of portions of this program with the +// OpenSSL library under certain conditions as described in each +// individual source file, and distribute linked combinations +// including the two. +// +// You must obey the GNU General Public License in all respects for +// all of the code used other than OpenSSL. If you modify file(s) +// with this exception, you may extend this exception to your version +// of the file(s), but you are not obligated to do so. If you do not +// wish to do so, delete this exception statement from your version. +// If you delete this exception statement from all source files in the +// program, then also delete it here. +// +// Contact: Jari Sundell +// +// Skomakerveien 33 +// 3185 Skoppum, NORWAY + +#include +#include + +namespace utils { + +// parse_* functions do the bare minimum necessary to parse what was +// asked for. If a whitespace is found, it will be treated as empty +// input rather than skipped. +// +// parse_whole_* functions allow for whitespaces and throw an +// exception if there is any garbage at the end of the input. + +inline bool parse_is_quote(const char c) { return c == '"'; } +inline bool parse_is_escape(const char c) { return c == '\\'; } +inline bool parse_is_seperator(const char c) { return c == ','; } + +const char* parse_skip_wspace(const char* first, const char* last); + +const char* parse_string(const char* first, const char* last, std::string* dest); +const char* parse_whole_string(const char* first, const char* last, std::string* dest); + +const char* parse_value(const char* src, int64_t* value, int base = 0, int unit = 1); + +const char* parse_list(const char* first, const char* last, torrent::Object* dest); +const char* parse_whole_list(const char* first, const char* last, torrent::Object* dest); + +std::string convert_list_to_string(const torrent::Object& src); +int64_t convert_to_value(const torrent::Object& src, int base = 0, int unit = 1); + +} diff --git a/src/utils/variable_generic.cc b/src/utils/variable_generic.cc index 6aeba4d7..4e554408 100644 --- a/src/utils/variable_generic.cc +++ b/src/utils/variable_generic.cc @@ -38,6 +38,7 @@ #include +#include "parse.h" #include "variable_generic.h" namespace utils { @@ -249,6 +250,9 @@ VariableStringSlot::set(const torrent::Object& arg) { case torrent::Object::TYPE_NONE: m_slotSet(std::string()); break; + case torrent::Object::TYPE_LIST: + m_slotSet(convert_list_to_string(arg)); + break; default: throw torrent::input_error("Not a string."); } @@ -280,4 +284,30 @@ VariableDownloadStringSlot::set_d(core::Download* download, const torrent::Objec } } +void +VariableListSlot::set(const torrent::Object& arg) { + switch (arg.type()) { +// case torrent::Object::TYPE_STRING: +// break; + case torrent::Object::TYPE_LIST: + m_slotSet(arg.as_list()); + break; + default: + throw torrent::input_error("Not a list."); + } +} + +void +VariableDownloadListSlot::set_d(core::Download* download, const torrent::Object& arg) { + switch (arg.type()) { +// case torrent::Object::TYPE_STRING: +// break; + case torrent::Object::TYPE_LIST: + m_slotSet(download, arg.as_list()); + break; + default: + throw torrent::input_error("Not a list."); + } +} + } diff --git a/src/utils/variable_generic.h b/src/utils/variable_generic.h index aa2fcb98..6067a638 100644 --- a/src/utils/variable_generic.h +++ b/src/utils/variable_generic.h @@ -295,6 +295,36 @@ private: torrent::Object m_cache; }; +class VariableListSlot : public Variable { +public: + typedef rak::function1 slot_set_type; + + template + VariableListSlot(SlotSet* slotSet) { + m_slotSet.set(slotSet); + } + + virtual void set(const torrent::Object& arg); + +private: + slot_set_type m_slotSet; +}; + +class VariableDownloadListSlot : public Variable { +public: + typedef rak::function2 slot_set_type; + + template + VariableDownloadListSlot(SlotSet* slotSet) { + m_slotSet.set(slotSet); + } + + virtual void set_d(core::Download* download, const torrent::Object& arg); + +private: + slot_set_type m_slotSet; +}; + } #endif diff --git a/src/utils/variable_map.cc b/src/utils/variable_map.cc index d6afd496..e518aeaf 100644 --- a/src/utils/variable_map.cc +++ b/src/utils/variable_map.cc @@ -45,6 +45,7 @@ #include #include +#include "parse.h" #include "variable.h" #include "variable_map.h" @@ -132,43 +133,6 @@ parse_name(const char* first, const char* last, std::string* dest) { return first; } -const char* -parse_unknown(const char* first, const char* last, VariableMap::mapped_type* dest) { - if (*first == '"') { - const char* next = std::find_if(++first, last, std::bind2nd(std::equal_to(), '"')); - - if (first == last || first == next || next == last) - throw torrent::input_error("Could not find closing '\"'."); - - *dest = std::string(first, next); - return ++next; - - } else { - // Add rak::or and check for ','. - const char* next = std::find_if(first, last, variable_map_is_space()); - - *dest = std::string(first, next); - return next; - } -} - -const char* -parse_args(const char* first, const char* last, VariableMap::mapped_type::list_type* dest) { - first = std::find_if(first, last, std::not1(variable_map_is_space())); - - while (first != last) { - dest->push_back(VariableMap::mapped_type()); - - first = parse_unknown(first, last, &dest->back()); - first = std::find_if(first, last, std::not1(variable_map_is_space())); - - if (first != last && *first != ',') - throw torrent::input_error("A string with blanks must be quoted."); - } - - return first; -} - const char* VariableMap::process_single(const char* first) { // This could be optimized, but dunno if there's any point in doing @@ -190,19 +154,12 @@ VariableMap::process_single(const char* first, const char* last) { if (first == last || *first != '=') throw torrent::input_error("Could not find '='."); - mapped_type args(mapped_type::TYPE_LIST); - first = parse_args(first + 1, last, &args.as_list()); + mapped_type args; + first = parse_whole_list(first + 1, last, &args); - if (args.as_list().empty()) - set(key.c_str(), mapped_type()); + set(key.c_str(), args); - else if (++args.as_list().begin() == args.as_list().end()) - set(key.c_str(), *args.as_list().begin()); - - else - set(key.c_str(), args); - - return std::find_if(first, last, std::not1(variable_map_is_space())); + return first; } const char* @@ -219,67 +176,36 @@ VariableMap::process_d_single(core::Download* download, const char* first, const if (first == last || *first != '=') throw torrent::input_error("Could not find '='."); - mapped_type args(mapped_type::TYPE_LIST); - first = parse_args(first + 1, last, &args.as_list()); + mapped_type args; + first = parse_whole_list(first + 1, last, &args); - if (args.as_list().empty()) - set_d(download, key.c_str(), mapped_type()); + set_d(download, key.c_str(), args); - else if (++args.as_list().begin() == args.as_list().end()) - set_d(download, key.c_str(), *args.as_list().begin()); - - else - set_d(download, key.c_str(), args); - - return std::find_if(first, last, std::not1(variable_map_is_space())); + return first; } -// void -// VariableMap::process_command(const std::string& command) { -// std::string::const_iterator pos = command.begin(); -// pos = std::find_if(pos, command.end(), std::not1(variable_map_is_space())); - -// if (pos == command.end() || *pos == '#') -// return; - -// // Replace with parse_unknown? -// std::string key; -// pos = parse_name(pos, command.end(), &key); -// pos = std::find_if(pos, command.end(), std::not1(variable_map_is_space())); - -// if (pos == command.end() || *pos != '=') -// throw torrent::input_error("Could not find '='."); - -// mapped_type args(mapped_type::TYPE_LIST); -// parse_args(pos + 1, command.end(), &args.as_list()); - -// if (args.as_list().empty()) -// set(key.c_str(), mapped_type()); - -// else if (++args.as_list().begin() == args.as_list().end()) -// set(key.c_str(), *args.as_list().begin()); - -// else -// set(key.c_str(), args); - - // Consider what the command scheduler should do. void VariableMap::process_multiple(const char* first) { - while (first != '\0') { - const char* last = first; + try { + while (first != '\0') { + const char* last = first; - while (*last != '\n' && *last != '\0') last++; + while (*last != '\n' && *last != '\0') last++; - // Should we check the return value? Probably not necessary as - // parse_args throws on unquoted multi-word input. - process_single(first, last); + // Should we check the return value? Probably not necessary as + // parse_args throws on unquoted multi-word input. + process_single(first, last); - if (*last == '\0') - return; + if (*last == '\0') + return; - first = last + 1; + first = last + 1; + } + + } catch (torrent::input_error& e) { + throw torrent::input_error(std::string("Error parsing multi-line option: ") + e.what()); } }