X-Git-Url: https://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=tools%2Fccanlint%2Ftests%2Fexamples_compile.c;h=746b47f9a3519ca16ac3ea742bf0057b52d7cc67;hp=529c526f09f1152b12a28e61977d07c559a3cfe8;hb=70539048ba95b1bc7ade71dad4ed99d2d34638cc;hpb=aba65f26a9cbc9b9cb3eb493731f83bca487d67f diff --git a/tools/ccanlint/tests/examples_compile.c b/tools/ccanlint/tests/examples_compile.c index 529c526f..746b47f9 100644 --- a/tools/ccanlint/tests/examples_compile.c +++ b/tools/ccanlint/tests/examples_compile.c @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -8,18 +9,69 @@ #include #include #include +#include static const char *can_run(struct manifest *m) { if (safe_mode) return "Safe mode enabled"; + if (list_empty(&m->examples)) + return "No examples to compile"; return NULL; } -static char *obj_list(const struct manifest *m) +/* FIXME: We should build if it doesn't exist... */ +static bool expect_obj_file(const char *dir) +{ + struct manifest *dep_man; + bool has_c_files; + + dep_man = get_manifest(dir, dir); + + /* If it has C files, we expect an object file built from them. */ + has_c_files = !list_empty(&dep_man->c_files); + talloc_free(dep_man); + return has_c_files; +} + +static char *add_dep(const struct manifest *m, char *list, const char *mod) +{ + char **deps, *obj; + unsigned int i; + + /* Not ourselves. */ + if (streq(m->basename, mod)) + return list; + + /* Not if there's no object file for that module */ + if (!expect_obj_file(talloc_asprintf(list, "%s/ccan/%s", ccan_dir,mod))) + return list; + + obj = talloc_asprintf(list, "%s/ccan/%s.o", ccan_dir, mod); + + /* Not anyone we've already included. */ + if (strstr(list, obj)) + return list; + + list = talloc_asprintf_append(list, " %s", obj); + + /* Get that modules depends as well... */ + assert(!safe_mode); + deps = get_deps(m, talloc_asprintf(list, "%s/ccan/%s", ccan_dir, mod), + false, NULL); + + for (i = 0; deps[i]; i++) { + if (strstarts(deps[i], "ccan/")) + list = add_dep(m, list, deps[i] + strlen("ccan/")); + } + return list; +} + +static char *obj_list(const struct manifest *m, struct ccan_file *f) { char *list = talloc_strdup(m, ""); struct ccan_file *i; + char **lines; /* Object files for this module. */ list_for_each(&m->c_files, i, list) @@ -31,6 +83,20 @@ static char *obj_list(const struct manifest *m) list = talloc_asprintf_append(list, " %s", i->compiled); } + /* Other modules implied by includes. */ + for (lines = get_ccan_file_lines(f); *lines; lines++) { + unsigned preflen = strspn(*lines, " \t"); + if (strstarts(*lines + preflen, "#include compiled = maybe_temp_file(ctx, "", keep, file->fullname); errmsg = compile_and_link(ctx, file->fullname, ccan_dir, - obj_list(m), "", lib_list(m), file->compiled); + obj_list(m, file), + "", lib_list(m), file->compiled); if (errmsg) { talloc_free(file->compiled); + file->compiled = NULL; return errmsg; } return NULL; } -struct score { - unsigned int score; - char *errors; -}; - -static char *start_main(char *ret) +static char *start_main(char *ret, const char *why) { return talloc_asprintf_append(ret, - "/* Fake function wrapper inserted */\n" - "int main(int argc, char *argv[])\n" - "{\n"); + "/* The example %s, so fake function wrapper inserted */\n" + "int main(int argc, char *argv[])\n" + "{\n", why); } /* We only handle simple function definitions here. */ static char *add_func(char *others, const char *line) { const char *p, *end = strchr(line, '(') - 1; - while (isblank(*end)) { + while (isspace(*end)) { end--; if (end == line) return others; @@ -91,49 +154,126 @@ static char *add_func(char *others, const char *line) } return talloc_asprintf_append(others, "printf(\"%%p\", %.*s);\n", - end - p + 1, p); + (unsigned)(end - p + 1), p); } -static bool looks_internal(const char *p) +static void strip_leading_whitespace(char **lines) { - return (strncmp(p, "#", 1) != 0 - && strncmp(p, "static", 6) != 0 - && strncmp(p, "struct", 6) != 0 - && strncmp(p, "union", 5) != 0); + unsigned int i, min_span = -1U; + + for (i = 0; lines[i]; i++) { + unsigned int span = strspn(lines[i], " \t"); + /* All whitespace? Ignore */ + if (!lines[i][span]) + continue; + if (span < min_span) + min_span = span; + } + + for (i = 0; lines[i]; i++) + if (strlen(lines[i]) >= min_span) + lines[i] += min_span; } -static void strip_leading_whitespace(char **lines, unsigned prefix_len) +static bool looks_internal(char **lines, char **why) { unsigned int i; + bool last_ended = true; /* Did last line finish a statement? */ - for (i = 0; lines[i]; i++) - if (strlen(lines[i]) >= prefix_len) - lines[i] += prefix_len; + for (i = 0; lines[i]; i++) { + /* Skip leading whitespace. */ + const char *line = lines[i] + strspn(lines[i], " \t"); + unsigned len = strspn(line, IDENT_CHARS); + + if (!line[0] || isspace(line[0]) || strstarts(line, "//")) + continue; + + /* The winners. */ + if (strstarts(line, "if") && len == 2) { + *why = "starts with if"; + return true; + } + if (strstarts(line, "for") && len == 3) { + *why = "starts with for"; + return true; + } + if (strstarts(line, "while") && len == 5) { + *why = "starts with while"; + return true; + } + if (strstarts(line, "do") && len == 2) { + *why = "starts with do"; + return true; + } + + /* The losers. */ + if (strstarts(line, "#include")) { + *why = "starts with #include"; + return false; + } + + if (last_ended && strchr(line, '(')) { + if (strstarts(line, "static")) { + *why = "starts with static and contains ("; + return false; + } + if (strends(line, ")")) { + *why = "contains ( and ends with )"; + return false; + } + } + + /* Single identifier then operator == inside function. */ + if (last_ended && len + && ispunct(line[len+strspn(line+len, " ")])) { + *why = "starts with identifier then punctuation"; + return true; + } + + last_ended = (strends(line, "}") + || strends(line, ";") + || streq(line, "...")); + } + + /* No idea... Say yes? */ + *why = "gave no clues"; + return true; } /* Examples will often build on prior ones. Try combining them. */ -static char **combine(char **lines, char **prev) +static char **combine(const void *ctx, char **lines, char **prev) { unsigned int i, lines_total, prev_total, count; char **ret; + const char *reasoning; + char *why = NULL; if (!prev) return NULL; /* If it looks internal, put prev at start. */ - if (lines[0] - && isblank(lines[0][0]) - && looks_internal(lines[0] + strspn(lines[0], " \t"))) { + if (looks_internal(lines, &why)) { count = 0; + reasoning = "seemed to belong inside a function"; } else { /* Try inserting in first elided position */ for (count = 0; lines[count]; count++) { if (strcmp(lines[count], "...") == 0) break; } - if (!lines[count]) - return NULL; - count++; + if (!lines[count]) { + /* Try at start anyway? */ + count = 0; + reasoning = "didn't seem to belong inside" + " a function, so we prepended the previous" + " example"; + } else { + reasoning = "didn't seem to belong inside" + " a function, so we put the previous example" + " at the first ..."; + + count++; + } } for (i = 0; lines[i]; i++); @@ -142,24 +282,28 @@ static char **combine(char **lines, char **prev) for (i = 0; prev[i]; i++); prev_total = i; - ret = talloc_array(lines, char *, lines_total + prev_total + 1); - memcpy(ret, lines, count * sizeof(ret[0])); - memcpy(ret + count, prev, prev_total * sizeof(ret[0])); - memcpy(ret + count + prev_total, lines + count, + ret = talloc_array(ctx, char *, 1 +lines_total + prev_total + 1); + ret[0] = talloc_asprintf(ret, "/* The example %s, thus %s */\n", + why, reasoning); + memcpy(ret+1, lines, count * sizeof(ret[0])); + memcpy(ret+1 + count, prev, prev_total * sizeof(ret[0])); + memcpy(ret+1 + count + prev_total, lines + count, (lines_total - count + 1) * sizeof(ret[0])); return ret; } static char *mangle(struct manifest *m, char **lines) { - char *ret, *use_funcs = NULL; + char *ret, *use_funcs = NULL, *why; bool in_function = false, fake_function = false, has_main = false; unsigned int i; ret = talloc_strdup(m, "/* Prepend a heap of headers. */\n" "#include \n" "#include \n" + "#include \n" "#include \n" + "#include \n" "#include \n" "#include \n" "#include \n" @@ -173,21 +317,21 @@ static char *mangle(struct manifest *m, char **lines) m->basename, m->basename); ret = talloc_asprintf_append(ret, "/* Useful dummy functions. */\n" - "int somefunc(void);\n" - "int somefunc(void) { return 0; }\n"); - - /* Starts indented? */ - if (lines[0] && isblank(lines[0][0])) { - unsigned prefix = strspn(lines[0], " \t"); - if (looks_internal(lines[0] + prefix)) { - /* Wrap it all in main(). */ - ret = start_main(ret); - fake_function = true; - in_function = true; - has_main = true; - } else - strip_leading_whitespace(lines, prefix); - } + "extern int somefunc(void);\n" + "int somefunc(void) { return 0; }\n" + "extern char somestring[];\n" + "char somestring[] = \"hello world\";\n"); + + if (looks_internal(lines, &why)) { + /* Wrap it all in main(). */ + ret = start_main(ret, why); + fake_function = true; + in_function = true; + has_main = true; + } else + ret = talloc_asprintf_append(ret, + "/* The example %s, so didn't wrap in main() */\n", + why); /* Primitive, very primitive. */ for (i = 0; lines[i]; i++) { @@ -197,10 +341,11 @@ static char *mangle(struct manifest *m, char **lines) in_function = false; } else { /* Character at start of line, with ( and no ; - * == function start. */ - if (!isblank(lines[i][0]) + * == function start. Ignore comments. */ + if (!isspace(lines[i][0]) && strchr(lines[i], '(') - && !strchr(lines[i], ';')) { + && !strchr(lines[i], ';') + && !strstr(lines[i], "//")) { in_function = true; if (strncmp(lines[i], "int main", 8) == 0) has_main = true; @@ -210,14 +355,12 @@ static char *mangle(struct manifest *m, char **lines) } } } - /* ... means elided code. If followed by spaced line, means - * next part is supposed to be inside a function. */ + /* ... means elided code. */ if (strcmp(lines[i], "...") == 0) { - if (!in_function - && lines[i+1] - && isblank(lines[i+1][0])) { + if (!in_function && !has_main + && looks_internal(lines + i + 1, &why)) { /* This implies we start a function here. */ - ret = start_main(ret); + ret = start_main(ret, why); has_main = true; fake_function = true; in_function = true; @@ -229,14 +372,18 @@ static char *mangle(struct manifest *m, char **lines) ret = talloc_asprintf_append(ret, "%s\n", lines[i]); } - /* Need a main to link successfully. */ if (!has_main) { - ret = talloc_asprintf_append(ret, "int main(void)\n{\n"); + ret = talloc_asprintf_append(ret, + "/* Need a main to link successfully. */\n" + "int main(void)\n{\n"); fake_function = true; } - /* Get rid of unused warnings by printing addresses of static funcs. */ if (use_funcs) { + ret = talloc_asprintf_append(ret, + "/* Get rid of unused warnings" + " by printing addresses of" + " static funcs. */"); if (!fake_function) { ret = talloc_asprintf_append(ret, "int use_funcs(void);\n" @@ -279,93 +426,119 @@ static struct ccan_file *mangle_example(struct manifest *m, return NULL; } close(fd); + f->contents = talloc_steal(f, contents); + list_add(&m->mangled_examples, &f->list); return f; } -static void *build_examples(struct manifest *m, bool keep, - unsigned int *timeleft) +/* If an example has expected output, it's complete and should not be + * included in future examples. */ +static bool has_expected_output(char **lines) +{ + unsigned int i; + + for (i = 0; lines[i]; i++) { + char *p = lines[i] + strspn(lines[i], " \t"); + if (!strstarts(p, "//")) + continue; + p += strspn(p, "/ "); + if (strncasecmp(p, "given", strlen("given")) == 0) + return true; + } + return false; +} + +static void build_examples(struct manifest *m, bool keep, + unsigned int *timeleft, struct score *score) { struct ccan_file *i; - struct score *score = talloc(m, struct score); - struct ccan_file *mangle; char **prev = NULL; - score->score = 0; - score->errors = NULL; + score->total = 0; + score->pass = true; list_for_each(&m->examples, i, list) { - char *ret; - - examples_compile.total_score++; - ret = compile(score, m, i, keep); - if (!ret) { - prev = get_ccan_file_lines(i); - score->score++; - continue; - } - - talloc_free(ret); - mangle = mangle_example(m, i, get_ccan_file_lines(i), keep); - ret = compile(score, m, mangle, keep); + char *ret, *ret1, *ret2 = NULL; + struct ccan_file *mangle1, *mangle2 = NULL; + char *err; + + score->total++; + /* Simplify our dumb parsing. */ + strip_leading_whitespace(get_ccan_file_lines(i)); + ret = compile(i, m, i, keep); if (!ret) { - prev = get_ccan_file_lines(i); + char **lines = get_ccan_file_lines(i); + if (!has_expected_output(lines)) + prev = lines; score->score++; continue; } - /* Try combining with previous (successful) example... */ - prev = combine(get_ccan_file_lines(i), prev); if (prev) { - talloc_free(ret); - - /* We're going to replace this failure. */ - if (keep) - unlink(mangle->fullname); - talloc_free(mangle); + char **new = combine(i, get_ccan_file_lines(i), prev); - mangle = mangle_example(m, i, prev, keep); - ret = compile(score, m, mangle, keep); - if (!ret) { + mangle2 = mangle_example(m, i, new, keep); + ret2 = compile(i, m, mangle2, keep); + if (!ret2) { + if (!has_expected_output(new)) + prev = new; score->score++; continue; } } - if (!score->errors) - score->errors = ret; - else { - score->errors = talloc_append_string(score->errors, - ret); - talloc_free(ret); + /* Try standalone. */ + mangle1 = mangle_example(m, i, get_ccan_file_lines(i), keep); + ret1 = compile(i, m, mangle1, keep); + if (!ret1) { + char **lines = get_ccan_file_lines(i); + if (!has_expected_output(lines)) + prev = lines; + score->score++; + continue; + } + + score->pass = false; + score->error = "Compiling extracted examples failed"; + if (!verbose) { + if (mangle2) + err = "Standalone, adding headers, " + "and including previous " + "example all failed"; + else + err = "Standalone compile and" + " adding headers both failed"; + } else { + err = talloc_asprintf(score, + "Standalone example:\n" + "%s\n" + "Errors: %s\n\n" + "Adding headers, wrappers:\n" + "%s\n" + "Errors: %s\n\n", + get_ccan_file_contents(i), + ret, + get_ccan_file_contents(mangle1), + ret1); + + if (mangle2) + err = talloc_asprintf_append(err, + "Combining with previous example:\n" + "%s\n" + "Errors: %s\n\n", + get_ccan_file_contents(mangle2), + ret2); } + score_file_error(score, i, 0, err); /* This didn't work, so not a candidate for combining. */ - talloc_free(prev); prev = NULL; } - return score; -} - -static unsigned int score_examples(struct manifest *m, void *check_result) -{ - struct score *score = check_result; - return score->score; -} - -static const char *describe(struct manifest *m, void *check_result) -{ - struct score *score = check_result; - if (verbose >= 2 && score->errors) - return talloc_asprintf(m, "Compile errors building examples:\n" - "%s", score->errors); - return NULL; } struct ccanlint examples_compile = { .key = "examples-compile", .name = "Module examples compile", - .score = score_examples, .check = build_examples, - .describe = describe, .can_run = can_run, };