X-Git-Url: http://git.ozlabs.org/?a=blobdiff_plain;f=tools%2Fccanlint%2Ftests%2Fexamples_compile.c;h=0f3dd0cd4bf76997417e0bc734b77f90897d3ebc;hb=b1801a00c945b67d8c218edd9e13dc483a60ac70;hp=7e1f14f3088ab55ab605e1a1262d8d7d8f58875d;hpb=f24a8d30f5b6b8c0e642a357e4dae6f9277d041f;p=ccan diff --git a/tools/ccanlint/tests/examples_compile.c b/tools/ccanlint/tests/examples_compile.c index 7e1f14f3..0f3dd0cd 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,6 +9,7 @@ #include #include #include +#include static const char *can_run(struct manifest *m) { @@ -16,10 +18,54 @@ static const char *can_run(struct manifest *m) 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) { - char *list; + 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 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 +77,23 @@ 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 basename, mod)) + continue; + list = add_dep(m, list, mod); + } + } + return list; } @@ -54,7 +117,8 @@ static char *compile(const void *ctx, file->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); return errmsg; @@ -75,17 +139,126 @@ static char *start_main(char *ret) "{\n"); } -static char *mangle(struct manifest *m, struct ccan_file *example) +/* 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)) { + end--; + if (end == line) + return others; + } + + for (p = end; isalnum(*p) || *p == '_'; p--) { + if (p == line) + return others; + } + + return talloc_asprintf_append(others, "printf(\"%%p\", %.*s);\n", + end - p + 1, p); +} + +static void strip_leading_whitespace(char **lines) +{ + 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 bool looks_internal(char **lines) { - char **lines = get_ccan_file_lines(example); - char *ret; - bool in_function = false, fake_function = false; + unsigned int i; + + for (i = 0; lines[i]; i++) { + unsigned len = strspn(lines[i], IDENT_CHARS); + + /* The winners. */ + if (strstarts(lines[i], "if") && len == 2) + return true; + if (strstarts(lines[i], "for") && len == 3) + return true; + if (strstarts(lines[i], "while") && len == 5) + return true; + if (strstarts(lines[i], "do") && len == 2) + return true; + + /* The losers. */ + if (strchr(lines[i], '(')) { + if (strstarts(lines[i], "static")) + return false; + if (strends(lines[i], ")")) + return false; + } + } + + /* No idea... Say no? */ + return false; +} + +/* Examples will often build on prior ones. Try combining them. */ +static char **combine(char **lines, char **prev) +{ + unsigned int i, lines_total, prev_total, count; + char **ret; + + if (!prev) + return NULL; + + strip_leading_whitespace(lines); + + /* If it looks internal, put prev at start. */ + if (looks_internal(lines)) { + count = 0; + } else { + /* Try inserting in first elided position */ + for (count = 0; lines[count]; count++) { + if (strcmp(lines[count], "...") == 0) + break; + } + if (!lines[count]) + /* Try at start anyway? */ + count = 0; + else + count++; + } + + for (i = 0; lines[i]; i++); + lines_total = i; + + 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, + (lines_total - count + 1) * sizeof(ret[0])); + return ret; +} + +static char *mangle(struct manifest *m, char **lines) +{ + char *ret, *use_funcs = NULL; + 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" @@ -98,15 +271,17 @@ static char *mangle(struct manifest *m, struct ccan_file *example) "#include \n", m->basename, m->basename); - ret = talloc_asprintf_append(ret, "/* Useful dummmy functions. */\n" + ret = talloc_asprintf_append(ret, "/* Useful dummy functions. */\n" "int somefunc(void);\n" "int somefunc(void) { return 0; }\n"); - /* Starts indented? Wrap it in a main() function. */ - if (lines[0] && isblank(lines[0][0])) { + strip_leading_whitespace(lines); + if (looks_internal(lines)) { + /* Wrap it all in main(). */ ret = start_main(ret); fake_function = true; in_function = true; + has_main = true; } /* Primitive, very primitive. */ @@ -117,11 +292,19 @@ static char *mangle(struct manifest *m, struct ccan_file *example) in_function = false; } else { /* Character at start of line, with ( and no ; - * == function start. */ + * == function start. Ignore comments. */ if (!isblank(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; + if (strncmp(lines[i], "static", 6) == 0) { + use_funcs = add_func(use_funcs, + lines[i]); + } + } } /* ... means elided code. If followed by spaced line, means * next part is supposed to be inside a function. */ @@ -131,6 +314,7 @@ static char *mangle(struct manifest *m, struct ccan_file *example) && isblank(lines[i+1][0])) { /* This implies we start a function here. */ ret = start_main(ret); + has_main = true; fake_function = true; in_function = true; } @@ -141,6 +325,23 @@ static char *mangle(struct manifest *m, struct ccan_file *example) 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"); + fake_function = true; + } + + /* Get rid of unused warnings by printing addresses of static funcs. */ + if (use_funcs) { + if (!fake_function) { + ret = talloc_asprintf_append(ret, + "int use_funcs(void);\n" + "int use_funcs(void) {\n"); + fake_function = true; + } + ret = talloc_asprintf_append(ret, " %s\n", use_funcs); + } + if (fake_function) ret = talloc_asprintf_append(ret, "return 0;\n" "}\n"); @@ -148,7 +349,9 @@ static char *mangle(struct manifest *m, struct ccan_file *example) } static struct ccan_file *mangle_example(struct manifest *m, - struct ccan_file *example, bool keep) + struct ccan_file *example, + char **lines, + bool keep) { char *name, *contents; int fd; @@ -166,12 +369,13 @@ static struct ccan_file *mangle_example(struct manifest *m, if (fd < 0) return NULL; - contents = mangle(m, example); + contents = mangle(m, lines); if (write(fd, contents, strlen(contents)) != strlen(contents)) { close(fd); return NULL; } close(fd); + f->contents = talloc_steal(f, contents); return f; } @@ -180,6 +384,8 @@ static void *build_examples(struct manifest *m, bool keep, { struct ccan_file *i; struct score *score = talloc(m, struct score); + struct ccan_file *mangle; + char **prev = NULL; score->score = 0; score->errors = NULL; @@ -189,26 +395,49 @@ static void *build_examples(struct manifest *m, bool keep, examples_compile.total_score++; ret = compile(score, m, i, keep); - if (!ret) + if (!ret) { + prev = get_ccan_file_lines(i); score->score++; - else { - struct ccan_file *mangle = mangle_example(m, i, keep); + continue; + } + + talloc_free(ret); + mangle = mangle_example(m, i, get_ccan_file_lines(i), keep); + ret = compile(score, m, mangle, keep); + if (!ret) { + prev = get_ccan_file_lines(i); + score->score++; + continue; + } + /* Try combining with previous (successful) example... */ + if (prev) { + prev = combine(get_ccan_file_lines(i), prev); talloc_free(ret); + + /* We're going to replace this failure. */ + if (keep) + unlink(mangle->fullname); + talloc_free(mangle); + + mangle = mangle_example(m, i, prev, keep); ret = compile(score, m, mangle, keep); - if (!ret) + if (!ret) { score->score++; - else { - if (!score->errors) - score->errors = ret; - else { - score->errors - = talloc_append_string(score->errors, - ret); - talloc_free(ret); - } + continue; } } + + if (!score->errors) + score->errors = ret; + else { + score->errors = talloc_append_string(score->errors, + ret); + talloc_free(ret); + } + /* This didn't work, so not a candidate for combining. */ + talloc_free(prev); + prev = NULL; } return score; }