Update.
[glibc.git] / stdlib / isomac.c
blob7148881d0f9aedbbcc629e901600b98ddc6d012d
1 /* Check system header files for ISO 9899:1990 (ISO C) compliance.
2 Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Jens Schweikhardt <schweikh@noc.dfn.de>, 1996.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Library General Public License
8 as published by the Free Software Foundation; either version 2 of
9 the License, or (at your option) any later version.
11 The GNU C Library is distributed in the hope that it will be
12 useful, but WITHOUT ANY WARRANTY; without even the implied warranty
13 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU Library General Public License for more details.
16 You should have received a copy of the GNU Library General Public
17 License along with the GNU C Library; see the file COPYING.LIB. If
18 not, write to the Free Software Foundation, Inc., 59 Temple Place -
19 Suite 330, Boston, MA 02111-1307, USA. */
21 /* This is a simple minded program that tries to find illegal macro
22 definitions in system header files. Illegal macro definitions are
23 those not from the implementation namespace (i.e. not starting with
24 an underscore) or not matching any identifier mandated by The
25 Standard. Some common macro names are considered okay, e.g. all those
26 beginning with E (which may be defined in <errno.h>) or ending in
27 _MAX. See the arrays prefix[] and suffix[] below for details.
29 In a compliant implementation no other macros can be defined, because
30 you could write strictly conforming programs that may fail to compile
31 due to syntax errors: suppose <stdio.h> defines PIPE_BUF, then the
32 conforming
34 #include <assert.h>
35 #include <stdio.h> <- or where the bogus macro is defined
36 #include <string.h>
37 #define STR(x) #x
38 #define XSTR(x) STR(x)
39 int main (void)
41 int PIPE_BUF = 0;
42 assert (strcmp ("PIPE_BUF", XSTR (PIPE_BUF)) == 0);
43 return 0;
46 is expected to compile and meet the assertion. If it does not, your
47 compiler compiles some other language than Standard C.
49 REQUIREMENTS:
50 This program calls gcc to get the list of defined macros. If you
51 don't have gcc you're probably out of luck unless your compiler or
52 preprocessor has something similar to gcc's -dM option. Tune
53 PRINT_MACROS in this case. This program assumes headers are found
54 under /usr/include and that there is a writable /tmp directory.
55 Tune SYSTEM_INCLUDE and TMPFILE if your system differs.
56 #define BROKEN_SYSTEM if system(NULL) bombs -- one more violation
57 of ISO C, by the way.
59 OUTPUT:
60 Each header file name is printed, followed by illegal macro names
61 and their definition. For the above example, you would see
62 ...
63 /usr/include/stdio.h
64 #define PIPE_BUF 5120
65 ...
66 If your implementation does not yet incorporate Amendment 1 you
67 will see messages about iso646.h, wctype.h and wchar.h not being
68 found. */
70 #ifndef _GNU_SOURCE
71 # define _GNU_SOURCE 1
72 #endif
74 #include <stdio.h>
75 #include <stdlib.h>
76 #include <string.h>
78 #define TMPFILE "/tmp/macros"
79 #define HEADER_MAX 256
81 /* ISO C header names including Amendment 1 (without ".h" suffix). */
82 static char *header[] =
84 "assert", "ctype", "errno", "float", "iso646", "limits", "locale",
85 "math", "setjmp", "signal", "stdarg", "stddef", "stdio", "stdlib",
86 "string", "time", "wchar", "wctype"
89 /* Macros with these prefixes are considered okay. */
90 static char *prefix[] =
92 "_", "E", "is", "str", "mem", "SIG", "FLT_", "DBL_", "LDBL_",
93 "LC_", "wmem", "wcs"
96 /* Macros with these suffixes are considered okay. Will not work for
97 parametrized macros with arguments. */
98 static char *suffix[] =
100 "_MAX", "_MIN"
103 /* These macros are considered okay. In fact, these are just more prefixes. */
104 static char *macros[] =
106 "BUFSIZ", "CHAR_BIT", "CHAR_MAX", "CHAR_MIN", "CLOCKS_PER_SEC",
107 "DBL_DIG", "DBL_EPSILON", "DBL_MANT_DIG", "DBL_MAX",
108 "DBL_MAX_10_EXP", "DBL_MAX_EXP", "DBL_MIN", "DBL_MIN_10_EXP",
109 "DBL_MIN_EXP", "EDOM", "EILSEQ", "EOF", "ERANGE", "EXIT_FAILURE",
110 "EXIT_SUCCESS", "FILENAME_MAX", "FLT_DIG", "FLT_EPSILON",
111 "FLT_MANT_DIG", "FLT_MAX", "FLT_MAX_10_EXP", "FLT_MAX_EXP",
112 "FLT_MIN", "FLT_MIN_10_EXP", "FLT_MIN_EXP", "FLT_RADIX",
113 "FLT_ROUNDS", "FOPEN_MAX", "HUGE_VAL", "INT_MAX", "INT_MIN",
114 "LC_ALL", "LC_COLLATE", "LC_CTYPE", "LC_MONETARY", "LC_NUMERIC",
115 "LC_TIME", "LDBL_DIG", "LDBL_EPSILON", "LDBL_MANT_DIG", "LDBL_MAX",
116 "LDBL_MAX_10_EXP", "LDBL_MAX_EXP", "LDBL_MIN", "LDBL_MIN_10_EXP",
117 "LDBL_MIN_EXP", "LONG_MAX", "LONG_MIN", "L_tmpnam", "MB_CUR_MAX",
118 "MB_LEN_MAX", "NDEBUG", "NULL", "RAND_MAX", "SCHAR_MAX",
119 "SCHAR_MIN", "SEEK_CUR", "SEEK_END", "SEEK_SET", "SHRT_MAX",
120 "SHRT_MIN", "SIGABRT", "SIGFPE", "SIGILL", "SIGINT", "SIGSEGV",
121 "SIGTERM", "SIG_DFL", "SIG_ERR", "SIG_IGN", "TMP_MAX", "UCHAR_MAX",
122 "UINT_MAX", "ULONG_MAX", "USHRT_MAX", "WCHAR_MAX", "WCHAR_MIN",
123 "WEOF", "_IOFBF", "_IOLBF", "_IONBF", "abort", "abs", "acos",
124 "acosf", "acosl", "and", "and_eq", "asctime", "asin", "asinf",
125 "asinl", "assert", "atan", "atan2", "atan2f", "atan2l", "atanf",
126 "atanl", "atexit", "atof", "atoi", "atol", "bitand", "bitor",
127 "bsearch", "btowc", "calloc", "ceil", "ceilf", "ceill", "clearerr",
128 "clock", "clock_t", "compl", "cos", "cosf", "cosh", "coshf",
129 "coshl", "cosl", "ctime", "difftime", "div", "div_t", "errno",
130 "exit", "exp", "expf", "expl", "fabs", "fabsf", "fabsl", "fclose",
131 "feof", "ferror", "fflush", "fgetc", "fgetpos", "fgets", "fgetwc",
132 "fgetws", "floor", "floorf", "floorl", "fmod", "fmodf", "fmodl",
133 "fopen", "fprintf", "fputc", "fputs", "fputwc", "fputws", "fread",
134 "free", "freopen", "frexp", "frexpf", "frexpl", "fscanf", "fseek",
135 "fsetpos", "ftell", "fwide", "fwprintf", "fwrite", "fwscanf",
136 "getc", "getchar", "getenv", "gets", "getwc", "getwchar", "gmtime",
137 "isalnum", "isalpha", "iscntrl", "isdigit", "isgraph", "islower",
138 "isprint", "ispunct", "isspace", "isupper", "iswalnum", "iswalpha",
139 "iswcntrl", "iswctype", "iswdigit", "iswgraph", "iswlower",
140 "iswprint", "iswpunct", "iswspace", "iswupper", "iswxdigit",
141 "isxdigit", "labs", "ldexp", "ldexpf", "ldexpl", "ldiv", "ldiv_t",
142 "localeconv", "localtime", "log", "log10", "log10f", "log10l",
143 "logf", "logl", "longjmp", "malloc", "mblen", "mbrlen", "mbrtowc",
144 "mbsinit", "mbsrtowcs", "mbstate_t", "mbstowcs", "mbtowc", "memchr",
145 "memcmp", "memcpy", "memmove", "memset", "mktime", "modf", "modff",
146 "modfl", "not", "not_eq", "offsetof", "or", "or_eq", "perror",
147 "pow", "powf", "powl", "printf", "ptrdiff_t", "putc", "putchar",
148 "puts", "putwc", "putwchar", "qsort", "raise", "rand", "realloc",
149 "remove", "rename", "rewind", "scanf", "setbuf", "setjmp",
150 "setlocale", "setvbuf", "sig_atomic_t", "signal", "sin", "sinf",
151 "sinh", "sinhf", "sinhl", "sinl", "size_t", "sprintf", "sqrt",
152 "sqrtf", "sqrtl", "srand", "sscanf", "stderr", "stdin", "stdout",
153 "strcat", "strchr", "strcmp", "strcoll", "strcpy", "strcspn",
154 "strerror", "strftime", "strlen", "strncat", "strncmp", "strncpy",
155 "strpbrk", "strrchr", "strspn", "strstr", "strtod", "strtok",
156 "strtol", "strtoul", "strxfrm", "swprintf", "swscanf", "system",
157 "tan", "tanf", "tanh", "tanhf", "tanhl", "tanl", "time", "time_t",
158 "tmpfile", "tmpnam", "tolower", "toupper", "towctrans", "towlower",
159 "towupper", "ungetc", "ungetwc", "va_arg", "va_copy", "va_end", "va_start",
160 "vfprintf", "vfwprintf", "vprintf", "vsprintf", "vswprintf",
161 "vwprintf", "wchar_t", "wcrtomb", "wcscat", "wcschr", "wcscmp",
162 "wcscoll", "wcscpy", "wcscspn", "wcsftime", "wcslen", "wcsncat",
163 "wcsncmp", "wcsncpy", "wcspbrk", "wcsrchr", "wcsrtombs", "wcsspn",
164 "wcsstr", "wcstod", "wcstok", "wcstol", "wcstombs", "wcstoul",
165 "wcsxfrm", "wctob", "wctomb", "wctrans", "wctrans_t", "wctype",
166 "wctype_t", "wint_t", "wmemchr", "wmemcmp", "wmemcpy", "wmemmove",
167 "wmemset", "wprintf", "wscanf", "xor", "xor_eq"
170 #define NUMBER_OF_HEADERS (sizeof header / sizeof *header)
171 #define NUMBER_OF_PREFIXES (sizeof prefix / sizeof *prefix)
172 #define NUMBER_OF_SUFFIXES (sizeof suffix / sizeof *suffix)
173 #define NUMBER_OF_MACROS (sizeof macros / sizeof *macros)
176 /* Format string to build command to invoke compiler. */
177 static const char fmt[] = "\
178 echo \"#include <%s>\" |\
179 %s -E -dM -ansi -pedantic %s -D_LIBC -I. \
180 -isystem `%s --print-prog-name=include` - 2> /dev/null > %s";
183 /* The compiler we use (given on the command line). */
184 char *CC;
185 /* The -I parameters for CC to find all headers. */
186 char *INC;
188 static char *xstrndup (const char *, size_t);
189 static const char **get_null_defines (void);
190 static int check_header (const char *, const char **);
193 main (int argc, char *argv[])
195 int h;
196 int result = 0;
197 const char **ignore_list;
199 CC = argc > 1 ? argv[1] : "gcc";
200 INC = argc > 2 ? argv[2] : "";
202 if (system (NULL) == 0)
204 puts ("Sorry, no command processor.");
205 return EXIT_FAILURE;
208 /* First get list of symbols which are defined by the compiler. */
209 ignore_list = get_null_defines ();
211 fputs ("Tested files:\n", stdout);
213 for (h = 0; h < NUMBER_OF_HEADERS; ++h)
215 char file_name[HEADER_MAX];
216 sprintf (file_name, "%s.h", header[h]);
217 result |= check_header (file_name, ignore_list);
220 /* The test suite should return errors but for now this is not
221 practical. Give a warning and ask the user to correct the bugs. */
222 return result;
226 static char *
227 xstrndup (const char *s, size_t n)
229 size_t len = n;
230 char *new = malloc (len + 1);
232 if (new == NULL)
233 return NULL;
235 new[len] = '\0';
236 return memcpy (new, s, len);
240 static const char **
241 get_null_defines (void)
243 char line[BUFSIZ], *command;
244 char **result = NULL;
245 size_t result_len = 0;
246 size_t result_max = 0;
247 FILE *input;
248 int first = 1;
250 command = malloc (sizeof fmt + sizeof "/dev/null" + 2 * strlen (CC)
251 + strlen (INC) + strlen (TMPFILE));
253 if (command == NULL)
255 puts ("No more memory.");
256 exit (1);
259 sprintf (command, fmt, "/dev/null", CC, INC, CC, TMPFILE);
261 if (system (command))
263 puts ("system() returned nonzero");
264 return NULL;
266 free (command);
267 input = fopen (TMPFILE, "r");
269 if (input == NULL)
271 printf ("Could not read %s: ", TMPFILE);
272 perror (NULL);
273 return NULL;
276 while (fgets (line, sizeof line, input) != NULL)
278 int i, okay = 0;
279 size_t endmac;
280 char *start, *end;
281 if (strlen (line) < 9 || line[7] != ' ')
282 { /* "#define A" */
283 printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
284 line);
285 continue;
287 if (line[8] == '_')
288 /* It's a safe identifier. */
289 continue;
290 if (result_len == result_max)
292 result_max += 10;
293 result = realloc (result, result_max * sizeof (char **));
294 if (result == NULL)
296 puts ("No more memory.");
297 exit (1);
300 start = &line[8];
301 for (end = start + 1; !isspace (*end) && *end != '\0'; ++end)
303 result[result_len++] = xstrndup (start, end - start);
305 if (first)
307 fputs ("The following identifiers will be ignored since the compiler defines them\nby default:\n", stdout);
308 first = 0;
310 puts (result[result_len - 1]);
312 if (result_len == result_max)
314 result_max += 1;
315 result = realloc (result, result_max * sizeof (char **));
316 if (result == NULL)
318 puts ("No more memory.");
319 exit (1);
322 result[result_len] = NULL;
323 fclose (input);
324 remove (TMPFILE);
326 return (const char **) result;
330 static int
331 check_header (const char *file_name, const char **except)
333 char line[BUFSIZ], *command;
334 FILE *input;
335 int result = 0;
337 command = malloc (sizeof fmt + strlen (file_name) + 2 * strlen (CC)
338 + strlen (INC) + strlen (TMPFILE));
340 if (command == NULL)
342 puts ("No more memory.");
343 exit (1);
346 puts (file_name);
347 sprintf (command, fmt, file_name, CC, INC, CC, TMPFILE);
349 if (system (command))
351 puts ("system() returned nonzero");
352 result = 1;
354 free (command);
355 input = fopen (TMPFILE, "r");
357 if (input == NULL)
359 printf ("Could not read %s: ", TMPFILE);
360 perror (NULL);
361 return 1;
364 while (fgets (line, sizeof line, input) != NULL)
366 int i, okay = 0;
367 size_t endmac;
368 const char **cpp;
369 if (strlen (line) < 9 || line[7] != ' ')
370 { /* "#define A" */
371 printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
372 line);
373 result = 1;
374 continue;
376 for (i = 0; i < NUMBER_OF_PREFIXES; ++i)
378 if (!strncmp (line+8, prefix[i], strlen (prefix[i]))) {
379 ++okay;
380 break;
383 if (okay)
384 continue;
385 for (i = 0; i < NUMBER_OF_MACROS; ++i)
387 if (!strncmp (line + 8, macros[i], strlen (macros[i])))
389 ++okay;
390 break;
393 if (okay)
394 continue;
395 /* Find next char after the macro identifier; this can be either
396 a space or an open parenthesis. */
397 endmac = strcspn (line + 8, " (");
398 if (line[8+endmac] == '\0')
400 printf ("malformed input, expected '#define MACRO VALUE'\n"
401 "got '%s'\n", line);
402 result = 1;
403 continue;
405 for (i = 0; i < NUMBER_OF_SUFFIXES; ++i)
407 size_t len = strlen (suffix[i]);
408 if (!strncmp (line + 8 + endmac - len, suffix[i], len))
410 ++okay;
411 break;
414 if (okay)
415 continue;
416 if (except != NULL)
417 for (cpp = except; *cpp != NULL; ++cpp)
419 size_t len = strlen (*cpp);
420 if (!strncmp (line + 8, *cpp, len) && isspace (line[8 + len]))
422 ++okay;
423 break;
426 if (!okay)
428 fputs (line, stdout);
429 result = 2;
432 fclose (input);
433 remove (TMPFILE);
435 return result;
438 /* EOF */