83a19e2cea57ad041f5c71584a9eb5beb23b008d
[ccan] / tools / ccanlint / tests / depends_accurate.c
1 #include <tools/ccanlint/ccanlint.h>
2 #include <tools/tools.h>
3 #include <ccan/talloc/talloc.h>
4 #include <ccan/str/str.h>
5 #include <ccan/str_talloc/str_talloc.h>
6 #include <ccan/foreach/foreach.h>
7 #include <sys/types.h>
8 #include <sys/stat.h>
9 #include <fcntl.h>
10 #include <unistd.h>
11 #include <limits.h>
12 #include <errno.h>
13 #include <stdlib.h>
14 #include <stdio.h>
15 #include <err.h>
16 #include <string.h>
17 #include <ctype.h>
18
19 static bool has_dep(struct manifest *m, char **deps, bool *used,
20                     const char *depname)
21 {
22         unsigned int i;
23
24         /* We can include ourselves, of course. */
25         if (streq(depname + strlen("ccan/"), m->modname))
26                 return true;
27
28         for (i = 0; deps[i]; i++) {
29                 if (streq(deps[i], depname)) {
30                         used[i] = true;
31                         return true;
32                 }
33         }
34         return false;
35 }
36
37 static bool check_dep_includes(struct manifest *m,
38                                char **deps, bool *used,
39                                struct score *score,
40                                struct ccan_file *f)
41 {
42         unsigned int i;
43         char **lines = get_ccan_file_lines(f);
44         struct line_info *li = get_ccan_line_info(f);
45         bool ok = true;
46
47         for (i = 0; lines[i]; i++) {
48                 char *mod;
49                 if (!strreg(f, lines[i],
50                             "^[ \t]*#[ \t]*include[ \t]*[<\"]"
51                             "(ccan/+.+)/+[^/]+.h", &mod))
52                         continue;
53
54                 if (has_dep(m, deps, used, mod))
55                         continue;
56
57                 /* FIXME: we can't be sure about
58                  * conditional includes, so don't
59                  * complain. */
60                 if (!li[i].cond) {
61                         score_file_error(score, f, i+1,
62                                          "%s not listed in _info", mod);
63                         ok = false;
64                 }
65         }
66         return ok;
67 }
68
69 static void check_depends_accurate(struct manifest *m,
70                                    unsigned int *timeleft, struct score *score)
71 {
72         struct list_head *list;
73         unsigned int i, core_deps, test_deps;
74         char **deps, **tdeps;
75         bool *used;
76         bool ok = true;
77
78         /* Get the *direct* dependencies. */
79         if (safe_mode) {
80                 deps = get_safe_ccan_deps(m, m->dir, "depends", false);
81                 tdeps = get_safe_ccan_deps(m, m->dir, "testdepends", false);
82         } else {
83                 deps = get_deps(m, m->dir, "depends", false,
84                                 get_or_compile_info);
85                 tdeps = get_deps(m, m->dir, "testdepends", false,
86                                  get_or_compile_info);
87         }
88
89         core_deps = talloc_array_length(deps) - 1;
90         test_deps = talloc_array_length(tdeps) - 1;
91
92         used = talloc_zero_array(m, bool, core_deps + test_deps + 1);
93
94         foreach_ptr(list, &m->c_files, &m->h_files) {
95                 struct ccan_file *f;
96
97                 list_for_each(list, f, list)
98                         ok &= check_dep_includes(m, deps, used, score, f);
99         }
100
101         for (i = 0; i < core_deps; i++) {
102                 if (!used[i])
103                         score_file_error(score, m->info_file, 0,
104                                          "%s is an unused dependency",
105                                          deps[i]);
106         }
107
108         /* Now append test dependencies to deps. */
109         deps = talloc_realloc(NULL, deps, char *,
110                               (core_deps + test_deps + 1) * sizeof(char *));
111         memcpy(&deps[core_deps], tdeps, test_deps * sizeof(char *));
112         /* ccan/tap is given a free pass. */
113         deps[core_deps + test_deps] = (char *)"ccan/tap";
114         deps[core_deps + test_deps + 1] = NULL;
115
116         foreach_ptr(list, &m->run_tests, &m->api_tests,
117                     &m->compile_ok_tests, &m->compile_fail_tests,
118                     &m->other_test_c_files) {
119                 struct ccan_file *f;
120
121                 list_for_each(list, f, list)
122                         ok &= check_dep_includes(m, deps, used, score, f);
123         }
124
125         for (i = core_deps; i < test_deps; i++) {
126                 if (!used[i])
127                         score_file_error(score, m->info_file, 0,
128                                          "%s is an unused test dependency",
129                                          deps[i]);
130         }
131
132         if (!score->error)
133                 score->score = score->total;
134
135         /* We don't count unused dependencies as an error (yet!) */
136         score->pass = ok;
137 }
138
139 struct ccanlint depends_accurate = {
140         .key = "depends_accurate",
141         .name = "Module's CCAN dependencies are the only CCAN files #included",
142         .check = check_depends_accurate,
143         .needs = "depends_exist test_depends_exist"
144 };
145
146 REGISTER_TEST(depends_accurate);