Subversion Repositories openrisc_me

/* 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) 1997, 1998, 1999, 2000, 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"

#include <fnmatch.h>

#include <sys/stat.h>

#ifndef SEPARATE_FIX_PROC

#include <sys/wait.h>

#endif

#if defined( HAVE_MMAP_FILE )

#include <sys/mman.h>

#define  BAD_ADDR ((void*)-1)

#endif

#ifndef SEPARATE_FIX_PROC

#include "server.h"

#endif

/*  The contents of this string are not very important.  It is mostly

    just used as part of the "I am alive and working" test.  */

static const char program_id[] = "fixincl version 1.1";

/*  This format will be used at the start of every generated file */

static const char z_std_preamble[] =

"/*  DO NOT EDIT THIS FILE.\n\n\

    It has been auto-edited by fixincludes from:\n\n\

\t\"%s/%s\"\n\n\

    This had to be done to correct non-standard usages in the\n\

    original, manufacturer supplied header file.  */\n\n";

int find_base_len = 0;

typedef enum {

  VERB_SILENT = 0,

  VERB_FIXES,

  VERB_APPLIES,

  VERB_PROGRESS,

  VERB_TESTS,

  VERB_EVERYTHING

} te_verbose;

te_verbose  verbose_level = VERB_PROGRESS;

int have_tty = 0;

#define VLEVEL(l)  ((unsigned int) verbose_level >= (unsigned int) l)

#define NOT_SILENT VLEVEL(VERB_FIXES)

pid_t process_chain_head = (pid_t) -1;

char*  pz_curr_file;  /*  name of the current file under test/fix  */

char*  pz_curr_data;  /*  original contents of that file  */

char*  pz_temp_file;  /*  for DOS, a place to stash the temporary

                          fixed data between system(3) calls  */

t_bool curr_data_mapped;

int    data_map_fd;

size_t data_map_size;

size_t ttl_data_size = 0;

#ifdef DO_STATS

int process_ct = 0;

int apply_ct = 0;

int fixed_ct = 0;

int altered_ct = 0;

#endif /* DO_STATS */

const char incl_quote_pat[] = "^[ \t]*#[ \t]*include[ \t]*\"[^/]";

tSCC z_fork_err[] = "Error %d (%s) starting filter process for %s\n";

regex_t incl_quote_re;

static void do_version (void) ATTRIBUTE_NORETURN;

char *load_file (const char *);

void run_compiles (void);

void initialize (int argc, char** argv);

void process (void);

/*  External Source Code */

#include "fixincl.x"

/* * * * * * * * * * * * * * * * * * *

 *

 *  MAIN ROUTINE

 */

extern int main (int, char **);

int

main (int argc, char** argv)

{

  char *file_name_buf;

  initialize ( argc, argv );

  have_tty = isatty (fileno (stderr));

  /* Before anything else, ensure we can allocate our file name buffer. */

  file_name_buf = load_file_data (stdin);

  /*  Because of the way server shells work, you have to keep stdin, out

      and err open so that the proper input file does not get closed

      by accident  */

  freopen ("/dev/null", "r", stdin);

  if (file_name_buf == (char *) NULL)

    {

      fputs ("No file names listed for fixing\n", stderr);

      exit (EXIT_FAILURE);

    }

  for (;;)

    {

      char* pz_end;

      /*  skip to start of name, past any "./" prefixes */

      while (ISSPACE (*file_name_buf))  file_name_buf++;

      while ((file_name_buf[0] == '.') && (file_name_buf[1] == '/'))

        file_name_buf += 2;

      /*  Check for end of list  */

      if (*file_name_buf == NUL)

        break;

      /*  Set global file name pointer and find end of name */

      pz_curr_file = file_name_buf;

      pz_end = strchr( pz_curr_file, '\n' );

      if (pz_end == (char*)NULL)

        pz_end = file_name_buf = pz_curr_file + strlen (pz_curr_file);

      else

        file_name_buf = pz_end + 1;

      while ((pz_end > pz_curr_file) && ISSPACE( pz_end[-1]))  pz_end--;

      /*  IF no name is found (blank line) or comment marker, skip line  */

      if ((pz_curr_file == pz_end) || (*pz_curr_file == '#'))

        continue;

      *pz_end = NUL;

      process ();

    } /*  for (;;) */

#ifdef DO_STATS

  if (VLEVEL( VERB_PROGRESS )) {

    tSCC zFmt[] =

      "\

Processed %5d files containing %d bytes    \n\

Applying  %5d fixes to %d files\n\

Altering  %5d of them\n";

    fprintf (stderr, zFmt, process_ct, ttl_data_size, apply_ct,

             fixed_ct, altered_ct);

  }

#endif /* DO_STATS */

# ifdef SEPARATE_FIX_PROC

  unlink( pz_temp_file );

# endif

  exit (EXIT_SUCCESS);

}

