Subversion Repositories openrisc

/* 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 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 2, 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 COPYING.  If not, write to

the Free Software Foundation, 51 Franklin Street, Fifth Floor,

Boston, MA 02110-1301, USA.  */

#include "fixlib.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 )

        {

# ifndef SEPARATE_FIX_PROC

          tSCC case_fmt[] = "case %s in\n";     /*  9 bytes, plus string */

          tSCC esac_fmt[] =

               " )\n    echo %s ;;\n* ) echo %s ;;\nesac";/*  4 bytes */

          tSCC skip[] = "skip";                 /*  4 bytes */

          tSCC run[] = "run";                   /*  3 bytes */

          /* total bytes to add to machine sum:    49 - see fixincl.tpl */

          const char **papz_machs = p_fixd->papz_machs;

          char *pz;

          const char *pz_sep = "";

          tCC *pz_if_true;

          tCC *pz_if_false;

          char cmd_buf[ MACH_LIST_SIZE_LIMIT ]; /* size lim from fixincl.tpl */

          /* Start the case statement */

          sprintf (cmd_buf, case_fmt, pz_machine);

          pz = cmd_buf + strlen (cmd_buf);

          /*  Determine if a match means to apply the fix or not apply it */

          if (p_fixd->fd_flags & FD_MACH_IFNOT)

            {

              pz_if_true  = skip;

              pz_if_false = run;

            }

          else

            {

              pz_if_true  = run;

              pz_if_false = skip;

            }

          /*  Emit all the machine names.  If there are more than one,

              then we will insert " | \\\n" between the names  */

          for (;;)

            {

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

              if (pz_mach == (const char*) NULL)

                break;

              sprintf (pz, "%s%s", pz_sep, pz_mach);

              pz += strlen (pz);

              pz_sep = " | \\\n";

            }

          /* Now emit the match and not-match actions and the esac */

          sprintf (pz, esac_fmt, pz_if_true, pz_if_false);

          /*  Run the script.

              The result will start either with 's' or 'r'.  */

          {

            int skip;

            pz = run_shell (cmd_buf);

            skip = (*pz == 's');

            free ( (void*)pz );

            if (skip)

              {

                p_fixd->fd_flags |= FD_SKIP_TEST;

                return BOOL_FALSE;

              }

          }

  return BOOL_TRUE;

# else /* is SEPARATE_FIX_PROC */

  const char **papz_machs = p_fixd->papz_machs;

  int invert = (p_fixd->fd_flags & FD_MACH_IFNOT) != 0;

  for (;;)

    {

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

      if (pz_mach == (const char*) NULL)

        break;

      if (strstr (pz_mach, "dos") != NULL && !invert)

        return BOOL_TRUE;

    }

  p_fixd->fd_flags |= FD_SKIP_TEST;

  return BOOL_FALSE;

# endif

}

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

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

  }

}