Files
RetroArch/tools/input_driver_table_check.c
LibretroAdmin b366054913 tools: C ports of the remaining Python CI checkers
Every Python checker still run by a workflow, rewritten in C89 on
tools/check_common.h and run through tools/check.sh, which builds each
one once and reuses the binary:

  command_table_check        overlay_setter_bounds
  companion_parity           overlay_texture_ownership
  ctx_presentable_check      removed_member_check
  d3d12_idle_wait_check      rgui_pixfmt_check
  gl_present_vsynced_check   sample_objdir_check
  gl_ring_fence_check        settings_capacity_check
  input_driver_table_check   surface_requirements_check
  input_video_separation_check  texture_image_init_check
  msg_hash_format_check      vfs_backend_parity
  msg_hash_packed_check      video_thread_state_check
  vulkan_idle_wait_check     vulkan_teardown_order_check

Each gives the same output and exit status as the script it replaces,
on the tree and on its self-test; each was also run against the
script on a few hundred generated inputs with no difference. Where the
script iterated a Python set, the C reports in sorted order.

msg_hash_format_check gains --rows FILE, the row filter intl/json2h.py
needs. rgui_pixfmt_check's harness moves out of a string into
tools/rgui_pixfmt_harness.inc, which includes the lifted block.

check_common.h gains ck_capture() and ck_sb_shq() to run a command and
read its output, ck_set_free(), ck_repr(), ck_blank_code() and
ck_def_name().
2026-10-13 10:23:47 +02:00

538 lines
14 KiB
C

