stdlib/isomac.c

   1 /* Check system header files for ISO 9899:1990 (ISO C) compliance.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2001 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 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 -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 (first)
 309         {
 310           fputs ("The following identifiers will be ignored since the compiler defines them\nby default:\n", stdout);
 311           first = 0;
 312         }
 313       puts (result[result_len - 1]);
 314     }
 315   if (result_len == result_max)
 316     {
 317       result_max += 1;
 318       result = realloc (result, result_max * sizeof (char **));
 319       if (result == NULL)
 320         {
 321           puts ("No more memory.");
 322           exit (1);
 323         }
 324     }
 325   result[result_len] = NULL;
 326   fclose (input);
 327   remove (macrofile);
 328
 329   return (const char **) result;
 330 }
 331
 332
 333 static int
 334 check_header (const char *file_name, const char **except)
 335 {
 336   char line[BUFSIZ], *command;
 337   FILE *input;
 338   int result = 0;
 339
 340   command = malloc (sizeof fmt + strlen (file_name) + 2 * strlen (CC)
 341                     + strlen (INC) + strlen (macrofile));
 342
 343   if (command == NULL)
 344     {
 345       puts ("No more memory.");
 346       exit (1);
 347     }
 348
 349   puts (file_name);
 350   sprintf (command, fmt, file_name, CC, INC, CC, macrofile);
 351
 352   if (system (command))
 353     {
 354       puts ("system() returned nonzero");
 355       result = 1;
 356     }
 357   free (command);
 358   input = fopen (macrofile, "r");
 359
 360   if (input == NULL)
 361     {
 362       printf ("Could not read %s: ", macrofile);
 363       perror (NULL);
 364       return 1;
 365     }
 366
 367   while (fgets (line, sizeof line, input) != NULL)
 368     {
 369       int i, okay = 0;
 370       size_t endmac;
 371       const char **cpp;
 372       if (strlen (line) < 9 || line[7] != ' ')
 373         { /* "#define A" */
 374           printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
 375                   line);
 376           result = 1;
 377           continue;
 378         }
 379       for (i = 0; i < NUMBER_OF_PREFIXES; ++i)
 380         {
 381           if (!strncmp (line+8, prefix[i], strlen (prefix[i]))) {
 382             ++okay;
 383             break;
 384           }
 385         }
 386       if (okay)
 387         continue;
 388       for (i = 0; i < NUMBER_OF_MACROS; ++i)
 389         {
 390           if (!strncmp (line + 8, macros[i], strlen (macros[i])))
 391             {
 392               ++okay;
 393               break;
 394             }
 395         }
 396       if (okay)
 397         continue;
 398       /* Find next char after the macro identifier; this can be either
 399          a space or an open parenthesis.  */
 400       endmac = strcspn (line + 8, " (");
 401       if (line[8+endmac] == '\0')
 402         {
 403           printf ("malformed input, expected '#define MACRO VALUE'\n"
 404                   "got '%s'\n", line);
 405           result = 1;
 406           continue;
 407         }
 408       for (i = 0; i < NUMBER_OF_SUFFIXES; ++i)
 409         {
 410           size_t len = strlen (suffix[i]);
 411           if (!strncmp (line + 8 + endmac - len, suffix[i], len))
 412             {
 413               ++okay;
 414               break;
 415             }
 416         }
 417       if (okay)
 418         continue;
 419       if (except != NULL)
 420         for (cpp = except; *cpp != NULL; ++cpp)
 421           {
 422             size_t len = strlen (*cpp);
 423             if (!strncmp (line + 8, *cpp, len) && isspace (line[8 + len]))
 424               {
 425                 ++okay;
 426                 break;
 427               }
 428           }
 429       if (!okay)
 430         {
 431           fputs (line, stdout);
 432           result = 2;
 433         }
 434     }
 435   fclose (input);
 436   remove (macrofile);
 437
 438   return result;
 439 }
 440
 441 /* EOF */