Let tests not fail because the compiler defines itself symbols which
[kopensolaris-gnu/glibc.git] / isomac.c
1 /* Check system header files for ISO 9899:1990 (ISO C) compliance.
2    Copyright (C) 1996, 1997 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Jens Schweikhardt <schweikh@noc.dfn.de>, 1996.
5
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.
10
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.
15
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.  */
20
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.
28
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
33
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)
40    {
41      int PIPE_BUF = 0;
42      assert (strcmp ("PIPE_BUF", XSTR (PIPE_BUF)) == 0);
43      return 0;
44    }
45
46    is expected to compile and meet the assertion. If it does not, your
47    compiler compiles some other language than Standard C.
48
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.
58
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.  */
69
70 #ifndef _GNU_SOURCE
71 # define _GNU_SOURCE 1
72 #endif
73
74 #include <stdio.h>
75 #include <stdlib.h>
76 #include <string.h>
77
78 #define TMPFILE             "/tmp/macros"
79 #define HEADER_MAX          256
80
81 /* ISO C header names including Amendment 1 (without ".h" suffix).  */
82 static char *header[] =
83 {
84   "assert", "ctype", "errno", "float", "iso646", "limits", "locale",
85   "math", "setjmp", "signal", "stdarg", "stddef", "stdio", "stdlib",
86   "string", "time", "wchar", "wctype"
87 };
88
89 /* Macros with these prefixes are considered okay.  */
90 static char *prefix[] =
91 {
92   "_", "E", "is", "str", "mem", "SIG", "FLT_", "DBL_", "LDBL_",
93   "LC_", "wmem", "wcs"
94 };
95
96 /* Macros with these suffixes are considered okay.  Will not work for
97    parametrized macros with arguments.  */
98 static char *suffix[] =
99 {
100   "_MAX", "_MIN"
101 };
102
103 /* These macros are considered okay. In fact, these are just more prefixes.  */
104 static char *macros[] =
105 {
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_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"
168 };
169
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)
174
175
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. -I `%s --print-prog-name=include` -\
180 > %s";
181
182
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;
187
188 static const char **get_null_defines (void);
189 static int check_header (const char *, const char **);
190
191 int
192 main (int argc, char *argv[])
193 {
194   int h;
195   int result = 0;
196   const char **ignore_list;
197
198   CC = argc > 1 ? argv[1] : "gcc";
199   INC = argc > 2 ? argv[2] : "";
200
201   if (system (NULL) == 0)
202     {
203       puts ("Sorry, no command processor.");
204       return EXIT_FAILURE;
205     }
206
207   /* First get list of symbols which are defined by the compiler.  */
208   ignore_list = get_null_defines ();
209
210   for (h = 0; h < NUMBER_OF_HEADERS; ++h)
211     {
212       char file_name[HEADER_MAX];
213       sprintf (file_name, "%s.h", header[h]);
214       result |= check_header (file_name, ignore_list);
215     }
216
217   /* The test suite should return errors but for now this is not
218      practical.  Give a warning and ask the user to correct the bugs.  */
219   return result;
220 }
221
222
223 static const char **
224 get_null_defines (void)
225 {
226   char line[BUFSIZ], *command;
227   char **result = NULL;
228   size_t result_len = 0;
229   size_t result_max = 0;
230   FILE *input;
231   int first = 1;
232
233   command = malloc (sizeof fmt + sizeof "/dev/null" + 2 * strlen (CC)
234                     + strlen (INC) + strlen (TMPFILE));
235
236   if (command == NULL)
237     {
238       puts ("No more memory.");
239       exit (1);
240     }
241
242   sprintf (command, fmt, "/dev/null", CC, INC, CC, TMPFILE);
243
244   if (system (command))
245     {
246       puts ("system() returned nonzero");
247       return NULL;
248     }
249   free (command);
250   input = fopen (TMPFILE, "r");
251
252   if (input == NULL)
253     {
254       printf ("Could not read %s: ", TMPFILE);
255       perror (NULL);
256       return NULL;
257     }
258
259   while (fgets (line, sizeof line, input) != NULL)
260     {
261       int i, okay = 0;
262       size_t endmac;
263       char *start, *end;
264       if (strlen (line) < 9 || line[7] != ' ')
265         { /* "#define A" */
266           printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
267                   line);
268           continue;
269         }
270       if (line[8] == '_')
271         /* It's a safe identifier.  */
272         continue;
273       if (result_len == result_max)
274         {
275           result_max += 10;
276           result = realloc (result, result_max * sizeof (char **));
277           if (result == NULL)
278             {
279               puts ("No more memory.");
280               exit (1);
281             }
282         }
283       start = &line[8];
284       for (end = start + 1; !isspace (*end) && *end != '\0'; ++end)
285         ;
286       result[result_len++] = strndup (start, end - start);
287
288       if (first)
289         {
290           fputs ("The following identifiers will be ignored since the compiler defines them\nby default:\n", stdout);
291           first = 0;
292         }
293       puts (result[result_len - 1]);
294     }
295   fclose (input);
296   remove (TMPFILE);
297
298   return (const char **) result;
299 }
300
301
302 static int
303 check_header (const char *file_name, const char **except)
304 {
305   char line[BUFSIZ], *command;
306   FILE *input;
307   int result = 0;
308
309   command = malloc (sizeof fmt + strlen (file_name) + 2 * strlen (CC)
310                     + strlen (INC) + strlen (TMPFILE));
311
312   if (command == NULL)
313     {
314       puts ("No more memory.");
315       exit (1);
316     }
317
318   puts (file_name);
319   sprintf (command, fmt, file_name, CC, INC, CC, TMPFILE);
320
321   if (system (command))
322     {
323       puts ("system() returned nonzero");
324       result = 1;
325     }
326   free (command);
327   input = fopen (TMPFILE, "r");
328
329   if (input == NULL)
330     {
331       printf ("Could not read %s: ", TMPFILE);
332       perror (NULL);
333       return 1;
334     }
335
336   while (fgets (line, sizeof line, input) != NULL)
337     {
338       int i, okay = 0;
339       size_t endmac;
340       const char **cpp;
341       if (strlen (line) < 9 || line[7] != ' ')
342         { /* "#define A" */
343           printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
344                   line);
345           result = 1;
346           continue;
347         }
348       for (i = 0; i < NUMBER_OF_PREFIXES; ++i)
349         {
350           if (!strncmp (line+8, prefix[i], strlen (prefix[i]))) {
351             ++okay;
352             break;
353           }
354         }
355       if (okay)
356         continue;
357       for (i = 0; i < NUMBER_OF_MACROS; ++i)
358         {
359           if (!strncmp (line + 8, macros[i], strlen (macros[i])))
360             {
361               ++okay;
362               break;
363             }
364         }
365       if (okay)
366         continue;
367       /* Find next char after the macro identifier; this can be either
368          a space or an open parenthesis.  */
369       endmac = strcspn (line + 8, " (");
370       if (line[8+endmac] == '\0')
371         {
372           printf ("malformed input, expected '#define MACRO VALUE'\n"
373                   "got '%s'\n", line);
374           result = 1;
375           continue;
376         }
377       for (i = 0; i < NUMBER_OF_SUFFIXES; ++i)
378         {
379           size_t len = strlen (suffix[i]);
380           if (!strncmp (line + 8 + endmac - len, suffix[i], len))
381             {
382               ++okay;
383               break;
384             }
385         }
386       if (okay)
387         continue;
388       if (except != NULL)
389         for (cpp = except; *cpp != NULL; ++cpp)
390           {
391             size_t len = strlen (*cpp);
392             if (!strncmp (line + 8, *cpp, len) && isspace (line[8 + len]))
393               {
394                 ++okay;
395                 break;
396               }
397           }
398       if (!okay)
399         {
400           fputs (line, stdout);
401           result = 2;
402         }
403     }
404   fclose (input);
405   remove (TMPFILE);
406
407   return result;
408 }
409
410 /* EOF */