stdlib/isomac.c

   1 /* Check system header files for ISO 9899:1990 (ISO C) compliance.
   2    Copyright (C) 1996-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 /* This is a simple minded program that tries to find illegal macro
  20    definitions in system header files. Illegal macro definitions are
  21    those not from the implementation namespace (i.e. not starting with
  22    an underscore) or not matching any identifier mandated by The
  23    Standard. Some common macro names are considered okay, e.g. all those
  24    beginning with E (which may be defined in <errno.h>) or ending in
  25    _MAX. See the arrays prefix[] and suffix[] below for details.
  26
  27    In a compliant implementation no other macros can be defined, because
  28    you could write strictly conforming programs that may fail to compile
  29    due to syntax errors: suppose <stdio.h> defines PIPE_BUF, then the
  30    conforming
  31
  32    #include <assert.h>
  33    #include <stdio.h>      <- or where the bogus macro is defined
  34    #include <string.h>
  35    #define STR(x) #x
  36    #define XSTR(x) STR(x)
  37    int main (void)
  38    {
  39      int PIPE_BUF = 0;
  40      assert (strcmp ("PIPE_BUF", XSTR (PIPE_BUF)) == 0);
  41      return 0;
  42    }
  43
  44    is expected to compile and meet the assertion. If it does not, your
  45    compiler compiles some other language than Standard C.
  46
  47    REQUIREMENTS:
  48      This program calls ${1-gcc} to get the list of defined macros. If you
  49      don't have gcc you're probably out of luck unless your compiler or
  50      preprocessor has something similar to gcc's -dM option. This program
  51      assumes headers are found in the default search path (pass -I... in
  52      $2 if this is not the case) and that there is a writable /tmp directory.
  53
  54    OUTPUT:
  55      Each header file name is printed, followed by illegal macro names
  56      and their definition. For the above example, you would see
  57      ...
  58      /usr/include/stdio.h
  59      #define PIPE_BUF 5120
  60      ...
  61      If your implementation does not yet incorporate Amendment 1 you
  62      will see messages about iso646.h, wctype.h and wchar.h not being
  63      found.  */
  64
  65 #ifndef _GNU_SOURCE
  66 # define _GNU_SOURCE 1
  67 #endif
  68
  69 #include <ctype.h>
  70 #include <stdio.h>
  71 #include <stdlib.h>
  72 #include <string.h>
  73 #include <unistd.h>
  74
  75 #define HEADER_MAX          256
  76
  77 static char macrofile[] = "/tmp/isomac.XXXXXX";
  78
  79 /* ISO C header names including Amendment 1 (without ".h" suffix).  */
  80 static char *header[] =
  81 {
  82   "assert", "ctype", "errno", "float", "iso646", "limits", "locale",
  83   "math", "setjmp", "signal", "stdarg", "stddef", "stdio", "stdlib",
  84   "string", "time", "wchar", "wctype"
  85 };
  86
  87 /* Macros with these prefixes are considered okay.  */
  88 static char *prefix[] =
  89 {
  90   "_", "E", "is", "str", "mem", "SIG", "FLT_", "DBL_", "LDBL_",
  91   "LC_", "wmem", "wcs"
  92 };
  93
  94 /* Macros with these suffixes are considered okay.  Will not work for
  95    parametrized macros with arguments.  */
  96 static char *suffix[] =
  97 {
  98   "_MAX", "_MIN"
  99 };
 100
 101 /* These macros are considered okay. In fact, these are just more prefixes.  */
 102 static char *macros[] =
 103 {
 104   "BUFSIZ", "CHAR_BIT", "CHAR_MAX", "CHAR_MIN", "CLOCKS_PER_SEC",
 105   "DBL_DIG", "DBL_EPSILON", "DBL_MANT_DIG", "DBL_MAX",
 106   "DBL_MAX_10_EXP", "DBL_MAX_EXP", "DBL_MIN", "DBL_MIN_10_EXP",
 107   "DBL_MIN_EXP", "EDOM", "EILSEQ", "EOF", "ERANGE", "EXIT_FAILURE",
 108   "EXIT_SUCCESS", "FILENAME_MAX", "FLT_DIG", "FLT_EPSILON",
 109   "FLT_MANT_DIG", "FLT_MAX", "FLT_MAX_10_EXP", "FLT_MAX_EXP",
 110   "FLT_MIN", "FLT_MIN_10_EXP", "FLT_MIN_EXP", "FLT_RADIX",
 111   "FLT_ROUNDS", "FOPEN_MAX", "HUGE_VAL", "INT_MAX", "INT_MIN",
 112   "LC_ALL", "LC_COLLATE", "LC_CTYPE", "LC_MONETARY", "LC_NUMERIC",
 113   "LC_TIME", "LDBL_DIG", "LDBL_EPSILON", "LDBL_MANT_DIG", "LDBL_MAX",
 114   "LDBL_MAX_10_EXP", "LDBL_MAX_EXP", "LDBL_MIN", "LDBL_MIN_10_EXP",
 115   "LDBL_MIN_EXP", "LONG_MAX", "LONG_MIN", "L_tmpnam", "MB_CUR_MAX",
 116   "MB_LEN_MAX", "NDEBUG", "NULL", "RAND_MAX", "SCHAR_MAX",
 117   "SCHAR_MIN", "SEEK_CUR", "SEEK_END", "SEEK_SET", "SHRT_MAX",
 118   "SHRT_MIN", "SIGABRT", "SIGFPE", "SIGILL", "SIGINT", "SIGSEGV",
 119   "SIGTERM", "SIG_DFL", "SIG_ERR", "SIG_IGN", "TMP_MAX", "UCHAR_MAX",
 120   "UINT_MAX", "ULONG_MAX", "USHRT_MAX", "WCHAR_MAX", "WCHAR_MIN",
 121   "WEOF", "_IOFBF", "_IOLBF", "_IONBF", "abort", "abs", "acos",
 122   "acosf", "acosl", "and", "and_eq", "asctime", "asin", "asinf",
 123   "asinl", "assert", "atan", "atan2", "atan2f", "atan2l", "atanf",
 124   "atanl", "atexit", "atof", "atoi", "atol", "bitand", "bitor",
 125   "bsearch", "btowc", "calloc", "ceil", "ceilf", "ceill", "clearerr",
 126   "clock", "clock_t", "compl", "cos", "cosf", "cosh", "coshf",
 127   "coshl", "cosl", "ctime", "difftime", "div", "div_t", "errno",
 128   "exit", "exp", "expf", "expl", "fabs", "fabsf", "fabsl", "fclose",
 129   "feof", "ferror", "fflush", "fgetc", "fgetpos", "fgets", "fgetwc",
 130   "fgetws", "floor", "floorf", "floorl", "fmod", "fmodf", "fmodl",
 131   "fopen", "fprintf", "fputc", "fputs", "fputwc", "fputws", "fread",
 132   "free", "freopen", "frexp", "frexpf", "frexpl", "fscanf", "fseek",
 133   "fsetpos", "ftell", "fwide", "fwprintf", "fwrite", "fwscanf",
 134   "getc", "getchar", "getenv", "gets", "getwc", "getwchar", "gmtime",
 135   "isalnum", "isalpha", "iscntrl", "isdigit", "isgraph", "islower",
 136   "isprint", "ispunct", "isspace", "isupper", "iswalnum", "iswalpha",
 137   "iswcntrl", "iswctype", "iswdigit", "iswgraph", "iswlower",
 138   "iswprint", "iswpunct", "iswspace", "iswupper", "iswxdigit",
 139   "isxdigit", "labs", "ldexp", "ldexpf", "ldexpl", "ldiv", "ldiv_t",
 140   "localeconv", "localtime", "log", "log10", "log10f", "log10l",
 141   "logf", "logl", "longjmp", "malloc", "mblen", "mbrlen", "mbrtowc",
 142   "mbsinit", "mbsrtowcs", "mbstate_t", "mbstowcs", "mbtowc", "memchr",
 143   "memcmp", "memcpy", "memmove", "memset", "mktime", "modf", "modff",
 144   "modfl", "not", "not_eq", "offsetof", "or", "or_eq", "perror",
 145   "pow", "powf", "powl", "printf", "ptrdiff_t", "putc", "putchar",
 146   "puts", "putwc", "putwchar", "qsort", "raise", "rand", "realloc",
 147   "remove", "rename", "rewind", "scanf", "setbuf", "setjmp",
 148   "setlocale", "setvbuf", "sig_atomic_t", "signal", "sin", "sinf",
 149   "sinh", "sinhf", "sinhl", "sinl", "size_t", "sprintf", "sqrt",
 150   "sqrtf", "sqrtl", "srand", "sscanf", "stderr", "stdin", "stdout",
 151   "strcat", "strchr", "strcmp", "strcoll", "strcpy", "strcspn",
 152   "strerror", "strftime", "strlen", "strncat", "strncmp", "strncpy",
 153   "strpbrk", "strrchr", "strspn", "strstr", "strtod", "strtok",
 154   "strtol", "strtoul", "strxfrm", "swprintf", "swscanf", "system",
 155   "tan", "tanf", "tanh", "tanhf", "tanhl", "tanl", "time", "time_t",
 156   "tmpfile", "tmpnam", "tolower", "toupper", "towctrans", "towlower",
 157   "towupper", "ungetc", "ungetwc", "va_arg", "va_copy", "va_end", "va_start",
 158   "vfprintf", "vfwprintf", "vprintf", "vsprintf", "vswprintf",
 159   "vwprintf", "wchar_t", "wcrtomb", "wcscat", "wcschr", "wcscmp",
 160   "wcscoll", "wcscpy", "wcscspn", "wcsftime", "wcslen", "wcsncat",
 161   "wcsncmp", "wcsncpy", "wcspbrk", "wcsrchr", "wcsrtombs", "wcsspn",
 162   "wcsstr", "wcstod", "wcstok", "wcstol", "wcstombs", "wcstoul",
 163   "wcsxfrm", "wctob", "wctomb", "wctrans", "wctrans_t", "wctype",
 164   "wctype_t", "wint_t", "wmemchr", "wmemcmp", "wmemcpy", "wmemmove",
 165   "wmemset", "wprintf", "wscanf", "xor", "xor_eq"
 166 };
 167
 168 #define NUMBER_OF_HEADERS              (sizeof header / sizeof *header)
 169 #define NUMBER_OF_PREFIXES             (sizeof prefix / sizeof *prefix)
 170 #define NUMBER_OF_SUFFIXES             (sizeof suffix / sizeof *suffix)
 171 #define NUMBER_OF_MACROS               (sizeof macros / sizeof *macros)
 172
 173
 174 /* Format string to build command to invoke compiler.  */
 175 static const char fmt[] = "\
 176 echo \"#include <%s>\" |\
 177 %s -E -dM -ansi -pedantic %s -D_LIBC -D_ISOMAC \
 178 -DIN_MODULE=MODULE_extramodules -I. \
 179 -isystem `%s --print-prog-name=include` - 2> /dev/null > %s";
 180
 181
 182 /* The compiler we use (given on the command line).  */
 183 char *CC;
 184 /* The -I parameters for CC to find all headers.  */
 185 char *INC;
 186
 187 static char *xstrndup (const char *, size_t);
 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   remove (macrofile);
 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   int fd = mkstemp (macrofile);
 252   if (fd == -1)
 253     {
 254       printf ("mkstemp failed: %m\n");
 255       exit (1);
 256     }
 257   close (fd);
 258
 259   command = malloc (sizeof fmt + sizeof "/dev/null" + 2 * strlen (CC)
 260                     + strlen (INC) + strlen (macrofile));
 261
 262   if (command == NULL)
 263     {
 264       puts ("No more memory.");
 265       exit (1);
 266     }
 267
 268   sprintf (command, fmt, "/dev/null", CC, INC, CC, macrofile);
 269
 270   if (system (command))
 271     {
 272       puts ("system() returned nonzero");
 273       free (command);
 274       return NULL;
 275     }
 276   free (command);
 277   input = fopen (macrofile, "r");
 278
 279   if (input == NULL)
 280     {
 281       printf ("Could not read %s: ", macrofile);
 282       perror (NULL);
 283       return NULL;
 284     }
 285
 286   while (fgets (line, sizeof line, input) != NULL)
 287     {
 288       int i, okay = 0;
 289       size_t endmac;
 290       char *start, *end;
 291       if (strlen (line) < 9 || line[7] != ' ')
 292         { /* "#define A" */
 293           printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
 294                   line);
 295           continue;
 296         }
 297       if (line[8] == '_')
 298         /* It's a safe identifier.  */
 299         continue;
 300       if (result_len == result_max)
 301         {
 302           result_max += 10;
 303           result = realloc (result, result_max * sizeof (char **));
 304           if (result == NULL)
 305             {
 306               puts ("No more memory.");
 307               exit (1);
 308             }
 309         }
 310       start = &line[8];
 311       for (end = start + 1; !isspace (*end) && *end != '\0'; ++end)
 312         ;
 313       result[result_len] = xstrndup (start, end - start);
 314
 315       if (strcmp (result[result_len], "IN_MODULE") != 0)
 316         {
 317           if (first)
 318             {
 319               fputs ("The following identifiers will be ignored since the compiler defines them\nby default:\n", stdout);
 320               first = 0;
 321             }
 322           puts (result[result_len]);
 323         }
 324       ++result_len;
 325     }
 326   if (result_len == result_max)
 327     {
 328       result_max += 1;
 329       result = realloc (result, result_max * sizeof (char **));
 330       if (result == NULL)
 331         {
 332           puts ("No more memory.");
 333           exit (1);
 334         }
 335     }
 336   result[result_len] = NULL;
 337   fclose (input);
 338
 339   return (const char **) result;
 340 }
 341
 342
 343 static int
 344 check_header (const char *file_name, const char **except)
 345 {
 346   char line[BUFSIZ], *command;
 347   FILE *input;
 348   int result = 0;
 349
 350   command = malloc (sizeof fmt + strlen (file_name) + 2 * strlen (CC)
 351                     + strlen (INC) + strlen (macrofile));
 352
 353   if (command == NULL)
 354     {
 355       puts ("No more memory.");
 356       exit (1);
 357     }
 358
 359   puts (file_name);
 360   sprintf (command, fmt, file_name, CC, INC, CC, macrofile);
 361
 362   if (system (command))
 363     {
 364       puts ("system() returned nonzero");
 365       result = 1;
 366     }
 367   free (command);
 368   input = fopen (macrofile, "r");
 369
 370   if (input == NULL)
 371     {
 372       printf ("Could not read %s: ", macrofile);
 373       perror (NULL);
 374       return 1;
 375     }
 376
 377   while (fgets (line, sizeof line, input) != NULL)
 378     {
 379       int i, okay = 0;
 380       size_t endmac;
 381       const char **cpp;
 382       if (strlen (line) < 9 || line[7] != ' ')
 383         { /* "#define A" */
 384           printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
 385                   line);
 386           result = 1;
 387           continue;
 388         }
 389       for (i = 0; i < NUMBER_OF_PREFIXES; ++i)
 390         {
 391           if (!strncmp (line+8, prefix[i], strlen (prefix[i]))) {
 392             ++okay;
 393             break;
 394           }
 395         }
 396       if (okay)
 397         continue;
 398       for (i = 0; i < NUMBER_OF_MACROS; ++i)
 399         {
 400           if (!strncmp (line + 8, macros[i], strlen (macros[i])))
 401             {
 402               ++okay;
 403               break;
 404             }
 405         }
 406       if (okay)
 407         continue;
 408       /* Find next char after the macro identifier; this can be either
 409          a space or an open parenthesis.  */
 410       endmac = strcspn (line + 8, " (");
 411       if (line[8+endmac] == '\0')
 412         {
 413           printf ("malformed input, expected '#define MACRO VALUE'\n"
 414                   "got '%s'\n", line);
 415           result = 1;
 416           continue;
 417         }
 418       for (i = 0; i < NUMBER_OF_SUFFIXES; ++i)
 419         {
 420           size_t len = strlen (suffix[i]);
 421           if (!strncmp (line + 8 + endmac - len, suffix[i], len))
 422             {
 423               ++okay;
 424               break;
 425             }
 426         }
 427       if (okay)
 428         continue;
 429       if (except != NULL)
 430         for (cpp = except; *cpp != NULL; ++cpp)
 431           {
 432             size_t len = strlen (*cpp);
 433             if (!strncmp (line + 8, *cpp, len) && isspace (line[8 + len]))
 434               {
 435                 ++okay;
 436                 break;
 437               }
 438           }
 439       if (!okay)
 440         {
 441           fputs (line, stdout);
 442           result = 2;
 443         }
 444     }
 445   fclose (input);
 446
 447   return result;
 448 }
 449
 450 /* EOF */