static void

do_version (void)

{

  static const char zFmt[] = "echo '%s'";

  char zBuf[ 1024 ];

  /* The 'version' option is really used to test that:

     1.  The program loads correctly (no missing libraries)

     2.  that we can compile all the regular expressions.

     3.  we can correctly run our server shell process

  */

  run_compiles ();

  sprintf (zBuf, zFmt, program_id);

#ifndef SEPARATE_FIX_PROC

  puts (zBuf + 5);

  exit (strcmp (run_shell (zBuf), program_id));

#else

  exit (system (zBuf));

#endif

}

/* * * * * * * * * * * * */

void

initialize ( int argc, char** argv )

{

  xmalloc_set_program_name (argv[0]);

  switch (argc)

    {

    case 1:

      break;

    case 2:

      if (strcmp (argv[1], "-v") == 0)

        do_version ();

      if (freopen (argv[1], "r", stdin) == (FILE*)NULL)

        {

          fprintf (stderr, "Error %d (%s) reopening %s as stdin\n",

                   errno, xstrerror (errno), argv[1] );

          exit (EXIT_FAILURE);

        }

      break;

    default:

      fputs ("fixincl ERROR:  too many command line arguments\n", stderr);

      exit (EXIT_FAILURE);

    }

#ifdef SIGCHLD

  /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will

     receive the signal.  A different setting is inheritable */

  signal (SIGCHLD, SIG_DFL);

#endif

  initialize_opts ();

  if (ISDIGIT ( *pz_verbose ))

    verbose_level = (te_verbose)atoi( pz_verbose );

  else

    switch (*pz_verbose) {

    case 's':

    case 'S':

      verbose_level = VERB_SILENT;     break;

    case 'f':

    case 'F':

      verbose_level = VERB_FIXES;      break;

    case 'a':

    case 'A':

      verbose_level = VERB_APPLIES;    break;

    default:

    case 'p':

    case 'P':

      verbose_level = VERB_PROGRESS;   break;

    case 't':

    case 'T':

      verbose_level = VERB_TESTS;      break;

    case 'e':

    case 'E':

      verbose_level = VERB_EVERYTHING; break;

    }

  if (verbose_level >= VERB_EVERYTHING) {

    verbose_level = VERB_EVERYTHING;

    fputs ("fixinc verbosity:  EVERYTHING\n", stderr);

  }

  while ((pz_find_base[0] == '.') && (pz_find_base[1] == '/'))

    pz_find_base += 2;

  if ((pz_find_base[0] != '.') || (pz_find_base[1] != NUL))

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

# ifdef SEPARATE_FIX_PROC

  /* NULL as the first argument to `tempnam' causes it to DTRT

     wrt the temporary directory where the file will be created.  */

  pz_temp_file = tempnam( NULL, "fxinc" );

# endif

  signal (SIGQUIT, SIG_IGN);

  signal (SIGIOT,  SIG_IGN);

  signal (SIGPIPE, SIG_IGN);

  signal (SIGALRM, SIG_IGN);

  signal (SIGTERM, SIG_IGN);

}

