fixincludes/fixincl.c

   1 /* Install modified versions of certain ANSI-incompatible system header
   2    files which are fixed to work correctly with ANSI C and placed in a
   3    directory that GCC will search.
   4
   5    Copyright (C) 1997, 1998, 1999, 2000, 2004 Free Software Foundation, Inc.
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  22 Boston, MA 02110-1301, USA.  */
  23
  24 #include "fixlib.h"
  25
  26 #include <sys/stat.h>
  27 #ifndef SEPARATE_FIX_PROC
  28 #include <sys/wait.h>
  29 #endif
  30
  31 #if defined( HAVE_MMAP_FILE )
  32 #include <sys/mman.h>
  33 #define  BAD_ADDR ((void*)-1)
  34 #endif
  35
  36 #ifndef SEPARATE_FIX_PROC
  37 #include "server.h"
  38 #endif
  39
  40 /*  The contents of this string are not very important.  It is mostly
  41     just used as part of the "I am alive and working" test.  */
  42
  43 static const char program_id[] = "fixincl version 1.1";
  44
  45 /*  This format will be used at the start of every generated file */
  46
  47 static const char z_std_preamble[] =
  48 "/*  DO NOT EDIT THIS FILE.\n\n\
  49     It has been auto-edited by fixincludes from:\n\n\
  50 \t\"%s/%s\"\n\n\
  51     This had to be done to correct non-standard usages in the\n\
  52     original, manufacturer supplied header file.  */\n\n";
  53
  54 int find_base_len = 0;
  55
  56 typedef enum {
  57   VERB_SILENT = 0,
  58   VERB_FIXES,
  59   VERB_APPLIES,
  60   VERB_PROGRESS,
  61   VERB_TESTS,
  62   VERB_EVERYTHING
  63 } te_verbose;
  64
  65 te_verbose  verbose_level = VERB_PROGRESS;
  66 int have_tty = 0;
  67
  68 #define VLEVEL(l)  ((unsigned int) verbose_level >= (unsigned int) l)
  69 #define NOT_SILENT VLEVEL(VERB_FIXES)
  70
  71 pid_t process_chain_head = (pid_t) -1;
  72
  73 char*  pz_curr_file;  /*  name of the current file under test/fix  */
  74 char*  pz_curr_data;  /*  original contents of that file  */
  75 char*  pz_temp_file;  /*  for DOS, a place to stash the temporary
  76                           fixed data between system(3) calls  */
  77 t_bool curr_data_mapped;
  78 int    data_map_fd;
  79 size_t data_map_size;
  80 size_t ttl_data_size = 0;
  81
  82 #ifdef DO_STATS
  83 int process_ct = 0;
  84 int apply_ct = 0;
  85 int fixed_ct = 0;
  86 int altered_ct = 0;
  87 #endif /* DO_STATS */
  88
  89 const char incl_quote_pat[] = "^[ \t]*#[ \t]*include[ \t]*\"[^/]";
  90 tSCC z_fork_err[] = "Error %d (%s) starting filter process for %s\n";
  91 regex_t incl_quote_re;
  92
  93 static void do_version (void) ATTRIBUTE_NORETURN;
  94 char *load_file (const char *);
  95 void run_compiles (void);
  96 void initialize (int argc, char** argv);
  97 void process (void);
  98
  99 /*  External Source Code */
 100
 101 #include "fixincl.x"
 102
 103 /* * * * * * * * * * * * * * * * * * *
 104  *
 105  *  MAIN ROUTINE
 106  */
 107 extern int main (int, char **);
 108 int
 109 main (int argc, char** argv)
 110 {
 111   char *file_name_buf;
 112
 113   initialize ( argc, argv );
 114
 115   have_tty = isatty (fileno (stderr));
 116
 117   /* Before anything else, ensure we can allocate our file name buffer. */
 118   file_name_buf = load_file_data (stdin);
 119
 120   /*  Because of the way server shells work, you have to keep stdin, out
 121       and err open so that the proper input file does not get closed
 122       by accident  */
 123
 124   freopen ("/dev/null", "r", stdin);
 125
 126   if (file_name_buf == (char *) NULL)
 127     {
 128       fputs ("No file names listed for fixing\n", stderr);
 129       exit (EXIT_FAILURE);
 130     }
 131
 132   for (;;)
 133     {
 134       char* pz_end;
 135
 136       /*  skip to start of name, past any "./" prefixes */
 137
 138       while (ISSPACE (*file_name_buf))  file_name_buf++;
 139       while ((file_name_buf[0] == '.') && (file_name_buf[1] == '/'))
 140         file_name_buf += 2;
 141
 142       /*  Check for end of list  */
 143
 144       if (*file_name_buf == NUL)
 145         break;
 146
 147       /*  Set global file name pointer and find end of name */
 148
 149       pz_curr_file = file_name_buf;
 150       pz_end = strchr( pz_curr_file, '\n' );
 151       if (pz_end == (char*)NULL)
 152         pz_end = file_name_buf = pz_curr_file + strlen (pz_curr_file);
 153       else
 154         file_name_buf = pz_end + 1;
 155
 156       while ((pz_end > pz_curr_file) && ISSPACE( pz_end[-1]))  pz_end--;
 157
 158       /*  IF no name is found (blank line) or comment marker, skip line  */
 159
 160       if ((pz_curr_file == pz_end) || (*pz_curr_file == '#'))
 161         continue;
 162       *pz_end = NUL;
 163
 164       process ();
 165     } /*  for (;;) */
 166
 167 #ifdef DO_STATS
 168   if (VLEVEL( VERB_PROGRESS )) {
 169     tSCC zFmt[] =
 170       "\
 171 Processed %5d files containing %d bytes    \n\
 172 Applying  %5d fixes to %d files\n\
 173 Altering  %5d of them\n";
 174
 175     fprintf (stderr, zFmt, process_ct, ttl_data_size, apply_ct,
 176              fixed_ct, altered_ct);
 177   }
 178 #endif /* DO_STATS */
 179
 180 # ifdef SEPARATE_FIX_PROC
 181   unlink( pz_temp_file );
 182 # endif
 183   exit (EXIT_SUCCESS);
 184 }
 185
 186
 187 static void
 188 do_version (void)
 189 {
 190   static const char zFmt[] = "echo '%s'";
 191   char zBuf[ 1024 ];
 192
 193   /* The 'version' option is really used to test that:
 194      1.  The program loads correctly (no missing libraries)
 195      2.  that we can compile all the regular expressions.
 196      3.  we can correctly run our server shell process
 197   */
 198   run_compiles ();
 199   sprintf (zBuf, zFmt, program_id);
 200 #ifndef SEPARATE_FIX_PROC
 201   puts (zBuf + 5);
 202   exit (strcmp (run_shell (zBuf), program_id));
 203 #else
 204   exit (system (zBuf));
 205 #endif
 206 }
 207
 208 /* * * * * * * * * * * * */
 209
 210 void
 211 initialize ( int argc, char** argv )
 212 {
 213   xmalloc_set_program_name (argv[0]);
 214
 215   switch (argc)
 216     {
 217     case 1:
 218       break;
 219
 220     case 2:
 221       if (strcmp (argv[1], "-v") == 0)
 222         do_version ();
 223       if (freopen (argv[1], "r", stdin) == (FILE*)NULL)
 224         {
 225           fprintf (stderr, "Error %d (%s) reopening %s as stdin\n",
 226                    errno, xstrerror (errno), argv[1] );
 227           exit (EXIT_FAILURE);
 228         }
 229       break;
 230
 231     default:
 232       fputs ("fixincl ERROR:  too many command line arguments\n", stderr);
 233       exit (EXIT_FAILURE);
 234     }
 235
 236 #ifdef SIGCHLD
 237   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
 238      receive the signal.  A different setting is inheritable */
 239   signal (SIGCHLD, SIG_DFL);
 240 #endif
 241
 242   initialize_opts ();
 243
 244   if (ISDIGIT ( *pz_verbose ))
 245     verbose_level = (te_verbose)atoi( pz_verbose );
 246   else
 247     switch (*pz_verbose) {
 248     case 's':
 249     case 'S':
 250       verbose_level = VERB_SILENT;     break;
 251
 252     case 'f':
 253     case 'F':
 254       verbose_level = VERB_FIXES;      break;
 255
 256     case 'a':
 257     case 'A':
 258       verbose_level = VERB_APPLIES;    break;
 259
 260     default:
 261     case 'p':
 262     case 'P':
 263       verbose_level = VERB_PROGRESS;   break;
 264
 265     case 't':
 266     case 'T':
 267       verbose_level = VERB_TESTS;      break;
 268
 269     case 'e':
 270     case 'E':
 271       verbose_level = VERB_EVERYTHING; break;
 272     }
 273   if (verbose_level >= VERB_EVERYTHING) {
 274     verbose_level = VERB_EVERYTHING;
 275     fputs ("fixinc verbosity:  EVERYTHING\n", stderr);
 276   }
 277   while ((pz_find_base[0] == '.') && (pz_find_base[1] == '/'))
 278     pz_find_base += 2;
 279   if ((pz_find_base[0] != '.') || (pz_find_base[1] != NUL))
 280     find_base_len = strlen( pz_find_base );
 281
 282   /*  Compile all the regular expressions now.
 283       That way, it is done only once for the whole run.
 284       */
 285   run_compiles ();
 286
 287 # ifdef SEPARATE_FIX_PROC
 288   /* NULL as the first argument to `tempnam' causes it to DTRT
 289      wrt the temporary directory where the file will be created.  */
 290   pz_temp_file = tempnam( NULL, "fxinc" );
 291 # endif
 292
 293   signal (SIGQUIT, SIG_IGN);
 294   signal (SIGIOT,  SIG_IGN);
 295   signal (SIGPIPE, SIG_IGN);
 296   signal (SIGALRM, SIG_IGN);
 297   signal (SIGTERM, SIG_IGN);
 298 }
 299
 300 /* * * * * * * * * * * * *
 301
 302    load_file loads all the contents of a file into malloc-ed memory.
 303    Its argument is the name of the file to read in; the returned
 304    result is the NUL terminated contents of the file.  The file
 305    is presumed to be an ASCII text file containing no NULs.  */
 306 char *
 307 load_file ( const char* fname )
 308 {
 309   struct stat stbf;
 310   char* res;
 311
 312   if (stat (fname, &stbf) != 0)
 313     {
 314       if (NOT_SILENT)
 315         fprintf (stderr, "error %d (%s) stat-ing %s\n",
 316                  errno, xstrerror (errno), fname );
 317       return (char *) NULL;
 318     }
 319   if (stbf.st_size == 0)
 320     return (char*)NULL;
 321
 322   /*  Make the data map size one larger than the file size for documentation
 323       purposes.  Truth is that there will be a following NUL character if
 324       the file size is not a multiple of the page size.  If it is a multiple,
 325       then this adjustment sometimes fails anyway.  */
 326   data_map_size = stbf.st_size+1;
 327   data_map_fd   = open (fname, O_RDONLY);
 328   ttl_data_size += data_map_size-1;
 329
 330   if (data_map_fd < 0)
 331     {
 332       if (NOT_SILENT)
 333         fprintf (stderr, "error %d (%s) opening %s for read\n",
 334                  errno, xstrerror (errno), fname);
 335       return (char*)NULL;
 336     }
 337
 338 #ifdef HAVE_MMAP_FILE
 339   curr_data_mapped = BOOL_TRUE;
 340
 341   /*  IF the file size is a multiple of the page size,
 342       THEN sometimes you will seg fault trying to access a trailing byte */
 343   if ((stbf.st_size & (getpagesize()-1)) == 0)
 344     res = (char*)BAD_ADDR;
 345   else
 346     res = (char*)mmap ((void*)NULL, data_map_size, PROT_READ,
 347                        MAP_PRIVATE, data_map_fd, 0);
 348   if (res == (char*)BAD_ADDR)
 349 #endif
 350     {
 351       FILE* fp = fdopen (data_map_fd, "r");
 352       curr_data_mapped = BOOL_FALSE;
 353       res = load_file_data (fp);
 354       fclose (fp);
 355     }
 356
 357   return res;
 358 }
 359
 360 static int
 361 machine_matches( tFixDesc* p_fixd )
 362         {
 363 # ifndef SEPARATE_FIX_PROC
 364           tSCC case_fmt[] = "case %s in\n";     /*  9 bytes, plus string */
 365           tSCC esac_fmt[] =
 366                " )\n    echo %s ;;\n* ) echo %s ;;\nesac";/*  4 bytes */
 367           tSCC skip[] = "skip";                 /*  4 bytes */
 368           tSCC run[] = "run";                   /*  3 bytes */
 369           /* total bytes to add to machine sum:    49 - see fixincl.tpl */
 370
 371           const char **papz_machs = p_fixd->papz_machs;
 372           char *pz;
 373           const char *pz_sep = "";
 374           tCC *pz_if_true;
 375           tCC *pz_if_false;
 376           char cmd_buf[ MACH_LIST_SIZE_LIMIT ]; /* size lim from fixincl.tpl */
 377
 378           /* Start the case statement */
 379
 380           sprintf (cmd_buf, case_fmt, pz_machine);
 381           pz = cmd_buf + strlen (cmd_buf);
 382
 383           /*  Determine if a match means to apply the fix or not apply it */
 384
 385           if (p_fixd->fd_flags & FD_MACH_IFNOT)
 386             {
 387               pz_if_true  = skip;
 388               pz_if_false = run;
 389             }
 390           else
 391             {
 392               pz_if_true  = run;
 393               pz_if_false = skip;
 394             }
 395
 396           /*  Emit all the machine names.  If there are more than one,
 397               then we will insert " | \\\n" between the names  */
 398
 399           for (;;)
 400             {
 401               const char* pz_mach = *(papz_machs++);
 402
 403               if (pz_mach == (const char*) NULL)
 404                 break;
 405               sprintf (pz, "%s%s", pz_sep, pz_mach);
 406               pz += strlen (pz);
 407               pz_sep = " | \\\n";
 408             }
 409
 410           /* Now emit the match and not-match actions and the esac */
 411
 412           sprintf (pz, esac_fmt, pz_if_true, pz_if_false);
 413
 414           /*  Run the script.
 415               The result will start either with 's' or 'r'.  */
 416
 417           {
 418             int skip;
 419             pz = run_shell (cmd_buf);
 420             skip = (*pz == 's');
 421             free ( (void*)pz );
 422             if (skip)
 423               {
 424                 p_fixd->fd_flags |= FD_SKIP_TEST;
 425                 return BOOL_FALSE;
 426               }
 427           }
 428
 429   return BOOL_TRUE;
 430 # else /* is SEPARATE_FIX_PROC */
 431   const char **papz_machs = p_fixd->papz_machs;
 432   int invert = (p_fixd->fd_flags & FD_MACH_IFNOT) != 0;
 433   for (;;)
 434     {
 435       const char* pz_mach = *(papz_machs++);
 436
 437       if (pz_mach == (const char*) NULL)
 438         break;
 439       if (strstr (pz_mach, "dos") != NULL && !invert)
 440         return BOOL_TRUE;
 441     }
 442
 443   p_fixd->fd_flags |= FD_SKIP_TEST;
 444   return BOOL_FALSE;
 445 # endif
 446 }
 447
 448 /* * * * * * * * * * * * *
 449
 450    run_compiles   run all the regexp compiles for all the fixes once.
 451    */
 452 void
 453 run_compiles (void)
 454 {
 455   tFixDesc *p_fixd = fixDescList;
 456   int fix_ct = FIX_COUNT;
 457   regex_t *p_re = XCNEWVEC (regex_t, REGEX_COUNT);
 458
 459   /*  Make sure compile_re does not stumble across invalid data */
 460
 461   memset (&incl_quote_re, '\0', sizeof (regex_t));
 462
 463   compile_re (incl_quote_pat, &incl_quote_re, 1,
 464               "quoted include", "run_compiles");
 465
 466   /*  Allow machine name tests to be ignored (testing, mainly) */
 467
 468   if (pz_machine && ((*pz_machine == '\0') || (*pz_machine == '*')))
 469     pz_machine = (char*)NULL;
 470
 471   /* FOR every fixup, ...  */
 472   do
 473     {
 474       tTestDesc *p_test = p_fixd->p_test_desc;
 475       int test_ct = p_fixd->test_ct;
 476
 477       /*  IF the machine type pointer is not NULL (we are not in test mode)
 478              AND this test is for or not done on particular machines
 479           THEN ...   */
 480
 481       if (  (pz_machine != NULL)
 482          && (p_fixd->papz_machs != (const char**) NULL)
 483          && ! machine_matches (p_fixd) )
 484         continue;
 485
 486       /* FOR every test for the fixup, ...  */
 487
 488       while (--test_ct >= 0)
 489         {
 490           switch (p_test->type)
 491             {
 492             case TT_EGREP:
 493             case TT_NEGREP:
 494               p_test->p_test_regex = p_re++;
 495               compile_re (p_test->pz_test_text, p_test->p_test_regex, 0,
 496                           "select test", p_fixd->fix_name);
 497             default: break;
 498             }
 499           p_test++;
 500         }
 501     }
 502   while (p_fixd++, --fix_ct > 0);
 503 }
 504
 505
 506 /* * * * * * * * * * * * *
 507
 508    create_file  Create the output modified file.
 509    Input:    the name of the file to create
 510    Returns:  a file pointer to the new, open file  */
 511
 512 #if defined(S_IRUSR) && defined(S_IWUSR) && \
 513     defined(S_IRGRP) && defined(S_IROTH)
 514
 515 #   define S_IRALL (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
 516 #else
 517 #   define S_IRALL 0644
 518 #endif
 519
 520 #if defined(S_IRWXU) && defined(S_IRGRP) && defined(S_IXGRP) && \
 521     defined(S_IROTH) && defined(S_IXOTH)
 522
 523 #   define S_DIRALL (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
 524 #else
 525 #   define S_DIRALL 0755
 526 #endif
 527
 528
 529 static FILE *
 530 create_file (void)
 531 {
 532   int fd;
 533   FILE *pf;
 534   char fname[MAXPATHLEN];
 535
 536   sprintf (fname, "%s/%s", pz_dest_dir, pz_curr_file + find_base_len);
 537
 538   fd = open (fname, O_WRONLY | O_CREAT | O_TRUNC, S_IRALL);
 539
 540   /*  We may need to create the directories needed... */
 541   if ((fd < 0) && (errno == ENOENT))
 542     {
 543       char *pz_dir = strchr (fname + 1, '/');
 544       struct stat stbf;
 545
 546       while (pz_dir != (char *) NULL)
 547         {
 548           *pz_dir = NUL;
 549           if (stat (fname, &stbf) < 0)
 550             {
 551 #ifdef _WIN32
 552               mkdir (fname);
 553 #else
 554               mkdir (fname, S_IFDIR | S_DIRALL);
 555 #endif
 556             }
 557
 558           *pz_dir = '/';
 559           pz_dir = strchr (pz_dir + 1, '/');
 560         }
 561
 562       /*  Now, lets try the open again... */
 563       fd = open (fname, O_WRONLY | O_CREAT | O_TRUNC, S_IRALL);
 564     }
 565   if (fd < 0)
 566     {
 567       fprintf (stderr, "Error %d (%s) creating %s\n",
 568                errno, xstrerror (errno), fname);
 569       exit (EXIT_FAILURE);
 570     }
 571   if (NOT_SILENT)
 572     fprintf (stderr, "Fixed:  %s\n", pz_curr_file);
 573   pf = fdopen (fd, "w");
 574
 575   /*
 576    *  IF pz_machine is NULL, then we are in some sort of test mode.
 577    *  Do not insert the current directory name.  Use a constant string.
 578    */
 579   fprintf (pf, z_std_preamble,
 580            (pz_machine == NULL)
 581            ? "fixinc/tests/inc"
 582            : pz_input_dir,
 583            pz_curr_file);
 584
 585   return pf;
 586 }
 587
 588
 589 /* * * * * * * * * * * * *
 590
 591   test_test   make sure a shell-style test expression passes.
 592   Input:  a pointer to the descriptor of the test to run and
 593           the name of the file that we might want to fix
 594   Result: APPLY_FIX or SKIP_FIX, depending on the result of the
 595           shell script we run.  */
 596 #ifndef SEPARATE_FIX_PROC
 597 static int
 598 test_test (tTestDesc* p_test, char* pz_test_file)
 599 {
 600   tSCC cmd_fmt[] =
 601 "file=%s\n\
 602 if ( test %s ) > /dev/null 2>&1\n\
 603 then echo TRUE\n\
 604 else echo FALSE\n\
 605 fi";
 606
 607   char *pz_res;
 608   int res;
 609
 610   static char cmd_buf[4096];
 611
 612   sprintf (cmd_buf, cmd_fmt, pz_test_file, p_test->pz_test_text);
 613   pz_res = run_shell (cmd_buf);
 614
 615   switch (*pz_res) {
 616   case 'T':
 617     res = APPLY_FIX;
 618     break;
 619
 620   case 'F':
 621     res = SKIP_FIX;
 622     break;
 623
 624   default:
 625     fprintf (stderr, "Script yielded bogus result of `%s':\n%s\n\n",
 626              pz_res, cmd_buf );
 627     res = SKIP_FIX;
 628   }
 629
 630   free ((void *) pz_res);
 631   return res;
 632 }
 633 #else
 634 /*
 635  *  IF we are in MS-DOS land, then whatever shell-type test is required
 636  *  will, by definition, fail
 637  */
 638 #define test_test(t,tf)  SKIP_FIX
 639 #endif
 640
 641 /* * * * * * * * * * * * *
 642
 643   egrep_test   make sure an egrep expression is found in the file text.
 644   Input:  a pointer to the descriptor of the test to run and
 645           the pointer to the contents of the file under suspicion
 646   Result: APPLY_FIX if the pattern is found, SKIP_FIX otherwise
 647
 648   The caller may choose to reverse meaning if the sense of the test
 649   is inverted.  */
 650
 651 static int
 652 egrep_test (char* pz_data, tTestDesc* p_test)
 653 {
 654 #ifdef DEBUG
 655   if (p_test->p_test_regex == 0)
 656     fprintf (stderr, "fixincl ERROR RE not compiled:  `%s'\n",
 657              p_test->pz_test_text);
 658 #endif
 659   if (xregexec (p_test->p_test_regex, pz_data, 0, 0, 0) == 0)
 660     return APPLY_FIX;
 661   return SKIP_FIX;
 662 }
 663
 664
 665 /* * * * * * * * * * * * *
 666
 667   quoted_file_exists  Make sure that a file exists before we emit
 668   the file name.  If we emit the name, our invoking shell will try
 669   to copy a non-existing file into the destination directory.  */
 670
 671 static int
 672 quoted_file_exists (const char* pz_src_path,
 673                     const char* pz_file_path,
 674                     const char* pz_file)
 675 {
 676   char z[ MAXPATHLEN ];
 677   char* pz;
 678   sprintf (z, "%s/%s/", pz_src_path, pz_file_path);
 679   pz = z + strlen ( z );
 680
 681   for (;;) {
 682     char ch = *pz_file++;
 683     if (! ISGRAPH( ch ))
 684       return 0;
 685     if (ch == '"')
 686       break;
 687     *pz++ = ch;
 688   }
 689   *pz = '\0';
 690   {
 691     struct stat s;
 692     if (stat (z, &s) != 0)
 693       return 0;
 694     return S_ISREG( s.st_mode );
 695   }
 696 }
 697
 698
 699 /* * * * * * * * * * * * *
 700  *
 701    extract_quoted_files
 702
 703    The syntax, `#include "file.h"' specifies that the compiler is to
 704    search the local directory of the current file before the include
 705    list.  Consequently, if we have modified a header and stored it in
 706    another directory, any files that are included by that modified
 707    file in that fashion must also be copied into this new directory.
 708    This routine finds those flavors of #include and for each one found
 709    emits a triple of:
 710
 711     1.  source directory of the original file
 712     2.  the relative path file name of the #includ-ed file
 713     3.  the full destination path for this file
 714
 715    Input:  the text of the file, the file name and a pointer to the
 716            match list where the match information was stored.
 717    Result: internally nothing.  The results are written to stdout
 718            for interpretation by the invoking shell  */
 719
 720
 721 static void
 722 extract_quoted_files (char* pz_data,
 723                       const char* pz_fixed_file,
 724                       regmatch_t* p_re_match)
 725 {
 726   char *pz_dir_end = strrchr (pz_fixed_file, '/');
 727   char *pz_incl_quot = pz_data;
 728
 729   if (VLEVEL( VERB_APPLIES ))
 730     fprintf (stderr, "Quoted includes in %s\n", pz_fixed_file);
 731
 732   /*  Set "pz_fixed_file" to point to the containing subdirectory of the source
 733       If there is none, then it is in our current directory, ".".   */
 734
 735   if (pz_dir_end == (char *) NULL)
 736     pz_fixed_file = ".";
 737   else
 738     *pz_dir_end = '\0';
 739
 740   for (;;)
 741     {
 742       pz_incl_quot += p_re_match->rm_so;
 743
 744       /*  Skip forward to the included file name */
 745       while (*pz_incl_quot != '"')
 746         pz_incl_quot++;
 747
 748       if (quoted_file_exists (pz_src_dir, pz_fixed_file, pz_incl_quot))
 749         {
 750           /* Print the source directory and the subdirectory
 751              of the file in question.  */
 752           printf ("%s  %s/", pz_src_dir, pz_fixed_file);
 753           pz_dir_end = pz_incl_quot;
 754
 755           /* Append to the directory the relative path of the desired file */
 756           while (*pz_incl_quot != '"')
 757             putc (*pz_incl_quot++, stdout);
 758
 759           /* Now print the destination directory appended with the
 760              relative path of the desired file */
 761           printf ("  %s/%s/", pz_dest_dir, pz_fixed_file);
 762           while (*pz_dir_end != '"')
 763             putc (*pz_dir_end++, stdout);
 764
 765           /* End of entry */
 766           putc ('\n', stdout);
 767         }
 768
 769       /* Find the next entry */
 770       if (xregexec (&incl_quote_re, pz_incl_quot, 1, p_re_match, 0) != 0)
 771         break;
 772     }
 773 }
 774
 775
 776 /* * * * * * * * * * * * *
 777
 778     Somebody wrote a *_fix subroutine that we must call.
 779     */
 780 #ifndef SEPARATE_FIX_PROC
 781 static int
 782 internal_fix (int read_fd, tFixDesc* p_fixd)
 783 {
 784   int fd[2];
 785
 786   if (pipe( fd ) != 0)
 787     {
 788       fprintf (stderr, "Error %d on pipe(2) call\n", errno );
 789       exit (EXIT_FAILURE);
 790     }
 791
 792   for (;;)
 793     {
 794       pid_t childid = fork();
 795
 796       switch (childid)
 797         {
 798         case -1:
 799           break;
 800
 801         case 0:
 802           close (fd[0]);
 803           goto do_child_task;
 804
 805         default:
 806           /*
 807            *  Parent process
 808            */
 809           close (read_fd);
 810           close (fd[1]);
 811           return fd[0];
 812         }
 813
 814       /*
 815        *  Parent in error
 816        */
 817       fprintf (stderr, z_fork_err, errno, xstrerror (errno),
 818                p_fixd->fix_name);
 819       {
 820         static int failCt = 0;
 821         if ((errno != EAGAIN) || (++failCt > 10))
 822           exit (EXIT_FAILURE);
 823         sleep (1);
 824       }
 825     } do_child_task:;
 826
 827   /*
 828    *  Close our current stdin and stdout
 829    */
 830   close (STDIN_FILENO);
 831   close (STDOUT_FILENO);
 832   UNLOAD_DATA();
 833
 834   /*
 835    *  Make the fd passed in the stdin, and the write end of
 836    *  the new pipe become the stdout.
 837    */
 838   dup2 (fd[1], STDOUT_FILENO);
 839   dup2 (read_fd, STDIN_FILENO);
 840
 841   apply_fix (p_fixd, pz_curr_file);
 842   exit (0);
 843 }
 844 #endif /* !SEPARATE_FIX_PROC */
 845
 846
 847 #ifdef SEPARATE_FIX_PROC
 848 static void
 849 fix_with_system (tFixDesc* p_fixd,
 850                  tCC* pz_fix_file,
 851                  tCC* pz_file_source,
 852                  tCC* pz_temp_file)
 853 {
 854   char*  pz_cmd;
 855   char*  pz_scan;
 856   size_t argsize;
 857
 858   if (p_fixd->fd_flags & FD_SUBROUTINE)
 859     {
 860       static const char z_applyfix_prog[] =
 861         "/../fixincludes/applyfix" EXE_EXT;
 862
 863       struct stat buf;
 864       argsize = 32
 865               + strlen (pz_orig_dir)
 866               + sizeof (z_applyfix_prog)
 867               + strlen (pz_fix_file)
 868               + strlen (pz_file_source)
 869               + strlen (pz_temp_file);
 870
 871       /* Allocate something sure to be big enough for our purposes */
 872       pz_cmd = XNEWVEC (char, argsize);
 873       strcpy (pz_cmd, pz_orig_dir);
 874       pz_scan = pz_cmd + strlen (pz_orig_dir);
 875
 876       strcpy (pz_scan, z_applyfix_prog);
 877
 878       /* IF we can't find the "applyfix" executable file at the first guess,
 879          try one level higher up  */
 880       if (stat (pz_cmd, &buf) == -1)
 881         {
 882           strcpy (pz_scan, "/..");
 883           strcpy (pz_scan+3, z_applyfix_prog);
 884         }
 885
 886       pz_scan += strlen (pz_scan);
 887
 888       /*
 889        *  Now add the fix number and file names that may be needed
 890        */
 891       sprintf (pz_scan, " %ld '%s' '%s' '%s'", p_fixd - fixDescList,
 892                pz_fix_file, pz_file_source, pz_temp_file);
 893     }
 894   else /* NOT an "internal" fix: */
 895     {
 896       size_t parg_size;
 897 #ifdef __MSDOS__
 898       /* Don't use the "src > dstX; rm -f dst; mv -f dstX dst" trick:
 899          dst is a temporary file anyway, so we know there's no other
 900          file by that name; and DOS's system(3) doesn't mind to
 901          clobber existing file in redirection.  Besides, with DOS 8+3
 902          limited file namespace, we can easily lose if dst already has
 903          an extension that is 3 or more characters long.
 904
 905          I do not think the 8+3 issue is relevant because all the files
 906          we operate on are named "*.h", making 8+2 adequate.  Anyway,
 907          the following bizarre use of 'cat' only works on DOS boxes.
 908          It causes the file to be dropped into a temporary file for
 909          'cat' to read (pipes do not work on DOS).  */
 910       tSCC   z_cmd_fmt[] = " '%s' | cat > '%s'";
 911 #else
 912       /* Don't use positional formatting arguments because some lame-o
 913          implementations cannot cope  :-(.  */
 914       tSCC   z_cmd_fmt[] = " %s > %sX ; rm -f %s; mv -f %sX %s";
 915 #endif
 916       tCC**  ppArgs = p_fixd->patch_args;
 917
 918       argsize = sizeof( z_cmd_fmt ) + strlen( pz_temp_file )
 919               + strlen( pz_file_source );
 920       parg_size = argsize;
 921
 922
 923       /*
 924        *  Compute the size of the command line.  Add lotsa extra space
 925        *  because some of the args to sed use lotsa single quotes.
 926        *  (This requires three extra bytes per quote.  Here we allow
 927        *  for up to 8 single quotes for each argument, including the
 928        *  command name "sed" itself.  Nobody will *ever* need more. :)
 929        */
 930       for (;;)
 931         {
 932           tCC* p_arg = *(ppArgs++);
 933           if (p_arg == NULL)
 934             break;
 935           argsize += 24 + strlen( p_arg );
 936         }
 937
 938       /* Estimated buffer size we will need.  */
 939       pz_scan = pz_cmd = XNEWVEC (char, argsize);
 940       /* How much of it do we allot to the program name and its
 941          arguments.  */
 942       parg_size = argsize - parg_size;
 943
 944       ppArgs = p_fixd->patch_args;
 945
 946       /*
 947        *  Copy the program name, unquoted
 948        */
 949       {
 950         tCC*   pArg = *(ppArgs++);
 951         for (;;)
 952           {
 953             char ch = *(pArg++);
 954             if (ch == NUL)
 955               break;
 956             *(pz_scan++) = ch;
 957           }
 958       }
 959
 960       /*
 961        *  Copy the program arguments, quoted
 962        */
 963       for (;;)
 964         {
 965           tCC*   pArg = *(ppArgs++);
 966           char*  pz_scan_save;
 967           if (pArg == NULL)
 968             break;
 969           *(pz_scan++) = ' ';
 970           pz_scan = make_raw_shell_str( pz_scan_save = pz_scan, pArg,
 971                                         parg_size - (pz_scan - pz_cmd) );
 972           /*
 973            *  Make sure we don't overflow the buffer due to sloppy
 974            *  size estimation.
 975            */
 976           while (pz_scan == (char*)NULL)
 977             {
 978               size_t already_filled = pz_scan_save - pz_cmd;
 979               pz_cmd = xrealloc (pz_cmd, argsize += 100);
 980               pz_scan_save = pz_scan = pz_cmd + already_filled;
 981               parg_size += 100;
 982               pz_scan = make_raw_shell_str( pz_scan, pArg,
 983                                             parg_size - (pz_scan - pz_cmd) );
 984             }
 985         }
 986
 987       /*
 988        *  add the file machinations.
 989        */
 990 #ifdef __MSDOS__
 991       sprintf (pz_scan, z_cmd_fmt, pz_file_source, pz_temp_file );
 992 #else
 993       sprintf (pz_scan, z_cmd_fmt, pz_file_source, pz_temp_file,
 994                pz_temp_file, pz_temp_file, pz_temp_file);
 995 #endif
 996     }
 997   system( pz_cmd );
 998   free( (void*)pz_cmd );
 999 }
