1 # Copyright © 2020, 2023 Nick Bowler
3 # This program is free software: you can redistribute it and/or modify
4 # it under the terms of the GNU General Public License as published by
5 # the Free Software Foundation, either version 3 of the License, or
6 # (at your option) any later version.
8 # This program is distributed in the hope that it will be useful,
9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 # GNU General Public License for more details.
13 # You should have received a copy of the GNU General Public License
14 # along with this program. If not, see <https://www.gnu.org/licenses/>.
16 AT_BANNER([Invalid C declarations])
18 m4_define([CHECK_BADDECL],
19 [AT_CHECK([cdecl99 -e '$1'], [1], [], [stderr])])
21 m4_define([SIMPLE_BADDECL],
23 m4_map_sep([CHECK_BADDECL], [m4_newline], m4_cdr(m4_dquote_elt($@)))
26 SIMPLE_BADDECL([Reject invalid identifiers],
27 [explain int x$], [declare x$ as int])
28 SIMPLE_BADDECL([Reject long long long],
29 [explain long long long x], [declare x as long long long])
30 SIMPLE_BADDECL([Reject long long double],
31 [explain long long double x], [declare x as long long double])
32 SIMPLE_BADDECL([Reject inline on object declarations],
33 [explain inline int x], [declare x as inline int])
35 dnl Storage-class specifiers
36 SIMPLE_BADDECL([Reject multiple storage-class specifiers],
37 [explain static auto int x], [declare x as static auto int])
38 SIMPLE_BADDECL([Reject typedef in type names],
39 [explain typedef int], [type typedef int])
42 SIMPLE_BADDECL([Reject implicit int],
43 [explain auto x], [declare x as auto])
44 SIMPLE_BADDECL([Reject void declarations],
45 [explain void x], [declare x as void])
46 SIMPLE_BADDECL([Reject complex integers],
47 [explain int _Complex x], [declare x as int _Complex],
48 [explain short _Complex x], [declare x as short _Complex],
49 [explain long _Complex x], [declare x as long _Complex],
50 [explain char _Complex x], [declare x as char _Complex])
51 SIMPLE_BADDECL([Reject imaginary integers],
52 [explain int _Imaginary x], [declare x as int _Imaginary],
53 [explain short _Imaginary x], [declare x as short _Imaginary],
54 [explain long _Imaginary x], [declare x as long _Imaginary],
55 [explain char _Imaginary x], [declare x as char _Imaginary])
56 SIMPLE_BADDECL([Reject signed floats],
57 [explain signed float x], [declare x as signed float],
58 [explain signed double x], [declare x as signed double])
59 SIMPLE_BADDECL([Reject unsigned floats],
60 [explain unsigned float x], [declare x as unsigned float],
61 [explain unsigned double x], [declare x as unsigned double])
63 dnl C99§6.7.3p2: Types other than pointer types derived from object or
64 dnl incomplete types shall not be restrict-qualified.
65 SIMPLE_BADDECL([Reject restrict on object declarations],
66 [explain restrict int x], [declare x as restrict int])
67 SIMPLE_BADDECL([Reject restrict on function pointers],
68 [explain int (*restrict f)(void)],
69 [declare f as restrict pointer to function (void) returning int])
72 SIMPLE_BADDECL([Reject ... with no formal parameters],
73 [explain void f(...)],
74 [declare f as function (...) returning void])
76 SIMPLE_BADDECL([Reject identifier lists with extra parentheses],
80 dnl TODO: Find C&V which actually prohibits these "obviously wrong"
82 SIMPLE_BADDECL([Reject non-trivial void parameters],
83 [explain void f(void, void)],
84 [declare f as function (void, void) returning void],
85 [explain void f(void, ...)],
86 [declare f as function (void, ...) returning void],
87 [explain void f(register void)],
88 [declare f as function (register void) returning void],
89 [explain void f(const void)],
90 [declare f as function (const void) returning void],
91 [explain void f(void const)],
92 [declare f as function (void const) returning void])
94 SIMPLE_BADDECL([Reject parameters with no type specifier],
95 [explain void f(const)],
96 [declare f as function (const) returning void])
98 SIMPLE_BADDECL([Reject typedef in function parameters],
99 [explain void f(typedef int x)],
100 [declare f as function (x as typedef int) returning void])
102 SIMPLE_BADDECL([Reject static in function parameters],
103 [explain void f(static int x)],
104 [declare f as function (x as static int) returning void])
106 SIMPLE_BADDECL([Reject inline in function parameters],
107 [explain int f(inline int g())],
108 [declare f as function (g as inline function returning int) returning int])
110 SIMPLE_BADDECL([Reject inline in type names],
111 [explain inline int (void)],
112 [type inline function (void) returning int])
114 SIMPLE_BADDECL([Reject functions returning arrays],
115 [explain int f(void)[[1]]],
116 [declare f as function (void) returning array 1 of int])
118 SIMPLE_BADDECL([Reject functions returning functions],
119 [explain int f(void)(void)],
120 [declare f as function (void) returning function (void) returning int])
122 SIMPLE_BADDECL([Reject 0-length arrays],
123 [explain int a[[0]]],
124 [declare a as array 0 of int])
126 SIMPLE_BADDECL([Reject arrays of void],
127 [explain void a[[1]]],
128 [declare a as array 1 of void])
130 SIMPLE_BADDECL([Reject arrays of functions],
131 [explain int a[[1]](void)],
132 [declare a as array 1 of function (void) returning int])
134 SIMPLE_BADDECL([Reject arrays with invalid identifiers],
135 [explain int a[[1nan]]],
136 [declare a as array 1nan of int])
138 SIMPLE_BADDECL([Reject arrays of unusual size],
139 [explain int a[[99999999999999999999999999999999999999999999999999999]]],
140 [declare a as array 99999999999999999999999999999999999999999999999999999 of int])
142 SIMPLE_BADDECL([Reject bad declarators after good ones],
143 [explain int f(void), g(...)],
144 [explain int f, g((x))])
146 SIMPLE_BADDECL([Reject multiple declarators in type names],
147 [explain int f, g((x))],
148 [explain int x, (void)],
149 [explain int [[5]], (void)])
151 SIMPLE_BADDECL([Error recovery on multiple object declaration],
152 [explain int inline x, y])