418 lines
10 KiB
C
418 lines
10 KiB
C
|
|
/* 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 GCC will search.
|
|
|
|
Copyright (C) 1999, 2000, 2001, 2004, 2009 Free Software Foundation, Inc.
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC 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 3, or (at your option)
|
|
any later version.
|
|
|
|
GCC 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 GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include "fixlib.h"
|
|
|
|
/* * * * * * * * * * * * *
|
|
|
|
load_file_data loads all the contents of a file into malloc-ed memory.
|
|
Its argument is the file pointer 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_data (FILE* fp)
|
|
{
|
|
char *pz_data = (char*)NULL;
|
|
int space_left = -1; /* allow for terminating NUL */
|
|
size_t space_used = 0;
|
|
|
|
if (fp == (FILE*)NULL)
|
|
return pz_data;
|
|
|
|
do
|
|
{
|
|
size_t size_read;
|
|
|
|
if (space_left < 1024)
|
|
{
|
|
space_left += 4096;
|
|
pz_data = XRESIZEVEC (char, pz_data, space_left + space_used + 1 );
|
|
}
|
|
size_read = fread (pz_data + space_used, 1, space_left, fp);
|
|
|
|
if (size_read == 0)
|
|
{
|
|
if (feof (fp))
|
|
break;
|
|
|
|
if (ferror (fp))
|
|
{
|
|
int err = errno;
|
|
if (err != EISDIR)
|
|
fprintf (stderr, "error %d (%s) reading input\n", err,
|
|
xstrerror (err));
|
|
free ((void *) pz_data);
|
|
return (char *) NULL;
|
|
}
|
|
}
|
|
|
|
space_left -= size_read;
|
|
space_used += size_read;
|
|
} while (! feof (fp));
|
|
|
|
pz_data = XRESIZEVEC (char, pz_data, space_used+1 );
|
|
pz_data[ space_used ] = NUL;
|
|
|
|
return pz_data;
|
|
}
|
|
|
|
#ifdef IS_CXX_HEADER_NEEDED
|
|
t_bool
|
|
is_cxx_header (tCC* fname, tCC* text)
|
|
{
|
|
/* First, check to see if the file is in a C++ directory */
|
|
for (;;)
|
|
{
|
|
switch (*(fname++))
|
|
{
|
|
case 'C': /* check for "CC/" */
|
|
if ((fname[0] == 'C') && (fname[1] == '/'))
|
|
return BOOL_TRUE;
|
|
break;
|
|
|
|
case 'x': /* check for "xx/" */
|
|
if ((fname[0] == 'x') && (fname[1] == '/'))
|
|
return BOOL_TRUE;
|
|
break;
|
|
|
|
case '+': /* check for "++" */
|
|
if (fname[0] == '+')
|
|
return BOOL_TRUE;
|
|
break;
|
|
|
|
case NUL:
|
|
goto not_cxx_name;
|
|
}
|
|
} not_cxx_name:;
|
|
|
|
/* Or it might contain one of several phrases which indicate C++ code.
|
|
Currently recognized are:
|
|
extern "C++"
|
|
-*- (Mode: )? C++ -*- (emacs mode marker)
|
|
template <
|
|
*/
|
|
{
|
|
tSCC cxxpat[] = "\
|
|
extern[ \t]*\"C\\+\\+\"|\
|
|
-\\*-[ \t]*([mM]ode:[ \t]*)?[cC]\\+\\+[; \t]*-\\*-|\
|
|
template[ \t]*<|\
|
|
^[ \t]*class[ \t]|\
|
|
(public|private|protected):|\
|
|
^[ \t]*#[ \t]*pragma[ \t]+(interface|implementation)\
|
|
";
|
|
static regex_t cxxre;
|
|
static int compiled;
|
|
|
|
if (!compiled)
|
|
compile_re (cxxpat, &cxxre, 0, "contents check", "is_cxx_header");
|
|
|
|
if (xregexec (&cxxre, text, 0, 0, 0) == 0)
|
|
return BOOL_TRUE;
|
|
}
|
|
|
|
return BOOL_FALSE;
|
|
}
|
|
#endif /* CXX_TYPE_NEEDED */
|
|
|
|
#ifdef SKIP_QUOTE_NEEDED
|
|
/*
|
|
* Skip over a quoted string. Single quote strings may
|
|
* contain multiple characters if the first character is
|
|
* a backslash. Especially a backslash followed by octal digits.
|
|
* We are not doing a correctness syntax check here.
|
|
*/
|
|
tCC*
|
|
skip_quote(char q, char* text )
|
|
{
|
|
for (;;)
|
|
{
|
|
char ch = *(text++);
|
|
switch (ch)
|
|
{
|
|
case '\\':
|
|
text++; /* skip over whatever character follows */
|
|
break;
|
|
|
|
case '"':
|
|
case '\'':
|
|
if (ch != q)
|
|
break;
|
|
/*FALLTHROUGH*/
|
|
|
|
case '\n':
|
|
case NUL:
|
|
goto skip_done;
|
|
}
|
|
} skip_done:;
|
|
|
|
return text;
|
|
}
|
|
#endif /* SKIP_QUOTE_NEEDED */
|
|
|
|
/* * * * * * * * * * * * *
|
|
|
|
Compile one regular expression pattern for later use. PAT contains
|
|
the pattern, RE points to a regex_t structure (which should have
|
|
been bzeroed). MATCH is 1 if we need to know where the regex
|
|
matched, 0 if not. If xregcomp fails, prints an error message and
|
|
aborts; E1 and E2 are strings to shove into the error message.
|
|
|
|
The patterns we search for are all egrep patterns.
|
|
REG_EXTENDED|REG_NEWLINE produces identical regex syntax/semantics
|
|
to egrep (verified from 4.4BSD Programmer's Reference Manual). */
|
|
void
|
|
compile_re( tCC* pat, regex_t* re, int match, tCC* e1, tCC* e2 )
|
|
{
|
|
tSCC z_bad_comp[] = "fixincl ERROR: cannot compile %s regex for %s\n\
|
|
\texpr = `%s'\n\terror %s\n";
|
|
int flags, err;
|
|
|
|
flags = (match ? REG_EXTENDED|REG_NEWLINE
|
|
: REG_EXTENDED|REG_NEWLINE|REG_NOSUB);
|
|
err = xregcomp (re, pat, flags);
|
|
|
|
if (err)
|
|
{
|
|
char rerrbuf[1024];
|
|
regerror (err, re, rerrbuf, 1024);
|
|
fprintf (stderr, z_bad_comp, e1, e2, pat, rerrbuf);
|
|
exit (EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
/* * * * * * * * * * * * *
|
|
|
|
Helper routine and data for the machine_name test and fix. */
|
|
|
|
tSCC mn_label_pat[] = "^[ \t]*#[ \t]*(if|ifdef|ifndef)[ \t]+";
|
|
static regex_t mn_label_re;
|
|
static regex_t mn_name_re;
|
|
|
|
static int mn_compiled = 0;
|
|
|
|
t_bool
|
|
mn_get_regexps(regex_t** label_re, regex_t** name_re, tCC* who )
|
|
{
|
|
if (! pz_mn_name_pat)
|
|
return BOOL_FALSE;
|
|
|
|
if (! mn_compiled)
|
|
{
|
|
compile_re (mn_label_pat, &mn_label_re, 1, "label pattern", who);
|
|
compile_re (pz_mn_name_pat, &mn_name_re, 1, "name pattern", who);
|
|
mn_compiled++;
|
|
}
|
|
*label_re = &mn_label_re;
|
|
*name_re = &mn_name_re;
|
|
return BOOL_TRUE;
|
|
}
|
|
|
|
|
|
#ifdef SEPARATE_FIX_PROC
|
|
|
|
char*
|
|
make_raw_shell_str( char* pz_d, tCC* pz_s, size_t smax )
|
|
{
|
|
tSCC zQ[] = "'\\''";
|
|
size_t dtaSize;
|
|
char* pz_d_start = pz_d;
|
|
|
|
smax--; /* adjust for trailing NUL */
|
|
|
|
dtaSize = strlen( pz_s ) + 3;
|
|
|
|
{
|
|
const char* pz = pz_s - 1;
|
|
|
|
for (;;) {
|
|
pz = strchr( pz+1, '\'' );
|
|
if (pz == (char*)NULL)
|
|
break;
|
|
dtaSize += sizeof( zQ )-1;
|
|
}
|
|
}
|
|
if (dtaSize > smax)
|
|
return (char*)NULL;
|
|
|
|
*(pz_d++) = '\'';
|
|
|
|
for (;;) {
|
|
if ((size_t) (pz_d - pz_d_start) >= smax)
|
|
return (char*)NULL;
|
|
switch (*(pz_d++) = *(pz_s++)) {
|
|
case NUL:
|
|
goto loopDone;
|
|
|
|
case '\'':
|
|
if ((size_t) (pz_d - pz_d_start) >= smax - sizeof( zQ )-1)
|
|
return (char*)NULL;
|
|
strcpy( pz_d-1, zQ );
|
|
pz_d += sizeof( zQ )-2;
|
|
}
|
|
} loopDone:;
|
|
pz_d[-1] = '\'';
|
|
*pz_d = NUL;
|
|
|
|
return pz_d;
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(__MINGW32__)
|
|
void
|
|
fix_path_separators (char* p)
|
|
{
|
|
while (p != NULL)
|
|
{
|
|
p = strchr (p, '\\');
|
|
if (p != NULL)
|
|
{
|
|
*p = '/';
|
|
++p;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Count number of needle character ocurrences in str */
|
|
static int
|
|
count_occurrences_of_char (char* str, char needle)
|
|
{
|
|
int cnt = 0;
|
|
|
|
while (str)
|
|
{
|
|
str = strchr (str, needle);
|
|
if (str)
|
|
{
|
|
++str;
|
|
++cnt;
|
|
}
|
|
}
|
|
|
|
return cnt;
|
|
}
|
|
|
|
/* On Mingw32, system function will just start cmd by default.
|
|
Call system function, but prepend ${CONFIG_SHELL} or ${SHELL} -c to the command,
|
|
replace newlines with '$'\n'', enclose command with double quotes
|
|
and escape special characters which were originally enclosed in single quotes.
|
|
*/
|
|
int
|
|
system_with_shell (char* s)
|
|
{
|
|
static const char z_shell_start_args[] = " -c \"";
|
|
static const char z_shell_end_args[] = "\"";
|
|
static const char z_shell_newline[] = "'$'\\n''";
|
|
|
|
/* Use configured shell if present */
|
|
char *env_shell = getenv ("CONFIG_SHELL");
|
|
int newline_cnt = count_occurrences_of_char (s, '\n');
|
|
int escapes_cnt = count_occurrences_of_char( s, '\\')
|
|
+ count_occurrences_of_char (s, '"')
|
|
+ count_occurrences_of_char (s, '`');
|
|
char *long_cmd;
|
|
char *cmd_endp;
|
|
int sys_result;
|
|
char *s_scan;
|
|
int in_quotes;
|
|
|
|
if (env_shell == NULL)
|
|
env_shell = getenv ("SHELL");
|
|
|
|
/* If neither CONFIGURED_SHELL nor SHELL is set, just call standard system function */
|
|
if (env_shell == NULL)
|
|
return system (s);
|
|
|
|
/* Allocate enough memory to fit newly created command string */
|
|
long_cmd = XNEWVEC (char, strlen (env_shell)
|
|
+ strlen (z_shell_start_args)
|
|
+ strlen (s)
|
|
+ newline_cnt * (strlen (z_shell_newline) - 1)
|
|
+ escapes_cnt
|
|
+ strlen (z_shell_end_args)
|
|
+ 1);
|
|
|
|
/* Start with ${SHELL} */
|
|
strcpy (long_cmd, env_shell);
|
|
cmd_endp = long_cmd + strlen (long_cmd);
|
|
|
|
/* Opening quote */
|
|
strcpy (cmd_endp, z_shell_start_args);
|
|
cmd_endp += strlen (z_shell_start_args);
|
|
|
|
/* Replace newlines and escape special chars */
|
|
in_quotes = 0;
|
|
for (s_scan = s; *s_scan; ++s_scan)
|
|
{
|
|
switch (*s_scan)
|
|
{
|
|
case '\n':
|
|
if (in_quotes)
|
|
{
|
|
/* Replace newline inside quotes with '$'\n'' */
|
|
strcpy (cmd_endp, z_shell_newline);
|
|
cmd_endp += strlen (z_shell_newline);
|
|
}
|
|
else
|
|
{
|
|
/* Replace newlines outside quotes with ; and merge subsequent newlines */
|
|
*(cmd_endp++) = ';';
|
|
*(cmd_endp++) = ' ';
|
|
while (*(s_scan + 1) == '\n' || *(s_scan + 1) == ' ' || *(s_scan + 1) == '\t')
|
|
++s_scan;
|
|
}
|
|
break;
|
|
case '\'':
|
|
/* Escape single quote and toggle in_quotes flag */
|
|
in_quotes = !in_quotes;
|
|
*(cmd_endp++) = *s_scan;
|
|
break;
|
|
case '\\':
|
|
case '`':
|
|
/* Escape backslash and backtick inside quotes */
|
|
if (in_quotes)
|
|
*(cmd_endp++) = '\\';
|
|
*(cmd_endp++) = *s_scan;
|
|
break;
|
|
case '"':
|
|
/* Escape double quotes always */
|
|
*(cmd_endp++) = '\\';
|
|
*(cmd_endp++) = *s_scan;
|
|
break;
|
|
default:
|
|
*(cmd_endp++) = *s_scan;
|
|
}
|
|
}
|
|
|
|
/* Closing quote */
|
|
strcpy (cmd_endp, z_shell_end_args);
|
|
|
|
sys_result = system (long_cmd);
|
|
|
|
free (long_cmd);
|
|
|
|
return sys_result;
|
|
}
|
|
|
|
#endif /* defined(__MINGW32__) */
|