/* An input driver's table has no more entries than the structure has
* members.
*
* Every input driver fills in an input_driver_t by position:
*
* input_driver_t input_uwp = {
* uwp_input_init,
* ...
* uwp_keys_down,
* uwp_bind_mouse_buttons
* };
*
* When a member is added to struct input_driver (input/input_driver.h)
* and a driver names it, the driver's table and the structure have to
* land together. They did not, once: the UWP, udev and web drivers named
* bind_mouse_buttons a commit before the structure had it. gcc and clang
* say "excess elements in struct initializer" and carry on; MSVC says
* C2078, too many initializers, and the UWP build stops - on a runner
* most contributors do not have, for a file no Linux job compiles.
*
* This is that check at source level, for every driver whatever SDK it
* needs: the entries of each `input_driver_t NAME = { ... };` are
* counted, down each side of any #if / #else in the table, and none may
* come to more than the structure's members. Fewer is fine - the members
* a table leaves out are NULL.
*
* tools/check.sh input_driver_table_check [--root DIR] [--selftest] */
#include "check_common.h"
#define HEADER "input/input_driver.h"
#define DIR_ "input/drivers"
static int is_strip_space(int c)
{
return CK_IS_SPACE(c) || (c >= 0x1c && c <= 0x1f);
}
/* Block comments made spaces with their line breaks kept, then line
* comments taken out. */
static size_t strip_comments(char *t, size_t n)
{
size_t i, o;
for (i = 0; i + 1 < n; i++)
{
size_t j;
if (t[i] != '/' || t[i + 1] != '*')
continue;
for (j = i + 2; j + 1 < n && !(t[j] == '*' && t[j + 1] == '/'); j++);
if (j + 1 >= n)
break;
for (; i < j + 2; i++)
{
if (t[i] != '\n')
t[i] = ' ';
}
i--;
}
for (i = o = 0; i < n; )
{
if (t[i] == '/' && i + 1 < n && t[i + 1] == '/')
{
while (i < n && t[i] != '\n')
i++;
}
else
t[o++] = t[i++];
}
t[o] = '\0';
return o;
}
static char *read_stripped(const char *path, size_t *len)
{
char *t = ck_read_file(path, len);
if (t)
*len = strip_comments(t, *len);
return t;
}
/* The members of struct input_driver, or 0. */
static long members(const char *root)
{
struct ck_sb path = {0};
const char *p, *e, *b;
size_t len;
long count = 0;
int depth;
char *t;
ck_sb_puts(&path, root);
ck_sb_puts(&path, "/" HEADER);
t = read_stripped(path.p, &len);
ck_sb_free(&path);
if (!t)
{
fprintf(stderr, "input_driver_table_check: cannot read %s\n", HEADER);
exit(1);
}
e = t + len;
/* ^struct input_driver\s*\{ (re.M) */
for (p = t, b = NULL; p < e && !b; p++)
{
const char *q;
if ((p != t && p[-1] != '\n') || (size_t)(e - p) < 19
|| memcmp(p, "struct input_driver", 19))
continue;
for (q = p + 19; q < e && CK_IS_SPACE(*q); q++);
if (q < e && *q == '{')
b = q + 1;
}
if (!b)
{
free(t);
return 0;
}
depth = 1;
for (p = b; depth && p < e; p++)
depth += *p == '{' ? 1 : *p == '}' ? -1 : 0;
/* a member is a declaration ending in ';' at the structure's own
* depth */
e = p - 1;
depth = 0;
for (p = b; p < e; p++)
{
if (*p == '(' || *p == '{')
depth++;
else if (*p == ')' || *p == '}')
depth--;
else if (*p == ';' && depth == 0)
count++;
}
free(t);
return count;
}
struct lines
{
const char **b;
const char **e;
size_t n;
};
static int starts(const struct lines *l, size_t i, const char *s)
{
const char *b = l->b[i], *e = l->e[i];
size_t n = strlen(s);
while (b < e && is_strip_space((unsigned char)*b))
b++;
return (size_t)(e - b) >= n && !memcmp(b, s, n);
}
/* Entries of plain text: the pieces between commas that are not blank */
static long entries(const struct ck_sb *text)
{
const char *p = text->p, *e = text->p + text->len;
long n = 0;
while (p <= e)
{
const char *c = (const char*)memchr(p, ',', (size_t)(e - p));
const char *s = c ? c : e;
const char *q;
for (q = p; q < s && is_strip_space((unsigned char)*q); q++);
n += q < s;
if (!c)
break;
p = c + 1;
}
return n;
}
static void die_short(void)
{
fprintf(stderr, "input_driver_table_check: an #if in a table does not"
" end\n");
exit(1);
}
/* (fewest, most) entries over every way through the #if branches */
static size_t block(const struct lines *l, size_t i, long *lo_out,
long *hi_out, int depth)
{
struct ck_sb text = {0};
long lo = 0, hi = 0;
if (depth > 1000)
die_short();
ck_sb_puts(&text, "");
while (i < l->n)
{
if (starts(l, i, "#if"))
{
long blo, bhi, mn, mx;
int saw_else = 0;
i = block(l, i + 1, &blo, &bhi, depth + 1);
mn = blo;
mx = bhi;
for (;;)
{
if (i >= l->n)
die_short();
if (!starts(l, i, "#elif") && !starts(l, i, "#else"))
break;
saw_else |= starts(l, i, "#else");
i = block(l, i + 1, &blo, &bhi, depth + 1);
if (blo < mn)
mn = blo;
if (bhi > mx)
mx = bhi;
}
if (!saw_else)
{
if (mn > 0)
mn = 0;
if (mx < 0)
mx = 0;
}
lo += mn;
hi += mx;
i++;
continue;
}
if (starts(l, i, "#elif") || starts(l, i, "#else")
|| starts(l, i, "#endif"))
break;
if (!starts(l, i, "#"))
{
ck_sb_putc(&text, ' ');
ck_sb_add(&text, l->b[i], (size_t)(l->e[i] - l->b[i]));
}
i++;
/* entries seen so far in plain text are counted when it ends */
if (i >= l->n || starts(l, i, "#"))
{
long n = entries(&text);
lo += n;
hi += n;
text.len = 0;
text.p[0] = '\0';
}
}
ck_sb_free(&text);
*lo_out = lo;
*hi_out = hi;
return i;
}
struct table
{
char *rel;
char *name;
unsigned long line;
long lo;
long hi;
};
struct tables
{
struct table *v;
size_t n;
};
static void find_tables(const char *root, struct tables *out)
{
struct ck_strv names = {0};
struct ck_sb base = {0};
size_t f;
out->v = NULL;
out->n = 0;
ck_sb_puts(&base, root);
ck_sb_puts(&base, "/" DIR_);
if (!ck_is_dir(base.p))
{
ck_sb_free(&base);
return;
}
ck_list_dir(base.p, &names);
ck_strv_sort(&names);
for (f = 0; f < names.n; f++)
{
struct ck_sb path = {0};
const char *t, *e, *p;
unsigned long line = 1;
const char *counted;
size_t len;
char *text;
if (!(ck_ends_with(names.v[f], ".c") || ck_ends_with(names.v[f], ".m")
|| ck_ends_with(names.v[f], ".mm")
|| ck_ends_with(names.v[f], ".cpp")))
continue;
ck_sb_puts(&path, base.p);
ck_sb_putc(&path, '/');
ck_sb_puts(&path, names.v[f]);
text = ck_is_file(path.p) ? read_stripped(path.p, &len) : NULL;
ck_sb_free(&path);
if (!text)
continue;
t = text;
e = t + len;
counted = t;
/* ^input_driver_t\s+(\w+)\s*=\s*\{ (re.M) */
for (p = t; p < e; )
{
const char *q, *w, *we, *end;
if ((p != t && p[-1] != '\n') || (size_t)(e - p) < 14
|| memcmp(p, "input_driver_t", 14))
{
p++;
continue;
}
for (q = p + 14; q < e && CK_IS_SPACE(*q); q++);
for (w = q; q < e && CK_IS_WORD(*q); q++);
we = q;
if (w == p + 14 || we == w)
{
p++;
continue;
}
for (; q < e && CK_IS_SPACE(*q); q++);
if (q >= e || *q != '=')
{
p++;
continue;
}
for (q++; q < e && CK_IS_SPACE(*q); q++);
if (q >= e || *q != '{')
{
p++;
continue;
}
q++;
for (; counted < p; counted++)
line += *counted == '\n';
end = strstr(q, "};");
if (end)
{
struct lines l;
const char *s = q;
long lo, hi;
l.b = NULL;
l.e = NULL;
l.n = 0;
for (;;)
{
const char *nl = (const char*)memchr(s, '\n',
(size_t)(end - s));
l.b = (const char**)ck_realloc(l.b, (l.n + 1) * sizeof(char*));
l.e = (const char**)ck_realloc(l.e, (l.n + 1) * sizeof(char*));
l.b[l.n] = s;
l.e[l.n] = nl ? nl : end;
l.n++;
if (!nl)
break;
s = nl + 1;
}
block(&l, 0, &lo, &hi, 0);
free(l.b);
free(l.e);
out->v = (struct table*)ck_realloc(out->v,
(out->n + 1) * sizeof(*out->v));
{
struct ck_sb rel = {0};
ck_sb_puts(&rel, DIR_ "/");
ck_sb_puts(&rel, names.v[f]);
out->v[out->n].rel = rel.p;
}
out->v[out->n].name = ck_strndup(w, (size_t)(we - w));
out->v[out->n].line = line;
out->v[out->n].lo = lo;
out->v[out->n].hi = hi;
out->n++;
}
p = q;
}
free(text);
}
ck_strv_free(&names);
ck_sb_free(&base);
}
static int run(const char *root, int quiet)
{
struct tables found;
long n = members(root);
long most = 0;
size_t i;
int bad = 0;
if (!n)
{
if (!quiet)
printf("error: struct input_driver was not found in %s; nothing"
" was checked\n", HEADER);
return 2;
}
find_tables(root, &found);
if (!found.n)
{
if (!quiet)
printf("error: no input_driver_t table was found; nothing was"
" checked\n");
return 2;
}
for (i = 0; i < found.n; i++)
{
const struct table *t = &found.v[i];
if (t->hi > most || !i)
most = t->hi;
if (t->hi > n)
{
if (!quiet)
printf("%s:%lu: %s has %ld entries, and struct input_driver has"
" %ld members.\n"
" MSVC stops at this (C2078, too many initializers). The"
" member a new entry\n"
" is for has to be in %s in the same commit.\n",
t->rel, t->line, t->name, t->hi, n, HEADER);
bad++;
}
}
for (i = 0; i < found.n; i++)
{
free(found.v[i].rel);
free(found.v[i].name);
}
free(found.v);
if (bad)
{
if (!quiet)
printf("FAIL input_driver_table_check: %d table(s)\n", bad);
return 1;
}
if (!quiet)
printf("PASS input_driver_table_check (%lu tables, none past the"
" structure's %ld members; the fullest has %ld)\n",
(unsigned long)i, n, most);
return 0;
}
static int selftest(void)
{
static const char *const bodies[] = {
" a, b, c, \"t\"",
" a, b",
" a, b, c, \"t\", e",
" a,\n#ifdef X\n b,\n#else\n NULL, /* b, c */\n#endif\n c, \"t\"",
" a, b, c,\n#ifdef X\n \"t\", e\n#else\n \"t\"\n#endif",
" a, b, c, \"t\"\n#ifdef X\n , e\n#endif"
};
static const int want[] = { 0, 0, 1, 0, 1, 1 };
static const char *const what[] = {
"as many entries as members",
"fewer entries than members",
"one entry too many",
"an #if with as many either way",
"too many down one side of an #if",
"too many when an #if with no #else is taken"
};
struct ck_sb p = {0};
char *root = ck_tmpdir();
size_t i;
int bad = 0;
long m;
ck_sb_puts(&p, root);
ck_sb_puts(&p, "/" HEADER);
ck_mkdirs_for(p.p);
ck_write_file(p.p, "struct input_driver\n{\n void *(*init)(const char"
" *j);\n /* one; two */\n void (*poll)(void *data);\n"
" int16_t (*state)(void *data,\n unsigned port);\n"
" const char *ident;\n};\n");
p.len = 0;
ck_sb_puts(&p, root);
ck_sb_puts(&p, "/" DIR_ "/t_input.c");
ck_mkdirs_for(p.p);
for (i = 0; i < sizeof(want) / sizeof(want[0]); i++)
{
struct ck_sb body = {0};
int got;
ck_sb_puts(&body, "input_driver_t input_t = {\n");
ck_sb_puts(&body, bodies[i]);
ck_sb_puts(&body, "\n};\n");
ck_write_file(p.p, body.p);
ck_sb_free(&body);
got = run(root, 1);
if (got != want[i])
{
printf("selftest: %s: wanted %d, got %d\n", what[i], want[i], got);
bad++;
}
}
if ((m = members(root)) != 4)
{
printf("selftest: the structure's members were counted as %ld, not 4\n",
m);
bad++;
}
ck_rmtree(root);
free(root);
ck_sb_free(&p);
if (bad)
{
printf("FAIL input_driver_table_check --selftest\n");
return 1;
}
printf("PASS input_driver_table_check --selftest (%lu cases)\n",
(unsigned long)(sizeof(want) / sizeof(want[0]) + 1));
return 0;
}
int main(int argc, char **argv)
{
const char *root = getenv("RA_TREE_ROOT");
int self = 0;
int i;
if (!root || !*root)
root = ".";
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "--selftest"))
self = 1;
else if (!strcmp(argv[i], "--root") && i + 1 < argc)
root = argv[++i];
else if (!strncmp(argv[i], "--root=", 7))
root = argv[i] + 7;
else
{
fprintf(stderr, "usage: input_driver_table_check [--root DIR]"
" [--selftest]\n");
return 2;
}
}
return self ? selftest() : run(root, 0);
}