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, 2009
6 Free Software Foundation, Inc.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
28 #ifndef SEPARATE_FIX_PROC
32 #if defined( HAVE_MMAP_FILE )
34 #define BAD_ADDR ((void*)-1)
37 #ifndef SEPARATE_FIX_PROC
41 /* The contents of this string are not very important. It is mostly
42 just used as part of the "I am alive and working" test. */
44 static const char program_id
[] = "fixincl version 1.1";
46 /* This format will be used at the start of every generated file */
48 static const char z_std_preamble
[] =
49 "/* DO NOT EDIT THIS FILE.\n\n\
50 It has been auto-edited by fixincludes from:\n\n\
52 This had to be done to correct non-standard usages in the\n\
53 original, manufacturer supplied header file. */\n\n";
55 int find_base_len
= 0;
66 te_verbose verbose_level
= VERB_PROGRESS
;
69 #define VLEVEL(l) ((unsigned int) verbose_level >= (unsigned int) l)
70 #define NOT_SILENT VLEVEL(VERB_FIXES)
72 pid_t process_chain_head
= (pid_t
) -1;
74 char* pz_curr_file
; /* name of the current file under test/fix */
75 char* pz_curr_data
; /* original contents of that file */
76 char* pz_temp_file
; /* for DOS, a place to stash the temporary
77 fixed data between system(3) calls */
78 t_bool curr_data_mapped
;
81 size_t ttl_data_size
= 0;
90 const char incl_quote_pat
[] = "^[ \t]*#[ \t]*include[ \t]*\"[^/]";
91 tSCC z_fork_err
[] = "Error %d (%s) starting filter process for %s\n";
92 regex_t incl_quote_re
;
94 static void do_version (void) ATTRIBUTE_NORETURN
;
95 char *load_file (const char *);
96 void run_compiles (void);
97 void initialize (int argc
, char** argv
);
100 /* External Source Code */
104 /* * * * * * * * * * * * * * * * * * *
108 extern int main (int, char **);
110 main (int argc
, char** argv
)
114 initialize ( argc
, argv
);
116 have_tty
= isatty (fileno (stderr
));
118 /* Before anything else, ensure we can allocate our file name buffer. */
119 file_name_buf
= load_file_data (stdin
);
121 /* Because of the way server shells work, you have to keep stdin, out
122 and err open so that the proper input file does not get closed
125 freopen ("/dev/null", "r", stdin
);
127 if (file_name_buf
== (char *) NULL
)
129 fputs ("No file names listed for fixing\n", stderr
);
137 /* skip to start of name, past any "./" prefixes */
139 while (ISSPACE (*file_name_buf
)) file_name_buf
++;
140 while ((file_name_buf
[0] == '.') && (file_name_buf
[1] == '/'))
143 /* Check for end of list */
145 if (*file_name_buf
== NUL
)
148 /* Set global file name pointer and find end of name */
150 pz_curr_file
= file_name_buf
;
151 pz_end
= strchr( pz_curr_file
, '\n' );
152 if (pz_end
== (char*)NULL
)
153 pz_end
= file_name_buf
= pz_curr_file
+ strlen (pz_curr_file
);
155 file_name_buf
= pz_end
+ 1;
157 while ((pz_end
> pz_curr_file
) && ISSPACE( pz_end
[-1])) pz_end
--;
159 /* IF no name is found (blank line) or comment marker, skip line */
161 if ((pz_curr_file
== pz_end
) || (*pz_curr_file
== '#'))
169 if (VLEVEL( VERB_PROGRESS
)) {
172 Processed %5d files containing %d bytes \n\
173 Applying %5d fixes to %d files\n\
174 Altering %5d of them\n";
176 fprintf (stderr
, zFmt
, process_ct
, ttl_data_size
, apply_ct
,
177 fixed_ct
, altered_ct
);
179 #endif /* DO_STATS */
181 # ifdef SEPARATE_FIX_PROC
182 unlink( pz_temp_file
);
191 static const char zFmt
[] = "echo '%s'";
194 /* The 'version' option is really used to test that:
195 1. The program loads correctly (no missing libraries)
196 2. that we can compile all the regular expressions.
197 3. we can correctly run our server shell process
200 sprintf (zBuf
, zFmt
, program_id
);
201 #ifndef SEPARATE_FIX_PROC
203 exit (strcmp (run_shell (zBuf
), program_id
));
205 exit (system (zBuf
));
209 /* * * * * * * * * * * * */
212 initialize ( int argc
, char** argv
)
214 xmalloc_set_program_name (argv
[0]);
222 if (strcmp (argv
[1], "-v") == 0)
224 if (freopen (argv
[1], "r", stdin
) == (FILE*)NULL
)
226 fprintf (stderr
, "Error %d (%s) reopening %s as stdin\n",
227 errno
, xstrerror (errno
), argv
[1] );
233 fputs ("fixincl ERROR: too many command line arguments\n", stderr
);
238 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
239 receive the signal. A different setting is inheritable */
240 signal (SIGCHLD
, SIG_DFL
);
245 if (ISDIGIT ( *pz_verbose
))
246 verbose_level
= (te_verbose
)atoi( pz_verbose
);
248 switch (*pz_verbose
) {
251 verbose_level
= VERB_SILENT
; break;
255 verbose_level
= VERB_FIXES
; break;
259 verbose_level
= VERB_APPLIES
; break;
264 verbose_level
= VERB_PROGRESS
; break;
268 verbose_level
= VERB_TESTS
; break;
272 verbose_level
= VERB_EVERYTHING
; break;
274 if (verbose_level
>= VERB_EVERYTHING
) {
275 verbose_level
= VERB_EVERYTHING
;
276 fputs ("fixinc verbosity: EVERYTHING\n", stderr
);
278 while ((pz_find_base
[0] == '.') && (pz_find_base
[1] == '/'))
280 if ((pz_find_base
[0] != '.') || (pz_find_base
[1] != NUL
))
281 find_base_len
= strlen( pz_find_base
);
283 /* Compile all the regular expressions now.
284 That way, it is done only once for the whole run.
288 # ifdef SEPARATE_FIX_PROC
289 /* NULL as the first argument to `tempnam' causes it to DTRT
290 wrt the temporary directory where the file will be created. */
291 pz_temp_file
= tempnam( NULL
, "fxinc" );
294 signal (SIGQUIT
, SIG_IGN
);
295 signal (SIGIOT
, SIG_IGN
);
296 signal (SIGPIPE
, SIG_IGN
);
297 signal (SIGALRM
, SIG_IGN
);
298 signal (SIGTERM
, SIG_IGN
);
301 /* * * * * * * * * * * * *
303 load_file loads all the contents of a file into malloc-ed memory.
304 Its argument is the name of the file to read in; the returned
305 result is the NUL terminated contents of the file. The file
306 is presumed to be an ASCII text file containing no NULs. */
308 load_file ( const char* fname
)
313 if (stat (fname
, &stbf
) != 0)
316 fprintf (stderr
, "error %d (%s) stat-ing %s\n",
317 errno
, xstrerror (errno
), fname
);
318 return (char *) NULL
;
320 if (stbf
.st_size
== 0)
323 /* Make the data map size one larger than the file size for documentation
324 purposes. Truth is that there will be a following NUL character if
325 the file size is not a multiple of the page size. If it is a multiple,
326 then this adjustment sometimes fails anyway. */
327 data_map_size
= stbf
.st_size
+1;
328 data_map_fd
= open (fname
, O_RDONLY
);
329 ttl_data_size
+= data_map_size
-1;
334 fprintf (stderr
, "error %d (%s) opening %s for read\n",
335 errno
, xstrerror (errno
), fname
);
339 #ifdef HAVE_MMAP_FILE
340 curr_data_mapped
= BOOL_TRUE
;
342 /* IF the file size is a multiple of the page size,
343 THEN sometimes you will seg fault trying to access a trailing byte */
344 if ((stbf
.st_size
& (getpagesize()-1)) == 0)
345 res
= (char*)BAD_ADDR
;
347 res
= (char*)mmap ((void*)NULL
, data_map_size
, PROT_READ
,
348 MAP_PRIVATE
, data_map_fd
, 0);
349 if (res
== (char*)BAD_ADDR
)
352 FILE* fp
= fdopen (data_map_fd
, "r");
353 curr_data_mapped
= BOOL_FALSE
;
354 res
= load_file_data (fp
);
362 machine_matches( tFixDesc
* p_fixd
)
364 char const ** papz_machs
= p_fixd
->papz_machs
;
365 int have_match
= BOOL_FALSE
;
369 char const * pz_mpat
= *(papz_machs
++);
372 if (fnmatch(pz_mpat
, pz_machine
, 0) == 0)
374 have_match
= BOOL_TRUE
;
379 /* Check for sense inversion then set the "skip test" flag, if needed */
380 if (p_fixd
->fd_flags
& FD_MACH_IFNOT
)
381 have_match
= ! have_match
;
384 p_fixd
->fd_flags
|= FD_SKIP_TEST
;
389 /* * * * * * * * * * * * *
391 * run_compiles run all the regexp compiles for all the fixes once.
396 tFixDesc
*p_fixd
= fixDescList
;
397 int fix_ct
= FIX_COUNT
;
398 regex_t
*p_re
= XCNEWVEC (regex_t
, REGEX_COUNT
);
400 /* Make sure compile_re does not stumble across invalid data */
402 memset (&incl_quote_re
, '\0', sizeof (regex_t
));
404 compile_re (incl_quote_pat
, &incl_quote_re
, 1,
405 "quoted include", "run_compiles");
407 /* Allow machine name tests to be ignored (testing, mainly) */
409 if (pz_machine
&& ((*pz_machine
== '\0') || (*pz_machine
== '*')))
410 pz_machine
= (char*)NULL
;
412 /* FOR every fixup, ... */
415 tTestDesc
*p_test
= p_fixd
->p_test_desc
;
416 int test_ct
= p_fixd
->test_ct
;
418 /* IF the machine type pointer is not NULL (we are not in test mode)
419 AND this test is for or not done on particular machines
422 if ( (pz_machine
!= NULL
)
423 && (p_fixd
->papz_machs
!= (const char**) NULL
)
424 && ! machine_matches (p_fixd
) )
427 /* FOR every test for the fixup, ... */
429 while (--test_ct
>= 0)
431 switch (p_test
->type
)
435 p_test
->p_test_regex
= p_re
++;
436 compile_re (p_test
->pz_test_text
, p_test
->p_test_regex
, 0,
437 "select test", p_fixd
->fix_name
);
443 while (p_fixd
++, --fix_ct
> 0);
447 /* * * * * * * * * * * * *
449 create_file Create the output modified file.
450 Input: the name of the file to create
451 Returns: a file pointer to the new, open file */
453 #if defined(S_IRUSR) && defined(S_IWUSR) && \
454 defined(S_IRGRP) && defined(S_IROTH)
456 # define S_IRALL (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
458 # define S_IRALL 0644
461 #if defined(S_IRWXU) && defined(S_IRGRP) && defined(S_IXGRP) && \
462 defined(S_IROTH) && defined(S_IXOTH)
464 # define S_DIRALL (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
466 # define S_DIRALL 0755
475 char fname
[MAXPATHLEN
];
477 sprintf (fname
, "%s/%s", pz_dest_dir
, pz_curr_file
+ find_base_len
);
479 fd
= open (fname
, O_WRONLY
| O_CREAT
| O_TRUNC
, S_IRALL
);
481 /* We may need to create the directories needed... */
482 if ((fd
< 0) && (errno
== ENOENT
))
484 char *pz_dir
= strchr (fname
+ 1, '/');
487 while (pz_dir
!= (char *) NULL
)
490 if (stat (fname
, &stbf
) < 0)
495 mkdir (fname
, S_IFDIR
| S_DIRALL
);
500 pz_dir
= strchr (pz_dir
+ 1, '/');
503 /* Now, lets try the open again... */
504 fd
= open (fname
, O_WRONLY
| O_CREAT
| O_TRUNC
, S_IRALL
);
508 fprintf (stderr
, "Error %d (%s) creating %s\n",
509 errno
, xstrerror (errno
), fname
);
513 fprintf (stderr
, "Fixed: %s\n", pz_curr_file
);
514 pf
= fdopen (fd
, "w");
517 * IF pz_machine is NULL, then we are in some sort of test mode.
518 * Do not insert the current directory name. Use a constant string.
520 fprintf (pf
, z_std_preamble
,
530 /* * * * * * * * * * * * *
532 test_test make sure a shell-style test expression passes.
533 Input: a pointer to the descriptor of the test to run and
534 the name of the file that we might want to fix
535 Result: APPLY_FIX or SKIP_FIX, depending on the result of the
536 shell script we run. */
537 #ifndef SEPARATE_FIX_PROC
539 test_test (tTestDesc
* p_test
, char* pz_test_file
)
543 if ( test %s ) > /dev/null 2>&1\n\
551 static char cmd_buf
[4096];
553 sprintf (cmd_buf
, cmd_fmt
, pz_test_file
, p_test
->pz_test_text
);
554 pz_res
= run_shell (cmd_buf
);
566 fprintf (stderr
, "Script yielded bogus result of `%s':\n%s\n\n",
571 free ((void *) pz_res
);
576 * IF we are in MS-DOS land, then whatever shell-type test is required
577 * will, by definition, fail
579 #define test_test(t,tf) SKIP_FIX
582 /* * * * * * * * * * * * *
584 egrep_test make sure an egrep expression is found in the file text.
585 Input: a pointer to the descriptor of the test to run and
586 the pointer to the contents of the file under suspicion
587 Result: APPLY_FIX if the pattern is found, SKIP_FIX otherwise
589 The caller may choose to reverse meaning if the sense of the test
593 egrep_test (char* pz_data
, tTestDesc
* p_test
)
596 if (p_test
->p_test_regex
== 0)
597 fprintf (stderr
, "fixincl ERROR RE not compiled: `%s'\n",
598 p_test
->pz_test_text
);
600 if (xregexec (p_test
->p_test_regex
, pz_data
, 0, 0, 0) == 0)
606 /* * * * * * * * * * * * *
608 quoted_file_exists Make sure that a file exists before we emit
609 the file name. If we emit the name, our invoking shell will try
610 to copy a non-existing file into the destination directory. */
613 quoted_file_exists (const char* pz_src_path
,
614 const char* pz_file_path
,
617 char z
[ MAXPATHLEN
];
619 sprintf (z
, "%s/%s/", pz_src_path
, pz_file_path
);
620 pz
= z
+ strlen ( z
);
623 char ch
= *pz_file
++;
633 if (stat (z
, &s
) != 0)
635 return S_ISREG( s
.st_mode
);
640 /* * * * * * * * * * * * *
644 The syntax, `#include "file.h"' specifies that the compiler is to
645 search the local directory of the current file before the include
646 list. Consequently, if we have modified a header and stored it in
647 another directory, any files that are included by that modified
648 file in that fashion must also be copied into this new directory.
649 This routine finds those flavors of #include and for each one found
652 1. source directory of the original file
653 2. the relative path file name of the #includ-ed file
654 3. the full destination path for this file
656 Input: the text of the file, the file name and a pointer to the
657 match list where the match information was stored.
658 Result: internally nothing. The results are written to stdout
659 for interpretation by the invoking shell */
663 extract_quoted_files (char* pz_data
,
664 const char* pz_fixed_file
,
665 regmatch_t
* p_re_match
)
667 char *pz_dir_end
= strrchr (pz_fixed_file
, '/');
668 char *pz_incl_quot
= pz_data
;
670 if (VLEVEL( VERB_APPLIES
))
671 fprintf (stderr
, "Quoted includes in %s\n", pz_fixed_file
);
673 /* Set "pz_fixed_file" to point to the containing subdirectory of the source
674 If there is none, then it is in our current directory, ".". */
676 if (pz_dir_end
== (char *) NULL
)
683 pz_incl_quot
+= p_re_match
->rm_so
;
685 /* Skip forward to the included file name */
686 while (*pz_incl_quot
!= '"')
689 if (quoted_file_exists (pz_src_dir
, pz_fixed_file
, pz_incl_quot
))
691 /* Print the source directory and the subdirectory
692 of the file in question. */
693 printf ("%s %s/", pz_src_dir
, pz_fixed_file
);
694 pz_dir_end
= pz_incl_quot
;
696 /* Append to the directory the relative path of the desired file */
697 while (*pz_incl_quot
!= '"')
698 putc (*pz_incl_quot
++, stdout
);
700 /* Now print the destination directory appended with the
701 relative path of the desired file */
702 printf (" %s/%s/", pz_dest_dir
, pz_fixed_file
);
703 while (*pz_dir_end
!= '"')
704 putc (*pz_dir_end
++, stdout
);
710 /* Find the next entry */
711 if (xregexec (&incl_quote_re
, pz_incl_quot
, 1, p_re_match
, 0) != 0)
717 /* * * * * * * * * * * * *
719 Somebody wrote a *_fix subroutine that we must call.
721 #ifndef SEPARATE_FIX_PROC
723 internal_fix (int read_fd
, tFixDesc
* p_fixd
)
729 fprintf (stderr
, "Error %d on pipe(2) call\n", errno
);
735 pid_t childid
= fork();
758 fprintf (stderr
, z_fork_err
, errno
, xstrerror (errno
),
761 static int failCt
= 0;
762 if ((errno
!= EAGAIN
) || (++failCt
> 10))
769 * Close our current stdin and stdout
771 close (STDIN_FILENO
);
772 close (STDOUT_FILENO
);
776 * Make the fd passed in the stdin, and the write end of
777 * the new pipe become the stdout.
779 dup2 (fd
[1], STDOUT_FILENO
);
780 dup2 (read_fd
, STDIN_FILENO
);
782 apply_fix (p_fixd
, pz_curr_file
);
785 #endif /* !SEPARATE_FIX_PROC */
788 #ifdef SEPARATE_FIX_PROC
790 fix_with_system (tFixDesc
* p_fixd
,
799 if (p_fixd
->fd_flags
& FD_SUBROUTINE
)
801 static const char z_applyfix_prog
[] =
802 "/../fixincludes/applyfix" EXE_EXT
;
806 + strlen (pz_orig_dir
)
807 + sizeof (z_applyfix_prog
)
808 + strlen (pz_fix_file
)
809 + strlen (pz_file_source
)
810 + strlen (pz_temp_file
);
812 /* Allocate something sure to be big enough for our purposes */
813 pz_cmd
= XNEWVEC (char, argsize
);
814 strcpy (pz_cmd
, pz_orig_dir
);
815 pz_scan
= pz_cmd
+ strlen (pz_orig_dir
);
817 strcpy (pz_scan
, z_applyfix_prog
);
819 /* IF we can't find the "applyfix" executable file at the first guess,
820 try one level higher up */
821 if (stat (pz_cmd
, &buf
) == -1)
823 strcpy (pz_scan
, "/..");
824 strcpy (pz_scan
+3, z_applyfix_prog
);
827 pz_scan
+= strlen (pz_scan
);
830 * Now add the fix number and file names that may be needed
832 sprintf (pz_scan
, " %ld '%s' '%s' '%s'", (long) (p_fixd
- fixDescList
),
833 pz_fix_file
, pz_file_source
, pz_temp_file
);
835 else /* NOT an "internal" fix: */
839 /* Don't use the "src > dstX; rm -f dst; mv -f dstX dst" trick:
840 dst is a temporary file anyway, so we know there's no other
841 file by that name; and DOS's system(3) doesn't mind to
842 clobber existing file in redirection. Besides, with DOS 8+3
843 limited file namespace, we can easily lose if dst already has
844 an extension that is 3 or more characters long.
846 I do not think the 8+3 issue is relevant because all the files
847 we operate on are named "*.h", making 8+2 adequate. Anyway,
848 the following bizarre use of 'cat' only works on DOS boxes.
849 It causes the file to be dropped into a temporary file for
850 'cat' to read (pipes do not work on DOS). */
851 tSCC z_cmd_fmt
[] = " '%s' | cat > '%s'";
853 /* Don't use positional formatting arguments because some lame-o
854 implementations cannot cope :-(. */
855 tSCC z_cmd_fmt
[] = " %s > %sX ; rm -f %s; mv -f %sX %s";
857 tCC
** ppArgs
= p_fixd
->patch_args
;
859 argsize
= sizeof( z_cmd_fmt
) + strlen( pz_temp_file
)
860 + strlen( pz_file_source
);
865 * Compute the size of the command line. Add lotsa extra space
866 * because some of the args to sed use lotsa single quotes.
867 * (This requires three extra bytes per quote. Here we allow
868 * for up to 8 single quotes for each argument, including the
869 * command name "sed" itself. Nobody will *ever* need more. :)
873 tCC
* p_arg
= *(ppArgs
++);
876 argsize
+= 24 + strlen( p_arg
);
879 /* Estimated buffer size we will need. */
880 pz_scan
= pz_cmd
= XNEWVEC (char, argsize
);
881 /* How much of it do we allot to the program name and its
883 parg_size
= argsize
- parg_size
;
885 ppArgs
= p_fixd
->patch_args
;
888 * Copy the program name, unquoted
891 tCC
* pArg
= *(ppArgs
++);
902 * Copy the program arguments, quoted
906 tCC
* pArg
= *(ppArgs
++);
911 pz_scan
= make_raw_shell_str( pz_scan_save
= pz_scan
, pArg
,
912 parg_size
- (pz_scan
- pz_cmd
) );
914 * Make sure we don't overflow the buffer due to sloppy
917 while (pz_scan
== (char*)NULL
)
919 size_t already_filled
= pz_scan_save
- pz_cmd
;
920 pz_cmd
= xrealloc (pz_cmd
, argsize
+= 100);
921 pz_scan_save
= pz_scan
= pz_cmd
+ already_filled
;
923 pz_scan
= make_raw_shell_str( pz_scan
, pArg
,
924 parg_size
- (pz_scan
- pz_cmd
) );
929 * add the file machinations.
932 sprintf (pz_scan
, z_cmd_fmt
, pz_file_source
, pz_temp_file
);
934 sprintf (pz_scan
, z_cmd_fmt
, pz_file_source
, pz_temp_file
,
935 pz_temp_file
, pz_temp_file
, pz_temp_file
);
939 free( (void*)pz_cmd
);
942 /* * * * * * * * * * * * *
944 This loop should only cycle for 1/2 of one loop.
945 "chain_open" starts a process that uses "read_fd" as
946 its stdin and returns the new fd this process will use
949 #else /* is *NOT* SEPARATE_FIX_PROC */
951 start_fixer (int read_fd
, tFixDesc
* p_fixd
, char* pz_fix_file
)
956 if ((p_fixd
->fd_flags
& FD_SUBROUTINE
) != 0)
957 return internal_fix (read_fd
, p_fixd
);
959 if ((p_fixd
->fd_flags
& FD_SHELL_SCRIPT
) == 0)
966 tSCC z_cmd_fmt
[] = "file='%s'\n%s";
967 pz_cmd
= XNEWVEC (char, strlen (p_fixd
->patch_args
[2])
968 + sizeof (z_cmd_fmt
) + strlen (pz_fix_file
));
969 sprintf (pz_cmd
, z_cmd_fmt
, pz_fix_file
, p_fixd
->patch_args
[2]);
970 pz_cmd_save
= p_fixd
->patch_args
[2];
971 p_fixd
->patch_args
[2] = pz_cmd
;
974 /* Start a fix process, handing off the previous read fd for its
975 stdin and getting a new fd that reads from the fix process' stdout.
976 We normally will not loop, but we will up to 10 times if we keep
977 getting "EAGAIN" errors.
982 static int failCt
= 0;
985 fd
= chain_open (read_fd
,
986 (tCC
**) p_fixd
->patch_args
,
987 (process_chain_head
== -1)
988 ? &process_chain_head
: (pid_t
*) NULL
);
996 fprintf (stderr
, z_fork_err
, errno
, xstrerror (errno
),
999 if ((errno
!= EAGAIN
) || (++failCt
> 10))
1000 exit (EXIT_FAILURE
);
1004 /* IF we allocated a shell script command,
1005 THEN free it and restore the command format to the fix description */
1006 if (pz_cmd
!= (char*)NULL
)
1008 free ((void*)pz_cmd
);
1009 p_fixd
->patch_args
[2] = pz_cmd_save
;
1017 /* * * * * * * * * * * * *
1019 * Process the potential fixes for a particular include file.
1020 * Input: the original text of the file and the file's name
1021 * Result: none. A new file may or may not be created.
1024 fix_applies (tFixDesc
* p_fixd
)
1026 const char *pz_fname
= pz_curr_file
;
1027 const char *pz_scan
= p_fixd
->file_list
;
1031 #ifdef SEPARATE_FIX_PROC
1033 * There is only one fix that uses a shell script as of this writing.
1034 * I hope to nuke it anyway, it does not apply to DOS and it would
1035 * be painful to implement. Therefore, no "shell" fixes for DOS.
1037 if (p_fixd
->fd_flags
& (FD_SHELL_SCRIPT
| FD_SKIP_TEST
))
1040 if (p_fixd
->fd_flags
& FD_SKIP_TEST
)
1044 /* IF there is a file name restriction,
1045 THEN ensure the current file name matches one in the pattern */
1047 if (pz_scan
!= (char *) NULL
)
1049 while ((pz_fname
[0] == '.') && (pz_fname
[1] == '/'))
1054 if (fnmatch (pz_scan
, pz_fname
, 0) == 0)
1056 pz_scan
+= strlen (pz_scan
) + 1;
1057 if (*pz_scan
== NUL
)
1062 /* FOR each test, see if it fails.
1063 IF it does fail, then we go on to the next test */
1065 for (p_test
= p_fixd
->p_test_desc
, test_ct
= p_fixd
->test_ct
;
1069 switch (p_test
->type
)
1072 if (test_test (p_test
, pz_curr_file
) != APPLY_FIX
) {
1074 if (VLEVEL( VERB_EVERYTHING
))
1075 fprintf (stderr
, z_failed
, "TEST", p_fixd
->fix_name
,
1076 pz_fname
, p_fixd
->test_ct
- test_ct
);
1083 if (egrep_test (pz_curr_data
, p_test
) != APPLY_FIX
) {
1085 if (VLEVEL( VERB_EVERYTHING
))
1086 fprintf (stderr
, z_failed
, "EGREP", p_fixd
->fix_name
,
1087 pz_fname
, p_fixd
->test_ct
- test_ct
);
1094 if (egrep_test (pz_curr_data
, p_test
) == APPLY_FIX
) {
1096 if (VLEVEL( VERB_EVERYTHING
))
1097 fprintf (stderr
, z_failed
, "NEGREP", p_fixd
->fix_name
,
1098 pz_fname
, p_fixd
->test_ct
- test_ct
);
1106 if (run_test (p_test
->pz_test_text
, pz_curr_file
, pz_curr_data
)
1109 if (VLEVEL( VERB_EVERYTHING
))
1110 fprintf (stderr
, z_failed
, "FTEST", p_fixd
->fix_name
,
1111 pz_fname
, p_fixd
->test_ct
- test_ct
);
1123 /* * * * * * * * * * * * *
1125 Write out a replacement file */
1128 write_replacement (tFixDesc
* p_fixd
)
1130 const char* pz_text
= p_fixd
->patch_args
[0];
1132 if ((pz_text
== (char*)NULL
) || (*pz_text
== NUL
))
1136 FILE* out_fp
= create_file ();
1137 size_t sz
= strlen (pz_text
);
1138 fwrite (pz_text
, sz
, 1, out_fp
);
1139 if (pz_text
[ sz
-1 ] != '\n')
1140 fputc ('\n', out_fp
);
1146 /* * * * * * * * * * * * *
1148 We have work to do. Read back in the output
1149 of the filtering chain. Compare each byte as we read it with
1150 the contents of the original file. As soon as we find any
1151 difference, we will create the output file, write out all
1152 the matched text and then copy any remaining data from the
1153 output of the filter chain.
1156 test_for_changes (int read_fd
)
1158 FILE *in_fp
= fdopen (read_fd
, "r");
1159 FILE *out_fp
= (FILE *) NULL
;
1160 unsigned char *pz_cmp
= (unsigned char*)pz_curr_data
;
1172 ch
&= 0xFF; /* all bytes are 8 bits */
1174 /* IF we are emitting the output
1175 THEN emit this character, too.
1177 if (out_fp
!= (FILE *) NULL
)
1180 /* ELSE if this character does not match the original,
1181 THEN now is the time to start the output.
1183 else if (ch
!= *pz_cmp
)
1185 out_fp
= create_file ();
1190 /* IF there are matched data, write the matched part now. */
1191 if ((char*)pz_cmp
!= pz_curr_data
)
1192 fwrite (pz_curr_data
, (size_t)((char*)pz_cmp
- pz_curr_data
),
1195 /* Emit the current unmatching character */
1199 /* ELSE the character matches. Advance the compare ptr */
1203 /* IF we created the output file, ... */
1204 if (out_fp
!= (FILE *) NULL
)
1208 /* Close the file and see if we have to worry about
1209 `#include "file.h"' constructs. */
1211 if (xregexec (&incl_quote_re
, pz_curr_data
, 1, &match
, 0) == 0)
1212 extract_quoted_files (pz_curr_data
, pz_curr_file
, &match
);
1216 close (read_fd
); /* probably redundant, but I'm paranoid */
1220 /* * * * * * * * * * * * *
1222 Process the potential fixes for a particular include file.
1223 Input: the original text of the file and the file's name
1224 Result: none. A new file may or may not be created. */
1229 tFixDesc
*p_fixd
= fixDescList
;
1230 int todo_ct
= FIX_COUNT
;
1232 # ifndef SEPARATE_FIX_PROC
1233 int num_children
= 0;
1234 # else /* is SEPARATE_FIX_PROC */
1235 char* pz_file_source
= pz_curr_file
;
1238 if (access (pz_curr_file
, R_OK
) != 0)
1241 fprintf (stderr
, "Cannot access %s from %s\n\terror %d (%s)\n",
1242 pz_curr_file
, getcwd ((char *) NULL
, MAXPATHLEN
),
1243 erno
, xstrerror (erno
));
1247 pz_curr_data
= load_file (pz_curr_file
);
1248 if (pz_curr_data
== (char *) NULL
)
1254 if (VLEVEL( VERB_PROGRESS
) && have_tty
)
1255 fprintf (stderr
, "%6lu %-50s \r",
1256 (unsigned long) data_map_size
, pz_curr_file
);
1258 # ifndef SEPARATE_FIX_PROC
1259 process_chain_head
= NOPROCESS
;
1261 /* For every fix in our fix list, ... */
1262 for (; todo_ct
> 0; p_fixd
++, todo_ct
--)
1264 if (! fix_applies (p_fixd
))
1267 if (VLEVEL( VERB_APPLIES
))
1268 fprintf (stderr
, "Applying %-24s to %s\n",
1269 p_fixd
->fix_name
, pz_curr_file
);
1271 if (p_fixd
->fd_flags
& FD_REPLACEMENT
)
1273 write_replacement (p_fixd
);
1278 /* IF we do not have a read pointer,
1279 THEN this is the first fix for the current file.
1280 Open the source file. That will be used as stdin for
1281 the first fix. Any subsequent fixes will use the
1282 stdout descriptor of the previous fix for its stdin. */
1286 read_fd
= open (pz_curr_file
, O_RDONLY
);
1289 fprintf (stderr
, "Error %d (%s) opening %s\n", errno
,
1290 xstrerror (errno
), pz_curr_file
);
1291 exit (EXIT_FAILURE
);
1294 /* Ensure we do not get duplicate output */
1299 read_fd
= start_fixer (read_fd
, p_fixd
, pz_curr_file
);
1303 /* IF we have a read-back file descriptor,
1304 THEN check for changes and write output if changed. */
1308 test_for_changes (read_fd
);
1310 apply_ct
+= num_children
;
1312 /* Wait for child processes created by chain_open()
1313 to avoid leaving zombies. */
1315 wait ((int *) NULL
);
1316 } while (--num_children
> 0);
1319 # else /* is SEPARATE_FIX_PROC */
1321 for (; todo_ct
> 0; p_fixd
++, todo_ct
--)
1323 if (! fix_applies (p_fixd
))
1326 if (VLEVEL( VERB_APPLIES
))
1327 fprintf (stderr
, "Applying %-24s to %s\n",
1328 p_fixd
->fix_name
, pz_curr_file
);
1330 if (p_fixd
->fd_flags
& FD_REPLACEMENT
)
1332 write_replacement (p_fixd
);
1336 fix_with_system (p_fixd
, pz_curr_file
, pz_file_source
, pz_temp_file
);
1337 pz_file_source
= pz_temp_file
;
1340 read_fd
= open (pz_temp_file
, O_RDONLY
);
1343 if (errno
!= ENOENT
)
1344 fprintf (stderr
, "error %d (%s) opening output (%s) for read\n",
1345 errno
, xstrerror (errno
), pz_temp_file
);
1349 test_for_changes (read_fd
);
1350 /* Unlinking a file while it is still open is a Bad Idea on
1353 unlink (pz_temp_file
);