stdlib/isomac.c

   1 /* Check system header files for ISO 9899:1990 (ISO C) compliance.
   2    Copyright (C) 1996-2016 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, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 /* This is a simple minded program that tries to find illegal macro
  21    definitions in system header files. Illegal macro definitions are
  22    those not from the implementation namespace (i.e. not starting with
  23    an underscore) or not matching any identifier mandated by The
  24    Standard. Some common macro names are considered okay, e.g. all those
  25    beginning with E (which may be defined in <errno.h>) or ending in
  26    _MAX. See the arrays prefix[] and suffix[] below for details.
  27
  28    In a compliant implementation no other macros can be defined, because
  29    you could write strictly conforming programs that may fail to compile
  30    due to syntax errors: suppose <stdio.h> defines PIPE_BUF, then the
  31    conforming
  32
  33    #include <assert.h>
  34    #include <stdio.h>      <- or where the bogus macro is defined
  35    #include <string.h>
  36    #define STR(x) #x
  37    #define XSTR(x) STR(x)
  38    int main (void)
  39    {
  40      int PIPE_BUF = 0;
  41      assert (strcmp ("PIPE_BUF", XSTR (PIPE_BUF)) == 0);
  42      return 0;
  43    }
  44
  45    is expected to compile and meet the assertion. If it does not, your
  46    compiler compiles some other language than Standard C.
  47
  48    REQUIREMENTS:
  49      This program calls gcc to get the list of defined macros. If you
  50      don't have gcc you're probably out of luck unless your compiler or
  51      preprocessor has something similar to gcc's -dM option. Tune
  52      PRINT_MACROS in this case. This program assumes headers are found
  53      under /usr/include and that there is a writable /tmp directory.
  54      Tune SYSTEM_INCLUDE if your system differs.
  55      #define BROKEN_SYSTEM if system(NULL) bombs -- one more violation
  56      of ISO C, by the way.
  57
  58    OUTPUT:
  59      Each header file name is printed, followed by illegal macro names
  60      and their definition. For the above example, you would see
  61      ...
  62      /usr/include/stdio.h
  63      #define PIPE_BUF 5120
  64      ...
  65      If your implementation does not yet incorporate Amendment 1 you
  66      will see messages about iso646.h, wctype.h and wchar.h not being
  67      found.  */
  68
  69 #ifndef _GNU_SOURCE
  70 # define _GNU_SOURCE 1
  71 #endif
  72
  73 #include <ctype.h>
  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 \
 181 -DIN_MODULE=MODULE_extramodules -I. \
 182 -isystem `%s --print-prog-name=include` - 2> /dev/null > %s";
 183
 184
 185 /* The compiler we use (given on the command line).  */
 186 char *CC;
 187 /* The -I parameters for CC to find all headers.  */
 188 char *INC;
 189
 190 static char *xstrndup (const char *, size_t);
 191 static const char **get_null_defines (void);
 192 static int check_header (const char *, const char **);
 193
 194 int
 195 main (int argc, char *argv[])
 196 {
 197   int h;
 198   int result = 0;
 199   const char **ignore_list;
 200
 201   CC = argc > 1 ? argv[1] : "gcc";
 202   INC = argc > 2 ? argv[2] : "";
 203
 204   if (system (NULL) == 0)
 205     {
 206       puts ("Sorry, no command processor.");
 207       return EXIT_FAILURE;
 208     }
 209
 210   /* First get list of symbols which are defined by the compiler.  */
 211   ignore_list = get_null_defines ();
 212
 213   fputs ("Tested files:\n", stdout);
 214
 215   for (h = 0; h < NUMBER_OF_HEADERS; ++h)
 216     {
 217       char file_name[HEADER_MAX];
 218       sprintf (file_name, "%s.h", header[h]);
 219       result |= check_header (file_name, ignore_list);
 220     }
 221
 222   /* The test suite should return errors but for now this is not
 223      practical.  Give a warning and ask the user to correct the bugs.  */
 224   return result;
 225 }
 226
 227
 228 static char *
 229 xstrndup (const char *s, size_t n)
 230 {
 231   size_t len = n;
 232   char *new = malloc (len + 1);
 233
 234   if (new == NULL)
 235     return NULL;
 236
 237   new[len] = '\0';
 238   return memcpy (new, s, len);
 239 }
 240
 241
 242 static const char **
 243 get_null_defines (void)
 244 {
 245   char line[BUFSIZ], *command;
 246   char **result = NULL;
 247   size_t result_len = 0;
 248   size_t result_max = 0;
 249   FILE *input;
 250   int first = 1;
 251
 252   macrofile = tmpnam (NULL);
 253
 254   command = malloc (sizeof fmt + sizeof "/dev/null" + 2 * strlen (CC)
 255                     + strlen (INC) + strlen (macrofile));
 256
 257   if (command == NULL)
 258     {
 259       puts ("No more memory.");
 260       exit (1);
 261     }
 262
 263   sprintf (command, fmt, "/dev/null", CC, INC, CC, macrofile);
 264
 265   if (system (command))
 266     {
 267       puts ("system() returned nonzero");
 268       free (command);
 269       return NULL;
 270     }
 271   free (command);
 272   input = fopen (macrofile, "r");
 273
 274   if (input == NULL)
 275     {
 276       printf ("Could not read %s: ", macrofile);
 277       perror (NULL);
 278       return NULL;
 279     }
 280
 281   while (fgets (line, sizeof line, input) != NULL)
 282     {
 283       int i, okay = 0;
 284       size_t endmac;
 285       char *start, *end;
 286       if (strlen (line) < 9 || line[7] != ' ')
 287         { /* "#define A" */
 288           printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
 289                   line);
 290           continue;
 291         }
 292       if (line[8] == '_')
 293         /* It's a safe identifier.  */
 294         continue;
 295       if (result_len == result_max)
 296         {
 297           result_max += 10;
 298           result = realloc (result, result_max * sizeof (char **));
 299           if (result == NULL)
 300             {
 301               puts ("No more memory.");
 302               exit (1);
 303             }
 304         }
 305       start = &line[8];
 306       for (end = start + 1; !isspace (*end) && *end != '\0'; ++end)
 307         ;
 308       result[result_len] = xstrndup (start, end - start);
 309
 310       if (strcmp (result[result_len], "IN_MODULE") != 0)
 311         {
 312           if (first)
 313             {
 314               fputs ("The following identifiers will be ignored since the compiler defines them\nby default:\n", stdout);
 315               first = 0;
 316             }
 317           puts (result[result_len]);
 318         }
 319       ++result_len;
 320     }
 321   if (result_len == result_max)
 322     {
 323       result_max += 1;
 324       result = realloc (result, result_max * sizeof (char **));
 325       if (result == NULL)
 326         {
 327           puts ("No more memory.");
 328           exit (1);
 329         }
 330     }
 331   result[result_len] = NULL;
 332   fclose (input);
 333   remove (macrofile);
 334
 335   return (const char **) result;
 336 }
 337
 338
 339 static int
 340 check_header (const char *file_name, const char **except)
 341 {
 342   char line[BUFSIZ], *command;
 343   FILE *input;
 344   int result = 0;
 345
 346   command = malloc (sizeof fmt + strlen (file_name) + 2 * strlen (CC)
 347                     + strlen (INC) + strlen (macrofile));
 348
 349   if (command == NULL)
 350     {
 351       puts ("No more memory.");
 352       exit (1);
 353     }
 354
 355   puts (file_name);
 356   sprintf (command, fmt, file_name, CC, INC, CC, macrofile);
 357
 358   if (system (command))
 359     {
 360       puts ("system() returned nonzero");
 361       result = 1;
 362     }
 363   free (command);
 364   input = fopen (macrofile, "r");
 365
 366   if (input == NULL)
 367     {
 368       printf ("Could not read %s: ", macrofile);
 369       perror (NULL);
 370       return 1;
 371     }
 372
 373   while (fgets (line, sizeof line, input) != NULL)
 374     {
 375       int i, okay = 0;
 376       size_t endmac;
 377       const char **cpp;
 378       if (strlen (line) < 9 || line[7] != ' ')
 379         { /* "#define A" */
 380           printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
 381                   line);
 382           result = 1;
 383           continue;
 384         }
 385       for (i = 0; i < NUMBER_OF_PREFIXES; ++i)
 386         {
 387           if (!strncmp (line+8, prefix[i], strlen (prefix[i]))) {
 388             ++okay;
 389             break;
 390           }
 391         }
 392       if (okay)
 393         continue;
 394       for (i = 0; i < NUMBER_OF_MACROS; ++i)
 395         {
 396           if (!strncmp (line + 8, macros[i], strlen (macros[i])))
 397             {
 398               ++okay;
 399               break;
 400             }
 401         }
 402       if (okay)
 403         continue;
 404       /* Find next char after the macro identifier; this can be either
 405          a space or an open parenthesis.  */
 406       endmac = strcspn (line + 8, " (");
 407       if (line[8+endmac] == '\0')
 408         {
 409           printf ("malformed input, expected '#define MACRO VALUE'\n"
 410                   "got '%s'\n", line);
 411           result = 1;
 412           continue;
 413         }
 414       for (i = 0; i < NUMBER_OF_SUFFIXES; ++i)
 415         {
 416           size_t len = strlen (suffix[i]);
 417           if (!strncmp (line + 8 + endmac - len, suffix[i], len))
 418             {
 419               ++okay;
 420               break;
 421             }
 422         }
 423       if (okay)
 424         continue;
 425       if (except != NULL)
 426         for (cpp = except; *cpp != NULL; ++cpp)
 427           {
 428             size_t len = strlen (*cpp);
 429             if (!strncmp (line + 8, *cpp, len) && isspace (line[8 + len]))
 430               {
 431                 ++okay;
 432                 break;
 433               }
 434           }
 435       if (!okay)
 436         {
 437           fputs (line, stdout);
 438           result = 2;
 439         }
 440     }
 441   fclose (input);
 442   remove (macrofile);
 443
 444   return result;
 445 }
 446
 447 /* EOF */