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);
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);
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;
* 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);
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);
* 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);
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)
* 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);
}
* 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;
}
*/
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");
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);
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");
}
* 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:
* 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;
}
*
* 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);
}
*
* 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);
}
*
* 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);
}
*
* 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);
}
*
* 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);
}
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);
}
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)
gras_datadesc_exit(void) {
VERB0("Exiting DataDesc");
gras_set_free(&gras_datadesc_set_local);
- gras_datadesc_set_local = NULL;
DEBUG0("Exited DataDesc");
}
* 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;
}
/**
* 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;
}
* 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];
}
*
* 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:");
}
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) {
#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 */
*/
#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 *
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);
* 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;
*/
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;
* 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;
* 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;
*
* Type descriptor.
*/
-struct s_gras_datadesc_type {
+typedef struct s_gras_datadesc_type {
/* headers for the data set */
unsigned int code;
char *name;
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);
/****************************************************
* 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);
* 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;
* 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;
}
*
* 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 {
*
* 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);
}
/**
*
* 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;
* 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)
*
* 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);
}
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;
* 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?)",
"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("----------------");
}
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;
}
* 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;
}
/**
* (default)
*/
void
-gras_datadesc_cycle_unset(gras_datadesc_type_t *ddt) {
+gras_datadesc_cycle_unset(gras_datadesc_type_t ddt) {
ddt->cycle = 0;
}
*
* 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);
* 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);
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;
}
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;
}
/**
*
* 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);
*
* 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);
*
* 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);
*
* 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);
* 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);
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;
}
* 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;
}
* 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;
}
*
* 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;
* 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;
}
* 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)) {
* 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;
}
*/
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:
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;
}
"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);
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,
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");
}
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) {
}
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] */
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;
}
* 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 */
}
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);
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);
* 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]);
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,
}
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;
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)
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; cpt<count; cpt++) {
TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, ptr, detect_cycle || sub_type->cycle));
* 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);
* 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,
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);
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;
}
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;
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,
/* 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)
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];
*
*/
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();
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) {
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;
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;
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;
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;
}
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;
} 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));
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 */
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));
*
* 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;
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 \
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);
gras_msg_exit(void) {
VERB0("Exiting Msg");
gras_set_free(&_gras_msgtype_set);
- _gras_msgtype_set = NULL;
}
/**
* 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);
*
* 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);
}
* 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).",
}
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);
}
*
* 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);
}
/**
*
* 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);
* 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,
* 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;
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'",
* 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;
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;
}
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 */
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;
}
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();
/* 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);
*
* 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;
/* 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);
*/
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);
*/
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;
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) {
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;
*/
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();
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 */
#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 */
* 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);
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 */
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;
*/
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);
}
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 */
* 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,
* 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,
* 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);
}
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) {
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){
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);
/***
*** 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);
/***
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 */
*** 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);
/***
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;
}
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;
* 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;
}
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;
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;
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);
}
* 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) {
* 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) {
* 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;
/***
*** 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);
*/
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;
*/
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;
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 */
* 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) {
* 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) {
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);
}
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;
}
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;
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;
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;
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;
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();
}
/* 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,
*** 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);
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;
* 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;
}
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;
}
}
-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 */
* 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) {
* 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) {
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,
*/
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 */
/* 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);
*/
-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,
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;
}
*/
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);
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;
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"};
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);
*/
-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();
}
/**
*/
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);
}
/**
* 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;
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;
}
*/
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);
}
*/
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);
}
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;
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);
}
/**
*/
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);
}
/**
*/
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) {
*/
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.",
cell->min,
gras_cfgelm_type_name[cell->type],
size);
- gras_dict_cursor_free(cursor);
+ gras_dict_cursor_free(&cursor);
return mismatch_error;
}
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) {
*/
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",
* @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;
* 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;
*/
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;
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;
* 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);
*/
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);
*/
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);
*/
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);
*
* 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;
* 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;
* 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;
*/
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;
*/
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);
* @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));
*/
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));
* @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;
* @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));
*
* @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",
*
* 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;
}
* 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;
}
}
* 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);
}
* 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);
}
/**
* 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);
* 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);
* 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);
* 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);
*/
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);
/*###########################################################################*/
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*/
*
* 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);
* 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;
}
}
*/
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;
}
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);
* 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);
}
*
* 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");
* 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);
}
/**
* 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;
return FALSE;
if (gras_dynar_length((*cursor)->keys) <= (*cursor)->pos) {
- gras_dict_cursor_free(*cursor);
- *cursor=NULL;
+ gras_dict_cursor_free(cursor);
return FALSE;
}
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;
}
* 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;
}
* 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;
}
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,
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);
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;
* 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;
}
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 ]##################################################*/
*/
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 */
*/
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,
*/
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;
}
* 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;
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;
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);
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);
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);
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);
* 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;
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);
}
/**
* 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);
}
/**
*/
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,
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;
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);
}
* 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) {
* 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) {
/*----[ _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);
}
/**
* 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) {
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;
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) {
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;
}
* 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);
}
/**
* 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 ]------------------------------------------------*/
/*---------------------------------------------------------------------------*/
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 (" ");
printf(" -> ");
- if (p_head->content) {
+ if (head->content) {
if (output) {
- output(p_head->content);
+ output(head->content);
} else {
printf("(data)");
}
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);
}
*/
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);
}
/**
}
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;
}
}
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;
}
}
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;
}
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);
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, \
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;
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;
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;
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;
* 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;
}
* 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;
}
}
* 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;
*/
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);
}
}
* 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);
}
* 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);
* 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);
* 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) {
}
/**
- * gras_dynar_remplace:
+ * gras_dynar_replace:
* @dynar:
* @idx:
* @object:
* 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);
{
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:
* 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) {
}
}
+/**
+ * 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:
* 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);
}
/**
* 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);
}
* 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);
}
* 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);
}
* 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);
*
*/
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;
}
* 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)++;
}
* 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) {
*
* 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);
}
}
}
}
+GRAS_LOG_EXTERNAL_CATEGORY(gras);
+GRAS_LOG_DEFAULT_CATEGORY(gras);
+
+void gras_die (const char *msg) {
+ CRITICAL1("%s",msg);
+ gras_abort();
+}
+
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 */
}
}
"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
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)
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,
}
}
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,
}
-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);
}
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;
* 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;
}
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))
}
}
-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;
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;
*/
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;
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) {
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);
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");
}
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);
/*
};
*/
-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.
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 ]############################################################*/
/**
*
* 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 ();
*
* 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;
}
}
* 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);
*
* 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));
* 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);
}
* 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);
/***
*** 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:
*
* 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");
}
*
* 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 ) );
}
*
* 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;
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
****/
