| |
| /* 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__) */ |
