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   fputs ("Tested files:\n", stdout);
 211
 212   for (h = 0; h < NUMBER_OF_HEADERS; ++h)
 213     {
 214       char file_name[HEADER_MAX];
 215       sprintf (file_name, "%s.h", header[h]);
 216       result |= check_header (file_name, ignore_list);
 217     }
 218
 219   /* The test suite should return errors but for now this is not
 220      practical.  Give a warning and ask the user to correct the bugs.  */
 221   return result;
 222 }
 223
 224
 225 static const char **
 226 get_null_defines (void)
 227 {
 228   char line[BUFSIZ], *command;
 229   char **result = NULL;
 230   size_t result_len = 0;
 231   size_t result_max = 0;
 232   FILE *input;
 233   int first = 1;
 234
 235   command = malloc (sizeof fmt + sizeof "/dev/null" + 2 * strlen (CC)
 236                     + strlen (INC) + strlen (TMPFILE));
 237
 238   if (command == NULL)
 239     {
 240       puts ("No more memory.");
 241       exit (1);
 242     }
 243
 244   sprintf (command, fmt, "/dev/null", CC, INC, CC, TMPFILE);
 245
 246   if (system (command))
 247     {
 248       puts ("system() returned nonzero");
 249       return NULL;
 250     }
 251   free (command);
 252   input = fopen (TMPFILE, "r");
 253
 254   if (input == NULL)
 255     {
 256       printf ("Could not read %s: ", TMPFILE);
 257       perror (NULL);
 258       return NULL;
 259     }
 260
 261   while (fgets (line, sizeof line, input) != NULL)
 262     {
 263       int i, okay = 0;
 264       size_t endmac;
 265       char *start, *end;
 266       if (strlen (line) < 9 || line[7] != ' ')
 267         { /* "#define A" */
 268           printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
 269                   line);
 270           continue;
 271         }
 272       if (line[8] == '_')
 273         /* It's a safe identifier.  */
 274         continue;
 275       if (result_len == result_max)
 276         {
 277           result_max += 10;
 278           result = realloc (result, result_max * sizeof (char **));
 279           if (result == NULL)
 280             {
 281               puts ("No more memory.");
 282               exit (1);
 283             }
 284         }
 285       start = &line[8];
 286       for (end = start + 1; !isspace (*end) && *end != '\0'; ++end)
 287         ;
 288       result[result_len++] = strndup (start, end - start);
 289
 290       if (first)
 291         {
 292           fputs ("The following identifiers will be ignored since the compiler defines them\nby default:\n", stdout);
 293           first = 0;
 294         }
 295       puts (result[result_len - 1]);
 296     }
 297   fclose (input);
 298   remove (TMPFILE);
 299
 300   return (const char **) result;
 301 }
 302
 303
 304 static int
 305 check_header (const char *file_name, const char **except)
 306 {
 307   char line[BUFSIZ], *command;
 308   FILE *input;
 309   int result = 0;
 310
 311   command = malloc (sizeof fmt + strlen (file_name) + 2 * strlen (CC)
 312                     + strlen (INC) + strlen (TMPFILE));
 313
 314   if (command == NULL)
 315     {
 316       puts ("No more memory.");
 317       exit (1);
 318     }
 319
 320   puts (file_name);
 321   sprintf (command, fmt, file_name, CC, INC, CC, TMPFILE);
 322
 323   if (system (command))
 324     {
 325       puts ("system() returned nonzero");
 326       result = 1;
 327     }
 328   free (command);
 329   input = fopen (TMPFILE, "r");
 330
 331   if (input == NULL)
 332     {
 333       printf ("Could not read %s: ", TMPFILE);
 334       perror (NULL);
 335       return 1;
 336     }
 337
 338   while (fgets (line, sizeof line, input) != NULL)
 339     {
 340       int i, okay = 0;
 341       size_t endmac;
 342       const char **cpp;
 343       if (strlen (line) < 9 || line[7] != ' ')
 344         { /* "#define A" */
 345           printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
 346                   line);
 347           result = 1;
 348           continue;
 349         }
 350       for (i = 0; i < NUMBER_OF_PREFIXES; ++i)
 351         {
 352           if (!strncmp (line+8, prefix[i], strlen (prefix[i]))) {
 353             ++okay;
 354             break;
 355           }
 356         }
 357       if (okay)
 358         continue;
 359       for (i = 0; i < NUMBER_OF_MACROS; ++i)
 360         {
 361           if (!strncmp (line + 8, macros[i], strlen (macros[i])))
 362             {
 363               ++okay;
 364               break;
 365             }
 366         }
 367       if (okay)
 368         continue;
 369       /* Find next char after the macro identifier; this can be either
 370          a space or an open parenthesis.  */
 371       endmac = strcspn (line + 8, " (");
 372       if (line[8+endmac] == '\0')
 373         {
 374           printf ("malformed input, expected '#define MACRO VALUE'\n"
 375                   "got '%s'\n", line);
 376           result = 1;
 377           continue;
 378         }
 379       for (i = 0; i < NUMBER_OF_SUFFIXES; ++i)
 380         {
 381           size_t len = strlen (suffix[i]);
 382           if (!strncmp (line + 8 + endmac - len, suffix[i], len))
 383             {
 384               ++okay;
 385               break;
 386             }
 387         }
 388       if (okay)
 389         continue;
 390       if (except != NULL)
 391         for (cpp = except; *cpp != NULL; ++cpp)
 392           {
 393             size_t len = strlen (*cpp);
 394             if (!strncmp (line + 8, *cpp, len) && isspace (line[8 + len]))
 395               {
 396                 ++okay;
 397                 break;
 398               }
 399           }
 400       if (!okay)
 401         {
 402           fputs (line, stdout);
 403           result = 2;
 404         }
 405     }
 406   fclose (input);
 407   remove (TMPFILE);
 408
 409   return result;
 410 }
 411
 412 /* EOF */