Subversion Repositories openrisc

/*

   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);

}