/* * * * * * * * * * * * *

   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 ( const char* fname )

{

  struct stat stbf;

  char* res;

  if (stat (fname, &stbf) != 0)

    {

      if (NOT_SILENT)

        fprintf (stderr, "error %d (%s) stat-ing %s\n",

                 errno, xstrerror (errno), fname );

      return (char *) NULL;

    }

  if (stbf.st_size == 0)

    return (char*)NULL;

  /*  Make the data map size one larger than the file size for documentation

      purposes.  Truth is that there will be a following NUL character if

      the file size is not a multiple of the page size.  If it is a multiple,

      then this adjustment sometimes fails anyway.  */

  data_map_size = stbf.st_size+1;

  data_map_fd   = open (fname, O_RDONLY);

  ttl_data_size += data_map_size-1;

  if (data_map_fd < 0)

    {

      if (NOT_SILENT)

        fprintf (stderr, "error %d (%s) opening %s for read\n",

                 errno, xstrerror (errno), fname);

      return (char*)NULL;

    }

#ifdef HAVE_MMAP_FILE

  curr_data_mapped = BOOL_TRUE;

  /*  IF the file size is a multiple of the page size,

      THEN sometimes you will seg fault trying to access a trailing byte */

  if ((stbf.st_size & (getpagesize()-1)) == 0)

    res = (char*)BAD_ADDR;

  else

    res = (char*)mmap ((void*)NULL, data_map_size, PROT_READ,

                       MAP_PRIVATE, data_map_fd, 0);

  if (res == (char*)BAD_ADDR)

#endif

    {

      FILE* fp = fdopen (data_map_fd, "r");

      curr_data_mapped = BOOL_FALSE;

      res = load_file_data (fp);

      fclose (fp);

    }

  return res;

}

static int

machine_matches( tFixDesc* p_fixd )

{

  char const ** papz_machs = p_fixd->papz_machs;

  int have_match = BOOL_FALSE;

  for (;;)

    {

      char const * pz_mpat = *(papz_machs++);

      if (pz_mpat == NULL)

        break;

      if (fnmatch(pz_mpat, pz_machine, 0) == 0)

        {

          have_match = BOOL_TRUE;

          break;

        }

    }

  /* Check for sense inversion then set the "skip test" flag, if needed */

  if (p_fixd->fd_flags & FD_MACH_IFNOT)

    have_match = ! have_match;

  if (! have_match)

    p_fixd->fd_flags |= FD_SKIP_TEST;

  return have_match;

}

/* * * * * * * * * * * * *

 *

 *  run_compiles   run all the regexp compiles for all the fixes once.

 */

void

run_compiles (void)

