From 8bd1d4d43b1cbdeec15247821932f6ca0971fd96 Mon Sep 17 00:00:00 2001 From: Frederic Suter Date: Tue, 15 Mar 2016 01:34:19 +0100 Subject: [PATCH] what a wonderful night in XBT ... --- src/xbt/RngStream.c | 75 +------ src/xbt/backtrace_linux.c | 51 ++--- src/xbt/config.c | 333 ++++++++-------------------- src/xbt/cunit.c | 140 ++++-------- src/xbt/dict.c | 206 +++++------------ src/xbt/dict_cursor.c | 25 +-- src/xbt/dict_elm.c | 15 +- src/xbt/dict_private.h | 7 +- src/xbt/dynar.c | 377 ++++++++++---------------------- src/xbt/ex.c | 31 +-- src/xbt/fifo.c | 21 +- src/xbt/fifo_private.h | 1 - src/xbt/graph.c | 30 +-- src/xbt/heap.c | 31 +-- src/xbt/lib.c | 3 +- src/xbt/log.c | 114 +++------- src/xbt/log_private.h | 6 +- src/xbt/mallocator.c | 92 +++----- src/xbt/memory_map.cpp | 18 +- src/xbt/parmap.cpp | 19 +- src/xbt/swag.c | 32 +-- src/xbt/xbt_log_appender_file.c | 18 +- src/xbt/xbt_log_layout_format.c | 7 +- src/xbt/xbt_log_layout_simple.c | 19 +- src/xbt/xbt_main.c | 5 +- src/xbt/xbt_matrix.c | 45 ++-- src/xbt/xbt_os_file.c | 18 +- src/xbt/xbt_os_synchro.c | 6 +- src/xbt/xbt_os_thread.c | 16 +- src/xbt/xbt_os_time.c | 25 +-- src/xbt/xbt_replay.c | 18 +- src/xbt/xbt_str.c | 56 ++--- src/xbt/xbt_strbuff.c | 49 ++--- src/xbt_modinter.h | 2 - 34 files changed, 553 insertions(+), 1358 deletions(-) diff --git a/src/xbt/RngStream.c b/src/xbt/RngStream.c index e4dbbb5a74..816d5d6497 100644 --- a/src/xbt/RngStream.c +++ b/src/xbt/RngStream.c @@ -17,19 +17,16 @@ * \***********************************************************************/ - #include "xbt/RngStream.h" #include "xbt/sysdep.h" #include #include #include - /*---------------------------------------------------------------------*/ /* Private part. */ /*---------------------------------------------------------------------*/ - #define norm 2.328306549295727688e-10 #define m1 4294967087.0 #define m2 4294944443.0 @@ -42,14 +39,9 @@ #define two53 9007199254740992.0 #define fact 5.9604644775390625e-8 /* 1 / 2^24 */ - - - -/* Default initial seed of the package. Will be updated to become - the seed of the next created stream. */ +/* Default initial seed of the package. Will be updated to become the seed of the next created stream. */ static double nextSeed[6] = { 12345, 12345, 12345, 12345, 12345, 12345 }; - /* The following are the transition matrices of the two MRG components */ /* (in matrix form), raised to the powers -1, 1, 2^76, and 2^127, resp.*/ static double InvA1[3][3] = { /* Inverse of A1p0 */ @@ -100,12 +92,6 @@ static double A2p127[3][3] = { { 2824425944.0, 32183930.0, 2093834863.0 } }; - - - - -/*-------------------------------------------------------------------------*/ - static double MultModM (double a, double s, double c, double m) /* Compute (a*s + c) % m. m must be < 2^35. Works also for s, c < 0 */ { @@ -127,9 +113,6 @@ static double MultModM (double a, double s, double c, double m) return v; } - -/*-------------------------------------------------------------------------*/ - static void MatVecModM (double A[3][3], double s[3], double v[3], double m) /* Returns v = A*s % m. Assumes that -m < s[i] < m. */ /* Works even if v = s. */ @@ -145,11 +128,7 @@ static void MatVecModM (double A[3][3], double s[3], double v[3], double m) v[i] = x[i]; } - -/*-------------------------------------------------------------------------*/ - -static void MatMatModM (double A[3][3], double B[3][3], double C[3][3], - double m) +static void MatMatModM (double A[3][3], double B[3][3], double C[3][3], double m) /* Returns C = A*B % m. Work even if A = C or B = C or A = B = C. */ { int i, j; @@ -167,9 +146,6 @@ static void MatMatModM (double A[3][3], double B[3][3], double C[3][3], } } - -/*-------------------------------------------------------------------------*/ - static void MatTwoPowModM (double A[3][3], double B[3][3], double m, long e) /* Compute matrix B = (A^(2^e) % m); works even if A = B */ { @@ -187,9 +163,6 @@ static void MatTwoPowModM (double A[3][3], double B[3][3], double m, long e) MatMatModM (B, B, B, m); } - -/*-------------------------------------------------------------------------*/ - static void MatPowModM (double A[3][3], double B[3][3], double m, long n) /* Compute matrix B = A^n % m ; works even if A = B */ { @@ -215,9 +188,6 @@ static void MatPowModM (double A[3][3], double B[3][3], double m, long n) } } - -/*-------------------------------------------------------------------------*/ - static double U01 (RngStream g) { long k; @@ -248,9 +218,6 @@ static double U01 (RngStream g) return (g->Anti) ? (1 - u) : u; } - -/*-------------------------------------------------------------------------*/ - static double U01d (RngStream g) { double u; @@ -265,13 +232,9 @@ static double U01d (RngStream g) } } - -/*-------------------------------------------------------------------------*/ - static int CheckSeed (unsigned long seed[6]) { - /* Check that the seeds are legitimate values. Returns 0 if legal seeds, - -1 otherwise */ + /* Check that the seeds are legitimate values. Returns 0 if legal seeds, -1 otherwise */ int i; for (i = 0; i < 3; ++i) { @@ -306,12 +269,10 @@ static int CheckSeed (unsigned long seed[6]) return 0; } - /*---------------------------------------------------------------------*/ /* Public part. */ /*---------------------------------------------------------------------*/ - RngStream RngStream_CreateStream (const char name[]) { int i; @@ -340,8 +301,6 @@ RngStream RngStream_CreateStream (const char name[]) return g; } -/*-------------------------------------------------------------------------*/ - void RngStream_DeleteStream (RngStream * p) { if (*p == NULL) @@ -351,8 +310,6 @@ void RngStream_DeleteStream (RngStream * p) *p = NULL; } -/*-------------------------------------------------------------------------*/ - RngStream RngStream_CopyStream (const RngStream src) { RngStream g; @@ -372,8 +329,6 @@ RngStream RngStream_CopyStream (const RngStream src) return g; } -/*-------------------------------------------------------------------------*/ - void RngStream_ResetStartStream (RngStream g) { int i; @@ -381,8 +336,6 @@ void RngStream_ResetStartStream (RngStream g) g->Cg[i] = g->Bg[i] = g->Ig[i]; } -/*-------------------------------------------------------------------------*/ - void RngStream_ResetNextSubstream (RngStream g) { int i; @@ -392,8 +345,6 @@ void RngStream_ResetNextSubstream (RngStream g) g->Cg[i] = g->Bg[i]; } -/*-------------------------------------------------------------------------*/ - void RngStream_ResetStartSubstream (RngStream g) { int i; @@ -401,8 +352,6 @@ void RngStream_ResetStartSubstream (RngStream g) g->Cg[i] = g->Bg[i]; } -/*-------------------------------------------------------------------------*/ - int RngStream_SetPackageSeed (unsigned long seed[6]) { int i; @@ -413,8 +362,6 @@ int RngStream_SetPackageSeed (unsigned long seed[6]) return 0; /* SUCCESS */ } -/*-------------------------------------------------------------------------*/ - int RngStream_SetSeed (RngStream g, unsigned long seed[6]) { int i; @@ -425,8 +372,6 @@ int RngStream_SetSeed (RngStream g, unsigned long seed[6]) return 0; /* SUCCESS */ } -/*-------------------------------------------------------------------------*/ - void RngStream_AdvanceState (RngStream g, long e, long c) { double B1[3][3], C1[3][3], B2[3][3], C2[3][3]; @@ -456,8 +401,6 @@ void RngStream_AdvanceState (RngStream g, long e, long c) MatVecModM (C2, &g->Cg[3], &g->Cg[3], m2); } -/*-------------------------------------------------------------------------*/ - void RngStream_GetState (RngStream g, unsigned long seed[6]) { int i; @@ -465,8 +408,6 @@ void RngStream_GetState (RngStream g, unsigned long seed[6]) seed[i] = g->Cg[i]; } -/*-------------------------------------------------------------------------*/ - void RngStream_WriteState (RngStream g) { int i; @@ -483,8 +424,6 @@ void RngStream_WriteState (RngStream g) printf ("%lu }\n\n", (unsigned long) g->Cg[5]); } -/*-------------------------------------------------------------------------*/ - void RngStream_WriteStateFull (RngStream g) { int i; @@ -515,22 +454,16 @@ void RngStream_WriteStateFull (RngStream g) printf ("%lu }\n\n", (unsigned long) g->Cg[5]); } -/*-------------------------------------------------------------------------*/ - void RngStream_IncreasedPrecis (RngStream g, int incp) { g->IncPrec = incp; } -/*-------------------------------------------------------------------------*/ - void RngStream_SetAntithetic (RngStream g, int a) { g->Anti = a; } -/*-------------------------------------------------------------------------*/ - double RngStream_RandU01 (RngStream g) { if (g->IncPrec) @@ -539,8 +472,6 @@ double RngStream_RandU01 (RngStream g) return U01 (g); } -/*-------------------------------------------------------------------------*/ - int RngStream_RandInt (RngStream g, int i, int j) { return i + (int) ((j - i + 1.0) * RngStream_RandU01 (g)); diff --git a/src/xbt/backtrace_linux.c b/src/xbt/backtrace_linux.c index a1a09e1284..e1de958cda 100644 --- a/src/xbt/backtrace_linux.c +++ b/src/xbt/backtrace_linux.c @@ -67,7 +67,6 @@ backtrace_helper (struct _Unwind_Context *ctx, void *a) * */ int xbt_backtrace_no_malloc(void **array, int size) { - int i = 0; for(i=0; i < size; i++) array[i] = NULL; @@ -96,7 +95,6 @@ void xbt_backtrace_current(xbt_ex_t * e) } } - void xbt_ex_setup_backtrace(xbt_ex_t * e) //FIXME: This code could be greatly improved/simplifyied with http://cairo.sourcearchive.com/documentation/1.9.4/backtrace-symbols_8c-source.html { int i; @@ -152,8 +150,7 @@ void xbt_ex_setup_backtrace(xbt_ex_t * e) //FIXME: This code could be greatly im binary_name = bprintf("%s/%s", data, xbt_binary_name); if (!stat(binary_name, &stat_buf)) { /* Found. */ - XBT_DEBUG("Looked in the PATH for the binary. Found %s", - binary_name); + XBT_DEBUG("Looked in the PATH for the binary. Found %s", binary_name); break; } } @@ -163,8 +160,7 @@ void xbt_ex_setup_backtrace(xbt_ex_t * e) //FIXME: This code could be greatly im e->used = 1; e->bt_strings = xbt_new(char *, 1); - e->bt_strings[0] = - bprintf("(binary '%s' not found in the PATH)", xbt_binary_name); + e->bt_strings[0] = bprintf("(binary '%s' not found in the PATH)", xbt_binary_name); free(backtrace_syms); return; } @@ -174,9 +170,7 @@ void xbt_ex_setup_backtrace(xbt_ex_t * e) //FIXME: This code could be greatly im } else { binary_name = xbt_strdup(xbt_binary_name); } - cmd = curr = - xbt_new(char, - strlen(ADDR2LINE) + 25 + strlen(binary_name) + 32 * e->used); + cmd = curr = xbt_new(char, strlen(ADDR2LINE) + 25 + strlen(binary_name) + 32 * e->used); curr += sprintf(curr, "%s -f -e %s ", ADDR2LINE, binary_name); free(binary_name); @@ -247,8 +241,7 @@ void xbt_ex_setup_backtrace(xbt_ex_t * e) //FIXME: This code could be greatly im addr = strtol(addrs[i], &p, 16); if (*p != '\0') { - XBT_CRITICAL("Cannot parse backtrace address '%s' (addr=%#lx)", - addrs[i], addr); + XBT_CRITICAL("Cannot parse backtrace address '%s' (addr=%#lx)", addrs[i], addr); } XBT_DEBUG("addr=%s (as string) =%#lx (as number)", addrs[i], addr); @@ -270,8 +263,7 @@ void xbt_ex_setup_backtrace(xbt_ex_t * e) //FIXME: This code could be greatly im } if (found) { XBT_DEBUG("%#lx in [%#lx-%#lx]", addr, first, last); - XBT_DEBUG - ("Symbol found, map lines not further displayed (even if looking for next ones)"); + XBT_DEBUG("Symbol found, map lines not further displayed (even if looking for next ones)"); } } fclose(maps); @@ -279,8 +271,7 @@ void xbt_ex_setup_backtrace(xbt_ex_t * e) //FIXME: This code could be greatly im free(addrs[i]); if (!found) { - XBT_VERB - ("Problem while reading the maps file. Following backtrace will be mangled."); + XBT_VERB("Problem while reading the maps file. Following backtrace will be mangled."); XBT_DEBUG("No dynamic. Static symbol: %s", backtrace_syms[i]); e->bt_strings[i] = bprintf("** In ?? (%s)", backtrace_syms[i]); continue; @@ -293,8 +284,7 @@ void xbt_ex_setup_backtrace(xbt_ex_t * e) //FIXME: This code could be greatly im addrs[i] = bprintf("0x%0*lx", addr_len - 2, addr - offset); XBT_DEBUG("offset=%#lx new addr=%s", offset, addrs[i]); - /* Got it. We have our new address. Let's get the library path and we - are set */ + /* Got it. We have our new address. Let's get the library path and we are set */ p = xbt_strdup(backtrace_syms[i]); if (p[0] == '[') { /* library path not displayed in the map file either... */ @@ -335,24 +325,19 @@ void xbt_ex_setup_backtrace(xbt_ex_t * e) //FIXME: This code could be greatly im /* check whether the trick worked */ if (strcmp("??", line_func)) { XBT_DEBUG("Found dynamic symbol %s() at %s", line_func, line_pos); - e->bt_strings[i] = - bprintf("** In %s() at %s", line_func, line_pos); + e->bt_strings[i] = bprintf("** In %s() at %s", line_func, line_pos); } else { /* damn, nothing to do here. Let's print the raw address */ - XBT_DEBUG("Dynamic symbol not found. Raw address = %s", - backtrace_syms[i]); + XBT_DEBUG("Dynamic symbol not found. Raw address = %s", backtrace_syms[i]); e->bt_strings[i] = bprintf("** In ?? at %s", backtrace_syms[i]); } - } free(addrs[i]); /* Mask the bottom of the stack */ if (!strncmp("main", line_func, strlen("main")) || - !strncmp("xbt_thread_context_wrapper", line_func, - strlen("xbt_thread_context_wrapper")) - || !strncmp("smx_ctx_sysv_wrapper", line_func, - strlen("smx_ctx_sysv_wrapper"))) { + !strncmp("xbt_thread_context_wrapper", line_func, strlen("xbt_thread_context_wrapper")) + || !strncmp("smx_ctx_sysv_wrapper", line_func, strlen("smx_ctx_sysv_wrapper"))) { int j; for (j = i + 1; j < e->used; j++) @@ -360,14 +345,11 @@ void xbt_ex_setup_backtrace(xbt_ex_t * e) //FIXME: This code could be greatly im e->used = i + 1; if (!strncmp - ("xbt_thread_context_wrapper", line_func, - strlen("xbt_thread_context_wrapper"))) { + ("xbt_thread_context_wrapper", line_func, strlen("xbt_thread_context_wrapper"))) { free(e->bt_strings[i]); e->bt_strings[i] = xbt_strdup("** (in a separate thread)"); } } - - } pclose(pipe); free(addrs); @@ -377,7 +359,6 @@ void xbt_ex_setup_backtrace(xbt_ex_t * e) //FIXME: This code could be greatly im #if HAVE_MC int xbt_libunwind_backtrace(void* bt[XBT_BACKTRACE_SIZE], int size){ - int i = 0; for(i=0; i < size; i++) bt[i] = NULL; @@ -389,21 +370,17 @@ int xbt_libunwind_backtrace(void* bt[XBT_BACKTRACE_SIZE], int size){ unw_getcontext (&uc); unw_init_local (&c, &uc); - + unw_word_t ip; unw_step(&c); - - while(unw_step(&c) >= 0 && i < size){ + while(unw_step(&c) >= 0 && i < size){ unw_get_reg(&c, UNW_REG_IP, &ip); bt[i] = (void*)(long)ip; i++; - } return i; - } - #endif diff --git a/src/xbt/config.c b/src/xbt/config.c index e5d71a48c1..f9659a10ff 100644 --- a/src/xbt/config.c +++ b/src/xbt/config.c @@ -23,8 +23,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_cfg, xbt, "configuration support"); /* xbt_cfgelm_t: the typedef corresponding to a config variable. - Both data and DTD are mixed, but fixing it now would prevent me to ever - defend my thesis. */ + Both data and DTD are mixed, but fixing it now would prevent me to ever defend my thesis. */ typedef struct { /* Description */ @@ -42,8 +41,7 @@ typedef struct { xbt_dynar_t content; } s_xbt_cfgelm_t, *xbt_cfgelm_t; -static const char *xbt_cfgelm_type_name[xbt_cfgelm_type_count] = - { "int", "double", "string", "boolean", "any" }; +static const char *xbt_cfgelm_type_name[xbt_cfgelm_type_count] = { "int", "double", "string", "boolean", "any" }; const struct xbt_boolean_couple xbt_cfgelm_boolean_values[] = { { "yes", "no"}, @@ -57,17 +55,13 @@ const struct xbt_boolean_couple xbt_cfgelm_boolean_values[] = { static void xbt_cfgelm_free(void *data); /* Retrieve the variable we'll modify */ -static xbt_cfgelm_t xbt_cfgelm_get(xbt_cfg_t cfg, const char *name, - e_xbt_cfgelm_type_t type); +static xbt_cfgelm_t xbt_cfgelm_get(xbt_cfg_t cfg, const char *name, e_xbt_cfgelm_type_t type); /*----[ Memory management ]-----------------------------------------------*/ - /** @brief Constructor * * Initialise a config set */ - - xbt_cfg_t xbt_cfg_new(void) { return (xbt_cfg_t) xbt_dict_new_homogeneous(&xbt_cfgelm_free); @@ -80,7 +74,6 @@ xbt_cfg_t xbt_cfg_new(void) * * This only copy the registrations, not the actual content */ - void xbt_cfg_cpy(xbt_cfg_t tocopy, xbt_cfg_t * whereto) { xbt_dict_cursor_t cursor = NULL; @@ -92,8 +85,7 @@ void xbt_cfg_cpy(xbt_cfg_t tocopy, xbt_cfg_t * whereto) xbt_assert(tocopy, "cannot copy NULL config"); xbt_dict_foreach((xbt_dict_t) tocopy, cursor, name, variable) { - xbt_cfg_register(whereto, name, variable->desc, variable->type, - variable->min, variable->max, variable->cb_set); + xbt_cfg_register(whereto, name, variable->desc, variable->type, variable->min, variable->max, variable->cb_set); } } @@ -129,49 +121,41 @@ void xbt_cfg_dump(const char *name, const char *indent, xbt_cfg_t cfg) printf("%s %s:", indent, key); size = xbt_dynar_length(variable->content); - printf - ("%d_to_%d_%s. Actual size=%d. postset=%p, List of values:\n", - variable->min, variable->max, xbt_cfgelm_type_name[variable->type], size, variable->cb_set); + printf ("%d_to_%d_%s. Actual size=%d. postset=%p, List of values:\n", + variable->min, variable->max, xbt_cfgelm_type_name[variable->type], size, variable->cb_set); switch (variable->type) { - case xbt_cfgelm_int: for (i = 0; i < size; i++) { ival = xbt_dynar_get_as(variable->content, i, int); printf("%s %d\n", indent, ival); } break; - case xbt_cfgelm_double: for (i = 0; i < size; i++) { dval = xbt_dynar_get_as(variable->content, i, double); printf("%s %f\n", indent, dval); } break; - case xbt_cfgelm_string: for (i = 0; i < size; i++) { sval = xbt_dynar_get_as(variable->content, i, char *); printf("%s %s\n", indent, sval); } break; - case xbt_cfgelm_boolean: for (i = 0; i < size; i++) { ival = xbt_dynar_get_as(variable->content, i, int); printf("%s %d\n", indent, ival); } break; - case xbt_cfgelm_alias: /* no content */ break; - default: printf("%s Invalid type!!\n", indent); break; } - } if (name) @@ -184,7 +168,6 @@ void xbt_cfg_dump(const char *name, const char *indent, xbt_cfg_t cfg) /* * free an config element */ - void xbt_cfgelm_free(void *data) { xbt_cfgelm_t c = (xbt_cfgelm_t) data; @@ -199,7 +182,6 @@ void xbt_cfgelm_free(void *data) } /*----[ Registering stuff ]-----------------------------------------------*/ - /** @brief Register an element within a config set * * @param cfg the config set @@ -210,11 +192,8 @@ void xbt_cfgelm_free(void *data) * @param max the maximum number of values for this config element * @param cb_set callback function called when a value is set */ - -void xbt_cfg_register(xbt_cfg_t * cfg, - const char *name, const char *desc, - e_xbt_cfgelm_type_t type, int min, - int max, xbt_cfg_cb_t cb_set) +void xbt_cfg_register(xbt_cfg_t * cfg, const char *name, const char *desc, e_xbt_cfgelm_type_t type, int min, + int max, xbt_cfg_cb_t cb_set) { xbt_cfgelm_t res; @@ -241,24 +220,19 @@ void xbt_cfg_register(xbt_cfg_t * cfg, case xbt_cfgelm_int: res->content = xbt_dynar_new(sizeof(int), NULL); break; - case xbt_cfgelm_double: res->content = xbt_dynar_new(sizeof(double), NULL); break; - case xbt_cfgelm_string: res->content = xbt_dynar_new(sizeof(char *), xbt_free_ref); break; - case xbt_cfgelm_boolean: res->content = xbt_dynar_new(sizeof(int), NULL); break; - default: XBT_ERROR("%d is an invalid type code", (int)type); break; } - xbt_dict_set((xbt_dict_t) * cfg, name, res, NULL); } @@ -285,6 +259,7 @@ void xbt_cfg_register_alias(xbt_cfg_t * cfg, const char *newname, const char *ol xbt_dict_set((xbt_dict_t) * cfg, oldname, res, NULL); } + /** @brief Unregister an element from a config set. * * @param cfg the config set @@ -293,7 +268,6 @@ void xbt_cfg_register_alias(xbt_cfg_t * cfg, const char *newname, const char *ol * Note that it removes both the description and the actual content. * Throws not_found when no such element exists. */ - void xbt_cfg_unregister(xbt_cfg_t cfg, const char *name) { XBT_DEBUG("Unregister elm '%s' from set %p", name, cfg); @@ -312,7 +286,6 @@ void xbt_cfg_unregister(xbt_cfg_t cfg, const char *name) * * Note that this does not allow to set the description, so you should prefer the other interface */ - void xbt_cfg_register_str(xbt_cfg_t * cfg, const char *entry) { char *entrycpy = xbt_strdup(entry); @@ -323,33 +296,25 @@ void xbt_cfg_register_str(xbt_cfg_t * cfg, const char *entry) XBT_DEBUG("Register string '%s'", entry); tok = strchr(entrycpy, ':'); - xbt_assert(tok, "Invalid config element descriptor: %s%s", - entry, "; Should be :_to__"); + xbt_assert(tok, "Invalid config element descriptor: %s%s", entry, "; Should be :_to__"); *(tok++) = '\0'; min = strtol(tok, &tok, 10); - xbt_assert(tok, "Invalid minimum in config element descriptor %s", - entry); + xbt_assert(tok, "Invalid minimum in config element descriptor %s", entry); - xbt_assert(strcmp(tok, "_to_"), - "Invalid config element descriptor : %s%s", + xbt_assert(strcmp(tok, "_to_"), "Invalid config element descriptor : %s%s", entry, "; Should be :_to__"); tok += strlen("_to_"); max = strtol(tok, &tok, 10); - xbt_assert(tok, "Invalid maximum in config element descriptor %s", - entry); + xbt_assert(tok, "Invalid maximum in config element descriptor %s", entry); - xbt_assert(*tok == '_', - "Invalid config element descriptor: %s%s", entry, + xbt_assert(*tok == '_', "Invalid config element descriptor: %s%s", entry, "; Should be :_to__"); tok++; - for (type = (e_xbt_cfgelm_type_t)0; - type < xbt_cfgelm_type_count - && strcmp(tok, xbt_cfgelm_type_name[type]); type++); - xbt_assert(type < xbt_cfgelm_type_count, - "Invalid type in config element descriptor: %s%s", entry, + for (type = (e_xbt_cfgelm_type_t)0; type < xbt_cfgelm_type_count && strcmp(tok, xbt_cfgelm_type_name[type]); type++); + xbt_assert(type < xbt_cfgelm_type_count, "Invalid type in config element descriptor: %s%s", entry, "; Should be one of 'string', 'int' or 'double'."); xbt_cfg_register(cfg, entrycpy, NULL, type, min, max, NULL); @@ -377,6 +342,7 @@ void xbt_cfg_aliases(xbt_cfg_t cfg) printf(" %s: %s\n", name, variable->desc); } } + /** @brief Displays the declared options and their description */ void xbt_cfg_help(xbt_cfg_t cfg) { @@ -418,32 +384,26 @@ void xbt_cfg_help(xbt_cfg_t cfg) case xbt_cfgelm_int: printf("%d%s", xbt_dynar_get_as(variable->content, i, int), sep); break; - case xbt_cfgelm_double: printf("%f%s", xbt_dynar_get_as(variable->content, i, double), sep); break; - case xbt_cfgelm_string: printf("'%s'%s", xbt_dynar_get_as(variable->content, i, char *), sep); break; - case xbt_cfgelm_boolean: { int b = xbt_dynar_get_as(variable->content, i, int); - const char *bs = b ? xbt_cfgelm_boolean_values[0].true_val - : xbt_cfgelm_boolean_values[0].false_val; + const char *bs = b ? xbt_cfgelm_boolean_values[0].true_val: xbt_cfgelm_boolean_values[0].false_val; if (b == 0 || b == 1) printf("'%s'%s", bs, sep); else printf("'%s/%d'%s", bs, b, sep); break; } - default: printf("Invalid type!!%s", sep); } } } - xbt_dynar_free(&names); } @@ -465,28 +425,22 @@ void xbt_cfg_check(xbt_cfg_t cfg) size = xbt_dynar_length(variable->content); if (variable->min > size) { xbt_dict_cursor_free(&cursor); - THROWF(mismatch_error, 0, - "Config elem %s needs at least %d %s, but there is only %d values.", - name, variable->min, xbt_cfgelm_type_name[variable->type], - size); + THROWF(mismatch_error, 0, "Config elem %s needs at least %d %s, but there is only %d values.", + name, variable->min, xbt_cfgelm_type_name[variable->type], size); } if (variable->isdefault && size > variable->min) { xbt_dict_cursor_free(&cursor); - THROWF(mismatch_error, 0, - "Config elem %s theoretically accepts %d %s, but has a default of %d values.", + THROWF(mismatch_error, 0, "Config elem %s theoretically accepts %d %s, but has a default of %d values.", name, variable->min, xbt_cfgelm_type_name[variable->type], size); } if (variable->max > 0 && variable->max < size) { xbt_dict_cursor_free(&cursor); - THROWF(mismatch_error, 0, - "Config elem %s accepts at most %d %s, but there is %d values.", - name, variable->max, xbt_cfgelm_type_name[variable->type], - size); + THROWF(mismatch_error, 0, "Config elem %s accepts at most %d %s, but there is %d values.", + name, variable->max, xbt_cfgelm_type_name[variable->type], size); } } - xbt_dict_cursor_free(&cursor); } @@ -509,9 +463,7 @@ static xbt_cfgelm_t xbt_cfgelm_get(xbt_cfg_t cfg, const char *name, e_xbt_cfgelm xbt_assert(type == xbt_cfgelm_any || res->type == type, "You tried to access to the config element %s as an %s, but its type is %s.", - name, - xbt_cfgelm_type_name[type], xbt_cfgelm_type_name[res->type]); - + name, xbt_cfgelm_type_name[type], xbt_cfgelm_type_name[res->type]); return res; } @@ -522,20 +474,15 @@ static xbt_cfgelm_t xbt_cfgelm_get(xbt_cfg_t cfg, const char *name, e_xbt_cfgelm * * @return the type of the given element */ - e_xbt_cfgelm_type_t xbt_cfg_get_type(xbt_cfg_t cfg, const char *name) { - xbt_cfgelm_t variable = NULL; variable = xbt_dict_get_or_null((xbt_dict_t) cfg, name); if (!variable) - THROWF(not_found_error, 0, - "Can't get the type of '%s' since this variable does not exist", - name); + THROWF(not_found_error, 0, "Can't get the type of '%s' since this variable does not exist", name); XBT_DEBUG("type in variable = %d", (int)variable->type); - return variable->type; } @@ -563,9 +510,7 @@ void xbt_cfg_set_vargs(xbt_cfg_t cfg, const char *name, va_list pa) CATCH(e) { if (e.category == not_found_error) { xbt_ex_free(e); - THROWF(not_found_error, 0, - "Can't set the property '%s' since it's not registered", - name); + THROWF(not_found_error, 0, "Can't set the property '%s' since it's not registered", name); } RETHROW; } @@ -575,22 +520,18 @@ void xbt_cfg_set_vargs(xbt_cfg_t cfg, const char *name, va_list pa) str = va_arg(pa, char *); xbt_cfg_set_string(cfg, name, str); break; - case xbt_cfgelm_int: i = va_arg(pa, int); xbt_cfg_set_int(cfg, name, i); break; - case xbt_cfgelm_double: d = va_arg(pa, double); xbt_cfg_set_double(cfg, name, d); break; - case xbt_cfgelm_boolean: str = va_arg(pa, char *); xbt_cfg_set_boolean(cfg, name, str); break; - default: xbt_die("Config element variable %s not valid (type=%d)", name, (int)type); } @@ -601,7 +542,6 @@ void xbt_cfg_set_vargs(xbt_cfg_t cfg, const char *name, va_list pa) * @param cfg config set to fill * @param name variable name * @param ... variable value - * */ void xbt_cfg_set(xbt_cfg_t cfg, const char *name, ...) { @@ -615,20 +555,15 @@ void xbt_cfg_set(xbt_cfg_t cfg, const char *name, ...) /** @brief Add values parsed from a string into a config set * * @param cfg config set to fill - * @param options a string containing the content to add to the config set. This - * is a '\\t',' ' or '\\n' or ',' separated list of variables. Each individual variable is - * like "[name]:[value]" where [name] is the name of an already registred - * variable, and [value] conforms to the data type under which this variable was - * registred. + * @param options a string containing the content to add to the config set. This is a '\\t',' ' or '\\n' or ',' + * separated list of variables. Each individual variable is like "[name]:[value]" where [name] is the name of an + * already registered variable, and [value] conforms to the data type under which this variable was registered. * * @todo This is a crude manual parser, it should be a proper lexer. */ - void xbt_cfg_set_parse(xbt_cfg_t cfg, const char *options) { - char *optionlist_cpy; char *option, *name, *val; - int len; XBT_IN(); @@ -640,32 +575,25 @@ void xbt_cfg_set_parse(xbt_cfg_t cfg, const char *options) { XBT_DEBUG("List to parse and set:'%s'", options); option = optionlist_cpy; while (1) { /* breaks in the code */ - if (!option) break; name = option; len = strlen(name); - XBT_DEBUG("Still to parse and set: '%s'. len=%d; option-name=%ld", - name, len, (long) (option - name)); + XBT_DEBUG("Still to parse and set: '%s'. len=%d; option-name=%ld", name, len, (long) (option - name)); /* Pass the value */ - while (option - name <= (len - 1) && *option != ' ' && *option != '\n' - && *option != '\t' && *option != ',') { + while (option - name <= (len - 1) && *option != ' ' && *option != '\n' && *option != '\t' && *option != ',') { XBT_DEBUG("Take %c.", *option); option++; } if (option - name == len) { XBT_DEBUG("Boundary=EOL"); option = NULL; /* don't do next iteration */ - } else { - XBT_DEBUG("Boundary on '%c'. len=%d;option-name=%ld", - *option, len, (long) (option - name)); - + XBT_DEBUG("Boundary on '%c'. len=%d;option-name=%ld", *option, len, (long) (option - name)); /* Pass the following blank chars */ *(option++) = '\0'; - while (option - name < (len - 1) && - (*option == ' ' || *option == '\n' || *option == '\t')) { + while (option - name < (len - 1) && (*option == ' ' || *option == '\n' || *option == '\t')) { /* fprintf(stderr,"Ignore a blank char.\n"); */ option++; } @@ -682,8 +610,7 @@ void xbt_cfg_set_parse(xbt_cfg_t cfg, const char *options) { val = strchr(name, ':'); if (!val) { /* don't free(optionlist_cpy) here, 'name' points inside it */ - xbt_die("Option '%s' badly formatted. Should be of the form 'name:value'", - name); + xbt_die("Option '%s' badly formatted. Should be of the form 'name:value'", name); } *(val++) = '\0'; @@ -727,8 +654,7 @@ void *xbt_cfg_set_as_string(xbt_cfg_t cfg, const char *key, const char *value) { variable = NULL; } } - } - CATCH(e) { + } CATCH(e) { if (e.category == not_found_error) { xbt_ex_free(e); THROWF(not_found_error, 0, "No registered variable corresponding to '%s'.", key); @@ -740,35 +666,28 @@ void *xbt_cfg_set_as_string(xbt_cfg_t cfg, const char *key, const char *value) { case xbt_cfgelm_string: xbt_cfg_set_string(cfg, key, value); /* throws */ break; - case xbt_cfgelm_int: i = strtol(value, &ret, 0); if (ret == value) { xbt_die("Value of option %s not valid. Should be an integer", key); } - xbt_cfg_set_int(cfg, key, i); /* throws */ break; - case xbt_cfgelm_double: d = strtod(value, &ret); if (ret == value) { xbt_die("Value of option %s not valid. Should be a double", key); } - xbt_cfg_set_double(cfg, key, d); /* throws */ break; - case xbt_cfgelm_boolean: xbt_cfg_set_boolean(cfg, key, value); /* throws */ ret = (char *)value + strlen(value); break; - default: THROWF(unknown_error, 0, "Type of config element %s is not valid.", key); break; } - return ret; } @@ -784,11 +703,8 @@ void xbt_cfg_setdefault_int(xbt_cfg_t cfg, const char *name, int val) if (variable->isdefault){ xbt_cfg_set_int(cfg, name, val); variable->isdefault = 1; - } - else - XBT_DEBUG - ("Do not override configuration variable '%s' with value '%d' because it was already set.", - name, val); + } else + XBT_DEBUG("Do not override configuration variable '%s' with value '%d' because it was already set.", name, val); } /** @brief Set an integer value to \a name within \a cfg if it wasn't changed yet @@ -803,11 +719,8 @@ void xbt_cfg_setdefault_double(xbt_cfg_t cfg, const char *name, double val) if (variable->isdefault) { xbt_cfg_set_double(cfg, name, val); variable->isdefault = 1; - } - else - XBT_DEBUG - ("Do not override configuration variable '%s' with value '%f' because it was already set.", - name, val); + } else + XBT_DEBUG("Do not override configuration variable '%s' with value '%f' because it was already set.", name, val); } /** @brief Set a string value to \a name within \a cfg if it wasn't changed yet @@ -815,22 +728,17 @@ void xbt_cfg_setdefault_double(xbt_cfg_t cfg, const char *name, double val) * This is useful to change the default value of a variable while allowing * users to override it with command line arguments */ -void xbt_cfg_setdefault_string(xbt_cfg_t cfg, const char *name, - const char *val) +void xbt_cfg_setdefault_string(xbt_cfg_t cfg, const char *name, const char *val) { xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_string); if (variable->isdefault){ xbt_cfg_set_string(cfg, name, val); variable->isdefault = 1; - } - else - XBT_DEBUG - ("Do not override configuration variable '%s' with value '%s' because it was already set.", - name, val); + } else + XBT_DEBUG("Do not override configuration variable '%s' with value '%s' because it was already set.", name, val); } - /** @brief Set an boolean value to \a name within \a cfg if it wasn't changed yet * * This is useful to change the default value of a variable while allowing @@ -845,9 +753,7 @@ void xbt_cfg_setdefault_boolean(xbt_cfg_t cfg, const char *name, const char *val variable->isdefault = 1; } else - XBT_DEBUG - ("Do not override configuration variable '%s' with value '%s' because it was already set.", - name, val); + XBT_DEBUG("Do not override configuration variable '%s' with value '%s' because it was already set.", name, val); } /** @brief Set or add an integer value to \a name within \a cfg @@ -858,18 +764,14 @@ void xbt_cfg_setdefault_boolean(xbt_cfg_t cfg, const char *name, const char *val */ void xbt_cfg_set_int(xbt_cfg_t cfg, const char *name, int val) { - XBT_VERB("Configuration setting: %s=%d", name, val); xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_int); if (variable->max == 1) { xbt_dynar_set(variable->content, 0, &val); } else { - if (variable->max - && xbt_dynar_length(variable->content) == - (unsigned long) variable->max) - THROWF(mismatch_error, 0, - "Cannot add value %d to the config element %s since it's already full (size=%d)", + if (variable->max && xbt_dynar_length(variable->content) == (unsigned long) variable->max) + THROWF(mismatch_error, 0, "Cannot add value %d to the config element %s since it's already full (size=%d)", val, name, variable->max); xbt_dynar_push(variable->content, &val); @@ -886,20 +788,16 @@ void xbt_cfg_set_int(xbt_cfg_t cfg, const char *name, int val) * @param name the name of the variable * @param val the doule to set */ - void xbt_cfg_set_double(xbt_cfg_t cfg, const char *name, double val) { - XBT_VERB("Configuration setting: %s=%f", name, val); xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_double); if (variable->max == 1) { xbt_dynar_set(variable->content, 0, &val); } else { - if (variable->max - && xbt_dynar_length(variable->content) == variable->max) - THROWF(mismatch_error, 0, - "Cannot add value %f to the config element %s since it's already full (size=%d)", + if (variable->max && xbt_dynar_length(variable->content) == variable->max) + THROWF(mismatch_error, 0, "Cannot add value %f to the config element %s since it's already full (size=%d)", val, name, variable->max); xbt_dynar_push(variable->content, &val); @@ -917,7 +815,6 @@ void xbt_cfg_set_double(xbt_cfg_t cfg, const char *name, double val) * @param val the value to be added * */ - void xbt_cfg_set_string(xbt_cfg_t cfg, const char *name, const char *val) { char *newval = xbt_strdup(val); @@ -938,8 +835,7 @@ void xbt_cfg_set_string(xbt_cfg_t cfg, const char *name, const char *val) } else { if (variable->max && xbt_dynar_length(variable->content) == variable->max) - THROWF(mismatch_error, 0, - "Cannot add value %s to the config element %s since it's already full (size=%d)", + THROWF(mismatch_error, 0, "Cannot add value %s to the config element %s since it's already full (size=%d)", name, val, variable->max); xbt_dynar_push(variable->content, &newval); @@ -964,14 +860,14 @@ void xbt_cfg_set_boolean(xbt_cfg_t cfg, const char *name, const char *val) xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_boolean); for (i = 0; xbt_cfgelm_boolean_values[i].true_val != NULL; i++) { - if (strcmp(val, xbt_cfgelm_boolean_values[i].true_val) == 0){ - bval = 1; - break; - } - if (strcmp(val, xbt_cfgelm_boolean_values[i].false_val) == 0){ - bval = 0; - break; - } + if (strcmp(val, xbt_cfgelm_boolean_values[i].true_val) == 0){ + bval = 1; + break; + } + if (strcmp(val, xbt_cfgelm_boolean_values[i].false_val) == 0){ + bval = 0; + break; + } } if (xbt_cfgelm_boolean_values[i].true_val == NULL) { xbt_die("Value of option '%s' not valid. Should be a boolean (yes,no,on,off,true,false,0,1)", val); @@ -980,11 +876,8 @@ void xbt_cfg_set_boolean(xbt_cfg_t cfg, const char *name, const char *val) if (variable->max == 1) { xbt_dynar_set(variable->content, 0, &bval); } else { - if (variable->max - && xbt_dynar_length(variable->content) == - (unsigned long) variable->max) - THROWF(mismatch_error, 0, - "Cannot add value %s to the config element %s since it's already full (size=%d)", + if (variable->max && xbt_dynar_length(variable->content) == (unsigned long) variable->max) + THROWF(mismatch_error, 0, "Cannot add value %s to the config element %s since it's already full (size=%d)", val, name, variable->max); xbt_dynar_push(variable->content, &bval); @@ -996,7 +889,6 @@ void xbt_cfg_set_boolean(xbt_cfg_t cfg, const char *name, const char *val) } /* ---- [ Removing ] ---- */ - /** @brief Remove the provided \e val integer value from a variable * * @param cfg the config set @@ -1005,7 +897,6 @@ void xbt_cfg_set_boolean(xbt_cfg_t cfg, const char *name, const char *val) */ void xbt_cfg_rm_int(xbt_cfg_t cfg, const char *name, int val) { - unsigned int cpt; int seen; @@ -1022,10 +913,7 @@ void xbt_cfg_rm_int(xbt_cfg_t cfg, const char *name, int val) return; } } - - THROWF(not_found_error, 0, - "Can't remove the value %d of config element %s: value not found.", - val, name); + THROWF(not_found_error, 0, "Can't remove the value %d of config element %s: value not found.", val, name); } /** @brief Remove the provided \e val double value from a variable @@ -1034,7 +922,6 @@ void xbt_cfg_rm_int(xbt_cfg_t cfg, const char *name, int val) * @param name the name of the variable * @param val the value to be removed */ - void xbt_cfg_rm_double(xbt_cfg_t cfg, const char *name, double val) { unsigned int cpt; @@ -1054,9 +941,7 @@ void xbt_cfg_rm_double(xbt_cfg_t cfg, const char *name, double val) } } - THROWF(not_found_error, 0, - "Can't remove the value %f of config element %s: value not found.", - val, name); + THROWF(not_found_error, 0,"Can't remove the value %f of config element %s: value not found.", val, name); } /** @brief Remove the provided \e val string value from a variable @@ -1083,9 +968,7 @@ void xbt_cfg_rm_string(xbt_cfg_t cfg, const char *name, const char *val) } } - THROWF(not_found_error, 0, - "Can't remove the value %s of config element %s: value not found.", - val, name); + THROWF(not_found_error, 0, "Can't remove the value %s of config element %s: value not found.", val, name); } /** @brief Remove the provided \e val boolean value from a variable @@ -1096,7 +979,6 @@ void xbt_cfg_rm_string(xbt_cfg_t cfg, const char *name, const char *val) */ void xbt_cfg_rm_boolean(xbt_cfg_t cfg, const char *name, int val) { - unsigned int cpt; int seen; xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_boolean); @@ -1113,16 +995,12 @@ void xbt_cfg_rm_boolean(xbt_cfg_t cfg, const char *name, int val) } } - THROWF(not_found_error, 0, - "Can't remove the value %d of config element %s: value not found.", - val, name); + THROWF(not_found_error, 0, "Can't remove the value %d of config element %s: value not found.", val, name); } /** @brief Remove the \e pos th value from the provided variable */ - void xbt_cfg_rm_at(xbt_cfg_t cfg, const char *name, int pos) { - xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_any); if (xbt_dynar_length(variable->content) == variable->min) @@ -1138,7 +1016,6 @@ void xbt_cfg_rm_at(xbt_cfg_t cfg, const char *name, int pos) * @param cfg the config set * @param name the name of the variable */ - void xbt_cfg_empty(xbt_cfg_t cfg, const char *name) { xbt_cfgelm_t variable = NULL; @@ -1146,8 +1023,7 @@ void xbt_cfg_empty(xbt_cfg_t cfg, const char *name) TRY { variable = xbt_dict_get((xbt_dict_t) cfg, name); - } - CATCH(e) { + } CATCH(e) { if (e.category != not_found_error) RETHROW; @@ -1158,9 +1034,8 @@ void xbt_cfg_empty(xbt_cfg_t cfg, const char *name) if (variable) xbt_dynar_reset(variable->content); } -/* - * Say if the value is the default value - */ + +/* Say if the value is the default value */ int xbt_cfg_is_default_value(xbt_cfg_t cfg, const char *name) { xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_any); @@ -1168,23 +1043,20 @@ int xbt_cfg_is_default_value(xbt_cfg_t cfg, const char *name) } /*----[ Getting ]---------------------------------------------------------*/ - /** @brief Retrieve an integer value of a variable (get a warning if not uniq) * * @param cfg the config set * @param name the name of the variable * * Returns the first value from the config set under the given name. - * If there is more than one value, it will issue a warning. Consider using - * xbt_cfg_get_dynar() instead. + * If there is more than one value, it will issue a warning. Consider using xbt_cfg_get_dynar() instead. */ int xbt_cfg_get_int(xbt_cfg_t cfg, const char *name) { xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_int); if (xbt_dynar_length(variable->content) > 1) { - XBT_WARN - ("You asked for the first value of the config element '%s', but there is %lu values", + XBT_WARN("You asked for the first value of the config element '%s', but there is %lu values", name, xbt_dynar_length(variable->content)); } @@ -1197,17 +1069,14 @@ int xbt_cfg_get_int(xbt_cfg_t cfg, const char *name) * @param name the name of the variable * * Returns the first value from the config set under the given name. - * If there is more than one value, it will issue a warning. Consider using - * xbt_cfg_get_dynar() instead. + * If there is more than one value, it will issue a warning. Consider using xbt_cfg_get_dynar() instead. */ - double xbt_cfg_get_double(xbt_cfg_t cfg, const char *name) { xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_double); if (xbt_dynar_length(variable->content) > 1) { - XBT_WARN - ("You asked for the first value of the config element '%s', but there is %lu values\n", + XBT_WARN ("You asked for the first value of the config element '%s', but there is %lu values\n", name, xbt_dynar_length(variable->content)); } @@ -1225,14 +1094,12 @@ double xbt_cfg_get_double(xbt_cfg_t cfg, const char *name) * * \warning the returned value is the actual content of the config set */ - char *xbt_cfg_get_string(xbt_cfg_t cfg, const char *name) { xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_string); if (xbt_dynar_length(variable->content) > 1) { - XBT_WARN - ("You asked for the first value of the config element '%s', but there is %lu values\n", + XBT_WARN("You asked for the first value of the config element '%s', but there is %lu values\n", name, xbt_dynar_length(variable->content)); } else if (xbt_dynar_is_empty(variable->content)) { return NULL; @@ -1247,16 +1114,14 @@ char *xbt_cfg_get_string(xbt_cfg_t cfg, const char *name) * @param name the name of the variable * * Returns the first value from the config set under the given name. - * If there is more than one value, it will issue a warning. Consider using - * xbt_cfg_get_dynar() instead. + * If there is more than one value, it will issue a warning. Consider using xbt_cfg_get_dynar() instead. */ int xbt_cfg_get_boolean(xbt_cfg_t cfg, const char *name) { xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_boolean); if (xbt_dynar_length(variable->content) > 1) { - XBT_WARN - ("You asked for the first value of the config element '%s', but there is %lu values", + XBT_WARN("You asked for the first value of the config element '%s', but there is %lu values", name, xbt_dynar_length(variable->content)); } @@ -1279,12 +1144,10 @@ xbt_dynar_t xbt_cfg_get_dynar(xbt_cfg_t cfg, const char *name) TRY { variable = xbt_dict_get((xbt_dict_t) cfg, name); - } - CATCH(e) { + } CATCH(e) { if (e.category == not_found_error) { xbt_ex_free(e); - THROWF(not_found_error, 0, - "No registered variable %s in this config set", name); + THROWF(not_found_error, 0, "No registered variable %s in this config set", name); } RETHROW; } @@ -1292,11 +1155,9 @@ xbt_dynar_t xbt_cfg_get_dynar(xbt_cfg_t cfg, const char *name) return variable->content; } - /** @brief Retrieve one of the integer value of a variable */ int xbt_cfg_get_int_at(xbt_cfg_t cfg, const char *name, int pos) { - xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_int); return xbt_dynar_get_as(variable->content, pos, int); } @@ -1304,16 +1165,13 @@ int xbt_cfg_get_int_at(xbt_cfg_t cfg, const char *name, int pos) /** @brief Retrieve one of the double value of a variable */ double xbt_cfg_get_double_at(xbt_cfg_t cfg, const char *name, int pos) { - xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_double); return xbt_dynar_get_as(variable->content, pos, double); } - /** @brief Retrieve one of the string value of a variable */ char *xbt_cfg_get_string_at(xbt_cfg_t cfg, const char *name, int pos) { - xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_string); return xbt_dynar_get_as(variable->content, pos, char *); } @@ -1321,12 +1179,10 @@ char *xbt_cfg_get_string_at(xbt_cfg_t cfg, const char *name, int pos) /** @brief Retrieve one of the boolean value of a variable */ int xbt_cfg_get_boolean_at(xbt_cfg_t cfg, const char *name, int pos) { - xbt_cfgelm_t variable = xbt_cfgelm_get(cfg, name, xbt_cfgelm_boolean); return xbt_dynar_get_as(variable->content, pos, int); } - #ifdef SIMGRID_TEST #include "xbt.h" #include "xbt/ex.h" @@ -1351,8 +1207,7 @@ XBT_TEST_UNIT("memuse", test_config_memuse, "Alloc and free a config set") { xbt_cfg_t set = make_set(); xbt_test_add("Alloc and free a config set"); - xbt_cfg_set_parse(set, - "peername:veloce user:mquinson\nuser:oaumage\tuser:alegrand"); + xbt_cfg_set_parse(set, "peername:veloce user:mquinson\nuser:oaumage\tuser:alegrand"); xbt_cfg_free(&set); xbt_cfg_free(&set); } @@ -1363,45 +1218,35 @@ XBT_TEST_UNIT("validation", test_config_validation, "Validation tests") xbt_ex_t e; xbt_test_add("Having too few elements for speed"); - xbt_cfg_set_parse(set, - "peername:veloce user:mquinson\nuser:oaumage\tuser:alegrand"); + xbt_cfg_set_parse(set, "peername:veloce user:mquinson\nuser:oaumage\tuser:alegrand"); TRY { xbt_cfg_check(set); - } - CATCH(e) { - if (e.category != mismatch_error || - strncmp(e.msg, "Config elem speed needs", - strlen("Config elem speed needs"))) + } CATCH(e) { + if (e.category != mismatch_error || strncmp(e.msg, "Config elem speed needs", strlen("Config elem speed needs"))) xbt_test_fail("Got an exception. msg=%s", e.msg); xbt_ex_free(e); } xbt_cfg_free(&set); xbt_cfg_free(&set); - - xbt_test_add("Having too much values of 'speed'"); set = make_set(); xbt_cfg_set_parse(set, "peername:toto:42 user:alegrand"); TRY { xbt_cfg_set_parse(set, "speed:42 speed:24 speed:34"); - } - CATCH(e) { + } CATCH(e) { if (e.category != mismatch_error || - strncmp(e.msg, "Cannot add value 34 to the config elem speed", - strlen("Config elem speed needs"))) + strncmp(e.msg, "Cannot add value 34 to the config elem speed", strlen("Config elem speed needs"))) xbt_test_fail("Got an exception. msg=%s", e.msg); xbt_ex_free(e); } xbt_cfg_check(set); xbt_cfg_free(&set); xbt_cfg_free(&set); - } XBT_TEST_UNIT("use", test_config_use, "Data retrieving tests") { - xbt_test_add("Get a single value"); { /* get_single_value */ @@ -1421,27 +1266,22 @@ XBT_TEST_UNIT("use", test_config_use, "Data retrieving tests") xbt_dynar_t dyn; xbt_cfg_t myset = make_set(); - xbt_cfg_set_parse(myset, - "peername:veloce user:foo\nuser:bar\tuser:toto"); + xbt_cfg_set_parse(myset, "peername:veloce user:foo\nuser:bar\tuser:toto"); xbt_cfg_set_parse(myset, "speed:42"); xbt_cfg_check(myset); dyn = xbt_cfg_get_dynar(myset, "user"); if (xbt_dynar_length(dyn) != 3) - xbt_test_fail("Dynar length = %lu, I expected 3", - xbt_dynar_length(dyn)); + xbt_test_fail("Dynar length = %lu, I expected 3", xbt_dynar_length(dyn)); if (strcmp(xbt_dynar_get_as(dyn, 0, char *), "foo")) - xbt_test_fail("Dynar[0] = %s, I expected foo", - xbt_dynar_get_as(dyn, 0, char *)); + xbt_test_fail("Dynar[0] = %s, I expected foo", xbt_dynar_get_as(dyn, 0, char *)); if (strcmp(xbt_dynar_get_as(dyn, 1, char *), "bar")) - xbt_test_fail("Dynar[1] = %s, I expected bar", - xbt_dynar_get_as(dyn, 1, char *)); + xbt_test_fail("Dynar[1] = %s, I expected bar", xbt_dynar_get_as(dyn, 1, char *)); if (strcmp(xbt_dynar_get_as(dyn, 2, char *), "toto")) - xbt_test_fail("Dynar[2] = %s, I expected toto", - xbt_dynar_get_as(dyn, 2, char *)); + xbt_test_fail("Dynar[2] = %s, I expected toto", xbt_dynar_get_as(dyn, 2, char *)); xbt_cfg_free(&myset); } @@ -1453,8 +1293,7 @@ XBT_TEST_UNIT("use", test_config_use, "Data retrieving tests") TRY { xbt_cfg_set_parse(myset, "color:blue"); - } - CATCH(e) { + } CATCH(e) { if (e.category != not_found_error) xbt_test_exception(e); xbt_ex_free(e); diff --git a/src/xbt/cunit.c b/src/xbt/cunit.c index 01c3f3ecad..a3015fe86c 100644 --- a/src/xbt/cunit.c +++ b/src/xbt/cunit.c @@ -37,7 +37,6 @@ static int _xbt_test_suite_disabled = 0; /* Context */ xbt_test_unit_t _xbt_test_current_unit = NULL; - /* test suite test log */ typedef struct s_xbt_test_log { char *text; @@ -48,8 +47,7 @@ typedef struct s_xbt_test_log { static void xbt_test_log_dump(xbt_test_log_t log) { if (log) - fprintf(stderr, " log %p(%s:%d)=%s\n", log, log->file, log->line, - log->text); + fprintf(stderr, " log %p(%s:%d)=%s\n", log, log->file, log->line, log->text); else fprintf(stderr, " log=NULL\n"); } @@ -70,8 +68,7 @@ static void xbt_test_test_dump(xbt_test_test_t test) if (test) { xbt_test_log_t log; unsigned int it_log; - fprintf(stderr, " test %p(%s:%d)=%s (%s)\n", - test, test->file, test->line, test->title, + fprintf(stderr, " test %p(%s:%d)=%s (%s)\n", test, test->file, test->line, test->title, test->failed ? "failed" : "not failed"); xbt_dynar_foreach(test->logs, it_log, log) xbt_test_log_dump(log); @@ -98,9 +95,7 @@ static void xbt_test_unit_dump(xbt_test_unit_t unit) if (unit) { xbt_test_test_t test; unsigned int it_test; - fprintf(stderr, " UNIT %s: %s (%s)\n", - unit->name, unit->title, - (unit->enabled ? "enabled" : "disabled")); + fprintf(stderr, " UNIT %s: %s (%s)\n", unit->name, unit->title, (unit->enabled ? "enabled" : "disabled")); if (unit->enabled) xbt_dynar_foreach(unit->tests, it_test, test) xbt_test_test_dump(test); @@ -164,13 +159,11 @@ xbt_test_suite_t xbt_test_suite_new(const char *name, const char *fmt, ...) va_list ap; if (!_xbt_test_suites) - _xbt_test_suites = - xbt_dynar_new(sizeof(xbt_test_suite_t), xbt_test_suite_free); + _xbt_test_suites = xbt_dynar_new(sizeof(xbt_test_suite_t), xbt_test_suite_free); va_start(ap, fmt); suite->title = bvprintf(fmt, ap); - suite->units = - xbt_dynar_new(sizeof(xbt_test_unit_t), &xbt_test_unit_free); + suite->units = xbt_dynar_new(sizeof(xbt_test_unit_t), &xbt_test_unit_free); va_end(ap); suite->name = name; suite->enabled = 1; @@ -181,8 +174,7 @@ xbt_test_suite_t xbt_test_suite_new(const char *name, const char *fmt, ...) } /** @brief retrieve a testsuite from name, or create a new one */ -xbt_test_suite_t xbt_test_suite_by_name(const char *name, const char *fmt, - ...) +xbt_test_suite_t xbt_test_suite_by_name(const char *name, const char *fmt, ...) { xbt_test_suite_t suite; unsigned int it_suite; @@ -209,9 +201,7 @@ void xbt_test_suite_dump(xbt_test_suite_t suite) if (suite) { xbt_test_unit_t unit; unsigned int it_unit; - fprintf(stderr, "TESTSUITE %s: %s (%s)\n", - suite->name, suite->title, - suite->enabled ? "enabled" : "disabled"); + fprintf(stderr, "TESTSUITE %s: %s (%s)\n", suite->name, suite->title, suite->enabled ? "enabled" : "disabled"); if (suite->enabled) xbt_dynar_foreach(suite->units, it_unit, unit) xbt_test_unit_dump(unit); @@ -221,8 +211,7 @@ void xbt_test_suite_dump(xbt_test_suite_t suite) } /* add test case to test suite */ -void xbt_test_suite_push(xbt_test_suite_t suite, const char *name, - ts_test_cb_t func, const char *fmt, ...) +void xbt_test_suite_push(xbt_test_suite_t suite, const char *name, ts_test_cb_t func, const char *fmt, ...) { xbt_test_unit_t unit; va_list ap; @@ -269,9 +258,7 @@ static int xbt_test_suite_run(xbt_test_suite_t suite, int verbosity) int suite_len = strlen(suite->title); int i; - xbt_assert(suite_len < 68, - "suite title \"%s\" too long (%d should be less than 68", - suite->title, suite_len); + xbt_assert(suite_len < 68, "suite title \"%s\" too long (%d should be less than 68", suite->title, suite_len); suite_title[0] = ' '; for (i = 1; i < 80; i++) @@ -279,8 +266,7 @@ static int xbt_test_suite_run(xbt_test_suite_t suite, int verbosity) suite_title[i++] = '\n'; suite_title[80] = '\0'; - sprintf(suite_title + 40 - (suite_len + 4) / 2, "[ %s ]", - suite->title); + sprintf(suite_title + 40 - (suite_len + 4) / 2, "[ %s ]", suite->title); suite_title[40 + (suite_len + 5) / 2] = '='; if (!suite->enabled) snprintf(suite_title + 70, 11, " DISABLED "); @@ -323,11 +309,8 @@ static int xbt_test_suite_run(xbt_test_suite_t suite, int verbosity) unit->test_expect++; } } - - /* Display whether this unit went well */ - if (unit->test_failed > 0 || unit->test_expect || - (verbosity && unit->nb_tests > 0)) { + if (unit->test_failed > 0 || unit->test_expect || (verbosity && unit->nb_tests > 0)) { /* some tests failed (or were supposed to), so do detailed reporting of test case */ if (unit->test_failed > 0) { fprintf(stderr, ".. failed\n"); @@ -339,34 +322,23 @@ static int xbt_test_suite_run(xbt_test_suite_t suite, int verbosity) xbt_dynar_foreach(unit->tests, it_test, test) { file = (test->file != NULL ? test->file : unit->file); line = (test->line != 0 ? test->line : unit->line); - fprintf(stderr, " %s: %s [%s:%d]\n", - (test->ignored ? " SKIP" - : (test->expected_failure - ? (test-> - failed ? "EFAIL" : "EPASS") : (test->failed ? - " FAIL" : - " PASS"))), - test->title, file, line); - - if ((test->expected_failure && !test->failed) - || (!test->expected_failure && test->failed)) { + fprintf(stderr, " %s: %s [%s:%d]\n", (test->ignored ? " SKIP" : (test->expected_failure + ? (test-> failed ? "EFAIL" : "EPASS") : (test->failed ? " FAIL" : " PASS"))),test->title, file, line); + + if ((test->expected_failure && !test->failed) || (!test->expected_failure && test->failed)) { xbt_dynar_foreach(test->logs, it_log, log) { file = (log->file != NULL ? log->file : file); line = (log->line != 0 ? log->line : line); - fprintf(stderr, " %s:%d: %s\n", - file, line, log->text); - + fprintf(stderr, " %s:%d: %s\n", file, line, log->text); } } } - fprintf(stderr, " Summary: %d of %d tests failed", - unit->test_failed, unit->nb_tests); + fprintf(stderr, " Summary: %d of %d tests failed", unit->test_failed, unit->nb_tests); if (unit->test_ignore) { fprintf(stderr, " (%d tests ignored)\n", unit->test_ignore); } else { fprintf(stderr, "\n"); } - } else if (!unit->enabled) { fprintf(stderr, " disabled\n"); /* no test were run */ } else if (unit->nb_tests) { @@ -413,65 +385,47 @@ static int xbt_test_suite_run(xbt_test_suite_t suite, int verbosity) _xbt_test_suite_ignore++; } - /* print test suite summary */ if (suite->enabled) { - - fprintf(stderr, - " =====================================================================%s\n", - (suite->nb_units - ? (suite->unit_failed ? "== FAILED" : "====== OK") - : (suite->unit_disabled ? " DISABLED" : "==== SKIP"))); - fprintf(stderr, " Summary: Units: %.0f%% ok (%d units: ", - suite->nb_units - ? ((1 - - (double) suite->unit_failed / (double) suite->nb_units) * - 100.0) : 100.0, suite->nb_units); + fprintf(stderr," =====================================================================%s\n", + (suite->nb_units ? (suite->unit_failed ? "== FAILED" : "====== OK") : + (suite->unit_disabled ? " DISABLED" : "==== SKIP"))); + fprintf(stderr, " Summary: Units: %.0f%% ok (%d units: ", suite->nb_units + ? ((1 - (double) suite->unit_failed / (double) suite->nb_units) * 100.0) : 100.0, suite->nb_units); if (suite->nb_units != suite->unit_failed) { - fprintf(stderr, "%s%d ok", (first ? "" : ", "), - suite->nb_units - suite->unit_failed); + fprintf(stderr, "%s%d ok", (first ? "" : ", "), suite->nb_units - suite->unit_failed); first = 0; } if (suite->unit_failed) { - fprintf(stderr, "%s%d failed", (first ? "" : ", "), - suite->unit_failed); + fprintf(stderr, "%s%d failed", (first ? "" : ", "), suite->unit_failed); first = 0; } if (suite->unit_ignore) { - fprintf(stderr, "%s%d ignored", (first ? "" : ", "), - suite->unit_ignore); + fprintf(stderr, "%s%d ignored", (first ? "" : ", "), suite->unit_ignore); first = 0; } if (suite->unit_disabled) { - fprintf(stderr, "%s%d disabled", (first ? "" : ", "), - suite->unit_disabled); + fprintf(stderr, "%s%d disabled", (first ? "" : ", "), suite->unit_disabled); } - fprintf(stderr, ")\n Tests: %.0f%% ok (%d tests: ", - suite->nb_tests - ? ((1 - - (double) suite->test_failed / (double) suite->nb_tests) * - 100.0) : 100.0, suite->nb_tests); + fprintf(stderr, ")\n Tests: %.0f%% ok (%d tests: ", suite->nb_tests + ? ((1 - (double) suite->test_failed / (double) suite->nb_tests) * 100.0) : 100.0, suite->nb_tests); first = 1; if (suite->nb_tests != suite->test_failed) { - fprintf(stderr, "%s%d ok", (first ? "" : ", "), - suite->nb_tests - suite->test_failed); + fprintf(stderr, "%s%d ok", (first ? "" : ", "), suite->nb_tests - suite->test_failed); first = 0; } if (suite->test_failed) { - fprintf(stderr, "%s%d failed", (first ? "" : ", "), - suite->test_failed); + fprintf(stderr, "%s%d failed", (first ? "" : ", "), suite->test_failed); first = 0; } if (suite->test_ignore) { - fprintf(stderr, "%s%d ignored", (first ? "" : "; "), - suite->test_ignore); + fprintf(stderr, "%s%d ignored", (first ? "" : "; "), suite->test_ignore); first = 0; } if (suite->test_expect) { - fprintf(stderr, "%s%d expected to fail", (first ? "" : "; "), - suite->test_expect); + fprintf(stderr, "%s%d expected to fail", (first ? "" : "; "), suite->test_expect); } fprintf(stderr, ")\n"); } @@ -574,9 +528,9 @@ static void apply_selection(char *selection) break; /* found the relevant serie. We are happy */ } } /* search relevant series */ - xbt_assert(it != xbt_dynar_length(_xbt_test_suites), "No suite of name '%s' found. Cannot apply the selection\n", suitename); + xbt_assert(it != xbt_dynar_length(_xbt_test_suites), + "No suite of name '%s' found. Cannot apply the selection\n", suitename); } - } } @@ -609,11 +563,8 @@ int xbt_test_run(char *selection, int verbosity) xbt_test_suite_run(suite, verbosity); /* Display some more statistics */ - fprintf(stderr, "\n\n TOTAL: Suites: %.0f%% ok (%d suites: ", - _xbt_test_nb_suites - ? ((1 - - (double) _xbt_test_suite_failed / - (double) _xbt_test_nb_suites) * 100.0) + fprintf(stderr, "\n\n TOTAL: Suites: %.0f%% ok (%d suites: ",_xbt_test_nb_suites + ? ((1 - (double) _xbt_test_suite_failed / (double) _xbt_test_nb_suites) * 100.0) : 100.0, _xbt_test_nb_suites); if (_xbt_test_nb_suites != _xbt_test_suite_failed) { fprintf(stderr, "%d ok", _xbt_test_nb_suites - _xbt_test_suite_failed); @@ -627,12 +578,8 @@ int xbt_test_run(char *selection, int verbosity) if (_xbt_test_suite_ignore) { fprintf(stderr, "%s%d ignored", (first ? "" : ", "), _xbt_test_suite_ignore); } - fprintf(stderr, ")\n Units: %.0f%% ok (%d units: ", - _xbt_test_nb_units - ? ((1 - - (double) _xbt_test_unit_failed / - (double) _xbt_test_nb_units) * 100.0) : 100.0, - _xbt_test_nb_units); + fprintf(stderr, ")\n Units: %.0f%% ok (%d units: ", _xbt_test_nb_units + ? ((1 - (double) _xbt_test_unit_failed / (double) _xbt_test_nb_units) * 100.0) : 100.0, _xbt_test_nb_units); first = 1; if (_xbt_test_nb_units != _xbt_test_unit_failed) { fprintf(stderr, "%s%d ok", (first ? "" : ", "), _xbt_test_nb_units - _xbt_test_unit_failed); @@ -645,12 +592,8 @@ int xbt_test_run(char *selection, int verbosity) if (_xbt_test_unit_ignore) { fprintf(stderr, "%s%d ignored", (first ? "" : ", "), _xbt_test_unit_ignore); } - fprintf(stderr, ")\n Tests: %.0f%% ok (%d tests: ", - _xbt_test_nb_tests - ? ((1 - - (double) _xbt_test_test_failed / - (double) _xbt_test_nb_tests) * 100.0) : 100.0, - _xbt_test_nb_tests); + fprintf(stderr, ")\n Tests: %.0f%% ok (%d tests: ", _xbt_test_nb_tests + ? ((1 - (double) _xbt_test_test_failed / (double) _xbt_test_nb_tests) * 100.0) : 100.0, _xbt_test_nb_tests); first = 1; if (_xbt_test_nb_tests != _xbt_test_test_failed) { fprintf(stderr, "%s%d ok", (first ? "" : ", "), _xbt_test_nb_tests - _xbt_test_test_failed); @@ -765,9 +708,7 @@ void _xbt_test_log(const char *file, int line, const char *fmt, ...) xbt_dynar_push(test->logs, &log); } - #ifdef SIMGRID_TEST - XBT_TEST_SUITE("cunit", "Testsuite mechanism autotest"); XBT_TEST_UNIT("expect", test_expected_failure, "expected failures") @@ -780,5 +721,4 @@ XBT_TEST_UNIT("expect", test_expected_failure, "expected failures") xbt_test_log("%s %s", "Test", "log"); xbt_test_fail("EXPECTED FAILURE"); } - #endif /* SIMGRID_TEST */ diff --git a/src/xbt/dict.c b/src/xbt/dict.c index 28c1165d1a..59927b752a 100644 --- a/src/xbt/dict.c +++ b/src/xbt/dict.c @@ -15,8 +15,7 @@ #include "xbt/str.h" #include "dict_private.h" -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dict, xbt, - "Dictionaries provide the same functionalities as hash tables"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dict, xbt, "Dictionaries provide the same functionalities as hash tables"); /** * \brief Constructor @@ -24,8 +23,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dict, xbt, * \see xbt_dict_new_homogenous(), xbt_dict_free() * * Creates and initialize a new dictionary with a default hashtable size. - * The dictionary is heterogeneous: each element can have a different free - * function. + * The dictionary is heterogeneous: each element can have a different free function. */ xbt_dict_t xbt_dict_new(void) { @@ -37,8 +35,7 @@ xbt_dict_t xbt_dict_new(void) /** * \brief Constructor - * \param free_ctn function to call with (\a data as argument) when - * \a data is removed from the dictionary + * \param free_ctn function to call with (\a data as argument) when \a data is removed from the dictionary * \return pointer to the destination * \see xbt_dict_new(), xbt_dict_free() * @@ -95,9 +92,7 @@ void xbt_dict_free(xbt_dict_t * dict) } } -/** - * Returns the amount of elements in the dict - */ +/** Returns the amount of elements in the dict */ inline unsigned int xbt_dict_size(xbt_dict_t dict) { return (dict ? (unsigned int) dict->count : (unsigned int) 0); @@ -114,9 +109,7 @@ static void xbt_dict_rehash(xbt_dict_t dict) xbt_dictelm_t bucklet; xbt_dictelm_t *pprev; - currcell = - (xbt_dictelm_t *) xbt_realloc((char *) dict->table, - newsize * sizeof(xbt_dictelm_t)); + currcell = (xbt_dictelm_t *) xbt_realloc((char *) dict->table, newsize * sizeof(xbt_dictelm_t)); memset(&currcell[oldsize], 0, oldsize * sizeof(xbt_dictelm_t)); /* zero second half */ dict->table_size = --newsize; dict->table = currcell; @@ -127,8 +120,7 @@ static void xbt_dict_rehash(xbt_dict_t dict) continue; twincell = currcell + oldsize; for (pprev = currcell, bucklet = *currcell; bucklet; bucklet = *pprev) { - /* Since we use "& size" instead of "%size" and since the size was doubled, - each bucklet of this cell must either : + /* Since we use "& size" instead of "%size" and since the size was doubled, each bucklet of this cell must either: - stay in cell i (ie, currcell) - go to the cell i+oldsize (ie, twincell) */ if ((bucklet->hash_code & newsize) != i) { /* Move to b */ @@ -141,7 +133,6 @@ static void xbt_dict_rehash(xbt_dict_t dict) } else { pprev = &bucklet->next; } - } if (!*currcell) /* everything moved */ @@ -155,29 +146,22 @@ static void xbt_dict_rehash(xbt_dict_t dict) * \param key the key to set the new data * \param key_len the size of the \a key * \param data the data to add in the dict - * \param free_ctn function to call with (\a data as argument) when - * \a data is removed from the dictionary. This param - * will only be considered when the dict was instantiated with - * xbt_dict_new() and not xbt_dict_new_homogeneous() + * \param free_ctn function to call with (\a data as argument) when \a data is removed from the dictionary. This param + * will only be considered when the dict was instantiated with xbt_dict_new() and not xbt_dict_new_homogeneous() * - * Set the \a data in the structure under the \a key, which can be any kind - * of data, as long as its length is provided in \a key_len. + * Set the \a data in the structure under the \a key, which can be any kind of data, as long as its length is provided + * in \a key_len. */ -inline void xbt_dict_set_ext(xbt_dict_t dict, - const char *key, int key_len, - void *data, void_f_pvoid_t free_ctn) +inline void xbt_dict_set_ext(xbt_dict_t dict, const char *key, int key_len, void *data, void_f_pvoid_t free_ctn) { - unsigned int hash_code = xbt_str_hash_ext(key, key_len); xbt_dictelm_t current, previous = NULL; - XBT_CDEBUG(xbt_dict, - "ADD %.*s hash = %u, size = %d, & = %u", key_len, key, hash_code, + XBT_CDEBUG(xbt_dict, "ADD %.*s hash = %u, size = %d, & = %u", key_len, key, hash_code, dict->table_size, hash_code & dict->table_size); current = dict->table[hash_code & dict->table_size]; - while (current != NULL && - (hash_code != current->hash_code || key_len != current->key_len + while (current != NULL && (hash_code != current->hash_code || key_len != current->key_len || memcmp(key, current->key, key_len))) { previous = current; current = current->next; @@ -197,8 +181,7 @@ inline void xbt_dict_set_ext(xbt_dict_t dict, } } else { XBT_CDEBUG(xbt_dict, "Replace %.*s by %.*s under key %.*s", - key_len, (char *) current->content, - key_len, (char *) data, key_len, (char *) key); + key_len, (char *) current->content, key_len, (char *) data, key_len, (char *) key); /* there is already an element with the same key: overwrite it */ xbt_dictelm_set_data(dict, current, data, free_ctn); } @@ -210,19 +193,13 @@ inline void xbt_dict_set_ext(xbt_dict_t dict, * \param dict the dict * \param key the key to set the new data * \param data the data to add in the dict - * \param free_ctn function to call with (\a data as argument) when - * \a data is removed from the dictionary. This param - * will only be considered when the dict was instantiated with - * xbt_dict_new() and not xbt_dict_new_homogeneous() + * \param free_ctn function to call with (\a data as argument) when \a data is removed from the dictionary. This param + * will only be considered when the dict was instantiated with xbt_dict_new() and not xbt_dict_new_homogeneous() * - * set the \a data in the structure under the \a key, which is a - * null terminated string. + * set the \a data in the structure under the \a key, which is anull terminated string. */ -inline void xbt_dict_set(xbt_dict_t dict, - const char *key, void *data, - void_f_pvoid_t free_ctn) +inline void xbt_dict_set(xbt_dict_t dict, const char *key, void *data, void_f_pvoid_t free_ctn) { - xbt_dict_set_ext(dict, key, strlen(key), data, free_ctn); } @@ -241,8 +218,7 @@ inline void *xbt_dict_get_ext(xbt_dict_t dict, const char *key, int key_len) unsigned int hash_code = xbt_str_hash_ext(key, key_len); xbt_dictelm_t current = dict->table[hash_code & dict->table_size]; - while (current != NULL && - (hash_code != current->hash_code || key_len != current->key_len + while (current != NULL && (hash_code != current->hash_code || key_len != current->key_len || memcmp(key, current->key, key_len))) { current = current->next; } @@ -259,8 +235,7 @@ void *xbt_dict_get_or_null_ext(xbt_dict_t dict, const char *key, int key_len) unsigned int hash_code = xbt_str_hash_ext(key, key_len); xbt_dictelm_t current = dict->table[hash_code & dict->table_size]; - while (current != NULL && - (hash_code != current->hash_code || key_len != current->key_len + while (current != NULL && (hash_code != current->hash_code || key_len != current->key_len || memcmp(key, current->key, key_len))) { current = current->next; } @@ -286,7 +261,6 @@ char *xbt_dict_get_key(xbt_dict_t dict, const void *data) current = current->next; } } - return NULL; } @@ -304,13 +278,13 @@ char *xbt_dict_get_elm_key(xbt_dictelm_t elm) * \return the data that we are looking for * * Search the given \a key. Throws not_found_error when not found. - * Check xbt_dict_get_or_null() for a version returning NULL without exception when - * not found. + * Check xbt_dict_get_or_null() for a version returning NULL without exception when not found. */ inline void *xbt_dict_get(xbt_dict_t dict, const char *key) { return xbt_dict_get_elm(dict, key)->content; } + /** * \brief Retrieve element from the dict (null-terminated key) * @@ -319,8 +293,7 @@ inline void *xbt_dict_get(xbt_dict_t dict, const char *key) * \return the s_xbt_dictelm_t that we are looking for * * Search the given \a key. Throws not_found_error when not found. - * Check xbt_dict_get_or_null() for a version returning NULL without exception when - * not found. + * Check xbt_dict_get_or_null() for a version returning NULL without exception when not found. */ inline xbt_dictelm_t xbt_dict_get_elm(xbt_dict_t dict, const char *key) { @@ -344,6 +317,7 @@ inline void *xbt_dict_get_or_null(xbt_dict_t dict, const char *key) return current->content; } + /** * \brief like xbt_dict_get_elm(), but returning NULL when not found */ @@ -352,13 +326,11 @@ inline xbt_dictelm_t xbt_dict_get_elm_or_null(xbt_dict_t dict, const char *key) unsigned int hash_code = xbt_str_hash(key); xbt_dictelm_t current = dict->table[hash_code & dict->table_size]; - while (current != NULL && - (hash_code != current->hash_code || strcmp(key, current->key))) + while (current != NULL && (hash_code != current->hash_code || strcmp(key, current->key))) current = current->next; return current; } - /** * \brief Remove data from the dict (arbitrary key) * @@ -374,8 +346,7 @@ inline void xbt_dict_remove_ext(xbt_dict_t dict, const char *key, int key_len) xbt_dictelm_t previous = NULL; xbt_dictelm_t current = dict->table[hash_code & dict->table_size]; - while (current != NULL && - (hash_code != current->hash_code || key_len != current->key_len + while (current != NULL && (hash_code != current->hash_code || key_len != current->key_len || strncmp(key, current->key, key_len))) { previous = current; /* save the previous node */ current = current->next; @@ -397,8 +368,6 @@ inline void xbt_dict_remove_ext(xbt_dict_t dict, const char *key, int key_len) dict->count--; } - - /** * \brief Remove data from the dict (null-terminated key) * @@ -462,10 +431,9 @@ inline int xbt_dict_is_empty(xbt_dict_t dict) * \param dict the exibitionist * \param output a function to dump each data in the tree (check @ref xbt_dict_dump_output_string) * - * Outputs the content of the structure. (for debugging purpose). \a output is a - * function to output the data. If NULL, data won't be displayed. + * Outputs the content of the structure. (for debugging purpose). \a output is a function to output the data. If NULL, + * data won't be displayed. */ - void xbt_dict_dump(xbt_dict_t dict, void_f_pvoid_t output) { int i; @@ -559,13 +527,9 @@ void xbt_dict_dump_sizes(xbt_dict_t dict) */ void xbt_dict_preinit(void) { - dict_elm_mallocator = xbt_mallocator_new(256, - dict_elm_mallocator_new_f, - dict_elm_mallocator_free_f, + dict_elm_mallocator = xbt_mallocator_new(256, dict_elm_mallocator_new_f, dict_elm_mallocator_free_f, dict_elm_mallocator_reset_f); - dict_het_elm_mallocator = xbt_mallocator_new(256, - dict_het_elm_mallocator_new_f, - dict_het_elm_mallocator_free_f, + dict_het_elm_mallocator = xbt_mallocator_new(256, dict_het_elm_mallocator_new_f, dict_het_elm_mallocator_free_f, dict_het_elm_mallocator_reset_f); } @@ -605,13 +569,11 @@ void xbt_dict_postexit(void) #include "xbt/ex.h" #include "src/internal_config.h" - XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(xbt_dict); XBT_TEST_SUITE("dict", "Dict data container"); -static void debuged_add_ext(xbt_dict_t head, const char *key, - const char *data_to_fill, void_f_pvoid_t free_f) +static void debuged_add_ext(xbt_dict_t head, const char *key, const char *data_to_fill, void_f_pvoid_t free_f) { char *data = xbt_strdup(data_to_fill); @@ -647,7 +609,6 @@ static void fill(xbt_dict_t * head, int homogeneous) debuged_add(*head, "123457", free_f); } - static void search_ext(xbt_dict_t head, const char *key, const char *data) { char *found; @@ -656,17 +617,12 @@ static void search_ext(xbt_dict_t head, const char *key, const char *data) found = xbt_dict_get(head, key); xbt_test_log("Found %s", found); if (data) { - xbt_test_assert(found, - "data do not match expectations: found NULL while searching for %s", - data); + xbt_test_assert(found, "data do not match expectations: found NULL while searching for %s", data); if (found) - xbt_test_assert(!strcmp(data, found), - "data do not match expectations: found %s while searching for %s", + xbt_test_assert(!strcmp(data, found), "data do not match expectations: found %s while searching for %s", found, data); } else { - xbt_test_assert(!found, - "data do not match expectations: found %s while searching for NULL", - found); + xbt_test_assert(!found, "data do not match expectations: found %s while searching for NULL", found); } } @@ -677,13 +633,11 @@ static void search(xbt_dict_t head, const char *key) static void debuged_remove(xbt_dict_t head, const char *key) { - xbt_test_add("Remove '%s'", key); xbt_dict_remove(head, key); /* xbt_dict_dump(head,(void (*)(void*))&printf); */ } - static void traverse(xbt_dict_t head) { xbt_dict_cursor_t cursor = NULL; @@ -697,8 +651,7 @@ static void traverse(xbt_dict_t head) } else { xbt_test_log("Seen #%d: %s", ++i, key); } - xbt_test_assert(!data || !strcmp(key, data), - "Key(%s) != value(%s). Aborting", key, data); + xbt_test_assert(!data || !strcmp(key, data), "Key(%s) != value(%s). Aborting", key, data); } } @@ -711,10 +664,8 @@ static void search_not_found(xbt_dict_t head, const char *data) TRY { data = xbt_dict_get(head, data); - THROWF(unknown_error, 0, - "Found something which shouldn't be there (%s)", data); - } - CATCH(e) { + THROWF(unknown_error, 0, "Found something which shouldn't be there (%s)", data); + } CATCH(e) { if (e.category != not_found_error) xbt_test_exception(e); xbt_ex_free(e); @@ -730,18 +681,13 @@ static void count(xbt_dict_t dict, int length) void *data; int effective = 0; - xbt_test_add("Count elements (expecting %d)", length); - xbt_test_assert(xbt_dict_length(dict) == length, - "Announced length(%d) != %d.", xbt_dict_length(dict), - length); + xbt_test_assert(xbt_dict_length(dict) == length, "Announced length(%d) != %d.", xbt_dict_length(dict), length); xbt_dict_foreach(dict, cursor, key, data) effective++; - xbt_test_assert(effective == length, "Effective length(%d) != %d.", - effective, length); - + xbt_test_assert(effective == length, "Effective length(%d) != %d.", effective, length); } static void count_check_get_key(xbt_dict_t dict, int length) @@ -752,25 +698,16 @@ static void count_check_get_key(xbt_dict_t dict, int length) void *data; int effective = 0; - - xbt_test_add - ("Count elements (expecting %d), and test the getkey function", - length); - xbt_test_assert(xbt_dict_length(dict) == length, - "Announced length(%d) != %d.", xbt_dict_length(dict), - length); + xbt_test_add("Count elements (expecting %d), and test the getkey function", length); + xbt_test_assert(xbt_dict_length(dict) == length, "Announced length(%d) != %d.", xbt_dict_length(dict), length); xbt_dict_foreach(dict, cursor, key, data) { effective++; key2 = xbt_dict_get_key(dict, data); - xbt_assert(!strcmp(key, key2), - "The data was registered under %s instead of %s as expected", - key2, key); + xbt_assert(!strcmp(key, key2), "The data was registered under %s instead of %s as expected", key2, key); } - xbt_test_assert(effective == length, "Effective length(%d) != %d.", - effective, length); - + xbt_test_assert(effective == length, "Effective length(%d) != %d.", effective, length); } xbt_ex_t e; @@ -789,8 +726,7 @@ static void basic_test(int homogeneous) traverse(head); TRY { debuged_remove(head, "12346"); - } - CATCH(e) { + } CATCH(e) { if (e.category != not_found_error) xbt_test_exception(e); xbt_ex_free(e); @@ -883,8 +819,7 @@ static void remove_test(int homogeneous) xbt_test_add("Remove non existing data"); TRY { debuged_remove(head, "Does not exist"); - } - CATCH(e) { + } CATCH(e) { if (e.category != not_found_error) xbt_test_exception(e); xbt_ex_free(e); @@ -893,8 +828,7 @@ static void remove_test(int homogeneous) xbt_dict_free(&head); - xbt_test_add - ("Remove each data manually (traversing the resulting dictionary each time)"); + xbt_test_add("Remove each data manually (traversing the resulting dictionary each time)"); fill(&head, homogeneous); debuged_remove(head, "12a"); traverse(head); @@ -910,8 +844,7 @@ static void remove_test(int homogeneous) count(head, 3); TRY { debuged_remove(head, "12346"); - } - CATCH(e) { + } CATCH(e) { if (e.category != not_found_error) xbt_test_exception(e); xbt_ex_free(e); @@ -925,16 +858,14 @@ static void remove_test(int homogeneous) traverse(head); TRY { debuged_remove(head, "12346"); - } - CATCH(e) { + } CATCH(e) { if (e.category != not_found_error) xbt_test_exception(e); xbt_ex_free(e); } traverse(head); - xbt_test_add - ("Free dict, create new fresh one, and then reset the dict"); + xbt_test_add("Free dict, create new fresh one, and then reset the dict"); xbt_dict_free(&head); fill(&head, homogeneous); xbt_dict_reset(head); @@ -980,8 +911,7 @@ XBT_TEST_UNIT("nulldata", test_dict_nulldata, "NULL data management") if (!strcmp(key, "null")) found = 1; } - xbt_test_assert(found, - "the key 'null', associated to NULL is not found"); + xbt_test_assert(found, "the key 'null', associated to NULL is not found"); } xbt_dict_free(&head); } @@ -1011,11 +941,8 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test") for (i = 0; i < 10; i++) { xbt_test_add("CRASH test number %d (%d to go)", i + 1, 10 - i - 1); - xbt_test_log - ("Fill the struct, count its elems and frees the structure"); - xbt_test_log - ("using 1000 elements with %d chars long randomized keys.", - SIZEOFKEY); + xbt_test_log("Fill the struct, count its elems and frees the structure"); + xbt_test_log("using 1000 elements with %d chars long randomized keys.", SIZEOFKEY); head = xbt_dict_new(); /* if (i%10) printf("."); else printf("%d",i/10); fflush(stdout); */ for (j = 0; j < 1000; j++) { @@ -1032,9 +959,7 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test") xbt_dict_set(head, key, key, &free); data = xbt_dict_get(head, key); - xbt_test_assert(!strcmp(key, data), - "Retrieved value (%s) != Injected value (%s)", key, - data); + xbt_test_assert(!strcmp(key, data), "Retrieved value (%s) != Injected value (%s)", key, data); count(head, j + 1); } @@ -1044,13 +969,10 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test") xbt_dict_free(&head); } - head = xbt_dict_new(); - xbt_test_add("Fill %d elements, with keys being the number of element", - NB_ELM); + xbt_test_add("Fill %d elements, with keys being the number of element", NB_ELM); for (j = 0; j < NB_ELM; j++) { /* if (!(j%1000)) { printf("."); fflush(stdout); } */ - key = xbt_malloc(10); sprintf(key, "%d", j); @@ -1058,8 +980,7 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test") } /*xbt_dict_dump(head,(void (*)(void*))&printf); */ - xbt_test_add - ("Count the elements (retrieving the key and data for each)"); + xbt_test_add("Count the elements (retrieving the key and data for each)"); i = countelems(head); xbt_test_log("There is %d elements", i); @@ -1069,15 +990,11 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test") void *data; /* if (i%10) printf("."); else printf("%d",i/10); fflush(stdout); */ for (j = 0; j < NB_ELM; j++) { - sprintf(key, "%d", j); data = xbt_dict_get(head, key); - xbt_test_assert(!strcmp(key, (char *) data), - "with get, key=%s != data=%s", key, (char *) data); + xbt_test_assert(!strcmp(key, (char *) data), "with get, key=%s != data=%s", key, (char *) data); data = xbt_dict_get_ext(head, key, strlen(key)); - xbt_test_assert(!strcmp(key, (char *) data), - "with get_ext, key=%s != data=%s", key, - (char *) data); + xbt_test_assert(!strcmp(key, (char *) data), "with get_ext, key=%s != data=%s", key, (char *) data); } } free(key); @@ -1086,13 +1003,11 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test") key = xbt_malloc(10); for (j = 0; j < NB_ELM; j++) { /* if (!(j%10000)) printf("."); fflush(stdout); */ - sprintf(key, "%d", j); xbt_dict_remove(head, key); } free(key); - xbt_test_add("Free the structure (twice)"); xbt_dict_free(&head); xbt_dict_free(&head); @@ -1107,18 +1022,15 @@ XBT_TEST_UNIT("ext", test_dict_int, "Test dictionnary with int keys") int i; for (i = 0; i < count; ++i) xbt_dict_set_ext(dict, (char*) &i, sizeof(i), (void*) (intptr_t) i, NULL); - xbt_test_assert(xbt_dict_size(dict) == count, - "Bad number of elements in the dictionnary"); + xbt_test_assert(xbt_dict_size(dict) == count, "Bad number of elements in the dictionnary"); xbt_test_add("Check elements"); for (i = 0; i < count; ++i) { int res = (int) (intptr_t) xbt_dict_get_ext(dict, (char*) &i, sizeof(i)); - xbt_test_assert(xbt_dict_size(dict) == count, - "Unexpected value at index %i, expected %i but was %i", i, i, res); + xbt_test_assert(xbt_dict_size(dict) == count, "Unexpected value at index %i, expected %i but was %i", i, i, res); } xbt_test_add("Free the array"); xbt_dict_free(&dict); } - #endif /* SIMGRID_TEST */ diff --git a/src/xbt/dict_cursor.c b/src/xbt/dict_cursor.c index c1c52fde10..ab5872c158 100644 --- a/src/xbt/dict_cursor.c +++ b/src/xbt/dict_cursor.c @@ -1,4 +1,4 @@ -/* dict_cursor - iterators over dictionnaries */ +/* dict_cursor - iterators over dictionaries */ /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ @@ -12,9 +12,7 @@ #include /* strlen() */ -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dict_cursor, xbt_dict, - "To traverse dictionaries"); - +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dict_cursor, xbt_dict, "To traverse dictionaries"); /*####[ Dict cursor functions ]#############################################*/ /* To traverse (simple) dicts */ @@ -57,7 +55,6 @@ static inline void __cursor_not_null(xbt_dict_cursor_t cursor) xbt_assert(cursor, "Null cursor"); } - /** @brief Reinitialize the cursor. Mandatory after removal or add in dict. */ inline void xbt_dict_cursor_rewind(xbt_dict_cursor_t cursor) { @@ -78,8 +75,7 @@ inline void xbt_dict_cursor_rewind(xbt_dict_cursor_t cursor) * @param dict on what to let the cursor iterate * @param[out] cursor dest address */ -inline void xbt_dict_cursor_first(const xbt_dict_t dict, - xbt_dict_cursor_t * cursor) +inline void xbt_dict_cursor_first(const xbt_dict_t dict, xbt_dict_cursor_t * cursor) { XBT_CDEBUG(xbt_dict_cursor, "xbt_dict_cursor_first"); if (!*cursor) { @@ -93,10 +89,7 @@ inline void xbt_dict_cursor_first(const xbt_dict_t dict, } } - -/** - * \brief Move to the next element. - */ +/** \brief Move to the next element. */ inline void xbt_dict_cursor_step(xbt_dict_cursor_t cursor) { xbt_dictelm_t current; @@ -109,7 +102,6 @@ inline void xbt_dict_cursor_step(xbt_dict_cursor_t cursor) line = cursor->line; if (cursor->dict != NULL) { - if (current != NULL) { XBT_CDEBUG(xbt_dict_cursor, "current is not null, take the next element"); current = current->next; @@ -133,15 +125,12 @@ inline void xbt_dict_cursor_step(xbt_dict_cursor_t cursor) * * @returns true if it's ok, false if there is no more data */ -inline int xbt_dict_cursor_get_or_free(xbt_dict_cursor_t * cursor, - char **key, void **data) +inline int xbt_dict_cursor_get_or_free(xbt_dict_cursor_t * cursor, char **key, void **data) { - xbt_dictelm_t current; XBT_CDEBUG(xbt_dict_cursor, "xbt_dict_get_or_free"); - if (!cursor || !(*cursor)) return FALSE; @@ -186,9 +175,7 @@ inline void *xbt_dict_cursor_get_data(xbt_dict_cursor_t cursor) * @param data the new data * @param free_ctn the function to free the new data */ -inline void xbt_dict_cursor_set_data(xbt_dict_cursor_t cursor, - void *data, - void_f_pvoid_t free_ctn) +inline void xbt_dict_cursor_set_data(xbt_dict_cursor_t cursor, void *data, void_f_pvoid_t free_ctn) { __cursor_not_null(cursor); xbt_dictelm_set_data(cursor->dict, cursor->current, data, free_ctn); diff --git a/src/xbt/dict_elm.c b/src/xbt/dict_elm.c index 286ffe7422..f7586e5901 100644 --- a/src/xbt/dict_elm.c +++ b/src/xbt/dict_elm.c @@ -8,21 +8,18 @@ #include "dict_private.h" /* prototypes of this module */ -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dict_elm, xbt_dict, - "Dictionaries internals"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dict_elm, xbt_dict, "Dictionaries internals"); xbt_mallocator_t dict_elm_mallocator = NULL; xbt_mallocator_t dict_het_elm_mallocator = NULL; -xbt_dictelm_t xbt_dictelm_new(xbt_dict_t dict, const char *key, int key_len, - unsigned int hash_code, void *content, +xbt_dictelm_t xbt_dictelm_new(xbt_dict_t dict, const char *key, int key_len, unsigned int hash_code, void *content, void_f_pvoid_t free_f) { xbt_dictelm_t element; if (dict->homogeneous) { - xbt_assert(!free_f, - "Cannot set an individual free function in homogeneous dicts."); + xbt_assert(!free_f, "Cannot set an individual free function in homogeneous dicts."); element = xbt_mallocator_get(dict_elm_mallocator); } else { xbt_het_dictelm_t het_element = xbt_mallocator_get(dict_het_elm_mallocator); @@ -63,14 +60,12 @@ void xbt_dictelm_free(xbt_dict_t dict, xbt_dictelm_t element) } } -void xbt_dictelm_set_data(xbt_dict_t dict, xbt_dictelm_t element, - void *data, void_f_pvoid_t free_ctn) +void xbt_dictelm_set_data(xbt_dict_t dict, xbt_dictelm_t element, void *data, void_f_pvoid_t free_ctn) { void_f_pvoid_t free_f; if (dict->homogeneous) { free_f = dict->free_f; - xbt_assert(!free_ctn, - "Cannot set an individual free function in homogeneous dicts."); + xbt_assert(!free_ctn, "Cannot set an individual free function in homogeneous dicts."); } else { xbt_het_dictelm_t het_element = (xbt_het_dictelm_t)element; free_f = het_element->free_f; diff --git a/src/xbt/dict_private.h b/src/xbt/dict_private.h index 7db9869605..9d3be26d8a 100644 --- a/src/xbt/dict_private.h +++ b/src/xbt/dict_private.h @@ -20,7 +20,6 @@ #define MAX_FILL_PERCENT 80 - typedef struct s_xbt_het_dictelm { s_xbt_dictelm_t element; void_f_pvoid_t free_f; @@ -49,10 +48,8 @@ extern XBT_PRIVATE void * dict_het_elm_mallocator_new_f(void); /*####[ Function prototypes ]################################################*/ XBT_PRIVATE xbt_dictelm_t xbt_dictelm_new(xbt_dict_t dict, const char *key, int key_len, - unsigned int hash_code, void *content, - void_f_pvoid_t free_f); + unsigned int hash_code, void *content, void_f_pvoid_t free_f); XBT_PRIVATE void xbt_dictelm_free(xbt_dict_t dict, xbt_dictelm_t element); -XBT_PRIVATE void xbt_dictelm_set_data(xbt_dict_t dict, xbt_dictelm_t element, - void *data, void_f_pvoid_t free_ctn); +XBT_PRIVATE void xbt_dictelm_set_data(xbt_dict_t dict, xbt_dictelm_t element, void *data, void_f_pvoid_t free_ctn); #endif /* _XBT_DICT_PRIVATE_H_ */ diff --git a/src/xbt/dynar.c b/src/xbt/dynar.c index 10a1086d2a..006ea0d932 100644 --- a/src/xbt/dynar.c +++ b/src/xbt/dynar.c @@ -28,8 +28,7 @@ static inline void _sanity_check_idx(int idx) static inline void _check_inbound_idx(xbt_dynar_t dynar, int idx) { if (idx < 0 || idx >= (int)dynar->used) { - THROWF(bound_error, idx, - "dynar is not that long. You asked %d, but it's only %lu long", + THROWF(bound_error, idx, "dynar is not that long. You asked %d, but it's only %lu long", (int) (idx), (unsigned long) dynar->used); } } @@ -41,8 +40,7 @@ static inline void _check_populated_dynar(xbt_dynar_t dynar) } } -static inline -void _xbt_dynar_resize(xbt_dynar_t dynar, unsigned long new_size) +static inline void _xbt_dynar_resize(xbt_dynar_t dynar, unsigned long new_size) { if (new_size != dynar->size) { dynar->size = new_size; @@ -50,21 +48,18 @@ void _xbt_dynar_resize(xbt_dynar_t dynar, unsigned long new_size) } } -static inline - void _xbt_dynar_expand(xbt_dynar_t const dynar, const unsigned long nb) +static inline void _xbt_dynar_expand(xbt_dynar_t const dynar, const unsigned long nb) { const unsigned long old_size = dynar->size; if (nb > old_size) { const unsigned long expand = 2 * (old_size + 1); _xbt_dynar_resize(dynar, (nb > expand ? nb : expand)); - XBT_DEBUG("expand %p from %lu to %lu elements", - dynar, old_size, dynar->size); + XBT_DEBUG("expand %p from %lu to %lu elements", dynar, old_size, dynar->size); } } -static inline - void *_xbt_dynar_elm(const xbt_dynar_t dynar, const unsigned long idx) +static inline void *_xbt_dynar_elm(const xbt_dynar_t dynar, const unsigned long idx) { char *const data = (char *) dynar->data; const unsigned long elmsize = dynar->elmsize; @@ -72,10 +67,7 @@ static inline return data + idx * elmsize; } -static inline - void -_xbt_dynar_get_elm(void *const dst, - const xbt_dynar_t dynar, const unsigned long idx) +static inline void _xbt_dynar_get_elm(void *const dst, const xbt_dynar_t dynar, const unsigned long idx) { void *const elm = _xbt_dynar_elm(dynar, idx); @@ -85,8 +77,7 @@ _xbt_dynar_get_elm(void *const dst, void xbt_dynar_dump(xbt_dynar_t dynar) { XBT_INFO("Dynar dump: size=%lu; used=%lu; elmsize=%lu; data=%p; free_f=%p", - dynar->size, dynar->used, dynar->elmsize, dynar->data, - dynar->free_f); + dynar->size, dynar->used, dynar->elmsize, dynar->data, dynar->free_f); } /** @brief Constructor @@ -94,14 +85,11 @@ void xbt_dynar_dump(xbt_dynar_t dynar) * \param elmsize size of each element in the dynar * \param free_f function to call each time we want to get rid of an element (or NULL if nothing to do). * - * Creates a new dynar. If a free_func is provided, the elements have to be - * pointer of pointer. That is to say that dynars can contain either base - * types (int, char, double, etc) or pointer of pointers (struct **). + * Creates a new dynar. If a free_func is provided, the elements have to be pointer of pointer. That is to say that + * dynars can contain either base types (int, char, double, etc) or pointer of pointers (struct **). */ -xbt_dynar_t -xbt_dynar_new(const unsigned long elmsize, void_f_pvoid_t const free_f) +xbt_dynar_t xbt_dynar_new(const unsigned long elmsize, void_f_pvoid_t const free_f) { - xbt_dynar_t dynar = xbt_new0(s_xbt_dynar_t, 1); dynar->size = 0; @@ -117,8 +105,8 @@ xbt_dynar_new(const unsigned long elmsize, void_f_pvoid_t const free_f) * * \param dynar poor victim * - * kilkil a dynar BUT NOT its content. Ie, the array is freed, but the content - * is not touched (the \a free_f function is not used) + * kilkil a dynar BUT NOT its content. Ie, the array is freed, but the content is not touched (the \a free_f function + * is not used) */ void xbt_dynar_free_container(xbt_dynar_t * dynar) { @@ -170,17 +158,13 @@ void xbt_dynar_merge(xbt_dynar_t *d1, xbt_dynar_t *d2) /** * \brief Shrink the dynar by removing empty slots at the end of the internal array * \param dynar a dynar - * \param empty_slots_wanted number of empty slots you want to keep at the end of the - * internal array for further insertions + * \param empty_slots_wanted number of empty slots you want to keep at the end of the internal array for further + * insertions * - * Reduces the internal array size of the dynar to the number of elements plus - * \a empty_slots_wanted. - * After removing elements from the dynar, you can call this function to make - * the dynar use less memory. - * Set \a empty_slots_wanted to zero to reduce the dynar internal array as much - * as possible. - * Note that if \a empty_slots_wanted is greater than the array size, the internal - * array is expanded instead of shriked. + * Reduces the internal array size of the dynar to the number of elements plus \a empty_slots_wanted. + * After removing elements from the dynar, you can call this function to make the dynar use less memory. + * Set \a empty_slots_wanted to zero to reduce the dynar internal array as much as possible. + * Note that if \a empty_slots_wanted is greater than the array size, the internal array is expanded instead of shrunk. */ void xbt_dynar_shrink(xbt_dynar_t dynar, int empty_slots_wanted) { @@ -193,7 +177,6 @@ void xbt_dynar_shrink(xbt_dynar_t dynar, int empty_slots_wanted) * * kilkil a dynar and its content */ - inline void xbt_dynar_free(xbt_dynar_t * dynar) { if (dynar && *dynar) { @@ -234,9 +217,7 @@ inline int xbt_dynar_is_empty(const xbt_dynar_t dynar) * \param idx index of the slot we want to retrieve * \param[out] dst where to put the result to. */ -inline void -xbt_dynar_get_cpy(const xbt_dynar_t dynar, - const unsigned long idx, void *const dst) +inline void xbt_dynar_get_cpy(const xbt_dynar_t dynar, const unsigned long idx, void *const dst) { _sanity_check_dynar(dynar); _check_inbound_idx(dynar, idx); @@ -253,10 +234,8 @@ xbt_dynar_get_cpy(const xbt_dynar_t dynar, * \warning The returned value is the actual content of the dynar. * Make a copy before fooling with it. */ -inline void *xbt_dynar_get_ptr(const xbt_dynar_t dynar, - const unsigned long idx) +inline void *xbt_dynar_get_ptr(const xbt_dynar_t dynar, const unsigned long idx) { - void *res; _sanity_check_dynar(dynar); _check_inbound_idx(dynar, idx); @@ -265,16 +244,14 @@ inline void *xbt_dynar_get_ptr(const xbt_dynar_t dynar, return res; } -inline void *xbt_dynar_set_at_ptr(const xbt_dynar_t dynar, - const unsigned long idx) +inline void *xbt_dynar_set_at_ptr(const xbt_dynar_t dynar, const unsigned long idx) { _sanity_check_dynar(dynar); if (idx >= dynar->used) { _xbt_dynar_expand(dynar, idx + 1); if (idx > dynar->used) { - memset(_xbt_dynar_elm(dynar, dynar->used), 0, - (idx - dynar->used) * dynar->elmsize); + memset(_xbt_dynar_elm(dynar, dynar->used), 0, (idx - dynar->used) * dynar->elmsize); } dynar->used = idx + 1; } @@ -289,10 +266,8 @@ inline void *xbt_dynar_set_at_ptr(const xbt_dynar_t dynar, * * If you want to free the previous content, use xbt_dynar_replace(). */ -inline void xbt_dynar_set(xbt_dynar_t dynar, const int idx, - const void *const src) +inline void xbt_dynar_set(xbt_dynar_t dynar, const int idx, const void *const src) { - memcpy(xbt_dynar_set_at_ptr(dynar, idx), src, dynar->elmsize); } @@ -302,13 +277,10 @@ inline void xbt_dynar_set(xbt_dynar_t dynar, const int idx, * \param idx * \param object * - * Set the Nth element of a dynar, expanding the dynar if needed, AND DO - * free the previous value at this position. If you don't want to free the - * previous content, use xbt_dynar_set(). + * Set the Nth element of a dynar, expanding the dynar if needed, AND DO free the previous value at this position. If + * you don't want to free the previous content, use xbt_dynar_set(). */ -void -xbt_dynar_replace(xbt_dynar_t dynar, - const unsigned long idx, const void *const object) +void xbt_dynar_replace(xbt_dynar_t dynar, const unsigned long idx, const void *const object) { _sanity_check_dynar(dynar); @@ -323,8 +295,8 @@ xbt_dynar_replace(xbt_dynar_t dynar, /** @brief Make room for a new element, and return a pointer to it * - * You can then use regular affectation to set its value instead of relying - * on the slow memcpy. This is what xbt_dynar_insert_at_as() does. + * You can then use regular affectation to set its value instead of relying on the slow memcpy. This is what + * xbt_dynar_insert_at_as() does. */ void *xbt_dynar_insert_at_ptr(xbt_dynar_t const dynar, const int idx) { @@ -344,8 +316,7 @@ void *xbt_dynar_insert_at_ptr(xbt_dynar_t const dynar, const int idx) nb_shift = old_used - idx; if (nb_shift>0) { - memmove(_xbt_dynar_elm(dynar, idx + 1), - _xbt_dynar_elm(dynar, idx), nb_shift * dynar->elmsize); + memmove(_xbt_dynar_elm(dynar, idx + 1), _xbt_dynar_elm(dynar, idx), nb_shift * dynar->elmsize); } dynar->used = new_used; @@ -355,31 +326,24 @@ void *xbt_dynar_insert_at_ptr(xbt_dynar_t const dynar, const int idx) /** @brief Set the Nth dynar's element, expanding the dynar and sliding the previous values to the right * - * 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. + * 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. */ -inline void -xbt_dynar_insert_at(xbt_dynar_t const dynar, - const int idx, const void *const src) +inline void xbt_dynar_insert_at(xbt_dynar_t const dynar, const int idx, const void *const src) { - /* checks done in xbt_dynar_insert_at_ptr */ memcpy(xbt_dynar_insert_at_ptr(dynar, idx), src, dynar->elmsize); } /** @brief Remove the Nth dynar's element, sliding the previous values to the left * - * Get the Nth element of a dynar, removing it from the dynar and moving - * all subsequent values to one position left in the dynar. + * Get the Nth element of a dynar, removing it from the dynar and moving all subsequent values to one position left in + * the dynar. * - * If the object argument of this function is a non-null pointer, the removed - * element is copied to this address. If not, the element is freed using the - * free_f function passed at dynar creation. + * If the object argument of this function is a non-null pointer, the removed element is copied to this address. If not, + * the element is freed using the free_f function passed at dynar creation. */ -void -xbt_dynar_remove_at(xbt_dynar_t const dynar, - const int idx, void *const object) +void xbt_dynar_remove_at(xbt_dynar_t const dynar, const int idx, void *const object) { unsigned long nb_shift; unsigned long offset; @@ -397,8 +361,7 @@ xbt_dynar_remove_at(xbt_dynar_t const dynar, if (nb_shift) { offset = nb_shift * dynar->elmsize; - memmove(_xbt_dynar_elm(dynar, idx), _xbt_dynar_elm(dynar, idx + 1), - offset); + memmove(_xbt_dynar_elm(dynar, idx), _xbt_dynar_elm(dynar, idx + 1), offset); } dynar->used--; @@ -406,15 +369,12 @@ xbt_dynar_remove_at(xbt_dynar_t const dynar, /** @brief Remove a slice of the dynar, sliding the rest of the values to the left * - * This function removes an n-sized slice that starts at element idx. It is equivalent - * to xbt_dynar_remove_at with a NULL object argument if n equals to 1. + * This function removes an n-sized slice that starts at element idx. It is equivalent to xbt_dynar_remove_at with a + * NULL object argument if n equals to 1. * - * Each of the removed elements is freed using the free_f function passed at dynar - * creation. + * Each of the removed elements is freed using the free_f function passed at dynar creation. */ -void -xbt_dynar_remove_n_at(xbt_dynar_t const dynar, - const unsigned int n, const int idx) +void xbt_dynar_remove_n_at(xbt_dynar_t const dynar, const unsigned int n, const int idx) { unsigned long nb_shift; unsigned long offset; @@ -436,8 +396,7 @@ xbt_dynar_remove_n_at(xbt_dynar_t const dynar, if (nb_shift) { offset = nb_shift * dynar->elmsize; - memmove(_xbt_dynar_elm(dynar, idx), _xbt_dynar_elm(dynar, idx + n), - offset); + memmove(_xbt_dynar_elm(dynar, idx), _xbt_dynar_elm(dynar, idx + n), offset); } dynar->used -= n; @@ -445,9 +404,9 @@ xbt_dynar_remove_n_at(xbt_dynar_t const dynar, /** @brief Returns the position of the element in the dynar * - * Beware that if your dynar contains pointed values (such as strings) instead - * of scalar, this function compares the pointer value, not what's pointed. The only - * solution to search for a pointed value is then to write the foreach loop yourself: + * Beware that if your dynar contains pointed values (such as strings) instead of scalar, this function compares the + * pointer value, not what's pointed. The only solution to search for a pointed value is then to write the foreach loop + * yourself: * \code * signed int position = -1; * xbt_dynar_foreach(dynar, iter, elem) { @@ -458,9 +417,8 @@ xbt_dynar_remove_n_at(xbt_dynar_t const dynar, * } * \endcode * - * Raises not_found_error if not found. If you have less than 2 millions elements, - * you probably want to use #xbt_dynar_search_or_negative() instead, so that you - * don't have to TRY/CATCH on element not found. + * Raises not_found_error if not found. If you have less than 2 millions elements, you probably want to use + * #xbt_dynar_search_or_negative() instead, so that you don't have to TRY/CATCH on element not found. */ unsigned int xbt_dynar_search(xbt_dynar_t const dynar, void *const elem) { @@ -477,12 +435,11 @@ unsigned int xbt_dynar_search(xbt_dynar_t const dynar, void *const elem) /** @brief Returns the position of the element in the dynar (or -1 if not found) * - * Beware that if your dynar contains pointed values (such as - * strings) instead of scalar, this function is probably not what you - * want. Check the documentation of xbt_dynar_search() for more info. + * Beware that if your dynar contains pointed values (such as strings) instead of scalar, this function is probably not + * what you want. Check the documentation of xbt_dynar_search() for more info. * - * Note that usually, the dynar indices are unsigned integers. If you have more - * than 2 million elements in your dynar, this very function will not work (but the other will). + * Note that usually, the dynar indices are unsigned integers. If you have more than 2 million elements in your dynar, + * this very function will not work (but the other will). */ signed int xbt_dynar_search_or_negative(xbt_dynar_t const dynar, void *const elem) { @@ -498,19 +455,16 @@ signed int xbt_dynar_search_or_negative(xbt_dynar_t const dynar, void *const ele /** @brief Returns a boolean indicating whether the element is part of the dynar * - * Beware that if your dynar contains pointed values (such as - * strings) instead of scalar, this function is probably not what you - * want. Check the documentation of xbt_dynar_search() for more info. + * Beware that if your dynar contains pointed values (such as strings) instead of scalar, this function is probably not + * what you want. Check the documentation of xbt_dynar_search() for more info. */ int xbt_dynar_member(xbt_dynar_t const dynar, void *const elem) { - xbt_ex_t e; TRY { xbt_dynar_search(dynar, elem); - } - CATCH(e) { + } CATCH(e) { if (e.category == not_found_error) { xbt_ex_free(e); return 0; @@ -522,8 +476,8 @@ int xbt_dynar_member(xbt_dynar_t const dynar, void *const elem) /** @brief Make room at the end of the dynar for a new element, and return a pointer to it. * - * You can then use regular affectation to set its value instead of relying - * on the slow memcpy. This is what xbt_dynar_push_as() does. + * You can then use regular affectation to set its value instead of relying on the slow memcpy. This is what + * xbt_dynar_push_as() does. */ inline void *xbt_dynar_push_ptr(xbt_dynar_t const dynar) { @@ -531,8 +485,7 @@ inline void *xbt_dynar_push_ptr(xbt_dynar_t const dynar) } /** @brief Add an element at the end of the dynar */ -inline void xbt_dynar_push(xbt_dynar_t const dynar, - const void *const src) +inline void xbt_dynar_push(xbt_dynar_t const dynar, const void *const src) { /* checks done in xbt_dynar_insert_at_ptr */ memcpy(xbt_dynar_insert_at_ptr(dynar, dynar->used), src, dynar->elmsize); @@ -540,8 +493,8 @@ inline void xbt_dynar_push(xbt_dynar_t const dynar, /** @brief Mark the last dynar's element as unused and return a pointer to it. * - * You can then use regular affectation to set its value instead of relying - * on the slow memcpy. This is what xbt_dynar_pop_as() does. + * You can then use regular affectation to set its value instead of relying on the slow memcpy. This is what + * xbt_dynar_pop_as() does. */ inline void *xbt_dynar_pop_ptr(xbt_dynar_t const dynar) { @@ -554,7 +507,6 @@ inline void *xbt_dynar_pop_ptr(xbt_dynar_t const dynar) /** @brief Get and remove the last element of the dynar */ inline void xbt_dynar_pop(xbt_dynar_t const dynar, void *const dst) { - /* sanity checks done by remove_at */ XBT_CDEBUG(xbt_dyn, "Pop %p", (void *) dynar); xbt_dynar_remove_at(dynar, dynar->used - 1, dst); @@ -564,10 +516,8 @@ inline void xbt_dynar_pop(xbt_dynar_t const dynar, void *const dst) * * This is less efficient than xbt_dynar_push() */ -inline void xbt_dynar_unshift(xbt_dynar_t const dynar, - const void *const src) +inline void xbt_dynar_unshift(xbt_dynar_t const dynar, const void *const src) { - /* sanity checks done by insert_at */ xbt_dynar_insert_at(dynar, 0, src); } @@ -578,18 +528,15 @@ inline void xbt_dynar_unshift(xbt_dynar_t const dynar, */ inline void xbt_dynar_shift(xbt_dynar_t const dynar, void *const dst) { - /* sanity checks done by remove_at */ xbt_dynar_remove_at(dynar, 0, dst); } /** @brief Apply a function to each member of a dynar * - * The mapped function may change the value of the element itself, - * but should not mess with the structure of the dynar. + * The mapped function may change the value of the element itself, but should not mess with the structure of the dynar. */ -inline void xbt_dynar_map(const xbt_dynar_t dynar, - void_f_pvoid_t const op) +inline void xbt_dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op) { char *const data = (char *) dynar->data; const unsigned long elmsize = dynar->elmsize; @@ -604,15 +551,12 @@ inline void xbt_dynar_map(const xbt_dynar_t dynar, } } - /** @brief Removes and free the entry pointed by the cursor * * This function can be used while traversing without problem. */ -inline void xbt_dynar_cursor_rm(xbt_dynar_t dynar, - unsigned int *const cursor) +inline void xbt_dynar_cursor_rm(xbt_dynar_t dynar, unsigned int *const cursor) { - xbt_dynar_remove_at(dynar, (*cursor)--, NULL); } @@ -621,11 +565,10 @@ inline void xbt_dynar_cursor_rm(xbt_dynar_t dynar, * \param dynar the dynar to sort * \param compar_fn comparison function of type (int (compar_fn*) (void*) (void*)). * - * Remark: if the elements stored in the dynar are structures, the compar_fn - * function has to retrieve the field to sort first. + * Remark: if the elements stored in the dynar are structures, the compar_fn function has to retrieve the field to sort + * first. */ -inline void xbt_dynar_sort(xbt_dynar_t dynar, - int_f_cpvoid_cpvoid_t compar_fn) +inline void xbt_dynar_sort(xbt_dynar_t dynar, int_f_cpvoid_cpvoid_t compar_fn) { qsort(dynar->data, dynar->used, dynar->elmsize, compar_fn); } @@ -633,6 +576,7 @@ inline void xbt_dynar_sort(xbt_dynar_t dynar, static int strcmp_voidp(const void *pa, const void *pb) { return strcmp(*(const char **)pa, *(const char **)pb); } + /** @brief Sorts a dynar of strings (ie, char* data) */ xbt_dynar_t xbt_dynar_sort_strings(xbt_dynar_t dynar) { @@ -645,15 +589,16 @@ xbt_dynar_t xbt_dynar_sort_strings(xbt_dynar_t dynar) * See for example http://en.wikipedia.org/wiki/Dutch_national_flag_problem * * \param dynar the dynar to sort - * \param color the color function of type (int (compar_fn*) (void*) (void*)). The return value of color is assumed to be 0, 1, or 2. + * \param color the color function of type (int (compar_fn*) (void*) (void*)). The return value of color is assumed to + * be 0, 1, or 2. * - * At the end of the call, elements with color 0 are at the beginning of the dynar, elements with color 2 are at the end and elements with color 1 are in the middle. + * At the end of the call, elements with color 0 are at the beginning of the dynar, elements with color 2 are at the + * end and elements with color 1 are in the middle. * - * Remark: if the elements stored in the dynar are structures, the color - * function has to retrieve the field to sort first. + * Remark: if the elements stored in the dynar are structures, the color function has to retrieve the field to sort + * first. */ -XBT_PUBLIC(void) xbt_dynar_three_way_partition(xbt_dynar_t const dynar, - int_f_pvoid_t color) +XBT_PUBLIC(void) xbt_dynar_three_way_partition(xbt_dynar_t const dynar, int_f_pvoid_t color) { unsigned long int i; unsigned long int p = -1; @@ -709,13 +654,11 @@ inline void *xbt_dynar_to_array(xbt_dynar_t dynar) * \param compar function to use to compare elements * \return 0 if d1 and d2 are equal and 1 if not equal * - * d1 and d2 should be dynars of pointers. The compar function takes two - * elements and returns 0 when they are considered equal, and a value different - * of zero when they are considered different. Finally, d2 is destroyed + * d1 and d2 should be dynars of pointers. The compar function takes two elements and returns 0 when they are + * considered equal, and a value different of zero when they are considered different. Finally, d2 is destroyed * afterwards. */ -int xbt_dynar_compare(xbt_dynar_t d1, xbt_dynar_t d2, - int(*compar)(const void *, const void *)) +int xbt_dynar_compare(xbt_dynar_t d1, xbt_dynar_t d2, int(*compar)(const void *, const void *)) { int i ; int size; @@ -726,22 +669,19 @@ int xbt_dynar_compare(xbt_dynar_t d1, xbt_dynar_t d2, xbt_dynar_free(&d2); return 1; } - if((d1->elmsize)!=(d2->elmsize)) - { + if((d1->elmsize)!=(d2->elmsize)) { XBT_DEBUG("Size of elmsize d1=%lu d2=%lu",d1->elmsize,d2->elmsize); xbt_dynar_free(&d2); return 1; // xbt_die } - if(xbt_dynar_length(d1) != xbt_dynar_length(d2)) - { + if(xbt_dynar_length(d1) != xbt_dynar_length(d2)) { XBT_DEBUG("Size of dynar d1=%lu d2=%lu",xbt_dynar_length(d1),xbt_dynar_length(d2)); xbt_dynar_free(&d2); return 1; } size = xbt_dynar_length(d1); - for(i=0;i= 0; cpt--) { xbt_dynar_shift(d, &i); - xbt_test_assert(i == cpt, - "The retrieved value is not the same than the injected one in the middle (%d!=%d)", + xbt_test_assert(i == cpt, "The retrieved value is not the same than the injected one in the middle (%d!=%d)", i, cpt); } for (cpt = 2500; cpt < NB_ELEM; cpt++) { xbt_dynar_shift(d, &i); - xbt_test_assert(i == cpt, - "The retrieved value is not the same than the injected one at the end (%d!=%d)", - i, cpt); + xbt_test_assert(i == cpt, "The retrieved value is not the same than the injected one at the end (%d!=%d)", i, cpt); } xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ /* in your code is naturally the way to go outside a regression test */ - xbt_test_add("==== Push %d int, remove 2000-4000. free the rest", - NB_ELEM); + xbt_test_add("==== Push %d int, remove 2000-4000. free the rest", NB_ELEM); d = xbt_dynar_new(sizeof(int), NULL); for (cpt = 0; cpt < NB_ELEM; cpt++) xbt_dynar_push_as(d, int, cpt); for (cpt = 2000; cpt < 4000; cpt++) { xbt_dynar_remove_at(d, 2000, &i); - xbt_test_assert(i == cpt, - "Remove a bad value. Got %d, expected %d", i, cpt); + xbt_test_assert(i == cpt, "Remove a bad value. Got %d, expected %d", i, cpt); XBT_DEBUG("remove %d, length=%lu", cpt, xbt_dynar_length(d)); } xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ @@ -927,8 +844,6 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers") /* in your code is naturally the way to go outside a regression test */ } -/*******************************************************************************/ -/*******************************************************************************/ /*******************************************************************************/ XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dynar_remove functions") { @@ -946,9 +861,7 @@ XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dyn /* 3. Traverse the dynar */ xbt_dynar_foreach(d, cursor, cpt) { - xbt_test_assert(cursor == cpt, - "The retrieved value is not the same than the injected one (%u!=%d)", - cursor, cpt); + xbt_test_assert(cursor == cpt, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt); } /* end_of_traversal */ @@ -956,19 +869,14 @@ XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dyn for (cpt = 0; cpt < NB_ELEM; cpt++) xbt_dynar_set_as(d, cpt, int, cpt); xbt_dynar_foreach(d, cursor, cpt) - xbt_test_assert(cursor == cpt, - "The retrieved value is not the same than the injected one (%u!=%d)", - cursor, cpt); + xbt_test_assert(cursor == cpt, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt); for (cpt = 0; cpt < NB_ELEM; cpt++) { int val; xbt_dynar_remove_at(d,0,&val); - xbt_test_assert(cpt == val, - "The retrieved value is not the same than the injected one (%u!=%d)", - cursor, cpt); + xbt_test_assert(cpt == val, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt); } - xbt_test_assert(xbt_dynar_is_empty(d), - "There is still %lu elements in the dynar after removing everything", + xbt_test_assert(xbt_dynar_is_empty(d), "There is still %lu elements in the dynar after removing everything", xbt_dynar_length(d)); xbt_dynar_free(&d); @@ -982,27 +890,20 @@ XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dyn /* 3. Traverse the dynar */ xbt_dynar_foreach(d, cursor, cpt) { - xbt_test_assert(cursor == cpt, - "The retrieved value is not the same than the injected one (%u!=%d)", - cursor, cpt); + xbt_test_assert(cursor == cpt, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt); } /* end_of_traversal */ for (cpt =NB_ELEM-1; cpt >=0; cpt--) { int val; xbt_dynar_remove_at(d,xbt_dynar_length(d)-1,&val); - xbt_test_assert(cpt == val, - "The retrieved value is not the same than the injected one (%u!=%d)", - cursor, cpt); + xbt_test_assert(cpt == val, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt); } - xbt_test_assert(xbt_dynar_is_empty(d), - "There is still %lu elements in the dynar after removing everything", + xbt_test_assert(xbt_dynar_is_empty(d), "There is still %lu elements in the dynar after removing everything", xbt_dynar_length(d)); xbt_dynar_free(&d); } -/*******************************************************************************/ -/*******************************************************************************/ /*******************************************************************************/ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles") { @@ -1014,8 +915,7 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles") xbt_test_add("==== Traverse the empty dynar"); d = xbt_dynar_new(sizeof(int), NULL); xbt_dynar_foreach(d, cursor, cpt) { - xbt_test_assert(FALSE, - "Damnit, there is something in the empty dynar"); + xbt_test_assert(FALSE, "Damnit, there is something in the empty dynar"); } xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ @@ -1029,16 +929,12 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles") } xbt_dynar_foreach(d, cursor, d2) { d1 = (double) cursor; - xbt_test_assert(d1 == d2, - "The retrieved value is not the same than the injected one (%f!=%f)", - d1, d2); + xbt_test_assert(d1 == d2, "The retrieved value is not the same than the injected one (%f!=%f)", d1, d2); } for (cpt = 0; cpt < 5000; cpt++) { d1 = (double) cpt; xbt_dynar_shift(d, &d2); - xbt_test_assert(d1 == d2, - "The retrieved value is not the same than the injected one (%f!=%f)", - d1, d2); + xbt_test_assert(d1 == d2, "The retrieved value is not the same than the injected one (%f!=%f)", d1, d2); } xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ @@ -1053,18 +949,13 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles") for (cpt = 0; cpt < 5000; cpt++) { d1 = (double) cpt; xbt_dynar_pop(d, &d2); - xbt_test_assert(d1 == d2, - "The retrieved value is not the same than the injected one (%f!=%f)", - d1, d2); + xbt_test_assert(d1 == d2, "The retrieved value is not the same than the injected one (%f!=%f)", d1, d2); } xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ /* in your code is naturally the way to go outside a regression test */ - - - xbt_test_add - ("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything"); + xbt_test_add("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything"); d = xbt_dynar_new(sizeof(double), NULL); for (cpt = 0; cpt < 5000; cpt++) { d1 = (double) cpt; @@ -1078,30 +969,25 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles") for (cpt = 0; cpt < 2500; cpt++) { d1 = (double) cpt; xbt_dynar_shift(d, &d2); - xbt_test_assert(d1 == d2, - "The retrieved value is not the same than the injected one at the begining (%f!=%f)", + xbt_test_assert(d1 == d2, "The retrieved value is not the same than the injected one at the begining (%f!=%f)", d1, d2); XBT_DEBUG("Pop %d, length=%lu", cpt, xbt_dynar_length(d)); } for (cpt = 999; cpt >= 0; cpt--) { d1 = (double) cpt; xbt_dynar_shift(d, &d2); - xbt_test_assert(d1 == d2, - "The retrieved value is not the same than the injected one in the middle (%f!=%f)", + xbt_test_assert(d1 == d2, "The retrieved value is not the same than the injected one in the middle (%f!=%f)", d1, d2); } for (cpt = 2500; cpt < 5000; cpt++) { d1 = (double) cpt; xbt_dynar_shift(d, &d2); - xbt_test_assert(d1 == d2, - "The retrieved value is not the same than the injected one at the end (%f!=%f)", - d1, d2); + xbt_test_assert(d1 == d2, "The retrieved value is not the same than the injected one at the end (%f!=%f)", d1, d2); } xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ /* in your code is naturally the way to go outside a regression test */ - xbt_test_add("==== Push 5000 double, remove 2000-4000. free the rest"); d = xbt_dynar_new(sizeof(double), NULL); for (cpt = 0; cpt < 5000; cpt++) { @@ -1111,19 +997,15 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles") for (cpt = 2000; cpt < 4000; cpt++) { d1 = (double) cpt; xbt_dynar_remove_at(d, 2000, &d2); - xbt_test_assert(d1 == d2, - "Remove a bad value. Got %f, expected %f", d2, d1); + xbt_test_assert(d1 == d2, "Remove a bad value. Got %f, expected %f", d2, d1); } xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ /* in your code is naturally the way to go outside a regression test */ } - /* doxygen_string_cruft */ -/*******************************************************************************/ -/*******************************************************************************/ /*******************************************************************************/ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") { @@ -1136,15 +1018,13 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") xbt_test_add("==== Traverse the empty dynar"); d = xbt_dynar_new(sizeof(char *), &xbt_free_ref); xbt_dynar_foreach(d, iter, s1) { - xbt_test_assert(FALSE, - "Damnit, there is something in the empty dynar"); + xbt_test_assert(FALSE, "Damnit, there is something in the empty dynar"); } xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ /* in your code is naturally the way to go outside a regression test */ - xbt_test_add("==== Push %d strings, set them again 3 times, shift them", - NB_ELEM); + xbt_test_add("==== Push %d strings, set them again 3 times, shift them", NB_ELEM); /* Populate_str [doxygen cruft] */ d = xbt_dynar_new(sizeof(char *), &xbt_free_ref); /* 1. Populate the dynar */ @@ -1171,9 +1051,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") for (cpt = 0; cpt < NB_ELEM; cpt++) { sprintf(buf, "%d", cpt); xbt_dynar_shift(d, &s2); - xbt_test_assert(!strcmp(buf, s2), - "The retrieved value is not the same than the injected one (%s!=%s)", - buf, s2); + xbt_test_assert(!strcmp(buf, s2), "The retrieved value is not the same than the injected one (%s!=%s)", buf, s2); free(s2); } xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ @@ -1190,17 +1068,13 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") /* 2. Traverse the dynar with the macro */ xbt_dynar_foreach(d, iter, s1) { sprintf(buf, "%u", NB_ELEM - iter - 1); - xbt_test_assert(!strcmp(buf, s1), - "The retrieved value is not the same than the injected one (%s!=%s)", - buf, s1); + xbt_test_assert(!strcmp(buf, s1), "The retrieved value is not the same than the injected one (%s!=%s)", buf, s1); } /* 3. Traverse the dynar with the macro */ for (cpt = 0; cpt < NB_ELEM; cpt++) { sprintf(buf, "%d", cpt); xbt_dynar_pop(d, &s2); - xbt_test_assert(!strcmp(buf, s2), - "The retrieved value is not the same than the injected one (%s!=%s)", - buf, s2); + xbt_test_assert(!strcmp(buf, s2), "The retrieved value is not the same than the injected one (%s!=%s)", buf, s2); free(s2); } /* 4. Free the resources */ @@ -1208,10 +1082,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ /* in your code is naturally the way to go outside a regression test */ - - xbt_test_add - ("==== Push %d strings, insert %d strings in the middle, shift everything", - NB_ELEM, NB_ELEM / 5); + xbt_test_add("==== Push %d strings, insert %d strings in the middle, shift everything", NB_ELEM, NB_ELEM / 5); d = xbt_dynar_new(sizeof(char *), &xbt_free_ref); for (cpt = 0; cpt < NB_ELEM; cpt++) { sprintf(buf, "%d", cpt); @@ -1228,23 +1099,20 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") sprintf(buf, "%d", cpt); xbt_dynar_shift(d, &s2); xbt_test_assert(!strcmp(buf, s2), - "The retrieved value is not the same than the injected one at the begining (%s!=%s)", - buf, s2); + "The retrieved value is not the same than the injected one at the begining (%s!=%s)", buf, s2); free(s2); } for (cpt = (NB_ELEM / 5) - 1; cpt >= 0; cpt--) { sprintf(buf, "%d", cpt); xbt_dynar_shift(d, &s2); xbt_test_assert(!strcmp(buf, s2), - "The retrieved value is not the same than the injected one in the middle (%s!=%s)", - buf, s2); + "The retrieved value is not the same than the injected one in the middle (%s!=%s)", buf, s2); free(s2); } for (cpt = NB_ELEM / 2; cpt < NB_ELEM; cpt++) { sprintf(buf, "%d", cpt); xbt_dynar_shift(d, &s2); - xbt_test_assert(!strcmp(buf, s2), - "The retrieved value is not the same than the injected one at the end (%s!=%s)", + xbt_test_assert(!strcmp(buf, s2), "The retrieved value is not the same than the injected one at the end (%s!=%s)", buf, s2); free(s2); } @@ -1252,9 +1120,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ /* in your code is naturally the way to go outside a regression test */ - - xbt_test_add("==== Push %d strings, remove %d-%d. free the rest", - NB_ELEM, 2 * (NB_ELEM / 5), 4 * (NB_ELEM / 5)); + xbt_test_add("==== Push %d strings, remove %d-%d. free the rest", NB_ELEM, 2 * (NB_ELEM / 5), 4 * (NB_ELEM / 5)); d = xbt_dynar_new(sizeof(char *), &xbt_free_ref); for (cpt = 0; cpt < NB_ELEM; cpt++) { sprintf(buf, "%d", cpt); @@ -1264,8 +1130,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") for (cpt = 2 * (NB_ELEM / 5); cpt < 4 * (NB_ELEM / 5); cpt++) { sprintf(buf, "%d", cpt); xbt_dynar_remove_at(d, 2 * (NB_ELEM / 5), &s2); - xbt_test_assert(!strcmp(buf, s2), - "Remove a bad value. Got %s, expected %s", s2, buf); + xbt_test_assert(!strcmp(buf, s2), "Remove a bad value. Got %s, expected %s", s2, buf); free(s2); } xbt_dynar_free(&d); /* end_of_doxygen */ diff --git a/src/xbt/ex.c b/src/xbt/ex.c index 9d3dca6a4b..37f1768373 100644 --- a/src/xbt/ex.c +++ b/src/xbt/ex.c @@ -65,7 +65,6 @@ # define HAVE_BACKTRACE 1 /* Hello x86 windows box */ #endif - XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_ex, xbt, "Exception mecanism"); XBT_EXPORT_NO_IMPORT(const xbt_running_ctx_t) __xbt_ex_ctx_initializer = XBT_RUNNING_CTX_INITIALIZER; @@ -133,12 +132,10 @@ void xbt_ex_display(xbt_ex_t * e) if (e->pid != xbt_getpid()) thrower = bprintf(" on process %d",e->pid); - fprintf(stderr, - "** SimGrid: UNCAUGHT EXCEPTION received on %s(%d): category: %s; value: %d\n" + fprintf(stderr, "** SimGrid: UNCAUGHT EXCEPTION received on %s(%d): category: %s; value: %d\n" "** %s\n" "** Thrown by %s()%s\n", - xbt_binary_name, xbt_getpid(), - xbt_ex_catname(e->category), e->value, e->msg, + xbt_binary_name, xbt_getpid(), xbt_ex_catname(e->category), e->value, e->msg, e->procname, thrower ? thrower : " in this process"); XBT_CRITICAL("%s", e->msg); xbt_free(thrower); @@ -183,7 +180,6 @@ void xbt_ex_display(xbt_ex_t * e) fprintf(stderr, "%s\n", e->bt_strings[i]); } } - } else #endif fprintf(stderr, "\n" @@ -191,7 +187,6 @@ void xbt_ex_display(xbt_ex_t * e) "** (no backtrace available)\n", e->func, e->file, e->line); } - /* default __ex_terminate callback function */ void __xbt_ex_terminate_default(xbt_ex_t * e) { @@ -203,7 +198,6 @@ void __xbt_ex_terminate_default(xbt_ex_t * e) XBT_EXPORT_NO_IMPORT(xbt_running_ctx_fetcher_t) __xbt_running_ctx_fetch = &__xbt_ex_ctx_default; XBT_EXPORT_NO_IMPORT(ex_term_cb_t) __xbt_ex_terminate = &__xbt_ex_terminate_default; - void xbt_ex_free(xbt_ex_t e) { free(e.msg); @@ -247,12 +241,10 @@ const char *xbt_ex_catname(xbt_errcat_t cat) return "io error"; case vm_error: return "vm error"; - } return "INVALID ERROR"; } - #ifdef SIMGRID_TEST #include #include "xbt/ex.h" @@ -275,8 +267,7 @@ XBT_TEST_UNIT("controlflow", test_controlflow, "basic nested control flow") xbt_test_fail("M2: n=%d (!= 2)", n); n++; THROWF(unknown_error, 0, "something"); - } - CATCH(ex) { + } CATCH(ex) { if (n != 3) xbt_test_fail("M3: n=%d (!= 3)", n); n++; @@ -288,8 +279,7 @@ XBT_TEST_UNIT("controlflow", test_controlflow, "basic nested control flow") xbt_test_fail("M2: n=%d (!= 5)", n); n++; THROWF(unknown_error, 0, "something"); - } - CATCH_ANONYMOUS { + } CATCH_ANONYMOUS { if (n != 6) xbt_test_fail("M3: n=%d (!= 6)", n); n++; @@ -297,8 +287,7 @@ XBT_TEST_UNIT("controlflow", test_controlflow, "basic nested control flow") n++; } xbt_test_fail("MX: n=%d (shouldn't reach this point)", n); - } - CATCH(ex) { + } CATCH(ex) { if (n != 7) xbt_test_fail("M4: n=%d (!= 7)", n); n++; @@ -314,8 +303,7 @@ XBT_TEST_UNIT("value", test_value, "exception value passing") TRY { THROWF(unknown_error, 2, "toto"); - } - CATCH(ex) { + } CATCH(ex) { xbt_test_add("exception value passing"); if (ex.category != unknown_error) xbt_test_fail("category=%d (!= 1)", (int)ex.category); @@ -340,8 +328,7 @@ XBT_TEST_UNIT("variables", test_variables, "variable value preservation") r2 = 5678; v2 = 5678; THROWF(unknown_error, 0, "toto"); - } - CATCH(ex) { + } CATCH(ex) { xbt_test_add("variable preservation"); if (r1 != 1234) xbt_test_fail("r1=%d (!= 1234)", r1); @@ -372,8 +359,7 @@ XBT_TEST_UNIT("cleanup", test_cleanup, "cleanup handling") if (v1 != 5678) xbt_test_fail("v1 = %d (!= 5678)", v1); c = 1; - } - CATCH(ex) { + } CATCH(ex) { if (v1 != 5678) xbt_test_fail("v1 = %d (!= 5678)", v1); if (!(ex.category == 1 && ex.value == 2 && !strcmp(ex.msg, "blah"))) @@ -384,7 +370,6 @@ XBT_TEST_UNIT("cleanup", test_cleanup, "cleanup handling") xbt_test_fail("xbt_ex_free not executed"); } - /* * The following is the example included in the documentation. It's a good * idea to check its syntax even if we don't try to run it. diff --git a/src/xbt/fifo.c b/src/xbt/fifo.c index df2439f6d5..399a8887fa 100644 --- a/src/xbt/fifo.c +++ b/src/xbt/fifo.c @@ -29,7 +29,6 @@ xbt_fifo_t xbt_fifo_new(void) return fifo; } - /** Destructor * \param l poor victim * @@ -244,7 +243,6 @@ int xbt_fifo_remove(xbt_fifo_t l, void *t) { xbt_fifo_item_t current, current_next; - for (current = l->head; current; current = current_next) { current_next = current->next; if (current->content != t) @@ -258,7 +256,6 @@ int xbt_fifo_remove(xbt_fifo_t l, void *t) return 0; } - /** * \param l * \param t an objet @@ -337,18 +334,16 @@ int xbt_fifo_is_in(xbt_fifo_t f, void *content) * This function allows to search an item with a user provided function instead * of the pointer comparison used elsewhere in this module. Assume for example that you have a fifo of * strings. You cannot use xbt_fifo_remove() to remove, say, "TOTO" from it because internally, xbt_fifo_remove() - * will do something like "if (item->content == "toto"), then remove it". And the pointer to the item content - * and the pointer to "toto" will never match. As a solution, the current function provides a way to search elements - * that are semanticaly equivalent instead of only syntaxically. So, removing "Toto" from a fifo can be - * achieved this way: + * will do something like "if (item->content == "toto"), then remove it". And the pointer to the item content and the + * pointer to "toto" will never match. As a solution, the current function provides a way to search elements that are + * semantically equivalent instead of only syntactically. So, removing "Toto" from a fifo can be achieved this way: * * @verbatim int my_comparison_function(void *searched, void *seen) { return !strcmp(searched, seen); } - xbt_fifo_remove_item(fifo, - xbt_fifo_search_item(fifo, my_comparison_function, "Toto")); + xbt_fifo_remove_item(fifo, xbt_fifo_search_item(fifo, my_comparison_function, "Toto")); @endverbatim * * \param f a fifo list @@ -364,7 +359,6 @@ xbt_fifo_item_t xbt_fifo_search_item(xbt_fifo_t f, int_f_pvoid_pvoid_t cmp_fun, item = item->next; } return NULL; - } /** @@ -561,10 +555,8 @@ xbt_fifo_item_t xbt_fifo_getPrevItem(xbt_fifo_item_t i) */ void xbt_fifo_preinit(void) { - item_mallocator = xbt_mallocator_new(65536, - fifo_item_mallocator_new_f, - fifo_item_mallocator_free_f, - fifo_item_mallocator_reset_f); + item_mallocator = xbt_mallocator_new(65536, fifo_item_mallocator_new_f, + fifo_item_mallocator_free_f, fifo_item_mallocator_reset_f); } void xbt_fifo_postexit(void) @@ -574,5 +566,4 @@ void xbt_fifo_postexit(void) item_mallocator = NULL; } } - /* @} */ diff --git a/src/xbt/fifo_private.h b/src/xbt/fifo_private.h index 1edc64a946..6d7c3c2bec 100644 --- a/src/xbt/fifo_private.h +++ b/src/xbt/fifo_private.h @@ -22,7 +22,6 @@ typedef struct xbt_fifo { xbt_fifo_item_t tail; } s_xbt_fifo_t; - #define xbt_fifo_getFirstitem(l) ((l)?(l)->head:NULL) #define xbt_fifo_getNextitem(i) ((i)?(i)->next:NULL) #define xbt_fifo_getPrevitem(i) ((i)?(i)->prev:NULL) diff --git a/src/xbt/graph.c b/src/xbt/graph.c index ef852803cc..0c8325a789 100644 --- a/src/xbt/graph.c +++ b/src/xbt/graph.c @@ -18,11 +18,8 @@ #include #include - XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_graph, xbt, "Graph"); - - /** @brief Constructor * @return a new graph */ @@ -131,9 +128,7 @@ void xbt_graph_edge_set_data(xbt_edge_t edge, void *data) * * Free the graph structure. */ -void xbt_graph_free_graph(xbt_graph_t g, - void_f_pvoid_t node_free_function, - void_f_pvoid_t edge_free_function, +void xbt_graph_free_graph(xbt_graph_t g, void_f_pvoid_t node_free_function, void_f_pvoid_t edge_free_function, void_f_pvoid_t graph_free_function) { unsigned int cursor; @@ -161,7 +156,6 @@ void xbt_graph_free_graph(xbt_graph_t g, free(g); } - /** @brief Retrieve the graph's nodes as a dynar */ xbt_dynar_t xbt_graph_get_nodes(xbt_graph_t g) { @@ -209,16 +203,13 @@ double xbt_graph_edge_get_length(xbt_edge_t edge) * * From wikipedia: * - * The Floyd–Warshall algorithm takes as input an adjacency matrix - * representation of a weighted, directed graph (V, E). The weight of a - * path between two vertices is the sum of the weights of the edges along - * that path. The edges E of the graph may have negative weights, but the - * graph must not have any negative weight cycles. The algorithm computes, - * for each pair of vertices, the minimum weight among all paths between - * the two vertices. The running time complexity is Θ(|V|3). + * The Floyd–Warshall algorithm takes as input an adjacency matrix representation of a weighted, directed graph (V, E). + * The weight of a path between two vertices is the sum of the weights of the edges along that path. The edges E of the + * graph may have negative weights, but the graph must not have any negative weight cycles. The algorithm computes, for + * each pair of vertices, the minimum weight among all paths between the two vertices. The running time complexity is + * Θ(|V|3). */ -void xbt_floyd_algorithm(xbt_graph_t g, double *adj, double *d, - xbt_node_t * p) +void xbt_floyd_algorithm(xbt_graph_t g, double *adj, double *d, xbt_node_t * p) { unsigned long i, j, k; unsigned long n; @@ -231,7 +222,6 @@ void xbt_floyd_algorithm(xbt_graph_t g, double *adj, double *d, d[i] = adj[i]; } - for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { if (D(i, j) != -1) { @@ -257,8 +247,7 @@ void xbt_floyd_algorithm(xbt_graph_t g, double *adj, double *d, } /** @brief Export the given graph in the GraphViz formatting for visualization */ -void xbt_graph_export_graphviz(xbt_graph_t g, const char *filename, - const char *(node_name) (xbt_node_t), +void xbt_graph_export_graphviz(xbt_graph_t g, const char *filename, const char *(node_name) (xbt_node_t), const char *(edge_name) (xbt_edge_t)) { unsigned int cursor = 0; @@ -278,8 +267,7 @@ void xbt_graph_export_graphviz(xbt_graph_t g, const char *filename, fprintf(file, " graph [overlap=scale]\n"); fprintf(file, " node [shape=box, style=filled]\n"); - fprintf(file, - " node [width=.3, height=.3, style=filled, color=skyblue]\n\n"); + fprintf(file, " node [width=.3, height=.3, style=filled, color=skyblue]\n\n"); xbt_dynar_foreach(g->nodes, cursor, node) { if (node_name){ diff --git a/src/xbt/heap.c b/src/xbt/heap.c index 469cc682dd..96da93ec17 100644 --- a/src/xbt/heap.c +++ b/src/xbt/heap.c @@ -23,13 +23,11 @@ static void xbt_heap_increase_key(xbt_heap_t H, int i); /** * @brief Creates a new heap. * \param init_size initial size of the heap - * \param free_func function to call on each element when you want to free - * the whole heap (or NULL if nothing to do). + * \param free_func function to call on each element when you want to free the whole heap (or NULL if nothing to do). * * Creates a new heap. */ -inline xbt_heap_t xbt_heap_new(int init_size, - void_f_pvoid_t const free_func) +inline xbt_heap_t xbt_heap_new(int init_size, void_f_pvoid_t const free_func) { xbt_heap_t H = xbt_new0(struct xbt_heap, 1); H->size = init_size; @@ -44,15 +42,11 @@ inline xbt_heap_t xbt_heap_new(int init_size, * @param H the heap we're working on * \param update_callback function to call on each element to update its index when needed. */ -inline void xbt_heap_set_update_callback(xbt_heap_t H, - void (*update_callback) (void - *, - int)) +inline void xbt_heap_set_update_callback(xbt_heap_t H, void (*update_callback) (void*, int)) { H->update_callback = update_callback; } - /** * @brief kilkil a heap and its content * @param H poor victim @@ -95,9 +89,7 @@ void xbt_heap_push(xbt_heap_t H, void *content, double key) if (count > size) { H->size = (size << 1) + 1; - H->items = - (void *) xbt_realloc(H->items, - (H->size) * sizeof(struct xbt_heap_item)); + H->items = (void *) xbt_realloc(H->items, (H->size) * sizeof(struct xbt_heap_item)); } item = &(H->items[count - 1]); @@ -113,9 +105,8 @@ void xbt_heap_push(xbt_heap_t H, void *content, double key) * \param H the heap we're working on * \return the element with the smallest key * - * Extracts from the heap and returns the element with the smallest - * key. The element with the next smallest key is automatically moved - * at the top of the heap. + * Extracts from the heap and returns the element with the smallest key. The element with the next smallest key is + * automatically moved at the top of the heap. */ void *xbt_heap_pop(xbt_heap_t H) { @@ -135,9 +126,7 @@ void *xbt_heap_pop(xbt_heap_t H) xbt_heap_max_heapify(H,0); if (H->count < size >> 2 && size > 16) { size = (size >> 1) + 1; - H->items = - (void *) xbt_realloc(items, - size * sizeof(struct xbt_heap_item)); + H->items = (void *) xbt_realloc(items, size * sizeof(struct xbt_heap_item)); H->size = size; } @@ -152,7 +141,7 @@ void *xbt_heap_pop(xbt_heap_t H) * \param i element position * \return the element at position i if ok, NULL otherwise * - * Extracts from the heap and returns the element at position i. The heap is automatically reorded. + * Extracts from the heap and returns the element at position i. The heap is automatically reordered. */ void *xbt_heap_remove(xbt_heap_t H, int i) { @@ -269,8 +258,8 @@ static void xbt_heap_max_heapify(xbt_heap_t H, int index) * \param H the heap we're working on * \param i an item position in the heap * - * Moves up an item at position i to its correct position. Works only - * when called from xbt_heap_push. Do not use otherwise. + * Moves up an item at position i to its correct position. Works only when called from xbt_heap_push. + * Do not use otherwise. */ static void xbt_heap_increase_key(xbt_heap_t H, int i) { diff --git a/src/xbt/lib.c b/src/xbt/lib.c index 2bd85204a1..cf672028c8 100644 --- a/src/xbt/lib.c +++ b/src/xbt/lib.c @@ -10,8 +10,7 @@ #include #include -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_lib, xbt, - "A dict with keys of type (name, level)"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_lib, xbt, "A dict with keys of type (name, level)"); xbt_lib_t xbt_lib_new(void) { diff --git a/src/xbt/log.c b/src/xbt/log.c index 1428f70217..88f426d966 100644 --- a/src/xbt/log.c +++ b/src/xbt/log.c @@ -518,8 +518,7 @@ static void _free_setting(void *s) } } -static void _xbt_log_cat_apply_set(xbt_log_category_t category, - xbt_log_setting_t setting); +static void _xbt_log_cat_apply_set(xbt_log_category_t category, xbt_log_setting_t setting); const char *xbt_log_priority_names[8] = { "NONE", @@ -541,8 +540,7 @@ s_xbt_log_category_t _XBT_LOGV(XBT_LOG_ROOT_CAT) = { 0 /* additivity */ }; -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(log, xbt, - "Loggings from the logging mechanism itself"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(log, xbt, "Loggings from the logging mechanism itself"); /* create the default appender and install it in the root category, which were already created (damnit. Too slow little beetle) */ @@ -804,10 +802,8 @@ void _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...) { xbt_log_category_t cat = ev->cat; - xbt_assert(ev->priority >= 0, - "Negative logging priority naturally forbidden"); - xbt_assert(ev->priority < sizeof(xbt_log_priority_names), - "Priority %d is greater than the biggest allowed value", + xbt_assert(ev->priority >= 0, "Negative logging priority naturally forbidden"); + xbt_assert(ev->priority < sizeof(xbt_log_priority_names), "Priority %d is greater than the biggest allowed value", ev->priority); do { @@ -816,8 +812,7 @@ void _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...) if (!appender) continue; /* No appender, try next */ - xbt_assert(cat->layout, - "No valid layout for the appender of category %s", cat->name); + xbt_assert(cat->layout, "No valid layout for the appender of category %s", cat->name); /* First, try with a static buffer */ if (XBT_LOG_STATIC_BUFFER_SIZE) { @@ -858,18 +853,15 @@ void _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...) /* NOTE: * - * The standard logging macros use _XBT_LOG_ISENABLED, which calls - * _xbt_log_cat_init(). Thus, if we want to avoid an infinite - * recursion, we can not use the standard logging macros in - * _xbt_log_cat_init(), and in all functions called from it. + * The standard logging macros use _XBT_LOG_ISENABLED, which calls _xbt_log_cat_init(). Thus, if we want to avoid an + * infinite recursion, we can not use the standard logging macros in _xbt_log_cat_init(), and in all functions called + * from it. * - * To circumvent the problem, we define the macro_xbt_log_init() as - * (0) for the length of the affected functions, and we do not forget - * to undefine it at the end! + * To circumvent the problem, we define the macro_xbt_log_init() as (0) for the length of the affected functions, and + * we do not forget to undefine it at the end! */ -static void _xbt_log_cat_apply_set(xbt_log_category_t category, - xbt_log_setting_t setting) +static void _xbt_log_cat_apply_set(xbt_log_category_t category, xbt_log_setting_t setting) { #define _xbt_log_cat_init(a, b) (0) @@ -877,8 +869,7 @@ static void _xbt_log_cat_apply_set(xbt_log_category_t category, xbt_log_threshold_set(category, setting->thresh); XBT_DEBUG("Apply settings for category '%s': set threshold to %s (=%d)", - category->name, xbt_log_priority_names[category->threshold], - category->threshold); + category->name, xbt_log_priority_names[category->threshold], category->threshold); } if (setting->fmt) { @@ -898,19 +889,16 @@ static void _xbt_log_cat_apply_set(xbt_log_category_t category, if (!category->layout) xbt_log_layout_set(category, xbt_log_layout_simple_new(NULL)); category->additivity = 0; - XBT_DEBUG("Set %p as appender of category '%s'", - setting->appender, category->name); + XBT_DEBUG("Set %p as appender of category '%s'", setting->appender, category->name); } #undef _xbt_log_cat_init } /* - * This gets called the first time a category is referenced and performs the - * initialization. + * This gets called the first time a category is referenced and performs the initialization. * Also resets threshold to inherited! */ -int _xbt_log_cat_init(xbt_log_category_t category, - e_xbt_log_priority_t priority) +int _xbt_log_cat_init(xbt_log_category_t category, e_xbt_log_priority_t priority) { #define _xbt_log_cat_init(a, b) (0) @@ -927,8 +915,7 @@ int _xbt_log_cat_init(xbt_log_category_t category, xbt_log_setting_t setting = NULL; int found = 0; - XBT_DEBUG("Initializing category '%s' (firstChild=%s, nextSibling=%s)", - category->name, + XBT_DEBUG("Initializing category '%s' (firstChild=%s, nextSibling=%s)", category->name, (category->firstChild ? category->firstChild->name : "none"), (category->nextSibling ? category->nextSibling->name : "none")); @@ -937,14 +924,11 @@ int _xbt_log_cat_init(xbt_log_category_t category, category->appender = xbt_log_default_appender; category->layout = xbt_log_default_layout; } else { - if (!category->parent) category->parent = &_XBT_LOGV(XBT_LOG_ROOT_CAT); - XBT_DEBUG("Set %s (%s) as father of %s ", - category->parent->name, - (category->parent->initialized ? - xbt_log_priority_names[category->parent->threshold] : "uninited"), + XBT_DEBUG("Set %s (%s) as father of %s ", category->parent->name, + (category->parent->initialized ? xbt_log_priority_names[category->parent->threshold] : "uninited"), category->name); xbt_log_parent_set(category, category->parent); @@ -962,14 +946,11 @@ int _xbt_log_cat_init(xbt_log_category_t category, cpp = cpp->nextSibling; } - XBT_DEBUG("Children of %s: %s; nextSibling: %s", - category->parent->name, res, - (category->parent->nextSibling ? - category->parent->nextSibling->name : "none")); + XBT_DEBUG("Children of %s: %s; nextSibling: %s", category->parent->name, res, + (category->parent->nextSibling ? category->parent->nextSibling->name : "none")); free(res); } - } /* Apply the control */ @@ -979,8 +960,7 @@ int _xbt_log_cat_init(xbt_log_category_t category, xbt_dynar_foreach(xbt_log_settings, cursor, setting) { xbt_assert(setting, "Damnit, NULL cat in the list"); - xbt_assert(setting->catname, "NULL setting(=%p)->catname", - (void *) setting); + xbt_assert(setting->catname, "NULL setting(=%p)->catname", (void *) setting); if (!strcmp(setting->catname, category->name)) { found = 1; @@ -991,8 +971,7 @@ int _xbt_log_cat_init(xbt_log_category_t category, if (!found) XBT_DEBUG("Category '%s': inherited threshold = %s (=%d)", - category->name, xbt_log_priority_names[category->threshold], - category->threshold); + category->name, xbt_log_priority_names[category->threshold], category->threshold); } category->initialized = 1; @@ -1010,7 +989,6 @@ void xbt_log_parent_set(xbt_log_category_t cat, xbt_log_category_t parent) /* if the category is initialized, unlink from current parent */ if (cat->initialized) { - xbt_log_category_t *cpp = &cat->parent->firstChild; while (*cpp != cat && *cpp != NULL) { @@ -1036,15 +1014,13 @@ void xbt_log_parent_set(xbt_log_category_t cat, xbt_log_category_t parent) static void _set_inherited_thresholds(xbt_log_category_t cat) { - xbt_log_category_t child = cat->firstChild; for (; child != NULL; child = child->nextSibling) { if (child->isThreshInherited) { if (cat != &_XBT_LOGV(log)) XBT_VERB("Set category threshold of %s to %s (=%d)", - child->name, xbt_log_priority_names[cat->threshold], - cat->threshold); + child->name, xbt_log_priority_names[cat->threshold], cat->threshold); child->threshold = cat->threshold; _set_inherited_thresholds(child); } @@ -1053,14 +1029,12 @@ static void _set_inherited_thresholds(xbt_log_category_t cat) } -void xbt_log_threshold_set(xbt_log_category_t cat, - e_xbt_log_priority_t threshold) +void xbt_log_threshold_set(xbt_log_category_t cat, e_xbt_log_priority_t threshold) { cat->threshold = threshold; cat->isThreshInherited = 0; _set_inherited_thresholds(cat); - } static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) @@ -1119,13 +1093,11 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) set->thresh = (e_xbt_log_priority_t) i; } else { THROWF(arg_error, 0, - "Unknown priority name: %s (must be one of: trace,debug,verbose,info,warning,error,critical)", - eq + 1); + "Unknown priority name: %s (must be one of: trace,debug,verbose,info,warning,error,critical)", eq + 1); } free(neweq); } else if (!strncmp(dot + 1, "add", (size_t) (eq - dot - 1)) || !strncmp(dot + 1, "additivity", (size_t) (eq - dot - 1))) { - char *neweq = xbt_strdup(eq + 1); char *p = neweq - 1; @@ -1134,8 +1106,7 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) *p -= 'a' - 'A'; } } - if (!strcmp(neweq, "ON") || !strcmp(neweq, "YES") - || !strcmp(neweq, "1")) { + if (!strcmp(neweq, "ON") || !strcmp(neweq, "YES") || !strcmp(neweq, "1")) { set->additivity = 1; } else { set->additivity = 0; @@ -1143,7 +1114,6 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) free(neweq); } else if (!strncmp(dot + 1, "app", (size_t) (eq - dot - 1)) || !strncmp(dot + 1, "appender", (size_t) (eq - dot - 1))) { - char *neweq = xbt_strdup(eq + 1); if (!strncmp(neweq, "file:", 5)) { @@ -1161,8 +1131,7 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) } else { char buff[512]; snprintf(buff, MIN(512, eq - dot), "%s", dot + 1); - THROWF(arg_error, 0, "Unknown setting of the log category: '%s'", - buff); + THROWF(arg_error, 0, "Unknown setting of the log category: '%s'", buff); } set->catname = (char *) xbt_malloc(dot - name + 1); @@ -1173,8 +1142,7 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) return set; } -static xbt_log_category_t _xbt_log_cat_searchsub(xbt_log_category_t cat, - char *name) +static xbt_log_category_t _xbt_log_cat_searchsub(xbt_log_category_t cat, char *name) { xbt_log_category_t child, res; @@ -1202,20 +1170,16 @@ static xbt_log_category_t _xbt_log_cat_searchsub(xbt_log_category_t cat, * * ( [category] "." [keyword] ":" value (" ")... )... * - * where [category] is one the category names (see \ref XBT_log_cats for - * a complete list of the ones defined in the SimGrid library) - * and keyword is one of the following: + * where [category] is one the category names (see \ref XBT_log_cats for a complete list of the ones defined in the + * SimGrid library) and keyword is one of the following: * * - thres: category's threshold priority. Possible values: * TRACE,DEBUG,VERBOSE,INFO,WARNING,ERROR,CRITICAL - * - add or additivity: whether the logging actions must be passed to - * the parent category. + * - add or additivity: whether the logging actions must be passed to the parent category. * Possible values: 0, 1, no, yes, on, off. * Default value: yes. * - fmt: the format to use. See \ref log_use_conf_fmt for more information. - * - app or appender: the appender to use. See \ref log_use_conf_app for more - * information. - * + * - app or appender: the appender to use. See \ref log_use_conf_app for more information. */ void xbt_log_control_set(const char *control_string) { @@ -1237,8 +1201,7 @@ void xbt_log_control_set(const char *control_string) } /* some initialization if this is the first time that this get called */ if (xbt_log_settings == NULL) - xbt_log_settings = xbt_dynar_new(sizeof(xbt_log_setting_t), - _free_setting); + xbt_log_settings = xbt_dynar_new(sizeof(xbt_log_setting_t), _free_setting); /* split the string, and remove empty entries */ set_strings = xbt_str_split_quoted(control_string); @@ -1254,15 +1217,13 @@ void xbt_log_control_set(const char *control_string) xbt_log_category_t cat = NULL; set = _xbt_log_parse_setting(str); - cat = - _xbt_log_cat_searchsub(&_XBT_LOGV(XBT_LOG_ROOT_CAT), set->catname); + cat = _xbt_log_cat_searchsub(&_XBT_LOGV(XBT_LOG_ROOT_CAT), set->catname); if (cat) { XBT_DEBUG("Apply directly"); _xbt_log_cat_apply_set(cat, set); _free_setting((void *) &set); } else { - XBT_DEBUG("Store for further application"); XBT_DEBUG("push %p to the settings", (void *) set); xbt_dynar_push(xbt_log_settings, &set); @@ -1285,9 +1246,7 @@ void xbt_log_layout_set(xbt_log_category_t cat, xbt_log_layout_t lay) { #define _xbt_log_cat_init(a, b) (0) if (!cat->appender) { - XBT_VERB - ("No appender to category %s. Setting the file appender as default", - cat->name); + XBT_VERB ("No appender to category %s. Setting the file appender as default", cat->name); xbt_log_appender_set(cat, xbt_log_appender_file_new(NULL)); } if (cat->layout) { @@ -1365,8 +1324,7 @@ static int xbt_log_cat_cmp(const void *pa, const void *pb) return strcmp(a->name, b->name); } -static void xbt_log_help_categories_rec(xbt_log_category_t category, - const char *prefix) +static void xbt_log_help_categories_rec(xbt_log_category_t category, const char *prefix) { char *this_prefix; char *child_prefix; diff --git a/src/xbt/log_private.h b/src/xbt/log_private.h index 7afcafdf26..f0baf8cf5b 100644 --- a/src/xbt/log_private.h +++ b/src/xbt/log_private.h @@ -15,8 +15,7 @@ struct xbt_log_appender_s { }; struct xbt_log_layout_s { - int (*do_layout) (xbt_log_layout_t l, - xbt_log_event_t event, const char *fmt); + int (*do_layout) (xbt_log_layout_t l, xbt_log_event_t event, const char *fmt); void (*free_) (xbt_log_layout_t l); void *data; }; @@ -28,8 +27,7 @@ struct xbt_log_layout_s { * * Programatically alter a category's parent (don't use). */ -XBT_PUBLIC(void) xbt_log_parent_set(xbt_log_category_t cat, - xbt_log_category_t parent); +XBT_PUBLIC(void) xbt_log_parent_set(xbt_log_category_t cat, xbt_log_category_t parent); #endif /* LOG_PRIVATE_H */ diff --git a/src/xbt/mallocator.c b/src/xbt/mallocator.c index 04d9cc2261..295ea55dfa 100644 --- a/src/xbt/mallocator.c +++ b/src/xbt/mallocator.c @@ -17,26 +17,21 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_mallocator, xbt, "Mallocators"); /** Implementation note on the mallocators: * - * Mallocators and memory mess introduced by model-checking do not mix well - * together: the mallocator will give standard memory when we are using raw - * memory (so these blocks are killed on restore) and the contrary (so these + * Mallocators and memory mess introduced by model-checking do not mix well together: the mallocator will give + * standard memory when we are using raw memory (so these blocks are killed on restore) and the contrary (so these * blocks will leak across restores). * - * In addition, model-checking is activated when the command-line arguments - * are parsed, at the beginning of main, while most of the mallocators are - * created during the constructor functions launched from xbt_preinit, before - * the beginning of the main function. + * In addition, model-checking is activated when the command-line arguments are parsed, at the beginning of main, while + * most of the mallocators are created during the constructor functions launched from xbt_preinit, before the beginning + * of the main function. * - * We want the code as fast as possible when they are active while we can deal - * with a little slow-down when they are inactive. So we start the mallocators - * as inactive. When they are so, they check at each use whether they should - * switch to the fast active mode or should stay in inactive mode. - * Finally, we give external elements a way to switch them - * all to the active mode (through xbt_mallocator_initialization_is_done). + * We want the code as fast as possible when they are active while we can deal with a little slow-down when they are + * inactive. So we start the mallocators as inactive. When they are so, they check at each use whether they should + * switch to the fast active mode or should stay in inactive mode. Finally, we give external elements a way to switch + * them all to the active mode (through xbt_mallocator_initialization_is_done). * - * This design avoids to store all mallocators somewhere for later conversion, - * which would be hard to achieve provided that all our data structures use - * some mallocators internally... + * This design avoids to store all mallocators somewhere for later conversion, which would be hard to achieve provided + * that all our data structures use some mallocators internally... */ /* Value != 0 when the framework configuration is done. Value > 1 if the @@ -64,13 +59,11 @@ static inline void lock_release(xbt_mallocator_t m) } /** - * This function must be called once the framework configuration is done. If not, - * mallocators will never get used. Check the implementation notes in - * src/xbt/mallocator.c for the justification of this. + * This function must be called once the framework configuration is done. If not, mallocators will never get used. + * Check the implementation notes in src/xbt/mallocator.c for the justification of this. * - * For example, surf_config uses this function to tell to the mallocators that - * the simgrid - * configuration is now finished and that it can create them if not done yet */ + * For example, surf_config uses this function to tell to the mallocators that the simgrid configuration is now + * finished and that it can create them if not done yet */ void xbt_mallocator_initialization_is_done(int protect) { initialization_done = protect ? 2 : 1; @@ -87,25 +80,20 @@ static inline int xbt_mallocator_is_active(void) { /** * \brief Constructor - * \param size size of the internal stack: number of objects the mallocator - * will be able to store - * \param new_f function to allocate a new object of your datatype, called - * in \a xbt_mallocator_get() when the mallocator is empty - * \param free_f function to free an object of your datatype, called - * in \a xbt_mallocator_release() when the stack is full, and when - * the mallocator is freed. - * \param reset_f function to reinitialise an object of your datatype, called - * when you extract an object from the mallocator (can be NULL) + * \param size size of the internal stack: number of objects the mallocator will be able to store + * \param new_f function to allocate a new object of your datatype, called in \a xbt_mallocator_get() when the + * mallocator is empty + * \param free_f function to free an object of your datatype, called in \a xbt_mallocator_release() when the stack is + * full, and when the mallocator is freed. + * \param reset_f function to reinitialise an object of your datatype, called when you extract an object from the + * mallocator (can be NULL) * * Create and initialize a new mallocator for a given datatype. * * \return pointer to the created mallocator * \see xbt_mallocator_free() */ -xbt_mallocator_t xbt_mallocator_new(int size, - pvoid_f_void_t new_f, - void_f_pvoid_t free_f, - void_f_pvoid_t reset_f) +xbt_mallocator_t xbt_mallocator_new(int size, pvoid_f_void_t new_f, void_f_pvoid_t free_f, void_f_pvoid_t reset_f) { xbt_mallocator_t m; @@ -113,8 +101,7 @@ xbt_mallocator_t xbt_mallocator_new(int size, xbt_assert(new_f != NULL && free_f != NULL, "invalid parameter"); m = xbt_new0(s_xbt_mallocator_t, 1); - XBT_VERB("Create mallocator %p (%s)", - m, xbt_mallocator_is_active() ? "enabled" : "disabled"); + XBT_VERB("Create mallocator %p (%s)", m, xbt_mallocator_is_active() ? "enabled" : "disabled"); m->current_size = 0; m->new_f = new_f; m->free_f = free_f; @@ -127,19 +114,16 @@ xbt_mallocator_t xbt_mallocator_new(int size, /** \brief Destructor * \param m the mallocator you want to destroy * - * Destroy the mallocator and all its data. The function - * free_f is called on each object in the mallocator. + * Destroy the mallocator and all its data. The function free_f is called on each object in the mallocator. * * \see xbt_mallocator_new() */ void xbt_mallocator_free(xbt_mallocator_t m) { - int i; xbt_assert(m != NULL, "Invalid parameter"); - XBT_VERB("Frees mallocator %p (size:%d/%d)", m, m->current_size, - m->max_size); + XBT_VERB("Frees mallocator %p (size:%d/%d)", m, m->current_size, m->max_size); for (i = 0; i < m->current_size; i++) { m->free_f(m->objects[i]); } @@ -153,11 +137,9 @@ void xbt_mallocator_free(xbt_mallocator_t m) * * Remove an object from the mallocator and return it. * This function is designed to be used instead of malloc(). - * If the mallocator is not empty, an object is - * extracted from the mallocator and no malloc is done. + * If the mallocator is not empty, an object is extracted from the mallocator and no malloc is done. * - * If the mallocator is empty, a new object is created, - * by calling the function new_f(). + * If the mallocator is empty, a new object is created, by calling the function new_f(). * * In both cases, the function reset_f() (if defined) is called on the object. * @@ -173,8 +155,7 @@ void *xbt_mallocator_get(xbt_mallocator_t m) /* No object is ready yet. Create a bunch of them to try to group the * mallocs on the same memory pages (to help the cache lines) */ - /* XBT_DEBUG("Create a new object for mallocator %p (size:%d/%d)", */ - /* m, m->current_size, m->max_size); */ + /* XBT_DEBUG("Create a new object for mallocator %p (size:%d/%d)", m, m->current_size, m->max_size); */ int i; int amount = MIN(m->max_size / 2, 1000); for (i = 0; i < amount; i++) @@ -183,8 +164,7 @@ void *xbt_mallocator_get(xbt_mallocator_t m) } /* there is at least an available object, now */ - /* XBT_DEBUG("Reuse an old object for mallocator %p (size:%d/%d)", */ - /* m, m->current_size, m->max_size); */ + /* XBT_DEBUG("Reuse an old object for mallocator %p (size:%d/%d)", m, m->current_size, m->max_size); */ object = m->objects[--m->current_size]; lock_release(m); } else { @@ -209,10 +189,8 @@ void *xbt_mallocator_get(xbt_mallocator_t m) * * Push into the mallocator an object you don't need anymore. * This function is designed to be used instead of free(). - * If the mallocator is not full, your object if stored into - * the mallocator and no free is done. - * If the mallocator is full, the object is freed by calling - * the function free_f(). + * If the mallocator is not full, your object if stored into the mallocator and no free is done. + * If the mallocator is full, the object is freed by calling the function free_f(). * * \see xbt_mallocator_get() */ @@ -222,16 +200,14 @@ void xbt_mallocator_release(xbt_mallocator_t m, void *object) lock_acquire(m); if (m->current_size < m->max_size) { /* there is enough place to push the object */ - /* XBT_DEBUG - ("Store deleted object in mallocator %p for further use (size:%d/%d)", + /* XBT_DEBUG("Store deleted object in mallocator %p for further use (size:%d/%d)", m, m->current_size, m->max_size); */ m->objects[m->current_size++] = object; lock_release(m); } else { lock_release(m); /* otherwise we don't have a choice, we must free the object */ - /* XBT_DEBUG("Free deleted object: mallocator %p is full (size:%d/%d)", m, - m->current_size, m->max_size); */ + /* XBT_DEBUG("Free deleted object: mallocator %p is full (size:%d/%d)", m, m->current_size, m->max_size); */ m->free_f(object); } } else { diff --git a/src/xbt/memory_map.cpp b/src/xbt/memory_map.cpp index 7d2888b250..0f7cc0f183 100644 --- a/src/xbt/memory_map.cpp +++ b/src/xbt/memory_map.cpp @@ -21,10 +21,7 @@ #include "memory_map.hpp" extern "C" { - -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_memory_map, xbt, - "Logging specific to algorithms for memory_map"); - +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_memory_map, xbt, "Logging specific to algorithms for memory_map"); } namespace simgrid { @@ -39,8 +36,7 @@ XBT_PRIVATE std::vector get_memory_map(pid_t pid) FILE *fp = std::fopen(path, "r"); if(fp == NULL) std::perror("fopen failed"); - xbt_assert(fp, - "Cannot open %s to investigate the memory map of the process.", path); + xbt_assert(fp, "Cannot open %s to investigate the memory map of the process.", path); free(path); setbuf(fp, NULL); @@ -57,8 +53,7 @@ XBT_PRIVATE std::vector get_memory_map(pid_t pid) /* Wipeout the new line character */ line[read - 1] = '\0'; - /* Tokenize the line using spaces as delimiters and store each token */ - /* in lfields array. We expect 5 tokens/fields */ + /* Tokenize the line using spaces as delimiters and store each token in lfields array. We expect 5 tokens/fields */ char* lfields[6]; lfields[0] = strtok(line, " "); @@ -119,7 +114,6 @@ XBT_PRIVATE std::vector get_memory_map(pid_t pid) if (lfields[1][4] == 'p') memreg.flags |= MAP_PRIVATE; - else if (lfields[1][4] == 's') memreg.flags |= MAP_SHARED; @@ -159,8 +153,7 @@ XBT_PRIVATE std::vector get_memory_map(pid_t pid) /* Create space for a new map region in the region's array and copy the */ /* parsed stuff from the temporal memreg variable */ - XBT_DEBUG("Found region for %s", - !memreg.pathname.empty() ? memreg.pathname.c_str() : "(null)"); + XBT_DEBUG("Found region for %s", !memreg.pathname.empty() ? memreg.pathname.c_str() : "(null)"); ret.push_back(std::move(memreg)); } @@ -169,8 +162,7 @@ XBT_PRIVATE std::vector get_memory_map(pid_t pid) std::fclose(fp); return ret; #else - /* On FreeBSD, kinfo_getvmmap() could be used but mmap() support is disabled - anyway. */ + /* On FreeBSD, kinfo_getvmmap() could be used but mmap() support is disabled anyway. */ xbt_die("Could not get memory map from process %lli", (long long int) pid); #endif } diff --git a/src/xbt/parmap.cpp b/src/xbt/parmap.cpp index 0a32bda976..de1dc57c1a 100644 --- a/src/xbt/parmap.cpp +++ b/src/xbt/parmap.cpp @@ -351,8 +351,8 @@ static void *xbt_parmap_worker_main(void *arg) * \param fun the function to call in parallel * \param data each element of this dynar will be passed as an argument to fun */ -int xbt_parmap_mc_apply(xbt_parmap_t parmap, int_f_pvoid_pvoid_t fun, - void* data, unsigned int length, void* ref_snapshot) +int xbt_parmap_mc_apply(xbt_parmap_t parmap, int_f_pvoid_pvoid_t fun, void* data, unsigned int length, + void* ref_snapshot) { /* Assign resources to worker threads */ parmap->snapshot_compare = fun; @@ -455,8 +455,7 @@ static void xbt_parmap_posix_master_wait(xbt_parmap_t parmap) /** * \brief Ends the parmap: wakes the controller thread when all workers terminate. * - * This function is called by all worker threads when they end (not including - * the controller). + * This function is called by all worker threads when they end (not including the controller). * * \param parmap a parmap */ @@ -490,8 +489,7 @@ static void xbt_parmap_posix_master_signal(xbt_parmap_t parmap) /** * \brief Waits for some work to process. * - * This function is called by each worker thread (not including the controller) - * when it has no more work to do. + * This function is called by each worker thread (not including the controller) when it has no more work to do. * * \param parmap a parmap * \param round the expected round number @@ -527,8 +525,7 @@ static void xbt_parmap_futex_master_wait(xbt_parmap_t parmap) /** * \brief Ends the parmap: wakes the controller thread when all workers terminate. * - * This function is called by all worker threads when they end (not including - * the controller). + * This function is called by all worker threads when they end (not including the controller). * * \param parmap a parmap */ @@ -559,8 +556,7 @@ static void xbt_parmap_futex_master_signal(xbt_parmap_t parmap) /** * \brief Waits for some work to process. * - * This function is called by each worker thread (not including the controller) - * when it has no more work to do. + * This function is called by each worker thread (not including the controller) when it has no more work to do. * * \param parmap a parmap * \param round the expected round number @@ -618,8 +614,7 @@ static void xbt_parmap_busy_master_signal(xbt_parmap_t parmap) /** * \brief Waits for some work to process. * - * This function is called by each worker thread (not including the controller) - * when it has no more work to do. + * This function is called by each worker thread (not including the controller) when it has no more work to do. * * \param parmap a parmap * \param round the expected round number diff --git a/src/xbt/swag.c b/src/xbt/swag.c index 71f6f001e3..e10514e663 100644 --- a/src/xbt/swag.c +++ b/src/xbt/swag.c @@ -32,8 +32,8 @@ inline xbt_swag_t xbt_swag_new(size_t offset) /** * \param swag poor victim * - * kilkil a swag but not it's content. If you do not understand why - * xbt_swag_free should not free its content, don't use swags. + * kilkil a swag but not it's content. If you do not understand why xbt_swag_free should not free its content, + * don't use swags. */ inline void xbt_swag_free(xbt_swag_t swag) { @@ -59,8 +59,8 @@ inline void xbt_swag_init(xbt_swag_t swag, size_t offset) * \param obj the objet to insert in the swag * \param swag a swag * - * insert (at the head... you probably had a very good reason to do - * that, I hope you know what you're doing) \a obj in \a swag + * insert (at the head... you probably had a very good reason to do that, I hope you know what you're doing) \a obj in + * \a swag */ inline void xbt_swag_insert_at_head(void *obj, xbt_swag_t swag) { @@ -72,8 +72,7 @@ inline void xbt_swag_insert_at_head(void *obj, xbt_swag_t swag) swag->head = obj; swag->tail = obj; swag->count++; - } - else if (obj != swag->head && !xbt_swag_getPrev(obj, swag->offset)) { + } else if (obj != swag->head && !xbt_swag_getPrev(obj, swag->offset)) { xbt_swag_getNext(obj, swag->offset) = swag->head; xbt_swag_getPrev(swag->head, swag->offset) = obj; swag->head = obj; @@ -85,8 +84,8 @@ inline void xbt_swag_insert_at_head(void *obj, xbt_swag_t swag) * \param obj the objet to insert in the swag * \param swag a swag * - * insert (at the tail... you probably had a very good reason to do - * that, I hope you know what you're doing) \a obj in \a swag + * insert (at the tail... you probably had a very good reason to do that, I hope you know what you're doing) \a obj in + * \a swag */ inline void xbt_swag_insert_at_tail(void *obj, xbt_swag_t swag) { @@ -98,8 +97,7 @@ inline void xbt_swag_insert_at_tail(void *obj, xbt_swag_t swag) swag->head = obj; swag->tail = obj; swag->count++; - } - else if (obj != swag->tail && !xbt_swag_getNext(obj, swag->offset)) { + } else if (obj != swag->tail && !xbt_swag_getNext(obj, swag->offset)) { xbt_swag_getPrev(obj, swag->offset) = swag->tail; xbt_swag_getNext(swag->tail, swag->offset) = obj; swag->tail = obj; @@ -129,19 +127,16 @@ inline void *xbt_swag_remove(void *obj, xbt_swag_t swag) if (next) { xbt_swag_getPrev(next, offset) = prev; xbt_swag_getNext(obj, offset) = NULL; - } - else { + } else { swag->tail = prev; } swag->count--; - } - else if (next) { + } else if (next) { xbt_swag_getPrev(next, offset) = NULL; xbt_swag_getNext(obj, offset) = NULL; swag->head = next; swag->count--; - } - else if (obj == swag->head) { + } else if (obj == swag->head) { swag->head = swag->tail = NULL; swag->count--; } @@ -182,7 +177,6 @@ inline int xbt_swag_size(xbt_swag_t swag) return (swag->count); } - #ifdef SIMGRID_TEST XBT_TEST_SUITE("swag", "Swag data container"); @@ -206,8 +200,7 @@ XBT_TEST_UNIT("basic", test_swag_basic, "Basic usage") obj2->name = "Obj 2"; xbt_test_add("Basic usage"); - xbt_test_log("%p %p %ld\n", obj1, &(obj1->setB), - (long) ((char *) &(obj1->setB) - (char *) obj1)); + xbt_test_log("%p %p %ld\n", obj1, &(obj1->setB), (long) ((char *) &(obj1->setB) - (char *) obj1)); setA = xbt_swag_new(xbt_swag_offset(*obj1, setA)); setB = xbt_swag_new(xbt_swag_offset(*obj1, setB)); @@ -247,5 +240,4 @@ XBT_TEST_UNIT("basic", test_swag_basic, "Basic usage") xbt_free(obj1); xbt_free(obj2); } - #endif /* SIMGRID_TEST */ diff --git a/src/xbt/xbt_log_appender_file.c b/src/xbt/xbt_log_appender_file.c index 27da68647b..0fa6906530 100644 --- a/src/xbt/xbt_log_appender_file.c +++ b/src/xbt/xbt_log_appender_file.c @@ -53,8 +53,7 @@ typedef struct xbt_log_append2_file_s* xbt_log_append2_file_t; #define APPEND2_END_TOKEN_CLEAR "\n " static void open_append2_file(xbt_log_append2_file_t data){ - if(data->count<0) - { + if(data->count<0) { //Roll if(!data->file) data->file= fopen(data->filename, "w"); @@ -62,8 +61,7 @@ static void open_append2_file(xbt_log_append2_file_t data){ fputs(APPEND2_END_TOKEN_CLEAR,data->file); fseek(data->file,0,SEEK_SET); } - } - else{ + } else{ //printf("Splitting\n"); //Split if(data->file) @@ -79,24 +77,19 @@ static void open_append2_file(xbt_log_append2_file_t data){ data->count++; data->file= fopen(newname, "w"); xbt_assert(data->file); - } } - - - static void append2_file(xbt_log_appender_t this_, char *str) { xbt_log_append2_file_t d=(xbt_log_append2_file_t) this_->data; xbt_assert(d->file); - if(ftell(d->file)>=d->limit) - { + if(ftell(d->file)>=d->limit) { open_append2_file(d); } fputs(str, d->file); if(d->count<0){ - fputs(APPEND2_END_TOKEN,d->file); - fseek(d->file,-((signed long)strlen(APPEND2_END_TOKEN)),SEEK_CUR); + fputs(APPEND2_END_TOKEN,d->file); + fseek(d->file,-((signed long)strlen(APPEND2_END_TOKEN)),SEEK_CUR); } } @@ -141,4 +134,3 @@ xbt_log_appender_t xbt_log_appender2_file_new(char *arg,int roll) { res->data = data; return res; } - diff --git a/src/xbt/xbt_log_layout_format.c b/src/xbt/xbt_log_layout_format.c index a54136216d..64162da8a1 100644 --- a/src/xbt/xbt_log_layout_format.c +++ b/src/xbt/xbt_log_layout_format.c @@ -77,9 +77,7 @@ static double format_begin_of_time = -1; #define show_int(data) show_it(data, "d") #define show_double(data) show_it(data, "f") -static int xbt_log_layout_format_doit(xbt_log_layout_t l, - xbt_log_event_t ev, - const char *msg_fmt) +static int xbt_log_layout_format_doit(xbt_log_layout_t l, xbt_log_event_t ev, const char *msg_fmt) { char *p = ev->buffer; int rem_size = ev->buffer_size; @@ -123,8 +121,7 @@ static int xbt_log_layout_format_doit(xbt_log_layout_t l, length = strtol(q, &q, 10); goto handle_modifier; case 'c': /* category name; LOG4J compliant - should accept a precision postfix to show the - hierarchy */ + should accept a precision postfix to show the hierarchy */ show_string(ev->cat->name); break; case 'p': /* priority name; LOG4J compliant */ diff --git a/src/xbt/xbt_log_layout_simple.c b/src/xbt/xbt_log_layout_simple.c index 5ef77ba601..7af08811a2 100644 --- a/src/xbt/xbt_log_layout_simple.c +++ b/src/xbt/xbt_log_layout_simple.c @@ -26,9 +26,7 @@ static double simple_begin_of_time = -1; } else \ return 0 -static int xbt_log_layout_simple_doit(xbt_log_layout_t l, - xbt_log_event_t ev, - const char *fmt) +static int xbt_log_layout_simple_doit(xbt_log_layout_t l, xbt_log_event_t ev, const char *fmt) { char *p = ev->buffer; int rem_size = ev->buffer_size; @@ -41,31 +39,26 @@ static int xbt_log_layout_simple_doit(xbt_log_layout_t l, /* Display the proc info if available */ procname = xbt_procname(); if (procname && strcmp(procname,"maestro")) { - len = snprintf(p, rem_size, "%s:%s:(%d) ", - SIMIX_host_self_get_name(), procname, xbt_getpid()); + len = snprintf(p, rem_size, "%s:%s:(%d) ", SIMIX_host_self_get_name(), procname, xbt_getpid()); check_overflow(len); } else if (!procname) { - len = snprintf(p, rem_size, "%s::(%d) ", - SIMIX_host_self_get_name(), xbt_getpid()); + len = snprintf(p, rem_size, "%s::(%d) ", SIMIX_host_self_get_name(), xbt_getpid()); check_overflow(len); } /* Display the date */ - len = snprintf(p, rem_size, "%f] ", - surf_get_clock() - simple_begin_of_time); + len = snprintf(p, rem_size, "%f] ", surf_get_clock() - simple_begin_of_time); check_overflow(len); /* Display file position if not INFO */ if (ev->priority != xbt_log_priority_info && !xbt_log_no_loc) { - len = snprintf(p, rem_size, "%s:%d: ", - ev->fileName, ev->lineNum); + len = snprintf(p, rem_size, "%s:%d: ", ev->fileName, ev->lineNum); check_overflow(len); } /* Display category name */ - len = snprintf(p, rem_size, "[%s/%s] ", - ev->cat->name, xbt_log_priority_names[ev->priority]); + len = snprintf(p, rem_size, "[%s/%s] ", ev->cat->name, xbt_log_priority_names[ev->priority]); check_overflow(len); /* Display user-provided message */ diff --git a/src/xbt/xbt_main.c b/src/xbt/xbt_main.c index 61551dfb40..43e903f5cf 100644 --- a/src/xbt/xbt_main.c +++ b/src/xbt/xbt_main.c @@ -35,7 +35,6 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(module, xbt, "module handling"); XBT_LOG_NEW_CATEGORY(smpi, "All SMPI categories"); /* lives here even if that's a bit odd to solve linking issues: this is used in xbt_log_file_appender to detect whether SMPI is used (and thus whether we should unbench the writing to disk) */ - char *xbt_binary_name = NULL; /* Name of the system process containing us (mandatory to retrieve neat backtraces) */ xbt_dynar_t xbt_cmdline = NULL; /* all we got in argv */ @@ -63,9 +62,7 @@ static void xbt_postexit(void); #include #ifndef __GNUC__ -/* Should not be necessary but for some reason, - * DllMain is called twice at attachment and - * at detachment.*/ +/* Should not be necessary but for some reason, DllMain is called twice at attachment and at detachment.*/ static int xbt_dll_process_is_attached = 0; /* see also http://msdn.microsoft.com/en-us/library/ms682583%28VS.85%29.aspx */ diff --git a/src/xbt/xbt_matrix.c b/src/xbt/xbt_matrix.c index 3e37abd24d..a90d2368b2 100644 --- a/src/xbt/xbt_matrix.c +++ b/src/xbt/xbt_matrix.c @@ -14,9 +14,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_matrix, xbt, "2D data storage"); /** \brief constructor */ -xbt_matrix_t xbt_matrix_new(int lines, int rows, - const unsigned long elmsize, - void_f_pvoid_t const free_f) +xbt_matrix_t xbt_matrix_new(int lines, int rows, const unsigned long elmsize, void_f_pvoid_t const free_f) { xbt_matrix_t res = xbt_new(s_xbt_matrix_t, 1); res->lines = lines; @@ -28,14 +26,10 @@ xbt_matrix_t xbt_matrix_new(int lines, int rows, } /** \brief Creates a matrix being a submatrix of another one */ -xbt_matrix_t xbt_matrix_new_sub(xbt_matrix_t from, - int lsize, int rsize, - int lpos, int rpos, +xbt_matrix_t xbt_matrix_new_sub(xbt_matrix_t from, int lsize, int rsize, int lpos, int rpos, pvoid_f_pvoid_t const cpy_f) { - - xbt_matrix_t res = xbt_matrix_new(lsize, rsize, - from->elmsize, from->free_f); + xbt_matrix_t res = xbt_matrix_new(lsize, rsize, from->elmsize, from->free_f); xbt_matrix_copy_values(res, from, lsize, rsize, 0, 0, lpos, rpos, cpy_f); return res; } @@ -61,16 +55,13 @@ void xbt_matrix_free_voidp(void *d) xbt_matrix_free((xbt_matrix_t) * (void **) d); } - /** \brief Display the content of a matrix (debugging purpose) * \param coords: boolean indicating whether we should add the coords of each cell to the output*/ -void xbt_matrix_dump(xbt_matrix_t matrix, const char *name, int coords, - void_f_pvoid_t display_fun) +void xbt_matrix_dump(xbt_matrix_t matrix, const char *name, int coords, void_f_pvoid_t display_fun) { unsigned int i, j; - fprintf(stderr, ">>> Matrix %s dump (%u x %u)\n", name, matrix->lines, - matrix->rows); + fprintf(stderr, ">>> Matrix %s dump (%u x %u)\n", name, matrix->lines, matrix->rows); for (i = 0; i < matrix->lines; i++) { fprintf(stderr, " "); for (j = 0; j < matrix->rows; j++) { @@ -100,18 +91,14 @@ void xbt_matrix_dump_display_double(void *d) * \param lpos_src: line offset on destination matrix * \param rpos_src: row offset on destination matrix */ -void xbt_matrix_copy_values(xbt_matrix_t dst, xbt_matrix_t src, - unsigned int lsize, unsigned int rsize, - unsigned int lpos_dst, unsigned int rpos_dst, - unsigned int lpos_src, unsigned int rpos_src, +void xbt_matrix_copy_values(xbt_matrix_t dst, xbt_matrix_t src, unsigned int lsize, unsigned int rsize, + unsigned int lpos_dst, unsigned int rpos_dst,unsigned int lpos_src, unsigned int rpos_src, pvoid_f_pvoid_t const cpy_f) { unsigned int i, j; - XBT_DEBUG - ("Copy a %ux%u submatrix from %ux%u(of %ux%u) to %ux%u (of %ux%u)", - lsize, rsize, lpos_src, rpos_src, src->lines, src->rows, lpos_dst, - rpos_dst, dst->lines, dst->rows); + XBT_DEBUG ("Copy a %ux%u submatrix from %ux%u(of %ux%u) to %ux%u (of %ux%u)", + lsize, rsize, lpos_src, rpos_src, src->lines, src->rows, lpos_dst, rpos_dst, dst->lines, dst->rows); /* everybody knows that issue is between the chair and the screen (particulary in my office) */ xbt_assert(src->elmsize == dst->elmsize); @@ -130,12 +117,10 @@ void xbt_matrix_copy_values(xbt_matrix_t dst, xbt_matrix_t src, xbt_matrix_get_as(dst, j + lpos_dst, i + rpos_dst, void *) = cpy_f(xbt_matrix_get_ptr(src, j + rpos_src, i + lpos_src)); } else { - memcpy(xbt_matrix_get_ptr(dst, lpos_dst, i + rpos_dst), - xbt_matrix_get_ptr(src, lpos_src, i + rpos_src), + memcpy(xbt_matrix_get_ptr(dst, lpos_dst, i + rpos_dst), xbt_matrix_get_ptr(src, lpos_src, i + rpos_src), dst->elmsize * lsize); } } - } /** \brief Creates a new matrix of double filled with zeros */ @@ -171,19 +156,15 @@ xbt_matrix_t xbt_matrix_double_new_seq(int lines, int rows) } /** \brief add to C the result of A*B */ -void xbt_matrix_double_addmult(xbt_matrix_t A, xbt_matrix_t B, - /*OUT*/ xbt_matrix_t C) +void xbt_matrix_double_addmult(xbt_matrix_t A, xbt_matrix_t B, /*OUT*/ xbt_matrix_t C) { unsigned int i, j, k; - xbt_assert(A->lines == C->lines, - "A->lines != C->lines (%u vs %u)", A->lines, C->lines); + xbt_assert(A->lines == C->lines, "A->lines != C->lines (%u vs %u)", A->lines, C->lines); xbt_assert(B->rows == C->rows); for (i = 0; i < C->lines; i++) for (j = 0; j < C->rows; j++) for (k = 0; k < B->lines; k++) - xbt_matrix_get_as(C, i, j, double) += - xbt_matrix_get_as(A, i, k, double) * xbt_matrix_get_as(B, k, j, - double); + xbt_matrix_get_as(C, i, j, double) += xbt_matrix_get_as(A, i, k, double) * xbt_matrix_get_as(B, k, j, double); } diff --git a/src/xbt/xbt_os_file.c b/src/xbt/xbt_os_file.c index b1ca8b856f..46dd79a42e 100644 --- a/src/xbt/xbt_os_file.c +++ b/src/xbt/xbt_os_file.c @@ -21,20 +21,18 @@ * * This is a reimplementation of the GNU getline function, so that our code don't depends on the GNU libc. * - * xbt_getline() reads an entire line from stream, storing the address of the - * buffer containing the text into *buf. The buffer is null-terminated and - * includes the newline character, if one was found. + * xbt_getline() reads an entire line from stream, storing the address of the buffer containing the text into *buf. + * The buffer is null-terminated and includes the newline character, if one was found. * - * If *buf is NULL, then xbt_getline() will allocate a buffer for storing the - * line, which should be freed by the user program. + * If *buf is NULL, then xbt_getline() will allocate a buffer for storing the line, which should be freed by the user + * program. * - * Alternatively, before calling xbt_getline(), *buf can contain a pointer to a - * malloc()-allocated buffer *n bytes in size. If the buffer is not large - * enough to hold the line, xbt_getline() resizes it with realloc(), updating + * Alternatively, before calling xbt_getline(), *buf can contain a pointer to a malloc()-allocated buffer *n bytes in + * size. If the buffer is not large enough to hold the line, xbt_getline() resizes it with realloc(), updating * *buf and *n as necessary. * - * In either case, on a successful call, *buf and *n will be updated to reflect - * the buffer address and allocated size respectively. + * In either case, on a successful call, *buf and *n will be updated to reflect the buffer address and allocated size + * respectively. */ ssize_t xbt_getline(char **buf, size_t *n, FILE *stream) { diff --git a/src/xbt/xbt_os_synchro.c b/src/xbt/xbt_os_synchro.c index fd52a4deae..5ece743e10 100644 --- a/src/xbt/xbt_os_synchro.c +++ b/src/xbt/xbt_os_synchro.c @@ -15,8 +15,7 @@ #include "simgrid/simix.h" /* used implementation */ #include "../simix/smx_private.h" /* FIXME */ -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_sync, xbt, - "Synchronization mechanism"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_sync, xbt, "Synchronization mechanism"); /****** mutex related functions ******/ struct s_xbt_mutex_ { @@ -101,7 +100,6 @@ xbt_bar_t xbt_barrier_init(unsigned int count) return bar; } - int xbt_barrier_wait(xbt_bar_t bar) { int ret=0; @@ -115,7 +113,6 @@ int xbt_barrier_wait(xbt_bar_t bar) xbt_cond_wait(bar->cond, bar->mutex); xbt_mutex_release(bar->mutex); } - return ret; } @@ -125,4 +122,3 @@ void xbt_barrier_destroy(xbt_bar_t bar) xbt_cond_destroy(bar->cond); xbt_free(bar); } - diff --git a/src/xbt/xbt_os_thread.c b/src/xbt/xbt_os_thread.c index b80fb3199a..0c1ae33cd4 100644 --- a/src/xbt/xbt_os_thread.c +++ b/src/xbt/xbt_os_thread.c @@ -45,7 +45,6 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_sync_os, xbt, "Synchronization mechanism (OS-level)"); - /* use named sempahore when sem_init() does not work */ #if !HAVE_SEM_INIT static int next_sem_ID = 0; @@ -117,7 +116,7 @@ void xbt_os_thread_mod_preinit(void) if ((errcode = pthread_setspecific(xbt_self_thread_key, main_thread))) THROWF(system_error, errcode, "Impossible to set the SimGrid identity descriptor to the main thread (pthread_setspecific failed)"); - + __xbt_running_ctx_fetch = _os_thread_get_running_ctx; __xbt_ex_terminate = _os_thread_ex_terminate; @@ -177,7 +176,6 @@ static void *wrapper_start_routine(void *s) return res; } - xbt_os_thread_t xbt_os_thread_create(const char *name, pvoid_f_pvoid_t start_routine, void *param, void *extra_data) { xbt_os_thread_t res_thread = xbt_new(s_xbt_os_thread_t, 1); @@ -288,13 +286,14 @@ void xbt_os_thread_key_create(xbt_os_thread_key_t* key) xbt_assert(errcode==0 , "pthread_key_create failed"); } -void xbt_os_thread_set_specific(xbt_os_thread_key_t key, void* value) { - +void xbt_os_thread_set_specific(xbt_os_thread_key_t key, void* value) +{ int errcode = pthread_setspecific(key, value); xbt_assert(errcode==0, "pthread_setspecific failed"); } -void* xbt_os_thread_get_specific(xbt_os_thread_key_t key) { +void* xbt_os_thread_get_specific(xbt_os_thread_key_t key) +{ return pthread_getspecific(key); } @@ -465,13 +464,11 @@ void xbt_os_sem_destroy(xbt_os_sem_t sem) { #if HAVE_SEM_INIT if (sem_destroy(sem->ps) < 0) - THROWF(system_error, errno, "sem_destroy() failed: %s", - strerror(errno)); + THROWF(system_error, errno, "sem_destroy() failed: %s", strerror(errno)); #else if (sem_close(sem->ps) < 0) THROWF(system_error, errno, "sem_close() failed: %s", strerror(errno)); xbt_free(sem->name); - #endif xbt_free(sem); } @@ -483,7 +480,6 @@ void xbt_os_sem_get_value(xbt_os_sem_t sem, int *svalue) strerror(errno)); } - /** @brief Returns the amount of cores on the current host */ int xbt_os_get_numcores(void) { #ifdef WIN32 diff --git a/src/xbt/xbt_os_time.c b/src/xbt/xbt_os_time.c index 0994708ee5..fa6fc2b437 100644 --- a/src/xbt/xbt_os_time.c +++ b/src/xbt/xbt_os_time.c @@ -85,16 +85,11 @@ void xbt_os_sleep(double sec) #endif } -/* TSC (tick-level) timers are said to be unreliable on SMP hosts and thus - disabled in SDL source code */ - +/* TSC (tick-level) timers are said to be unreliable on SMP hosts and thus disabled in SDL source code */ /* \defgroup XBT_sysdep All system dependency - * \brief This section describes many macros/functions that can serve as - * an OS abstraction. + * \brief This section describes many macros/functions that can serve as an OS abstraction. */ - - struct s_xbt_os_timer { #if HAVE_POSIX_GETTIME struct timespec start, stop, elapse; @@ -122,18 +117,14 @@ void xbt_os_timer_free(xbt_os_timer_t timer) double xbt_os_timer_elapsed(xbt_os_timer_t timer) { #if HAVE_POSIX_GETTIME - return ((double) timer->stop.tv_sec) - ((double) timer->start.tv_sec) + - ((double) timer->elapse.tv_sec ) + - ((((double) timer->stop.tv_nsec) - - ((double) timer->start.tv_nsec) + ((double) timer->elapse.tv_nsec )) / 1e9); + return ((double) timer->stop.tv_sec) - ((double) timer->start.tv_sec) + ((double) timer->elapse.tv_sec ) + + ((((double) timer->stop.tv_nsec) - ((double) timer->start.tv_nsec) + ((double) timer->elapse.tv_nsec )) / 1e9); #elif HAVE_GETTIMEOFDAY || defined(_WIN32) - return ((double) timer->stop.tv_sec) - ((double) timer->start.tv_sec) - + ((double) timer->elapse.tv_sec ) + - ((((double) timer->stop.tv_usec) - - ((double) timer->start.tv_usec) + ((double) timer->elapse.tv_usec )) / 1000000.0); + return ((double) timer->stop.tv_sec) - ((double) timer->start.tv_sec) + ((double) timer->elapse.tv_sec ) + + ((((double) timer->stop.tv_usec) - ((double) timer->start.tv_usec) + ((double) timer->elapse.tv_usec )) / + 1000000.0); #else - return (double) timer->stop - (double) timer->start + (double) - timer->elapse; + return (double) timer->stop - (double) timer->start + (double) timer->elapse; #endif } diff --git a/src/xbt/xbt_replay.c b/src/xbt/xbt_replay.c index 0532a8146b..2aa0ce23dc 100644 --- a/src/xbt/xbt_replay.c +++ b/src/xbt/xbt_replay.c @@ -152,13 +152,11 @@ int xbt_replay_action_runner(int argc, char *argv[]) char **evt; while ((evt = action_get_action(argv[0]))) { char* lowername = str_tolower (evt[1]); - action_fun function = - (action_fun)xbt_dict_get(xbt_action_funs, lowername); + action_fun function = (action_fun)xbt_dict_get(xbt_action_funs, lowername); xbt_free(lowername); TRY{ function((const char **)evt); - } - CATCH(e) { + } CATCH(e) { free(evt); xbt_die("Replay error :\n %s", e.msg); } @@ -170,8 +168,7 @@ int xbt_replay_action_runner(int argc, char *argv[]) const char **evt; xbt_assert(argc >= 2, "No '%s' agent function provided, no simulation-wide trace file provided, " - "and no process-wide trace file provided in deployment file. Aborting.", - argv[0] + "and no process-wide trace file provided in deployment file. Aborting.", argv[0] ); xbt_replay_reader_t reader = xbt_replay_reader_new(argv[1]); while ((evt=xbt_replay_reader_get(reader))) { @@ -181,8 +178,7 @@ int xbt_replay_action_runner(int argc, char *argv[]) xbt_free(lowername); TRY{ function(evt); - } - CATCH(e) { + } CATCH(e) { free(evt); xbt_die("Replay error on line %d of file %s :\n %s" , reader->linenum,reader->filename, e.msg); } @@ -196,7 +192,6 @@ int xbt_replay_action_runner(int argc, char *argv[]) return 0; } - static char **action_get_action(char *name) { xbt_dynar_t evt = NULL; @@ -204,7 +199,6 @@ static char **action_get_action(char *name) xbt_dynar_t myqueue = xbt_dict_get_or_null(xbt_action_queues, name); if (myqueue == NULL || xbt_dynar_is_empty(myqueue)) { // nothing stored for me. Read the file further - if (xbt_action_fp == NULL) { // File closed now. There's nothing more to read. I'm out of here goto todo_done; } @@ -231,8 +225,7 @@ static char **action_get_action(char *name) xbt_dynar_t otherqueue = xbt_dict_get_or_null(xbt_action_queues, evtname); if (otherqueue == NULL) { // Damn. Create the queue of that guy - otherqueue = - xbt_dynar_new(sizeof(xbt_dynar_t), xbt_dynar_free_voidp); + otherqueue = xbt_dynar_new(sizeof(xbt_dynar_t), xbt_dynar_free_voidp); xbt_dict_set(xbt_action_queues, evtname, otherqueue, NULL); } xbt_dynar_push(otherqueue, &evt); @@ -245,7 +238,6 @@ static char **action_get_action(char *name) return xbt_dynar_to_array(evt); } - // I did all my actions for me in the file (either I closed the file, or a colleague did) // Let's cleanup before leaving todo_done: diff --git a/src/xbt/xbt_str.c b/src/xbt/xbt_str.c index 5c1e85220d..4f6ac2aeed 100644 --- a/src/xbt/xbt_str.c +++ b/src/xbt/xbt_str.c @@ -27,7 +27,6 @@ * * @param s The string to strip. Modified in place. * @param char_list A string which contains the characters you want to strip. - * */ void xbt_str_rtrim(char *s, const char *char_list) { @@ -71,7 +70,6 @@ void xbt_str_rtrim(char *s, const char *char_list) * * @param s The string to strip. Modified in place. * @param char_list A string which contains the characters you want to strip. - * */ void xbt_str_ltrim(char *s, const char *char_list) { @@ -112,11 +110,9 @@ void xbt_str_ltrim(char *s, const char *char_list) * * @param s The string to strip. * @param char_list A string which contains the characters you want to strip. - * */ void xbt_str_trim(char *s, const char *char_list) { - if (!s) return; @@ -155,12 +151,10 @@ void xbt_str_subst(char *str, char from, char to, int occurence) * * If the variable name contains spaces, use the brace version (ie, ${toto tutu}) * - * You can provide a default value to use if the variable is not set in the dict by using - * '${var:=default}' or '${var:-default}'. These two forms are equivalent, even if they - * shouldn't to respect the shell standard (:= form should set the value in the dict, - * but does not) (BUG). + * You can provide a default value to use if the variable is not set in the dict by using '${var:=default}' or + * '${var:-default}'. These two forms are equivalent, even if they shouldn't to respect the shell standard (:= form + * should set the value in the dict, but does not) (BUG). */ - char *xbt_str_varsubst(const char *str, xbt_dict_t patterns) { xbt_strbuff_t buff = xbt_strbuff_new_from(str); @@ -186,7 +180,6 @@ char *xbt_str_varsubst(const char *str, xbt_dict_t patterns) * - "\0" (ASCII 0 (0x00)) NULL. * - "\x0B" (ASCII 11 (0x0B)) vertical tab. */ - xbt_dynar_t xbt_str_split(const char *s, const char *sep) { xbt_dynar_t res = xbt_dynar_new(sizeof(char *), &xbt_free_ref); @@ -283,14 +276,12 @@ xbt_dynar_t xbt_str_split_str(const char *s, const char *sep) * * The string passed as argument must be writable (not const) * The elements of the dynar are just parts of the string passed as argument. - * So if you don't store that argument elsewhere, you should free it in addition - * to freeing the dynar. This can be done by simply freeing the first argument - * of the dynar: + * So if you don't store that argument elsewhere, you should free it in addition to freeing the dynar. This can be done + * by simply freeing the first argument of the dynar: * free(xbt_dynar_get_ptr(dynar,0)); * - * Actually this function puts a bunch of \0 in the memory area you passed as - * argument to separate the elements, and pushes the address of each chunk - * in the resulting dynar. Yes, that's uneven. Yes, that's gory. But that's efficient. + * Actually this function puts a bunch of \0 in the memory area you passed as argument to separate the elements, and + * pushes the address of each chunk in the resulting dynar. Yes, that's uneven. Yes, that's gory. But that's efficient. */ xbt_dynar_t xbt_str_split_quoted_in_place(char *s) { xbt_dynar_t res = xbt_dynar_new(sizeof(char *), NULL); @@ -308,8 +299,6 @@ xbt_dynar_t xbt_str_split_quoted_in_place(char *s) { end = beg; while (!done) { - - switch (*end) { case '\\': ctn = 1; @@ -319,7 +308,6 @@ xbt_dynar_t xbt_str_split_quoted_in_place(char *s) { THROWF(arg_error, 0, "String ends with \\"); end++; /* Pass the protected char */ break; - case '\'': ctn = 1; if (!in_double_quote) { @@ -340,15 +328,12 @@ xbt_dynar_t xbt_str_split_quoted_in_place(char *s) { end++; } break; - case ' ': case '\t': case '\n': case '\0': if (*end == '\0' && (in_simple_quote || in_double_quote)) { - THROWF(arg_error, 0, - "End of string found while searching for %c in %s", - (in_simple_quote ? '\'' : '"'), s); + THROWF(arg_error, 0, "End of string found while searching for %c in %s", (in_simple_quote ? '\'' : '"'), s); } if (in_simple_quote || in_double_quote) { end++; @@ -373,7 +358,6 @@ xbt_dynar_t xbt_str_split_quoted_in_place(char *s) { end = beg; } break; - default: ctn = 1; end++; @@ -384,14 +368,11 @@ xbt_dynar_t xbt_str_split_quoted_in_place(char *s) { /** @brief Splits a string into a dynar of strings, taking quotes into account * - * It basically does the same argument separation than the shell, where white - * spaces can be escaped and where arguments are never split within a - * quote group. + * It basically does the same argument separation than the shell, where white spaces can be escaped and where arguments + * are never split within a quote group. * Several subsequent spaces are ignored (unless within quotes, of course). * You may want to trim the input string, if you want to avoid empty entries - * */ - xbt_dynar_t xbt_str_split_quoted(const char *s) { xbt_dynar_t res = xbt_dynar_new(sizeof(char *), &xbt_free_ref); @@ -442,6 +423,7 @@ char *xbt_str_join(xbt_dynar_t dyn, const char *sep) } return res; } + /** @brief Join a set of strings as a single string * * The parameter must be a NULL-terminated array of chars, @@ -476,9 +458,7 @@ char *xbt_str_join_array(const char *const *strs, const char *sep) return res; } -/** @brief creates a new string containing what can be read on a fd - * - */ +/** @brief creates a new string containing what can be read on a fd */ char *xbt_str_from_file(FILE * file) { xbt_strbuff_t buff = xbt_strbuff_new(); @@ -514,6 +494,7 @@ long int xbt_str_parse_int(const char* str, const char* error_msg) return res; } + /** @brief Parse a double out of a string, or raise an error * * The #str is passed as argument to your #error_msg, as follows: @@ -553,8 +534,7 @@ XBT_TEST_UNIT("xbt_str_split_quoted", test_split_quoted, "test the function xbt_ mytest("Empty", "", ""); mytest("Basic test", "toto tutu", "totoXXXtutu"); - mytest("Useless backslashes", "\\t\\o\\t\\o \\t\\u\\t\\u", - "totoXXXtutu"); + mytest("Useless backslashes", "\\t\\o\\t\\o \\t\\u\\t\\u", "totoXXXtutu"); mytest("Protected space", "toto\\ tutu", "toto tutu"); mytest("Several spaces", "toto tutu", "totoXXXtutu"); mytest("LTriming", " toto tatu", "totoXXXtatu"); @@ -562,11 +542,8 @@ XBT_TEST_UNIT("xbt_str_split_quoted", test_split_quoted, "test the function xbt_ mytest("Single quotes", "'toto tutu' tata", "toto tutuXXXtata"); mytest("Double quotes", "\"toto tutu\" tata", "toto tutuXXXtata"); mytest("Mixed quotes", "\"toto' 'tutu\" tata", "toto' 'tutuXXXtata"); - mytest("Backslashed quotes", "\\'toto tutu\\' tata", - "'totoXXXtutu'XXXtata"); - mytest("Backslashed quotes + quotes", "'toto \\'tutu' tata", - "toto 'tutuXXXtata"); - + mytest("Backslashed quotes", "\\'toto tutu\\' tata", "'totoXXXtutu'XXXtata"); + mytest("Backslashed quotes + quotes", "'toto \\'tutu' tata", "toto 'tutuXXXtata"); } #define mytest_str(name, input, separator, expected) \ @@ -640,5 +617,4 @@ XBT_TEST_UNIT("xbt_str_parse", test_parse, "Test the parsing functions") test_parse_error(xbt_str_parse_double, "Parse '' as a double", rdouble, ""); test_parse_error(xbt_str_parse_double, "Parse cruft as a double", rdouble, "cruft"); } - #endif /* SIMGRID_TEST */ diff --git a/src/xbt/xbt_strbuff.c b/src/xbt/xbt_strbuff.c index c3247d2118..1d3067c542 100644 --- a/src/xbt/xbt_strbuff.c +++ b/src/xbt/xbt_strbuff.c @@ -12,10 +12,6 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(strbuff, xbt, "String buffers"); -/** -** Buffer code -**/ - inline void xbt_strbuff_empty(xbt_strbuff_t b) { b->used = 0; @@ -85,14 +81,12 @@ void xbt_strbuff_append(xbt_strbuff_t b, const char *toadd) * * If the variable name contains spaces, use the brace version (ie, ${toto tutu}) * - * You can provide a default value to use if the variable is not set in the dict by using - * '${var:=default}' or '${var:-default}'. These two forms are equivalent, even if they - * shouldn't to respect the shell standard (:= form should set the value in the dict, - * but does not) (BUG). + * You can provide a default value to use if the variable is not set in the dict by using '${var:=default}' or + * '${var:-default}'. These two forms are equivalent, even if they shouldn't to respect the shell standard (:= form + * should set the value in the dict, but does not) (BUG). */ void xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns) { - char *end; /* pointers around the parsed chunk */ int in_simple_quote = 0, in_double_quote = 0; int done = 0; @@ -108,7 +102,6 @@ void xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns) end++; xbt_assert(*end != '\0', "String ends with \\"); break; - case '\'': if (!in_double_quote) { /* simple quote not protected by double ones, note it */ @@ -121,7 +114,6 @@ void xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns) in_double_quote = !in_double_quote; } break; - case '$': if (!in_simple_quote) { /* Go for the substitution. First search the variable name */ @@ -131,7 +123,6 @@ void xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns) int val_len; beg_subst = end; - if (*(++end) == '{') { /* the variable name is enclosed in braces. */ beg_var = end + 1; @@ -152,7 +143,6 @@ void xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns) default_value[p - end_var - 2] = '\0'; end_subst = p + 1; /* eat '}' */ - break; } end_var++; @@ -163,14 +153,11 @@ void xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns) end_subst = end_var + 1; /* also kill the } in the name */ xbt_assert(end_var != beg_var, "Variable name empty (${} is not valid)"); - - } else { /* name given directly */ beg_var = end; end_var = beg_var; - while (*end_var != '\0' && *end_var != ' ' && *end_var != '\t' - && *end_var != '\n') + while (*end_var != '\0' && *end_var != ' ' && *end_var != '\t' && *end_var != '\n') end_var++; end_subst = end_var; xbt_assert (end_var != beg_var, "Variable name empty ($ is not valid)"); @@ -191,7 +178,8 @@ void xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns) if (val_len <= end_subst - beg_subst) { /* enough room to do the substitute in place */ memmove(beg_subst, value, val_len); /* substitute */ - memmove(beg_subst + val_len, end_subst, b->used - (end_subst - b->data) + 1); /* move the end of the string closer */ + /* move the end of the string closer */ + memmove(beg_subst + val_len, end_subst, b->used - (end_subst - b->data) + 1); // XBT_DEBUG("String is now: '%s'",b->data); end = beg_subst + val_len; /* update the currently explored char in the overall loop */ // XBT_DEBUG("end of substituted section is now '%s'",end); @@ -202,9 +190,10 @@ void xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns) int tooshort = val_len - (end_subst - beg_subst) + 1 /* don't forget \0 */ ; int newused = b->used + tooshort; end += tooshort; /* update the pointer of the overall loop */ -// XBT_DEBUG("Too short (by %d chars; %d chars left in area)",val_len- (end_subst-beg_subst), b->size - b->used); +// XBT_DEBUG("Too short (by %d chars; %d chars left in area)",val_len-(end_subst-beg_subst),b->size - b->used); if (newused > b->size) { - /* We have to realloc the data area before (because b->size is too small). We have to update our pointers, too */ + /* We have to realloc the data area before (because b->size is too small). + * We have to update our pointers, too */ char *newdata = xbt_realloc(b->data, b->used + MAX(minimal_increment, tooshort)); int offset = newdata - b->data; b->data = newdata; @@ -213,19 +202,17 @@ void xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns) beg_subst += offset; end_subst += offset; } - memmove(beg_subst + val_len, end_subst, b->used - (end_subst - b->data) + 1); /* move the end of the string a bit further */ + /* move the end of the string a bit further */ + memmove(beg_subst + val_len, end_subst, b->used - (end_subst - b->data) + 1); memmove(beg_subst, value, val_len); /* substitute */ b->used = newused; // XBT_DEBUG("String is now: %s",b->data); } free(value); - free(default_value); - end--; /* compensate the next end++ */ } break; - case '\0': done = 1; break; @@ -237,7 +224,8 @@ void xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns) #ifdef SIMGRID_TEST #include "xbt/strbuff.h" -/* buffstr have 512 chars by default. Adding 1000 chars like this will force a resize, allowing us to test that b->used and b->size are consistent */ +/* buffstr have 512 chars by default. Adding 1000 chars like this will force a resize, allowing us to test that + * b->used and b->size are consistent */ #define force_resize \ "1.........1.........2.........3.........4.........5.........6.........7.........8.........9........." \ "2.........1.........2.........3.........4.........5.........6.........7.........8.........9........." \ @@ -250,8 +238,7 @@ void xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns) "9.........1.........2.........3.........4.........5.........6.........7.........8.........9........." \ "0.........1.........2.........3.........4.........5.........6.........7.........8.........9........." -static void mytest(const char *input, const char *patterns, - const char *expected) +static void mytest(const char *input, const char *patterns, const char *expected) { xbt_dynar_t dyn_patterns; /* splited string */ xbt_dict_t p; /* patterns */ @@ -274,8 +261,7 @@ static void mytest(const char *input, const char *patterns, xbt_strbuff_append(sb, input); xbt_strbuff_varsubst(sb, p); xbt_dict_free(&p); - xbt_test_assert(!strcmp(sb->data, expected), - "Input (%s) with patterns (%s) leads to (%s) instead of (%s)", + xbt_test_assert(!strcmp(sb->data, expected), "Input (%s) with patterns (%s) leads to (%s) instead of (%s)", input, patterns, sb->data, expected); xbt_strbuff_free(sb); } @@ -350,8 +336,7 @@ XBT_TEST_UNIT("xbt_strbuff_substitute", test_strbuff_substitute, "test the funct xbt_test_add("Value much longer, no braces, data before and after"); mytest("toto $t tata", "t=" force_resize, "toto " force_resize " tata"); xbt_test_add("Value much longer, braces, data before and after"); - mytest("toto ${t} tata", "t=" force_resize, - "toto " force_resize " tata"); + mytest("toto ${t} tata", "t=" force_resize, "toto " force_resize " tata"); xbt_test_add("Escaped $"); mytest("\\$tutu", "tutu=t", "\\$tutu"); @@ -369,7 +354,5 @@ XBT_TEST_UNIT("xbt_strbuff_substitute", test_strbuff_substitute, "test the funct mytest("${t:-toto}", "", "toto"); xbt_test_add("Useless default value (variable already defined)"); mytest("${t:-toto}", "t=TRUC", "TRUC"); - } - #endif /* SIMGRID_TEST */ diff --git a/src/xbt_modinter.h b/src/xbt_modinter.h index 4d9dfd72c6..988f5f48a5 100644 --- a/src/xbt_modinter.h +++ b/src/xbt_modinter.h @@ -34,7 +34,5 @@ void mmalloc_postexit(void); extern int smx_cleaned; extern int xbt_initialized; - SG_END_DECL() - #endif /* XBT_MODINTER_H */ -- 2.20.1