ccanlint: keep separate array of compiled versions.

[ccan] / tools / ccanlint / ccanlint.c

diff --git a/tools/ccanlint/ccanlint.c b/tools/ccanlint/ccanlint.c
index e3d99c79a7b72bda874466b48d427b5df2dad65c..5f443d6fafd4ec4f9cbea5b62ebf054be0d92a98 100644 (file)
--- a/tools/ccanlint/ccanlint.c
+++ b/tools/ccanlint/ccanlint.c
@@ -186,6 +186,8 @@ static bool run_test(struct ccanlint *i,
 static void register_test(struct list_head *h, struct ccanlint *test)
 {
        list_add(h, &test->list);
+       test->options = talloc_array(NULL, char *, 1);
+       test->options[0] = NULL;
 }
 
 /**
@@ -220,6 +222,13 @@ static struct ccanlint *find_test(const char *key)
        return NULL;
 }
 
+bool is_excluded(const char *name)
+{
+       return btree_lookup(cmdline_exclude, name) != NULL
+               || btree_lookup(info_exclude, name) != NULL
+               || find_test(name)->skip != NULL;
+}
+
 #undef REGISTER_TEST
 #define REGISTER_TEST(name, ...) extern struct ccanlint name
 #include "generated-normal-tests"
@@ -285,19 +294,24 @@ static void init_tests(void)
        }
        btree_delete(keys);
        btree_delete(names);
+}
 
-       if (!verbose)
-               return;
+static void print_test_depends(void)
+{
+       struct list_head *list;
 
        foreach_ptr(list, &compulsory_tests, &normal_tests) {
+               struct ccanlint *c;
                printf("\%s Tests\n",
                       list == &compulsory_tests ? "Compulsory" : "Normal");
 
-               if (!list_empty(&c->dependencies)) {
-                       const struct dependent *d;
-                       printf("These depend on us:\n");
-                       list_for_each(&c->dependencies, d, node)
-                               printf("\t%s\n", d->dependent->name);
+               list_for_each(list, c, list) {
+                       if (!list_empty(&c->dependencies)) {
+                               const struct dependent *d;
+                               printf("These depend on %s:\n", c->key);
+                               list_for_each(&c->dependencies, d, node)
+                                       printf("\t%s\n", d->dependent->key);
+                       }
                }
        }
 }
@@ -404,11 +418,30 @@ static char **collapse(char **lines, unsigned int *nump)
                if (lines[i][0])
                        lines[j++] = lines[i];
        }
+       lines[j] = NULL;
        if (nump)
                *nump = j;
        return lines;
 }
 
+
+static void add_options(struct ccanlint *test, char **options,
+                       unsigned int num_options)
+{
+       unsigned int num;
+
+       if (!test->options)
+               num = 0;
+       else
+               /* -1, because last one is NULL. */
+               num = talloc_array_length(test->options) - 1;
+
+       test->options = talloc_realloc(NULL, test->options,
+                                      char *,
+                                      num + num_options + 1);
+       memcpy(&test->options[num], options, (num_options + 1)*sizeof(char *));
+}
+
 static void add_info_options(struct ccan_file *info, bool mark_fails)
 {
        struct doc_section *d;
@@ -420,9 +453,10 @@ static void add_info_options(struct ccan_file *info, bool mark_fails)
                        continue;
 
                for (i = 0; i < d->num_lines; i++) {
+                       unsigned int num_words;
                        char **words = collapse(strsplit(d, d->lines[i], " \t"),
-                                               NULL);
-                       if (!words[0])
+                                               &num_words);
+                       if (num_words == 0)
                                continue;
 
                        if (strncmp(words[0], "//", 2) == 0)
@@ -449,14 +483,49 @@ static void add_info_options(struct ccan_file *info, bool mark_fails)
                                if (!test->takes_options)
                                        warnx("%s: %s doesn't take options",
                                              info->fullname, words[0]);
-                               /* Copy line exactly into options. */
-                               test->options = strstr(d->lines[i], words[0])
-                                       + strlen(words[0]);
+                               add_options(test, words+1, num_words-1);
                        }
                }
        }
 }
 
+/* If options are of form "filename:<option>" they only apply to that file */
+char **per_file_options(const struct ccanlint *test, struct ccan_file *f)
+{
+       char **ret;
+       unsigned int i, j = 0;
+
+       /* Fast path. */
+       if (!test->options[0])
+               return test->options;
+
+       ret = talloc_array(f, char *, talloc_array_length(test->options));
+       for (i = 0; test->options[i]; i++) {
+               char *optname;
+
+               if (!test->options[i] || !strchr(test->options[i], ':')) {
+                       optname = test->options[i];
+               } else if (strstarts(test->options[i], f->name)
+                          && test->options[i][strlen(f->name)] == ':') {
+                       optname = test->options[i] + strlen(f->name) + 1;
+               } else
+                       continue;
+
+               /* FAIL overrides anything else. */
+               if (streq(optname, "FAIL")) {
+                       ret = talloc_array(f, char *, 2);
+                       ret[0] = (char *)"FAIL";
+                       ret[1] = NULL;
+                       return ret;
+               }
+               ret[j++] = optname;
+       }
+       ret[j] = NULL;
+
+       /* Shrink it to size so talloc_array_length() works as expected. */
+       return talloc_realloc(NULL, ret, char *, j + 1);
+}
+
 static bool depends_on(struct ccanlint *i, struct ccanlint *target)
 {
        const struct dependent *d;
@@ -640,8 +709,10 @@ int main(int argc, char *argv[])
                dir[strlen(dir)-1] = '\0';
        if (dir != base_dir)
                prefix = talloc_append_string(talloc_basename(NULL, dir), ": ");
-       if (verbose >= 3)
+       if (verbose >= 3) {
                compile_verbose = true;
+               print_test_depends();
+       }
        if (verbose >= 4)
                tools_verbose = true;