1000
1001 /* * * * * * * * * * * * *
1002
1003     This loop should only cycle for 1/2 of one loop.
1004     "chain_open" starts a process that uses "read_fd" as
1005     its stdin and returns the new fd this process will use
1006     for stdout.  */
1007
1008 #else /* is *NOT* SEPARATE_FIX_PROC */
1009 static int
1010 start_fixer (int read_fd, tFixDesc* p_fixd, char* pz_fix_file)
1011 {
1012   tCC* pz_cmd_save;
1013   char* pz_cmd;
1014
1015   if ((p_fixd->fd_flags & FD_SUBROUTINE) != 0)
1016     return internal_fix (read_fd, p_fixd);
1017
1018   if ((p_fixd->fd_flags & FD_SHELL_SCRIPT) == 0)
1019     {
1020       pz_cmd = NULL;
1021       pz_cmd_save = NULL;
1022     }
1023   else
1024     {
1025       tSCC z_cmd_fmt[] = "file='%s'\n%s";
1026       pz_cmd = XNEWVEC (char, strlen (p_fixd->patch_args[2])
1027                         + sizeof (z_cmd_fmt) + strlen (pz_fix_file));
1028       sprintf (pz_cmd, z_cmd_fmt, pz_fix_file, p_fixd->patch_args[2]);
1029       pz_cmd_save = p_fixd->patch_args[2];
1030       p_fixd->patch_args[2] = pz_cmd;
1031     }
1032
1033   /*  Start a fix process, handing off the  previous read fd for its
1034       stdin and getting a new fd that reads from the fix process' stdout.
1035       We normally will not loop, but we will up to 10 times if we keep
1036       getting "EAGAIN" errors.
1037
1038       */
1039   for (;;)
1040     {
1041       static int failCt = 0;
1042       int fd;
1043
1044       fd = chain_open (read_fd,
1045                        (tCC **) p_fixd->patch_args,
1046                        (process_chain_head == -1)
1047                        ? &process_chain_head : (pid_t *) NULL);
1048
1049       if (fd != -1)
1050         {
1051           read_fd = fd;
1052           break;
1053         }
1054
1055       fprintf (stderr, z_fork_err, errno, xstrerror (errno),
1056                p_fixd->fix_name);
1057
1058       if ((errno != EAGAIN) || (++failCt > 10))
1059         exit (EXIT_FAILURE);
1060       sleep (1);
1061     }
1062
1063   /*  IF we allocated a shell script command,
1064       THEN free it and restore the command format to the fix description */
1065   if (pz_cmd != (char*)NULL)
1066     {
1067       free ((void*)pz_cmd);
1068       p_fixd->patch_args[2] = pz_cmd_save;
1069     }
1070
1071   return read_fd;
1072 }
1073 #endif
1074
1075
1076 /* * * * * * * * * * * * *
1077
1078    Process the potential fixes for a particular include file.
1079    Input:  the original text of the file and the file's name
1080    Result: none.  A new file may or may not be created.  */
1081
1082 static t_bool
1083 fix_applies (tFixDesc* p_fixd)
1084 {
1085   const char *pz_fname = pz_curr_file;
1086   const char *pz_scan = p_fixd->file_list;
1087   int test_ct;
1088   tTestDesc *p_test;
1089
1090 # ifdef SEPARATE_FIX_PROC
1091   /*
1092    *  There is only one fix that uses a shell script as of this writing.
1093    *  I hope to nuke it anyway, it does not apply to DOS and it would
1094    *  be painful to implement.  Therefore, no "shell" fixes for DOS.
1095    */
1096   if (p_fixd->fd_flags & (FD_SHELL_SCRIPT | FD_SKIP_TEST))
1097     return BOOL_FALSE;
1098 # else
1099   if (p_fixd->fd_flags & FD_SKIP_TEST)
1100     return BOOL_FALSE;
1101 # endif
1102
1103   /*  IF there is a file name restriction,
1104       THEN ensure the current file name matches one in the pattern  */
1105
1106   if (pz_scan != (char *) NULL)
1107     {
1108       size_t name_len;
1109
1110       while ((pz_fname[0] == '.') && (pz_fname[1] == '/'))
1111         pz_fname += 2;
1112       name_len = strlen (pz_fname);
1113
1114       for (;;)
1115         {
1116           pz_scan = strstr (pz_scan + 1, pz_fname);
1117           /*  IF we can't match the string at all,
1118               THEN bail  */
1119           if (pz_scan == (char *) NULL)
1120             return BOOL_FALSE;
1121
1122           /*  IF the match is surrounded by the '|' markers,
1123               THEN we found a full match -- time to run the tests  */
1124
1125           if ((pz_scan[-1] == '|') && (pz_scan[name_len] == '|'))
1126             break;
1127         }
1128     }
1129
1130   /*  FOR each test, see if it fails.
1131       IF it does fail, then we go on to the next test */
1132
1133   for (p_test = p_fixd->p_test_desc, test_ct = p_fixd->test_ct;
1134        test_ct-- > 0;
1135        p_test++)
1136     {
1137       switch (p_test->type)
1138         {
1139         case TT_TEST:
1140           if (test_test (p_test, pz_curr_file) != APPLY_FIX) {
1141 #ifdef DEBUG
1142             if (VLEVEL( VERB_EVERYTHING ))
1143               fprintf (stderr, z_failed, "TEST", p_fixd->fix_name,
1144                        pz_fname, p_fixd->test_ct - test_ct);
1145 #endif
1146             return BOOL_FALSE;
1147           }
1148           break;
1149
1150         case TT_EGREP:
1151           if (egrep_test (pz_curr_data, p_test) != APPLY_FIX) {
1152 #ifdef DEBUG
1153             if (VLEVEL( VERB_EVERYTHING ))
1154               fprintf (stderr, z_failed, "EGREP", p_fixd->fix_name,
1155                        pz_fname, p_fixd->test_ct - test_ct);
1156 #endif
1157             return BOOL_FALSE;
1158           }
1159           break;
1160
1161         case TT_NEGREP:
1162           if (egrep_test (pz_curr_data, p_test) == APPLY_FIX) {
1163 #ifdef DEBUG
1164             if (VLEVEL( VERB_EVERYTHING ))
1165               fprintf (stderr, z_failed, "NEGREP", p_fixd->fix_name,
1166                        pz_fname, p_fixd->test_ct - test_ct);
1167 #endif
1168             /*  Negated sense  */
1169             return BOOL_FALSE;
1170           }
1171           break;
1172
1173         case TT_FUNCTION:
1174           if (run_test (p_test->pz_test_text, pz_curr_file, pz_curr_data)
1175               != APPLY_FIX) {
1176 #ifdef DEBUG
1177             if (VLEVEL( VERB_EVERYTHING ))
1178               fprintf (stderr, z_failed, "FTEST", p_fixd->fix_name,
1179                        pz_fname, p_fixd->test_ct - test_ct);
1180 #endif
1181             return BOOL_FALSE;
1182           }
1183           break;
1184         }
1185     }
1186
1187   return BOOL_TRUE;
1188 }
1189
1190
1191 /* * * * * * * * * * * * *
1192
1193    Write out a replacement file  */
1194
1195 static void
1196 write_replacement (tFixDesc* p_fixd)
1197 {
1198    const char* pz_text = p_fixd->patch_args[0];
1199
1200    if ((pz_text == (char*)NULL) || (*pz_text == NUL))
1201      return;
1202
1203    {
1204      FILE* out_fp = create_file ();
1205      size_t sz = strlen (pz_text);
1206      fwrite (pz_text, sz, 1, out_fp);
1207      if (pz_text[ sz-1 ] != '\n')
1208        fputc ('\n', out_fp);
1209      fclose (out_fp);
1210    }
1211 }
1212
1213
1214 /* * * * * * * * * * * * *
1215
1216     We have work to do.  Read back in the output
1217     of the filtering chain.  Compare each byte as we read it with
1218     the contents of the original file.  As soon as we find any
1219     difference, we will create the output file, write out all
1220     the matched text and then copy any remaining data from the
1221     output of the filter chain.
1222     */
1223 static void
1224 test_for_changes (int read_fd)
1225 {
1226   FILE *in_fp = fdopen (read_fd, "r");
1227   FILE *out_fp = (FILE *) NULL;
1228   unsigned char *pz_cmp = (unsigned char*)pz_curr_data;
1229
1230 #ifdef DO_STATS
1231   fixed_ct++;
1232 #endif
1233   for (;;)
1234     {
1235       int ch;
1236
1237       ch = getc (in_fp);
1238       if (ch == EOF)
1239         break;
1240       ch &= 0xFF; /* all bytes are 8 bits */
1241
1242       /*  IF we are emitting the output
1243           THEN emit this character, too.
1244       */
1245       if (out_fp != (FILE *) NULL)
1246         putc (ch, out_fp);
1247
1248       /*  ELSE if this character does not match the original,
1249           THEN now is the time to start the output.
1250       */
1251       else if (ch != *pz_cmp)
1252         {
1253           out_fp = create_file ();
1254
1255 #ifdef DO_STATS
1256           altered_ct++;
1257 #endif
1258           /*  IF there are matched data, write the matched part now. */
1259           if ((char*)pz_cmp != pz_curr_data)
1260             fwrite (pz_curr_data, (size_t)((char*)pz_cmp - pz_curr_data),
1261                                         1, out_fp);
1262
1263           /*  Emit the current unmatching character */
1264           putc (ch, out_fp);
1265         }
1266       else
1267         /*  ELSE the character matches.  Advance the compare ptr */
1268         pz_cmp++;
1269     }
1270
1271   /*  IF we created the output file, ... */
1272   if (out_fp != (FILE *) NULL)
1273     {
1274       regmatch_t match;
1275
1276       /* Close the file and see if we have to worry about
1277          `#include "file.h"' constructs.  */
1278       fclose (out_fp);
1279       if (xregexec (&incl_quote_re, pz_curr_data, 1, &match, 0) == 0)
1280         extract_quoted_files (pz_curr_data, pz_curr_file, &match);
1281     }
1282
1283   fclose (in_fp);
1284   close (read_fd);  /* probably redundant, but I'm paranoid */
1285 }
1286
1287
1288 /* * * * * * * * * * * * *
1289
1290    Process the potential fixes for a particular include file.
1291    Input:  the original text of the file and the file's name
1292    Result: none.  A new file may or may not be created.  */
1293
1294 void
1295 process (void)
1296 {
1297   tFixDesc *p_fixd = fixDescList;
1298   int todo_ct = FIX_COUNT;
1299   int read_fd = -1;
1300 # ifndef SEPARATE_FIX_PROC
1301   int num_children = 0;
1302 # else /* is SEPARATE_FIX_PROC */
1303   char* pz_file_source = pz_curr_file;
1304 # endif
1305
1306   if (access (pz_curr_file, R_OK) != 0)
1307     {
1308       int erno = errno;
1309       fprintf (stderr, "Cannot access %s from %s\n\terror %d (%s)\n",
1310                pz_curr_file, getcwd ((char *) NULL, MAXPATHLEN),
1311                erno, xstrerror (erno));
1312       return;
1313     }
1314
1315   pz_curr_data = load_file (pz_curr_file);
1316   if (pz_curr_data == (char *) NULL)
1317     return;
1318
1319 #ifdef DO_STATS
1320   process_ct++;
1321 #endif
1322   if (VLEVEL( VERB_PROGRESS ) && have_tty)
1323     fprintf (stderr, "%6lu %-50s   \r",
1324              (unsigned long) data_map_size, pz_curr_file);
1325
1326 # ifndef SEPARATE_FIX_PROC
1327   process_chain_head = NOPROCESS;
1328
1329   /* For every fix in our fix list, ...  */
1330   for (; todo_ct > 0; p_fixd++, todo_ct--)
1331     {
1332       if (! fix_applies (p_fixd))
1333         continue;
1334
1335       if (VLEVEL( VERB_APPLIES ))
1336         fprintf (stderr, "Applying %-24s to %s\n",
1337                  p_fixd->fix_name, pz_curr_file);
1338
1339       if (p_fixd->fd_flags & FD_REPLACEMENT)
1340         {
1341           write_replacement (p_fixd);
1342           UNLOAD_DATA();
1343           return;
1344         }
1345
1346       /*  IF we do not have a read pointer,
1347           THEN this is the first fix for the current file.
1348           Open the source file.  That will be used as stdin for
1349           the first fix.  Any subsequent fixes will use the
1350           stdout descriptor of the previous fix for its stdin.  */
1351
1352       if (read_fd == -1)
1353         {
1354           read_fd = open (pz_curr_file, O_RDONLY);
1355           if (read_fd < 0)
1356             {
1357               fprintf (stderr, "Error %d (%s) opening %s\n", errno,
1358                        xstrerror (errno), pz_curr_file);
1359               exit (EXIT_FAILURE);
1360             }
1361
1362           /*  Ensure we do not get duplicate output */
1363
1364           fflush (stdout);
1365         }
1366
1367       read_fd = start_fixer (read_fd, p_fixd, pz_curr_file);
1368       num_children++;
1369     }
1370
1371   /*  IF we have a read-back file descriptor,
1372       THEN check for changes and write output if changed.   */
1373
1374   if (read_fd >= 0)
1375     {
1376       test_for_changes (read_fd);
1377 #ifdef DO_STATS
1378       apply_ct += num_children;
1379 #endif
1380       /* Wait for child processes created by chain_open()
1381          to avoid leaving zombies.  */
1382       do  {
1383         wait ((int *) NULL);
1384       } while (--num_children > 0);
1385     }
1386
1387 # else /* is SEPARATE_FIX_PROC */
1388
1389   for (; todo_ct > 0; p_fixd++, todo_ct--)
1390     {
1391       if (! fix_applies (p_fixd))
1392         continue;
1393
1394       if (VLEVEL( VERB_APPLIES ))
1395         fprintf (stderr, "Applying %-24s to %s\n",
1396                  p_fixd->fix_name, pz_curr_file);
1397
1398       if (p_fixd->fd_flags & FD_REPLACEMENT)
1399         {
1400           write_replacement (p_fixd);
1401           UNLOAD_DATA();
1402           return;
1403         }
1404       fix_with_system (p_fixd, pz_curr_file, pz_file_source, pz_temp_file);
1405       pz_file_source = pz_temp_file;
1406     }
1407
1408   read_fd = open (pz_temp_file, O_RDONLY);
1409   if (read_fd < 0)
1410     {
1411       if (errno != ENOENT)
1412         fprintf (stderr, "error %d (%s) opening output (%s) for read\n",
1413                  errno, xstrerror (errno), pz_temp_file);
1414     }
1415   else
1416     {
1417       test_for_changes (read_fd);
1418       /* Unlinking a file while it is still open is a Bad Idea on
1419          DOS/Windows.  */
1420       close (read_fd);
1421       unlink (pz_temp_file);
1422     }
1423
1424 # endif
1425   UNLOAD_DATA();
1426 }