MatCat.OpenSource/8sa1-gcc
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
f2fb2b0991
8sa1-gcc/gcc/fixinc/fixincl.c
Bruce Korb bb78620135 Remove references to setenv/putenv 
From-SVN: r27312
1999-06-02 07:08:54 +00:00

1187 lines
31 KiB
C
Raw Blame History

/* Install modified versions of certain ANSI-incompatible system header
files which are fixed to work correctly with ANSI C and placed in a
directory that GNU C will search.
Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include "auto-host.h"
#include "gansidecl.h"
#include "system.h"
#include <signal.h>
#include "gnu-regex.h"
#include "server.h"
static const char program_id[] = "fixincl version 1.0";
#define MINIMUM_MAXIMUM_LINES 128
/* If this particular system's header files define the macro `MAXPATHLEN',
we happily take advantage of it; otherwise we use a value which ought
to be large enough. */
#ifndef MAXPATHLEN
# define MAXPATHLEN 4096
#endif
#define NAME_TABLE_SIZE (MINIMUM_MAXIMUM_LINES * MAXPATHLEN)
#ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
#endif
#ifndef EXIT_FAILURE
# define EXIT_FAILURE 1
#endif
char *file_name_buf;
#define tSCC static const char
#define tCC const char
#define tSC static char
typedef int t_success;
#define FAILURE (-1)
#define SUCCESS 0
#define PROBLEM 1
#define SUCCEEDED(p) ((p) == SUCCESS)
#define SUCCESSFUL(p) SUCCEEDED (p)
#define FAILED(p) ((p) < SUCCESS)
#define HADGLITCH(p) ((p) > SUCCESS)
#define NUL '\0'
/* Test Descriptor
Each fix may have associated tests that determine
whether the fix needs to be applied or not.
Each test has a type (from the te_test_type enumeration);
associated test text; and, if the test is TT_EGREP or
the negated form TT_NEGREP, a pointer to the compiled
version of the text string.
*/
typedef enum
{
TT_TEST, TT_EGREP, TT_NEGREP
} te_test_type;
typedef struct test_desc tTestDesc;
struct test_desc
{
te_test_type type;
const char *pz_test_text;
regex_t *p_test_regex;
};
typedef struct patch_desc tPatchDesc;
/* Fix Descriptor
Everything you ever wanted to know about how to apply
a particular fix (which files, how to qualify them,
how to actually make the fix, etc...)
*/
#define FD_MACH_ONLY 0x0000
#define FD_MACH_IFNOT 0x0001
#define FD_SHELL_SCRIPT 0x0002
#define FD_SKIP_TEST 0x8000
typedef struct fix_desc tFixDesc;
struct fix_desc
{
const char* fix_name; /* Name of the fix */
const char* file_list; /* List of files it applies to */
const char** papz_machs; /* List of machine/os-es it applies to */
regex_t* unused;
int test_ct;
int fd_flags;
tTestDesc* p_test_desc;
const char** patch_args;
};
/* Working environment strings. Essentially, invocation 'options'. */
char *pz_dest_dir = NULL;
char *pz_src_dir = NULL;
char *pz_machine = NULL;
char *pz_find_base = NULL;
int find_base_len = 0;
pid_t process_chain_head = (pid_t) -1;
const char incl_quote_pat[] = "^[ \t]*#[ \t]*include[ \t]*\"[^/]";
regex_t incl_quote_re;
char *load_file _P_((const char *));
void process _P_((char *, const char *));
void run_compiles ();
void wait_for_pid _P_(( pid_t ));
void initialize ();
#include "fixincl.x"
/* * * * * * * * * * * * * * * * * * *
*
* MAIN ROUTINE
*/
int
main (argc, argv)
int argc;
char **argv;
{
static const char gnu_lib_mark[] =
"This file is part of the GNU C Library";
#ifndef NO_BOGOSITY_LIMITS
# define BOGUS_LIMIT MINIMUM_MAXIMUM_LINES
size_t loop_ct;
#endif
char *apz_names[BOGUS_LIMIT];
size_t file_name_ct;
/* Before anything else, ensure we can allocate our file name buffer. */
file_name_buf = (char *) malloc (NAME_TABLE_SIZE);
if (file_name_buf == (char *) NULL)
{
fprintf (stderr, "fixincl cannot allocate 0x%08X bytes\n",
NAME_TABLE_SIZE);
exit (EXIT_FAILURE);
}
switch (argc)
{
case 1:
break;
case 2:
if (strcmp (argv[1], "-v") == 0)
{
static const char zFmt[] = "echo '%s'";
/* The 'version' option is really used to test that:
1. The program loads correctly (no missing libraries)
2. we can correctly run our server shell process
3. that we can compile all the regular expressions.
*/
run_compiles ();
sprintf (file_name_buf, zFmt, program_id);
fputs (file_name_buf + 5, stdout);
exit (strcmp (run_shell (file_name_buf), program_id));
}
freopen (argv[1], "r", stdin);
break;
default:
fputs ("fixincl ERROR: too many command line arguments\n", stderr);
exit (EXIT_FAILURE);
}
initialize ();
#ifndef NO_BOGOSITY_LIMITS
/* Some systems only allow so many calls to fork(2).
This is inadequate for this program. Consequently,
we must let a grandfather process spawn children
that then spawn all the processes that do the real work.
*/
for (;;)
{
file_name_ct = 0;
{
char *pz_buf = file_name_buf;
/* Only the parent process can read from stdin without confusing
the world. (How does the child tell the parent to skip
forward? Pipes and files behave differently.) */
while ( (file_name_ct < BOGUS_LIMIT)
&& (pz_buf < (file_name_buf + NAME_TABLE_SIZE - MAXPATHLEN)))
{
if (fgets (pz_buf, MAXPATHLEN, stdin) == (char *) NULL)
break;
while (isspace (*pz_buf))
pz_buf++;
if ((*pz_buf == '\0') || (*pz_buf == '#'))
continue;
apz_names[file_name_ct++] = pz_buf;
pz_buf += strlen (pz_buf);
while (isspace (pz_buf[-1]))
pz_buf--;
*pz_buf++ = '\0';
}
}
/* IF we did not get any files this time thru
THEN we must be done. */
if (file_name_ct == 0)
return EXIT_SUCCESS;
fflush (stdout);
fflush (stderr);
{
pid_t child = fork ();
if (child == NULLPROCESS)
break;
if (child == NOPROCESS)
{
fprintf (stderr, "Error %d (%s) forking in main\n",
errno, strerror (errno));
exit (EXIT_FAILURE);
}
#ifdef DEBUG
fprintf (stderr, "Waiting for %d to complete %d files\n",
child, file_name_ct);
#endif
wait_for_pid( child, file_name_ct );
}
}
#else
/*#*/ error "NON-BOGUS LIMITS NOT SUPPORTED?!?!"
#endif
/* For every file specified in stdandard in
(except as throttled for bogus reasons)...
*/
for (loop_ct = 0; loop_ct < file_name_ct; loop_ct++)
{
char *pz_data;
char *pz_file_name = apz_names[loop_ct];
if (access (pz_file_name, R_OK) != 0)
{
int erno = errno;
fprintf (stderr, "Cannot access %s from %s\n\terror %d (%s)\n",
pz_file_name, getcwd ((char *) NULL, MAXPATHLEN),
erno, strerror (erno));
}
else if (pz_data = load_file (pz_file_name), (pz_data != (char *) NULL))
{
if (strstr (pz_data, gnu_lib_mark) == (char *) NULL)
process (pz_data, pz_file_name);
free ((void *) pz_data);
}
}
return EXIT_SUCCESS;
}
/* * * * * * * * * * * * */
void
initialize()
{
static const char var_not_found[] =
"fixincl ERROR: %s environment variable not defined\n";
{
static const char var[] = "TARGET_MACHINE";
pz_machine = getenv (var);
if (pz_machine == (char *) NULL)
{
fprintf (stderr, var_not_found, var);
exit (EXIT_FAILURE);
}
}
{
static const char var[] = "DESTDIR";
pz_dest_dir = getenv (var);
if (pz_dest_dir == (char *) NULL)
{
fprintf (stderr, var_not_found, var);
exit (EXIT_FAILURE);
}
}
{
static const char var[] = "SRCDIR";
pz_src_dir = getenv (var);
if (pz_src_dir == (char *) NULL)
{
fprintf (stderr, var_not_found, var);
exit (EXIT_FAILURE);
}
}
{
static const char var[] = "FIND_BASE";
pz_find_base = getenv (var);
if (pz_find_base == (char *) NULL)
{
fprintf (stderr, var_not_found, var);
exit (EXIT_FAILURE);
}
find_base_len = strlen( pz_find_base );
}
/* Compile all the regular expressions now.
That way, it is done only once for the whole run.
*/
run_compiles ();
signal (SIGQUIT, SIG_IGN);
signal (SIGIOT, SIG_IGN);
signal (SIGPIPE, SIG_IGN);
signal (SIGALRM, SIG_IGN);
signal (SIGTERM, SIG_IGN);
/*
Make sure that if we opened a server process, we close it now.
This is the grandparent process. We don't need the server anymore
and our children should make their own. */
close_server ();
(void)wait ( (int*)NULL );
}
/* * * * * * * * * * * * *
wait_for_pid - Keep calling `wait(2)' until it returns
the process id we are looking for. Not every system has
`waitpid(2)'. We also ensure that the children exit with success. */
void
wait_for_pid(child, file_name_ct)
pid_t child;
int file_name_ct;
{
for (;;) {
int status;
pid_t dead_kid = wait (&status);
if (dead_kid == child)
{
if (! WIFEXITED( status ))
{
fprintf (stderr, "child process %d is hung on signal %d\n",
child, WSTOPSIG( status ));
exit (EXIT_FAILURE);
}
if (WEXITSTATUS( status ) != 0)
{
fprintf (stderr, "child process %d exited with status %d\n",
child, WEXITSTATUS( status ));
exit (EXIT_FAILURE);
}
break; /* normal child completion */
}
/*
IF there is an error, THEN see if it is retryable.
If it is not retryable, then break out of this loop. */
if (dead_kid == NOPROCESS)
{
switch (errno) {
case EINTR:
case EAGAIN:
break;
default:
fprintf (stderr, "Error %d (%s) waiting for %d to finish\n",
errno, strerror( errno ), child );
/* FALLTHROUGH */
case ECHILD: /* no children to wait for?? */
return;
}
}
} done_waiting:;
}
/* * * * * * * * * * * * *
load_file loads all the contents of a file into malloc-ed memory.
Its argument is the name of the file to read in; the returned
result is the NUL terminated contents of the file. The file
is presumed to be an ASCII text file containing no NULs. */
char *
load_file (pz_file_name)
const char *pz_file_name;
{
char *pz_data;
size_t file_size;
{
struct stat stbf;
if (stat (pz_file_name, &stbf) != 0)
{
fprintf (stderr, "error %d (%s) stat-ing %s\n",
errno, strerror (errno), pz_file_name);
return (char *) NULL;
}
file_size = stbf.st_size;
}
if (file_size == 0)
return (char *) NULL;
pz_data = (char *) malloc ((file_size + 16) & ~0x00F);
if (pz_data == (char *) NULL)
{
fprintf (stderr, "error: could not malloc %d bytes\n",
file_size);
exit (EXIT_FAILURE);
}
{
FILE *fp = fopen (pz_file_name, "r");
size_t size_left = file_size;
char *read_ptr = pz_data;
if (fp == (FILE *) NULL)
{
fprintf (stderr, "error %d (%s) opening %s\n", errno,
strerror (errno), pz_file_name);
free ((void *) pz_data);
return (char *) NULL;
}
do
{
size_t sizeRead = fread ((void *) read_ptr, 1, size_left, fp);
if (sizeRead == 0)
{
if (feof (fp))
break;
if (ferror (fp))
{
int err = errno;
if (err != EISDIR)
fprintf (stderr, "error %d (%s) reading %s\n", err,
strerror (err), pz_file_name);
free ((void *) pz_data);
fclose (fp);
return (char *) NULL;
}
}
read_ptr += sizeRead;
size_left -= sizeRead;
}
while (size_left != 0);
*read_ptr = '\0';
fclose (fp);
}
return pz_data;
}
/* * * * * * * * * * * * *
run_compiles run all the regexp compiles for all the fixes once.
*/
void
run_compiles ()
{
tSCC z_bad_comp[] = "fixincl ERROR: cannot compile %s regex for %s\n\
\texpr = `%s'\n\terror %s\n";
tFixDesc *p_fixd = fixDescList;
int fix_ct = FIX_COUNT;
tTestDesc *p_test;
int test_ct;
int re_ct = REGEX_COUNT;
const char *pz_err;
regex_t *p_re = (regex_t *) malloc (REGEX_COUNT * sizeof (regex_t));
if (p_re == (regex_t *) NULL)
{
fprintf (stderr, "fixincl ERROR: cannot allocate %d bytes for regex\n",
REGEX_COUNT * sizeof (regex_t));
exit (EXIT_FAILURE);
}
/* Make sure re_compile_pattern does not stumble across invalid
data */
memset ( (void*)p_re, '\0', REGEX_COUNT * sizeof (regex_t) );
memset ( (void*)&incl_quote_re, '\0', sizeof (regex_t) );
/* The patterns we search for are all egrep patterns.
In the shell version of this program, we invoke egrep
with the supplied pattern. Here, we will run
re_compile_pattern, but it must be using the same rules. */
re_set_syntax (RE_SYNTAX_EGREP);
pz_err = re_compile_pattern (incl_quote_pat, sizeof (incl_quote_pat)-1,
&incl_quote_re);
if (pz_err != (char *) NULL)
{
fprintf (stderr, z_bad_comp, "quoted include", "run_compiles",
incl_quote_pat, pz_err);
exit (EXIT_FAILURE);
}
/* FOR every fixup, ... */
do
{
p_test = p_fixd->p_test_desc;
test_ct = p_fixd->test_ct;
/* IF the machine type pointer is not NULL (we are not in test mode)
AND this test is for or not done on particular machines
THEN ... */
if ( (pz_machine != NULL)
&& (p_fixd->papz_machs != (const char**) NULL) )
{
const char **papz_machs = p_fixd->papz_machs;
char *pz = file_name_buf;
char *pz_sep = "";
tCC *pz_if_true;
tCC *pz_if_false;
tSCC skip[] = "skip";
tSCC run[] = "run";
/* Construct a shell script that looks like this:
case our-cpu-platform-os in
tests-cpu-platform-os-pattern )
echo run ;;
* )
echo skip ;;
esac
where 'run' and 'skip' may be reversed, depending on
the sense of the test. */
sprintf (pz, "case %s in\n", pz_machine);
pz += strlen (pz);
if (p_fixd->fd_flags & FD_MACH_IFNOT)
{
pz_if_true = skip;
pz_if_false = run;
}
else
{
pz_if_true = run;
pz_if_false = skip;
}
/* FOR any additional machine names to test for,
insert the " | \\\n" glue and the machine pattern. */
for (;;)
{
const char* pz_mach = *(papz_machs++);
if (pz_mach == (const char*) NULL)
break;
sprintf (pz, "%s %s", pz_sep, pz_mach);
pz += strlen (pz);
pz_sep = " | \\\n";
}
sprintf (pz, " )\n echo %s ;;\n * )\n echo %s ;;\nesac",
pz_if_true, pz_if_false);
/* Run the script.
The result will start either with 's' or 'r'. */
{
int skip;
pz = run_shell (file_name_buf);
skip = (*pz == 's');
free ( (void*)pz );
if (skip)
{
p_fixd->fd_flags |= FD_SKIP_TEST;
continue;
}
}
}
/* FOR every test for the fixup, ... */
while (--test_ct >= 0)
{
switch (p_test->type)
{
case TT_EGREP:
case TT_NEGREP:
/* You might consider putting the following under #ifdef.
The number of re's used is computed by autogen.
So, it is static and known at compile time. */
if (--re_ct < 0)
{
fputs ("out of RE's\n", stderr);
exit (EXIT_FAILURE);
}
p_test->p_test_regex = p_re++;
pz_err = re_compile_pattern (p_test->pz_test_text,
strlen (p_test->pz_test_text),
p_test->p_test_regex);
if (pz_err != (char *) NULL)
{
fprintf (stderr, z_bad_comp, "select test", p_fixd->fix_name,
p_test->pz_test_text, pz_err);
exit (EXIT_FAILURE);
}
}
p_test++;
}
}
while (p_fixd++, --fix_ct > 0);
}
/* * * * * * * * * * * * *
create_file Create the output modified file.
Input: the name of the file to create
Returns: a file pointer to the new, open file */
#define S_IRALL (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
FILE *
create_file (pz_file_name)
const char *pz_file_name;
{
int fd;
FILE *pf;
char fname[MAXPATHLEN];
#ifdef DEBUG
if (strncmp( pz_file_name, pz_find_base, find_base_len ) != 0)
{
fprintf (stderr, "Error: input file %s does not match %s/*\n",
pz_file_name, pz_find_base );
exit (1);
}
#endif
sprintf (fname, "%s/%s", pz_dest_dir, pz_file_name + find_base_len);
fd = open (fname, O_WRONLY | O_CREAT | O_TRUNC, S_IRALL);
/* We may need to create the directories needed... */
if ((fd < 0) && (errno == ENOENT))
{
char *pz_dir = strchr (fname + 1, '/');
struct stat stbf;
while (pz_dir != (char *) NULL)
{
*pz_dir = NUL;
if (stat (fname, &stbf) < 0)
{
mkdir (fname, S_IFDIR | S_IRWXU | S_IRGRP | S_IXGRP
| S_IROTH | S_IXOTH);
}
*pz_dir = '/';
pz_dir = strchr (pz_dir + 1, '/');
}
/* Now, lets try the open again... */
fd = open (fname, O_WRONLY | O_CREAT | O_TRUNC, S_IRALL);
}
if (fd < 0)
{
fprintf (stderr, "Error %d (%s) creating %s\n",
errno, strerror (errno), fname);
exit (EXIT_FAILURE);
}
fprintf (stderr, "Fixed: %s\n", pz_file_name);
pf = fdopen (fd, "w");
#ifdef LATER
{
static const char hdr[] =
"/* DO NOT EDIT THIS FILE.\n\n"
" It has been auto-edited by fixincludes from /usr/include/%s\n"
" This had to be done to correct non-standard usages in the\n"
" original, manufacturer supplied header file. */\n\n";
fprintf (pf, hdr, pz_file_name);
}
#endif
return pf;
}
/* * * * * * * * * * * * *
test_test make sure a shell-style test expression passes.
Input: a pointer to the descriptor of the test to run and
the name of the file that we might want to fix
Result: SUCCESS or FAILURE, depending on the result of the
shell script we run. */
t_success
test_test (p_test, pz_file_name)
tTestDesc *p_test;
char* pz_file_name;
{
tSCC cmd_fmt[] =
"file=%s\n\
if ( test %s ) > /dev/null 2>&1\n\
then echo TRUE\n\
else echo FALSE\n\
fi";
char *pz_res;
t_success res = FAILURE;
static char cmd_buf[4096];
sprintf (cmd_buf, cmd_fmt, pz_file_name, p_test->pz_test_text);
pz_res = run_shell (cmd_buf);
if (*pz_res == 'T')
res = SUCCESS;
free ((void *) pz_res);
return res;
}
/* * * * * * * * * * * * *
egrep_test make sure an egrep expression is found in the file text.
Input: a pointer to the descriptor of the test to run and
the pointer to the contents of the file under suspicion
Result: SUCCESS if the pattern is found, FAILURE otherwise
The caller may choose 'FAILURE' as 'SUCCESS' if the sense of the test
is inverted. */
t_success
egrep_test (pz_data, p_test)
char *pz_data;
tTestDesc *p_test;
{
regmatch_t match;
#ifndef NO_BOGOSITY
if (p_test->p_test_regex == 0)
fprintf (stderr, "fixincl ERROR RE not compiled: `%s'\n",
p_test->pz_test_text);
#endif
if (regexec (p_test->p_test_regex, pz_data, 1, &match, 0) == 0)
return SUCCESS;
return FAILURE;
}
/* * * * * * * * * * * * *
quoted_file_exists Make sure that a file exists before we emit
the file name. If we emit the name, our invoking shell will try
to copy a non-existing file into the destination directory. */
int
quoted_file_exists (pz_src_path, pz_file_path, pz_file)
char* pz_src_path;
char* pz_file_path;
char* pz_file;
{
char z[ MAXPATHLEN ];
char* pz;
sprintf (z, "%s/%s/", pz_src_path, pz_file_path);
pz = z + strlen ( z );
for (;;) {
char ch = *pz_file++;
if (! isgraph( ch ))
return 0;
if (ch == '"')
break;
*pz++ = ch;
}
*pz = '\0';
{
struct stat s;
if (stat (z, &s) != 0)
return 0;
return S_ISREG( s.st_mode );
}
}
/* * * * * * * * * * * * *
*
extract_quoted_files
The syntax, `#include "file.h"' specifies that the compiler is to
search the local directory of the current file before the include
list. Consequently, if we have modified a header and stored it in
another directory, any files that are included by that modified
file in that fashion must also be copied into this new directory.
This routine finds those flavors of #include and for each one found
emits a triple of:
1. source directory of the original file
2. the relative path file name of the #includ-ed file
3. the full destination path for this file
Input: the text of the file, the file name and a pointer to the
match list where the match information was stored.
Result: internally nothing. The results are written to stdout
for interpretation by the invoking shell */
void
extract_quoted_files (pz_data, pz_file_name, p_re_match)
char *pz_data;
const char *pz_file_name;
regmatch_t *p_re_match;
{
char *pz_dir_end = strrchr (pz_file_name, '/');
char *pz_incl_quot = pz_data;
fprintf (stderr, "Quoted includes in %s\n", pz_file_name);
/* Set "pz_file_name" to point to the containing subdirectory of the source
If there is none, then it is in our current directory, ".". */
if (pz_dir_end == (char *) NULL)
pz_file_name = ".";
else
*pz_dir_end = '\0';
for (;;)
{
pz_incl_quot += p_re_match->rm_so;
/* Skip forward to the included file name */
while (isspace (*pz_incl_quot))
pz_incl_quot++;
while (isspace (*++pz_incl_quot))
;
pz_incl_quot += sizeof ("include") - 1;
while (*pz_incl_quot++ != '"')
;
if (quoted_file_exists (pz_src_dir, pz_file_name, pz_incl_quot))
{
/* Print the source directory and the subdirectory
of the file in question. */
printf ("%s %s/", pz_src_dir, pz_file_name);
pz_dir_end = pz_incl_quot;
/* Append to the directory the relative path of the desired file */
while (*pz_incl_quot != '"')
putc (*pz_incl_quot++, stdout);
/* Now print the destination directory appended with the
relative path of the desired file */
printf (" %s/%s/", pz_dest_dir, pz_file_name);
while (*pz_dir_end != '"')
putc (*pz_dir_end++, stdout);
/* End of entry */
putc ('\n', stdout);
}
/* Find the next entry */
if (regexec (&incl_quote_re, pz_incl_quot, 1, p_re_match, 0) != 0)
break;
}
}
/* * * * * * * * * * * * *
This loop should only cycle for 1/2 of one loop.
"chain_open" starts a process that uses "read_fd" as
its stdin and returns the new fd this process will use
for stdout. */
int
start_fixer (read_fd, p_fixd, pz_file_name)
int read_fd;
tFixDesc* p_fixd;
char* pz_file_name;
{
tSCC z_err[] = "Error %d (%s) starting filter process for %s\n";
tCC* pz_cmd_save;
char* pz_cmd;
if ((p_fixd->fd_flags & FD_SHELL_SCRIPT) == 0)
pz_cmd = (char*)NULL;
else
{
tSCC z_cmd_fmt[] = "file='%s'\n%s";
pz_cmd = (char*)xmalloc (strlen (p_fixd->patch_args[2])
+ sizeof( z_cmd_fmt )
+ strlen( pz_file_name ));
sprintf (pz_cmd, z_cmd_fmt, pz_file_name, p_fixd->patch_args[2]);
pz_cmd_save = p_fixd->patch_args[2];
p_fixd->patch_args[2] = pz_cmd;
}
for (;;)
{
static int failCt = 0;
int fd;
fd = chain_open (read_fd,
(t_pchar *) p_fixd->patch_args,
(process_chain_head == -1)
? &process_chain_head : (pid_t *) NULL);
if (fd != -1)
{
read_fd = fd;
break;
}
fprintf (stderr, z_err, errno, strerror (errno),
p_fixd->fix_name);
if ((errno != EAGAIN) || (++failCt > 10))
exit (EXIT_FAILURE);
sleep (1);
}
if (pz_cmd != (char*)NULL)
{
free ((void*)pz_cmd);
p_fixd->patch_args[2] = pz_cmd_save;
}
return read_fd;
}
/* * * * * * * * * * * * *
Process the potential fixes for a particular include file.
Input: the original text of the file and the file's name
Result: none. A new file may or may not be created. */
void
process (pz_data, pz_file_name)
char *pz_data;
const char *pz_file_name;
{
static char env_current_file[1024];
tFixDesc *p_fixd = fixDescList;
int todo_ct = FIX_COUNT;
int read_fd = -1;
int num_children = 0;
process_chain_head = NOPROCESS;
fprintf (stderr, "%-50s \r", pz_file_name );
/* For every fix in our fix list, ... */
for (; todo_ct > 0; p_fixd++, todo_ct--)
{
tTestDesc *p_test;
int test_ct;
if (p_fixd->fd_flags & FD_SKIP_TEST)
continue;
/* IF there is a file name restriction,
THEN ensure the current file name matches one in the pattern */
if (p_fixd->file_list != (char *) NULL)
{
const char *pz_fname = pz_file_name;
const char *pz_scan = p_fixd->file_list;
size_t name_len;
while ((pz_fname[0] == '.') && (pz_fname[1] == '/'))
pz_fname += 2;
name_len = strlen (pz_fname);
for (;;)
{
pz_scan = strstr (pz_scan + 1, pz_fname);
/* IF we can't match the string at all,
THEN bail */
if (pz_scan == (char *) NULL)
goto next_fix;
/* IF the match is surrounded by the '|' markers,
THEN we found a full match -- time to run the tests */
if ((pz_scan[-1] == '|') && (pz_scan[name_len] == '|'))
break;
}
}
/* FOR each test, see if it fails.
IF it does fail, then we go on to the next test */
for (p_test = p_fixd->p_test_desc, test_ct = p_fixd->test_ct;
test_ct-- > 0;
p_test++)
{
#ifdef DEBUG_TEST
static const char z_test_fail[] =
"%16s test %2d failed for %s\n";
#endif
switch (p_test->type)
{
case TT_TEST:
if (!SUCCESSFUL (test_test (p_test, pz_file_name)))
{
#ifdef DEBUG_TEST
fprintf (stderr, z_test_fail, p_fixd->fix_name,
p_fixd->test_ct - test_ct, pz_file_name);
#endif
goto next_fix;
}
break;
case TT_EGREP:
if (!SUCCESSFUL (egrep_test (pz_data, p_test)))
{
#ifdef DEBUG_TEST
fprintf (stderr, z_test_fail, p_fixd->fix_name,
p_fixd->test_ct - test_ct, pz_file_name);
#endif
goto next_fix;
}
break;
case TT_NEGREP:
if (SUCCESSFUL (egrep_test (pz_data, p_test)))
{
#ifdef DEBUG_TEST
fprintf (stderr, z_test_fail, p_fixd->fix_name,
p_fixd->test_ct - test_ct, pz_file_name);
#endif
goto next_fix;
}
break;
}
}
fprintf (stderr, "Applying %-24s to %s\n",
p_fixd->fix_name, pz_file_name);
/* IF we do not have a read pointer,
THEN this is the first fix for the current file.
Open the source file. That will be used as stdin for
the first fix. Any subsequent fixes will use the
stdout descriptor of the previous fix as its stdin. */
if (read_fd == -1)
{
read_fd = open (pz_file_name, O_RDONLY);
if (read_fd < 0)
{
fprintf (stderr, "Error %d (%s) opening %s\n", errno,
strerror (errno), pz_file_name);
exit (EXIT_FAILURE);
}
}
read_fd = start_fixer (read_fd, p_fixd, pz_file_name);
num_children++;
next_fix:
;
}
/* IF after all the tests we did not start any patch programs,
THEN quit now. */
if (read_fd < 0)
return;
/* OK. We have work to do. Read back in the output
of the filtering chain. Compare each byte as we read it with
the contents of the original file. As soon as we find any
difference, we will create the output file, write out all
the matched text and then copy any remaining data from the
output of the filter chain.
*/
{
FILE *in_fp = fdopen (read_fd, "r");
FILE *out_fp = (FILE *) NULL;
char *pz_cmp = pz_data;
for (;;)
{
int ch;
ch = getc (in_fp);
if (ch == EOF)
break;
/* IF we are emitting the output
THEN emit this character, too.
*/
if (out_fp != (FILE *) NULL)
putc (ch, out_fp);
/* ELSE if this character does not match the original,
THEN now is the time to start the output.
*/
else if (ch != *pz_cmp)
{
out_fp = create_file (pz_file_name);
/* IF there are matched data, write it all now. */
if (pz_cmp != pz_data)
{
char c = *pz_cmp;
*pz_cmp = NUL;
fputs (pz_data, out_fp);
*pz_cmp = c;
}
/* Emit the current unmatching character */
putc (ch, out_fp);
}
else
/* ELSE the character matches. Advance the compare ptr */
pz_cmp++;
}
/* IF we created the output file, ... */
if (out_fp != (FILE *) NULL)
{
regmatch_t match;
/* Close the file and see if we have to worry about
`#include "file.h"' constructs. */
fclose (out_fp);
if (regexec (&incl_quote_re, pz_data, 1, &match, 0) == 0)
extract_quoted_files (pz_data, pz_file_name, &match);
}
fclose (in_fp);
}
close (read_fd); /* probably redundant, but I'm paranoid */
/* Wait for child processes created by chain_open()
to avoid creating zombies. */
while (--num_children >= 0)
wait ((int *) NULL);
}
Reference in New Issue View Git Blame Copy Permalink