if (!job)
return EINVAL;
- return (*(job->func)) (job->argc, job->argv);
+ return job->func(job->argc, job->argv);
}
int job_free(job_t * ref)
# include <stdio.h>
#include <errno.h>
# define MAYDAY_SAVE(m) printf("%d %s:%d save %p\n", \
- (*xbt_getpid)(),__FILE__,__LINE__, \
+ xbt_getpid(), __FILE__, __LINE__, \
(m)->jb \
),
# define MAYDAY_RESTORE(m) printf("%d %s:%d restore %p\n", \
- (*xbt_getpid)(),__FILE__,__LINE__, \
+ xbt_getpid(), __FILE__, __LINE__, \
(m)->jb \
),
# define MAYDAY_CATCH(e) printf("%d %s:%d Catched '%s'\n", \
- (*xbt_getpid)(),__FILE__,__LINE__, \
+ xbt_getpid(), __FILE__, __LINE__, \
(e).msg \
),
#else
_throw_ctx->exception.remote = 0; \
_throw_ctx->exception.host = (char*)NULL; \
_throw_ctx->exception.procname = (char*)xbt_procname(); \
- _throw_ctx->exception.pid = (*xbt_getpid)(); \
+ _throw_ctx->exception.pid = xbt_getpid(); \
_throw_ctx->exception.file = (char*)__FILE__; \
_throw_ctx->exception.line = __LINE__; \
_throw_ctx->exception.func = (char*)_XBT_FUNCTION; \
/* Detect the referenced type */
sub_type = ref_data.type;
if (sub_type == NULL) {
- sub_type = (*ref_data.selector) (type, state, src);
+ sub_type = ref_data.selector(type, state, src);
}
/* Send the pointed data only if not already sent */
/* Detect the referenced type and send it to peer if needed */
sub_type = ref_data.type;
if (sub_type == NULL) {
- sub_type = (*ref_data.selector) (type, state, data);
+ sub_type = ref_data.selector(type, state, data);
gras_dd_send_int(sock, &(sub_type->code), 1 /*stable */ );
}
XBT_DEBUG
("Use the callback #%d (@%p) for incomming msg '%s' (payload_size=%d)",
cpt + 1, cb, msg.type->name, msg.payl_size);
- if (!(*cb) (&ctx, msg.payl)) {
+ if (!cb(&ctx, msg.payl)) {
/* cb handled the message */
free(msg.payl);
ran_ok = 1;
timer->action);
xbt_dynar_cursor_rm(pd->timers, &cursor);
}
- (*action) ();
+ action();
return 0.0;
} else if (untilthis < untilnext || untilnext == -1) {
untilnext = untilthis;
void gras_trp_send(gras_socket_t sd, char *data, long int size, int stable)
{
xbt_assert(sd->outgoing, "Socket not suited for data send");
- (*sd->plugin->send) (sd, data, size, stable);
+ sd->plugin->send(sd, data, size, stable);
}
/**
{
if (!sock->plugin->my_port)
THROWF(unknown_error,0,"Function my_port unimplemented in plugin %s",sock->plugin->name);
- return (*sock->plugin->my_port)(sock);
+ return sock->plugin->my_port(sock);
}
{
if (!sock->plugin->peer_port)
THROWF(unknown_error,0,"Function peer_port unimplemented in plugin %s",sock->plugin->name);
- return (*sock->plugin->peer_port)(sock);
+ return sock->plugin->peer_port(sock);
}
const char *gras_socket_peer_name(gras_socket_t sock)
{
xbt_assert(sock->plugin);
- return (*sock->plugin->peer_name)(sock);
+ return sock->plugin->peer_name(sock);
}
const char *gras_socket_peer_proc(gras_socket_t sock)
{
- return (*sock->plugin->peer_proc)(sock);
+ return sock->plugin->peer_proc(sock);
}
void gras_socket_peer_proc_set(gras_socket_t sock, char *peer_proc)
{
- return (*sock->plugin->peer_proc_set)(sock,peer_proc);
+ return sock->plugin->peer_proc_set(sock,peer_proc);
}
/** \brief Check if the provided socket is a measurement one (or a regular one) */
"Sent %lu msgs of %lu (size of each: %ld) to %s:%d",
sent_sofar, msg_amount, msg_size, gras_socket_peer_name(peer),
gras_socket_peer_port(peer));
- (*peer->plugin->raw_send) (peer, chunk, msg_size);
+ peer->plugin->raw_send(peer, chunk, msg_size);
}
XBT_CDEBUG(gras_trp_meas,
"Sent %lu msgs of %lu (size of each: %ld) to %s:%d", sent_sofar,
int id = xbt_dynar_search(pd->moddata, p);
gras_module_t mod = (gras_module_t) xbt_set_get_by_id(_gras_modules, id);
- (*mod->leave_f) (gras_moddata_by_id(id));
+ mod->leave_f(gras_moddata_by_id(id));
}
void gras_module_join(const char *name)
XBT_VERB("Init module %s", name);
mod->name = xbt_strdup(name);
- (*mod->init_f) ();
+ mod->init_f();
} else {
XBT_DEBUG("Module %s already inited. Refcount=%d ID=%d",
mod->name, mod->refcount, *(mod->p_id));
xbt_dynar_set(pd->moddata, *(mod->p_id), &moddata);
- (*mod->join_f) (moddata);
+ mod->join_f(moddata);
XBT_DEBUG("Module %s joined successfully (ID=%d)", name, *(mod->p_id));
}
/* LEAVE */
moddata = gras_moddata_by_id(*(mod->p_id));
- (*mod->leave_f) (moddata);
+ mod->leave_f(moddata);
/* EXIT */
mod->refcount--;
if (!mod->refcount) {
XBT_VERB("Exit module %s", name);
- (*mod->exit_f) ();
+ mod->exit_f();
/* Don't remove the module for real, sets don't allow to
"MayDay: two modules use '%s' as libdata name", fab.name);
/* Add the data in place, after some more sanity checking */
- elem = (*(fab.constructor)) ();
+ elem = fab.constructor();
if (elem->name_len && elem->name_len != strlen(elem->name)) {
elem->name_len = strlen(elem->name);
XBT_WARN
static void *spawner_wrapper(void *data) {
spawner_wrapper_args *a = data;
- (*(a->code))(a->argc,a->argv);
+ a->code(a->argc, a->argv);
free(a);
return NULL;
}
while ((evt = action_get_action(argv[0]))) {
msg_action_fun function = xbt_dict_get(action_funs, evt[1]);
- (*function) (evt);
+ function(evt);
free(evt);
}
} else { // Should have got my trace file in argument
while ((evt=xbt_replay_trace_reader_get(reader))) {
if (!strcmp(argv[0],evt[0])) {
msg_action_fun function = xbt_dict_get(action_funs, evt[1]);
- (*function) (evt);
+ function(evt);
free(evt);
} else {
XBT_WARN("%s: Ignore trace element not for me",
smx_process_t simix_process)
{
- return (*(simix_global->context_factory->create_context))
- (code, argc, argv, cleanup_func, simix_process);
+ return simix_global->context_factory->create_context(code,
+ argc, argv,
+ cleanup_func,
+ simix_process);
}
/**
*/
static XBT_INLINE void SIMIX_context_free(smx_context_t context)
{
- (*(simix_global->context_factory->free)) (context);
+ simix_global->context_factory->free(context);
}
/**
*/
static XBT_INLINE void SIMIX_context_stop(smx_context_t context)
{
- (*(simix_global->context_factory->stop)) (context);
+ simix_global->context_factory->stop(context);
}
/**
*/
static XBT_INLINE void SIMIX_context_suspend(smx_context_t context)
{
- (*(simix_global->context_factory->suspend)) (context);
+ simix_global->context_factory->suspend(context);
}
/**
*/
static XBT_INLINE void SIMIX_context_runall()
{
- (*(simix_global->context_factory->runall)) ();
+ simix_global->context_factory->runall();
}
/**
static XBT_INLINE smx_context_t SIMIX_context_self(void)
{
if (simix_global && simix_global->context_factory != NULL) {
- return (*(simix_global->context_factory->self))();
+ return simix_global->context_factory->self();
}
return NULL;
*/
static XBT_INLINE void* SIMIX_context_get_data(smx_context_t context)
{
- return (*(simix_global->context_factory->get_data))(context);
+ return simix_global->context_factory->get_data(context);
}
XBT_PUBLIC(int) SIMIX_process_get_maxpid(void);
if (!simix_global->context_factory) {
/* select the context factory to use to create the contexts */
if (smx_factory_initializer_to_use) {
- (*smx_factory_initializer_to_use)(&(simix_global->context_factory));
+ smx_factory_initializer_to_use(&simix_global->context_factory);
}
else { /* use the factory specified by --cfg=contexts/factory:value */
/* finalize the context factory */
finalize_factory = simix_global->context_factory->finalize;
- (*finalize_factory) (&simix_global->context_factory);
+ finalize_factory(&simix_global->context_factory);
}
xbt_dict_remove((xbt_dict_t) _surf_cfg_set,"contexts/factory");
}
void smx_ctx_base_stop(smx_context_t context)
{
if (context->cleanup_func)
- (*(context->cleanup_func)) (context->data);
+ context->cleanup_func(context->data);
context->iwannadie = 0;
SIMIX_req_process_cleanup(context->data);
}
XBT_DEBUG("Starting Process %s(%s) right now", parse_argv[0], parse_host);
if (simix_global->create_process_function)
- (*simix_global->create_process_function) (&process,
- parse_argv[0],
- parse_code, NULL,
- parse_host, parse_argc,
- parse_argv,
- current_property_set);
+ simix_global->create_process_function(&process,
+ parse_argv[0],
+ parse_code, NULL,
+ parse_host, parse_argc,
+ parse_argv,
+ current_property_set);
else
SIMIX_req_process_create(&process, parse_argv[0], parse_code, NULL, parse_host, parse_argc, parse_argv,
current_property_set);
if (buff_size == 0)
return;
- (*SIMIX_comm_copy_data_callback) (comm, buff_size);
+ SIMIX_comm_copy_data_callback(comm, buff_size);
/* Set the copied flag so we copy data only once */
/* (this function might be called from both communication ends) */
(link->lmm_resource.power.peak * link->lmm_resource.power.scale);
if (bandwidth_bound < 0.0)
bandwidth_bound =
- (*bandwidth_factor_callback) (size) *
+ bandwidth_factor_callback(size) *
(link->lmm_resource.power.peak * link->lmm_resource.power.scale);
else
bandwidth_bound =
min(bandwidth_bound,
- (*bandwidth_factor_callback) (size) *
+ bandwidth_factor_callback(size) *
(link->lmm_resource.power.peak *
link->lmm_resource.power.scale));
}
/* LARGE PLATFORMS HACK:
Add src->link and dst->link latencies */
action->lat_current = action->latency;
- action->latency *= (*latency_factor_callback) (size);
+ action->latency *= latency_factor_callback(size);
action->rate =
- (*bandwidth_constraint_callback) (action->rate, bandwidth_bound,
+ bandwidth_constraint_callback(action->rate, bandwidth_bound,
size);
if(xbt_dynar_length(route) > 0) {
(link->lmm_resource.power.peak * link->lmm_resource.power.scale);
if (bandwidth_bound < 0.0)
bandwidth_bound =
- (*im_bandwidth_factor_callback) (size) *
+ im_bandwidth_factor_callback(size) *
(link->lmm_resource.power.peak * link->lmm_resource.power.scale);
else
bandwidth_bound =
min(bandwidth_bound,
- (*im_bandwidth_factor_callback) (size) *
+ im_bandwidth_factor_callback(size) *
(link->lmm_resource.power.peak *
link->lmm_resource.power.scale));
}
/* LARGE PLATFORMS HACK:
Add src->link and dst->link latencies */
action->lat_current = action->latency;
- action->latency *= (*im_latency_factor_callback) (size);
+ action->latency *= im_latency_factor_callback(size);
action->rate =
- (*im_bandwidth_constraint_callback) (action->rate, bandwidth_bound,
+ im_bandwidth_constraint_callback(action->rate, bandwidth_bound,
size);
/* LARGE PLATFORMS HACK:
unsigned int iterator;
sg_platf_host_cb_t fun;
xbt_dynar_foreach(sg_platf_host_cb_list, iterator, fun) {
- (*fun) (h);
+ fun(h);
}
}
void sg_platf_new_router(sg_platf_router_cbarg_t router) {
unsigned int iterator;
sg_platf_router_cb_t fun;
xbt_dynar_foreach(sg_platf_router_cb_list, iterator, fun) {
- (*fun) (router);
+ fun(router);
}
}
void sg_platf_new_link(sg_platf_link_cbarg_t link){
unsigned int iterator;
sg_platf_link_cb_t fun;
xbt_dynar_foreach(sg_platf_link_cb_list, iterator, fun) {
- (*fun) (link);
+ fun(link);
}
}
void sg_platf_new_peer(sg_platf_peer_cbarg_t peer){
unsigned int iterator;
sg_platf_peer_cb_t fun;
xbt_dynar_foreach(sg_platf_link_cb_list, iterator, fun) {
- (*fun) (peer);
+ fun(peer);
}
}
unsigned int iterator;
void_f_void_t fun;
xbt_dynar_foreach(sg_platf_postparse_cb_list, iterator, fun) {
- (*fun) ();
+ fun();
}
}
}
xbt_dynar_foreach(sg_platf_AS_begin_cb_list, iterator, fun) {
- (*fun) (id,routing);
+ fun(id, routing);
}
}
unsigned int iterator;
void_f_void_t fun;
xbt_dynar_foreach(sg_platf_AS_end_cb_list, iterator, fun) {
- (*fun) ();
+ fun();
}
}
xbt_assert(!xbt_lib_get_or_null(host_lib, host->id, ROUTING_HOST_LEVEL),
"Reading a host, processing unit \"%s\" already exists", host->id);
- (*(current_routing->parse_PU)) (current_routing, host->id);
+ current_routing->parse_PU(current_routing, host->id);
info = xbt_new0(s_network_element_info_t, 1);
info->rc_component = current_routing;
info->rc_type = SURF_NETWORK_ELEMENT_HOST;
"Reading a router, processing unit \"%s\" already exists",
router->id);
- (*(current_routing->parse_PU)) (current_routing, router->id);
+ current_routing->parse_PU(current_routing, router->id);
info = xbt_new0(s_network_element_info_t, 1);
info->rc_component = current_routing;
info->rc_type = SURF_NETWORK_ELEMENT_ROUTER;
xbt_assert(current_routing->parse_route,
"no defined method \"set_route\" in \"%s\"",
current_routing->name);
- (*(current_routing->parse_route)) (current_routing, src, dst, route);
+ current_routing->parse_route(current_routing, src, dst, route);
link_list = NULL;
src = NULL;
dst = NULL;
xbt_assert(current_routing->parse_ASroute,
"no defined method \"set_ASroute\" in \"%s\"",
current_routing->name);
- (*(current_routing->parse_ASroute)) (current_routing, src, dst, e_route);
+ current_routing->parse_ASroute(current_routing, src, dst, e_route);
link_list = NULL;
src = NULL;
dst = NULL;
xbt_assert(current_routing->parse_bypassroute,
"Bypassing mechanism not implemented by routing '%s'",
current_routing->name);
- (*(current_routing->parse_bypassroute)) (current_routing, src, dst, e_route);
+ current_routing->parse_bypassroute(current_routing, src, dst, e_route);
link_list = NULL;
src = NULL;
dst = NULL;
}
/* make a new routing component */
- new_as = (AS_t) (*(model->create)) ();
+ new_as = (AS_t) model->create();
new_as->model_desc = model;
new_as->hierarchy = SURF_ROUTING_NULL;
new_as->name = xbt_strdup(AS_id);
xbt_dict_set(current_routing->routing_sons, AS_id,
(void *) new_as, NULL);
/* add to the father element list */
- (*(current_routing->parse_AS)) (current_routing, AS_id);
+ current_routing->parse_AS(current_routing, AS_id);
} else {
THROWF(arg_error, 0, "All defined components must be belong to a AS");
}
(void *) info);
if (current_routing->model_desc->end)
- (*(current_routing->model_desc->end)) (current_routing);
+ current_routing->model_desc->end(current_routing);
current_routing = current_routing->routing_father;
}
}
if(routing_get_network_element_type(src) == SURF_NETWORK_ELEMENT_AS) {
int need_to_clean = e_route?0:1;
double latency;
- e_route = e_route?e_route:(*(rc->get_route)) (rc, src, dst);
+ e_route = e_route ? e_route : rc->get_route(rc, src, dst);
latency = base_vivaldi_get_latency(e_route->src_gateway,e_route->dst_gateway);
if(need_to_clean) generic_free_extended_route(e_route);
return latency;
unsigned int iterator;
void_f_void_t fun;
xbt_dynar_foreach(cb_list, iterator, fun) {
- if (fun) (*fun) ();
+ if (fun) fun();
}
}
return;
}
- (*fun_set_options) ((*fun_get_options) () |
+ fun_set_options(fun_get_options() |
SYMOPT_LOAD_LINES | SYMOPT_DEFERRED_LOADS);
- if (!(*fun_initialize) (process_handle, 0, 1)) {
+ if (!fun_initialize(process_handle, 0, 1)) {
FreeLibrary(hlp_dbg_instance);
hlp_dbg_instance = NULL;
}
if (!hlp_dbg_instance)
return;
- if ((*fun_cleanup) (process_handle))
+ if (fun_cleanup(process_handle))
FreeLibrary(hlp_dbg_instance);
hlp_dbg_instance = NULL;
if (NULL != stack_frame) {
- if ((*fun_get_sym_from_addr)
+ if (fun_get_sym_from_addr
(process_handle, stack_frame->AddrPC.Offset, &offset, pSym)) {
- if ((*fun_get_line_from_addr)
+ if (fun_get_line_from_addr
(process_handle, stack_frame->AddrPC.Offset, &offset,
&line_info)) {
strings[pos] =
if (variable->max == 1) {
if (variable->cb_rm && xbt_dynar_length(variable->content))
- (*variable->cb_rm) (name, 0);
+ variable->cb_rm(name, 0);
xbt_dynar_set(variable->content, 0, &val);
} else {
}
if (variable->cb_set)
- (*variable->cb_set) (name, xbt_dynar_length(variable->content) - 1);
+ variable->cb_set(name, xbt_dynar_length(variable->content) - 1);
variable->isdefault = 0;
}
if (variable->max == 1) {
if (variable->cb_rm && xbt_dynar_length(variable->content))
- (*variable->cb_rm) (name, 0);
+ variable->cb_rm(name, 0);
xbt_dynar_set(variable->content, 0, &val);
} else {
}
if (variable->cb_set)
- (*variable->cb_set) (name, xbt_dynar_length(variable->content) - 1);
+ variable->cb_set(name, xbt_dynar_length(variable->content) - 1);
variable->isdefault = 0;
}
if (variable->max == 1) {
if (xbt_dynar_length(variable->content)) {
if (variable->cb_rm)
- (*variable->cb_rm) (name, 0);
+ variable->cb_rm(name, 0);
else if (variable->type == xbt_cfgelm_string) {
char *sval = xbt_dynar_get_as(variable->content, 0, char *);
free(sval);
}
if (variable->cb_set)
- (*variable->cb_set) (name, xbt_dynar_length(variable->content) - 1);
+ variable->cb_set(name, xbt_dynar_length(variable->content) - 1);
variable->isdefault = 0;
}
if (variable->max == 1) {
if (variable->cb_rm && xbt_dynar_length(variable->content))
- (*variable->cb_rm) (name, 0);
+ variable->cb_rm(name, 0);
xbt_dynar_set(variable->content, 0, &val);
} else {
}
if (variable->cb_set)
- (*variable->cb_set) (name, xbt_dynar_length(variable->content) - 1);
+ variable->cb_set(name, xbt_dynar_length(variable->content) - 1);
variable->isdefault = 0;
}
xbt_dynar_foreach(variable->content, cpt, seen) {
if (seen == val) {
if (variable->cb_rm)
- (*variable->cb_rm) (name, cpt);
+ variable->cb_rm(name, cpt);
xbt_dynar_cursor_rm(variable->content, &cpt);
return;
}
if (seen == val) {
xbt_dynar_cursor_rm(variable->content, &cpt);
if (variable->cb_rm)
- (*variable->cb_rm) (name, cpt);
+ variable->cb_rm(name, cpt);
return;
}
}
xbt_dynar_foreach(variable->content, cpt, seen) {
if (!strcpy(seen, val)) {
if (variable->cb_rm)
- (*variable->cb_rm) (name, cpt);
+ variable->cb_rm(name, cpt);
xbt_dynar_cursor_rm(variable->content, &cpt);
return;
}
xbt_dynar_foreach(variable->content, cpt, seen) {
if (!strcpy(seen->name, peer) && seen->port == port) {
if (variable->cb_rm)
- (*variable->cb_rm) (name, cpt);
+ variable->cb_rm(name, cpt);
xbt_dynar_cursor_rm(variable->content, &cpt);
return;
}
pos, name, variable->min);
if (variable->cb_rm)
- (*variable->cb_rm) (name, pos);
+ variable->cb_rm(name, pos);
xbt_dynar_remove_at(variable->content, pos, NULL);
}
unsigned int cpt;
void *ignored;
xbt_dynar_foreach(variable->content, cpt, ignored) {
- (*variable->cb_rm) (name, cpt);
+ variable->cb_rm(name, cpt);
}
}
xbt_dynar_reset(variable->content);
while (element != NULL) {
printf(" %s -> '", element->key);
if (output != NULL) {
- (*output) (element->content);
+ output(element->content);
}
printf("'\n");
element = element->next;
if (dynar->elmsize <= SIZEOF_MAX) {
char elm[SIZEOF_MAX];
_xbt_dynar_get_elm(elm, dynar, idx);
- (*dynar->free_f) (elm);
+ dynar->free_f(elm);
} else {
char *elm = malloc(dynar->elmsize);
_xbt_dynar_get_elm(elm, dynar, idx);
- (*dynar->free_f) (elm);
+ dynar->free_f(elm);
free(elm);
}
}
if (idx < dynar->used && dynar->free_f) {
void *const old_object = _xbt_dynar_elm(dynar, idx);
- (*(dynar->free_f)) (old_object);
+ dynar->free_f(old_object);
}
_xbt_dynar_set(dynar, idx, object);
for (i = 0; i < used; i++) {
char* elm = (char*) data + i * elmsize;
- (*op) (elm);
+ op(elm);
}
}
"** SimGrid: UNCAUGHT EXCEPTION received on %s(%d): category: %s; value: %d\n"
"** %s\n"
"** Thrown by %s()%s\n",
- gras_os_myname(), (*xbt_getpid) (),
+ gras_os_myname(), xbt_getpid(),
xbt_ex_catname(e->category), e->value, e->msg,
e->procname, thrower ? thrower : " in this process");
XBT_CRITICAL("%s", e->msg);
xbt_dynar_free(&(node->out));
xbt_dynar_free(&(node->in));
if (node_free_function)
- (*node_free_function) (node->data);
+ node_free_function(node->data);
}
xbt_dynar_foreach(g->edges, cursor, edge) {
if (edge_free_function)
- (*edge_free_function) (edge->data);
+ edge_free_function(edge->data);
}
xbt_dynar_foreach(g->nodes, cursor, node)
free(edge);
xbt_dynar_free(&(g->edges));
if (graph_free_function)
- (*graph_free_function) (g->data);
+ graph_free_function(g->data);
free(g);
xbt_graph_parse_lex_destroy();
return;
}
if ((node_free_function) && (n->data))
- (*node_free_function) (n->data);
+ node_free_function(n->data);
cursor = 0;
xbt_dynar_foreach(g->nodes, cursor, node)
xbt_edge_t edge = NULL;
if ((free_function) && (e->data))
- (*free_function) (e->data);
+ free_function(e->data);
xbt_dynar_foreach(g->edges, cursor, edge) {
if (edge == e) {
xbt_graph_parse_open(filename);
_XBT_GNUC_UNUSED int res;
- res = (*xbt_graph_parse) ();
+ res = xbt_graph_parse();
xbt_assert(!res, "Parse error in %s", filename);
xbt_graph_parse_close();
void STag_graphxml_graph(void)
{
- (*STag_graphxml_graph_fun) ();
+ STag_graphxml_graph_fun();
}
void ETag_graphxml_graph(void)
{
- (*ETag_graphxml_graph_fun) ();
+ ETag_graphxml_graph_fun();
}
void STag_graphxml_node(void)
{
- (*STag_graphxml_node_fun) ();
+ STag_graphxml_node_fun();
}
void ETag_graphxml_node(void)
{
- (*ETag_graphxml_node_fun) ();
+ ETag_graphxml_node_fun();
}
void STag_graphxml_edge(void)
{
- (*STag_graphxml_edge_fun) ();
+ STag_graphxml_edge_fun();
}
void ETag_graphxml_edge(void)
{
- (*ETag_graphxml_edge_fun) ();
+ ETag_graphxml_edge_fun();
}
int i;
if (H->free)
for (i = 0; i < H->count; i++)
- (*(H->free)) (H->items[i].content);
+ H->free(H->items[i].content);
free(H->items);
free(H);
return;
XBT_VERB("Frees mallocator %p (size:%d/%d)", m, m->current_size,
m->max_size);
for (i = 0; i < m->current_size; i++) {
- (*(m->free_f)) (m->objects[i]);
+ m->free_f(m->objects[i]);
}
xbt_free(m->objects);
xbt_free(m);
int i;
int amount = MIN(m->max_size / 2, 1000);
for (i = 0; i < amount; i++)
- m->objects[i] = (*(m->new_f)) ();
+ m->objects[i] = m->new_f();
m->current_size = amount;
}
/* m, m->current_size, m->max_size); */
object = m->objects[--m->current_size];
} else {
- object = (*(m->new_f)) ();
+ object = m->new_f();
}
- (*(m->reset_f)) (object);
+ m->reset_f(object);
return object;
}
/* otherwise we don't have a choice, we must free the object */
/* XBT_DEBUG("Free deleted object: mallocator %p is full (size:%d/%d)", m,
m->current_size, m->max_size); */
- (*(m->free_f)) (object);
+ m->free_f(object);
}
}
}
}
if (mdp->mfree_hook != NULL) {
- (*mdp->mfree_hook) (mdp, ptr);
+ mdp->mfree_hook(mdp, ptr);
} else {
__mmalloc_free(mdp, ptr);
}
// printf("(%s) Mallocing %d bytes on %p (default: %p)...",xbt_thread_self_name(),size,mdp,__mmalloc_default_mdp);fflush(stdout);
if (mdp->mmalloc_hook != NULL) {
- return (*mdp->mmalloc_hook) (md, size);
+ return mdp->mmalloc_hook(md, size);
}
if (!(mdp->flags & MMALLOC_INITIALIZED)) {
{
if (hdr->magic != MAGICWORD ||
((char *) &hdr[1])[hdr->size] != MAGICBYTE) {
- (*mdp->abortfunc) ();
+ mdp->abortfunc();
}
}
}
if (mdp->mrealloc_hook != NULL) {
- return ((*mdp->mrealloc_hook) (md, ptr, size));
+ return mdp->mrealloc_hook(md, ptr, size);
}
block = BLOCK(ptr);
if (mat) {
if (mat->free_f) {
for (i = 0; i < (mat->lines * mat->rows); i++) {
- (*(mat->free_f)) ((void *) &(mat->data[i * mat->elmsize]));
+ mat->free_f((void *) &(mat->data[i * mat->elmsize]));
}
}
free(mat->data);
fprintf(stderr, " (%d,%d)=", i, j);
else
fprintf(stderr, " ");
- (*display_fun) (xbt_matrix_get_ptr(matrix, i, j));
+ display_fun(xbt_matrix_get_ptr(matrix, i, j));
}
fprintf(stderr, "\n");
}
if (cpy_f) {
for (j = 0; j < lsize; j++)
xbt_matrix_get_as(dst, j + lpos_dst, i + rpos_dst, void *) =
- (*cpy_f) (xbt_matrix_get_ptr(src, j + rpos_src, i + lpos_src));
+ cpy_f(xbt_matrix_get_ptr(src, j + rpos_src, i + lpos_src));
} else {
memcpy(xbt_matrix_get_ptr(dst, lpos_dst, i + rpos_dst),
xbt_matrix_get_ptr(src, lpos_src, i + rpos_src),
THROWF(system_error, errcode,
"pthread_setspecific failed for xbt_self_thread_key");
- void *res = (*(t->start_routine)) (t->param);
+ void *res = t->start_routine(t->param);
if (t->detached)
xbt_os_thread_free_thread_data(t);
return res;
{
xbt_thread_t t = (xbt_thread_t) p;
XBT_DEBUG("I'm thread %p", p);
- (*t->code) (t->userparam);
+ t->code(t->userparam);
return NULL;
}
xbt_thread_t t =
(xbt_thread_t) SIMIX_process_self_get_data();
SIMIX_req_process_set_data(SIMIX_process_self(), t->father_data);
- (*t->code) (t->userparam);
+ t->code(t->userparam);
if (t->joinable) {
t->done = 1;
xbt_mutex_acquire(t->mutex);
static void worker_wrapper(void *w)
{
worker_data_t me = (worker_data_t) w;
- (*me->function) (me->rank, xbt_dynar_get_ptr(me->data, me->rank));
+ me->function(me->rank, xbt_dynar_get_ptr(me->data, me->rank));
}
void xbt_dynar_dopar(xbt_dynar_t datas, void_f_int_pvoid_t function)
return; /* nothing to do */
if (xbt_dynar_length(datas) == 1) {
/* don't start any new thread, do it directly */
- (*function) (0, xbt_dynar_get_ptr(datas, 0));
+ function(0, xbt_dynar_get_ptr(datas, 0));
return;
}
/* Start all workers */