dte test coverage


Directory: ./
File: src/compiler.c
Date: 2025-07-19 20:13:10
Exec Total Coverage
Lines: 60 62 96.8%
Functions: 9 9 100.0%
Branches: 20 24 83.3%

Line Branch Exec Source
1 #include <stdlib.h>
2 #include <string.h>
3 #include "compiler.h"
4 #include "command/serialize.h"
5 #include "util/array.h"
6 #include "util/debug.h"
7 #include "util/intern.h"
8 #include "util/str-util.h"
9 #include "util/xmalloc.h"
10
11 static const char capture_names[NR_ERRFMT_INDICES][8] = {
12 [ERRFMT_FILE] = "file",
13 [ERRFMT_LINE] = "line",
14 [ERRFMT_COLUMN] = "column",
15 [ERRFMT_MESSAGE] = "message"
16 };
17
18 24 UNITTEST {
19 24 CHECK_STRING_ARRAY(capture_names);
20 24 }
21
22 291 ssize_t errorfmt_capture_name_to_index(const char *name)
23 {
24
2/2
✓ Branch 0 (6→3) taken 673 times.
✓ Branch 1 (6→7) taken 1 times.
674 for (size_t i = 0; i < ARRAYLEN(capture_names); i++) {
25
2/2
✓ Branch 0 (3→4) taken 290 times.
✓ Branch 1 (3→5) taken 383 times.
673 if (streq(name, capture_names[i])) {
26 290 return i;
27 }
28 }
29 return -1;
30 }
31
32 243 static Compiler *find_or_add_compiler(HashMap *compilers, const char *name)
33 {
34 243 Compiler *c = find_compiler(compilers, name);
35
2/2
✓ Branch 0 (3→4) taken 27 times.
✓ Branch 1 (3→7) taken 216 times.
243 return c ? c : hashmap_insert(compilers, xstrdup(name), xcalloc1(sizeof(*c)));
36 }
37
38 243 void add_error_fmt (
39 HashMap *compilers,
40 const char *name,
41 const char *pattern,
42 regex_t *re,
43 int8_t idx[NR_ERRFMT_INDICES],
44 bool ignore
45 ) {
46 243 ErrorFormat *f = xmalloc(sizeof(*f));
47 243 f->ignore = ignore;
48 243 f->re = *re; // Takes ownership (responsible for calling regfree(3))
49 243 memcpy(f->capture_index, idx, NR_ERRFMT_INDICES);
50
51 243 Compiler *compiler = find_or_add_compiler(compilers, name);
52 243 f->pattern = str_intern(pattern);
53 243 ptr_array_append(&compiler->error_formats, f);
54 243 }
55
56 243 void free_error_format(ErrorFormat *f)
57 {
58 243 regfree(&f->re);
59 243 free(f);
60 243 }
61
62 27 void free_compiler(Compiler *c)
63 {
64 27 ptr_array_free_cb(&c->error_formats, FREE_FUNC(free_error_format));
65 27 free(c);
66 27 }
67
68 18 void remove_compiler(HashMap *compilers, const char *name)
69 {
70 18 Compiler *c = hashmap_remove(compilers, name);
71
1/2
✗ Branch 0 (3→4) not taken.
✓ Branch 1 (3→5) taken 18 times.
18 if (c) {
72 free_compiler(c);
73 }
74 18 }
75
76 2 void collect_errorfmt_capture_names(PointerArray *a, const char *prefix)
77 {
78 2 COLLECT_STRINGS(capture_names, a, prefix);
79
2/2
✓ Branch 0 (3→4) taken 1 times.
✓ Branch 1 (3→6) taken 1 times.
2 if (str_has_prefix("_", prefix)) {
80 1 ptr_array_append(a, xstrdup("_"));
81 }
82 2 }
83
84 3 void dump_compiler(const Compiler *c, const char *name, String *s)
85 {
86
2/2
✓ Branch 0 (24→3) taken 27 times.
✓ Branch 1 (24→25) taken 3 times.
30 for (size_t i = 0, n = c->error_formats.count; i < n; i++) {
87 27 ErrorFormat *e = c->error_formats.ptrs[i];
88 27 string_append_literal(s, "errorfmt ");
89
2/2
✓ Branch 0 (4→5) taken 17 times.
✓ Branch 1 (4→6) taken 10 times.
27 if (e->ignore) {
90 17 string_append_literal(s, "-i ");
91 }
92
2/4
✓ Branch 0 (6→7) taken 27 times.
✗ Branch 1 (6→8) not taken.
✗ Branch 2 (7→8) not taken.
✓ Branch 3 (7→9) taken 27 times.
27 if (unlikely(name[0] == '-' || e->pattern[0] == '-')) {
93 string_append_literal(s, "-- ");
94 }
95 27 string_append_escaped_arg(s, name, true);
96 27 string_append_byte(s, ' ');
97 27 string_append_escaped_arg(s, e->pattern, true);
98
99 27 static_assert(ARRAYLEN(e->capture_index) == 4);
100 27 const int8_t *a = e->capture_index;
101 27 int max_idx = MAX4(a[0], a[1], a[2], a[3]);
102 27 BUG_ON(max_idx > ERRORFMT_CAPTURE_MAX);
103
104
2/2
✓ Branch 0 (21→17) taken 32 times.
✓ Branch 1 (21→22) taken 27 times.
59 for (int j = 1; j <= max_idx; j++) {
105 74 const char *capname = "_";
106
1/2
✓ Branch 0 (17→14) taken 74 times.
✗ Branch 1 (17→18) not taken.
74 for (size_t k = 0; k < ARRAYLEN(capture_names); k++) {
107
2/2
✓ Branch 0 (14→15) taken 32 times.
✓ Branch 1 (14→16) taken 42 times.
74 if (j == a[k]) {
108 32 capname = capture_names[k];
109 32 break;
110 }
111 }
112 32 string_append_byte(s, ' ');
113 32 string_append_cstring(s, capname);
114 }
115
116 27 string_append_byte(s, '\n');
117 }
118 3 }
119