* texi2pod.pl: Convert two single quotes or two backquotes to
[official-gcc.git] / fixincludes / fixincl.c
blob250f0b01b62f1478072b96128582a81763830457
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.
5 Copyright (C) 1997, 1998, 1999, 2000, 2004 Free Software Foundation, Inc.
7 This file is part of GCC.
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.
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.
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. */
24 #include "fixlib.h"
26 #include <sys/stat.h>
27 #ifndef SEPARATE_FIX_PROC
28 #include <sys/wait.h>
29 #endif
31 #if defined( HAVE_MMAP_FILE )
32 #include <sys/mman.h>
33 #define BAD_ADDR ((void*)-1)
34 #endif
36 #ifndef SEPARATE_FIX_PROC
37 #include "server.h"
38 #endif
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. */
43 static const char program_id[] = "fixincl version 1.1";
45 /* This format will be used at the start of every generated file */
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";
54 int find_base_len = 0;
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;
65 te_verbose verbose_level = VERB_PROGRESS;
66 int have_tty = 0;
68 #define VLEVEL(l) ((unsigned int) verbose_level >= (unsigned int) l)
69 #define NOT_SILENT VLEVEL(VERB_FIXES)
71 pid_t process_chain_head = (pid_t) -1;
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;
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 */
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;
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);
99 /* External Source Code */
101 #include "fixincl.x"
103 /* * * * * * * * * * * * * * * * * * *
105 * MAIN ROUTINE
107 extern int main (int, char **);
109 main (int argc, char** argv)
111 char *file_name_buf;
113 initialize ( argc, argv );
115 have_tty = isatty (fileno (stderr));
117 /* Before anything else, ensure we can allocate our file name buffer. */
118 file_name_buf = load_file_data (stdin);
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 */
124 freopen ("/dev/null", "r", stdin);
126 if (file_name_buf == (char *) NULL)
128 fputs ("No file names listed for fixing\n", stderr);
129 exit (EXIT_FAILURE);
132 for (;;)
134 char* pz_end;
136 /* skip to start of name, past any "./" prefixes */
138 while (ISSPACE (*file_name_buf)) file_name_buf++;
139 while ((file_name_buf[0] == '.') && (file_name_buf[1] == '/'))
140 file_name_buf += 2;
142 /* Check for end of list */
144 if (*file_name_buf == NUL)
145 break;
147 /* Set global file name pointer and find end of name */
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;
156 while ((pz_end > pz_curr_file) && ISSPACE( pz_end[-1])) pz_end--;
158 /* IF no name is found (blank line) or comment marker, skip line */
160 if ((pz_curr_file == pz_end) || (*pz_curr_file == '#'))
161 continue;
162 *pz_end = NUL;
164 process ();
165 } /* for (;;) */
167 #ifdef DO_STATS
168 if (VLEVEL( VERB_PROGRESS )) {
169 tSCC zFmt[] =
171 Processed %5d files containing %d bytes \n\
172 Applying %5d fixes to %d files\n\
173 Altering %5d of them\n";
175 fprintf (stderr, zFmt, process_ct, ttl_data_size, apply_ct,
176 fixed_ct, altered_ct);
178 #endif /* DO_STATS */
180 # ifdef SEPARATE_FIX_PROC
181 unlink( pz_temp_file );
182 # endif
183 exit (EXIT_SUCCESS);
187 static void
188 do_version (void)
190 static const char zFmt[] = "echo '%s'";
191 char zBuf[ 1024 ];
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
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
208 /* * * * * * * * * * * * */
210 void
211 initialize ( int argc, char** argv )
213 xmalloc_set_program_name (argv[0]);
215 switch (argc)
217 case 1:
218 break;
220 case 2:
221 if (strcmp (argv[1], "-v") == 0)
222 do_version ();
223 if (freopen (argv[1], "r", stdin) == (FILE*)NULL)
225 fprintf (stderr, "Error %d (%s) reopening %s as stdin\n",
226 errno, xstrerror (errno), argv[1] );
227 exit (EXIT_FAILURE);
229 break;
231 default:
232 fputs ("fixincl ERROR: too many command line arguments\n", stderr);
233 exit (EXIT_FAILURE);
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
242 initialize_opts ();
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;
252 case 'f':
253 case 'F':
254 verbose_level = VERB_FIXES; break;
256 case 'a':
257 case 'A':
258 verbose_level = VERB_APPLIES; break;
260 default:
261 case 'p':
262 case 'P':
263 verbose_level = VERB_PROGRESS; break;
265 case 't':
266 case 'T':
267 verbose_level = VERB_TESTS; break;
269 case 'e':
270 case 'E':
271 verbose_level = VERB_EVERYTHING; break;
273 if (verbose_level >= VERB_EVERYTHING) {
274 verbose_level = VERB_EVERYTHING;
275 fputs ("fixinc verbosity: EVERYTHING\n", stderr);
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 );
282 /* Compile all the regular expressions now.
283 That way, it is done only once for the whole run.
285 run_compiles ();
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
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);
300 /* * * * * * * * * * * * *
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 )
309 struct stat stbf;
310 char* res;
312 if (stat (fname, &stbf) != 0)
314 if (NOT_SILENT)
315 fprintf (stderr, "error %d (%s) stat-ing %s\n",
316 errno, xstrerror (errno), fname );
317 return (char *) NULL;
319 if (stbf.st_size == 0)
320 return (char*)NULL;
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;
330 if (data_map_fd < 0)
332 if (NOT_SILENT)
333 fprintf (stderr, "error %d (%s) opening %s for read\n",
334 errno, xstrerror (errno), fname);
335 return (char*)NULL;
338 #ifdef HAVE_MMAP_FILE
339 curr_data_mapped = BOOL_TRUE;
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
351 FILE* fp = fdopen (data_map_fd, "r");
352 curr_data_mapped = BOOL_FALSE;
353 res = load_file_data (fp);
354 fclose (fp);
357 return res;
360 static int
361 machine_matches( tFixDesc* p_fixd )
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 */
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 */
378 /* Start the case statement */
380 sprintf (cmd_buf, case_fmt, pz_machine);
381 pz = cmd_buf + strlen (cmd_buf);
383 /* Determine if a match means to apply the fix or not apply it */
385 if (p_fixd->fd_flags & FD_MACH_IFNOT)
387 pz_if_true = skip;
388 pz_if_false = run;
390 else
392 pz_if_true = run;
393 pz_if_false = skip;
396 /* Emit all the machine names. If there are more than one,
397 then we will insert " | \\\n" between the names */
399 for (;;)
401 const char* pz_mach = *(papz_machs++);
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";
410 /* Now emit the match and not-match actions and the esac */
412 sprintf (pz, esac_fmt, pz_if_true, pz_if_false);
414 /* Run the script.
415 The result will start either with 's' or 'r'. */
418 int skip;
419 pz = run_shell (cmd_buf);
420 skip = (*pz == 's');
421 free ( (void*)pz );
422 if (skip)
424 p_fixd->fd_flags |= FD_SKIP_TEST;
425 return BOOL_FALSE;
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 (;;)
435 const char* pz_mach = *(papz_machs++);
437 if (pz_mach == (const char*) NULL)
438 break;
439 if (strstr (pz_mach, "dos") != NULL && !invert)
440 return BOOL_TRUE;
443 p_fixd->fd_flags |= FD_SKIP_TEST;
444 return BOOL_FALSE;
445 # endif
448 /* * * * * * * * * * * * *
450 run_compiles run all the regexp compiles for all the fixes once.
452 void
453 run_compiles (void)
455 tFixDesc *p_fixd = fixDescList;
456 int fix_ct = FIX_COUNT;
457 regex_t *p_re = XCNEWVEC (regex_t, REGEX_COUNT);
459 /* Make sure compile_re does not stumble across invalid data */
461 memset (&incl_quote_re, '\0', sizeof (regex_t));
463 compile_re (incl_quote_pat, &incl_quote_re, 1,
464 "quoted include", "run_compiles");
466 /* Allow machine name tests to be ignored (testing, mainly) */
468 if (pz_machine && ((*pz_machine == '\0') || (*pz_machine == '*')))
469 pz_machine = (char*)NULL;
471 /* FOR every fixup, ... */
474 tTestDesc *p_test = p_fixd->p_test_desc;
475 int test_ct = p_fixd->test_ct;
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 ... */
481 if ( (pz_machine != NULL)
482 && (p_fixd->papz_machs != (const char**) NULL)
483 && ! machine_matches (p_fixd) )
484 continue;
486 /* FOR every test for the fixup, ... */
488 while (--test_ct >= 0)
490 switch (p_test->type)
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;
499 p_test++;
502 while (p_fixd++, --fix_ct > 0);
506 /* * * * * * * * * * * * *
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 */
512 #if defined(S_IRUSR) && defined(S_IWUSR) && \
513 defined(S_IRGRP) && defined(S_IROTH)
515 # define S_IRALL (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
516 #else
517 # define S_IRALL 0644
518 #endif
520 #if defined(S_IRWXU) && defined(S_IRGRP) && defined(S_IXGRP) && \
521 defined(S_IROTH) && defined(S_IXOTH)
523 # define S_DIRALL (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
524 #else
525 # define S_DIRALL 0755
526 #endif
529 static FILE *
530 create_file (void)
532 int fd;
533 FILE *pf;
534 char fname[MAXPATHLEN];
536 sprintf (fname, "%s/%s", pz_dest_dir, pz_curr_file + find_base_len);
538 fd = open (fname, O_WRONLY | O_CREAT | O_TRUNC, S_IRALL);
540 /* We may need to create the directories needed... */
541 if ((fd < 0) && (errno == ENOENT))
543 char *pz_dir = strchr (fname + 1, '/');
544 struct stat stbf;
546 while (pz_dir != (char *) NULL)
548 *pz_dir = NUL;
549 if (stat (fname, &stbf) < 0)
551 #ifdef _WIN32
552 mkdir (fname);
553 #else
554 mkdir (fname, S_IFDIR | S_DIRALL);
555 #endif
558 *pz_dir = '/';
559 pz_dir = strchr (pz_dir + 1, '/');
562 /* Now, lets try the open again... */
563 fd = open (fname, O_WRONLY | O_CREAT | O_TRUNC, S_IRALL);
565 if (fd < 0)
567 fprintf (stderr, "Error %d (%s) creating %s\n",
568 errno, xstrerror (errno), fname);
569 exit (EXIT_FAILURE);
571 if (NOT_SILENT)
572 fprintf (stderr, "Fixed: %s\n", pz_curr_file);
573 pf = fdopen (fd, "w");
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.
579 fprintf (pf, z_std_preamble,
580 (pz_machine == NULL)
581 ? "fixinc/tests/inc"
582 : pz_input_dir,
583 pz_curr_file);
585 return pf;
589 /* * * * * * * * * * * * *
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)
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";
607 char *pz_res;
608 int res;
610 static char cmd_buf[4096];
612 sprintf (cmd_buf, cmd_fmt, pz_test_file, p_test->pz_test_text);
613 pz_res = run_shell (cmd_buf);
615 switch (*pz_res) {
616 case 'T':
617 res = APPLY_FIX;
618 break;
620 case 'F':
621 res = SKIP_FIX;
622 break;
624 default:
625 fprintf (stderr, "Script yielded bogus result of `%s':\n%s\n\n",
626 pz_res, cmd_buf );
627 res = SKIP_FIX;
630 free ((void *) pz_res);
631 return res;
633 #else
635 * IF we are in MS-DOS land, then whatever shell-type test is required
636 * will, by definition, fail
638 #define test_test(t,tf) SKIP_FIX
639 #endif
641 /* * * * * * * * * * * * *
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
648 The caller may choose to reverse meaning if the sense of the test
649 is inverted. */
651 static int
652 egrep_test (char* pz_data, tTestDesc* p_test)
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;
665 /* * * * * * * * * * * * *
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. */
671 static int
672 quoted_file_exists (const char* pz_src_path,
673 const char* pz_file_path,
674 const char* pz_file)
676 char z[ MAXPATHLEN ];
677 char* pz;
678 sprintf (z, "%s/%s/", pz_src_path, pz_file_path);
679 pz = z + strlen ( z );
681 for (;;) {
682 char ch = *pz_file++;
683 if (! ISGRAPH( ch ))
684 return 0;
685 if (ch == '"')
686 break;
687 *pz++ = ch;
689 *pz = '\0';
691 struct stat s;
692 if (stat (z, &s) != 0)
693 return 0;
694 return S_ISREG( s.st_mode );
699 /* * * * * * * * * * * * *
701 extract_quoted_files
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:
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
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 */
721 static void
722 extract_quoted_files (char* pz_data,
723 const char* pz_fixed_file,
724 regmatch_t* p_re_match)
726 char *pz_dir_end = strrchr (pz_fixed_file, '/');
727 char *pz_incl_quot = pz_data;
729 if (VLEVEL( VERB_APPLIES ))
730 fprintf (stderr, "Quoted includes in %s\n", pz_fixed_file);
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, ".". */
735 if (pz_dir_end == (char *) NULL)
736 pz_fixed_file = ".";
737 else
738 *pz_dir_end = '\0';
740 for (;;)
742 pz_incl_quot += p_re_match->rm_so;
744 /* Skip forward to the included file name */
745 while (*pz_incl_quot != '"')
746 pz_incl_quot++;
748 if (quoted_file_exists (pz_src_dir, pz_fixed_file, pz_incl_quot))
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;
755 /* Append to the directory the relative path of the desired file */
756 while (*pz_incl_quot != '"')
757 putc (*pz_incl_quot++, stdout);
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);
765 /* End of entry */
766 putc ('\n', stdout);
769 /* Find the next entry */
770 if (xregexec (&incl_quote_re, pz_incl_quot, 1, p_re_match, 0) != 0)
771 break;
776 /* * * * * * * * * * * * *
778 Somebody wrote a *_fix subroutine that we must call.
780 #ifndef SEPARATE_FIX_PROC
781 static int
782 internal_fix (int read_fd, tFixDesc* p_fixd)
784 int fd[2];
786 if (pipe( fd ) != 0)
788 fprintf (stderr, "Error %d on pipe(2) call\n", errno );
789 exit (EXIT_FAILURE);
792 for (;;)
794 pid_t childid = fork();
796 switch (childid)
798 case -1:
799 break;
801 case 0:
802 close (fd[0]);
803 goto do_child_task;
805 default:
807 * Parent process
809 close (read_fd);
810 close (fd[1]);
811 return fd[0];
815 * Parent in error
817 fprintf (stderr, z_fork_err, errno, xstrerror (errno),
818 p_fixd->fix_name);
820 static int failCt = 0;
821 if ((errno != EAGAIN) || (++failCt > 10))
822 exit (EXIT_FAILURE);
823 sleep (1);
825 } do_child_task:;
828 * Close our current stdin and stdout
830 close (STDIN_FILENO);
831 close (STDOUT_FILENO);
832 UNLOAD_DATA();
835 * Make the fd passed in the stdin, and the write end of
836 * the new pipe become the stdout.
838 dup2 (fd[1], STDOUT_FILENO);
839 dup2 (read_fd, STDIN_FILENO);
841 apply_fix (p_fixd, pz_curr_file);
842 exit (0);
844 #endif /* !SEPARATE_FIX_PROC */
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)
854 char* pz_cmd;
855 char* pz_scan;
856 size_t argsize;
858 if (p_fixd->fd_flags & FD_SUBROUTINE)
860 static const char z_applyfix_prog[] =
861 "/../fixincludes/applyfix" EXE_EXT;
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);
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);
876 strcpy (pz_scan, z_applyfix_prog);
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)
882 strcpy (pz_scan, "/..");
883 strcpy (pz_scan+3, z_applyfix_prog);
886 pz_scan += strlen (pz_scan);
889 * Now add the fix number and file names that may be needed
891 sprintf (pz_scan, " %ld '%s' '%s' '%s'", p_fixd - fixDescList,
892 pz_fix_file, pz_file_source, pz_temp_file);
894 else /* NOT an "internal" fix: */
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.
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;
918 argsize = sizeof( z_cmd_fmt ) + strlen( pz_temp_file )
919 + strlen( pz_file_source );
920 parg_size = argsize;
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. :)
930 for (;;)
932 tCC* p_arg = *(ppArgs++);
933 if (p_arg == NULL)
934 break;
935 argsize += 24 + strlen( p_arg );
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;
944 ppArgs = p_fixd->patch_args;
947 * Copy the program name, unquoted
950 tCC* pArg = *(ppArgs++);
951 for (;;)
953 char ch = *(pArg++);
954 if (ch == NUL)
955 break;
956 *(pz_scan++) = ch;
961 * Copy the program arguments, quoted
963 for (;;)
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) );
973 * Make sure we don't overflow the buffer due to sloppy
974 * size estimation.
976 while (pz_scan == (char*)NULL)
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) );
988 * add the file machinations.
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
997 system( pz_cmd );
998 free( (void*)pz_cmd );
1001 /* * * * * * * * * * * * *
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. */
1008 #else /* is *NOT* SEPARATE_FIX_PROC */
1009 static int
1010 start_fixer (int read_fd, tFixDesc* p_fixd, char* pz_fix_file)
1012 tCC* pz_cmd_save;
1013 char* pz_cmd;
1015 if ((p_fixd->fd_flags & FD_SUBROUTINE) != 0)
1016 return internal_fix (read_fd, p_fixd);
1018 if ((p_fixd->fd_flags & FD_SHELL_SCRIPT) == 0)
1020 pz_cmd = NULL;
1021 pz_cmd_save = NULL;
1023 else
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;
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.
1039 for (;;)
1041 static int failCt = 0;
1042 int fd;
1044 fd = chain_open (read_fd,
1045 (tCC **) p_fixd->patch_args,
1046 (process_chain_head == -1)
1047 ? &process_chain_head : (pid_t *) NULL);
1049 if (fd != -1)
1051 read_fd = fd;
1052 break;
1055 fprintf (stderr, z_fork_err, errno, xstrerror (errno),
1056 p_fixd->fix_name);
1058 if ((errno != EAGAIN) || (++failCt > 10))
1059 exit (EXIT_FAILURE);
1060 sleep (1);
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)
1067 free ((void*)pz_cmd);
1068 p_fixd->patch_args[2] = pz_cmd_save;
1071 return read_fd;
1073 #endif
1076 /* * * * * * * * * * * * *
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. */
1082 static t_bool
1083 fix_applies (tFixDesc* p_fixd)
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;
1090 # ifdef SEPARATE_FIX_PROC
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.
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
1103 /* IF there is a file name restriction,
1104 THEN ensure the current file name matches one in the pattern */
1106 if (pz_scan != (char *) NULL)
1108 size_t name_len;
1110 while ((pz_fname[0] == '.') && (pz_fname[1] == '/'))
1111 pz_fname += 2;
1112 name_len = strlen (pz_fname);
1114 for (;;)
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;
1122 /* IF the match is surrounded by the '|' markers,
1123 THEN we found a full match -- time to run the tests */
1125 if ((pz_scan[-1] == '|') && (pz_scan[name_len] == '|'))
1126 break;
1130 /* FOR each test, see if it fails.
1131 IF it does fail, then we go on to the next test */
1133 for (p_test = p_fixd->p_test_desc, test_ct = p_fixd->test_ct;
1134 test_ct-- > 0;
1135 p_test++)
1137 switch (p_test->type)
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;
1148 break;
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;
1159 break;
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;
1171 break;
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;
1183 break;
1187 return BOOL_TRUE;
1191 /* * * * * * * * * * * * *
1193 Write out a replacement file */
1195 static void
1196 write_replacement (tFixDesc* p_fixd)
1198 const char* pz_text = p_fixd->patch_args[0];
1200 if ((pz_text == (char*)NULL) || (*pz_text == NUL))
1201 return;
1204 FILE* out_fp = create_file ();
1205 fputs (pz_text, out_fp);
1206 fclose (out_fp);
1211 /* * * * * * * * * * * * *
1213 We have work to do. Read back in the output
1214 of the filtering chain. Compare each byte as we read it with
1215 the contents of the original file. As soon as we find any
1216 difference, we will create the output file, write out all
1217 the matched text and then copy any remaining data from the
1218 output of the filter chain.
1220 static void
1221 test_for_changes (int read_fd)
1223 FILE *in_fp = fdopen (read_fd, "r");
1224 FILE *out_fp = (FILE *) NULL;
1225 unsigned char *pz_cmp = (unsigned char*)pz_curr_data;
1227 #ifdef DO_STATS
1228 fixed_ct++;
1229 #endif
1230 for (;;)
1232 int ch;
1234 ch = getc (in_fp);
1235 if (ch == EOF)
1236 break;
1237 ch &= 0xFF; /* all bytes are 8 bits */
1239 /* IF we are emitting the output
1240 THEN emit this character, too.
1242 if (out_fp != (FILE *) NULL)
1243 putc (ch, out_fp);
1245 /* ELSE if this character does not match the original,
1246 THEN now is the time to start the output.
1248 else if (ch != *pz_cmp)
1250 out_fp = create_file ();
1252 #ifdef DO_STATS
1253 altered_ct++;
1254 #endif
1255 /* IF there are matched data, write the matched part now. */
1256 if ((char*)pz_cmp != pz_curr_data)
1257 fwrite (pz_curr_data, (size_t)((char*)pz_cmp - pz_curr_data),
1258 1, out_fp);
1260 /* Emit the current unmatching character */
1261 putc (ch, out_fp);
1263 else
1264 /* ELSE the character matches. Advance the compare ptr */
1265 pz_cmp++;
1268 /* IF we created the output file, ... */
1269 if (out_fp != (FILE *) NULL)
1271 regmatch_t match;
1273 /* Close the file and see if we have to worry about
1274 `#include "file.h"' constructs. */
1275 fclose (out_fp);
1276 if (xregexec (&incl_quote_re, pz_curr_data, 1, &match, 0) == 0)
1277 extract_quoted_files (pz_curr_data, pz_curr_file, &match);
1280 fclose (in_fp);
1281 close (read_fd); /* probably redundant, but I'm paranoid */
1285 /* * * * * * * * * * * * *
1287 Process the potential fixes for a particular include file.
1288 Input: the original text of the file and the file's name
1289 Result: none. A new file may or may not be created. */
1291 void
1292 process (void)
1294 tFixDesc *p_fixd = fixDescList;
1295 int todo_ct = FIX_COUNT;
1296 int read_fd = -1;
1297 # ifndef SEPARATE_FIX_PROC
1298 int num_children = 0;
1299 # else /* is SEPARATE_FIX_PROC */
1300 char* pz_file_source = pz_curr_file;
1301 # endif
1303 if (access (pz_curr_file, R_OK) != 0)
1305 int erno = errno;
1306 fprintf (stderr, "Cannot access %s from %s\n\terror %d (%s)\n",
1307 pz_curr_file, getcwd ((char *) NULL, MAXPATHLEN),
1308 erno, xstrerror (erno));
1309 return;
1312 pz_curr_data = load_file (pz_curr_file);
1313 if (pz_curr_data == (char *) NULL)
1314 return;
1316 #ifdef DO_STATS
1317 process_ct++;
1318 #endif
1319 if (VLEVEL( VERB_PROGRESS ) && have_tty)
1320 fprintf (stderr, "%6lu %-50s \r",
1321 (unsigned long) data_map_size, pz_curr_file);
1323 # ifndef SEPARATE_FIX_PROC
1324 process_chain_head = NOPROCESS;
1326 /* For every fix in our fix list, ... */
1327 for (; todo_ct > 0; p_fixd++, todo_ct--)
1329 if (! fix_applies (p_fixd))
1330 continue;
1332 if (VLEVEL( VERB_APPLIES ))
1333 fprintf (stderr, "Applying %-24s to %s\n",
1334 p_fixd->fix_name, pz_curr_file);
1336 if (p_fixd->fd_flags & FD_REPLACEMENT)
1338 write_replacement (p_fixd);
1339 UNLOAD_DATA();
1340 return;
1343 /* IF we do not have a read pointer,
1344 THEN this is the first fix for the current file.
1345 Open the source file. That will be used as stdin for
1346 the first fix. Any subsequent fixes will use the
1347 stdout descriptor of the previous fix for its stdin. */
1349 if (read_fd == -1)
1351 read_fd = open (pz_curr_file, O_RDONLY);
1352 if (read_fd < 0)
1354 fprintf (stderr, "Error %d (%s) opening %s\n", errno,
1355 xstrerror (errno), pz_curr_file);
1356 exit (EXIT_FAILURE);
1359 /* Ensure we do not get duplicate output */
1361 fflush (stdout);
1364 read_fd = start_fixer (read_fd, p_fixd, pz_curr_file);
1365 num_children++;
1368 /* IF we have a read-back file descriptor,
1369 THEN check for changes and write output if changed. */
1371 if (read_fd >= 0)
1373 test_for_changes (read_fd);
1374 #ifdef DO_STATS
1375 apply_ct += num_children;
1376 #endif
1377 /* Wait for child processes created by chain_open()
1378 to avoid leaving zombies. */
1379 do {
1380 wait ((int *) NULL);
1381 } while (--num_children > 0);
1384 # else /* is SEPARATE_FIX_PROC */
1386 for (; todo_ct > 0; p_fixd++, todo_ct--)
1388 if (! fix_applies (p_fixd))
1389 continue;
1391 if (VLEVEL( VERB_APPLIES ))
1392 fprintf (stderr, "Applying %-24s to %s\n",
1393 p_fixd->fix_name, pz_curr_file);
1395 if (p_fixd->fd_flags & FD_REPLACEMENT)
1397 write_replacement (p_fixd);
1398 UNLOAD_DATA();
1399 return;
1401 fix_with_system (p_fixd, pz_curr_file, pz_file_source, pz_temp_file);
1402 pz_file_source = pz_temp_file;
1405 read_fd = open (pz_temp_file, O_RDONLY);
1406 if (read_fd < 0)
1408 if (errno != ENOENT)
1409 fprintf (stderr, "error %d (%s) opening output (%s) for read\n",
1410 errno, xstrerror (errno), pz_temp_file);
1412 else
1414 test_for_changes (read_fd);
1415 /* Unlinking a file while it is still open is a Bad Idea on
1416 DOS/Windows. */
1417 close (read_fd);
1418 unlink (pz_temp_file);
1421 # endif
1422 UNLOAD_DATA();