{

  tFixDesc *p_fixd = fixDescList;

  int fix_ct = FIX_COUNT;

  regex_t *p_re = XCNEWVEC (regex_t, REGEX_COUNT);

  /*  Make sure compile_re does not stumble across invalid data */

  memset (&incl_quote_re, '\0', sizeof (regex_t));

  compile_re (incl_quote_pat, &incl_quote_re, 1,

              "quoted include", "run_compiles");

  /*  Allow machine name tests to be ignored (testing, mainly) */

  if (pz_machine && ((*pz_machine == '\0') || (*pz_machine == '*')))

    pz_machine = (char*)NULL;

  /* FOR every fixup, ...  */

  do

    {

      tTestDesc *p_test = p_fixd->p_test_desc;

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

         && ! machine_matches (p_fixd) )

        continue;

      /* FOR every test for the fixup, ...  */

      while (--test_ct >= 0)

        {

          switch (p_test->type)

            {

            case TT_EGREP:

            case TT_NEGREP:

              p_test->p_test_regex = p_re++;

              compile_re (p_test->pz_test_text, p_test->p_test_regex, 0,

                          "select test", p_fixd->fix_name);

            default: break;

            }

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

#if defined(S_IRUSR) && defined(S_IWUSR) && \

    defined(S_IRGRP) && defined(S_IROTH)

#   define S_IRALL (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

#else

#   define S_IRALL 0644

#endif

#if defined(S_IRWXU) && defined(S_IRGRP) && defined(S_IXGRP) && \

    defined(S_IROTH) && defined(S_IXOTH)

#   define S_DIRALL (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)

#else

#   define S_DIRALL 0755

#endif

static FILE *

create_file (void)

{

  int fd;

  FILE *pf;

  char fname[MAXPATHLEN];

  sprintf (fname, "%s/%s", pz_dest_dir, pz_curr_file + 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)

            {

#ifdef _WIN32

              mkdir (fname);

#else

              mkdir (fname, S_IFDIR | S_DIRALL);

#endif

            }

          *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, xstrerror (errno), fname);

      exit (EXIT_FAILURE);

    }

  if (NOT_SILENT)

    fprintf (stderr, "Fixed:  %s\n", pz_curr_file);

  pf = fdopen (fd, "w");

  /*

   *  IF pz_machine is NULL, then we are in some sort of test mode.

   *  Do not insert the current directory name.  Use a constant string.

   */

  fprintf (pf, z_std_preamble,

           (pz_machine == NULL)

           ? "fixinc/tests/inc"

           : pz_input_dir,

           pz_curr_file);

  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: APPLY_FIX or SKIP_FIX, depending on the result of the

          shell script we run.  */

#ifndef SEPARATE_FIX_PROC

static int

test_test (tTestDesc* p_test, char* pz_test_file)

{

  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;

  int res;

  static char cmd_buf[4096];

  sprintf (cmd_buf, cmd_fmt, pz_test_file, p_test->pz_test_text);

  pz_res = run_shell (cmd_buf);

  switch (*pz_res) {

  case 'T':

    res = APPLY_FIX;

    break;

  case 'F':

    res = SKIP_FIX;

    break;

  default:

    fprintf (stderr, "Script yielded bogus result of `%s':\n%s\n\n",

             pz_res, cmd_buf );

    res = SKIP_FIX;

  }

  free ((void *) pz_res);

  return res;

}

#else

/*

 *  IF we are in MS-DOS land, then whatever shell-type test is required

 *  will, by definition, fail

 */

#define test_test(t,tf)  SKIP_FIX

#endif

/* * * * * * * * * * * * *

  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: APPLY_FIX if the pattern is found, SKIP_FIX otherwise

  The caller may choose to reverse meaning if the sense of the test

  is inverted.  */

static int

egrep_test (char* pz_data, tTestDesc* p_test)

{

#ifdef DEBUG

  if (p_test->p_test_regex == 0)

    fprintf (stderr, "fixincl ERROR RE not compiled:  `%s'\n",

             p_test->pz_test_text);

#endif

  if (xregexec (p_test->p_test_regex, pz_data, 0, 0, 0) == 0)

    return APPLY_FIX;

  return SKIP_FIX;

}

/* * * * * * * * * * * * *

  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.  */

static int

quoted_file_exists (const char* pz_src_path,

                    const char* pz_file_path,

                    const 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  */

static void

extract_quoted_files (char* pz_data,

                      const char* pz_fixed_file,

                      regmatch_t* p_re_match)

{

  char *pz_dir_end = strrchr (pz_fixed_file, '/');

  char *pz_incl_quot = pz_data;

  if (VLEVEL( VERB_APPLIES ))

    fprintf (stderr, "Quoted includes in %s\n", pz_fixed_file);

  /*  Set "pz_fixed_file" 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_fixed_file = ".";

  else

    *pz_dir_end = '\0';

  for (;;)

    {

      pz_incl_quot += p_re_match->rm_so;

      /*  Skip forward to the included file name */

      while (*pz_incl_quot != '"')

        pz_incl_quot++;

      if (quoted_file_exists (pz_src_dir, pz_fixed_file, pz_incl_quot))

        {

          /* Print the source directory and the subdirectory

             of the file in question.  */

          printf ("%s  %s/", pz_src_dir, pz_fixed_file);

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

          while (*pz_dir_end != '"')

            putc (*pz_dir_end++, stdout);