Update NOTES.opensolaris with scheduling details
[kopensolaris-gnu/glibc.git] / stdlib / isomac.c
1 /* Check system header files for ISO 9899:1990 (ISO C) compliance.
2    Copyright (C) 1996,97,98,99,2001,02 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 Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    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 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 HEADER_MAX          256
79
80 static const char *macrofile;
81
82 /* ISO C header names including Amendment 1 (without ".h" suffix).  */
83 static char *header[] =
84 {
85   "assert", "ctype", "errno", "float", "iso646", "limits", "locale",
86   "math", "setjmp", "signal", "stdarg", "stddef", "stdio", "stdlib",
87   "string", "time", "wchar", "wctype"
88 };
89
90 /* Macros with these prefixes are considered okay.  */
91 static char *prefix[] =
92 {
93   "_", "E", "is", "str", "mem", "SIG", "FLT_", "DBL_", "LDBL_",
94   "LC_", "wmem", "wcs"
95 };
96
97 /* Macros with these suffixes are considered okay.  Will not work for
98    parametrized macros with arguments.  */
99 static char *suffix[] =
100 {
101   "_MAX", "_MIN"
102 };
103
104 /* These macros are considered okay. In fact, these are just more prefixes.  */
105 static char *macros[] =
106 {
107   "BUFSIZ", "CHAR_BIT", "CHAR_MAX", "CHAR_MIN", "CLOCKS_PER_SEC",
108   "DBL_DIG", "DBL_EPSILON", "DBL_MANT_DIG", "DBL_MAX",
109   "DBL_MAX_10_EXP", "DBL_MAX_EXP", "DBL_MIN", "DBL_MIN_10_EXP",
110   "DBL_MIN_EXP", "EDOM", "EILSEQ", "EOF", "ERANGE", "EXIT_FAILURE",
111   "EXIT_SUCCESS", "FILENAME_MAX", "FLT_DIG", "FLT_EPSILON",
112   "FLT_MANT_DIG", "FLT_MAX", "FLT_MAX_10_EXP", "FLT_MAX_EXP",
113   "FLT_MIN", "FLT_MIN_10_EXP", "FLT_MIN_EXP", "FLT_RADIX",
114   "FLT_ROUNDS", "FOPEN_MAX", "HUGE_VAL", "INT_MAX", "INT_MIN",
115   "LC_ALL", "LC_COLLATE", "LC_CTYPE", "LC_MONETARY", "LC_NUMERIC",
116   "LC_TIME", "LDBL_DIG", "LDBL_EPSILON", "LDBL_MANT_DIG", "LDBL_MAX",
117   "LDBL_MAX_10_EXP", "LDBL_MAX_EXP", "LDBL_MIN", "LDBL_MIN_10_EXP",
118   "LDBL_MIN_EXP", "LONG_MAX", "LONG_MIN", "L_tmpnam", "MB_CUR_MAX",
119   "MB_LEN_MAX", "NDEBUG", "NULL", "RAND_MAX", "SCHAR_MAX",
120   "SCHAR_MIN", "SEEK_CUR", "SEEK_END", "SEEK_SET", "SHRT_MAX",
121   "SHRT_MIN", "SIGABRT", "SIGFPE", "SIGILL", "SIGINT", "SIGSEGV",
122   "SIGTERM", "SIG_DFL", "SIG_ERR", "SIG_IGN", "TMP_MAX", "UCHAR_MAX",
123   "UINT_MAX", "ULONG_MAX", "USHRT_MAX", "WCHAR_MAX", "WCHAR_MIN",
124   "WEOF", "_IOFBF", "_IOLBF", "_IONBF", "abort", "abs", "acos",
125   "acosf", "acosl", "and", "and_eq", "asctime", "asin", "asinf",
126   "asinl", "assert", "atan", "atan2", "atan2f", "atan2l", "atanf",
127   "atanl", "atexit", "atof", "atoi", "atol", "bitand", "bitor",
128   "bsearch", "btowc", "calloc", "ceil", "ceilf", "ceill", "clearerr",
129   "clock", "clock_t", "compl", "cos", "cosf", "cosh", "coshf",
130   "coshl", "cosl", "ctime", "difftime", "div", "div_t", "errno",
131   "exit", "exp", "expf", "expl", "fabs", "fabsf", "fabsl", "fclose",
132   "feof", "ferror", "fflush", "fgetc", "fgetpos", "fgets", "fgetwc",
133   "fgetws", "floor", "floorf", "floorl", "fmod", "fmodf", "fmodl",
134   "fopen", "fprintf", "fputc", "fputs", "fputwc", "fputws", "fread",
135   "free", "freopen", "frexp", "frexpf", "frexpl", "fscanf", "fseek",
136   "fsetpos", "ftell", "fwide", "fwprintf", "fwrite", "fwscanf",
137   "getc", "getchar", "getenv", "gets", "getwc", "getwchar", "gmtime",
138   "isalnum", "isalpha", "iscntrl", "isdigit", "isgraph", "islower",
139   "isprint", "ispunct", "isspace", "isupper", "iswalnum", "iswalpha",
140   "iswcntrl", "iswctype", "iswdigit", "iswgraph", "iswlower",
141   "iswprint", "iswpunct", "iswspace", "iswupper", "iswxdigit",
142   "isxdigit", "labs", "ldexp", "ldexpf", "ldexpl", "ldiv", "ldiv_t",
143   "localeconv", "localtime", "log", "log10", "log10f", "log10l",
144   "logf", "logl", "longjmp", "malloc", "mblen", "mbrlen", "mbrtowc",
145   "mbsinit", "mbsrtowcs", "mbstate_t", "mbstowcs", "mbtowc", "memchr",
146   "memcmp", "memcpy", "memmove", "memset", "mktime", "modf", "modff",
147   "modfl", "not", "not_eq", "offsetof", "or", "or_eq", "perror",
148   "pow", "powf", "powl", "printf", "ptrdiff_t", "putc", "putchar",
149   "puts", "putwc", "putwchar", "qsort", "raise", "rand", "realloc",
150   "remove", "rename", "rewind", "scanf", "setbuf", "setjmp",
151   "setlocale", "setvbuf", "sig_atomic_t", "signal", "sin", "sinf",
152   "sinh", "sinhf", "sinhl", "sinl", "size_t", "sprintf", "sqrt",
153   "sqrtf", "sqrtl", "srand", "sscanf", "stderr", "stdin", "stdout",
154   "strcat", "strchr", "strcmp", "strcoll", "strcpy", "strcspn",
155   "strerror", "strftime", "strlen", "strncat", "strncmp", "strncpy",
156   "strpbrk", "strrchr", "strspn", "strstr", "strtod", "strtok",
157   "strtol", "strtoul", "strxfrm", "swprintf", "swscanf", "system",
158   "tan", "tanf", "tanh", "tanhf", "tanhl", "tanl", "time", "time_t",
159   "tmpfile", "tmpnam", "tolower", "toupper", "towctrans", "towlower",
160   "towupper", "ungetc", "ungetwc", "va_arg", "va_copy", "va_end", "va_start",
161   "vfprintf", "vfwprintf", "vprintf", "vsprintf", "vswprintf",
162   "vwprintf", "wchar_t", "wcrtomb", "wcscat", "wcschr", "wcscmp",
163   "wcscoll", "wcscpy", "wcscspn", "wcsftime", "wcslen", "wcsncat",
164   "wcsncmp", "wcsncpy", "wcspbrk", "wcsrchr", "wcsrtombs", "wcsspn",
165   "wcsstr", "wcstod", "wcstok", "wcstol", "wcstombs", "wcstoul",
166   "wcsxfrm", "wctob", "wctomb", "wctrans", "wctrans_t", "wctype",
167   "wctype_t", "wint_t", "wmemchr", "wmemcmp", "wmemcpy", "wmemmove",
168   "wmemset", "wprintf", "wscanf", "xor", "xor_eq"
169 };
170
171 #define NUMBER_OF_HEADERS              (sizeof header / sizeof *header)
172 #define NUMBER_OF_PREFIXES             (sizeof prefix / sizeof *prefix)
173 #define NUMBER_OF_SUFFIXES             (sizeof suffix / sizeof *suffix)
174 #define NUMBER_OF_MACROS               (sizeof macros / sizeof *macros)
175
176
177 /* Format string to build command to invoke compiler.  */
178 static const char fmt[] = "\
179 echo \"#include <%s>\" |\
180 %s -E -dM -ansi -pedantic %s -D_LIBC -D_ISOMAC -DNOT_IN_libc -I. \
181 -isystem `%s --print-prog-name=include` - 2> /dev/null > %s";
182
183
184 /* The compiler we use (given on the command line).  */
185 char *CC;
186 /* The -I parameters for CC to find all headers.  */
187 char *INC;
188
189 static char *xstrndup (const char *, size_t);
190 static const char **get_null_defines (void);
191 static int check_header (const char *, const char **);
192
193 int
194 main (int argc, char *argv[])
195 {
196   int h;
197   int result = 0;
198   const char **ignore_list;
199
200   CC = argc > 1 ? argv[1] : "gcc";
201   INC = argc > 2 ? argv[2] : "";
202
203   if (system (NULL) == 0)
204     {
205       puts ("Sorry, no command processor.");
206       return EXIT_FAILURE;
207     }
208
209   /* First get list of symbols which are defined by the compiler.  */
210   ignore_list = get_null_defines ();
211
212   fputs ("Tested files:\n", stdout);
213
214   for (h = 0; h < NUMBER_OF_HEADERS; ++h)
215     {
216       char file_name[HEADER_MAX];
217       sprintf (file_name, "%s.h", header[h]);
218       result |= check_header (file_name, ignore_list);
219     }
220
221   /* The test suite should return errors but for now this is not
222      practical.  Give a warning and ask the user to correct the bugs.  */
223   return result;
224 }
225
226
227 static char *
228 xstrndup (const char *s, size_t n)
229 {
230   size_t len = n;
231   char *new = malloc (len + 1);
232
233   if (new == NULL)
234     return NULL;
235
236   new[len] = '\0';
237   return memcpy (new, s, len);
238 }
239
240
241 static const char **
242 get_null_defines (void)
243 {
244   char line[BUFSIZ], *command;
245   char **result = NULL;
246   size_t result_len = 0;
247   size_t result_max = 0;
248   FILE *input;
249   int first = 1;
250
251   macrofile = tmpnam (NULL);
252
253   command = malloc (sizeof fmt + sizeof "/dev/null" + 2 * strlen (CC)
254                     + strlen (INC) + strlen (macrofile));
255
256   if (command == NULL)
257     {
258       puts ("No more memory.");
259       exit (1);
260     }
261
262   sprintf (command, fmt, "/dev/null", CC, INC, CC, macrofile);
263
264   if (system (command))
265     {
266       puts ("system() returned nonzero");
267       return NULL;
268     }
269   free (command);
270   input = fopen (macrofile, "r");
271
272   if (input == NULL)
273     {
274       printf ("Could not read %s: ", macrofile);
275       perror (NULL);
276       return NULL;
277     }
278
279   while (fgets (line, sizeof line, input) != NULL)
280     {
281       int i, okay = 0;
282       size_t endmac;
283       char *start, *end;
284       if (strlen (line) < 9 || line[7] != ' ')
285         { /* "#define A" */
286           printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
287                   line);
288           continue;
289         }
290       if (line[8] == '_')
291         /* It's a safe identifier.  */
292         continue;
293       if (result_len == result_max)
294         {
295           result_max += 10;
296           result = realloc (result, result_max * sizeof (char **));
297           if (result == NULL)
298             {
299               puts ("No more memory.");
300               exit (1);
301             }
302         }
303       start = &line[8];
304       for (end = start + 1; !isspace (*end) && *end != '\0'; ++end)
305         ;
306       result[result_len] = xstrndup (start, end - start);
307
308       if (strcmp (result[result_len], "NOT_IN_libc") != 0)
309         {
310           if (first)
311             {
312               fputs ("The following identifiers will be ignored since the compiler defines them\nby default:\n", stdout);
313               first = 0;
314             }
315           puts (result[result_len]);
316         }
317       ++result_len;
318     }
319   if (result_len == result_max)
320     {
321       result_max += 1;
322       result = realloc (result, result_max * sizeof (char **));
323       if (result == NULL)
324         {
325           puts ("No more memory.");
326           exit (1);
327         }
328     }
329   result[result_len] = NULL;
330   fclose (input);
331   remove (macrofile);
332
333   return (const char **) result;
334 }
335
336
337 static int
338 check_header (const char *file_name, const char **except)
339 {
340   char line[BUFSIZ], *command;
341   FILE *input;
342   int result = 0;
343
344   command = malloc (sizeof fmt + strlen (file_name) + 2 * strlen (CC)
345                     + strlen (INC) + strlen (macrofile));
346
347   if (command == NULL)
348     {
349       puts ("No more memory.");
350       exit (1);
351     }
352
353   puts (file_name);
354   sprintf (command, fmt, file_name, CC, INC, CC, macrofile);
355
356   if (system (command))
357     {
358       puts ("system() returned nonzero");
359       result = 1;
360     }
361   free (command);
362   input = fopen (macrofile, "r");
363
364   if (input == NULL)
365     {
366       printf ("Could not read %s: ", macrofile);
367       perror (NULL);
368       return 1;
369     }
370
371   while (fgets (line, sizeof line, input) != NULL)
372     {
373       int i, okay = 0;
374       size_t endmac;
375       const char **cpp;
376       if (strlen (line) < 9 || line[7] != ' ')
377         { /* "#define A" */
378           printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
379                   line);
380           result = 1;
381           continue;
382         }
383       for (i = 0; i < NUMBER_OF_PREFIXES; ++i)
384         {
385           if (!strncmp (line+8, prefix[i], strlen (prefix[i]))) {
386             ++okay;
387             break;
388           }
389         }
390       if (okay)
391         continue;
392       for (i = 0; i < NUMBER_OF_MACROS; ++i)
393         {
394           if (!strncmp (line + 8, macros[i], strlen (macros[i])))
395             {
396               ++okay;
397               break;
398             }
399         }
400       if (okay)
401         continue;
402       /* Find next char after the macro identifier; this can be either
403          a space or an open parenthesis.  */
404       endmac = strcspn (line + 8, " (");
405       if (line[8+endmac] == '\0')
406         {
407           printf ("malformed input, expected '#define MACRO VALUE'\n"
408                   "got '%s'\n", line);
409           result = 1;
410           continue;
411         }
412       for (i = 0; i < NUMBER_OF_SUFFIXES; ++i)
413         {
414           size_t len = strlen (suffix[i]);
415           if (!strncmp (line + 8 + endmac - len, suffix[i], len))
416             {
417               ++okay;
418               break;
419             }
420         }
421       if (okay)
422         continue;
423       if (except != NULL)
424         for (cpp = except; *cpp != NULL; ++cpp)
425           {
426             size_t len = strlen (*cpp);
427             if (!strncmp (line + 8, *cpp, len) && isspace (line[8 + len]))
428               {
429                 ++okay;
430                 break;
431               }
432           }
433       if (!okay)
434         {
435           fputs (line, stdout);
436           result = 2;
437         }
438     }
439   fclose (input);
440   remove (macrofile);
441
442   return result;
443 }
444
445 /* EOF */