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 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_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"
 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 -D_ISOMAC -I. \
 180 -isystem `%s --print-prog-name=include` - 2> /dev/null > %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 char *xstrndup (const char *, size_t);
 189 static const char **get_null_defines (void);
 190 static int check_header (const char *, const char **);
 191
 192 int
 193 main (int argc, char *argv[])
 194 {
 195   int h;
 196   int result = 0;
 197   const char **ignore_list;
 198
 199   CC = argc > 1 ? argv[1] : "gcc";
 200   INC = argc > 2 ? argv[2] : "";
 201
 202   if (system (NULL) == 0)
 203     {
 204       puts ("Sorry, no command processor.");
 205       return EXIT_FAILURE;
 206     }
 207
 208   /* First get list of symbols which are defined by the compiler.  */
 209   ignore_list = get_null_defines ();
 210
 211   fputs ("Tested files:\n", stdout);
 212
 213   for (h = 0; h < NUMBER_OF_HEADERS; ++h)
 214     {
 215       char file_name[HEADER_MAX];
 216       sprintf (file_name, "%s.h", header[h]);
 217       result |= check_header (file_name, ignore_list);
 218     }
 219
 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;
 223 }
 224
 225
 226 static char *
 227 xstrndup (const char *s, size_t n)
 228 {
 229   size_t len = n;
 230   char *new = malloc (len + 1);
 231
 232   if (new == NULL)
 233     return NULL;
 234
 235   new[len] = '\0';
 236   return memcpy (new, s, len);
 237 }
 238
 239
 240 static const char **
 241 get_null_defines (void)
 242 {
 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;
 249
 250   command = malloc (sizeof fmt + sizeof "/dev/null" + 2 * strlen (CC)
 251                     + strlen (INC) + strlen (TMPFILE));
 252
 253   if (command == NULL)
 254     {
 255       puts ("No more memory.");
 256       exit (1);
 257     }
 258
 259   sprintf (command, fmt, "/dev/null", CC, INC, CC, TMPFILE);
 260
 261   if (system (command))
 262     {
 263       puts ("system() returned nonzero");
 264       return NULL;
 265     }
 266   free (command);
 267   input = fopen (TMPFILE, "r");
 268
 269   if (input == NULL)
 270     {
 271       printf ("Could not read %s: ", TMPFILE);
 272       perror (NULL);
 273       return NULL;
 274     }
 275
 276   while (fgets (line, sizeof line, input) != NULL)
 277     {
 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;
 286         }
 287       if (line[8] == '_')
 288         /* It's a safe identifier.  */
 289         continue;
 290       if (result_len == result_max)
 291         {
 292           result_max += 10;
 293           result = realloc (result, result_max * sizeof (char **));
 294           if (result == NULL)
 295             {
 296               puts ("No more memory.");
 297               exit (1);
 298             }
 299         }
 300       start = &line[8];
 301       for (end = start + 1; !isspace (*end) && *end != '\0'; ++end)
 302         ;
 303       result[result_len++] = xstrndup (start, end - start);
 304
 305       if (first)
 306         {
 307           fputs ("The following identifiers will be ignored since the compiler defines them\nby default:\n", stdout);
 308           first = 0;
 309         }
 310       puts (result[result_len - 1]);
 311     }
 312   if (result_len == result_max)
 313     {
 314       result_max += 1;
 315       result = realloc (result, result_max * sizeof (char **));
 316       if (result == NULL)
 317         {
 318           puts ("No more memory.");
 319           exit (1);
 320         }
 321     }
 322   result[result_len] = NULL;
 323   fclose (input);
 324   remove (TMPFILE);
 325
 326   return (const char **) result;
 327 }
 328
 329
 330 static int
 331 check_header (const char *file_name, const char **except)
 332 {
 333   char line[BUFSIZ], *command;
 334   FILE *input;
 335   int result = 0;
 336
 337   command = malloc (sizeof fmt + strlen (file_name) + 2 * strlen (CC)
 338                     + strlen (INC) + strlen (TMPFILE));
 339
 340   if (command == NULL)
 341     {
 342       puts ("No more memory.");
 343       exit (1);
 344     }
 345
 346   puts (file_name);
 347   sprintf (command, fmt, file_name, CC, INC, CC, TMPFILE);
 348
 349   if (system (command))
 350     {
 351       puts ("system() returned nonzero");
 352       result = 1;
 353     }
 354   free (command);
 355   input = fopen (TMPFILE, "r");
 356
 357   if (input == NULL)
 358     {
 359       printf ("Could not read %s: ", TMPFILE);
 360       perror (NULL);
 361       return 1;
 362     }
 363
 364   while (fgets (line, sizeof line, input) != NULL)
 365     {
 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;
 375         }
 376       for (i = 0; i < NUMBER_OF_PREFIXES; ++i)
 377         {
 378           if (!strncmp (line+8, prefix[i], strlen (prefix[i]))) {
 379             ++okay;
 380             break;
 381           }
 382         }
 383       if (okay)
 384         continue;
 385       for (i = 0; i < NUMBER_OF_MACROS; ++i)
 386         {
 387           if (!strncmp (line + 8, macros[i], strlen (macros[i])))
 388             {
 389               ++okay;
 390               break;
 391             }
 392         }
 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')
 399         {
 400           printf ("malformed input, expected '#define MACRO VALUE'\n"
 401                   "got '%s'\n", line);
 402           result = 1;
 403           continue;
 404         }
 405       for (i = 0; i < NUMBER_OF_SUFFIXES; ++i)
 406         {
 407           size_t len = strlen (suffix[i]);
 408           if (!strncmp (line + 8 + endmac - len, suffix[i], len))
 409             {
 410               ++okay;
 411               break;
 412             }
 413         }
 414       if (okay)
 415         continue;
 416       if (except != NULL)
 417         for (cpp = except; *cpp != NULL; ++cpp)
 418           {
 419             size_t len = strlen (*cpp);
 420             if (!strncmp (line + 8, *cpp, len) && isspace (line[8 + len]))
 421               {
 422                 ++okay;
 423                 break;
 424               }
 425           }
 426       if (!okay)
 427         {
 428           fputs (line, stdout);
 429           result = 2;
 430         }
 431     }
 432   fclose (input);
 433   remove (TMPFILE);
 434
 435   return result;
 436 }
 437
 438 /* EOF */