New approach to including locale data in the rpm.
[glibc.git] / stdlib / isomac.c
blobc0b9ad1db21e1c7ab9f28e75b24706e803faa3c0
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.
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.
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.
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. */
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 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 HEADER_MAX 256
80 static const char *macrofile;
82 /* ISO C header names including Amendment 1 (without ".h" suffix). */
83 static char *header[] =
85 "assert", "ctype", "errno", "float", "iso646", "limits", "locale",
86 "math", "setjmp", "signal", "stdarg", "stddef", "stdio", "stdlib",
87 "string", "time", "wchar", "wctype"
90 /* Macros with these prefixes are considered okay. */
91 static char *prefix[] =
93 "_", "E", "is", "str", "mem", "SIG", "FLT_", "DBL_", "LDBL_",
94 "LC_", "wmem", "wcs"
97 /* Macros with these suffixes are considered okay. Will not work for
98 parametrized macros with arguments. */
99 static char *suffix[] =
101 "_MAX", "_MIN"
104 /* These macros are considered okay. In fact, these are just more prefixes. */
105 static char *macros[] =
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"
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)
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";
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;
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 **);
194 main (int argc, char *argv[])
196 int h;
197 int result = 0;
198 const char **ignore_list;
200 CC = argc > 1 ? argv[1] : "gcc";
201 INC = argc > 2 ? argv[2] : "";
203 if (system (NULL) == 0)
205 puts ("Sorry, no command processor.");
206 return EXIT_FAILURE;
209 /* First get list of symbols which are defined by the compiler. */
210 ignore_list = get_null_defines ();
212 fputs ("Tested files:\n", stdout);
214 for (h = 0; h < NUMBER_OF_HEADERS; ++h)
216 char file_name[HEADER_MAX];
217 sprintf (file_name, "%s.h", header[h]);
218 result |= check_header (file_name, ignore_list);
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;
227 static char *
228 xstrndup (const char *s, size_t n)
230 size_t len = n;
231 char *new = malloc (len + 1);
233 if (new == NULL)
234 return NULL;
236 new[len] = '\0';
237 return memcpy (new, s, len);
241 static const char **
242 get_null_defines (void)
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;
251 macrofile = tmpnam (NULL);
253 command = malloc (sizeof fmt + sizeof "/dev/null" + 2 * strlen (CC)
254 + strlen (INC) + strlen (macrofile));
256 if (command == NULL)
258 puts ("No more memory.");
259 exit (1);
262 sprintf (command, fmt, "/dev/null", CC, INC, CC, macrofile);
264 if (system (command))
266 puts ("system() returned nonzero");
267 return NULL;
269 free (command);
270 input = fopen (macrofile, "r");
272 if (input == NULL)
274 printf ("Could not read %s: ", macrofile);
275 perror (NULL);
276 return NULL;
279 while (fgets (line, sizeof line, input) != NULL)
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;
290 if (line[8] == '_')
291 /* It's a safe identifier. */
292 continue;
293 if (result_len == result_max)
295 result_max += 10;
296 result = realloc (result, result_max * sizeof (char **));
297 if (result == NULL)
299 puts ("No more memory.");
300 exit (1);
303 start = &line[8];
304 for (end = start + 1; !isspace (*end) && *end != '\0'; ++end)
306 result[result_len] = xstrndup (start, end - start);
308 if (strcmp (result[result_len], "NOT_IN_libc") != 0)
310 if (first)
312 fputs ("The following identifiers will be ignored since the compiler defines them\nby default:\n", stdout);
313 first = 0;
315 puts (result[result_len]);
317 ++result_len;
319 if (result_len == result_max)
321 result_max += 1;
322 result = realloc (result, result_max * sizeof (char **));
323 if (result == NULL)
325 puts ("No more memory.");
326 exit (1);
329 result[result_len] = NULL;
330 fclose (input);
331 remove (macrofile);
333 return (const char **) result;
337 static int
338 check_header (const char *file_name, const char **except)
340 char line[BUFSIZ], *command;
341 FILE *input;
342 int result = 0;
344 command = malloc (sizeof fmt + strlen (file_name) + 2 * strlen (CC)
345 + strlen (INC) + strlen (macrofile));
347 if (command == NULL)
349 puts ("No more memory.");
350 exit (1);
353 puts (file_name);
354 sprintf (command, fmt, file_name, CC, INC, CC, macrofile);
356 if (system (command))
358 puts ("system() returned nonzero");
359 result = 1;
361 free (command);
362 input = fopen (macrofile, "r");
364 if (input == NULL)
366 printf ("Could not read %s: ", macrofile);
367 perror (NULL);
368 return 1;
371 while (fgets (line, sizeof line, input) != NULL)
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;
383 for (i = 0; i < NUMBER_OF_PREFIXES; ++i)
385 if (!strncmp (line+8, prefix[i], strlen (prefix[i]))) {
386 ++okay;
387 break;
390 if (okay)
391 continue;
392 for (i = 0; i < NUMBER_OF_MACROS; ++i)
394 if (!strncmp (line + 8, macros[i], strlen (macros[i])))
396 ++okay;
397 break;
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')
407 printf ("malformed input, expected '#define MACRO VALUE'\n"
408 "got '%s'\n", line);
409 result = 1;
410 continue;
412 for (i = 0; i < NUMBER_OF_SUFFIXES; ++i)
414 size_t len = strlen (suffix[i]);
415 if (!strncmp (line + 8 + endmac - len, suffix[i], len))
417 ++okay;
418 break;
421 if (okay)
422 continue;
423 if (except != NULL)
424 for (cpp = except; *cpp != NULL; ++cpp)
426 size_t len = strlen (*cpp);
427 if (!strncmp (line + 8, *cpp, len) && isspace (line[8 + len]))
429 ++okay;
430 break;
433 if (!okay)
435 fputs (line, stdout);
436 result = 2;
439 fclose (input);
440 remove (macrofile);
442 return result;
445 /* EOF */