diff options
author | upstream source tree <ports@midipix.org> | 2015-03-15 20:14:05 -0400 |
---|---|---|
committer | upstream source tree <ports@midipix.org> | 2015-03-15 20:14:05 -0400 |
commit | 554fd8c5195424bdbcabf5de30fdc183aba391bd (patch) | |
tree | 976dc5ab7fddf506dadce60ae936f43f58787092 /fixincludes/fixfixes.c | |
download | cbb-gcc-4.6.4-554fd8c5195424bdbcabf5de30fdc183aba391bd.tar.bz2 cbb-gcc-4.6.4-554fd8c5195424bdbcabf5de30fdc183aba391bd.tar.xz |
obtained gcc-4.6.4.tar.bz2 from upstream website;upstream
verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.
downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.
if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.
Diffstat (limited to 'fixincludes/fixfixes.c')
-rw-r--r-- | fixincludes/fixfixes.c | 806 |
1 files changed, 806 insertions, 0 deletions
diff --git a/fixincludes/fixfixes.c b/fixincludes/fixfixes.c new file mode 100644 index 000000000..5616bf149 --- /dev/null +++ b/fixincludes/fixfixes.c @@ -0,0 +1,806 @@ + +/* + + Test to see if a particular fix should be applied to a header file. + + Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2009 + Free Software Foundation, Inc. + += = = = = = = = = = = = = = = = = = = = = = = = = + +NOTE TO DEVELOPERS + +The routines you write here must work closely with fixincl.c. + +Here are the rules: + +1. Every test procedure name must be suffixed with "_fix". + These routines will be referenced from inclhack.def, sans the suffix. + +2. Use the "FIX_PROC_HEAD()" macro _with_ the "_fix" suffix + (I cannot use the ## magic from ANSI C) for defining your entry point. + +3. Put your test name into the FIXUP_TABLE. + +4. Do not read anything from stdin. It is closed. + +5. Write to stderr only in the event of a reportable error + In such an event, call "exit (EXIT_FAILURE)". + +6. You have access to the fixDescList entry for the fix in question. + This may be useful, for example, if there are interesting strings + or pre-compiled regular expressions stored there. + += = = = = = = = = = = = = = = = = = = = = = = = = + +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" +#define GTYPE_SE_CT 1 + +#ifdef SEPARATE_FIX_PROC +#include "fixincl.x" +#endif + +tSCC zNeedsArg[] = "fixincl error: `%s' needs %s argument (c_fix_arg[%d])\n"; + +typedef void t_fix_proc (const char *, const char *, tFixDesc *) ; +typedef struct { + const char* fix_name; + t_fix_proc* fix_proc; +} fix_entry_t; + +#define FIXUP_TABLE \ + _FT_( "char_macro_def", char_macro_def_fix ) \ + _FT_( "char_macro_use", char_macro_use_fix ) \ + _FT_( "format", format_fix ) \ + _FT_( "machine_name", machine_name_fix ) \ + _FT_( "wrap", wrap_fix ) \ + _FT_( "gnu_type", gnu_type_fix ) + + +#define FIX_PROC_HEAD( fix ) \ +static void fix (const char* filname ATTRIBUTE_UNUSED , \ + const char* text ATTRIBUTE_UNUSED , \ + tFixDesc* p_fixd ATTRIBUTE_UNUSED ) + +#ifdef NEED_PRINT_QUOTE +/* + * 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. + */ +static char* +print_quote(char q, char* text ) +{ + fputc( q, stdout ); + + for (;;) + { + char ch = *(text++); + fputc( ch, stdout ); + + switch (ch) + { + case '\\': + if (*text == NUL) + goto quote_done; + + fputc( *(text++), stdout ); + break; + + case '"': + case '\'': + if (ch != q) + break; + /*FALLTHROUGH*/ + + case '\n': + case NUL: + goto quote_done; + } + } quote_done:; + + return text; +} +#endif /* NEED_PRINT_QUOTE */ + + +/* + * Emit the GNU standard type wrapped up in such a way that + * this thing can be encountered countless times during a compile + * and not cause even a warning. + */ +static const char* +emit_gnu_type (const char* text, regmatch_t* rm ) +{ + char z_TYPE[ 64 ]; + char z_type[ 64 ]; + + fwrite (text, rm[0].rm_so, 1, stdout); + + { + const char* ps = text + rm[1].rm_so; + const char* pe = text + rm[1].rm_eo; + char* pd = z_type; + char* pD = z_TYPE; + + while (ps < pe) + *(pD++) = TOUPPER( *(pd++) = *(ps++) ); + + *pD = *pd = NUL; + } + + /* + * Now print out the reformed typedef, + * with a C++ guard for WCHAR + */ + { + tSCC z_fmt[] = "\ +#if !defined(_GCC_%s_T)%s\n\ +#define _GCC_%s_T\n\ +typedef __%s_TYPE__ %s_t;\n\ +#endif\n"; + + const char *const pz_guard = (strcmp (z_type, "wchar") == 0) + ? " && ! defined(__cplusplus)" : ""; + + printf (z_fmt, z_TYPE, pz_guard, z_TYPE, z_TYPE, z_type); + } + + return text += rm[0].rm_eo; +} + + +/* + * Copy the `format' string to std out, replacing `%n' expressions + * with the matched text from a regular expression evaluation. + * Doubled '%' characters will be replaced with a single copy. + * '%' characters in other contexts and all other characters are + * copied out verbatim. + */ +static void +format_write (tCC* format, tCC* text, regmatch_t av[] ) +{ + int c; + + while ((c = (unsigned)*(format++)) != NUL) { + + if (c != '%') + { + putchar(c); + continue; + } + + c = (unsigned)*(format++); + + /* + * IF the character following a '%' is not a digit, + * THEN we will always emit a '%' and we may or may + * not emit the following character. We will end on + * a NUL and we will emit only one of a pair of '%'. + */ + if (! ISDIGIT ( c )) + { + putchar( '%' ); + switch (c) { + case NUL: + return; + case '%': + break; + default: + putchar(c); + } + } + + /* + * Emit the matched subexpression numbered 'c'. + * IF, of course, there was such a match... + */ + else { + regmatch_t* pRM = av + (c - (unsigned)'0'); + size_t len; + + if (pRM->rm_so < 0) + continue; + + len = pRM->rm_eo - pRM->rm_so; + if (len > 0) + fwrite(text + pRM->rm_so, len, 1, stdout); + } + } +} + + +/* + * Search for multiple copies of a regular expression. Each block + * of matched text is replaced with the format string, as described + * above in `format_write'. + */ +FIX_PROC_HEAD( format_fix ) +{ + tCC* pz_pat = p_fixd->patch_args[2]; + tCC* pz_fmt = p_fixd->patch_args[1]; + regex_t re; + regmatch_t rm[10]; + IGNORE_ARG(filname); + + /* + * We must have a format + */ + if (pz_fmt == (tCC*)NULL) + { + fprintf( stderr, zNeedsArg, p_fixd->fix_name, "replacement format", 0 ); + exit (EXIT_BROKEN); + } + + /* + * IF we don't have a search text, then go find the first + * regular expression among the tests. + */ + if (pz_pat == (tCC*)NULL) + { + tTestDesc* pTD = p_fixd->p_test_desc; + int ct = p_fixd->test_ct; + for (;;) + { + if (ct-- <= 0) + { + fprintf( stderr, zNeedsArg, p_fixd->fix_name, "search text", 1 ); + exit (EXIT_BROKEN); + } + + if (pTD->type == TT_EGREP) + { + pz_pat = pTD->pz_test_text; + break; + } + + pTD++; + } + } + + /* + * Replace every copy of the text we find + */ + compile_re (pz_pat, &re, 1, "format search-text", "format_fix" ); + while (xregexec (&re, text, 10, rm, 0) == 0) + { + fwrite( text, rm[0].rm_so, 1, stdout ); + format_write( pz_fmt, text, rm ); + text += rm[0].rm_eo; + } + + /* + * Dump out the rest of the file + */ + fputs (text, stdout); +} + + +/* Scan the input file for all occurrences of text like this: + + #define TIOCCONS _IO(T, 12) + + and change them to read like this: + + #define TIOCCONS _IO('T', 12) + + which is the required syntax per the C standard. (The definition of + _IO also has to be tweaked - see below.) 'IO' is actually whatever you + provide as the `c_fix_arg' argument. */ + +FIX_PROC_HEAD( char_macro_use_fix ) +{ + /* This regexp looks for a traditional-syntax #define (# in column 1) + of an object-like macro. */ + static const char pat[] = + "^#[ \t]*define[ \t]+[_A-Za-z][_A-Za-z0-9]*[ \t]+"; + static regex_t re; + + const char* str = p_fixd->patch_args[1]; + regmatch_t rm[1]; + const char *p, *limit; + size_t len; + IGNORE_ARG(filname); + + if (str == NULL) + { + fprintf (stderr, zNeedsArg, p_fixd->fix_name, "ioctl type", 0); + exit (EXIT_BROKEN); + } + + len = strlen (str); + compile_re (pat, &re, 1, "macro pattern", "char_macro_use_fix"); + + for (p = text; + xregexec (&re, p, 1, rm, 0) == 0; + p = limit + 1) + { + /* p + rm[0].rm_eo is the first character of the macro replacement. + Find the end of the macro replacement, and the STR we were + sent to look for within the replacement. */ + p += rm[0].rm_eo; + limit = p - 1; + do + { + limit = strchr (limit + 1, '\n'); + if (!limit) + goto done; + } + while (limit[-1] == '\\'); + + do + { + if (*p == str[0] && !strncmp (p+1, str+1, len-1)) + goto found; + } + while (++p < limit - len); + /* Hit end of line. */ + continue; + + found: + /* Found STR on this line. If the macro needs fixing, + the next few chars will be whitespace or uppercase, + then an open paren, then a single letter. */ + while ((ISSPACE (*p) || ISUPPER (*p)) && p < limit) p++; + if (*p++ != '(') + continue; + if (!ISALPHA (*p)) + continue; + if (ISIDNUM (p[1])) + continue; + + /* Splat all preceding text into the output buffer, + quote the character at p, then proceed. */ + fwrite (text, 1, p - text, stdout); + putchar ('\''); + putchar (*p); + putchar ('\''); + text = p + 1; + } + done: + fputs (text, stdout); +} + + +/* Scan the input file for all occurrences of text like this: + + #define xxxIOxx(x, y) (....'x'<<16....) + + and change them to read like this: + + #define xxxIOxx(x, y) (....x<<16....) + + which is the required syntax per the C standard. (The uses of _IO + also has to be tweaked - see above.) 'IO' is actually whatever + you provide as the `c_fix_arg' argument. */ +FIX_PROC_HEAD( char_macro_def_fix ) +{ + /* This regexp looks for any traditional-syntax #define (# in column 1). */ + static const char pat[] = + "^#[ \t]*define[ \t]+"; + static regex_t re; + + const char* str = p_fixd->patch_args[1]; + regmatch_t rm[1]; + const char *p, *limit; + char arg; + size_t len; + IGNORE_ARG(filname); + + if (str == NULL) + { + fprintf (stderr, zNeedsArg, p_fixd->fix_name, "ioctl type", 0); + exit (EXIT_BROKEN); + } + + len = strlen (str); + compile_re (pat, &re, 1, "macro pattern", "fix_char_macro_defines"); + + for (p = text; + xregexec (&re, p, 1, rm, 0) == 0; + p = limit + 1) + { + /* p + rm[0].rm_eo is the first character of the macro name. + Find the end of the macro replacement, and the STR we were + sent to look for within the name. */ + p += rm[0].rm_eo; + limit = p - 1; + do + { + limit = strchr (limit + 1, '\n'); + if (!limit) + goto done; + } + while (limit[-1] == '\\'); + + do + { + if (*p == str[0] && !strncmp (p+1, str+1, len-1)) + goto found; + p++; + } + while (ISIDNUM (*p)); + /* Hit end of macro name without finding the string. */ + continue; + + found: + /* Found STR in this macro name. If the macro needs fixing, + there may be a few uppercase letters, then there will be an + open paren with _no_ intervening whitespace, and then a + single letter. */ + while (ISUPPER (*p) && p < limit) p++; + if (*p++ != '(') + continue; + if (!ISALPHA (*p)) + continue; + if (ISIDNUM (p[1])) + continue; + + /* The character at P is the one to look for in the following + text. */ + arg = *p; + p += 2; + + while (p < limit) + { + if (p[-1] == '\'' && p[0] == arg && p[1] == '\'') + { + /* Remove the quotes from this use of ARG. */ + p--; + fwrite (text, 1, p - text, stdout); + putchar (arg); + p += 3; + text = p; + } + else + p++; + } + } + done: + fputs (text, stdout); +} + +/* Fix for machine name #ifdefs that are not in the namespace reserved + by the C standard. They won't be defined if compiling with -ansi, + and the headers will break. We go to some trouble to only change + #ifdefs where the macro is defined by GCC in non-ansi mode; this + minimizes the number of headers touched. */ + +#define SCRATCHSZ 64 /* hopefully long enough */ + +FIX_PROC_HEAD( machine_name_fix ) +{ + regmatch_t match[2]; + const char *line, *base, *limit, *p, *q; + regex_t *label_re, *name_re; + char scratch[SCRATCHSZ]; + size_t len; + IGNORE_ARG(filname); + IGNORE_ARG(p_fixd); + + if (!mn_get_regexps (&label_re, &name_re, "machine_name_fix")) + { + fputs( "The target machine has no needed machine name fixes\n", stderr ); + goto done; + } + + scratch[0] = '_'; + scratch[1] = '_'; + + for (base = text; + xregexec (label_re, base, 2, match, 0) == 0; + base = limit) + { + base += match[0].rm_eo; + /* We're looking at an #if or #ifdef. Scan forward for the + next non-escaped newline. */ + line = limit = base; + do + { + limit++; + limit = strchr (limit, '\n'); + if (!limit) + goto done; + } + while (limit[-1] == '\\'); + + /* If the 'name_pat' matches in between base and limit, we have + a bogon. It is not worth the hassle of excluding comments + because comments on #if/#ifdef lines are rare, and strings on + such lines are illegal. + + REG_NOTBOL means 'base' is not at the beginning of a line, which + shouldn't matter since the name_re has no ^ anchor, but let's + be accurate anyway. */ + + for (;;) + { + again: + if (base == limit) + break; + + if (xregexec (name_re, base, 1, match, REG_NOTBOL)) + goto done; /* No remaining match in this file */ + + /* Match; is it on the line? */ + if (match[0].rm_eo > limit - base) + break; + + p = base + match[0].rm_so; + base += match[0].rm_eo; + + /* One more test: if on the same line we have the same string + with the appropriate underscores, then leave it alone. + We want exactly two leading and trailing underscores. */ + if (*p == '_') + { + len = base - p - ((*base == '_') ? 2 : 1); + q = p + 1; + } + else + { + len = base - p - ((*base == '_') ? 1 : 0); + q = p; + } + if (len + 4 > SCRATCHSZ) + abort (); + memcpy (&scratch[2], q, len); + len += 2; + scratch[len++] = '_'; + scratch[len++] = '_'; + + for (q = line; q <= limit - len; q++) + if (*q == '_' && !strncmp (q, scratch, len)) + goto again; + + fwrite (text, 1, p - text, stdout); + fwrite (scratch, 1, len, stdout); + + text = base; + } + } + done: + fputs (text, stdout); +} + + +FIX_PROC_HEAD( wrap_fix ) +{ + tSCC z_no_wrap_pat[] = "^#if.*__need_"; + static regex_t no_wrapping_re; /* assume zeroed data */ + + tCC* pz_name = NULL; + + if (no_wrapping_re.allocated == 0) + compile_re( z_no_wrap_pat, &no_wrapping_re, 0, "no-wrap pattern", + "wrap-fix" ); + + /* + * IF we do *not* match the no-wrap re, then we have a double negative. + * A double negative means YES. + */ + if (xregexec( &no_wrapping_re, text, 0, NULL, 0 ) != 0) + { + /* + * A single file can get wrapped more than once by different fixes. + * A single fix can wrap multiple files. Therefore, guard with + * *both* the fix name and the file name. + */ + size_t ln = strlen( filname ) + strlen( p_fixd->fix_name ) + 14; + char* pz = XNEWVEC (char, ln); + pz_name = pz; + sprintf( pz, "FIXINC_WRAP_%s-%s", filname, p_fixd->fix_name ); + + for (pz += 12; 1; pz++) { + char ch = *pz; + + if (ch == NUL) + break; + + if (! ISALNUM( ch )) { + *pz = '_'; + } + else { + *pz = TOUPPER( ch ); + } + } + + printf( "#ifndef %s\n", pz_name ); + printf( "#define %s 1\n\n", pz_name ); + } + + if (p_fixd->patch_args[1] == (tCC*)NULL) + fputs( text, stdout ); + + else { + fputs( p_fixd->patch_args[1], stdout ); + fputs( text, stdout ); + if (p_fixd->patch_args[2] != (tCC*)NULL) + fputs( p_fixd->patch_args[2], stdout ); + } + + if (pz_name != NULL) { + printf( "\n#endif /* %s */\n", pz_name ); + free( (void*)pz_name ); + } +} + + +/* + * Search for multiple copies of a regular expression. Each block + * of matched text is replaced with the format string, as described + * above in `format_write'. + */ +FIX_PROC_HEAD( gnu_type_fix ) +{ + const char* pz_pat; + regex_t re; + regmatch_t rm[GTYPE_SE_CT+1]; + IGNORE_ARG(filname); + + { + tTestDesc* pTD = p_fixd->p_test_desc; + int ct = p_fixd->test_ct; + for (;;) + { + if (ct-- <= 0) + { + fprintf (stderr, zNeedsArg, p_fixd->fix_name, "search text", 1); + exit (EXIT_BROKEN); + } + + if (pTD->type == TT_EGREP) + { + pz_pat = pTD->pz_test_text; + break; + } + + pTD++; + } + } + + compile_re (pz_pat, &re, 1, "gnu type typedef", "gnu_type_fix"); + + while (xregexec (&re, text, GTYPE_SE_CT+1, rm, 0) == 0) + { + text = emit_gnu_type (text, rm); + } + + /* + * Dump out the rest of the file + */ + fputs (text, stdout); +} + + +/* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = + + test for fix selector + + THIS IS THE ONLY EXPORTED ROUTINE + +*/ +void +apply_fix( tFixDesc* p_fixd, tCC* filname ) +{ +#define _FT_(n,p) { n, p }, + static fix_entry_t fix_table[] = { FIXUP_TABLE { NULL, NULL }}; +#undef _FT_ +#define FIX_TABLE_CT (ARRAY_SIZE (fix_table)-1) + + tCC* fixname = p_fixd->patch_args[0]; + char* buf; + int ct = FIX_TABLE_CT; + fix_entry_t* pfe = fix_table; + + for (;;) + { + if (strcmp (pfe->fix_name, fixname) == 0) + break; + if (--ct <= 0) + { + fprintf (stderr, "fixincl error: the `%s' fix is unknown\n", + fixname ); + exit (EXIT_BROKEN); + } + pfe++; + } + + buf = load_file_data (stdin); + (*pfe->fix_proc)( filname, buf, p_fixd ); +} + +#ifdef SEPARATE_FIX_PROC +tSCC z_usage[] = +"USAGE: applyfix <fix-name> <file-to-fix> <file-source> <file-destination>\n"; +tSCC z_reopen[] = +"FS error %d (%s) reopening %s as std%s\n"; + +int +main( int argc, char** argv ) +{ + tFixDesc* pFix; + char* pz_tmptmp; + char* pz_tmp_base; + char* pz_tmp_dot; + + if (argc != 5) + { + usage_failure: + fputs (z_usage, stderr); + return EXIT_FAILURE; + } + + initialize_opts (); + + { + char* pz = argv[1]; + long idx; + + if (! ISDIGIT ( *pz )) + goto usage_failure; + + idx = strtol (pz, &pz, 10); + if ((*pz != NUL) || ((unsigned)idx >= FIX_COUNT)) + goto usage_failure; + pFix = fixDescList + idx; + } + + if (freopen (argv[3], "r", stdin) != stdin) + { + fprintf (stderr, z_reopen, errno, strerror( errno ), argv[3], "in"); + return EXIT_FAILURE; + } + + pz_tmptmp = XNEWVEC (char, strlen (argv[4]) + 5); + strcpy( pz_tmptmp, argv[4] ); + + /* Don't lose because "12345678" and "12345678X" map to the same + file under DOS restricted 8+3 file namespace. Note that DOS + doesn't allow more than one dot in the trunk of a file name. */ + pz_tmp_base = basename( pz_tmptmp ); + pz_tmp_dot = strchr( pz_tmp_base, '.' ); +#ifdef _PC_NAME_MAX + if (pathconf( pz_tmptmp, _PC_NAME_MAX ) <= 12 /* is this DOS or Windows9X? */ + && pz_tmp_dot != (char*)NULL) + strcpy (pz_tmp_dot+1, "X"); /* nuke the original extension */ + else +#endif /* _PC_NAME_MAX */ + strcat (pz_tmptmp, ".X"); + if (freopen (pz_tmptmp, "w", stdout) != stdout) + { + fprintf (stderr, z_reopen, errno, strerror( errno ), pz_tmptmp, "out"); + return EXIT_FAILURE; + } + + apply_fix (pFix, argv[1]); + fclose (stdout); + fclose (stdin); + unlink (argv[4]); + if (rename (pz_tmptmp, argv[4]) != 0) + { + fprintf (stderr, "error %d (%s) renaming %s to %s\n", errno, + strerror( errno ), pz_tmptmp, argv[4]); + return EXIT_FAILURE; + } + + return EXIT_SUCCESS; +} +#endif |