X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/6760cb07d6b57be16928d95339d71e57c4e24f36..06bbf29ce502b7c0b1969241d6acfffd43de9d2e:/src/gras/DataDesc/ddt_parse.c diff --git a/src/gras/DataDesc/ddt_parse.c b/src/gras/DataDesc/ddt_parse.c index d6e2e82339..d2657a750e 100644 --- a/src/gras/DataDesc/ddt_parse.c +++ b/src/gras/DataDesc/ddt_parse.c @@ -42,61 +42,61 @@ extern char *gras_ddt_parse_text; /* text being considered in the parser * /* local functions */ static void parse_type_modifier(type_modifier_t type_modifier) { - XBT_IN; + XBT_IN(""); do { if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_STAR) { /* This only used when parsing 'short *' since this function returns when int, float, double,... is encountered */ - DEBUG0("This is a reference"); + XBT_DEBUG("This is a reference"); type_modifier->is_ref++; } else if (!strcmp(gras_ddt_parse_text, "unsigned")) { - DEBUG0("This is an unsigned"); + XBT_DEBUG("This is an unsigned"); type_modifier->is_unsigned = 1; } else if (!strcmp(gras_ddt_parse_text, "short")) { - DEBUG0("This is short"); + XBT_DEBUG("This is short"); type_modifier->is_short = 1; } else if (!strcmp(gras_ddt_parse_text, "long")) { - DEBUG0("This is long"); + XBT_DEBUG("This is long"); type_modifier->is_long++; /* handle "long long" */ } else if (!strcmp(gras_ddt_parse_text, "struct")) { - DEBUG0("This is a struct"); + XBT_DEBUG("This is a struct"); type_modifier->is_struct = 1; } else if (!strcmp(gras_ddt_parse_text, "union")) { - DEBUG0("This is an union"); + XBT_DEBUG("This is an union"); type_modifier->is_union = 1; } else if (!strcmp(gras_ddt_parse_text, "enum")) { - DEBUG0("This is an enum"); + XBT_DEBUG("This is an enum"); type_modifier->is_enum = 1; } else if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_EMPTY) { - DEBUG0("Pass space"); + XBT_DEBUG("Pass space"); } else { - DEBUG1("Done with modifiers (got %s)", gras_ddt_parse_text); + XBT_DEBUG("Done with modifiers (got %s)", gras_ddt_parse_text); break; } gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); if ((gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_WORD) && (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_STAR)) { - DEBUG2("Done with modifiers (got %s,%d)", gras_ddt_parse_text, + XBT_DEBUG("Done with modifiers (got %s,%d)", gras_ddt_parse_text, gras_ddt_parse_tok_num); break; } } while (1); - XBT_OUT; + XBT_OUT(); } static void print_type_modifier(s_type_modifier_t tm) { int i; - XBT_IN; + XBT_IN(""); if (tm.is_unsigned) printf("(unsigned) "); if (tm.is_short) @@ -113,7 +113,7 @@ static void print_type_modifier(s_type_modifier_t tm) for (i = 0; i < tm.is_ref; i++) printf("(ref) "); - XBT_OUT; + XBT_OUT(); } static void change_to_fixed_array(xbt_dynar_t dynar, long int size) @@ -121,10 +121,10 @@ static void change_to_fixed_array(xbt_dynar_t dynar, long int size) s_identifier_t former, array; memset(&array, 0, sizeof(array)); - XBT_IN; + XBT_IN(""); xbt_dynar_pop(dynar, &former); array.type_name = (char *) xbt_malloc(strlen(former.type->name) + 48); - DEBUG2("Array specification (size=%ld, elm='%s'), change pushed type", + XBT_DEBUG("Array specification (size=%ld, elm='%s'), change pushed type", size, former.type_name); sprintf(array.type_name, "%s%s%s%s[%ld]", (former.tm.is_unsigned ? "u " : ""), @@ -136,7 +136,7 @@ static void change_to_fixed_array(xbt_dynar_t dynar, long int size) array.name = former.name; xbt_dynar_push(dynar, &array); - XBT_OUT; + XBT_OUT(); } static void change_to_ref(xbt_dynar_t dynar) @@ -144,10 +144,10 @@ static void change_to_ref(xbt_dynar_t dynar) s_identifier_t former, ref; memset(&ref, 0, sizeof(ref)); - XBT_IN; + XBT_IN(""); xbt_dynar_pop(dynar, &former); ref.type_name = (char *) xbt_malloc(strlen(former.type->name) + 2); - DEBUG1("Ref specification (elm='%s'), change pushed type", + XBT_DEBUG("Ref specification (elm='%s'), change pushed type", former.type_name); sprintf(ref.type_name, "%s*", former.type_name); free(former.type_name); @@ -156,7 +156,7 @@ static void change_to_ref(xbt_dynar_t dynar) ref.name = former.name; xbt_dynar_push(dynar, &ref); - XBT_OUT; + XBT_OUT(); } static void change_to_ref_pop_array(xbt_dynar_t dynar) @@ -164,7 +164,7 @@ static void change_to_ref_pop_array(xbt_dynar_t dynar) s_identifier_t former, ref; memset(&ref, 0, sizeof(ref)); - XBT_IN; + XBT_IN(""); xbt_dynar_pop(dynar, &former); ref.type = gras_datadesc_ref_pop_arr(former.type); /* redeclaration are ignored */ ref.type_name = (char *) strdup(ref.type->name); @@ -173,7 +173,7 @@ static void change_to_ref_pop_array(xbt_dynar_t dynar) free(former.type_name); xbt_dynar_push(dynar, &ref); - XBT_OUT; + XBT_OUT(); } static void change_to_dynar_of(xbt_dynar_t dynar, @@ -182,7 +182,7 @@ static void change_to_dynar_of(xbt_dynar_t dynar, s_identifier_t former, ref; memset(&ref, 0, sizeof(ref)); - XBT_IN; + XBT_IN(""); xbt_dynar_pop(dynar, &former); ref.type = gras_datadesc_dynar(subtype, NULL); /* redeclaration are ignored */ ref.type_name = (char *) strdup(ref.type->name); @@ -191,7 +191,7 @@ static void change_to_dynar_of(xbt_dynar_t dynar, free(former.type_name); xbt_dynar_push(dynar, &ref); - XBT_OUT; + XBT_OUT(); } static void change_to_matrix_of(xbt_dynar_t dynar, @@ -200,7 +200,7 @@ static void change_to_matrix_of(xbt_dynar_t dynar, s_identifier_t former, ref; memset(&ref, 0, sizeof(ref)); - XBT_IN; + XBT_IN(""); xbt_dynar_pop(dynar, &former); ref.type = gras_datadesc_matrix(subtype, NULL); /* redeclaration are ignored */ ref.type_name = (char *) strdup(ref.type->name); @@ -209,7 +209,7 @@ static void change_to_matrix_of(xbt_dynar_t dynar, free(former.type_name); xbt_dynar_push(dynar, &ref); - XBT_OUT; + XBT_OUT(); } static void add_free_f(xbt_dynar_t dynar, void_f_pvoid_t free_f) @@ -217,11 +217,11 @@ static void add_free_f(xbt_dynar_t dynar, void_f_pvoid_t free_f) s_identifier_t former, ref; memset(&ref, 0, sizeof(ref)); - XBT_IN; + XBT_IN(""); xbt_dynar_pop(dynar, &former); memcpy(former.type->extra, free_f, sizeof(free_f)); xbt_dynar_push(dynar, &former); - XBT_OUT; + XBT_OUT(); } static void parse_statement(char *definition, @@ -234,13 +234,13 @@ static void parse_statement(char *definition, int expect_id_separator = 0; - XBT_IN; + XBT_IN(""); memset(&identifier, 0, sizeof(identifier)); gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_RA) { - XBT_OUT; - THROW0(mismatch_error, 0, "End of the englobing structure or union"); + XBT_OUT(); + THROWF(mismatch_error, 0, "End of the englobing structure or union"); } if (XBT_LOG_ISENABLED(gras_ddt_parse, xbt_log_priority_debug)) { @@ -248,16 +248,16 @@ static void parse_statement(char *definition, for (colon_pos = gras_ddt_parse_col_pos; definition[colon_pos] != ';'; colon_pos++); definition[colon_pos] = '\0'; - DEBUG3("Parse the statement \"%s%s;\" (col_pos=%d)", + XBT_DEBUG("Parse the statement \"%s%s;\" (col_pos=%d)", gras_ddt_parse_text, definition + gras_ddt_parse_col_pos, gras_ddt_parse_col_pos); definition[colon_pos] = ';'; } if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_WORD) - PARSE_ERROR1 - ("Unparsable symbol: found a typeless statement (got '%s' instead)", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparsable symbol: found a typeless statement (got '%s' instead)", + gras_ddt_parse_text); /**** get the type modifier of this statement ****/ parse_type_modifier(&identifier.tm); @@ -265,8 +265,8 @@ static void parse_statement(char *definition, /* FIXME: This does not detect recursive definitions at all? */ if (identifier.tm.is_union || identifier.tm.is_enum || identifier.tm.is_struct) - PARSE_ERROR0 - ("Unimplemented feature: GRAS_DEFINE_TYPE cannot handle recursive type definition yet"); + PARSE_ERROR + ("Unimplemented feature: GRAS_DEFINE_TYPE cannot handle recursive type definition yet"); /**** get the base type, giving "short a" the needed love ****/ if (!identifier.tm.is_union && @@ -280,21 +280,21 @@ static void parse_statement(char *definition, /* bastard user, they omited "int" ! */ identifier.type_name = (char *) strdup("int"); - DEBUG0("the base type is 'int', which were omited (you vicious user)"); + XBT_DEBUG("the base type is 'int', which were omited (you vicious user)"); } else { identifier.type_name = (char *) strdup(gras_ddt_parse_text); - DEBUG1("the base type is '%s'", identifier.type_name); + XBT_DEBUG("the base type is '%s'", identifier.type_name); gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); } /**** build the base type for latter use ****/ if (identifier.tm.is_union) { - PARSE_ERROR0 - ("Unimplemented feature: GRAS_DEFINE_TYPE cannot handle union yet (get callback from annotation?)"); + PARSE_ERROR + ("Unimplemented feature: GRAS_DEFINE_TYPE cannot handle union yet (get callback from annotation?)"); } else if (identifier.tm.is_enum) { - PARSE_ERROR0 - ("Unimplemented feature: GRAS_DEFINE_TYPE cannot handle enum yet"); + PARSE_ERROR + ("Unimplemented feature: GRAS_DEFINE_TYPE cannot handle enum yet"); } else if (identifier.tm.is_struct) { sprintf(buffname, "struct %s", identifier.type_name); @@ -325,7 +325,7 @@ static void parse_statement(char *definition, } else if (!strcmp(identifier.type_name, "double")) { if (identifier.tm.is_long) - PARSE_ERROR0("long double not portable and thus not handled"); + PARSE_ERROR("long double not portable and thus not handled"); identifier.type = gras_datadesc_by_name("double"); @@ -345,7 +345,7 @@ static void parse_statement(char *definition, identifier.type = gras_datadesc_by_name("char"); } else { - DEBUG1("Base type is a constructed one (%s)", identifier.type_name); + XBT_DEBUG("Base type is a constructed one (%s)", identifier.type_name); if (!strcmp(identifier.type_name, "xbt_matrix_t")) { identifier.tm.is_matrix = 1; } else if (!strcmp(identifier.type_name, "xbt_dynar_t")) { @@ -353,7 +353,7 @@ static void parse_statement(char *definition, } else { identifier.type = gras_datadesc_by_name(identifier.type_name); if (!identifier.type) - PARSE_ERROR1("Unknown base type '%s'", identifier.type_name); + PARSE_ERROR("Unknown base type '%s'", identifier.type_name); } } } @@ -379,8 +379,8 @@ static void parse_statement(char *definition, /* Handle fixed size arrays */ gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_RB) { - PARSE_ERROR0 - ("Unimplemented feature: GRAS_DEFINE_TYPE cannot deal with [] constructs (yet)"); + PARSE_ERROR + ("Unimplemented feature: GRAS_DEFINE_TYPE cannot deal with [] constructs (yet)"); } else if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_WORD) { char *end; @@ -388,14 +388,14 @@ static void parse_statement(char *definition, if (end == gras_ddt_parse_text || *end != '\0') { /* Not a number. Get the constant value, if any */ - int *storage = - xbt_dict_get_or_null(gras_dd_constants, gras_ddt_parse_text); + int *storage = xbt_dict_get_or_null(gras_dd_constants, + gras_ddt_parse_text); if (storage) { size = *storage; } else { - PARSE_ERROR1 - ("Unparsable size of array. Found '%s', expected number or known constant. Need to use gras_datadesc_set_const(), huh?", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparsable size of array. Found '%s', expected number or known constant. Need to use gras_datadesc_set_const(), huh?", + gras_ddt_parse_text); } } @@ -405,11 +405,11 @@ static void parse_statement(char *definition, /* eat the closing bracket */ gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_RB) - PARSE_ERROR0("Unparsable size of array"); - DEBUG1("Fixed size array, size=%ld", size); + PARSE_ERROR("Unparsable size of array"); + XBT_DEBUG("Fixed size array, size=%ld", size); continue; } else { - PARSE_ERROR0("Unparsable size of array"); + PARSE_ERROR("Unparsable size of array"); } /* End of fixed size arrays handling */ @@ -420,51 +420,58 @@ static void parse_statement(char *definition, char *keyval = NULL; memset(&array, 0, sizeof(array)); if (strcmp(gras_ddt_parse_text, "GRAS_ANNOTE")) - PARSE_ERROR1("Unparsable symbol: Expected 'GRAS_ANNOTE', got '%s'", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparsable symbol: Expected 'GRAS_ANNOTE', got '%s'", + gras_ddt_parse_text); gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_LP) - PARSE_ERROR1 - ("Unparsable annotation: Expected parenthesis, got '%s'", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparsable annotation: Expected parenthesis, got '%s'", + gras_ddt_parse_text); while ((gras_ddt_parse_tok_num = - gras_ddt_parse_lex_n_dump()) == GRAS_DDT_PARSE_TOKEN_EMPTY); + gras_ddt_parse_lex_n_dump()) == + GRAS_DDT_PARSE_TOKEN_EMPTY); if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_WORD) - PARSE_ERROR1("Unparsable annotation: Expected key name, got '%s'", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparsable annotation: Expected key name, got '%s'", + gras_ddt_parse_text); keyname = (char *) strdup(gras_ddt_parse_text); while ((gras_ddt_parse_tok_num = - gras_ddt_parse_lex_n_dump()) == GRAS_DDT_PARSE_TOKEN_EMPTY); + gras_ddt_parse_lex_n_dump()) == + GRAS_DDT_PARSE_TOKEN_EMPTY); if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_COLON) - PARSE_ERROR1 - ("Unparsable annotation: expected ',' after the key name, got '%s'", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparsable annotation: expected ',' after the key name, got '%s'", + gras_ddt_parse_text); while ((gras_ddt_parse_tok_num = - gras_ddt_parse_lex_n_dump()) == GRAS_DDT_PARSE_TOKEN_EMPTY); + gras_ddt_parse_lex_n_dump()) == + GRAS_DDT_PARSE_TOKEN_EMPTY); /* get the value */ if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_WORD) - PARSE_ERROR1("Unparsable annotation: Expected key value, got '%s'", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparsable annotation: Expected key value, got '%s'", + gras_ddt_parse_text); keyval = (char *) strdup(gras_ddt_parse_text); while ((gras_ddt_parse_tok_num = - gras_ddt_parse_lex_n_dump()) == GRAS_DDT_PARSE_TOKEN_EMPTY); + gras_ddt_parse_lex_n_dump()) == + GRAS_DDT_PARSE_TOKEN_EMPTY); /* Done with parsing the annotation. Now deal with it by replacing previously pushed type with the right one */ - DEBUG2("Anotation: %s=%s", keyname, keyval); + XBT_DEBUG("Anotation: %s=%s", keyname, keyval); if (!strcmp(keyname, "size")) { - free(keyname); if (!identifier.tm.is_ref) - PARSE_ERROR0("Size annotation for a field not being a reference"); + PARSE_ERROR + ("Size annotation for a field not being a reference"); identifier.tm.is_ref--; if (!strcmp(keyval, "1")) { @@ -495,17 +502,17 @@ static void parse_statement(char *definition, change_to_dynar_of(identifiers, subtype); identifier.tm.is_dynar = -1; } else { - PARSE_ERROR1 - ("subtype annotation only accepted for dynars and matrices, but passed to '%s'", - identifier.type_name); + PARSE_ERROR + ("subtype annotation only accepted for dynars and matrices, but passed to '%s'", + identifier.type_name); } free(keyval); } else if (!strcmp(keyname, "free_f")) { int *storage = xbt_dict_get_or_null(gras_dd_constants, keyval); if (!storage) - PARSE_ERROR1 - ("value for free_f annotation of field %s is not a known constant", - identifier.name); + PARSE_ERROR + ("value for free_f annotation of field %s is not a known constant", + identifier.name); if (identifier.tm.is_matrix == -1) { add_free_f(identifiers, *(void_f_pvoid_t *) storage); identifier.tm.is_matrix = 0; @@ -513,15 +520,16 @@ static void parse_statement(char *definition, add_free_f(identifiers, *(void_f_pvoid_t *) storage); identifier.tm.is_dynar = 0; } else { - PARSE_ERROR1 - ("free_f annotation only accepted for dynars and matrices which subtype is already declared (field %s)", - identifier.name); + PARSE_ERROR + ("free_f annotation only accepted for dynars and matrices which subtype is already declared (field %s)", + identifier.name); } free(keyval); } else { free(keyval); - PARSE_ERROR1("Unknown annotation type: '%s'", keyname); + PARSE_ERROR("Unknown annotation type: '%s'", keyname); } + free(keyname); /* Get all the multipliers */ while (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_STAR) { @@ -529,9 +537,9 @@ static void parse_statement(char *definition, gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_WORD) - PARSE_ERROR1 - ("Unparsable annotation: Expected field name after '*', got '%s'", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparsable annotation: Expected field name after '*', got '%s'", + gras_ddt_parse_text); keyval = xbt_malloc(strlen(gras_ddt_parse_text) + 2); sprintf(keyval, "*%s", gras_ddt_parse_text); @@ -545,20 +553,20 @@ static void parse_statement(char *definition, } if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_RP) - PARSE_ERROR1 - ("Unparsable annotation: Expected parenthesis, got '%s'", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparsable annotation: Expected parenthesis, got '%s'", + gras_ddt_parse_text); continue; /* End of annotation handling */ } else { - PARSE_ERROR1 - ("Unparsable symbol: Got '%s' instead of expected comma (',')", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparsable symbol: Got '%s' instead of expected comma (',')", + gras_ddt_parse_text); } } else if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_COLON) { - PARSE_ERROR0("Unparsable symbol: Unexpected comma (',')"); + PARSE_ERROR("Unparsable symbol: Unexpected comma (',')"); } if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_STAR) { @@ -570,24 +578,24 @@ static void parse_statement(char *definition, if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_WORD) { identifier.name = (char *) strdup(gras_ddt_parse_text); - DEBUG1("Found the identifier \"%s\"", identifier.name); + XBT_DEBUG("Found the identifier \"%s\"", identifier.name); xbt_dynar_push(identifiers, &identifier); - DEBUG1("Dynar_len=%lu", xbt_dynar_length(identifiers)); + XBT_DEBUG("Dynar_len=%lu", xbt_dynar_length(identifiers)); expect_id_separator = 1; continue; } - PARSE_ERROR0 - ("Unparasable symbol (maybe a def struct in a def struct or a parser bug ;)"); + PARSE_ERROR + ("Unparasable symbol (maybe a def struct in a def struct or a parser bug ;)"); } if (identifier.tm.is_matrix > 0) - PARSE_ERROR0("xbt_matrix_t field without 'subtype' annotation"); + PARSE_ERROR("xbt_matrix_t field without 'subtype' annotation"); if (identifier.tm.is_dynar > 0) - PARSE_ERROR0("xbt_dynar_t field without 'subtype' annotation"); + PARSE_ERROR("xbt_dynar_t field without 'subtype' annotation"); - XBT_OUT; + XBT_OUT(); } static gras_datadesc_type_t parse_struct(char *definition) @@ -608,25 +616,25 @@ static gras_datadesc_type_t parse_struct(char *definition) gras_datadesc_type_t struct_type; - XBT_IN; + XBT_IN(""); identifiers = xbt_dynar_new(sizeof(s_identifier_t), NULL); fields_to_push = xbt_dynar_new(sizeof(char *), NULL); /* Create the struct descriptor */ if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_WORD) { struct_type = gras_datadesc_struct(gras_ddt_parse_text); - VERB1("Parse the struct '%s'", gras_ddt_parse_text); + XBT_VERB("Parse the struct '%s'", gras_ddt_parse_text); gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); } else { sprintf(buffname, "anonymous struct %d", anonymous_struct++); - VERB1("Parse the anonymous struct nb %d", anonymous_struct); + XBT_VERB("Parse the anonymous struct nb %d", anonymous_struct); struct_type = gras_datadesc_struct(buffname); } if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_LA) - PARSE_ERROR1 - ("Unparasable symbol: Expecting struct definition, but got %s instead of '{'", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparasable symbol: Expecting struct definition, but got %s instead of '{'", + gras_ddt_parse_text); /* Parse the identifiers */ done = 0; @@ -641,33 +649,33 @@ static gras_datadesc_type_t parse_struct(char *definition) done = 1; } - DEBUG1("This statement contained %lu identifiers", + XBT_DEBUG("This statement contained %lu identifiers", xbt_dynar_length(identifiers)); /* append the identifiers we've found */ xbt_dynar_foreach(identifiers, iter, field) { if (field.tm.is_ref) - PARSE_ERROR2 - ("Not enough GRAS_ANNOTATE to deal with all dereferencing levels of %s (%d '*' left)", - field.name, field.tm.is_ref); + PARSE_ERROR + ("Not enough GRAS_ANNOTATE to deal with all dereferencing levels of %s (%d '*' left)", + field.name, field.tm.is_ref); - VERB2("Append field '%s' to %p", field.name, (void *) struct_type); + XBT_VERB("Append field '%s' to %p", field.name, (void *) struct_type); gras_datadesc_struct_append(struct_type, field.name, field.type); free(field.name); free(field.type_name); } xbt_dynar_reset(identifiers); - DEBUG1("struct_type=%p", (void *) struct_type); + XBT_DEBUG("struct_type=%p", (void *) struct_type); /* Make sure that all fields declaring a size push it into the cbps */ xbt_dynar_foreach(fields_to_push, iter, name) { - DEBUG1("struct_type=%p", (void *) struct_type); + XBT_DEBUG("struct_type=%p", (void *) struct_type); if (name[0] == '*') { - VERB2("Push field '%s' as a multiplier into size stack of %p", + XBT_VERB("Push field '%s' as a multiplier into size stack of %p", name + 1, (void *) struct_type); gras_datadesc_cb_field_push_multiplier(struct_type, name + 1); } else { - VERB2("Push field '%s' into size stack of %p", + XBT_VERB("Push field '%s' into size stack of %p", name, (void *) struct_type); gras_datadesc_cb_field_push(struct_type, name); } @@ -679,15 +687,15 @@ static gras_datadesc_type_t parse_struct(char *definition) /* terminates */ if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_RA) - PARSE_ERROR1 - ("Unparasable symbol: Expected '}' at the end of struct definition, got '%s'", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparasable symbol: Expected '}' at the end of struct definition, got '%s'", + gras_ddt_parse_text); gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); xbt_dynar_free(&identifiers); xbt_dynar_free(&fields_to_push); - XBT_OUT; + XBT_OUT(); return struct_type; } @@ -696,35 +704,35 @@ static gras_datadesc_type_t parse_typedef(char *definition) s_type_modifier_t tm; - gras_datadesc_type_t struct_desc = NULL; gras_datadesc_type_t typedef_desc = NULL; - XBT_IN; + XBT_IN(""); memset(&tm, 0, sizeof(tm)); /* get the aliased type */ parse_type_modifier(&tm); if (tm.is_struct) { - struct_desc = parse_struct(definition); + parse_struct(definition); } parse_type_modifier(&tm); if (tm.is_ref) - PARSE_ERROR0 - ("GRAS_DEFINE_TYPE cannot handle reference without annotation"); + PARSE_ERROR + ("GRAS_DEFINE_TYPE cannot handle reference without annotation"); /* get the aliasing name */ if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_WORD) - PARSE_ERROR1("Unparsable typedef: Expected the alias name, and got '%s'", - gras_ddt_parse_text); + PARSE_ERROR + ("Unparsable typedef: Expected the alias name, and got '%s'", + gras_ddt_parse_text); /* (FIXME: should) build the alias */ - PARSE_ERROR0 - ("Unimplemented feature: GRAS_DEFINE_TYPE cannot handle typedef yet"); + PARSE_ERROR + ("Unimplemented feature: GRAS_DEFINE_TYPE cannot handle typedef yet"); - XBT_OUT; + XBT_OUT(); return typedef_desc; } @@ -743,7 +751,7 @@ gras_datadesc_parse(const char *name, const char *C_statement) int semicolon_count = 0; int def_count, C_count; - XBT_IN; + XBT_IN(""); /* reput the \n in place for debug */ for (C_count = 0; C_statement[C_count] != '\0'; C_count++) if (C_statement[C_count] == ';' || C_statement[C_count] == '{') @@ -758,7 +766,7 @@ gras_datadesc_parse(const char *name, const char *C_statement) definition[def_count] = '\0'; /* init */ - VERB2("_gras_ddt_type_parse(%s) -> %d chars", definition, def_count); + XBT_VERB("_gras_ddt_type_parse(%s) -> %d chars", definition, def_count); gras_ddt_parse_pointer_string_init(definition); /* Do I have a typedef, or a raw struct ? */ @@ -775,24 +783,24 @@ gras_datadesc_parse(const char *name, const char *C_statement) res = parse_typedef(definition); } else { - ERROR1 - ("Failed to parse the following symbol (not a struct neither a typedef) :\n%s", - definition); + XBT_ERROR + ("Failed to parse the following symbol (not a struct neither a typedef) :\n%s", + definition); xbt_abort(); } gras_ddt_parse_pointer_string_close(); - VERB0("end of _gras_ddt_type_parse()"); + XBT_VERB("end of _gras_ddt_type_parse()"); free(definition); /* register it under the name provided as symbol */ if (strcmp(res->name, name)) { - ERROR2 - ("In GRAS_DEFINE_TYPE, the provided symbol (here %s) must be the C type name (here %s)", - name, res->name); + XBT_ERROR + ("In GRAS_DEFINE_TYPE, the provided symbol (here %s) must be the C type name (here %s)", + name, res->name); xbt_abort(); } gras_ddt_parse_lex_destroy(); - XBT_OUT; + XBT_OUT(); return res; }