X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3e42c9c678d7e69776850a7e168d160f122d24e1..a89702134ae7f9d4fb2178523311a4201d150480:/src/surf/xml/surfxml_sax_cb.cpp diff --git a/src/surf/xml/surfxml_sax_cb.cpp b/src/surf/xml/surfxml_sax_cb.cpp index c348cd5346..bd7ffc5d36 100644 --- a/src/surf/xml/surfxml_sax_cb.cpp +++ b/src/surf/xml/surfxml_sax_cb.cpp @@ -30,39 +30,32 @@ std::vector parsed_link_list; /* temporary store of cu /* * Helping functions */ -void surf_parse_assert(bool cond, const char *fmt, ...) { +void surf_parse_assert(bool cond, std::string msg) +{ if (not cond) { - va_list va; - va_start(va,fmt); int lineno = surf_parse_lineno; - char *msg = bvprintf(fmt,va); - va_end(va); cleanup(); - XBT_ERROR("Parse error at %s:%d: %s", surf_parsed_filename, lineno, msg); + XBT_ERROR("Parse error at %s:%d: %s", surf_parsed_filename, lineno, msg.c_str()); surf_exit(); xbt_die("Exiting now"); } } -void surf_parse_error(const char *fmt, ...) { - va_list va; - va_start(va,fmt); + +void surf_parse_error(std::string msg) +{ int lineno = surf_parse_lineno; - char *msg = bvprintf(fmt,va); - va_end(va); cleanup(); - XBT_ERROR("Parse error at %s:%d: %s", surf_parsed_filename, lineno, msg); + XBT_ERROR("Parse error at %s:%d: %s", surf_parsed_filename, lineno, msg.c_str()); surf_exit(); xbt_die("Exiting now"); } -void surf_parse_assert_netpoint(char* hostname, const char* pre, const char* post) + +void surf_parse_assert_netpoint(std::string hostname, std::string pre, std::string post) { - if (sg_netpoint_by_name_or_null(hostname) != nullptr) // found + if (sg_netpoint_by_name_or_null(hostname.c_str()) != nullptr) // found return; - std::string msg = std::string(pre); - msg += hostname; - msg += post; - msg += " Existing netpoints: \n"; + std::string msg = pre + hostname + post + " Existing netpoints: \n"; std::vector list; simgrid::s4u::Engine::getInstance()->getNetpointList(&list); @@ -85,36 +78,36 @@ void surf_parse_assert_netpoint(char* hostname, const char* pre, const char* pos break; } } - surf_parse_error("%s", msg.c_str()); + surf_parse_error(msg); } -void surf_parse_warn(const char *fmt, ...) { - va_list va; - va_start(va,fmt); - char *msg = bvprintf(fmt,va); - va_end(va); - XBT_WARN("%s:%d: %s", surf_parsed_filename, surf_parse_lineno, msg); - free(msg); +void surf_parse_warn(std::string msg) +{ + XBT_WARN("%s:%d: %s", surf_parsed_filename, surf_parse_lineno, msg.c_str()); } -double surf_parse_get_double(const char *string) { - double res; - int ret = sscanf(string, "%lg", &res); - if (ret != 1) - surf_parse_error("%s is not a double", string); - return res; +double surf_parse_get_double(std::string s) +{ + try { + return std::stod(s); + } catch (std::invalid_argument& ia) { + surf_parse_error(s + " is not a double"); + return -1; + } } -int surf_parse_get_int(const char *string) { - int res; - int ret = sscanf(string, "%d", &res); - if (ret != 1) - surf_parse_error("%s is not an integer", string); - return res; +int surf_parse_get_int(std::string s) +{ + try { + return std::stoi(s); + } catch (std::invalid_argument& ia) { + surf_parse_error(s + " is not a double"); + return -1; + } } /* Turn something like "1-4,6,9-11" into the vector {1,2,3,4,6,9,10,11} */ -static std::vector* explodesRadical(const char* radicals) +static std::vector* explodesRadical(std::string radicals) { std::vector* exploded = new std::vector(); @@ -124,18 +117,18 @@ static std::vector* explodesRadical(const char* radicals) for (auto group : radical_elements) { std::vector radical_ends; boost::split(radical_ends, group, boost::is_any_of("-")); - int start = surf_parse_get_int((radical_ends.front()).c_str()); - int end = 0; + int start = surf_parse_get_int(radical_ends.front()); + int end = 0; switch (radical_ends.size()) { case 1: end = start; break; case 2: - end = surf_parse_get_int((radical_ends.back()).c_str()); + end = surf_parse_get_int(radical_ends.back()); break; default: - surf_parse_error("Malformed radical: %s", group.c_str()); + surf_parse_error(std::string("Malformed radical: ") + group); break; } for (int i = start; i <= end; i++) @@ -159,9 +152,9 @@ static double surf_parse_get_value_with_unit(const char *string, const struct un errno = 0; double res = strtod(string, &ptr); if (errno == ERANGE) - surf_parse_error("value out of range: %s", string); + surf_parse_error(std::string("value out of range: ") + string); if (ptr == string) - surf_parse_error("cannot parse number: %s", string); + surf_parse_error(std::string("cannot parse number:") + string); if (ptr[0] == '\0') { if (res == 0) return res; // Ok, 0 can be unit-less @@ -174,7 +167,7 @@ static double surf_parse_get_value_with_unit(const char *string, const struct un if (units[i].unit != nullptr) res *= units[i].scale; else - surf_parse_error("unknown unit: %s", ptr); + surf_parse_error(std::string("unknown unit: ") + ptr); return res; } @@ -319,13 +312,10 @@ static std::vector surf_parse_get_all_speeds(char* speeds, const char* e /* make sure these symbols are defined as strong ones in this file so that the linker can resolve them */ /* The default current property receiver. Setup in the corresponding opening callbacks. */ -xbt_dict_t current_property_set = nullptr; +std::map* current_property_set = nullptr; std::map* current_model_property_set = nullptr; int ZONE_TAG = 0; // Whether we just opened a zone tag (to see what to do with the properties) -/* dictionary of random generator data */ -xbt_dict_t random_data_list = nullptr; - YY_BUFFER_STATE surf_input_buffer; FILE *surf_file_to_parse = nullptr; @@ -360,8 +350,7 @@ void STag_surfxml_storage___type() } void ETag_surfxml_storage___type() { - s_sg_platf_storage_type_cbarg_t storage_type; - memset(&storage_type,0,sizeof(storage_type)); + StorageTypeCreationArgs storage_type; storage_type.properties = current_property_set; current_property_set = nullptr; @@ -369,11 +358,11 @@ void ETag_surfxml_storage___type() storage_type.model_properties = current_model_property_set; current_model_property_set = nullptr; - storage_type.content = A_surfxml_storage___type_content; - storage_type.id = A_surfxml_storage___type_id; - storage_type.model = A_surfxml_storage___type_model; - storage_type.size = surf_parse_get_size(A_surfxml_storage___type_size, - "size of storage type", storage_type.id); + storage_type.content = A_surfxml_storage___type_content; + storage_type.id = A_surfxml_storage___type_id; + storage_type.model = A_surfxml_storage___type_model; + storage_type.size = + surf_parse_get_size(A_surfxml_storage___type_size, "size of storage type", storage_type.id.c_str()); sg_platf_new_storage_type(&storage_type); } @@ -521,11 +510,10 @@ void STag_surfxml_prop() simgrid::s4u::NetZone* netzone = simgrid::s4u::Engine::getInstance()->getNetzoneByNameOrNull(A_surfxml_zone_id); netzone->setProperty(A_surfxml_prop_id, A_surfxml_prop_value); - } - else{ + } else { if (not current_property_set) - current_property_set = xbt_dict_new_homogeneous(&xbt_free_f); // Maybe, it should raise an error - xbt_dict_set(current_property_set, A_surfxml_prop_id, xbt_strdup(A_surfxml_prop_value), nullptr); + current_property_set = new std::map; // Maybe, it should raise an error + current_property_set->insert({A_surfxml_prop_id, A_surfxml_prop_value}); XBT_DEBUG("add prop %s=%s into current property set %p", A_surfxml_prop_id, A_surfxml_prop_value, current_property_set); } @@ -606,8 +594,7 @@ void ETag_surfxml_cluster(){ cluster.topology= SURF_CLUSTER_DRAGONFLY ; break; default: - surf_parse_error("Invalid cluster topology for cluster %s", - cluster.id); + surf_parse_error(std::string("Invalid cluster topology for cluster ") + cluster.id); break; } cluster.topo_parameters = A_surfxml_cluster_topo___parameters; @@ -624,7 +611,7 @@ void ETag_surfxml_cluster(){ cluster.sharing_policy = SURF_LINK_FATPIPE; break; default: - surf_parse_error("Invalid cluster sharing policy for cluster %s", cluster.id); + surf_parse_error(std::string("Invalid cluster sharing policy for cluster ") + cluster.id); break; } switch (AX_surfxml_cluster_bb___sharing___policy) { @@ -635,7 +622,7 @@ void ETag_surfxml_cluster(){ cluster.bb_sharing_policy = SURF_LINK_SHARED; break; default: - surf_parse_error("Invalid bb sharing policy in cluster %s", cluster.id); + surf_parse_error(std::string("Invalid bb sharing policy in cluster ") + cluster.id); break; } @@ -650,14 +637,13 @@ void STag_surfxml_cluster(){ void STag_surfxml_cabinet(){ parse_after_config(); - s_sg_platf_cabinet_cbarg_t cabinet; - memset(&cabinet,0,sizeof(cabinet)); + CabinetCreationArgs cabinet; cabinet.id = A_surfxml_cabinet_id; cabinet.prefix = A_surfxml_cabinet_prefix; cabinet.suffix = A_surfxml_cabinet_suffix; - cabinet.speed = surf_parse_get_speed(A_surfxml_cabinet_speed, "speed of cabinet", cabinet.id); - cabinet.bw = surf_parse_get_bandwidth(A_surfxml_cabinet_bw, "bw of cabinet", cabinet.id); - cabinet.lat = surf_parse_get_time(A_surfxml_cabinet_lat, "lat of cabinet", cabinet.id); + cabinet.speed = surf_parse_get_speed(A_surfxml_cabinet_speed, "speed of cabinet", cabinet.id.c_str()); + cabinet.bw = surf_parse_get_bandwidth(A_surfxml_cabinet_bw, "bw of cabinet", cabinet.id.c_str()); + cabinet.lat = surf_parse_get_time(A_surfxml_cabinet_lat, "lat of cabinet", cabinet.id.c_str()); cabinet.radicals = explodesRadical(A_surfxml_cabinet_radical); sg_platf_new_cabinet(&cabinet); @@ -711,35 +697,31 @@ void ETag_surfxml_link(){ link.policy = SURF_LINK_FULLDUPLEX; break; default: - surf_parse_error("Invalid sharing policy in link %s", link.id.c_str()); + surf_parse_error(std::string("Invalid sharing policy in link ") + link.id); break; } sg_platf_new_link(&link); } -void STag_surfxml_link___ctn(){ - +void STag_surfxml_link___ctn() +{ simgrid::surf::LinkImpl* link = nullptr; - char *link_name=nullptr; switch (A_surfxml_link___ctn_direction) { case AU_surfxml_link___ctn_direction: case A_surfxml_link___ctn_direction_NONE: link = simgrid::surf::LinkImpl::byName(A_surfxml_link___ctn_id); break; case A_surfxml_link___ctn_direction_UP: - link_name = bprintf("%s_UP", A_surfxml_link___ctn_id); - link = simgrid::surf::LinkImpl::byName(link_name); + link = simgrid::surf::LinkImpl::byName(std::string(A_surfxml_link___ctn_id) + "_UP"); break; case A_surfxml_link___ctn_direction_DOWN: - link_name = bprintf("%s_DOWN", A_surfxml_link___ctn_id); - link = simgrid::surf::LinkImpl::byName(link_name); + link = simgrid::surf::LinkImpl::byName(std::string(A_surfxml_link___ctn_id) + "_DOWN"); break; default: - surf_parse_error("Invalid direction for link %s", link_name); + surf_parse_error(std::string("Invalid direction for link ") + A_surfxml_link___ctn_id); break; } - xbt_free(link_name); // no-op if it's already nullptr const char* dirname = ""; switch (A_surfxml_link___ctn_direction) { @@ -752,7 +734,7 @@ void STag_surfxml_link___ctn(){ default: dirname = ""; } - surf_parse_assert(link != nullptr, "No such link: '%s'%s", A_surfxml_link___ctn_id, dirname); + surf_parse_assert(link != nullptr, std::string("No such link: '") + A_surfxml_link___ctn_id + "'" + dirname); parsed_link_list.push_back(link); } @@ -914,8 +896,7 @@ void ETag_surfxml_bypassZoneRoute() } void ETag_surfxml_trace(){ - s_sg_platf_trace_cbarg_t trace; - memset(&trace,0,sizeof(trace)); + TraceCreationArgs trace; trace.id = A_surfxml_trace_id; trace.file = A_surfxml_trace_file; @@ -928,7 +909,7 @@ void ETag_surfxml_trace(){ void STag_surfxml_trace___connect() { parse_after_config(); - s_sg_platf_trace_connect_cbarg_t trace_connect; + TraceConnectCreationArgs trace_connect; memset(&trace_connect,0,sizeof(trace_connect)); trace_connect.element = A_surfxml_trace___connect_element; @@ -974,20 +955,23 @@ void STag_surfxml_zone() { parse_after_config(); ZONE_TAG = 1; - s_sg_platf_AS_cbarg_t AS = {A_surfxml_zone_id, (int)A_surfxml_zone_routing}; + ZoneCreationArgs zone; + zone.id = A_surfxml_zone_id; + zone.routing = static_cast(A_surfxml_zone_routing); - sg_platf_new_AS_begin(&AS); + sg_platf_new_Zone_begin(&zone); } void ETag_surfxml_zone() { - sg_platf_new_AS_seal(); + sg_platf_new_Zone_seal(); } void STag_surfxml_config() { ZONE_TAG = 0; - xbt_assert(current_property_set == nullptr, "Someone forgot to reset the property set to nullptr in its closing tag (or XML malformed)"); + xbt_assert(current_property_set == nullptr, + "Someone forgot to reset the property set to nullptr in its closing tag (or XML malformed)"); XBT_DEBUG("START configuration name = %s",A_surfxml_config_id); if (_sg_cfg_init_status == 2) { surf_parse_error("All tags must be given before any platform elements (such as , , , " @@ -997,19 +981,16 @@ void STag_surfxml_config() void ETag_surfxml_config() { - xbt_dict_cursor_t cursor = nullptr; - char *key; - char *elem; - xbt_dict_foreach(current_property_set, cursor, key, elem) { - if (xbt_cfg_is_default_value(key)) { - std::string cfg = std::string(key) + ":" + elem; + for (auto elm : *current_property_set) { + if (xbt_cfg_is_default_value(elm.first.c_str())) { + std::string cfg = elm.first + ":" + elm.second; xbt_cfg_set_parse(cfg.c_str()); } else - XBT_INFO("The custom configuration '%s' is already defined by user!",key); + XBT_INFO("The custom configuration '%s' is already defined by user!", elm.first.c_str()); } XBT_DEBUG("End configuration name = %s",A_surfxml_config_id); - xbt_dict_free(¤t_property_set); + delete current_property_set; current_property_set = nullptr; } @@ -1021,6 +1002,7 @@ void STag_surfxml_process() AX_surfxml_actor_function = AX_surfxml_process_function; STag_surfxml_actor(); } + void STag_surfxml_actor() { ZONE_TAG = 0; @@ -1039,6 +1021,7 @@ void ETag_surfxml_process() AX_surfxml_actor_on___failure = (AT_surfxml_actor_on___failure)AX_surfxml_process_on___failure; ETag_surfxml_actor(); } + void ETag_surfxml_actor() { s_sg_platf_process_cbarg_t actor; @@ -1085,8 +1068,7 @@ void STag_surfxml_model___prop(){ if (not current_model_property_set) current_model_property_set = new std::map(); - current_model_property_set->insert( - {std::string(A_surfxml_model___prop_id), std::string(A_surfxml_model___prop_value)}); + current_model_property_set->insert({A_surfxml_model___prop_id, A_surfxml_model___prop_value}); } void ETag_surfxml_prop(){/* Nothing to do */}