From: mquinson Date: Tue, 2 Nov 2004 11:35:19 +0000 (+0000) Subject: The change Arnaud wanted so much: Big Star Eradication (plus some more, check the... X-Git-Tag: v3.3~4899 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/421e2f7dd584b6aa936de631a730fb3b21ca7565 The change Arnaud wanted so much: Big Star Eradication (plus some more, check the changelog) git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@451 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- diff --git a/src/gras/DataDesc/cbps.c b/src/gras/DataDesc/cbps.c index a36c2eb961..f63f19bb10 100644 --- a/src/gras/DataDesc/cbps.c +++ b/src/gras/DataDesc/cbps.c @@ -12,18 +12,18 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(ddt_cbps,datadesc,"callback persistant state"); typedef struct { - gras_datadesc_type_t *type; + gras_datadesc_type_t type; void *data; -} gras_cbps_elm_t; +} s_gras_cbps_elm_t, *gras_cbps_elm_t; -struct s_gras_cbps { - gras_dynar_t *lints; /* simple stack of long integers (easy interface) */ +typedef struct s_gras_cbps { + gras_dynar_t lints; /* simple stack of long integers (easy interface) */ - gras_dict_t *space; /* varname x dynar of gras_cbps_elm_t */ - gras_dynar_t *frames; /* of dynar of names defined within this frame + gras_dict_t space; /* varname x dynar of gras_cbps_elm_t */ + gras_dynar_t frames; /* of dynar of names defined within this frame (and to pop when we leave it) */ - gras_dynar_t *globals; -}; + gras_dynar_t globals; +} s_gras_cbps_t; static void free_string(void *d); @@ -31,16 +31,16 @@ static void free_string(void *d){ gras_free(*(void**)d); } -gras_cbps_t * gras_cbps_new(void) { +gras_cbps_t gras_cbps_new(void) { gras_error_t errcode; - gras_cbps_t *res; + gras_cbps_t res; - res=gras_new(gras_cbps_t,1); + res=gras_new(s_gras_cbps_t,1); res->lints = gras_dynar_new(sizeof(int), NULL); res->space = gras_dict_new(); /* no leak, the content is freed manually on block_end */ - res->frames = gras_dynar_new(sizeof(gras_dynar_t*), NULL); + res->frames = gras_dynar_new(sizeof(gras_dynar_t), NULL); res->globals = gras_dynar_new(sizeof(char*), NULL); gras_cbps_block_begin(res); @@ -48,14 +48,14 @@ gras_cbps_t * gras_cbps_new(void) { return res; } -void gras_cbps_free(gras_cbps_t **state) { +void gras_cbps_free(gras_cbps_t *state) { - gras_dynar_free( (*state)->lints ); + gras_dynar_free( &( (*state)->lints ) ); gras_cbps_block_end(*state); gras_dict_free ( &( (*state)->space ) ); - gras_dynar_free( (*state)->frames ); - gras_dynar_free( (*state)->globals ); + gras_dynar_free( &( (*state)->frames ) ); + gras_dynar_free( &( (*state)->globals ) ); gras_free(*state); *state = NULL; @@ -69,13 +69,13 @@ void gras_cbps_free(gras_cbps_t **state) { * seeable again only after a pop to remove the value this push adds. */ gras_error_t -gras_cbps_v_push(gras_cbps_t *ps, - const char *name, - void *data, - gras_datadesc_type_t *ddt) { +gras_cbps_v_push(gras_cbps_t ps, + const char *name, + void *data, + gras_datadesc_type_t ddt) { - gras_dynar_t *varstack,*frame; - gras_cbps_elm_t *p_var; + gras_dynar_t varstack,frame; + gras_cbps_elm_t var; gras_error_t errcode; char *varname = (char*)strdup(name); @@ -91,11 +91,11 @@ gras_cbps_v_push(gras_cbps_t *ps, return errcode; } - p_var = gras_new0(gras_cbps_elm_t,1); - p_var->type = ddt; - p_var->data = data; + var = gras_new0(s_gras_cbps_elm_t,1); + var->type = ddt; + var->data = data; - gras_dynar_push(varstack, &p_var); + gras_dynar_push(varstack, &var); gras_dynar_pop(ps->frames, &frame); DEBUG4("Push %s (%p @%p) into frame %p",varname,(void*)varname,(void*)&varname,(void*)frame); @@ -112,13 +112,13 @@ gras_cbps_v_push(gras_cbps_t *ps, * in upper blocks since this denotes a programmation error. */ gras_error_t -gras_cbps_v_pop (gras_cbps_t *ps, - const char *name, - gras_datadesc_type_t **ddt, - void **res) { - gras_dynar_t *varstack,*frame; - gras_cbps_elm_t *var = NULL; - void *data = NULL; +gras_cbps_v_pop (gras_cbps_t ps, + const char *name, + gras_datadesc_type_t *ddt, + void **res) { + gras_dynar_t varstack,frame; + gras_cbps_elm_t var = NULL; + void *data = NULL; gras_error_t errcode; DEBUG1("pop(%s)",name); @@ -133,7 +133,7 @@ gras_cbps_v_pop (gras_cbps_t *ps, if (!gras_dynar_length(varstack)) { DEBUG1("Last incarnation of %s poped. Kill it",name); gras_dict_remove(ps->space, name); - gras_dynar_free(varstack); + gras_dynar_free(&varstack); } if (ddt) @@ -175,32 +175,32 @@ gras_cbps_v_pop (gras_cbps_t *ps, * its value is changed. */ void -gras_cbps_v_set (gras_cbps_t *ps, - const char *name, - void *data, - gras_datadesc_type_t *ddt) { - - gras_dynar_t *p_dynar = NULL; - gras_cbps_elm_t *p_elm = NULL; - gras_error_t errcode; +gras_cbps_v_set (gras_cbps_t ps, + const char *name, + void *data, + gras_datadesc_type_t ddt) { + + gras_dynar_t dynar = NULL; + gras_cbps_elm_t elm = NULL; + gras_error_t errcode; DEBUG1("set(%s)",name); - errcode = gras_dict_get(ps->space, name, (void **)&p_dynar); + errcode = gras_dict_get(ps->space, name, (void **)&dynar); if (errcode == mismatch_error) { - p_dynar = gras_dynar_new(sizeof (gras_cbps_elm_t *), NULL); - gras_dict_set(ps->space, name, (void **)p_dynar, NULL); + dynar = gras_dynar_new(sizeof (gras_cbps_elm_t), NULL); + gras_dict_set(ps->space, name, (void **)dynar, NULL); - p_elm = gras_new0(gras_cbps_elm_t,1); + elm = gras_new0(s_gras_cbps_elm_t,1); gras_dynar_push(ps->globals, &name); } else { - gras_dynar_pop(p_dynar, &p_elm); + gras_dynar_pop(dynar, &elm); } - p_elm->type = ddt; - p_elm->data = data; + elm->type = ddt; + elm->data = data; - gras_dynar_push(p_dynar, &p_elm); + gras_dynar_push(dynar, &elm); } @@ -214,24 +214,24 @@ gras_cbps_v_set (gras_cbps_t *ps, * If not present there neither, the code may segfault (Oli?). */ void * -gras_cbps_v_get (gras_cbps_t *ps, - const char *name, - gras_datadesc_type_t **ddt) { +gras_cbps_v_get (gras_cbps_t ps, + const char *name, + /* OUT */gras_datadesc_type_t *ddt) { - gras_dynar_t *p_dynar = NULL; - gras_cbps_elm_t *p_elm = NULL; + gras_dynar_t dynar = NULL; + gras_cbps_elm_t elm = NULL; DEBUG1("get(%s)",name); /* FIXME: Error handling */ - gras_dict_get(ps->space, name, (void **)&p_dynar); - gras_dynar_pop(p_dynar, &p_elm); - gras_dynar_push(p_dynar, &p_elm); + gras_dict_get(ps->space, name, (void **)&dynar); + gras_dynar_pop(dynar, &elm); + gras_dynar_push(dynar, &elm); if (ddt) { - *ddt = p_elm->type; + *ddt = elm->type; } - return p_elm->data; + return elm->data; } @@ -250,26 +250,26 @@ gras_cbps_v_get (gras_cbps_t *ps, */ void -gras_cbps_block_begin(gras_cbps_t *ps) { +gras_cbps_block_begin(gras_cbps_t ps) { - gras_dynar_t *p_dynar = NULL; + gras_dynar_t dynar = NULL; DEBUG0(">>> Block begin"); - p_dynar = gras_dynar_new(sizeof (char *), NULL); - gras_dynar_push(ps->frames, &p_dynar); + dynar = gras_dynar_new(sizeof (char *), NULL); + gras_dynar_push(ps->frames, &dynar); } /** - * gras_cbps_block_begin: + * gras_cbps_block_end: * * End the current block, and go back to the upper one. */ void -gras_cbps_block_end(gras_cbps_t *ps) { +gras_cbps_block_end(gras_cbps_t ps) { - gras_dynar_t *frame = NULL; - int cursor = 0; - char *name = NULL; + gras_dynar_t frame = NULL; + int cursor = 0; + char *name = NULL; gras_assert0(gras_dynar_length(ps->frames), "More block_end than block_begin"); @@ -277,8 +277,8 @@ gras_cbps_block_end(gras_cbps_t *ps) { gras_dynar_foreach(frame, cursor, name) { - gras_dynar_t *varstack = NULL; - gras_cbps_elm_t *var = NULL; + gras_dynar_t varstack = NULL; + gras_cbps_elm_t var = NULL; DEBUG2("Get ride of %s (%p)",name,(void*)name); gras_dict_get(ps->space, name, (void **)&varstack); @@ -286,14 +286,14 @@ gras_cbps_block_end(gras_cbps_t *ps) { if (!gras_dynar_length(varstack)) { gras_dict_remove(ps->space, name); - gras_dynar_free_container(varstack); /*already empty, save a test ;) */ + gras_dynar_free_container(&varstack); /*already empty, save a test ;) */ } if (var->data) gras_free(var->data); gras_free(var); gras_free(name); } - gras_dynar_free_container(frame);/* we just emptied it */ + gras_dynar_free_container(&frame);/* we just emptied it */ DEBUG0("<<< Block end"); } @@ -304,11 +304,11 @@ gras_cbps_block_end(gras_cbps_t *ps) { * Push a new long integer value into the cbps. */ void -gras_cbps_i_push(gras_cbps_t *ps, +gras_cbps_i_push(gras_cbps_t ps, int val) { gras_error_t errcode; DEBUG1("push %d as a size",val); - gras_dynar_push(ps->lints,&val); + gras_dynar_push_as(ps->lints,int,val); } /** * gras_cbps_i_pop: @@ -316,12 +316,12 @@ gras_cbps_i_push(gras_cbps_t *ps, * Pop the lastly pushed long integer value from the cbps. */ int -gras_cbps_i_pop(gras_cbps_t *ps) { +gras_cbps_i_pop(gras_cbps_t ps) { int ret; gras_assert0(gras_dynar_length(ps->lints) > 0, "gras_cbps_i_pop: no value to pop"); - gras_dynar_pop(ps->lints, &ret); + ret = gras_dynar_pop_as(ps->lints,int); DEBUG1("pop %d as a size",ret); return ret; } @@ -331,7 +331,7 @@ gras_cbps_i_pop(gras_cbps_t *ps) { * * Generic cb returning the lastly pushed value */ -int gras_datadesc_cb_pop(gras_cbps_t *vars, void *data) { +int gras_datadesc_cb_pop(gras_cbps_t vars, void *data) { return gras_cbps_i_pop(vars); } @@ -340,7 +340,7 @@ int gras_datadesc_cb_pop(gras_cbps_t *vars, void *data) { * * Cb to push an integer. Must be attached to the field you want to push */ -void gras_datadesc_cb_push_int(gras_cbps_t *vars, void *data) { +void gras_datadesc_cb_push_int(gras_cbps_t vars, void *data) { int *i = (int*)data; gras_cbps_i_push(vars, (int) *i); } @@ -350,7 +350,7 @@ void gras_datadesc_cb_push_int(gras_cbps_t *vars, void *data) { * * Cb to push an unsigned integer. Must be attached to the field you want to push */ -void gras_datadesc_cb_push_uint(gras_cbps_t *vars, void *data) { +void gras_datadesc_cb_push_uint(gras_cbps_t vars, void *data) { unsigned int *i = (unsigned int*)data; gras_cbps_i_push(vars, (int) *i); } @@ -360,7 +360,7 @@ void gras_datadesc_cb_push_uint(gras_cbps_t *vars, void *data) { * * Cb to push an long integer. Must be attached to the field you want to push */ -void gras_datadesc_cb_push_lint(gras_cbps_t *vars, void *data) { +void gras_datadesc_cb_push_lint(gras_cbps_t vars, void *data) { long int *i = (long int*)data; gras_cbps_i_push(vars, (int) *i); } @@ -369,7 +369,7 @@ void gras_datadesc_cb_push_lint(gras_cbps_t *vars, void *data) { * * Cb to push an long integer. Must be attached to the field you want to push */ -void gras_datadesc_cb_push_ulint(gras_cbps_t *vars, void *data) { +void gras_datadesc_cb_push_ulint(gras_cbps_t vars, void *data) { unsigned long int *i = (unsigned long int*)data; gras_cbps_i_push(vars, (int) *i); } diff --git a/src/gras/DataDesc/datadesc.c b/src/gras/DataDesc/datadesc.c index 1b0515badf..5b2ee3733e 100644 --- a/src/gras/DataDesc/datadesc.c +++ b/src/gras/DataDesc/datadesc.c @@ -12,12 +12,12 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(datadesc,gras,"Data description"); /* FIXME: make this host-dependent using a trick such as UserData*/ -gras_set_t *gras_datadesc_set_local=NULL; +gras_set_t gras_datadesc_set_local=NULL; /* callback for array size when sending strings */ static int -_strlen_cb(gras_cbps_t *vars, void *data) { +_strlen_cb(gras_cbps_t vars, void *data) { return 1+(long int)strlen(data); } @@ -33,7 +33,7 @@ _strlen_cb(gras_cbps_t *vars, void *data) { void gras_datadesc_init(void) { gras_error_t errcode; - gras_datadesc_type_t *ddt; /* What to add */ + gras_datadesc_type_t ddt; /* What to add */ /* only initialize once */ if (gras_datadesc_set_local != NULL) @@ -123,7 +123,6 @@ void gras_datadesc_exit(void) { VERB0("Exiting DataDesc"); gras_set_free(&gras_datadesc_set_local); - gras_datadesc_set_local = NULL; DEBUG0("Exited DataDesc"); } @@ -133,7 +132,7 @@ gras_datadesc_exit(void) { * Returns the name of a datadescription (to ease the debug) */ char * -gras_datadesc_get_name(gras_datadesc_type_t *ddt) { +gras_datadesc_get_name(gras_datadesc_type_t ddt) { return ddt->name; } /** @@ -142,7 +141,7 @@ gras_datadesc_get_name(gras_datadesc_type_t *ddt) { * Returns the name of a datadescription (to ease the debug) */ int -gras_datadesc_get_id(gras_datadesc_type_t *ddt) { +gras_datadesc_get_id(gras_datadesc_type_t ddt) { return ddt->code; } @@ -152,7 +151,7 @@ gras_datadesc_get_id(gras_datadesc_type_t *ddt) { * Returns the size occuped by data of this type (on the current arch). * */ -int gras_datadesc_size(gras_datadesc_type_t *type) { +int gras_datadesc_size(gras_datadesc_type_t type) { return type->size[GRAS_THISARCH]; } @@ -161,7 +160,7 @@ int gras_datadesc_size(gras_datadesc_type_t *type) { * * For debugging purpose */ -void gras_datadesc_type_dump(const gras_datadesc_type_t *ddt){ +void gras_datadesc_type_dump(const gras_datadesc_type_t ddt){ int cpt; printf("DataDesc dump:"); @@ -202,8 +201,8 @@ void gras_datadesc_type_dump(const gras_datadesc_type_t *ddt){ } printf ("]\n"); if (ddt->category_code == e_gras_datadesc_type_cat_struct) { - gras_dd_cat_struct_t struct_data; - gras_dd_cat_field_t *field; + gras_dd_cat_struct_t struct_data; + gras_dd_cat_field_t field; struct_data = ddt->category.struct_data; gras_dynar_foreach(struct_data.fields, cpt, field) { diff --git a/src/gras/DataDesc/datadesc_interface.h b/src/gras/DataDesc/datadesc_interface.h index a841f1800f..b0b71dfcda 100644 --- a/src/gras/DataDesc/datadesc_interface.h +++ b/src/gras/DataDesc/datadesc_interface.h @@ -14,27 +14,24 @@ #define GRAS_DATADESC_INTERFACE_H gras_error_t gras_datadesc_by_id (long int code, - gras_datadesc_type_t **type); + gras_datadesc_type_t *type); /* to debug */ -void gras_datadesc_type_dump(const gras_datadesc_type_t *ddt); +void gras_datadesc_type_dump(const gras_datadesc_type_t ddt); const char *gras_datadesc_arch_name(int code); /* compare two data type description */ int -gras_datadesc_type_cmp(const gras_datadesc_type_t *d1, - const gras_datadesc_type_t *d2); +gras_datadesc_type_cmp(const gras_datadesc_type_t d1, + const gras_datadesc_type_t d2); /* Access function */ -int gras_datadesc_size(gras_datadesc_type_t *type); +int gras_datadesc_size(gras_datadesc_type_t type); /* Described data exchanges */ -gras_error_t -gras_datadesc_cpy(gras_datadesc_type_t *type, void *src, void **dst); -gras_error_t -gras_datadesc_send(gras_socket_t *sock, gras_datadesc_type_t *type, void *src); -gras_error_t -gras_datadesc_recv(gras_socket_t *sock, gras_datadesc_type_t *type, - int r_arch, void *dst); +gras_error_t gras_datadesc_cpy(gras_datadesc_type_t type, void *src, void **dst); +gras_error_t gras_datadesc_send(gras_socket_t sock, gras_datadesc_type_t type, void *src); +gras_error_t gras_datadesc_recv(gras_socket_t sock, gras_datadesc_type_t type, + int r_arch, void *dst); #endif /* GRAS_DATADESC_INTERFACE_H */ diff --git a/src/gras/DataDesc/datadesc_private.h b/src/gras/DataDesc/datadesc_private.h index 6350d6b638..cdb0935877 100644 --- a/src/gras/DataDesc/datadesc_private.h +++ b/src/gras/DataDesc/datadesc_private.h @@ -36,7 +36,7 @@ */ #define aligned(v, a) (((v) + (a - 1)) & ~(a - 1)) -extern gras_set_t *gras_datadesc_set_local; +extern gras_set_t gras_datadesc_set_local; void gras_ddt_freev(void *ddt); /******************************************* * Descriptions of all known architectures * @@ -108,12 +108,12 @@ typedef struct s_gras_dd_cat_field { char *name; long int offset[gras_arch_count]; - gras_datadesc_type_t *type; + gras_datadesc_type_t type; gras_datadesc_type_cb_void_t pre; gras_datadesc_type_cb_void_t post; -} gras_dd_cat_field_t; +} s_gras_dd_cat_field_t,*gras_dd_cat_field_t; void gras_dd_cat_field_free(void *f); @@ -142,7 +142,7 @@ typedef struct s_gras_dd_cat_scalar { * Specific fields of a struct */ typedef struct s_gras_dd_cat_struct { - gras_dynar_t *fields; /* elm type = gras_dd_cat_field_t */ + gras_dynar_t fields; /* elm type = gras_dd_cat_field_t */ int closed; /* gras_datadesc_declare_struct_close() was called */ } gras_dd_cat_struct_t; @@ -153,7 +153,7 @@ typedef struct s_gras_dd_cat_struct { */ typedef struct s_gras_dd_cat_union { gras_datadesc_type_cb_int_t selector; - gras_dynar_t *fields; /* elm type = gras_dd_cat_field_t */ + gras_dynar_t fields; /* elm type = gras_dd_cat_field_t */ int closed; /* gras_datadesc_declare_union_close() was called */ } gras_dd_cat_union_t; @@ -163,7 +163,7 @@ typedef struct s_gras_dd_cat_union { * Specific fields of a reference */ typedef struct s_gras_dd_cat_ref { - gras_datadesc_type_t *type; + gras_datadesc_type_t type; /* callback used to return the referenced type number */ gras_datadesc_selector_t selector; @@ -176,7 +176,7 @@ typedef struct s_gras_dd_cat_ref { * Specific fields of an array */ typedef struct s_gras_dd_cat_array { - gras_datadesc_type_t *type; + gras_datadesc_type_t type; /* element_count == 0 means dynamically defined */ unsigned long int fixed_size; @@ -221,7 +221,7 @@ union u_gras_datadesc_category { * * Type descriptor. */ -struct s_gras_datadesc_type { +typedef struct s_gras_datadesc_type { /* headers for the data set */ unsigned int code; char *name; @@ -240,14 +240,14 @@ struct s_gras_datadesc_type { gras_datadesc_type_cb_void_t recv; int cycle; /* true if the datatype may contain cycle */ -}; +} s_gras_datadesc_type_t; /*************************** * constructor/desctructor * ***************************/ void gras_datadesc_free(gras_datadesc_type_t *type); -gras_datadesc_type_t * +gras_datadesc_type_t gras_datadesc_scalar(const char *name, gras_ddt_scalar_type_t type, enum e_gras_dd_scalar_encoding encoding); @@ -255,14 +255,14 @@ gras_datadesc_type_t * /**************************************************** * Callback persistant state constructor/destructor * ****************************************************/ -gras_cbps_t *gras_cbps_new(void); -void gras_cbps_free(gras_cbps_t **state); +gras_cbps_t gras_cbps_new(void); +void gras_cbps_free(gras_cbps_t *state); /*************** * Convertions * ***************/ gras_error_t -gras_dd_convert_elm(gras_datadesc_type_t *type, int count, +gras_dd_convert_elm(gras_datadesc_type_t type, int count, int r_arch, void *src, void *dst); diff --git a/src/gras/DataDesc/ddt_convert.c b/src/gras/DataDesc/ddt_convert.c index a5da480753..949c691775 100644 --- a/src/gras/DataDesc/ddt_convert.c +++ b/src/gras/DataDesc/ddt_convert.c @@ -69,7 +69,7 @@ gras_dd_reverse_bytes(void *to, * Both pointers may be the same location if no resizing is needed. */ gras_error_t -gras_dd_convert_elm(gras_datadesc_type_t *type, int count, +gras_dd_convert_elm(gras_datadesc_type_t type, int count, int r_arch, void *src, void *dst) { gras_dd_cat_scalar_t scal = type->category.scalar_data; diff --git a/src/gras/DataDesc/ddt_create.c b/src/gras/DataDesc/ddt_create.c index d7e021d558..1d49562047 100644 --- a/src/gras/DataDesc/ddt_create.c +++ b/src/gras/DataDesc/ddt_create.c @@ -19,26 +19,26 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(ddt_create,datadesc,"Creating new datadescripti * gime that memory back, dude. I mean it. */ void gras_ddt_freev(void *ddt) { - gras_datadesc_type_t *type= (gras_datadesc_type_t *)ddt; + gras_datadesc_type_t type= (gras_datadesc_type_t)ddt; if (type) { - gras_datadesc_free(type); + gras_datadesc_free(&type); } } -static gras_datadesc_type_t *gras_ddt_new(const char *name) { +static gras_datadesc_type_t gras_ddt_new(const char *name) { gras_error_t errcode; - gras_datadesc_type_t *res; + gras_datadesc_type_t res; GRAS_IN1("(%s)",name); - res=gras_new0(gras_datadesc_type_t,1); + res=gras_new0(s_gras_datadesc_type_t,1); res->name = (char*)strdup(name); res->name_len = strlen(name); res->cycle = 0; gras_set_add(gras_datadesc_set_local, - (gras_set_elm_t*)res,&gras_ddt_freev); + (gras_set_elm_t)res,&gras_ddt_freev); GRAS_OUT; return res; } @@ -48,13 +48,13 @@ static gras_datadesc_type_t *gras_ddt_new(const char *name) { * * Retrieve a type from its name */ -gras_datadesc_type_t *gras_datadesc_by_name(const char *name) { +gras_datadesc_type_t gras_datadesc_by_name(const char *name) { - gras_datadesc_type_t *type; + gras_datadesc_type_t type; GRAS_IN1("(%s)",name); if (gras_set_get_by_name(gras_datadesc_set_local, - name,(gras_set_elm_t**)&type) == no_error) { + name,(gras_set_elm_t*)&type) == no_error) { GRAS_OUT; return type; } else { @@ -68,11 +68,11 @@ gras_datadesc_type_t *gras_datadesc_by_name(const char *name) { * * Retrieve a type from its code */ -gras_error_t gras_datadesc_by_id(long int code, - gras_datadesc_type_t **type) { +gras_error_t gras_datadesc_by_id(long int code, + gras_datadesc_type_t *type) { GRAS_IN; return gras_set_get_by_id(gras_datadesc_set_local, - code,(gras_set_elm_t**)type); + code,(gras_set_elm_t*)type); } /** @@ -80,12 +80,12 @@ gras_error_t gras_datadesc_by_id(long int code, * * Create a new scalar and give a pointer to it */ -gras_datadesc_type_t * +gras_datadesc_type_t gras_datadesc_scalar(const char *name, gras_ddt_scalar_type_t type, enum e_gras_dd_scalar_encoding encoding) { - gras_datadesc_type_t *res; + gras_datadesc_type_t res; long int arch; GRAS_IN; @@ -156,7 +156,7 @@ gras_datadesc_type_t * * Frees one struct or union field */ void gras_dd_cat_field_free(void *f) { - gras_dd_cat_field_t *field = *(gras_dd_cat_field_t **)f; + gras_dd_cat_field_t field = *(gras_dd_cat_field_t *)f; GRAS_IN; if (field) { if (field->name) @@ -171,11 +171,11 @@ void gras_dd_cat_field_free(void *f) { * * Create a new struct and give a pointer to it */ -gras_datadesc_type_t * +gras_datadesc_type_t gras_datadesc_struct(const char *name) { gras_error_t errcode; - gras_datadesc_type_t *res; + gras_datadesc_type_t res; long int arch; GRAS_IN1("(%s)",name); @@ -196,7 +196,7 @@ gras_datadesc_type_t * } res->category_code = e_gras_datadesc_type_cat_struct; res->category.struct_data.fields = - gras_dynar_new(sizeof(gras_dd_cat_field_t*), + gras_dynar_new(sizeof(gras_dd_cat_field_t), &gras_dd_cat_field_free); GRAS_OUT; @@ -209,14 +209,17 @@ gras_datadesc_type_t * * Append a field to the struct */ void -gras_datadesc_struct_append(gras_datadesc_type_t *struct_type, - const char *name, - gras_datadesc_type_t *field_type) { +gras_datadesc_struct_append(gras_datadesc_type_t struct_type, + const char *name, + gras_datadesc_type_t field_type) { gras_error_t errcode; - gras_dd_cat_field_t *field; + gras_dd_cat_field_t field; int arch; + gras_assert2(field_type, + "Cannot add the field '%s' into struct '%s': its type is NULL. Typo in get_by_name?", + name,struct_type->name); GRAS_IN3("(%s %s.%s;)",field_type->name,struct_type->name,name); if (struct_type->category.struct_data.closed) { VERB1("Ignoring request to add field to struct %s (closed. Redefinition?)", @@ -228,7 +231,7 @@ gras_datadesc_struct_append(gras_datadesc_type_t *struct_type, "Cannot add a dynamically sized field in structure %s", struct_type->name); - field=gras_new(gras_dd_cat_field_t,1); + field=gras_new(s_gras_dd_cat_field_t,1); field->name = (char*)strdup(name); DEBUG0("----------------"); @@ -268,7 +271,7 @@ gras_datadesc_struct_append(gras_datadesc_type_t *struct_type, } void -gras_datadesc_struct_close(gras_datadesc_type_t *struct_type) { +gras_datadesc_struct_close(gras_datadesc_type_t struct_type) { GRAS_IN; struct_type->category.struct_data.closed = 1; } @@ -283,7 +286,7 @@ gras_datadesc_struct_close(gras_datadesc_type_t *struct_type) { * on the performance (several times slower on big data). */ void -gras_datadesc_cycle_set(gras_datadesc_type_t *ddt) { +gras_datadesc_cycle_set(gras_datadesc_type_t ddt) { ddt->cycle = 1; } /** @@ -294,7 +297,7 @@ gras_datadesc_cycle_set(gras_datadesc_type_t *ddt) { * (default) */ void -gras_datadesc_cycle_unset(gras_datadesc_type_t *ddt) { +gras_datadesc_cycle_unset(gras_datadesc_type_t ddt) { ddt->cycle = 0; } @@ -303,12 +306,12 @@ gras_datadesc_cycle_unset(gras_datadesc_type_t *ddt) { * * Create a new union and give a pointer to it */ -gras_datadesc_type_t * +gras_datadesc_type_t gras_datadesc_union(const char *name, gras_datadesc_type_cb_int_t selector) { gras_error_t errcode; - gras_datadesc_type_t *res; + gras_datadesc_type_t res; int arch; GRAS_IN1("(%s)",name); @@ -349,11 +352,11 @@ gras_datadesc_union(const char *name, * Append a field to the union */ void -gras_datadesc_union_append(gras_datadesc_type_t *union_type, - const char *name, - gras_datadesc_type_t *field_type) { +gras_datadesc_union_append(gras_datadesc_type_t union_type, + const char *name, + gras_datadesc_type_t field_type) { - gras_dd_cat_field_t *field; + gras_dd_cat_field_t field; int arch; GRAS_IN3("(%s %s.%s;)",field_type->name,union_type->name,name); @@ -367,7 +370,7 @@ gras_datadesc_union_append(gras_datadesc_type_t *union_type, return; } - field=gras_new0(gras_dd_cat_field_t,1); + field=gras_new0(s_gras_dd_cat_field_t,1); field->name = (char*)strdup(name); field->type = field_type; @@ -386,7 +389,7 @@ gras_datadesc_union_append(gras_datadesc_type_t *union_type, } void -gras_datadesc_union_close(gras_datadesc_type_t *union_type) { +gras_datadesc_union_close(gras_datadesc_type_t union_type) { union_type->category.union_data.closed = 1; } /** @@ -394,13 +397,13 @@ gras_datadesc_union_close(gras_datadesc_type_t *union_type) { * * Create a new ref to a fixed type and give a pointer to it */ -gras_datadesc_type_t * - gras_datadesc_ref(const char *name, - gras_datadesc_type_t *referenced_type) { +gras_datadesc_type_t + gras_datadesc_ref(const char *name, + gras_datadesc_type_t referenced_type) { gras_error_t errcode; - gras_datadesc_type_t *res; - gras_datadesc_type_t *pointer_type = gras_datadesc_by_name("data pointer"); + gras_datadesc_type_t res; + gras_datadesc_type_t pointer_type = gras_datadesc_by_name("data pointer"); int arch; GRAS_IN1("(%s)",name); @@ -437,12 +440,12 @@ gras_datadesc_type_t * * * Create a new ref to a type given at use time, and give a pointer to it */ -gras_datadesc_type_t * +gras_datadesc_type_t gras_datadesc_ref_generic(const char *name, gras_datadesc_selector_t selector) { - gras_datadesc_type_t *res; - gras_datadesc_type_t *pointer_type = gras_datadesc_by_name("data pointer"); + gras_datadesc_type_t res; + gras_datadesc_type_t pointer_type = gras_datadesc_by_name("data pointer"); int arch; GRAS_IN1("(%s)",name); @@ -480,12 +483,12 @@ gras_datadesc_type_t * * * Create a new array and give a pointer to it */ -gras_datadesc_type_t * - gras_datadesc_array_fixed(const char *name, - gras_datadesc_type_t *element_type, - long int fixed_size) { +gras_datadesc_type_t + gras_datadesc_array_fixed(const char *name, + gras_datadesc_type_t element_type, + long int fixed_size) { - gras_datadesc_type_t *res; + gras_datadesc_type_t res; int arch; GRAS_IN1("(%s)",name); @@ -525,12 +528,12 @@ gras_datadesc_type_t * * * Create a new array and give a pointer to it */ -gras_datadesc_type_t * - gras_datadesc_array_dyn(const char *name, - gras_datadesc_type_t *element_type, - gras_datadesc_type_cb_int_t dynamic_size) { +gras_datadesc_type_t + gras_datadesc_array_dyn(const char *name, + gras_datadesc_type_t element_type, + gras_datadesc_type_cb_int_t dynamic_size) { - gras_datadesc_type_t *res; + gras_datadesc_type_t res; int arch; GRAS_IN1("(%s)",name); @@ -593,10 +596,10 @@ gras_datadesc_type_t * * list when the first field gets transfered. * */ -gras_datadesc_type_t * - gras_datadesc_ref_pop_arr(gras_datadesc_type_t *element_type) { +gras_datadesc_type_t + gras_datadesc_ref_pop_arr(gras_datadesc_type_t element_type) { - gras_datadesc_type_t *res; + gras_datadesc_type_t res; char *name=(char*)gras_malloc(strlen(element_type->name) + 4); sprintf(name,"%s[]",element_type->name); @@ -614,8 +617,8 @@ gras_datadesc_type_t * gras_error_t gras_datadesc_import_nws(const char *name, const DataDescriptor *desc, - size_t howmany, - gras_datadesc_type_t **dst) { + unsigned long howmany, + /* OUT */ gras_datadesc_type_t *dst) { RAISE_UNIMPLEMENTED; } @@ -625,7 +628,7 @@ gras_datadesc_import_nws(const char *name, * Add a pre-send callback to this datadesc. * (useful to push the sizes of the upcoming arrays, for example) */ -void gras_datadesc_cb_send (gras_datadesc_type_t *type, +void gras_datadesc_cb_send (gras_datadesc_type_t type, gras_datadesc_type_cb_void_t send) { type->send = send; } @@ -635,7 +638,7 @@ void gras_datadesc_cb_send (gras_datadesc_type_t *type, * Add a post-receive callback to this datadesc. * (useful to put the function pointers to the rigth value, for example) */ -void gras_datadesc_cb_recv(gras_datadesc_type_t *type, +void gras_datadesc_cb_recv(gras_datadesc_type_t type, gras_datadesc_type_cb_void_t recv) { type->recv = recv; } @@ -644,14 +647,14 @@ void gras_datadesc_cb_recv(gras_datadesc_type_t *type, * * Returns the type descriptor of the given field. Abort on error. */ -static gras_datadesc_type_t * - gras_dd_find_field(gras_datadesc_type_t *type, - const char *field_name) { - gras_datadesc_type_t *sub_type=NULL; - gras_dynar_t *field_array; +static gras_datadesc_type_t + gras_dd_find_field(gras_datadesc_type_t type, + const char *field_name) { + gras_datadesc_type_t sub_type=NULL; + gras_dynar_t field_array; - gras_dd_cat_field_t *field=NULL; - int field_num; + gras_dd_cat_field_t field=NULL; + int field_num; if (type->category_code == e_gras_datadesc_type_cat_union) { field_array = type->category.union_data.fields; @@ -677,11 +680,11 @@ static gras_datadesc_type_t * * Add a pre-send callback to the given field of the datadesc (which must be a struct or union). * (useful to push the sizes of the upcoming arrays, for example) */ -void gras_datadesc_cb_field_send (gras_datadesc_type_t *type, +void gras_datadesc_cb_field_send (gras_datadesc_type_t type, const char *field_name, gras_datadesc_type_cb_void_t send) { - gras_datadesc_type_t *sub_type=gras_dd_find_field(type,field_name); + gras_datadesc_type_t sub_type=gras_dd_find_field(type,field_name); sub_type->send = send; } @@ -691,10 +694,10 @@ void gras_datadesc_cb_field_send (gras_datadesc_type_t *type, * Add a pre-send callback to the given field resulting in its value to be pushed to * the stack of sizes. It must be a int, unsigned int, long int or unsigned long int. */ -void gras_datadesc_cb_field_push (gras_datadesc_type_t *type, - const char *field_name) { +void gras_datadesc_cb_field_push (gras_datadesc_type_t type, + const char *field_name) { - gras_datadesc_type_t *sub_type=gras_dd_find_field(type,field_name); + gras_datadesc_type_t sub_type=gras_dd_find_field(type,field_name); if (!strcmp("int",sub_type->name)) { sub_type->send = gras_datadesc_cb_push_int; } else if (!strcmp("unsigned int",sub_type->name)) { @@ -715,11 +718,11 @@ void gras_datadesc_cb_field_push (gras_datadesc_type_t *type, * Add a post-receive callback to the given field of the datadesc (which must be a struct or union). * (useful to put the function pointers to the right value, for example) */ -void gras_datadesc_cb_field_recv(gras_datadesc_type_t *type, +void gras_datadesc_cb_field_recv(gras_datadesc_type_t type, const char *field_name, gras_datadesc_type_cb_void_t recv) { - gras_datadesc_type_t *sub_type=gras_dd_find_field(type,field_name); + gras_datadesc_type_t sub_type=gras_dd_find_field(type,field_name); sub_type->recv = recv; } @@ -730,9 +733,9 @@ void gras_datadesc_cb_field_recv(gras_datadesc_type_t *type, */ void gras_datadesc_free(gras_datadesc_type_t *type) { - DEBUG1("Let's free ddt %s",type->name); + DEBUG1("Let's free ddt %s",(*type)->name); - switch (type->category_code) { + switch ((*type)->category_code) { case e_gras_datadesc_type_cat_scalar: case e_gras_datadesc_type_cat_ref: case e_gras_datadesc_type_cat_array: @@ -740,24 +743,25 @@ void gras_datadesc_free(gras_datadesc_type_t *type) { break; case e_gras_datadesc_type_cat_ignored: - if (type->category.ignored_data.free_func) { - type->category.ignored_data.free_func - (type->category.ignored_data.default_value); + if ((*type)->category.ignored_data.free_func) { + (*type)->category.ignored_data.free_func + ((*type)->category.ignored_data.default_value); } break; case e_gras_datadesc_type_cat_struct: - gras_dynar_free(type->category.struct_data.fields); + gras_dynar_free(&( (*type)->category.struct_data.fields )); break; case e_gras_datadesc_type_cat_union: - gras_dynar_free(type->category.union_data.fields); + gras_dynar_free(&( (*type)->category.union_data.fields )); break; default: /* datadesc was invalid. Killing it is like euthanasy, I guess */ break; } - gras_free(type->name); - gras_free(type); + gras_free((*type)->name); + gras_free(*type); + type=NULL; } diff --git a/src/gras/DataDesc/ddt_exchange.c b/src/gras/DataDesc/ddt_exchange.c index f132161fed..ffa1013830 100644 --- a/src/gras/DataDesc/ddt_exchange.c +++ b/src/gras/DataDesc/ddt_exchange.c @@ -18,13 +18,13 @@ const char *gras_datadesc_cat_names[9] = { "scalar", "struct", "union", "ref", "array", "ignored", "invalid"}; -static gras_datadesc_type_t *int_type = NULL; -static gras_datadesc_type_t *pointer_type = NULL; -static _GRAS_INLINE gras_error_t gras_dd_send_int(gras_socket_t *sock, int i); -static _GRAS_INLINE gras_error_t gras_dd_recv_int(gras_socket_t *sock, int r_arch, int *i); +static gras_datadesc_type_t int_type = NULL; +static gras_datadesc_type_t pointer_type = NULL; +static _GRAS_INLINE gras_error_t gras_dd_send_int(gras_socket_t sock, int i); +static _GRAS_INLINE gras_error_t gras_dd_recv_int(gras_socket_t sock, int r_arch, int *i); static _GRAS_INLINE gras_error_t -gras_dd_alloc_ref(gras_dict_t *refs, long int size, +gras_dd_alloc_ref(gras_dict_t refs, long int size, char **r_ref, long int r_len, char **l_ref, int detect_cycle); @@ -32,17 +32,17 @@ static _GRAS_INLINE int gras_dd_is_r_null(char **r_ptr, long int length); static gras_error_t -gras_datadesc_send_rec(gras_socket_t *sock, - gras_cbps_t *state, - gras_dict_t *refs, - gras_datadesc_type_t *type, +gras_datadesc_send_rec(gras_socket_t sock, + gras_cbps_t state, + gras_dict_t refs, + gras_datadesc_type_t type, char *data, int detect_cycle); static gras_error_t -gras_datadesc_recv_rec(gras_socket_t *sock, - gras_cbps_t *state, - gras_dict_t *refs, - gras_datadesc_type_t *type, +gras_datadesc_recv_rec(gras_socket_t sock, + gras_cbps_t state, + gras_dict_t refs, + gras_datadesc_type_t type, int r_arch, char **r_data, long int r_lgr, @@ -52,7 +52,7 @@ gras_datadesc_recv_rec(gras_socket_t *sock, static _GRAS_INLINE gras_error_t -gras_dd_send_int(gras_socket_t *sock,int i) { +gras_dd_send_int(gras_socket_t sock,int i) { if (!int_type) { int_type = gras_datadesc_by_name("int"); @@ -64,7 +64,7 @@ gras_dd_send_int(gras_socket_t *sock,int i) { } static _GRAS_INLINE gras_error_t -gras_dd_recv_int(gras_socket_t *sock, int r_arch, int *i) { +gras_dd_recv_int(gras_socket_t sock, int r_arch, int *i) { gras_error_t errcode; if (!int_type) { @@ -108,7 +108,7 @@ gras_dd_is_r_null(char **r_ptr, long int length) { } static _GRAS_INLINE gras_error_t -gras_dd_alloc_ref(gras_dict_t *refs, +gras_dd_alloc_ref(gras_dict_t refs, long int size, char **r_ref, long int r_len, /* pointer_type->size[r_arch] */ @@ -128,12 +128,13 @@ gras_dd_alloc_ref(gras_dict_t *refs, gras_error_t errcode; void *ptr = gras_malloc(sizeof(void *)); + CRITICAL0("detect_cycle"); memcpy(ptr,l_ref, sizeof(void *)); DEBUG2("Insert %p under %p",*(void**)ptr, *(void**)r_ref); if (detect_cycle) - gras_dict_set_ext(refs,(const char *) r_ref, r_len, ptr, gras_free); + gras_dict_set_ext(refs,(const char *) r_ref, r_len, ptr, gras_free_fct); } return no_error; } @@ -146,11 +147,11 @@ gras_dd_alloc_ref(gras_dict_t *refs, * This comparison does not take the set headers into account (name and ID), * but only the payload (actual type description). */ -int gras_datadesc_type_cmp(const gras_datadesc_type_t *d1, - const gras_datadesc_type_t *d2) { +int gras_datadesc_type_cmp(const gras_datadesc_type_t d1, + const gras_datadesc_type_t d2) { int ret,cpt; - gras_dd_cat_field_t *field1,*field2; - gras_datadesc_type_t *field_desc_1,*field_desc_2; + gras_dd_cat_field_t field1,field2; + gras_datadesc_type_t field_desc_1,field_desc_2; if (d1 == d2) return 0; /* easy optimization */ @@ -228,7 +229,7 @@ int gras_datadesc_type_cmp(const gras_datadesc_type_t *d1, } gras_dynar_foreach(d1->category.struct_data.fields, cpt, field1) { - field2 = gras_dynar_get_as(d2->category.struct_data.fields, cpt, gras_dd_cat_field_t *); + field2 = gras_dynar_get_as(d2->category.struct_data.fields, cpt, gras_dd_cat_field_t); field_desc_1 = field1->type; field_desc_2 = field2->type; ret = gras_datadesc_type_cmp(field_desc_1,field_desc_2); @@ -254,7 +255,7 @@ int gras_datadesc_type_cmp(const gras_datadesc_type_t *d1, gras_dynar_foreach(d1->category.union_data.fields, cpt, field1) { - field2 = gras_dynar_get_as(d2->category.union_data.fields, cpt, gras_dd_cat_field_t *); + field2 = gras_dynar_get_as(d2->category.union_data.fields, cpt, gras_dd_cat_field_t); field_desc_1 = field1->type; field_desc_2 = field2->type; ret = gras_datadesc_type_cmp(field_desc_1,field_desc_2); @@ -302,23 +303,23 @@ int gras_datadesc_type_cmp(const gras_datadesc_type_t *d1, * to a new location, and store a pointer to it in dst. * */ -gras_error_t gras_datadesc_cpy(gras_datadesc_type_t *type, +gras_error_t gras_datadesc_cpy(gras_datadesc_type_t type, void *src, void **dst) { RAISE_UNIMPLEMENTED; } static gras_error_t -gras_datadesc_send_rec(gras_socket_t *sock, - gras_cbps_t *state, - gras_dict_t *refs, - gras_datadesc_type_t *type, +gras_datadesc_send_rec(gras_socket_t sock, + gras_cbps_t state, + gras_dict_t refs, + gras_datadesc_type_t type, char *data, int detect_cycle) { - gras_error_t errcode; - int cpt; - gras_datadesc_type_t *sub_type; /* type on which we recurse */ + gras_error_t errcode; + int cpt; + gras_datadesc_type_t sub_type; /* type on which we recurse */ VERB2("Send a %s (%s)", type->name, gras_datadesc_cat_names[type->category_code]); @@ -333,9 +334,9 @@ gras_datadesc_send_rec(gras_socket_t *sock, break; case e_gras_datadesc_type_cat_struct: { - gras_dd_cat_struct_t struct_data; - gras_dd_cat_field_t *field; - char *field_data; + gras_dd_cat_struct_t struct_data; + gras_dd_cat_field_t field; + char *field_data; struct_data = type->category.struct_data; gras_assert1(struct_data.closed, @@ -363,9 +364,9 @@ gras_datadesc_send_rec(gras_socket_t *sock, } case e_gras_datadesc_type_cat_union: { - gras_dd_cat_union_t union_data; - gras_dd_cat_field_t *field=NULL; - int field_num; + gras_dd_cat_union_t union_data; + gras_dd_cat_field_t field=NULL; + int field_num; union_data = type->category.union_data; @@ -387,7 +388,7 @@ gras_datadesc_send_rec(gras_socket_t *sock, TRY(gras_dd_send_int(sock, field_num)); /* Send the content */ - field = gras_dynar_get_as(union_data.fields, field_num, gras_dd_cat_field_t *); + field = gras_dynar_get_as(union_data.fields, field_num, gras_dd_cat_field_t); sub_type = field->type; if (field->pre) @@ -472,6 +473,15 @@ gras_datadesc_send_rec(gras_socket_t *sock, VERB1("Array of %ld scalars, send it in one shot",count); TRY(gras_trp_chunk_send(sock, data, sub_type->aligned_size[GRAS_THISARCH] * count)); + } else if (sub_type->category_code == e_gras_datadesc_type_cat_array && + sub_type->category.array_data.fixed_size > 0 && + sub_type->category.array_data.type->category_code == e_gras_datadesc_type_cat_scalar) { + + VERB1("Array of %ld fixed array of scalars, send it in one shot",count); + TRY(gras_trp_chunk_send(sock, data, + sub_type->category.array_data.type->aligned_size[GRAS_THISARCH] + * count * sub_type->category.array_data.fixed_size)); + } else { for (cpt=0; cptcycle)); @@ -494,17 +504,17 @@ gras_datadesc_send_rec(gras_socket_t *sock, * Copy the data pointed by src and described by type to the socket * */ -gras_error_t gras_datadesc_send(gras_socket_t *sock, - gras_datadesc_type_t *type, +gras_error_t gras_datadesc_send(gras_socket_t sock, + gras_datadesc_type_t type, void *src) { gras_error_t errcode; - gras_cbps_t *state = NULL; - gras_dict_t *refs; /* all references already sent */ + gras_cbps_t state; + gras_dict_t refs; /* all references already sent */ refs = gras_dict_new(); state = gras_cbps_new(); - + errcode = gras_datadesc_send_rec(sock,state,refs,type,(char*)src, type->cycle); gras_dict_free(&refs); @@ -526,10 +536,10 @@ gras_error_t gras_datadesc_send(gras_socket_t *sock, * hack, but I was told that working code is sometimes better than neat one ;) */ gras_error_t -gras_datadesc_recv_rec(gras_socket_t *sock, - gras_cbps_t *state, - gras_dict_t *refs, - gras_datadesc_type_t *type, +gras_datadesc_recv_rec(gras_socket_t sock, + gras_cbps_t state, + gras_dict_t refs, + gras_datadesc_type_t type, int r_arch, char **r_data, long int r_lgr, @@ -537,9 +547,9 @@ gras_datadesc_recv_rec(gras_socket_t *sock, int subsize, int detect_cycle) { - gras_error_t errcode; - int cpt; - gras_datadesc_type_t *sub_type; + gras_error_t errcode; + int cpt; + gras_datadesc_type_t sub_type; VERB2("Recv a %s @%p", type->name, (void*)l_data); gras_assert(l_data); @@ -561,8 +571,8 @@ gras_datadesc_recv_rec(gras_socket_t *sock, break; case e_gras_datadesc_type_cat_struct: { - gras_dd_cat_struct_t struct_data; - gras_dd_cat_field_t *field; + gras_dd_cat_struct_t struct_data; + gras_dd_cat_field_t field; struct_data = type->category.struct_data; @@ -586,9 +596,9 @@ gras_datadesc_recv_rec(gras_socket_t *sock, } case e_gras_datadesc_type_cat_union: { - gras_dd_cat_union_t union_data; - gras_dd_cat_field_t *field=NULL; - int field_num; + gras_dd_cat_union_t union_data; + gras_dd_cat_field_t field=NULL; + int field_num; union_data = type->category.union_data; @@ -606,7 +616,7 @@ gras_datadesc_recv_rec(gras_socket_t *sock, type->name, field_num, gras_dynar_length(union_data.fields)); /* Recv the content */ - field = gras_dynar_get_as(union_data.fields, field_num, gras_dd_cat_field_t *); + field = gras_dynar_get_as(union_data.fields, field_num, gras_dd_cat_field_t); sub_type = field->type; TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type, @@ -667,7 +677,7 @@ gras_datadesc_recv_rec(gras_socket_t *sock, /* Damn. Reference to a dynamic array. Allocating the size for it is more complicated */ gras_dd_cat_array_t array_data = sub_type->category.array_data; - gras_datadesc_type_t *subsub_type; + gras_datadesc_type_t subsub_type; subsubcount = array_data.fixed_size; if (subsubcount == 0) @@ -745,6 +755,31 @@ gras_datadesc_recv_rec(gras_socket_t *sock, TRY(gras_dd_convert_elm(sub_type,count,r_arch, ptr,l_data)); gras_free(ptr); } + } else if (sub_type->category_code == e_gras_datadesc_type_cat_array && + sub_type->category.array_data.fixed_size > 0 && + sub_type->category.array_data.type->category_code == e_gras_datadesc_type_cat_scalar) { + array_data = sub_type->category.array_data; + gras_datadesc_type_t subsub_type = array_data.type; + + VERB1("Array of %d fixed array of scalars, get it in one shot",count); + if (subsub_type->aligned_size[GRAS_THISARCH] >= + subsub_type->aligned_size[r_arch]) { + TRY(gras_trp_chunk_recv(sock, (char*)l_data, + subsub_type->aligned_size[r_arch] * count * + array_data.fixed_size)); + if (r_arch != GRAS_THISARCH) + TRY(gras_dd_convert_elm(subsub_type,count*array_data.fixed_size,r_arch, l_data,l_data)); + } else { + ptr = gras_malloc(subsub_type->aligned_size[r_arch] * count*array_data.fixed_size); + + TRY(gras_trp_chunk_recv(sock, (char*)ptr, + subsub_type->size[r_arch] * count*array_data.fixed_size)); + if (r_arch != GRAS_THISARCH) + TRY(gras_dd_convert_elm(subsub_type,count*array_data.fixed_size,r_arch, ptr,l_data)); + gras_free(ptr); + } + + } else { /* not scalar content, get it recursively (may contain pointers) */ elm_size = sub_type->aligned_size[GRAS_THISARCH]; @@ -779,14 +814,14 @@ gras_datadesc_recv_rec(gras_socket_t *sock, * */ gras_error_t -gras_datadesc_recv(gras_socket_t *sock, - gras_datadesc_type_t *type, - int r_arch, - void *dst) { +gras_datadesc_recv(gras_socket_t sock, + gras_datadesc_type_t type, + int r_arch, + void *dst) { gras_error_t errcode; - gras_cbps_t *state = NULL; /* callback persistent state */ - gras_dict_t *refs; /* all references already sent */ + gras_cbps_t state; /* callback persistent state */ + gras_dict_t refs; /* all references already sent */ refs = gras_dict_new(); state = gras_cbps_new(); diff --git a/src/gras/DataDesc/ddt_parse.c b/src/gras/DataDesc/ddt_parse.c index 0885117175..f41d6fdc5c 100644 --- a/src/gras/DataDesc/ddt_parse.c +++ b/src/gras/DataDesc/ddt_parse.c @@ -26,19 +26,19 @@ typedef struct s_type_modifier{ short is_enum; short is_ref; -} type_modifier_t; +} s_type_modifier_t,*type_modifier_t; typedef struct s_field { - gras_datadesc_type_t *type; + gras_datadesc_type_t type; char *type_name; char *name; - type_modifier_t tm; -} identifier_t; + s_type_modifier_t tm; +} s_identifier_t; extern char *gras_ddt_parse_text; /* text being considered in the parser */ /* local functions */ -static void parse_type_modifier(type_modifier_t *type_modifier) { +static void parse_type_modifier(type_modifier_t type_modifier) { GRAS_IN; do { if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_STAR) { @@ -88,7 +88,7 @@ static void parse_type_modifier(type_modifier_t *type_modifier) { GRAS_OUT; } -static void print_type_modifier(type_modifier_t tm) { +static void print_type_modifier(s_type_modifier_t tm) { int i; GRAS_IN; @@ -104,8 +104,8 @@ static void print_type_modifier(type_modifier_t tm) { GRAS_OUT; } -static void change_to_fixed_array(gras_dynar_t *dynar, long int size) { - identifier_t former,array; +static void change_to_fixed_array(gras_dynar_t dynar, long int size) { + s_identifier_t former,array; memset(&array,0,sizeof(array)); GRAS_IN; @@ -122,8 +122,8 @@ static void change_to_fixed_array(gras_dynar_t *dynar, long int size) { gras_dynar_push(dynar,&array); GRAS_OUT; } -static void change_to_ref(gras_dynar_t *dynar) { - identifier_t former,ref; +static void change_to_ref(gras_dynar_t dynar) { + s_identifier_t former,ref; memset(&ref,0,sizeof(ref)); GRAS_IN; @@ -140,8 +140,8 @@ static void change_to_ref(gras_dynar_t *dynar) { GRAS_OUT; } -static void change_to_ref_pop_array(gras_dynar_t *dynar) { - identifier_t former,ref; +static void change_to_ref_pop_array(gras_dynar_t dynar) { + s_identifier_t former,ref; memset(&ref,0,sizeof(ref)); GRAS_IN; @@ -157,12 +157,12 @@ static void change_to_ref_pop_array(gras_dynar_t *dynar) { } static gras_error_t parse_statement(char *definition, - gras_dynar_t *identifiers, - gras_dynar_t *fields_to_push) { + gras_dynar_t identifiers, + gras_dynar_t fields_to_push) { gras_error_t errcode; char buffname[512]; - identifier_t identifier; + s_identifier_t identifier; int expect_id_separator = 0; @@ -328,7 +328,7 @@ static gras_error_t parse_statement(char *definition, } else if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_WORD) { /* Handle annotation */ - identifier_t array; + s_identifier_t array; char *keyname = NULL; char *keyval = NULL; memset(&array,0,sizeof(array)); @@ -431,23 +431,23 @@ static gras_error_t parse_statement(char *definition, return no_error; } -static gras_datadesc_type_t *parse_struct(char *definition) { +static gras_datadesc_type_t parse_struct(char *definition) { gras_error_t errcode; char buffname[32]; static int anonymous_struct=0; - gras_dynar_t *identifiers; - identifier_t field; + gras_dynar_t identifiers; + s_identifier_t field; int i; - gras_dynar_t *fields_to_push; + gras_dynar_t fields_to_push; char *name; - gras_datadesc_type_t *struct_type; + gras_datadesc_type_t struct_type; GRAS_IN; - identifiers = gras_dynar_new(sizeof(identifier_t),NULL); + identifiers = gras_dynar_new(sizeof(s_identifier_t),NULL); fields_to_push = gras_dynar_new(sizeof(char*),NULL); /* Create the struct descriptor */ @@ -508,18 +508,18 @@ static gras_datadesc_type_t *parse_struct(char *definition) { gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); - gras_dynar_free(identifiers); - gras_dynar_free(fields_to_push); + gras_dynar_free(&identifiers); + gras_dynar_free(&fields_to_push); GRAS_OUT; return struct_type; } -static gras_datadesc_type_t * parse_typedef(char *definition) { +static gras_datadesc_type_t parse_typedef(char *definition) { - type_modifier_t tm; + s_type_modifier_t tm; - gras_datadesc_type_t *struct_desc=NULL; - gras_datadesc_type_t *typedef_desc=NULL; + gras_datadesc_type_t struct_desc=NULL; + gras_datadesc_type_t typedef_desc=NULL; GRAS_IN; memset(&tm,0,sizeof(tm)); @@ -554,11 +554,11 @@ static gras_datadesc_type_t * parse_typedef(char *definition) { * * Create a datadescription from the result of parsing the C type description */ -gras_datadesc_type_t * +gras_datadesc_type_t gras_datadesc_parse(const char *name, const char *C_statement) { - gras_datadesc_type_t * res=NULL; + gras_datadesc_type_t res=NULL; char *definition; int semicolon_count=0; int def_count,C_count; diff --git a/src/gras/Makefile.am b/src/gras/Makefile.am index 2a63cb2d93..40bc8dc13d 100644 --- a/src/gras/Makefile.am +++ b/src/gras/Makefile.am @@ -11,8 +11,8 @@ AM_CFLAGS= -DNDEBUG MAINTAINERCLEANFILES=Makefile.in -INCLUDES= -I$(top_srcdir)/src/include \ - @CFLAGS_SimGrid@ +INCLUDES= @CFLAGS_SimGrid@ + EXTRA_DIST= ./gras_private.h \ Core/dict_private.h \ Transport/transport_interface.h \ diff --git a/src/gras/Msg/msg.c b/src/gras/Msg/msg.c index b787bfa260..c976c97a28 100644 --- a/src/gras/Msg/msg.c +++ b/src/gras/Msg/msg.c @@ -15,7 +15,7 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(msg,gras,"High level messaging"); -gras_set_t *_gras_msgtype_set = NULL; +gras_set_t _gras_msgtype_set = NULL; static char GRAS_header[6]; static char *make_namev(const char *name, short int ver); @@ -49,7 +49,6 @@ void gras_msg_exit(void) { VERB0("Exiting Msg"); gras_set_free(&_gras_msgtype_set); - _gras_msgtype_set = NULL; } /** @@ -58,7 +57,7 @@ gras_msg_exit(void) { * Reclamed memory */ void gras_msgtype_free(void *t) { - gras_msgtype_t *msgtype=(gras_msgtype_t *)t; + gras_msgtype_t msgtype=(gras_msgtype_t)t; if (msgtype) { gras_free(msgtype->name); gras_free(msgtype); @@ -92,8 +91,8 @@ static char *make_namev(const char *name, short int ver) { * * Registers a message to the GRAS mecanism. */ -void gras_msgtype_declare(const char *name, - gras_datadesc_type_t *payload) { +void gras_msgtype_declare(const char *name, + gras_datadesc_type_t payload) { gras_msgtype_declare_v(name, 0, payload); } @@ -110,16 +109,16 @@ void gras_msgtype_declare(const char *name, * differents for each of them. */ void -gras_msgtype_declare_v(const char *name, - short int version, - gras_datadesc_type_t *payload) { +gras_msgtype_declare_v(const char *name, + short int version, + gras_datadesc_type_t payload) { - gras_error_t errcode; - gras_msgtype_t *msgtype; + gras_error_t errcode; + gras_msgtype_t msgtype; char *namev=make_namev(name,version); errcode = gras_set_get_by_name(_gras_msgtype_set, - namev,(gras_set_elm_t**)&msgtype); + namev,(gras_set_elm_t*)&msgtype); if (errcode == no_error) { VERB2("Re-register version %d of message '%s' (same payload, ignored).", @@ -133,16 +132,16 @@ gras_msgtype_declare_v(const char *name, } gras_assert_error(mismatch_error); /* expect this error */ - INFO3("Register version %d of message '%s' (payload: %s).", + VERB3("Register version %d of message '%s' (payload: %s).", version, name, gras_datadesc_get_name(payload)); - msgtype = gras_new(gras_msgtype_t,1); + msgtype = gras_new(s_gras_msgtype_t,1); msgtype->name = (namev == name ? strdup(name) : namev); msgtype->name_len = strlen(namev); msgtype->version = version; msgtype->ctn_type = payload; - gras_set_add(_gras_msgtype_set, (gras_set_elm_t*)msgtype, + gras_set_add(_gras_msgtype_set, (gras_set_elm_t)msgtype, &gras_msgtype_free); } @@ -151,7 +150,7 @@ gras_msgtype_declare_v(const char *name, * * Retrieve a datatype description from its name */ -gras_msgtype_t * gras_msgtype_by_name (const char *name) { +gras_msgtype_t gras_msgtype_by_name (const char *name) { return gras_msgtype_by_namev(name,0); } /** @@ -159,17 +158,19 @@ gras_msgtype_t * gras_msgtype_by_name (const char *name) { * * Retrieve a datatype description from its name and version */ -gras_msgtype_t * gras_msgtype_by_namev(const char *name, - short int version) { - gras_msgtype_t *res; +gras_msgtype_t gras_msgtype_by_namev(const char *name, + short int version) { + gras_msgtype_t res; gras_error_t errcode; char *namev = make_namev(name,version); errcode = gras_set_get_by_name(_gras_msgtype_set, namev, - (gras_set_elm_t**)&res); + (gras_set_elm_t*)&res); if (errcode != no_error) res = NULL; + if (!res) + WARN1("msgtype_by_name(%s) returns NULL",namev); if (name != namev) gras_free(namev); @@ -182,12 +183,12 @@ gras_msgtype_t * gras_msgtype_by_namev(const char *name, * Send the given message on the given socket */ gras_error_t -gras_msg_send(gras_socket_t *sock, - gras_msgtype_t *msgtype, +gras_msg_send(gras_socket_t sock, + gras_msgtype_t msgtype, void *payload) { gras_error_t errcode; - static gras_datadesc_type_t *string_type=NULL; + static gras_datadesc_type_t string_type=NULL; if (!msgtype) RAISE0(mismatch_error, @@ -214,13 +215,13 @@ gras_msg_send(gras_socket_t *sock, * receive the next message on the given socket. */ gras_error_t -gras_msg_recv(gras_socket_t *sock, - gras_msgtype_t **msgtype, +gras_msg_recv(gras_socket_t sock, + gras_msgtype_t *msgtype, void **payload, int *payload_size) { gras_error_t errcode; - static gras_datadesc_type_t *string_type=NULL; + static gras_datadesc_type_t string_type=NULL; char header[6]; int cpt; int r_arch; @@ -244,7 +245,7 @@ gras_msg_recv(gras_socket_t *sock, TRY(gras_datadesc_recv(sock, string_type, r_arch, &msg_name)); errcode = gras_set_get_by_name(_gras_msgtype_set, - msg_name,(gras_set_elm_t**)msgtype); + msg_name,(gras_set_elm_t*)msgtype); if (errcode != no_error) RAISE2(errcode, "Got error %s while retrieving the type associated to messages '%s'", @@ -275,12 +276,12 @@ gras_msg_recv(gras_socket_t *sock, * and used by subsequent call to this function or MsgHandle(). */ gras_error_t -gras_msg_wait(double timeout, - gras_msgtype_t *msgt_want, - gras_socket_t **expeditor, - void *payload) { +gras_msg_wait(double timeout, + gras_msgtype_t msgt_want, + gras_socket_t *expeditor, + void *payload) { - gras_msgtype_t *msgt_got; + gras_msgtype_t msgt_got; void *payload_got; int payload_size_got; gras_error_t errcode; @@ -352,10 +353,10 @@ gras_msg_handle(double timeOut) { int cpt; gras_msg_t msg; - gras_socket_t *expeditor; + gras_socket_t expeditor; void *payload=NULL; int payload_size; - gras_msgtype_t *msgtype; + gras_msgtype_t msgtype; gras_procdata_t*pd=gras_procdata_get(); gras_cblist_t *list; @@ -393,7 +394,7 @@ gras_msg_handle(double timeOut) { } gras_dynar_foreach(list->cbs,cpt,cb) { - INFO3("Invoque the callback #%d (@%p) for incomming msg %s", + INFO3("Use the callback #%d (@%p) for incomming msg %s", cpt+1,cb,msgtype->name); if ((*cb)(expeditor,payload)) { /* cb handled the message */ @@ -411,13 +412,13 @@ void gras_cbl_free(void *data){ gras_cblist_t *list=*(void**)data; if (list) { - gras_dynar_free(list->cbs); + gras_dynar_free(&( list->cbs )); gras_free(list); } } void -gras_cb_register(gras_msgtype_t *msgtype, +gras_cb_register(gras_msgtype_t msgtype, gras_cb_t cb) { gras_procdata_t *pd=gras_procdata_get(); gras_cblist_t *list=NULL; @@ -446,7 +447,7 @@ gras_cb_register(gras_msgtype_t *msgtype, } void -gras_cb_unregister(gras_msgtype_t *msgtype, +gras_cb_unregister(gras_msgtype_t msgtype, gras_cb_t cb) { gras_procdata_t *pd=gras_procdata_get(); diff --git a/src/gras/Msg/msg_interface.h b/src/gras/Msg/msg_interface.h index 847d973bf3..fd10834897 100644 --- a/src/gras/Msg/msg_interface.h +++ b/src/gras/Msg/msg_interface.h @@ -15,13 +15,13 @@ /* gras_msg_t is dereferenced to be stored in procdata, living in Virtu */ typedef struct { - gras_socket_t *expeditor; - gras_msgtype_t *type; + gras_socket_t expeditor; + gras_msgtype_t type; void *payload; int payload_size; } gras_msg_t; -gras_error_t gras_msg_send_namev(gras_socket_t *sock, +gras_error_t gras_msg_send_namev(gras_socket_t sock, const char *namev, void *payload); diff --git a/src/gras/Msg/msg_private.h b/src/gras/Msg/msg_private.h index 7e36382860..2cc7607d44 100644 --- a/src/gras/Msg/msg_private.h +++ b/src/gras/Msg/msg_private.h @@ -34,7 +34,7 @@ * * Message type descriptor. There one of these for each registered version. */ -struct s_gras_msgtype { +typedef struct s_gras_msgtype { /* headers for the data set */ unsigned int code; char *name; @@ -42,15 +42,15 @@ struct s_gras_msgtype { /* payload */ short int version; - gras_datadesc_type_t *ctn_type; -}; + gras_datadesc_type_t ctn_type; +} s_gras_msgtype_t; -extern gras_set_t *_gras_msgtype_set; /* of gras_msgtype_t */ +extern gras_set_t _gras_msgtype_set; /* of gras_msgtype_t */ void gras_msgtype_free(void *msgtype); -gras_error_t gras_msg_recv(gras_socket_t *sock, - gras_msgtype_t **msgtype, +gras_error_t gras_msg_recv(gras_socket_t sock, + gras_msgtype_t *msgtype, void **payload, int *payload_size); @@ -61,7 +61,7 @@ gras_error_t gras_msg_recv(gras_socket_t *sock, */ struct s_gras_cblist { long int id; - gras_dynar_t *cbs; /* of gras_msg_cb_t */ + gras_dynar_t cbs; /* of gras_msg_cb_t */ }; void gras_cblist_free(void *cbl); diff --git a/src/gras/Transport/rl_transport.c b/src/gras/Transport/rl_transport.c index 1e584a4364..04970c4f91 100644 --- a/src/gras/Transport/rl_transport.c +++ b/src/gras/Transport/rl_transport.c @@ -32,10 +32,10 @@ GRAS_LOG_DEFAULT_CATEGORY(transport); */ gras_error_t gras_trp_select(double timeout, - gras_socket_t **dst) { + gras_socket_t *dst) { gras_error_t errcode; - gras_dynar_t *sockets= gras_socketset_get(); + gras_dynar_t sockets= gras_socketset_get(); int done = -1; double wakeup = gras_os_time() + 1000000*timeout; double now = 0; @@ -47,8 +47,8 @@ gras_trp_select(double timeout, fd_set FDS; int ready; /* return of select: number of socket ready to be serviced */ - gras_socket_t *sock_iter; /* iterating over all sockets */ - int cursor; /* iterating over all sockets */ + gras_socket_t sock_iter; /* iterating over all sockets */ + int cursor; /* iterating over all sockets */ *dst=NULL; while (done == -1) { @@ -128,7 +128,7 @@ gras_trp_select(double timeout, if ( sock_iter->accepting && sock_iter->plugin->socket_accept) { /* not a socket but an ear. accept on it and serve next socket */ - gras_socket_t *accepted; + gras_socket_t accepted; TRY(sock_iter->plugin->socket_accept(sock_iter,&accepted)); accepted->raw = sock_iter->raw; diff --git a/src/gras/Transport/sg_transport.c b/src/gras/Transport/sg_transport.c index af8fbe9976..39adee9db8 100644 --- a/src/gras/Transport/sg_transport.c +++ b/src/gras/Transport/sg_transport.c @@ -28,7 +28,7 @@ GRAS_LOG_DEFAULT_CATEGORY(transport); */ gras_error_t gras_trp_select(double timeout, - gras_socket_t **dst) { + gras_socket_t *dst) { gras_error_t errcode; double startTime=gras_os_time(); @@ -36,7 +36,7 @@ gras_trp_select(double timeout, gras_trp_sg_sock_data_t *sockdata; gras_trp_plugin_t *trp; - gras_socket_t *sock_iter; /* iterating over all sockets */ + gras_socket_t sock_iter; /* iterating over all sockets */ int cursor,cpt; gras_sg_portrec_t pr; /* iterating to find the chanel of expeditor */ diff --git a/src/gras/Transport/transport.c b/src/gras/Transport/transport.c index afbfdddf52..415218a50d 100644 --- a/src/gras/Transport/transport.c +++ b/src/gras/Transport/transport.c @@ -11,8 +11,9 @@ #include "gras/Transport/transport_private.h" GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(transport,gras,"Conveying bytes over the network"); +GRAS_LOG_NEW_SUBCATEGORY(raw_trp,transport,"Conveying bytes over the network without formating"); -static gras_dict_t *_gras_trp_plugins; /* All registered plugins */ +static gras_dict_t _gras_trp_plugins; /* All registered plugins */ static void gras_trp_plugin_free(void *p); /* free one of the plugins */ static void gras_trp_socket_free(void *s); /* free one socket */ @@ -89,9 +90,9 @@ void gras_trp_plugin_free(void *p) { * Malloc a new socket, and initialize it with defaults */ void gras_trp_socket_new(int incoming, - gras_socket_t **dst) { + gras_socket_t *dst) { - gras_socket_t *sock=gras_new(gras_socket_t,1); + gras_socket_t sock=gras_new0(s_gras_socket_t,1); DEBUG1("Create a new socket (%p)", (void*)sock); @@ -126,15 +127,17 @@ gras_socket_server_ext(unsigned short port, unsigned long int bufSize, int raw, - /* OUT */ gras_socket_t **dst) { + /* OUT */ gras_socket_t *dst) { gras_error_t errcode; gras_trp_plugin_t *trp; - gras_socket_t *sock; + gras_socket_t sock; *dst = NULL; - DEBUG1("Create a server socket from plugin %s",gras_if_RL() ? "tcp" : "sg"); + DEBUG2("Create a server socket from plugin %s on port %d", + gras_if_RL() ? "tcp" : "sg", + port); TRY(gras_trp_plugin_get_by_name("buf",&trp)); /* defaults settings */ @@ -174,11 +177,11 @@ gras_socket_client_ext(const char *host, unsigned long int bufSize, int raw, - /* OUT */ gras_socket_t **dst) { + /* OUT */ gras_socket_t *dst) { gras_error_t errcode; gras_trp_plugin_t *trp; - gras_socket_t *sock; + gras_socket_t sock; *dst = NULL; @@ -218,7 +221,7 @@ gras_socket_client_ext(const char *host, */ gras_error_t gras_socket_server(unsigned short port, - /* OUT */ gras_socket_t **dst) { + /* OUT */ gras_socket_t *dst) { return gras_socket_server_ext(port,32,0,dst); } @@ -231,14 +234,14 @@ gras_socket_server(unsigned short port, gras_error_t gras_socket_client(const char *host, unsigned short port, - /* OUT */ gras_socket_t **dst) { + /* OUT */ gras_socket_t *dst) { return gras_socket_client_ext(host,port,32,0,dst); } -void gras_socket_close(gras_socket_t *sock) { - gras_dynar_t *sockets = gras_socketset_get(); - gras_socket_t *sock_iter; +void gras_socket_close(gras_socket_t sock) { + gras_dynar_t sockets = gras_socketset_get(); + gras_socket_t sock_iter; int cursor; /* FIXME: Issue an event when the socket is closed */ @@ -266,7 +269,7 @@ void gras_socket_close(gras_socket_t *sock) { * Send a bunch of bytes from on socket */ gras_error_t -gras_trp_chunk_send(gras_socket_t *sd, +gras_trp_chunk_send(gras_socket_t sd, char *data, long int size) { gras_assert1(sd->outgoing, @@ -283,7 +286,7 @@ gras_trp_chunk_send(gras_socket_t *sd, * Receive a bunch of bytes from a socket */ gras_error_t -gras_trp_chunk_recv(gras_socket_t *sd, +gras_trp_chunk_recv(gras_socket_t sd, char *data, long int size) { gras_assert0(sd->incoming, @@ -300,7 +303,7 @@ gras_trp_chunk_recv(gras_socket_t *sd, * Make sure all pending communications are done */ gras_error_t -gras_trp_flush(gras_socket_t *sd) { +gras_trp_flush(gras_socket_t sd) { return (sd->plugin->flush)(sd); } @@ -311,17 +314,17 @@ gras_trp_plugin_get_by_name(const char *name, return gras_dict_get(_gras_trp_plugins,name,(void**)dst); } -int gras_socket_my_port (gras_socket_t *sock) { +int gras_socket_my_port (gras_socket_t sock) { return sock->port; } -int gras_socket_peer_port(gras_socket_t *sock) { +int gras_socket_peer_port(gras_socket_t sock) { return sock->peer_port; } -char *gras_socket_peer_name(gras_socket_t *sock) { +char *gras_socket_peer_name(gras_socket_t sock) { return sock->peer_name; } -gras_error_t gras_socket_raw_send(gras_socket_t *peer, +gras_error_t gras_socket_raw_send(gras_socket_t peer, unsigned int timeout, unsigned long int exp_size, unsigned long int msg_size) { @@ -329,16 +332,22 @@ gras_error_t gras_socket_raw_send(gras_socket_t *peer, char *chunk = gras_malloc(msg_size); int exp_sofar; - gras_assert0(peer->raw,"Asked to send raw data on a regular socket\n"); + gras_assert0(peer->raw,"Asked to send raw data on a regular socket"); for (exp_sofar=0; exp_sofar < exp_size; exp_sofar += msg_size) { + CDEBUG5(raw_trp,"Sent %d of %lu (msg_size=%ld) to %s:%d", + exp_sofar,exp_size,msg_size, + gras_socket_peer_name(peer), gras_socket_peer_port(peer)); TRY(gras_trp_chunk_send(peer,chunk,msg_size)); } + CDEBUG5(raw_trp,"Sent %d of %lu (msg_size=%ld) to %s:%d", + exp_sofar,exp_size,msg_size, + gras_socket_peer_name(peer), gras_socket_peer_port(peer)); gras_free(chunk); return no_error;//gras_socket_raw_exchange(peer,1,timeout,expSize,msgSize); } -gras_error_t gras_socket_raw_recv(gras_socket_t *peer, +gras_error_t gras_socket_raw_recv(gras_socket_t peer, unsigned int timeout, unsigned long int exp_size, unsigned long int msg_size){ @@ -349,8 +358,14 @@ gras_error_t gras_socket_raw_recv(gras_socket_t *peer, gras_assert0(peer->raw,"Asked to recveive raw data on a regular socket\n"); for (exp_sofar=0; exp_sofar < exp_size; exp_sofar += msg_size) { - TRY(gras_trp_chunk_send(peer,chunk,msg_size)); + CDEBUG5(raw_trp,"Recvd %d of %lu (msg_size=%ld) from %s:%d", + exp_sofar,exp_size,msg_size, + gras_socket_peer_name(peer), gras_socket_peer_port(peer)); + TRY(gras_trp_chunk_recv(peer,chunk,msg_size)); } + CDEBUG5(raw_trp,"Recvd %d of %lu (msg_size=%ld) from %s:%d", + exp_sofar,exp_size,msg_size, + gras_socket_peer_name(peer), gras_socket_peer_port(peer)); gras_free(chunk); return no_error;//gras_socket_raw_exchange(peer,0,timeout,expSize,msgSize); diff --git a/src/gras/Transport/transport_interface.h b/src/gras/Transport/transport_interface.h index 63e3429407..d2dade378b 100644 --- a/src/gras/Transport/transport_interface.h +++ b/src/gras/Transport/transport_interface.h @@ -16,18 +16,18 @@ /*** *** Main user functions ***/ -gras_error_t gras_trp_chunk_send(gras_socket_t *sd, +gras_error_t gras_trp_chunk_send(gras_socket_t sd, char *data, long int size); -gras_error_t gras_trp_chunk_recv(gras_socket_t *sd, +gras_error_t gras_trp_chunk_recv(gras_socket_t sd, char *data, long int size); -gras_error_t gras_trp_flush(gras_socket_t *sd); +gras_error_t gras_trp_flush(gras_socket_t sd); /* Find which socket needs to be read next */ gras_error_t gras_trp_select(double timeout, - gras_socket_t **dst); + gras_socket_t *dst); /*** @@ -45,27 +45,27 @@ struct gras_trp_plugin_ { before call to socket_client/server. Retrive the info you need from there. */ gras_error_t (*socket_client)(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *dst); + gras_socket_t dst); gras_error_t (*socket_server)(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *dst); + gras_socket_t dst); - gras_error_t (*socket_accept)(gras_socket_t *sock, - /* OUT */gras_socket_t **dst); + gras_error_t (*socket_accept)(gras_socket_t sock, + gras_socket_t *dst); /* socket_close() is responsible of telling the OS that the socket is over, but should not free the socket itself (beside the specific part) */ - void (*socket_close)(gras_socket_t *sd); + void (*socket_close)(gras_socket_t sd); - gras_error_t (*chunk_send)(gras_socket_t *sd, + gras_error_t (*chunk_send)(gras_socket_t sd, const char *data, long int size); - gras_error_t (*chunk_recv)(gras_socket_t *sd, - char *Data, + gras_error_t (*chunk_recv)(gras_socket_t sd, + char *data, long int size); /* flush has to make sure that the pending communications are achieved */ - gras_error_t (*flush)(gras_socket_t *sd); + gras_error_t (*flush)(gras_socket_t sd); void *data; /* plugin-specific data */ diff --git a/src/gras/Transport/transport_plugin_buf.c b/src/gras/Transport/transport_plugin_buf.c index 26410d2191..ea7f095de3 100644 --- a/src/gras/Transport/transport_plugin_buf.c +++ b/src/gras/Transport/transport_plugin_buf.c @@ -22,22 +22,22 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(trp_buf,transport, *** Prototypes ***/ gras_error_t gras_trp_buf_socket_client(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *sock); + gras_socket_t sock); gras_error_t gras_trp_buf_socket_server(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *sock); -gras_error_t gras_trp_buf_socket_accept(gras_socket_t *sock, - gras_socket_t **dst); + gras_socket_t sock); +gras_error_t gras_trp_buf_socket_accept(gras_socket_t sock, + gras_socket_t *dst); -void gras_trp_buf_socket_close(gras_socket_t *sd); +void gras_trp_buf_socket_close(gras_socket_t sd); -gras_error_t gras_trp_buf_chunk_send(gras_socket_t *sd, +gras_error_t gras_trp_buf_chunk_send(gras_socket_t sd, const char *data, long int size); -gras_error_t gras_trp_buf_chunk_recv(gras_socket_t *sd, +gras_error_t gras_trp_buf_chunk_recv(gras_socket_t sd, char *data, long int size); -gras_error_t gras_trp_buf_flush(gras_socket_t *sock); +gras_error_t gras_trp_buf_flush(gras_socket_t sock); /*** @@ -64,7 +64,7 @@ struct gras_trp_bufdata_{ int buffsize; }; -void gras_trp_buf_init_sock(gras_socket_t *sock) { +void gras_trp_buf_init_sock(gras_socket_t sock) { gras_trp_bufdata_t *data=gras_new(gras_trp_bufdata_t,1); GRAS_IN; @@ -112,7 +112,7 @@ gras_trp_buf_setup(gras_trp_plugin_t *plug) { } gras_error_t gras_trp_buf_socket_client(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *sock){ + /* OUT */ gras_socket_t sock){ gras_error_t errcode; gras_trp_plugin_t *super=((gras_trp_buf_plug_data_t*)self->data)->super; @@ -130,7 +130,7 @@ gras_error_t gras_trp_buf_socket_client(gras_trp_plugin_t *self, * Open a socket used to receive messages. */ gras_error_t gras_trp_buf_socket_server(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *sock){ + /* OUT */ gras_socket_t sock){ gras_error_t errcode; gras_trp_plugin_t *super=((gras_trp_buf_plug_data_t*)self->data)->super; @@ -142,8 +142,8 @@ gras_error_t gras_trp_buf_socket_server(gras_trp_plugin_t *self, } gras_error_t -gras_trp_buf_socket_accept(gras_socket_t *sock, - gras_socket_t **dst) { +gras_trp_buf_socket_accept(gras_socket_t sock, + gras_socket_t *dst) { gras_error_t errcode; gras_trp_plugin_t *super=((gras_trp_buf_plug_data_t*)sock->plugin->data)->super; @@ -154,7 +154,7 @@ gras_trp_buf_socket_accept(gras_socket_t *sock, return no_error; } -void gras_trp_buf_socket_close(gras_socket_t *sock){ +void gras_trp_buf_socket_close(gras_socket_t sock){ gras_trp_plugin_t *super=((gras_trp_buf_plug_data_t*)sock->plugin->data)->super; gras_trp_bufdata_t *data=sock->bufdata; @@ -162,10 +162,10 @@ void gras_trp_buf_socket_close(gras_socket_t *sock){ if (data->in.size || data->out.size) gras_trp_buf_flush(sock); if (data->in.data) - free(data->in.data); + gras_free(data->in.data); if (data->out.data) - free(data->out.data); - free(data); + gras_free(data->out.data); + gras_free(data); super->socket_close(sock); } @@ -176,7 +176,7 @@ void gras_trp_buf_socket_close(gras_socket_t *sock){ * Send data on a TCP socket */ gras_error_t -gras_trp_buf_chunk_send(gras_socket_t *sock, +gras_trp_buf_chunk_send(gras_socket_t sock, const char *chunk, long int size) { @@ -217,7 +217,7 @@ gras_trp_buf_chunk_send(gras_socket_t *sock, * Receive data on a TCP socket. */ gras_error_t -gras_trp_buf_chunk_recv(gras_socket_t *sock, +gras_trp_buf_chunk_recv(gras_socket_t sock, char *chunk, long int size) { @@ -269,7 +269,7 @@ gras_trp_buf_chunk_recv(gras_socket_t *sock, * Make sure the data is sent */ gras_error_t -gras_trp_buf_flush(gras_socket_t *sock) { +gras_trp_buf_flush(gras_socket_t sock) { gras_error_t errcode; uint32_t size; gras_trp_plugin_t *super=((gras_trp_buf_plug_data_t*)sock->plugin->data)->super; diff --git a/src/gras/Transport/transport_plugin_file.c b/src/gras/Transport/transport_plugin_file.c index 11f1a29cda..36cb896991 100644 --- a/src/gras/Transport/transport_plugin_file.c +++ b/src/gras/Transport/transport_plugin_file.c @@ -23,13 +23,13 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(trp_file,transport, /*** *** Prototypes ***/ -void gras_trp_file_close(gras_socket_t *sd); +void gras_trp_file_close(gras_socket_t sd); -gras_error_t gras_trp_file_chunk_send(gras_socket_t *sd, +gras_error_t gras_trp_file_chunk_send(gras_socket_t sd, const char *data, long int size); -gras_error_t gras_trp_file_chunk_recv(gras_socket_t *sd, +gras_error_t gras_trp_file_chunk_recv(gras_socket_t sd, char *data, long int size); @@ -75,7 +75,7 @@ gras_trp_file_setup(gras_trp_plugin_t *plug) { */ gras_error_t gras_socket_client_from_file(const char*path, - /* OUT */ gras_socket_t **dst) { + /* OUT */ gras_socket_t *dst) { gras_error_t errcode; gras_trp_plugin_t *trp; @@ -118,7 +118,7 @@ gras_socket_client_from_file(const char*path, */ gras_error_t gras_socket_server_from_file(const char*path, - /* OUT */ gras_socket_t **dst) { + /* OUT */ gras_socket_t *dst) { gras_error_t errcode; gras_trp_plugin_t *trp; @@ -152,7 +152,7 @@ gras_socket_server_from_file(const char*path, return no_error; } -void gras_trp_file_close(gras_socket_t *sock){ +void gras_trp_file_close(gras_socket_t sock){ gras_trp_file_plug_data_t *data; if (!sock) return; /* close only once */ @@ -182,7 +182,7 @@ void gras_trp_file_close(gras_socket_t *sock){ * Send data on a file pseudo-socket */ gras_error_t -gras_trp_file_chunk_send(gras_socket_t *sock, +gras_trp_file_chunk_send(gras_socket_t sock, const char *data, long int size) { @@ -217,7 +217,7 @@ gras_trp_file_chunk_send(gras_socket_t *sock, * Receive data on a file pseudo-socket. */ gras_error_t -gras_trp_file_chunk_recv(gras_socket_t *sock, +gras_trp_file_chunk_recv(gras_socket_t sock, char *data, long int size) { diff --git a/src/gras/Transport/transport_plugin_sg.c b/src/gras/Transport/transport_plugin_sg.c index 5e685834a0..3ed5e64327 100644 --- a/src/gras/Transport/transport_plugin_sg.c +++ b/src/gras/Transport/transport_plugin_sg.c @@ -29,16 +29,16 @@ static gras_error_t find_port(gras_hostdata_t *hd, int port, gras_error_t gras_trp_sg_socket_client(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *sock); + /* OUT */ gras_socket_t sock); gras_error_t gras_trp_sg_socket_server(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *sock); -void gras_trp_sg_socket_close(gras_socket_t *sd); + /* OUT */ gras_socket_t sock); +void gras_trp_sg_socket_close(gras_socket_t sd); -gras_error_t gras_trp_sg_chunk_send(gras_socket_t *sd, +gras_error_t gras_trp_sg_chunk_send(gras_socket_t sd, const char *data, long int size); -gras_error_t gras_trp_sg_chunk_recv(gras_socket_t *sd, +gras_error_t gras_trp_sg_chunk_recv(gras_socket_t sd, char *data, long int size); @@ -90,7 +90,7 @@ gras_trp_sg_setup(gras_trp_plugin_t *plug) { } gras_error_t gras_trp_sg_socket_client(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *sock){ + /* OUT */ gras_socket_t sock){ gras_error_t errcode; @@ -149,7 +149,7 @@ gras_error_t gras_trp_sg_socket_client(gras_trp_plugin_t *self, } gras_error_t gras_trp_sg_socket_server(gras_trp_plugin_t *self, - gras_socket_t *sock){ + gras_socket_t sock){ gras_error_t errcode; @@ -170,12 +170,14 @@ gras_error_t gras_trp_sg_socket_server(gras_trp_plugin_t *self, RAISE2(mismatch_error, "can't listen on address %s:%d: port already in use\n.", host,sock->port); + break; case mismatch_error: /* Port not used so far. Do it */ pr.tochan = sock->raw ? pd->rawChan : pd->chan; pr.port = sock->port; pr.raw = sock->raw; gras_dynar_push(hd->ports,&pr); + break; default: return errcode; @@ -190,14 +192,14 @@ gras_error_t gras_trp_sg_socket_server(gras_trp_plugin_t *self, sock->data = data; - INFO6("'%s' (%d) ears on %s:%d%s (%p)", + VERB6("'%s' (%d) ears on %s:%d%s (%p)", MSG_process_get_name(MSG_process_self()), MSG_process_self_PID(), host,sock->port,sock->raw? " (mode RAW)":"",sock); return no_error; } -void gras_trp_sg_socket_close(gras_socket_t *sock){ +void gras_trp_sg_socket_close(gras_socket_t sock){ gras_hostdata_t *hd=(gras_hostdata_t *)MSG_host_get_data(MSG_host_self()); int cpt; @@ -227,7 +229,7 @@ typedef struct { void *data; } sg_task_data_t; -gras_error_t gras_trp_sg_chunk_send(gras_socket_t *sock, +gras_error_t gras_trp_sg_chunk_send(gras_socket_t sock, const char *data, long int size) { m_task_t task=NULL; @@ -255,7 +257,7 @@ gras_error_t gras_trp_sg_chunk_send(gras_socket_t *sock, return no_error; } -gras_error_t gras_trp_sg_chunk_recv(gras_socket_t *sock, +gras_error_t gras_trp_sg_chunk_recv(gras_socket_t sock, char *data, long int size){ gras_procdata_t *pd=gras_procdata_get(); @@ -290,7 +292,7 @@ gras_error_t gras_trp_sg_chunk_recv(gras_socket_t *sock, } /* Data exchange over raw sockets */ -gras_error_t gras_socket_raw_exchange(gras_socket_t *peer, +gras_error_t gras_socket_raw_exchange(gras_socket_t peer, int sender, unsigned int timeout, unsigned long int expSize, diff --git a/src/gras/Transport/transport_plugin_tcp.c b/src/gras/Transport/transport_plugin_tcp.c index 56aa78e37d..d502ce1063 100644 --- a/src/gras/Transport/transport_plugin_tcp.c +++ b/src/gras/Transport/transport_plugin_tcp.c @@ -29,19 +29,19 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(trp_tcp,transport,"TCP transport"); *** Prototypes ***/ gras_error_t gras_trp_tcp_socket_client(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *sock); + gras_socket_t sock); gras_error_t gras_trp_tcp_socket_server(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *sock); -gras_error_t gras_trp_tcp_socket_accept(gras_socket_t *sock, - gras_socket_t **dst); + gras_socket_t sock); +gras_error_t gras_trp_tcp_socket_accept(gras_socket_t sock, + gras_socket_t *dst); -void gras_trp_tcp_socket_close(gras_socket_t *sd); +void gras_trp_tcp_socket_close(gras_socket_t sd); -gras_error_t gras_trp_tcp_chunk_send(gras_socket_t *sd, +gras_error_t gras_trp_tcp_chunk_send(gras_socket_t sd, const char *data, long int size); -gras_error_t gras_trp_tcp_chunk_recv(gras_socket_t *sd, +gras_error_t gras_trp_tcp_chunk_recv(gras_socket_t sd, char *data, long int size); @@ -95,11 +95,11 @@ gras_error_t gras_trp_tcp_setup(gras_trp_plugin_t *plug) { void gras_trp_tcp_exit(gras_trp_plugin_t *plug) { DEBUG1("Exit plugin TCP (free %p)", plug->data); - free(plug->data); + gras_free(plug->data); } gras_error_t gras_trp_tcp_socket_client(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *sock){ + gras_socket_t sock){ struct sockaddr_in addr; struct hostent *he; @@ -152,7 +152,7 @@ gras_error_t gras_trp_tcp_socket_client(gras_trp_plugin_t *self, * Open a socket used to receive messages. */ gras_error_t gras_trp_tcp_socket_server(gras_trp_plugin_t *self, - /* OUT */ gras_socket_t *sock){ + /* OUT */ gras_socket_t sock){ int size = sock->bufSize * 1024; int on = 1; struct sockaddr_in server; @@ -200,9 +200,9 @@ gras_error_t gras_trp_tcp_socket_server(gras_trp_plugin_t *self, } gras_error_t -gras_trp_tcp_socket_accept(gras_socket_t *sock, - gras_socket_t **dst) { - gras_socket_t *res; +gras_trp_tcp_socket_accept(gras_socket_t sock, + gras_socket_t *dst) { + gras_socket_t res; gras_error_t errcode; struct sockaddr_in peer_in; @@ -272,7 +272,7 @@ gras_trp_tcp_socket_accept(gras_socket_t *sock, } } -void gras_trp_tcp_socket_close(gras_socket_t *sock){ +void gras_trp_tcp_socket_close(gras_socket_t sock){ gras_trp_tcp_plug_data_t *tcp; if (!sock) return; /* close only once */ @@ -313,7 +313,7 @@ void gras_trp_tcp_socket_close(gras_socket_t *sock){ * Send data on a TCP socket */ gras_error_t -gras_trp_tcp_chunk_send(gras_socket_t *sock, +gras_trp_tcp_chunk_send(gras_socket_t sock, const char *data, long int size) { @@ -348,7 +348,7 @@ gras_trp_tcp_chunk_send(gras_socket_t *sock, * Receive data on a TCP socket. */ gras_error_t -gras_trp_tcp_chunk_recv(gras_socket_t *sock, +gras_trp_tcp_chunk_recv(gras_socket_t sock, char *data, long int size) { @@ -403,7 +403,7 @@ static int TcpProtoNumber(void) { But I fail to find a good internal organization for now. We may want to split raw and regular sockets more efficiently. */ -gras_error_t gras_socket_raw_exchange(gras_socket_t *peer, +gras_error_t gras_socket_raw_exchange(gras_socket_t peer, int sender, unsigned int timeout, unsigned long int exp_size, diff --git a/src/gras/Transport/transport_private.h b/src/gras/Transport/transport_private.h index 1539170f68..621e8eca74 100644 --- a/src/gras/Transport/transport_private.h +++ b/src/gras/Transport/transport_private.h @@ -34,7 +34,7 @@ */ typedef struct gras_trp_bufdata_ gras_trp_bufdata_t; -struct s_gras_socket { +typedef struct s_gras_socket { gras_trp_plugin_t *plugin; int incoming :1; /* true if we can read from this sock */ @@ -53,10 +53,10 @@ struct s_gras_socket { /* buffer plugin specific data. Yeah, C is not OO, so I got to trick */ gras_trp_bufdata_t *bufdata; -}; +}s_gras_socket_t; void gras_trp_socket_new(int incomming, - gras_socket_t **dst); + gras_socket_t *dst); /* The drivers */ typedef gras_error_t (*gras_trp_setup_t)(gras_trp_plugin_t *dst); @@ -84,11 +84,11 @@ gras_error_t gras_trp_buf_setup(gras_trp_plugin_t *plug); */ -void gras_trp_buf_init_sock(gras_socket_t *sock); +void gras_trp_buf_init_sock(gras_socket_t sock); /* Data exchange over raw sockets */ -gras_error_t gras_socket_raw_exchange(gras_socket_t *peer, +gras_error_t gras_socket_raw_exchange(gras_socket_t peer, int sender, unsigned int timeout, unsigned long int expSize, diff --git a/src/gras/Virtu/process.c b/src/gras/Virtu/process.c index eea80f7f68..838aaa4e60 100644 --- a/src/gras/Virtu/process.c +++ b/src/gras/Virtu/process.c @@ -47,12 +47,12 @@ void gras_procdata_exit() { gras_procdata_t *pd=gras_procdata_get(); - gras_dynar_free(pd->msg_queue); - gras_dynar_free(pd->cbl_list); - gras_dynar_free(pd->sockets); + gras_dynar_free(&( pd->msg_queue )); + gras_dynar_free(&( pd->cbl_list )); + gras_dynar_free(&( pd->sockets )); } -gras_dynar_t * +gras_dynar_t gras_socketset_get(void) { return gras_procdata_get()->sockets; } diff --git a/src/gras/Virtu/virtu_interface.h b/src/gras/Virtu/virtu_interface.h index 935ddb4d7f..46bab61429 100644 --- a/src/gras/Virtu/virtu_interface.h +++ b/src/gras/Virtu/virtu_interface.h @@ -27,22 +27,22 @@ */ typedef struct { /*queue of msgs storing the ones got while msg_wait'ing for something else */ - gras_dynar_t *msg_queue; /* elm type: gras_msg_t */ + gras_dynar_t msg_queue; /* elm type: gras_msg_t */ /* registered callbacks for each message */ - gras_dynar_t *cbl_list; /* elm type: gras_cblist_t */ + gras_dynar_t cbl_list; /* elm type: gras_cblist_t */ /* SG only elements. In RL, they are part of the OS ;) */ int chan; /* Formated messages channel */ int rawChan; /* Unformated echange channel */ - gras_dynar_t *sockets; /* all sockets known to this process */ + gras_dynar_t sockets; /* all sockets known to this process */ /* globals of the process */ void *userdata; } gras_procdata_t; /* Access */ -gras_dynar_t * gras_socketset_get(void); +gras_dynar_t gras_socketset_get(void); /* FIXME: mv to _private? */ gras_procdata_t *gras_procdata_get(void); diff --git a/src/gras/Virtu/virtu_sg.h b/src/gras/Virtu/virtu_sg.h index e05ff6aa87..2090257e6f 100644 --- a/src/gras/Virtu/virtu_sg.h +++ b/src/gras/Virtu/virtu_sg.h @@ -27,7 +27,7 @@ typedef struct { int proc[GRAS_MAX_CHANNEL]; /* PID of who's connected to each channel */ /* If =0, then free */ - gras_dynar_t *ports; + gras_dynar_t ports; } gras_hostdata_t; diff --git a/src/xbt/config.c b/src/xbt/config.c index 81cddbe6d5..713e18c430 100644 --- a/src/xbt/config.c +++ b/src/xbt/config.c @@ -28,13 +28,13 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(config,xbt,"configuration support"); typedef struct { /* Allowed type of the cell */ - gras_cfgelm_type_t type; + e_gras_cfgelm_type_t type; int min,max; /* actual content (cannot be an union because type host uses both str and i) */ - gras_dynar_t *content; -} gras_cfgelm_t; + gras_dynar_t content; +} s_gras_cfgelm_t,*gras_cfgelm_t; static const char *gras_cfgelm_type_name[gras_cfgelm_type_count]= {"int","double","string","host"}; @@ -43,9 +43,9 @@ static const char *gras_cfgelm_type_name[gras_cfgelm_type_count]= static void gras_cfgelm_free(void *data); /* Retrieve the cell we'll modify */ -static gras_error_t gras_cfgelm_get(gras_cfg_t *cfg, const char *name, - gras_cfgelm_type_t type, - /* OUT */ gras_cfgelm_t **whereto); +static gras_error_t gras_cfgelm_get(gras_cfg_t cfg, const char *name, + e_gras_cfgelm_type_t type, + /* OUT */ gras_cfgelm_t *whereto); void gras_cfg_str_free(void *d); void gras_cfg_host_free(void *d); @@ -72,8 +72,8 @@ void gras_cfg_host_free(void *d){ */ -gras_cfg_t *gras_cfg_new(void) { - return (gras_cfg_t *)gras_dict_new(); +gras_cfg_t gras_cfg_new(void) { + return (gras_cfg_t)gras_dict_new(); } /** @@ -85,21 +85,21 @@ gras_cfg_t *gras_cfg_new(void) { */ void -gras_cfg_cpy(gras_cfg_t **whereto, gras_cfg_t *tocopy) { - gras_dict_cursor_t *cursor=NULL; - gras_cfgelm_t *cell=NULL; +gras_cfg_cpy(gras_cfg_t tocopy,gras_cfg_t *whereto) { + gras_dict_cursor_t cursor=NULL; + gras_cfgelm_t cell=NULL; char *name=NULL; *whereto=NULL; gras_assert0(tocopy,"cannot copy NULL config"); - gras_dict_foreach((gras_dict_t*)tocopy,cursor,name,cell) { + gras_dict_foreach((gras_dict_t)tocopy,cursor,name,cell) { gras_cfg_register(*whereto, name, cell->type, cell->min, cell->max); } } -void gras_cfg_free(gras_cfg_t **cfg) { - gras_dict_free((gras_dict_t**)cfg); +void gras_cfg_free(gras_cfg_t *cfg) { + gras_dict_free((gras_dict_t*)cfg); } /** @@ -111,10 +111,10 @@ void gras_cfg_free(gras_cfg_t **cfg) { * Dumps a config set for debuging purpose */ void -gras_cfg_dump(const char *name,const char *indent,gras_cfg_t *cfg) { - gras_dict_t *dict = (gras_dict_t*) cfg; - gras_dict_cursor_t *cursor=NULL; - gras_cfgelm_t *cell=NULL; +gras_cfg_dump(const char *name,const char *indent,gras_cfg_t cfg) { + gras_dict_t dict = (gras_dict_t) cfg; + gras_dict_cursor_t cursor=NULL; + gras_cfgelm_t cell=NULL; char *key=NULL; int i; gras_error_t errcode; @@ -174,7 +174,7 @@ gras_cfg_dump(const char *name,const char *indent,gras_cfg_t *cfg) { if (name) printf("%s<< End of the config set '%s'\n",indent,name); fflush(stdout); - gras_dict_cursor_free(cursor); + gras_dict_cursor_free(&cursor); return; } @@ -187,10 +187,10 @@ gras_cfg_dump(const char *name,const char *indent,gras_cfg_t *cfg) { */ void gras_cfgelm_free(void *data) { - gras_cfgelm_t *c=(gras_cfgelm_t *)data; + gras_cfgelm_t c=(gras_cfgelm_t)data; if (!c) return; - gras_dynar_free(c->content); + gras_dynar_free(&(c->content)); gras_free(c); } @@ -207,14 +207,14 @@ void gras_cfgelm_free(void *data) { */ void -gras_cfg_register(gras_cfg_t *cfg, - const char *name, gras_cfgelm_type_t type, +gras_cfg_register(gras_cfg_t cfg, + const char *name, e_gras_cfgelm_type_t type, int min, int max){ - gras_cfgelm_t *res; + gras_cfgelm_t res; gras_error_t errcode; DEBUG4("Register cfg elm %s (%d to %d %s)",name,min,max,gras_cfgelm_type_name[type]); - errcode = gras_dict_get((gras_dict_t*)cfg,name,(void**)&res); + errcode = gras_dict_get((gras_dict_t)cfg,name,(void**)&res); if (errcode == no_error) { WARN1("Config elem %s registered twice.",name); @@ -222,7 +222,7 @@ gras_cfg_register(gras_cfg_t *cfg, } gras_assert_error(mismatch_error); - res=gras_new(gras_cfgelm_t,1); + res=gras_new(s_gras_cfgelm_t,1); res->type=type; res->min=min; @@ -249,7 +249,7 @@ gras_cfg_register(gras_cfg_t *cfg, ERROR1("%d is an invalide type code",type); } - gras_dict_set((gras_dict_t*)cfg,name,res,&gras_cfgelm_free); + gras_dict_set((gras_dict_t)cfg,name,res,&gras_cfgelm_free); } /** @@ -263,8 +263,8 @@ gras_cfg_register(gras_cfg_t *cfg, */ gras_error_t -gras_cfg_unregister(gras_cfg_t *cfg,const char *name) { - return gras_dict_remove((gras_dict_t*)cfg,name); +gras_cfg_unregister(gras_cfg_t cfg,const char *name) { + return gras_dict_remove((gras_dict_t)cfg,name); } /** @@ -277,12 +277,12 @@ gras_cfg_unregister(gras_cfg_t *cfg,const char *name) { */ gras_error_t -gras_cfg_register_str(gras_cfg_t *cfg,const char *entry) { +gras_cfg_register_str(gras_cfg_t cfg,const char *entry) { char *entrycpy=gras_strdup(entry); char *tok; int min,max; - gras_cfgelm_type_t type; + e_gras_cfgelm_type_t type; tok=strchr(entrycpy, ':'); if (!tok) { @@ -351,15 +351,15 @@ gras_cfg_register_str(gras_cfg_t *cfg,const char *entry) { */ gras_error_t -gras_cfg_check(gras_cfg_t *cfg) { - gras_dict_cursor_t *cursor; - gras_cfgelm_t *cell; +gras_cfg_check(gras_cfg_t cfg) { + gras_dict_cursor_t cursor; + gras_cfgelm_t cell; char *name; int size; gras_assert0(cfg,"NULL config set."); - gras_dict_foreach((gras_dict_t*)cfg,cursor,name,cell) { + gras_dict_foreach((gras_dict_t)cfg,cursor,name,cell) { size = gras_dynar_length(cell->content); if (cell->min > size) { ERROR4("Config elem %s needs at least %d %s, but there is only %d values.", @@ -367,7 +367,7 @@ gras_cfg_check(gras_cfg_t *cfg) { cell->min, gras_cfgelm_type_name[cell->type], size); - gras_dict_cursor_free(cursor); + gras_dict_cursor_free(&cursor); return mismatch_error; } @@ -377,22 +377,22 @@ gras_cfg_check(gras_cfg_t *cfg) { cell->max, gras_cfgelm_type_name[cell->type], size); - gras_dict_cursor_free(cursor); + gras_dict_cursor_free(&cursor); return mismatch_error; } } - gras_dict_cursor_free(cursor); + gras_dict_cursor_free(&cursor); return no_error; } -static gras_error_t gras_cfgelm_get(gras_cfg_t *cfg, +static gras_error_t gras_cfgelm_get(gras_cfg_t cfg, const char *name, - gras_cfgelm_type_t type, - /* OUT */ gras_cfgelm_t **whereto){ + e_gras_cfgelm_type_t type, + /* OUT */ gras_cfgelm_t *whereto){ - gras_error_t errcode = gras_dict_get((gras_dict_t*)cfg,name, + gras_error_t errcode = gras_dict_get((gras_dict_t)cfg,name, (void**)whereto); if (errcode == mismatch_error) { @@ -423,13 +423,13 @@ static gras_error_t gras_cfgelm_get(gras_cfg_t *cfg, */ gras_error_t -gras_cfg_get_type(gras_cfg_t *cfg, const char *name, - /* OUT */gras_cfgelm_type_t *type) { +gras_cfg_get_type(gras_cfg_t cfg, const char *name, + /* OUT */e_gras_cfgelm_type_t *type) { - gras_cfgelm_t *cell; + gras_cfgelm_t cell; gras_error_t errcode; - TRYCATCH(mismatch_error,gras_dict_get((gras_dict_t*)cfg,name,(void**)&cell)); + TRYCATCH(mismatch_error,gras_dict_get((gras_dict_t)cfg,name,(void**)&cell)); if (errcode == mismatch_error) { ERROR1("Can't get the type of '%s' since this cell does not exist", @@ -452,11 +452,11 @@ gras_cfg_get_type(gras_cfg_t *cfg, const char *name, * @warning: if the list isn't NULL terminated, it will segfault. */ gras_error_t -gras_cfg_set_vargs(gras_cfg_t *cfg, va_list pa) { +gras_cfg_set_vargs(gras_cfg_t cfg, va_list pa) { char *str,*name; int i; double d; - gras_cfgelm_type_t type; + e_gras_cfgelm_type_t type; gras_error_t errcode; @@ -504,7 +504,7 @@ gras_cfg_set_vargs(gras_cfg_t *cfg, va_list pa) { * Add some values to the config set. * @warning: if the list isn't NULL terminated, it will segfault. */ -gras_error_t gras_cfg_set(gras_cfg_t *cfg, ...) { +gras_error_t gras_cfg_set(gras_cfg_t cfg, ...) { va_list pa; gras_error_t errcode; @@ -527,12 +527,12 @@ gras_error_t gras_cfg_set(gras_cfg_t *cfg, ...) { */ gras_error_t -gras_cfg_set_parse(gras_cfg_t *cfg, const char *options) { +gras_cfg_set_parse(gras_cfg_t cfg, const char *options) { int i; double d; char *str; - gras_cfgelm_t *cell; + gras_cfgelm_t cell; char *optionlist_cpy; char *option, *name,*val; @@ -595,7 +595,7 @@ gras_cfg_set_parse(gras_cfg_t *cfg, const char *options) { DEBUG2("name='%s';val='%s'",name,val); - errcode=gras_dict_get((gras_dict_t*)cfg,name,(void**)&cell); + errcode=gras_dict_get((gras_dict_t)cfg,name,(void**)&cell); switch (errcode) { case no_error: break; @@ -684,8 +684,8 @@ gras_cfg_set_parse(gras_cfg_t *cfg, const char *options) { * Set the value of the cell @name in @cfg with the provided value. */ gras_error_t -gras_cfg_set_int(gras_cfg_t *cfg,const char*name, int val) { - gras_cfgelm_t *cell; +gras_cfg_set_int(gras_cfg_t cfg,const char*name, int val) { + gras_cfgelm_t cell; gras_error_t errcode; VERB2("Configuration setting: %s=%d",name,val); @@ -709,8 +709,8 @@ gras_cfg_set_int(gras_cfg_t *cfg,const char*name, int val) { */ gras_error_t -gras_cfg_set_double(gras_cfg_t *cfg,const char*name, double val) { - gras_cfgelm_t *cell; +gras_cfg_set_double(gras_cfg_t cfg,const char*name, double val) { + gras_cfgelm_t cell; gras_error_t errcode; VERB2("Configuration setting: %s=%f",name,val); @@ -735,8 +735,8 @@ gras_cfg_set_double(gras_cfg_t *cfg,const char*name, double val) { */ gras_error_t -gras_cfg_set_string(gras_cfg_t *cfg,const char*name, const char*val) { - gras_cfgelm_t *cell; +gras_cfg_set_string(gras_cfg_t cfg,const char*name, const char*val) { + gras_cfgelm_t cell; gras_error_t errcode; char *newval = gras_strdup(val); @@ -764,9 +764,9 @@ gras_cfg_set_string(gras_cfg_t *cfg,const char*name, const char*val) { */ gras_error_t -gras_cfg_set_host(gras_cfg_t *cfg,const char*name, +gras_cfg_set_host(gras_cfg_t cfg,const char*name, const char *host,int port) { - gras_cfgelm_t *cell; + gras_cfgelm_t cell; gras_error_t errcode; gras_host_t *val=gras_new(gras_host_t,1); @@ -796,9 +796,9 @@ gras_cfg_set_host(gras_cfg_t *cfg,const char*name, * * Remove the provided @val from the cell @name in @cfg. */ -gras_error_t gras_cfg_rm_int (gras_cfg_t *cfg,const char*name, int val) { +gras_error_t gras_cfg_rm_int(gras_cfg_t cfg,const char*name, int val) { - gras_cfgelm_t *cell; + gras_cfgelm_t cell; int cpt,seen; gras_error_t errcode; @@ -826,8 +826,8 @@ gras_error_t gras_cfg_rm_int (gras_cfg_t *cfg,const char*name, int val) { * Remove the provided @val from the cell @name in @cfg. */ -gras_error_t gras_cfg_rm_double(gras_cfg_t *cfg,const char*name, double val) { - gras_cfgelm_t *cell; +gras_error_t gras_cfg_rm_double(gras_cfg_t cfg,const char*name, double val) { + gras_cfgelm_t cell; int cpt; double seen; gras_error_t errcode; @@ -856,8 +856,8 @@ gras_error_t gras_cfg_rm_double(gras_cfg_t *cfg,const char*name, double val) { * Remove the provided @val from the cell @name in @cfg. */ gras_error_t -gras_cfg_rm_string(gras_cfg_t *cfg,const char*name, const char *val) { - gras_cfgelm_t *cell; +gras_cfg_rm_string(gras_cfg_t cfg,const char*name, const char *val) { + gras_cfgelm_t cell; int cpt; char *seen; gras_error_t errcode; @@ -888,8 +888,8 @@ gras_cfg_rm_string(gras_cfg_t *cfg,const char*name, const char *val) { */ gras_error_t -gras_cfg_rm_host (gras_cfg_t *cfg,const char*name, const char *host,int port) { - gras_cfgelm_t *cell; +gras_cfg_rm_host(gras_cfg_t cfg,const char*name, const char *host,int port) { + gras_cfgelm_t cell; int cpt; gras_host_t *seen; gras_error_t errcode; @@ -920,13 +920,13 @@ gras_cfg_rm_host (gras_cfg_t *cfg,const char*name, const char *host,int port) { */ gras_error_t -gras_cfg_empty(gras_cfg_t *cfg,const char*name) { - gras_cfgelm_t *cell; +gras_cfg_empty(gras_cfg_t cfg,const char*name) { + gras_cfgelm_t cell; gras_error_t errcode; TRYCATCH(mismatch_error, - gras_dict_get((gras_dict_t*)cfg,name,(void**)&cell)); + gras_dict_get((gras_dict_t)cfg,name,(void**)&cell)); if (errcode == mismatch_error) { ERROR1("Can't empty '%s' since this config element does not exist", name); @@ -954,10 +954,10 @@ gras_cfg_empty(gras_cfg_t *cfg,const char*name) { * @warning the returned value is the actual content of the config set */ gras_error_t -gras_cfg_get_int (gras_cfg_t *cfg, +gras_cfg_get_int (gras_cfg_t cfg, const char *name, int *val) { - gras_cfgelm_t *cell; + gras_cfgelm_t cell; gras_error_t errcode; TRY (gras_cfgelm_get(cfg,name,gras_cfgelm_int,&cell)); @@ -985,11 +985,11 @@ gras_cfg_get_int (gras_cfg_t *cfg, */ gras_error_t -gras_cfg_get_double(gras_cfg_t *cfg, +gras_cfg_get_double(gras_cfg_t cfg, const char *name, double *val) { - gras_cfgelm_t *cell; - gras_error_t errcode; + gras_cfgelm_t cell; + gras_error_t errcode; TRY (gras_cfgelm_get(cfg,name,gras_cfgelm_double,&cell)); @@ -1016,10 +1016,10 @@ gras_cfg_get_double(gras_cfg_t *cfg, * @warning the returned value is the actual content of the config set */ -gras_error_t gras_cfg_get_string(gras_cfg_t *cfg, +gras_error_t gras_cfg_get_string(gras_cfg_t cfg, const char *name, char **val) { - gras_cfgelm_t *cell; + gras_cfgelm_t cell; gras_error_t errcode; *val=NULL; @@ -1050,13 +1050,13 @@ gras_error_t gras_cfg_get_string(gras_cfg_t *cfg, * @warning the returned value is the actual content of the config set */ -gras_error_t gras_cfg_get_host (gras_cfg_t *cfg, +gras_error_t gras_cfg_get_host (gras_cfg_t cfg, const char *name, char **host, int *port) { - gras_cfgelm_t *cell; - gras_error_t errcode; - gras_host_t *val; + gras_cfgelm_t cell; + gras_error_t errcode; + gras_host_t *val; TRY (gras_cfgelm_get(cfg,name,gras_cfgelm_host,&cell)); @@ -1082,12 +1082,12 @@ gras_error_t gras_cfg_get_host (gras_cfg_t *cfg, * * @warning the returned value is the actual content of the config set */ -gras_error_t gras_cfg_get_dynar (gras_cfg_t *cfg, - const char *name, - gras_dynar_t **dynar) { - gras_cfgelm_t *cell; - gras_error_t errcode = gras_dict_get((gras_dict_t*)cfg,name, - (void**)&cell); +gras_error_t gras_cfg_get_dynar (gras_cfg_t cfg, + const char *name, + gras_dynar_t *dynar) { + gras_cfgelm_t cell; + gras_error_t errcode = gras_dict_get((gras_dict_t)cfg,name, + (void**)&cell); if (errcode == mismatch_error) { ERROR1("No registered cell %s in this config set", diff --git a/src/xbt/dict.c b/src/xbt/dict.c index 101a08abd7..2a79ff183f 100644 --- a/src/xbt/dict.c +++ b/src/xbt/dict.c @@ -30,9 +30,9 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(dict,xbt, * * Creates and initialize a new dictionnary */ -gras_dict_t * +gras_dict_t gras_dict_new(void) { - gras_dict_t *res= gras_new(gras_dict_t,1); + gras_dict_t res= gras_new(s_gras_dict_t,1); res->head=NULL; return res; } @@ -43,13 +43,13 @@ gras_dict_new(void) { * Frees a cache structure with all its childs. */ void -gras_dict_free(gras_dict_t **dict) { +gras_dict_free(gras_dict_t *dict) { if (dict && *dict) { if ((*dict)->head) { gras_dictelm_free( &( (*dict)->head ) ); (*dict)->head = NULL; } - free(*dict); + gras_free(*dict); *dict=NULL; } } @@ -66,15 +66,15 @@ gras_dict_free(gras_dict_t **dict) { * of data, as long as its length is provided in @key_len. */ void -gras_dict_set_ext(gras_dict_t *p_dict, +gras_dict_set_ext(gras_dict_t dict, const char *key, int key_len, void *data, void_f_pvoid_t *free_ctn) { - gras_assert(p_dict); + gras_assert(dict); - gras_dictelm_set_ext(&(p_dict->head), + gras_dictelm_set_ext(&(dict->head), key, key_len, data, free_ctn); } @@ -90,14 +90,14 @@ gras_dict_set_ext(gras_dict_t *p_dict, * null terminated string. */ void -gras_dict_set(gras_dict_t *p_dict, - const char *key, - void *data, - void_f_pvoid_t *free_ctn) { +gras_dict_set(gras_dict_t dict, + const char *key, + void *data, + void_f_pvoid_t *free_ctn) { - gras_assert(p_dict); + gras_assert(dict); - gras_dictelm_set(&(p_dict->head), key, data, free_ctn); + gras_dictelm_set(&(dict->head), key, data, free_ctn); } /** @@ -111,10 +111,10 @@ gras_dict_set(gras_dict_t *p_dict, * Search the given @key. mismatch_error when not found. */ gras_error_t -gras_dict_get_ext(gras_dict_t *dict, - const char *key, - int key_len, - /* OUT */void **data) { +gras_dict_get_ext(gras_dict_t dict, + const char *key, + int key_len, + /* OUT */void **data) { gras_assert(dict); @@ -132,9 +132,9 @@ gras_dict_get_ext(gras_dict_t *dict, * Search the given @key. mismatch_error when not found. */ gras_error_t -gras_dict_get(gras_dict_t *dict, - const char *key, - /* OUT */void **data) { +gras_dict_get(gras_dict_t dict, + const char *key, + /* OUT */void **data) { gras_assert(dict); return gras_dictelm_get(dict->head, key, data); @@ -151,7 +151,7 @@ gras_dict_get(gras_dict_t *dict, * Remove the entry associated with the given @key */ gras_error_t -gras_dict_remove_ext(gras_dict_t *dict, +gras_dict_remove_ext(gras_dict_t dict, const char *key, int key_len) { gras_assert(dict); @@ -169,7 +169,7 @@ gras_dict_remove_ext(gras_dict_t *dict, * Remove the entry associated with the given @key */ gras_error_t -gras_dict_remove(gras_dict_t *dict, +gras_dict_remove(gras_dict_t dict, const char *key) { if (!dict) RAISE1(mismatch_error,"Asked to remove key %s from NULL dict",key); @@ -190,7 +190,7 @@ gras_dict_remove(gras_dict_t *dict, */ void -gras_dict_dump(gras_dict_t *dict, +gras_dict_dump(gras_dict_t dict, void_f_pvoid_t *output) { printf("Dict %p:\n", (void*)dict); diff --git a/src/xbt/dict_cursor.c b/src/xbt/dict_cursor.c index a4308fbf5c..3b600aa485 100644 --- a/src/xbt/dict_cursor.c +++ b/src/xbt/dict_cursor.c @@ -23,16 +23,16 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(dict_cursor,dict,"To traverse dictionaries"); /*###########################################################################*/ struct gras_dict_cursor_ { /* we store all level encountered until here, to backtrack on next() */ - gras_dynar_t *keys; - gras_dynar_t *key_lens; - int pos; - int pos_len; - gras_dictelm_t *head; + gras_dynar_t keys; + gras_dynar_t key_lens; + int pos; + int pos_len; + gras_dictelm_t head; }; static _GRAS_INLINE void -_cursor_push_keys(gras_dict_cursor_t *p_cursor, - gras_dictelm_t *p_elm); +_cursor_push_keys(gras_dict_cursor_t p_cursor, + gras_dictelm_t p_elm); #undef gras_dict_CURSOR_DEBUG /*#define gras_dict_CURSOR_DEBUG 1*/ @@ -45,17 +45,17 @@ _cursor_push_keys(gras_dict_cursor_t *p_cursor, * * Structure creator */ -gras_dict_cursor_t * -gras_dict_cursor_new(const gras_dict_t *p_head) { +gras_dict_cursor_t +gras_dict_cursor_new(const gras_dict_t head) { gras_error_t errcode = no_error; - gras_dict_cursor_t *res = NULL; + gras_dict_cursor_t res = NULL; - res = gras_new(gras_dict_cursor_t,1); + res = gras_new(s_gras_dict_cursor_t,1); res->keys = gras_dynar_new(sizeof(char **), NULL); res->key_lens = gras_dynar_new(sizeof(int *), NULL); res->pos = 0; res->pos_len = 0; - res->head = p_head ? p_head->head : NULL; + res->head = head ? head->head : NULL; gras_dict_cursor_rewind(res); @@ -70,12 +70,12 @@ gras_dict_cursor_new(const gras_dict_t *p_head) { * Structure destructor */ void -gras_dict_cursor_free(gras_dict_cursor_t *p_cursor) { - if (p_cursor) { - gras_dynar_free(p_cursor->keys); - gras_dynar_free(p_cursor->key_lens); - memset(p_cursor, 0, sizeof(gras_dict_cursor_t)); - gras_free(p_cursor); +gras_dict_cursor_free(gras_dict_cursor_t *cursor) { + if (*cursor) { + gras_dynar_free(&((*cursor)->keys)); + gras_dynar_free(&((*cursor)->key_lens)); + gras_free(*cursor); + *cursor = NULL; } } @@ -86,11 +86,11 @@ gras_dict_cursor_free(gras_dict_cursor_t *p_cursor) { */ static _GRAS_INLINE gras_error_t -__cursor_not_null(gras_dict_cursor_t *p_cursor) { +__cursor_not_null(gras_dict_cursor_t cursor) { - gras_assert0(p_cursor, "Null cursor"); + gras_assert0(cursor, "Null cursor"); - if (!p_cursor->head) { + if (!cursor->head) { return mismatch_error; } @@ -100,24 +100,24 @@ __cursor_not_null(gras_dict_cursor_t *p_cursor) { static _GRAS_INLINE void -_cursor_push_keys(gras_dict_cursor_t *p_cursor, - gras_dictelm_t *p_elm) { +_cursor_push_keys(gras_dict_cursor_t cursor, + gras_dictelm_t elm) { gras_error_t errcode = no_error; - gras_dictelm_t *p_child = NULL; + gras_dictelm_t child = NULL; int i = 0; static volatile int count = 0; /* ??? */ - CDEBUG1(dict_cursor, "Push childs of %p in the cursor", (void*)p_elm); + CDEBUG1(dict_cursor, "Push childs of %p in the cursor", (void*)elm); - if (p_elm->content) { - gras_dynar_push(p_cursor->keys, &p_elm->key ); - gras_dynar_push(p_cursor->key_lens, &p_elm->key_len); + if (elm->content) { + gras_dynar_push(cursor->keys, &elm->key ); + gras_dynar_push(cursor->key_lens, &elm->key_len); count++; } - gras_dynar_foreach(p_elm->sub, i, p_child) { - if (p_child) - _cursor_push_keys(p_cursor, p_child); + gras_dynar_foreach(elm->sub, i, child) { + if (child) + _cursor_push_keys(cursor, child); } CDEBUG1(dict_cursor, "Count = %d", count); @@ -131,22 +131,22 @@ _cursor_push_keys(gras_dict_cursor_t *p_cursor, * back to the first element */ void -gras_dict_cursor_rewind(gras_dict_cursor_t *p_cursor) { +gras_dict_cursor_rewind(gras_dict_cursor_t cursor) { gras_error_t errcode = no_error; CDEBUG0(dict_cursor, "gras_dict_cursor_rewind"); - gras_assert(p_cursor); + gras_assert(cursor); - gras_dynar_reset(p_cursor->keys); - gras_dynar_reset(p_cursor->key_lens); + gras_dynar_reset(cursor->keys); + gras_dynar_reset(cursor->key_lens); - if (!p_cursor->head) + if (!cursor->head) return ; - _cursor_push_keys(p_cursor, p_cursor->head); + _cursor_push_keys(cursor, cursor->head); - gras_dynar_cursor_first(p_cursor->keys, &p_cursor->pos ); - gras_dynar_cursor_first(p_cursor->key_lens, &p_cursor->pos_len); + gras_dynar_cursor_first(cursor->keys, &cursor->pos ); + gras_dynar_cursor_first(cursor->key_lens, &cursor->pos_len); } @@ -157,8 +157,8 @@ gras_dict_cursor_rewind(gras_dict_cursor_t *p_cursor) { * * Create the cursor if it does not exists. Rewind it in any case. */ -void gras_dict_cursor_first (const gras_dict_t *dict, - gras_dict_cursor_t **cursor){ +void gras_dict_cursor_first (const gras_dict_t dict, + gras_dict_cursor_t *cursor){ if (!*cursor) { DEBUG0("Create the cursor on first use"); @@ -176,11 +176,11 @@ void gras_dict_cursor_first (const gras_dict_t *dict, * Move to the next element. */ void -gras_dict_cursor_step(gras_dict_cursor_t *p_cursor) { - gras_assert(p_cursor); +gras_dict_cursor_step(gras_dict_cursor_t cursor) { + gras_assert(cursor); - gras_dynar_cursor_step(p_cursor->keys, &p_cursor->pos); - gras_dynar_cursor_step(p_cursor->key_lens, &p_cursor->pos_len); + gras_dynar_cursor_step(cursor->keys, &cursor->pos); + gras_dynar_cursor_step(cursor->key_lens, &cursor->pos_len); } /** @@ -191,7 +191,7 @@ gras_dict_cursor_step(gras_dict_cursor_t *p_cursor) { * Get current data */ int -gras_dict_cursor_get_or_free(gras_dict_cursor_t **cursor, +gras_dict_cursor_get_or_free(gras_dict_cursor_t *cursor, char **key, void **data) { gras_error_t errcode = no_error; @@ -201,8 +201,7 @@ gras_dict_cursor_get_or_free(gras_dict_cursor_t **cursor, return FALSE; if (gras_dynar_length((*cursor)->keys) <= (*cursor)->pos) { - gras_dict_cursor_free(*cursor); - *cursor=NULL; + gras_dict_cursor_free(cursor); return FALSE; } @@ -211,8 +210,7 @@ gras_dict_cursor_get_or_free(gras_dict_cursor_t **cursor, errcode = gras_dictelm_get_ext((*cursor)->head, *key, key_len, data); if (errcode == mismatch_error) { - gras_dict_cursor_free(*cursor); - *cursor=NULL; + gras_dict_cursor_free(cursor); return FALSE; } @@ -232,13 +230,13 @@ gras_dict_cursor_get_or_free(gras_dict_cursor_t **cursor, * Get current key */ gras_error_t -gras_dict_cursor_get_key(gras_dict_cursor_t *p_cursor, +gras_dict_cursor_get_key(gras_dict_cursor_t cursor, /*OUT*/char **key) { gras_error_t errcode = no_error; - TRY(__cursor_not_null(p_cursor)); + TRY(__cursor_not_null(cursor)); - *key = gras_dynar_get_as(p_cursor->keys, p_cursor->pos - 1, char*); + *key = gras_dynar_get_as(cursor->keys, cursor->pos - 1, char*); return errcode; } @@ -250,18 +248,18 @@ gras_dict_cursor_get_key(gras_dict_cursor_t *p_cursor, * Get current data */ gras_error_t -gras_dict_cursor_get_data(gras_dict_cursor_t *p_cursor, +gras_dict_cursor_get_data(gras_dict_cursor_t cursor, /*OUT*/void **data) { gras_error_t errcode = no_error; char *key = NULL; int key_len = 0; - TRY(__cursor_not_null(p_cursor)); + TRY(__cursor_not_null(cursor)); - key = gras_dynar_get_as(p_cursor->keys, p_cursor->pos-1, char *); - key_len = gras_dynar_get_as(p_cursor->key_lens, p_cursor->pos_len-1, int); + key = gras_dynar_get_as(cursor->keys, cursor->pos-1, char *); + key_len = gras_dynar_get_as(cursor->key_lens, cursor->pos_len-1, int); - TRY(gras_dictelm_get_ext(p_cursor->head, key, key_len, data)); + TRY(gras_dictelm_get_ext(cursor->head, key, key_len, data)); return errcode; } diff --git a/src/xbt/dict_elm.c b/src/xbt/dict_elm.c index 0ee32ad5f2..a2dd56259d 100644 --- a/src/xbt/dict_elm.c +++ b/src/xbt/dict_elm.c @@ -25,8 +25,8 @@ static _GRAS_INLINE void _gras_dictelm_alloc(char *key, int offset, int key_len, void *data, - void_f_pvoid_t *free_ctn, - /*OUT*/gras_dictelm_t **where); + void_f_pvoid_t *free_f, + /*OUT*/s_gras_dictelm_t **where); static void _dictelm_wrapper_free(void*); static _GRAS_INLINE void _str_prefix_lgr(const char *key1, @@ -37,31 +37,31 @@ static _GRAS_INLINE void _str_prefix_lgr(const char *key1, int *match); -static void _gras_dictelm_dump_rec(gras_dictelm_t *head, +static void _gras_dictelm_dump_rec(s_gras_dictelm_t *head, int offset, void_f_pvoid_t *output); -static void _gras_dictelm_set_rec(gras_dictelm_t *head, +static void _gras_dictelm_set_rec(s_gras_dictelm_t *head, char *key, int key_len, int offset, void *data, - void_f_pvoid_t *free_ctn); -static gras_error_t _gras_dictelm_get_rec(gras_dictelm_t *head, + void_f_pvoid_t *free_f); +static gras_error_t _gras_dictelm_get_rec(s_gras_dictelm_t *head, const char *key, int key_len, int offset, /* OUT */void **data); -static gras_error_t _gras_dictelm_remove_rec(gras_dictelm_t *head, +static gras_error_t _gras_dictelm_remove_rec(s_gras_dictelm_t *head, const char *key, int key_len, int offset); static _GRAS_INLINE void -_collapse_if_need(gras_dictelm_t *p_head, +_collapse_if_need(s_gras_dictelm_t *p_head, int pos, int offset); @@ -129,19 +129,19 @@ _gras_dictelm_alloc(char *key, int key_len, int offset, void *data, - void_f_pvoid_t *free_ctn, - /*OUT*/gras_dictelm_t **pp_elm) { + void_f_pvoid_t *free_f, + /*OUT*/s_gras_dictelm_t **pp_elm) { gras_error_t errcode = no_error; - gras_dictelm_t *p_elm = NULL; + s_gras_dictelm_t *p_elm = NULL; - p_elm = gras_new(gras_dictelm_t,1); + p_elm = gras_new(s_gras_dictelm_t,1); p_elm->key = key; p_elm->key_len = key_len; p_elm->offset = offset; p_elm->content = data; - p_elm->free_ctn = free_ctn; - p_elm->sub = gras_dynar_new(sizeof(gras_dictelm_t*), _dictelm_wrapper_free); + p_elm->free_f = free_f; + p_elm->sub = gras_dynar_new(sizeof(s_gras_dictelm_t*), _dictelm_wrapper_free); *pp_elm = p_elm; @@ -155,22 +155,20 @@ _gras_dictelm_alloc(char *key, * Frees a dictionnary element with all its childs. */ void -gras_dictelm_free(gras_dictelm_t **pp_elm) { +gras_dictelm_free(s_gras_dictelm_t **pp_elm) { if (*pp_elm) { - gras_dictelm_t *p_elm = *pp_elm; + s_gras_dictelm_t *p_elm = *pp_elm; - gras_dynar_free(p_elm->sub); + gras_dynar_free(&(p_elm->sub)); if (p_elm->key) { gras_free(p_elm->key); } - if (p_elm->free_ctn && p_elm->content) { - p_elm->free_ctn(p_elm->content); + if (p_elm->free_f && p_elm->content) { + p_elm->free_f(p_elm->content); } - memset(p_elm, 0, sizeof (*p_elm)); - gras_free(p_elm); *pp_elm = NULL; } @@ -185,9 +183,9 @@ static void _dictelm_wrapper_free(void *pp_elm) { DEBUG3("Free dictelm '%.*s' %p", - (*(gras_dictelm_t**)pp_elm)->key_len, (*(gras_dictelm_t**)pp_elm)->key, + (*(s_gras_dictelm_t**)pp_elm)->key_len, (*(s_gras_dictelm_t**)pp_elm)->key, *(void**)pp_elm); - gras_dictelm_free((gras_dictelm_t**)pp_elm); + gras_dictelm_free((s_gras_dictelm_t**)pp_elm); } /*####[ utility functions ]##################################################*/ @@ -258,19 +256,19 @@ _str_prefix_lgr(const char *key1, */ static _GRAS_INLINE void -_dict_child_cmp(gras_dictelm_t *p_dict, +_dict_child_cmp(s_gras_dictelm_t *p_dict, int pos, const char *key, const int key_len, int *p_offset, int *p_match, int *p_cmp) { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; int cmp = 0; int o = *p_offset; int m = *p_match; - p_child = gras_dynar_get_as(p_dict->sub, pos, gras_dictelm_t*); + p_child = gras_dynar_get_as(p_dict->sub, pos, s_gras_dictelm_t*); /* Compute the length of the prefix and if the searched key is before or after cur */ @@ -323,7 +321,7 @@ _dict_child_cmp(gras_dictelm_t *p_dict, */ static _GRAS_INLINE void -_gras_dictelm_child_search(gras_dictelm_t *p_elm, +_gras_dictelm_child_search(s_gras_dictelm_t *p_elm, const char *key, int key_len, int *p_pos, @@ -378,15 +376,15 @@ _gras_dictelm_child_search(gras_dictelm_t *p_elm, */ static _GRAS_INLINE void -_gras_dictelm_change_value(gras_dictelm_t *p_elm, +_gras_dictelm_change_value(s_gras_dictelm_t *p_elm, void *data, - void_f_pvoid_t *free_ctn) { + void_f_pvoid_t *free_f) { - if (p_elm->content && p_elm->free_ctn) { - p_elm->free_ctn(p_elm->content); + if (p_elm->content && p_elm->free_f) { + p_elm->free_f(p_elm->content); } - p_elm->free_ctn = free_ctn; + p_elm->free_f = free_f; p_elm->content = data; } @@ -406,12 +404,12 @@ _gras_dictelm_change_value(gras_dictelm_t *p_elm, * strdup the key before action. */ void -_gras_dictelm_set_rec(gras_dictelm_t *p_head, +_gras_dictelm_set_rec(s_gras_dictelm_t *p_head, char *key, int key_len, int offset, void *data, - void_f_pvoid_t *free_ctn) { + void_f_pvoid_t *free_f) { int match = 0; int pos = 0; const int old_offset = offset; @@ -429,7 +427,7 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, CDEBUG0(dict_add, "--> Change the value of head"); - _gras_dictelm_change_value(p_head, data, free_ctn); + _gras_dictelm_change_value(p_head, data, free_f); gras_free(key); /* Keep the key used in the tree */ return; @@ -445,9 +443,9 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, case 0: /* no child have a common prefix */ { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; - _gras_dictelm_alloc(key, key_len, offset, data, free_ctn, &p_child); + _gras_dictelm_alloc(key, key_len, offset, data, free_f, &p_child); CDEBUG1(dict_add, "-> Add a child %p", (void*)p_child); gras_dynar_insert_at(p_head->sub, pos, &p_child); @@ -456,11 +454,11 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, case 1: /* A child have exactly this key => change its value*/ { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; - p_child = gras_dynar_get_as(p_head->sub, pos, gras_dictelm_t*); + p_child = gras_dynar_get_as(p_head->sub, pos, s_gras_dictelm_t*); CDEBUG1(dict_add, "-> Change the value of the child %p", (void*)p_child); - _gras_dictelm_change_value(p_child, data, free_ctn); + _gras_dictelm_change_value(p_child, data, free_f); gras_free(key); @@ -469,23 +467,23 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, case 2: /* A child constitutes a prefix of the key => recurse */ { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; - p_child=gras_dynar_get_as(p_head->sub, pos, gras_dictelm_t*); + p_child=gras_dynar_get_as(p_head->sub, pos, s_gras_dictelm_t*); CDEBUG2(dict_add,"-> Recurse on %p (offset=%d)", (void*)p_child, offset); _gras_dictelm_set_rec(p_child, key, key_len, - offset, data, free_ctn); + offset, data, free_f); return; } case 3: /* The key is a prefix of the child => child becomes child of p_new */ { - gras_dictelm_t *p_new = NULL; - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_new = NULL; + s_gras_dictelm_t *p_child = NULL; - p_child=gras_dynar_get_as(p_head->sub, pos, gras_dictelm_t*); - _gras_dictelm_alloc(key, key_len, old_offset, data, free_ctn, &p_new); + p_child=gras_dynar_get_as(p_head->sub, pos, s_gras_dictelm_t*); + _gras_dictelm_alloc(key, key_len, old_offset, data, free_f, &p_new); CDEBUG2(dict_add, "-> The child %p become child of new dict (%p)", (void*)p_child, (void*)p_new); @@ -499,14 +497,14 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, case 4: /* A child share a common prefix with this key => Common ancestor */ { - gras_dictelm_t *p_new = NULL; - gras_dictelm_t *p_child = NULL; - gras_dictelm_t *p_anc = NULL; + s_gras_dictelm_t *p_new = NULL; + s_gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_anc = NULL; char *anc_key = NULL; int anc_key_len = offset; - _gras_dictelm_alloc(key, key_len, offset, data, free_ctn, &p_new); - p_child=gras_dynar_get_as(p_head->sub, pos, gras_dictelm_t*); + _gras_dictelm_alloc(key, key_len, offset, data, free_f, &p_new); + p_child=gras_dynar_get_as(p_head->sub, pos, s_gras_dictelm_t*); anc_key = gras_memdup(key, anc_key_len); @@ -547,26 +545,26 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, * of data, as long as its length is provided in @key_len. */ void -gras_dictelm_set_ext(gras_dictelm_t **pp_head, +gras_dictelm_set_ext(s_gras_dictelm_t **pp_head, const char *_key, int key_len, void *data, - void_f_pvoid_t *free_ctn) { - gras_dictelm_t *p_head = *pp_head; + void_f_pvoid_t *free_f) { + s_gras_dictelm_t *p_head = *pp_head; char *key = NULL; key = gras_memdup(_key, key_len); /* there is no head, create it */ if (!p_head) { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; CDEBUG0(dict_add, "Create an head"); /* The head is priviledged by being the only one with a NULL key */ _gras_dictelm_alloc(NULL, 0, 0, NULL, NULL, &p_head); - _gras_dictelm_alloc(key, key_len, 0, data, free_ctn, &p_child); + _gras_dictelm_alloc(key, key_len, 0, data, free_f, &p_child); gras_dynar_insert_at(p_head->sub, 0, &p_child); *pp_head = p_head; @@ -574,7 +572,7 @@ gras_dictelm_set_ext(gras_dictelm_t **pp_head, return; } - _gras_dictelm_set_rec(p_head, key, key_len, 0, data, free_ctn); + _gras_dictelm_set_rec(p_head, key, key_len, 0, data, free_f); } /** @@ -589,12 +587,12 @@ gras_dictelm_set_ext(gras_dictelm_t **pp_head, * null terminated string. */ void -gras_dictelm_set(gras_dictelm_t **pp_head, +gras_dictelm_set(s_gras_dictelm_t **pp_head, const char *_key, void *data, - void_f_pvoid_t *free_ctn) { + void_f_pvoid_t *free_f) { - gras_dictelm_set_ext(pp_head, _key, 1+strlen(_key), data, free_ctn); + gras_dictelm_set_ext(pp_head, _key, 1+strlen(_key), data, free_f); } /** @@ -610,7 +608,7 @@ gras_dictelm_set(gras_dictelm_t **pp_head, */ static gras_error_t -_gras_dictelm_get_rec(gras_dictelm_t *p_head, +_gras_dictelm_get_rec(s_gras_dictelm_t *p_head, const char *key, int key_len, int offset, @@ -644,9 +642,9 @@ _gras_dictelm_get_rec(gras_dictelm_t *p_head, case 1: /* A child have exactly this key => Got it */ { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; - p_child = gras_dynar_get_as(p_head->sub, pos, gras_dictelm_t*); + p_child = gras_dynar_get_as(p_head->sub, pos, s_gras_dictelm_t*); *data = p_child->content; return no_error; @@ -654,9 +652,9 @@ _gras_dictelm_get_rec(gras_dictelm_t *p_head, case 2: /* A child constitutes a prefix of the key => recurse */ { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; - p_child = gras_dynar_get_as(p_head->sub, pos, gras_dictelm_t*); + p_child = gras_dynar_get_as(p_head->sub, pos, s_gras_dictelm_t*); return _gras_dictelm_get_rec(p_child, key, key_len, offset, data); } @@ -684,7 +682,7 @@ _gras_dictelm_get_rec(gras_dictelm_t *p_head, * Search the given @key. mismatch_error when not found. */ gras_error_t -gras_dictelm_get_ext(gras_dictelm_t *p_head, +gras_dictelm_get_ext(s_gras_dictelm_t *p_head, const char *key, int key_len, /* OUT */void **data) { @@ -707,7 +705,7 @@ gras_dictelm_get_ext(gras_dictelm_t *p_head, * Search the given @key. mismatch_error when not found. */ gras_error_t -gras_dictelm_get(gras_dictelm_t *p_head, +gras_dictelm_get(s_gras_dictelm_t *p_head, const char *key, /* OUT */void **data) { @@ -717,54 +715,55 @@ gras_dictelm_get(gras_dictelm_t *p_head, /*----[ _gras_dict_collapse ]------------------------------------------------*/ static _GRAS_INLINE void -_collapse_if_need(gras_dictelm_t *p_head, - int pos, - int offset) { - gras_dictelm_t *p_child = NULL; +_collapse_if_need(gras_dictelm_t head, + int pos, + int offset) { + gras_dictelm_t child = NULL; - CDEBUG2(dict_collapse, "Collapse %d of %p... ", pos, (void*)p_head); + CDEBUG2(dict_collapse, "Collapse %d of %p... ", pos, (void*)head); if (pos >= 0) { /* Remove the child if |it's key| == 0 (meaning it's dead) */ - p_child = gras_dynar_get_as(p_head->sub, pos, gras_dictelm_t*); + child = gras_dynar_get_as(head->sub, pos, gras_dictelm_t); - if (offset >= p_child->key_len) { + if (offset >= child->key_len) { - gras_assert0(gras_dynar_length(p_child->sub) == 0, + gras_assert0(gras_dynar_length(child->sub) == 0, "Found a dead child with grand childs. Internal error"); - CDEBUG1(dict_collapse, "Remove dead child %p.... ", (void*)p_child); - gras_dynar_remove_at(p_head->sub, pos, &p_child); + CDEBUG1(dict_collapse, "Remove dead child %p.... ", (void*)child); + gras_dynar_remove_at(head->sub, pos, &child); + gras_dictelm_free(&child); } } - if (!p_head->key) { + if (!head->key) { CDEBUG0(dict_collapse, "Do not collapse the head, you stupid programm"); return; } - if (p_head->content || p_head->free_ctn || - gras_dynar_length(p_head->sub) != 1) { + if (head->content || head->free_f || + gras_dynar_length(head->sub) != 1) { CDEBUG0(dict_collapse, "Cannot collapse"); return; /* cannot collapse */ } - p_child = gras_dynar_get_as(p_head->sub, 0, gras_dictelm_t*); + child = gras_dynar_get_as(head->sub, 0, gras_dictelm_t); /* Get the child's key as new key */ CDEBUG2(dict_collapse, - "Do collapse with only child %.*s", p_child->key_len, p_child->key); + "Do collapse with only child %.*s", child->key_len, child->key); - p_head->content = p_child->content; - p_head->free_ctn = p_child->free_ctn; - gras_free(p_head->key); - p_head->key = p_child->key; - p_head->key_len = p_child->key_len; + head->content = child->content; + head->free_f = child->free_f; + gras_free(head->key); + head->key = child->key; + head->key_len = child->key_len; - gras_dynar_free_container(p_head->sub) ; + gras_dynar_free_container(&(head->sub)) ; - p_head->sub = p_child->sub; - gras_free(p_child); + head->sub = child->sub; + gras_free(child); } /** @@ -778,7 +777,7 @@ _collapse_if_need(gras_dictelm_t *p_head, * Remove the entry associated with the given @key */ gras_error_t -_gras_dictelm_remove_rec(gras_dictelm_t *p_head, +_gras_dictelm_remove_rec(gras_dictelm_t head, const char *key, int key_len, int offset) { @@ -788,18 +787,18 @@ _gras_dictelm_remove_rec(gras_dictelm_t *p_head, if (offset >= key_len) { int killme = 0; /* do I need to suicide me ? */ - if (p_head->content && p_head->free_ctn) { - p_head->free_ctn(p_head->content); + if (head->content && head->free_f) { + head->free_f(head->content); } - killme = !gras_dynar_length(p_head->sub); - p_head->content = NULL; - p_head->free_ctn = NULL; - _collapse_if_need(p_head, -1, offset); + killme = !gras_dynar_length(head->sub); + head->content = NULL; + head->free_f = NULL; + _collapse_if_need(head, -1, offset); if (killme) { DEBUG0("kill this node"); - p_head->key_len = 0; /* killme. Cleanup done one step higher in recursion */ + head->key_len = 0; /* killme. Cleanup done one step higher in recursion */ } return errcode; @@ -810,7 +809,7 @@ _gras_dictelm_remove_rec(gras_dictelm_t *p_head, int old_offset = offset; /*** Search where is the good child, and how good it is ***/ - _gras_dictelm_child_search(p_head, key, key_len, &pos, &offset, &match); + _gras_dictelm_child_search(head, key, key_len, &pos, &offset, &match); switch (match) { @@ -818,14 +817,14 @@ _gras_dictelm_remove_rec(gras_dictelm_t *p_head, case 2: /* A child constitutes a prefix of the key => recurse */ { - gras_dictelm_t *p_child = NULL; + s_gras_dictelm_t *p_child = NULL; - p_child = gras_dynar_get_as(p_head->sub, pos, gras_dictelm_t*); + p_child = gras_dynar_get_as(head->sub, pos, s_gras_dictelm_t*); /*DEBUG5("Recurse on child %d of %p to remove %.*s (prefix=%d)", pos, (void*)p_child, key+offset, key_len-offset,offset);*/ TRY(_gras_dictelm_remove_rec(p_child, key, key_len, offset)); - _collapse_if_need(p_head, pos, old_offset); + _collapse_if_need(head, pos, old_offset); return no_error; } @@ -854,15 +853,15 @@ _gras_dictelm_remove_rec(gras_dictelm_t *p_head, * Remove the entry associated with the given @key */ gras_error_t -gras_dictelm_remove_ext(gras_dictelm_t *p_head, - const char *key, - int key_len) { +gras_dictelm_remove_ext(gras_dictelm_t head, + const char *key, + int key_len) { /* there is no head, go to hell */ - if (!p_head) { + if (!head) { RAISE0(mismatch_error, "there is no head, go to hell"); } - return _gras_dictelm_remove_rec(p_head, key, key_len, 0); + return _gras_dictelm_remove_rec(head, key, key_len, 0); } /** @@ -875,9 +874,9 @@ gras_dictelm_remove_ext(gras_dictelm_t *p_head, * Remove the entry associated with the given @key */ gras_error_t -gras_dictelm_remove(gras_dictelm_t *p_head, +gras_dictelm_remove(gras_dictelm_t head, const char *key) { - return _gras_dictelm_remove_rec(p_head, key, 1+strlen(key),0); + return _gras_dictelm_remove_rec(head, key, 1+strlen(key),0); } /*----[ _gras_dict_dump_rec ]------------------------------------------------*/ @@ -885,21 +884,21 @@ gras_dictelm_remove(gras_dictelm_t *p_head, /*---------------------------------------------------------------------------*/ static void -_gras_dictelm_dump_rec(gras_dictelm_t *p_head, +_gras_dictelm_dump_rec(gras_dictelm_t head, int offset, void_f_pvoid_t *output) { - gras_dictelm_t *p_child = NULL; - char *key = NULL; - int key_len = 0; - int i = 0; + gras_dictelm_t child = NULL; + char *key = NULL; + int key_len = 0; + int i = 0; - if (!p_head) + if (!head) return; - printf("[%p] ", (void*)p_head); + printf("[%p] ", (void*)head); - key = p_head->key; - key_len = p_head->key_len; + key = head->key; + key_len = head->key_len; if (key_len) printf (" "); @@ -928,10 +927,10 @@ _gras_dictelm_dump_rec(gras_dictelm_t *p_head, printf(" -> "); - if (p_head->content) { + if (head->content) { if (output) { - output(p_head->content); + output(head->content); } else { printf("(data)"); } @@ -940,10 +939,10 @@ _gras_dictelm_dump_rec(gras_dictelm_t *p_head, printf("(null)"); } - printf(" \t\t\t[ %lu child(s) ]\n", gras_dynar_length(p_head->sub)); + printf(" \t\t\t[ %lu child(s) ]\n", gras_dynar_length(head->sub)); - gras_dynar_foreach(p_head->sub, i, p_child) - _gras_dictelm_dump_rec(p_child, p_child->offset, output); + gras_dynar_foreach(head->sub, i, child) + _gras_dictelm_dump_rec(child, child->offset, output); } @@ -959,9 +958,9 @@ _gras_dictelm_dump_rec(gras_dictelm_t *p_head, */ void -gras_dictelm_dump(gras_dictelm_t *p_head, - void_f_pvoid_t *output) { - _gras_dictelm_dump_rec(p_head, 0, output); +gras_dictelm_dump(gras_dictelm_t head, + void_f_pvoid_t *output) { + _gras_dictelm_dump_rec(head, 0, output); } /** diff --git a/src/xbt/dict_multi.c b/src/xbt/dict_multi.c index e1fd5ef723..d77a438192 100644 --- a/src/xbt/dict_multi.c +++ b/src/xbt/dict_multi.c @@ -95,9 +95,9 @@ gras_multidict_set(gras_dictelm_t **pp_head, } TRYCLEAN(gras_multidict_set_ext(pp_head, keycount, key, key_len, data, free_ctn), - free(key_len)); + gras_free(key_len)); - free(key_len); + gras_free(key_len); return errcode; } @@ -182,8 +182,8 @@ gras_multidict_get(gras_dictelm_t *p_head, } TRYCLEAN(gras_multidict_get_ext(p_head, keycount, key, key_len, data), - free(key_len)); - free(key_len); + gras_free(key_len)); + gras_free(key_len); return errcode; } @@ -241,8 +241,8 @@ gras_multidict_remove(gras_dictelm_t *p_head, } TRYCLEAN(gras_multidict_remove_ext(p_head, keycount, key, key_len), - free(key_len)); - free(key_len); + gras_free(key_len)); + gras_free(key_len); return errcode; } diff --git a/src/xbt/dict_private.h b/src/xbt/dict_private.h index b675d2b0e0..04484bce51 100644 --- a/src/xbt/dict_private.h +++ b/src/xbt/dict_private.h @@ -24,43 +24,45 @@ typedef struct gras_dictelm_ { int key_len; int offset; /* offset on the key */ void *content; - void_f_pvoid_t *free_ctn; /*pointer to the function to call to free this ctn*/ + void_f_pvoid_t *free_f; /*pointer to the function to call to free this ctn*/ - gras_dynar_t *sub; /* sub */ -} gras_dictelm_t; + gras_dynar_t sub; /* sub */ +} s_gras_dictelm_t, *gras_dictelm_t; -struct gras_dict_ { - gras_dictelm_t *head; -}; +typedef struct gras_dict_ { + s_gras_dictelm_t *head; +} s_gras_dict_t; + +typedef struct gras_dict_cursor_ s_gras_dict_cursor_t; /*####[ Function prototypes ]################################################*/ -void gras_dictelm_free (gras_dictelm_t **pp_elm); +void gras_dictelm_free (s_gras_dictelm_t **pp_elm); -void gras_dictelm_set (gras_dictelm_t **pp_head, +void gras_dictelm_set (s_gras_dictelm_t **pp_head, const char *_key, void *data, void_f_pvoid_t *free_ctn); -void gras_dictelm_set_ext (gras_dictelm_t **pp_head, +void gras_dictelm_set_ext (s_gras_dictelm_t **pp_head, const char *_key, int key_len, void *data, void_f_pvoid_t *free_ctn); -gras_error_t gras_dictelm_get (gras_dictelm_t *p_head, +gras_error_t gras_dictelm_get (s_gras_dictelm_t *p_head, const char *key, /* OUT */void **data); -gras_error_t gras_dictelm_get_ext (gras_dictelm_t *p_head, +gras_error_t gras_dictelm_get_ext (s_gras_dictelm_t *p_head, const char *key, int key_len, /* OUT */void **data); -gras_error_t gras_dictelm_remove (gras_dictelm_t *p_head, +gras_error_t gras_dictelm_remove (s_gras_dictelm_t *p_head, const char *key); -gras_error_t gras_dictelm_remove_ext(gras_dictelm_t *p_head, +gras_error_t gras_dictelm_remove_ext(s_gras_dictelm_t *p_head, const char *key, int key_len); -void gras_dictelm_dump (gras_dictelm_t *p_head, +void gras_dictelm_dump (s_gras_dictelm_t *p_head, void_f_pvoid_t *output); void gras_dictelm_print_fct (void *data); diff --git a/src/xbt/dynar.c b/src/xbt/dynar.c index df30a43a01..28f04364f2 100644 --- a/src/xbt/dynar.c +++ b/src/xbt/dynar.c @@ -17,13 +17,13 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(dynar,xbt,"Dynamic arrays"); -struct gras_dynar_s { +typedef struct gras_dynar_s { unsigned long size; unsigned long used; unsigned long elmsize; void *data; - void_f_pvoid_t *free; -}; + void_f_pvoid_t *free_f; +} s_gras_dynar_t; #define __sanity_check_dynar(dynar) \ gras_assert0(dynar, \ @@ -52,8 +52,8 @@ void _gras_clear_mem(void * const ptr, static _GRAS_INLINE gras_error_t -_gras_dynar_expand(gras_dynar_t * const dynar, - const int nb) { +_gras_dynar_expand(gras_dynar_t const dynar, + const int nb) { gras_error_t errcode = no_error; const unsigned long old_size = dynar->size; @@ -89,8 +89,8 @@ _gras_dynar_expand(gras_dynar_t * const dynar, static _GRAS_INLINE void * -_gras_dynar_elm(const gras_dynar_t * const dynar, - const unsigned long idx) { +_gras_dynar_elm(const gras_dynar_t dynar, + const unsigned long idx) { char * const data = dynar->data; const unsigned long elmsize = dynar->elmsize; @@ -99,9 +99,9 @@ _gras_dynar_elm(const gras_dynar_t * const dynar, static _GRAS_INLINE void -_gras_dynar_get_elm(void * const dst, - const gras_dynar_t * const dynar, - const unsigned long idx) { +_gras_dynar_get_elm(void * const dst, + const gras_dynar_t dynar, + const unsigned long idx) { void * const elm = _gras_dynar_elm(dynar, idx); const unsigned long elmsize = dynar->elmsize; @@ -110,9 +110,9 @@ _gras_dynar_get_elm(void * const dst, static _GRAS_INLINE void -_gras_dynar_put_elm(const gras_dynar_t * const dynar, - const unsigned long idx, - const void * const src) { +_gras_dynar_put_elm(const gras_dynar_t dynar, + const unsigned long idx, + const void * const src) { void * const elm = _gras_dynar_elm(dynar, idx); const unsigned long elmsize = dynar->elmsize; @@ -128,17 +128,17 @@ _gras_dynar_put_elm(const gras_dynar_t * const dynar, * pointer of pointer. That is to say that dynars can contain either base * types (int, char, double, etc) or pointer of pointers (struct **). */ -gras_dynar_t * +gras_dynar_t gras_dynar_new(const unsigned long elmsize, - void_f_pvoid_t * const free_func) { + void_f_pvoid_t * const free_f) { - gras_dynar_t *dynar = gras_new0(gras_dynar_t,1); + gras_dynar_t dynar = gras_new0(s_gras_dynar_t,1); dynar->size = 0; dynar->used = 0; dynar->elmsize = elmsize; dynar->data = NULL; - dynar->free = free_func; + dynar->free_f = free_f; return dynar; } @@ -151,17 +151,18 @@ gras_dynar_new(const unsigned long elmsize, * its contain points to. */ void -gras_dynar_free_container(gras_dynar_t * const dynar) { - if (dynar) { +gras_dynar_free_container(gras_dynar_t *dynar) { + if (dynar && *dynar) { - if (dynar->data) { - _gras_clear_mem(dynar->data, dynar->size); - gras_free(dynar->data); + if ((*dynar)->data) { + _gras_clear_mem((*dynar)->data, (*dynar)->size); + gras_free((*dynar)->data); } - _gras_clear_mem(dynar, sizeof(gras_dynar_t)); + _gras_clear_mem(*dynar, sizeof(s_gras_dynar_t)); - gras_free(dynar); + gras_free(*dynar); + *dynar=NULL; } } @@ -172,19 +173,17 @@ gras_dynar_free_container(gras_dynar_t * const dynar) { * Frees the content and set the size to 0 */ void -gras_dynar_reset(gras_dynar_t * const dynar) { +gras_dynar_reset(gras_dynar_t const dynar) { __sanity_check_dynar(dynar); DEBUG1("Reset the dynar %p",(void*)dynar); - if (dynar->free) { - gras_dynar_map(dynar, dynar->free); + if (dynar->free_f) { + gras_dynar_map(dynar, dynar->free_f); } - if (dynar->data) { - _gras_clear_mem(dynar->data, dynar->size); + if (dynar->data) gras_free(dynar->data); - } dynar->size = 0; dynar->used = 0; @@ -199,9 +198,9 @@ gras_dynar_reset(gras_dynar_t * const dynar) { */ void -gras_dynar_free(gras_dynar_t * const dynar) { - if (dynar) { - gras_dynar_reset(dynar); +gras_dynar_free(gras_dynar_t * dynar) { + if (dynar && *dynar) { + gras_dynar_reset(*dynar); gras_dynar_free_container(dynar); } } @@ -213,7 +212,7 @@ gras_dynar_free(gras_dynar_t * const dynar) { * Returns the count of elements in a dynar */ unsigned long -gras_dynar_length(const gras_dynar_t * const dynar) { +gras_dynar_length(const gras_dynar_t dynar) { return (dynar ? (unsigned long) dynar->used : (unsigned long)0); } @@ -226,9 +225,9 @@ gras_dynar_length(const gras_dynar_t * const dynar) { * Retrieve a copy of the Nth element of a dynar. */ void -gras_dynar_get_cpy(const gras_dynar_t * const dynar, - const int idx, - void * const dst) { +gras_dynar_get_cpy(const gras_dynar_t dynar, + const int idx, + void * const dst) { __sanity_check_dynar(dynar); __sanity_check_idx(idx); @@ -247,8 +246,8 @@ gras_dynar_get_cpy(const gras_dynar_t * const dynar, * the dynar. Make a copy before fooling with it. */ void* -gras_dynar_get_ptr(const gras_dynar_t * const dynar, - const int idx) { +gras_dynar_get_ptr(const gras_dynar_t dynar, + const int idx) { __sanity_check_dynar(dynar); __sanity_check_idx(idx); @@ -268,7 +267,7 @@ gras_dynar_get_ptr(const gras_dynar_t * const dynar, * use gras_dynar_replace(). */ void -gras_dynar_set(gras_dynar_t * const dynar, +gras_dynar_set(gras_dynar_t dynar, const int idx, const void * const src) { @@ -285,7 +284,7 @@ gras_dynar_set(gras_dynar_t * const dynar, } /** - * gras_dynar_remplace: + * gras_dynar_replace: * @dynar: * @idx: * @object: @@ -295,37 +294,33 @@ gras_dynar_set(gras_dynar_t * const dynar, * previous content, use gras_dynar_set(). */ void -gras_dynar_remplace(gras_dynar_t * const dynar, - const int idx, - const void * const object) { +gras_dynar_replace(gras_dynar_t dynar, + const int idx, + const void * const object) { __sanity_check_dynar(dynar); __sanity_check_idx(idx); - if (idx < dynar->used && dynar->free) { + if (idx < dynar->used && dynar->free_f) { void * const old_object = _gras_dynar_elm(dynar, idx); - dynar->free(old_object); + dynar->free_f(old_object); } gras_dynar_set(dynar, idx, object); } /** - * gras_dynar_insert_at: - * @dynar: - * @idx: - * @src: What will be feeded to the dynar - * - * Set the Nth element of a dynar, expanding the dynar if needed, and - * moving the previously existing value and all subsequent ones to one - * position right in the dynar. + * gras_dynar_insert_at_ptr: + * + * Make room for a new element in the dynar, and return a pointer to + * its position. You can then use regular affectation to set its value + * instead of relying on the slow memcpy */ -void -gras_dynar_insert_at(gras_dynar_t * const dynar, - const int idx, - const void * const src) { - +void * +gras_dynar_insert_at_ptr(gras_dynar_t const dynar, + const int idx) { + __sanity_check_dynar(dynar); __sanity_check_idx(idx); __check_sloppy_inbound_idx(dynar, idx); @@ -338,21 +333,39 @@ gras_dynar_insert_at(gras_dynar_t * const dynar, { const unsigned long nb_shift = old_used - idx; - const unsigned long elmsize = dynar->elmsize; - const unsigned long offset = nb_shift*elmsize; - - void * const elm_src = _gras_dynar_elm(dynar, idx); - void * const elm_dst = _gras_dynar_elm(dynar, idx+1); - - memmove(elm_dst, elm_src, offset); + if (nb_shift) + memmove(_gras_dynar_elm(dynar, idx+1), + _gras_dynar_elm(dynar, idx), + nb_shift * dynar->elmsize); } - _gras_dynar_put_elm(dynar, idx, src); dynar->used = new_used; + return _gras_dynar_elm(dynar,idx); } } +/** + * gras_dynar_insert_at: + * @dynar: + * @idx: + * @src: What will be feeded to the dynar + * + * Set the Nth element of a dynar, expanding the dynar if needed, and + * moving the previously existing value and all subsequent ones to one + * position right in the dynar. + */ +void +gras_dynar_insert_at(gras_dynar_t const dynar, + const int idx, + const void * const src) { + + /* checks done in gras_dynar_insert_at_ptr */ + memcpy(gras_dynar_insert_at_ptr(dynar,idx), + src, + dynar->elmsize); +} + /** * gras_dynar_remove_at: * @dynar: @@ -363,7 +376,7 @@ gras_dynar_insert_at(gras_dynar_t * const dynar, * all subsequent values to one position left in the dynar. */ void -gras_dynar_remove_at(gras_dynar_t * const dynar, +gras_dynar_remove_at(gras_dynar_t const dynar, const int idx, void * const object) { @@ -392,6 +405,16 @@ gras_dynar_remove_at(gras_dynar_t * const dynar, } } +/** + * gras_dynar_push_ptr: + * + * Make room at the end of the dynar for a new element, and return a pointer to it + */ +void * +gras_dynar_push_ptr(gras_dynar_t const dynar) { + return gras_dynar_insert_at_ptr(dynar, dynar->used); +} + /** * gras_dynar_push: * @dynar: @@ -400,10 +423,26 @@ gras_dynar_remove_at(gras_dynar_t * const dynar, * Add an element at the end of the dynar */ void -gras_dynar_push(gras_dynar_t * const dynar, +gras_dynar_push(gras_dynar_t const dynar, const void * const src) { - __sanity_check_dynar(dynar); - gras_dynar_insert_at(dynar, dynar->used, src); + /* sanity checks done by insert_at */ + gras_dynar_insert_at(dynar, dynar->used, src); +} + +/** + * gras_dynar_pop_ptr: + * @dynar: + * @dst: + * + * Make the last element of the dynar as unused and return a pointer to it. + */ +void * +gras_dynar_pop_ptr(gras_dynar_t const dynar) { + + __check_populated_dynar(dynar); + DEBUG1("Pop %p",(void*)dynar); + dynar->used--; + return _gras_dynar_elm(dynar,dynar->used); } /** @@ -414,10 +453,10 @@ gras_dynar_push(gras_dynar_t * const dynar, * Get and remove the last element of the dynar */ void -gras_dynar_pop(gras_dynar_t * const dynar, +gras_dynar_pop(gras_dynar_t const dynar, void * const dst) { - __sanity_check_dynar(dynar); - __check_populated_dynar(dynar); + + /* sanity checks done by remove_at */ DEBUG1("Pop %p",(void*)dynar); gras_dynar_remove_at(dynar, dynar->used-1, dst); } @@ -431,9 +470,10 @@ gras_dynar_pop(gras_dynar_t * const dynar, * gras_dynar_push() when possible) */ void -gras_dynar_unshift(gras_dynar_t * const dynar, +gras_dynar_unshift(gras_dynar_t const dynar, const void * const src) { - __sanity_check_dynar(dynar); + + /* sanity checks done by insert_at */ gras_dynar_insert_at(dynar, 0, src); } @@ -446,11 +486,10 @@ gras_dynar_unshift(gras_dynar_t * const dynar, * gras_dynar_pop() when possible) */ void -gras_dynar_shift(gras_dynar_t * const dynar, +gras_dynar_shift(gras_dynar_t const dynar, void * const dst) { - __sanity_check_dynar(dynar); - __check_populated_dynar(dynar); + /* sanity checks done by remove_at */ gras_dynar_remove_at(dynar, 0, dst); } @@ -463,7 +502,7 @@ gras_dynar_shift(gras_dynar_t * const dynar, * value of the element itself, but should not mess with the dynar). */ void -gras_dynar_map(const gras_dynar_t * const dynar, +gras_dynar_map(const gras_dynar_t dynar, void_f_pvoid_t * const operator) { __sanity_check_dynar(dynar); @@ -492,10 +531,9 @@ gras_dynar_map(const gras_dynar_t * const dynar, * */ void -gras_dynar_cursor_first(const gras_dynar_t * const dynar, - int * const cursor) { +gras_dynar_cursor_first(const gras_dynar_t dynar, + int * const cursor) { - __sanity_check_dynar(dynar); DEBUG1("Set cursor on %p to the first position",(void*)dynar); *cursor = 0; } @@ -506,10 +544,9 @@ gras_dynar_cursor_first(const gras_dynar_t * const dynar, * Move the cursor to the next value (and return true), or return false. */ void -gras_dynar_cursor_step(const gras_dynar_t * const dynar, - int * const cursor) { +gras_dynar_cursor_step(const gras_dynar_t dynar, + int * const cursor) { - __sanity_check_dynar(dynar); (*cursor)++; } @@ -519,7 +556,7 @@ gras_dynar_cursor_step(const gras_dynar_t * const dynar, * Get the current value of the cursor */ int -gras_dynar_cursor_get(const gras_dynar_t * const dynar, +gras_dynar_cursor_get(const gras_dynar_t dynar, int * const cursor, void * const dst) { @@ -547,25 +584,25 @@ gras_dynar_cursor_get(const gras_dynar_t * const dynar, * * Remove (free) the entry pointed by the cursor, for use in the middle of a foreach */ -void gras_dynar_cursor_rm(gras_dynar_t * dynar, +void gras_dynar_cursor_rm(gras_dynar_t dynar, int * const cursor) { void *dst; if (dynar->elmsize > sizeof(void*)) { DEBUG0("Elements too big to fit into a pointer"); - if (dynar->free) { + if (dynar->free_f) { dst=gras_malloc(dynar->elmsize); gras_dynar_remove_at(dynar,(*cursor)--,dst); - (dynar->free)(dst); + (dynar->free_f)(dst); gras_free(dst); } else { - DEBUG0("Ok, we dont care about the element when no free function"); + DEBUG0("Ok, we dont care about the element without free function"); gras_dynar_remove_at(dynar,(*cursor)--,NULL); } } else { gras_dynar_remove_at(dynar,(*cursor)--,&dst); - if (dynar->free) - (dynar->free)(dst); + if (dynar->free_f) + (dynar->free_f)(dst); } } diff --git a/src/xbt/error.c b/src/xbt/error.c index fa12a0a8b9..9cf52d5fd6 100644 --- a/src/xbt/error.c +++ b/src/xbt/error.c @@ -34,3 +34,11 @@ const char *gras_error_name(gras_error_t errcode) { } } +GRAS_LOG_EXTERNAL_CATEGORY(gras); +GRAS_LOG_DEFAULT_CATEGORY(gras); + +void gras_die (const char *msg) { + CRITICAL1("%s",msg); + gras_abort(); +} + diff --git a/src/xbt/log.c b/src/xbt/log.c index 364edb1e12..3cfad1ee42 100644 --- a/src/xbt/log.c +++ b/src/xbt/log.c @@ -21,15 +21,15 @@ typedef struct { char *catname; - gras_log_priority_t thresh; -} gras_log_setting_t; + e_gras_log_priority_t thresh; +} s_gras_log_setting_t,*gras_log_setting_t; -static gras_dynar_t *gras_log_settings=NULL; +static gras_dynar_t gras_log_settings=NULL; static void _free_setting(void *s) { - gras_log_setting_t *set=(gras_log_setting_t*)s; + gras_log_setting_t set=(gras_log_setting_t)s; if (set) { gras_free(set->catname); -/* free(set); FIXME: uncommenting this leads to segfault when more than one chunk is passed as gras-log */ +/* gras_free(set); FIXME: uncommenting this leads to segfault when more than one chunk is passed as gras-log */ } } @@ -44,7 +44,7 @@ const char *gras_log_priority_names[8] = { "CRITICAL" }; -gras_log_category_t _GRAS_LOGV(GRAS_LOG_ROOT_CAT) = { +s_gras_log_category_t _GRAS_LOGV(GRAS_LOG_ROOT_CAT) = { 0, 0, 0, "root", gras_log_priority_uninitialized, 0, NULL, 0 @@ -55,9 +55,9 @@ GRAS_LOG_NEW_SUBCATEGORY(xbt,GRAS_LOG_ROOT_CAT,"All XBT categories (gras toolbox GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(log,xbt,"Loggings from the logging mecanism itself"); -static void _apply_control(gras_log_category_t* cat) { +static void _apply_control(gras_log_category_t cat) { int cursor; - gras_log_setting_t *setting=NULL; + gras_log_setting_t setting=NULL; int found = 0; if (!gras_log_settings) @@ -77,8 +77,8 @@ static void _apply_control(gras_log_category_t* cat) { gras_dynar_cursor_rm(gras_log_settings,&cursor); if (cat->threshold <= gras_log_priority_verbose) { - gras_log_event_t _log_ev = - {cat,gras_log_priority_verbose,__FILE__,__FUNCTION__,__LINE__}; + s_gras_log_event_t _log_ev = + {cat,gras_log_priority_verbose,__FILE__,_GRAS_GNUC_FUNCTION,__LINE__}; _gras_log_event_log(&_log_ev, "Apply settings for category '%s': set threshold to %s (=%d)", cat->name, @@ -87,8 +87,8 @@ static void _apply_control(gras_log_category_t* cat) { } } if (!found && cat->threshold <= gras_log_priority_verbose) { - gras_log_event_t _log_ev = - {cat,gras_log_priority_verbose,__FILE__,__FUNCTION__,__LINE__}; + s_gras_log_event_t _log_ev = + {cat,gras_log_priority_verbose,__FILE__,_GRAS_GNUC_FUNCTION,__LINE__}; _gras_log_event_log(&_log_ev, "Category '%s': inherited threshold = %s (=%d)", cat->name, @@ -97,11 +97,11 @@ static void _apply_control(gras_log_category_t* cat) { } -void _gras_log_event_log( gras_log_event_t* ev, const char *fmt, ...) { - gras_log_category_t* cat = ev->cat; +void _gras_log_event_log( gras_log_event_t ev, const char *fmt, ...) { + gras_log_category_t cat = ev->cat; va_start(ev->ap, fmt); while(1) { - gras_log_appender_t* appender = cat->appender; + gras_log_appender_t appender = cat->appender; if (appender != NULL) { appender->do_append(appender, ev, fmt); } @@ -113,7 +113,7 @@ void _gras_log_event_log( gras_log_event_t* ev, const char *fmt, ...) { va_end(ev->ap); } -static void _cat_init(gras_log_category_t* category) { +static void _cat_init(gras_log_category_t category) { if (category == &_GRAS_LOGV(GRAS_LOG_ROOT_CAT)) { category->threshold = gras_log_priority_info; category->appender = gras_log_default_appender; @@ -128,23 +128,23 @@ static void _cat_init(gras_log_category_t* category) { * initialization. * Also resets threshold to inherited! */ -int _gras_log_cat_init(gras_log_priority_t priority, - gras_log_category_t* category) { +int _gras_log_cat_init(e_gras_log_priority_t priority, + gras_log_category_t category) { _cat_init(category); return priority >= category->threshold; } -void gras_log_parent_set(gras_log_category_t* cat, - gras_log_category_t* parent) { +void gras_log_parent_set(gras_log_category_t cat, + gras_log_category_t parent) { gras_assert0(cat,"NULL category to be given a parent"); gras_assert1(parent,"The parent category of %s is NULL",cat->name); /* unlink from current parent */ if (cat->threshold != gras_log_priority_uninitialized) { - gras_log_category_t** cpp = &parent->firstChild; + gras_log_category_t* cpp = &parent->firstChild; while(*cpp != cat && *cpp != NULL) { cpp = &(*cpp)->nextSibling; } @@ -167,8 +167,8 @@ void gras_log_parent_set(gras_log_category_t* cat, cat->isThreshInherited = 1; } /* log_setParent */ -static void _set_inherited_thresholds(gras_log_category_t* cat) { - gras_log_category_t* child = cat->firstChild; +static void _set_inherited_thresholds(gras_log_category_t cat) { + gras_log_category_t child = cat->firstChild; for( ; child != NULL; child = child->nextSibling) { if (child->isThreshInherited) { if (cat != &_GRAS_LOGV(log)) @@ -180,15 +180,15 @@ static void _set_inherited_thresholds(gras_log_category_t* cat) { } } -void gras_log_threshold_set(gras_log_category_t* cat, - gras_log_priority_t threshold) { +void gras_log_threshold_set(gras_log_category_t cat, + e_gras_log_priority_t threshold) { cat->threshold = threshold; cat->isThreshInherited = 0; _set_inherited_thresholds(cat); } -static void _gras_log_parse_setting(const char* control_string, - gras_log_setting_t *set) { +static void _gras_log_parse_setting(const char* control_string, + gras_log_setting_t set) { const char *name, *dot, *eq; set->catname=NULL; @@ -243,9 +243,10 @@ static void _gras_log_parse_setting(const char* control_string, DEBUG1("This is for cat '%s'", set->catname); } -static gras_error_t _gras_log_cat_searchsub(gras_log_category_t *cat,char *name,gras_log_category_t**whereto) { +static gras_error_t _gras_log_cat_searchsub(gras_log_category_t cat,char *name, + /*OUT*/gras_log_category_t*whereto) { gras_error_t errcode; - gras_log_category_t *child; + gras_log_category_t child; if (!strcmp(cat->name,name)) { *whereto=cat; @@ -311,7 +312,7 @@ static void _cleanup_double_spaces(char *s) { */ void gras_log_control_set(const char* control_string) { gras_error_t errcode; - gras_log_setting_t *set; + gras_log_setting_t set; char *cs; char *p; int done = 0; @@ -320,16 +321,16 @@ void gras_log_control_set(const char* control_string) { if (control_string == NULL) return; if (gras_log_settings == NULL) - gras_log_settings = gras_dynar_new(sizeof(gras_log_setting_t*), + gras_log_settings = gras_dynar_new(sizeof(gras_log_setting_t), _free_setting); - set = gras_new(gras_log_setting_t,1); + set = gras_new(s_gras_log_setting_t,1); cs=gras_strdup(control_string); _cleanup_double_spaces(cs); while (!done) { - gras_log_category_t *cat; + gras_log_category_t cat; p=strrchr(cs,' '); if (p) { @@ -347,7 +348,7 @@ void gras_log_control_set(const char* control_string) { DEBUG1("push %p to the settings",(void*)set); gras_dynar_push(gras_log_settings,&set); /* malloc in advance the next slot */ - set = gras_new(gras_log_setting_t,1); + set = gras_new(s_gras_log_setting_t,1); } else { DEBUG0("Apply directly"); gras_free(set->catname); @@ -358,12 +359,12 @@ void gras_log_control_set(const char* control_string) { gras_free(cs); } -void gras_log_appender_set(gras_log_category_t* cat, gras_log_appender_t* app) { +void gras_log_appender_set(gras_log_category_t cat, gras_log_appender_t app) { cat->appender = app; } void gras_log_exit(void) { VERB0("Exiting log"); - gras_dynar_free(gras_log_settings); + gras_dynar_free(&gras_log_settings); VERB0("Exited log"); } diff --git a/src/xbt/log_default_appender.c b/src/xbt/log_default_appender.c index 931e6899fd..c96adb63ea 100644 --- a/src/xbt/log_default_appender.c +++ b/src/xbt/log_default_appender.c @@ -21,7 +21,7 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(log_app,log,"default logging handler"); extern const char *gras_log_priority_names[7]; -static void append_file(gras_log_appender_t* this, gras_log_event_t* ev, +static void append_file(gras_log_appender_t this, gras_log_event_t ev, const char *fmt); /* @@ -31,13 +31,13 @@ struct gras_log_appender_file_s { }; */ -static gras_log_appender_t gras_log_appender_file = { append_file, NULL } ; +static s_gras_log_appender_t gras_log_appender_file = { append_file, NULL } ; /* appender_data=FILE* */ -gras_log_appender_t* gras_log_default_appender = &gras_log_appender_file; +gras_log_appender_t gras_log_default_appender = &gras_log_appender_file; -static void append_file(gras_log_appender_t* this, - gras_log_event_t* ev, +static void append_file(gras_log_appender_t this, + gras_log_event_t ev, const char *fmt) { /* TODO: define a format field in struct for timestamp, etc. diff --git a/src/xbt/set.c b/src/xbt/set.c index ff05014417..fe86a9775b 100644 --- a/src/xbt/set.c +++ b/src/xbt/set.c @@ -20,10 +20,10 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(set,xbt,"data container consisting in dict+dynar"); /*####[ Type definition ]####################################################*/ -struct gras_set_ { - gras_dict_t *dict; /* data stored by name */ - gras_dynar_t *dynar; /* data stored by ID */ -}; +typedef struct gras_set_ { + gras_dict_t dict; /* data stored by name */ + gras_dynar_t dynar; /* data stored by ID */ +} s_gras_set_t; /*####[ Memory ]############################################################*/ /** @@ -32,8 +32,8 @@ struct gras_set_ { * * Creates a new set. */ -gras_set_t *gras_set_new (void) { - gras_set_t *res=gras_new(gras_set_t,1); +gras_set_t gras_set_new (void) { + gras_set_t res=gras_new(s_gras_set_t,1); gras_error_t errcode; res->dict=gras_dict_new (); @@ -48,12 +48,12 @@ gras_set_t *gras_set_new (void) { * * Frees a set. */ -void gras_set_free(gras_set_t **set) { +void gras_set_free(gras_set_t *set) { if (*set) { gras_dict_free ( &( (*set)->dict ) ); - gras_dynar_free( (*set)->dynar ); + gras_dynar_free( &( (*set)->dynar ) ); gras_free(*set); - *set=NULL; + *set = NULL; } } @@ -69,12 +69,12 @@ void gras_set_free(gras_set_t **set) { * elm->name_len is used as is unless it's <= 0 (in which case it's recomputed); * elm->ID is attributed automatically. */ -void gras_set_add (gras_set_t *set, - gras_set_elm_t *elm, +void gras_set_add (gras_set_t set, + gras_set_elm_t elm, void_f_pvoid_t *free_func) { - gras_error_t errcode; - gras_set_elm_t *found_in_dict; + gras_error_t errcode; + gras_set_elm_t found_in_dict; if (elm->name_len <= 0) { elm->name_len = strlen(elm->name); @@ -114,9 +114,9 @@ void gras_set_add (gras_set_t *set, * * get a data stored in the cell by providing its name. */ -gras_error_t gras_set_get_by_name (gras_set_t *set, +gras_error_t gras_set_get_by_name (gras_set_t set, const char *name, - /* OUT */gras_set_elm_t **dst) { + /* OUT */gras_set_elm_t *dst) { gras_error_t errcode; errcode = gras_dict_get_ext(set->dict, name, strlen(name), (void**) dst); DEBUG2("Lookup key %s: %s",name,gras_error_name(errcode)); @@ -133,10 +133,10 @@ gras_error_t gras_set_get_by_name (gras_set_t *set, * of the name, when strlen cannot be trusted because you don't use a char* * as name, you weird guy). */ -gras_error_t gras_set_get_by_name_ext(gras_set_t *set, +gras_error_t gras_set_get_by_name_ext(gras_set_t set, const char *name, int name_len, - /* OUT */gras_set_elm_t **dst) { + /* OUT */gras_set_elm_t *dst) { return gras_dict_get_ext (set->dict, name, name_len, (void**)dst); } @@ -150,13 +150,13 @@ gras_error_t gras_set_get_by_name_ext(gras_set_t *set, * get a data stored in the cell by providing its id. * @warning, if the ID does not exists, you're getting into trouble */ -gras_error_t gras_set_get_by_id (gras_set_t *set, +gras_error_t gras_set_get_by_id (gras_set_t set, int id, - /* OUT */gras_set_elm_t **dst) { + /* OUT */gras_set_elm_t *dst) { /* Don't bother checking the bounds, the dynar does so */ - *dst = gras_dynar_get_as(set->dynar,id,gras_set_elm_t *); + *dst = gras_dynar_get_as(set->dynar,id,gras_set_elm_t); DEBUG3("Lookup type of id %d (of %lu): %s", id, gras_dynar_length(set->dynar), (*dst)->name); @@ -166,10 +166,10 @@ gras_error_t gras_set_get_by_id (gras_set_t *set, /*** *** Cursors ***/ -struct gras_set_cursor_ { - gras_set_t *set; +typedef struct gras_set_cursor_ { + gras_set_t set; int val; -}; +} s_gras_set_cursor_t; /** * gras_set_cursor_first: @@ -178,13 +178,13 @@ struct gras_set_cursor_ { * * Create the cursor if it does not exists. Rewind it in any case. */ -void gras_set_cursor_first (gras_set_t *set, - gras_set_cursor_t **cursor) { +void gras_set_cursor_first (gras_set_t set, + gras_set_cursor_t *cursor) { if (set != NULL) { if (!*cursor) { DEBUG0("Create the cursor on first use"); - *cursor = gras_new(gras_set_cursor_t,1); + *cursor = gras_new(s_gras_set_cursor_t,1); gras_assert0(*cursor, "Malloc error during the creation of the cursor"); } @@ -201,7 +201,7 @@ void gras_set_cursor_first (gras_set_t *set, * * Move to the next element. */ -void gras_set_cursor_step (gras_set_cursor_t *cursor) { +void gras_set_cursor_step (gras_set_cursor_t cursor) { gras_dynar_cursor_step(cursor->set->dynar, &( cursor->val ) ); } @@ -212,9 +212,9 @@ void gras_set_cursor_step (gras_set_cursor_t *cursor) { * * Get current data */ -int gras_set_cursor_get_or_free (gras_set_cursor_t **curs, - gras_set_elm_t **elm) { - gras_set_cursor_t *cursor; +int gras_set_cursor_get_or_free (gras_set_cursor_t *curs, + gras_set_elm_t *elm) { + gras_set_cursor_t cursor; if (!curs || !(*curs)) return FALSE; diff --git a/src/xbt/sysdep.c b/src/xbt/sysdep.c index f7408972e7..0734456c75 100644 --- a/src/xbt/sysdep.c +++ b/src/xbt/sysdep.c @@ -18,42 +18,6 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(sysdep, xbt, "System dependency"); -/**** - **** Memory management - ****/ - -void* gras_malloc (long int bytes) { - void *ptr = (bytes == 0 ? NULL : (void*) malloc ((size_t) bytes)); - gras_assert1(ptr, "Malloc of %ld bytes failed",bytes); - return ptr; -} -void* gras_malloc0 (long int bytes) { - void *ptr = (bytes == 0 ? NULL : (void*) calloc ((size_t) bytes, 1)); - gras_assert1(ptr, "Malloc of %ld bytes failed",bytes); - return ptr; -} - -void* gras_realloc (void *memory, long int bytes) { - if (bytes == 0) { - gras_free(memory); - return NULL; - } else { - void *ptr = (void*) realloc (memory, (size_t) bytes); - gras_assert1(ptr, "Realloc of %ld bytes failed",bytes); - return ptr; - } -} -char* gras_strdup (const char* str) { - char *ret = (char*)strdup(str); - gras_assert0(ret, "String duplication failed"); - return ret; -} - -void gras_free (void *memory) { - if (memory) - free (memory); -} - /**** **** Misc ****/