Subversion Repositories openrisc_me

/* ar.c - Archive modify and extract.

   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,

   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008

   Free Software Foundation, Inc.

   This file is part of GNU Binutils.

   This program 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 of the License, or

   (at your option) any later version.

   This program 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 this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

/*

   Bugs: should use getopt the way tar does (complete w/optional -) and

   should have long options too. GNU ar used to check file against filesystem

   in quick_update and replace operations (would check mtime). Doesn't warn

   when name truncated. No way to specify pos_end. Error messages should be

   more consistent.  */

#include "sysdep.h"

#include "bfd.h"

#include "libiberty.h"

#include "progress.h"

#include "aout/ar.h"

#include "libbfd.h"

#include "bucomm.h"

#include "arsup.h"

#include "filenames.h"

#include "binemul.h"

#include <sys/stat.h>

#ifdef __GO32___

#define EXT_NAME_LEN 3          /* Bufflen of addition to name if it's MS-DOS.  */

#else

#define EXT_NAME_LEN 6          /* Ditto for *NIX.  */

#endif

/* Kludge declaration from BFD!  This is ugly!  FIXME!  XXX  */

struct ar_hdr *

  bfd_special_undocumented_glue (bfd * abfd, const char *filename);

/* Static declarations.  */

static void mri_emul (void);

static const char *normalize (const char *, bfd *);

static void remove_output (void);

static void map_over_members (bfd *, void (*)(bfd *), char **, int);

static void print_contents (bfd * member);

static void delete_members (bfd *, char **files_to_delete);

static void move_members (bfd *, char **files_to_move);

static void replace_members

  (bfd *, char **files_to_replace, bfd_boolean quick);

static void print_descr (bfd * abfd);

static void write_archive (bfd *);

static int  ranlib_only (const char *archname);

static int  ranlib_touch (const char *archname);

static void usage (int);

/** Globals and flags.  */

static int mri_mode;

/* This flag distinguishes between ar and ranlib:

   1 means this is 'ranlib'; 0 means this is 'ar'.

   -1 means if we should use argv[0] to decide.  */

extern int is_ranlib;

/* Nonzero means don't warn about creating the archive file if necessary.  */

int silent_create = 0;

/* Nonzero means describe each action performed.  */

int verbose = 0;

/* Nonzero means preserve dates of members when extracting them.  */

int preserve_dates = 0;

/* Nonzero means don't replace existing members whose dates are more recent

   than the corresponding files.  */

int newer_only = 0;

/* Controls the writing of an archive symbol table (in BSD: a __.SYMDEF

   member).  -1 means we've been explicitly asked to not write a symbol table;

   +1 means we've been explicitly asked to write it;

   Traditionally, the default in BSD has been to not write the table.

   However, for POSIX.2 compliance the default is now to write a symbol table

   if any of the members are object files.  */

int write_armap = 0;

/* Nonzero means it's the name of an existing member; position new or moved

   files with respect to this one.  */

char *posname = NULL;

/* Sez how to use `posname': pos_before means position before that member.

   pos_after means position after that member. pos_end means always at end.

   pos_default means default appropriately. For the latter two, `posname'

   should also be zero.  */

enum pos

  {

    pos_default, pos_before, pos_after, pos_end

  } postype = pos_default;

static bfd **

get_pos_bfd (bfd **, enum pos, const char *);

/* For extract/delete only.  If COUNTED_NAME_MODE is TRUE, we only

   extract the COUNTED_NAME_COUNTER instance of that name.  */

static bfd_boolean counted_name_mode = 0;

static int counted_name_counter = 0;

/* Whether to truncate names of files stored in the archive.  */

static bfd_boolean ar_truncate = FALSE;

/* Whether to use a full file name match when searching an archive.

   This is convenient for archives created by the Microsoft lib

   program.  */

static bfd_boolean full_pathname = FALSE;

/* Whether to create a "thin" archive (symbol index only -- no files).  */

static bfd_boolean make_thin_archive = FALSE;

int interactive = 0;

static void

mri_emul (void)

{

  interactive = isatty (fileno (stdin));

  yyparse ();

}

/* If COUNT is 0, then FUNCTION is called once on each entry.  If nonzero,

   COUNT is the length of the FILES chain; FUNCTION is called on each entry

   whose name matches one in FILES.  */

static void

map_over_members (bfd *arch, void (*function)(bfd *), char **files, int count)

{

  bfd *head;

  int match_count;

  if (count == 0)

    {

      for (head = arch->archive_next; head; head = head->archive_next)

        {

          PROGRESS (1);

          function (head);

        }

      return;

    }

  /* This may appear to be a baroque way of accomplishing what we want.

     However we have to iterate over the filenames in order to notice where

     a filename is requested but does not exist in the archive.  Ditto

     mapping over each file each time -- we want to hack multiple

     references.  */

  for (; count > 0; files++, count--)

    {

      bfd_boolean found = FALSE;

      match_count = 0;

      for (head = arch->archive_next; head; head = head->archive_next)

        {

          const char * filename;

          PROGRESS (1);

          filename = head->filename;

          if (filename == NULL)

            {

              /* Some archive formats don't get the filenames filled in

                 until the elements are opened.  */

              struct stat buf;

              bfd_stat_arch_elt (head, &buf);

            }

          else if (bfd_is_thin_archive (arch))

            {

              /* Thin archives store full pathnames.  Need to normalize.  */

              filename = normalize (filename, arch);

            }

          if ((filename != NULL) &&

              (!FILENAME_CMP (normalize (*files, arch), filename)))

            {

              ++match_count;

              if (counted_name_mode

                  && match_count != counted_name_counter)

                {

                  /* Counting, and didn't match on count; go on to the

                     next one.  */

                  continue;

                }

              found = TRUE;

              function (head);

            }

        }

      if (!found)

        /* xgettext:c-format */

        fprintf (stderr, _("no entry %s in archive\n"), *files);

    }

}

bfd_boolean operation_alters_arch = FALSE;

static void

usage (int help)

{

  FILE *s;

  s = help ? stdout : stderr;

  if (! is_ranlib)

    {

      /* xgettext:c-format */

      fprintf (s, _("Usage: %s [emulation options] [-]{dmpqrstx}[abcfilNoPsSuvV] [member-name] [count] archive-file file...\n"),

               program_name);

      /* xgettext:c-format */

      fprintf (s, _("       %s -M [<mri-script]\n"), program_name);

      fprintf (s, _(" commands:\n"));

      fprintf (s, _("  d            - delete file(s) from the archive\n"));

      fprintf (s, _("  m[ab]        - move file(s) in the archive\n"));

      fprintf (s, _("  p            - print file(s) found in the archive\n"));

      fprintf (s, _("  q[f]         - quick append file(s) to the archive\n"));

      fprintf (s, _("  r[ab][f][u]  - replace existing or insert new file(s) into the archive\n"));

      fprintf (s, _("  t            - display contents of archive\n"));

      fprintf (s, _("  x[o]         - extract file(s) from the archive\n"));

      fprintf (s, _(" command specific modifiers:\n"));

      fprintf (s, _("  [a]          - put file(s) after [member-name]\n"));

      fprintf (s, _("  [b]          - put file(s) before [member-name] (same as [i])\n"));

      fprintf (s, _("  [N]          - use instance [count] of name\n"));

      fprintf (s, _("  [f]          - truncate inserted file names\n"));

      fprintf (s, _("  [P]          - use full path names when matching\n"));

      fprintf (s, _("  [o]          - preserve original dates\n"));

      fprintf (s, _("  [u]          - only replace files that are newer than current archive contents\n"));

      fprintf (s, _(" generic modifiers:\n"));

      fprintf (s, _("  [c]          - do not warn if the library had to be created\n"));

      fprintf (s, _("  [s]          - create an archive index (cf. ranlib)\n"));

      fprintf (s, _("  [S]          - do not build a symbol table\n"));

      fprintf (s, _("  [T]          - make a thin archive\n"));

      fprintf (s, _("  [v]          - be verbose\n"));

      fprintf (s, _("  [V]          - display the version number\n"));

      fprintf (s, _("  @<file>      - read options from <file>\n"));

      ar_emul_usage (s);

    }

  else

    {

      /* xgettext:c-format */

      fprintf (s, _("Usage: %s [options] archive\n"), program_name);

      fprintf (s, _(" Generate an index to speed access to archives\n"));

      fprintf (s, _(" The options are:\n\

  @<file>                      Read options from <file>\n\

  -t                           Update the archive's symbol map timestamp\n\

  -h --help                    Print this help message\n\

  -v --version                 Print version information\n"));

    }

  list_supported_targets (program_name, s);

  if (REPORT_BUGS_TO[0] && help)

    fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO);

  xexit (help ? 0 : 1);

}

/* Normalize a file name specified on the command line into a file

   name which we will use in an archive.  */

static const char *

normalize (const char *file, bfd *abfd)

{

  const char *filename;

  if (full_pathname)

    return file;

  filename = strrchr (file, '/');

#ifdef HAVE_DOS_BASED_FILE_SYSTEM

  {

    /* We could have foo/bar\\baz, or foo\\bar, or d:bar.  */

    char *bslash = strrchr (file, '\\');

    if (filename == NULL || (bslash != NULL && bslash > filename))

      filename = bslash;

    if (filename == NULL && file[0] != '\0' && file[1] == ':')

      filename = file + 1;

  }

#endif

  if (filename != (char *) NULL)

    filename++;

  else

    filename = file;

  if (ar_truncate

      && abfd != NULL

      && strlen (filename) > abfd->xvec->ar_max_namelen)

    {

      char *s;

      /* Space leak.  */

      s = xmalloc (abfd->xvec->ar_max_namelen + 1);

      memcpy (s, filename, abfd->xvec->ar_max_namelen);

      s[abfd->xvec->ar_max_namelen] = '\0';

      filename = s;

    }

  return filename;

}

/* Remove any output file.  This is only called via xatexit.  */

static const char *output_filename = NULL;

static FILE *output_file = NULL;

static bfd *output_bfd = NULL;

static void

remove_output (void)

{

  if (output_filename != NULL)

    {

      if (output_bfd != NULL)

        bfd_cache_close (output_bfd);

      if (output_file != NULL)

        fclose (output_file);

      unlink_if_ordinary (output_filename);

    }

}

/* The option parsing should be in its own function.

   It will be when I have getopt working.  */

int main (int, char **);

int

main (int argc, char **argv)

{

  char *arg_ptr;

  char c;

  enum

    {

      none = 0, delete, replace, print_table,

      print_files, extract, move, quick_append

    } operation = none;

  int arg_index;

  char **files;

  int file_count;

  char *inarch_filename;

  int show_version;

  int i;

  int do_posix = 0;

#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)

  setlocale (LC_MESSAGES, "");

#endif

#if defined (HAVE_SETLOCALE)

  setlocale (LC_CTYPE, "");

#endif

  bindtextdomain (PACKAGE, LOCALEDIR);

  textdomain (PACKAGE);

  program_name = argv[0];

  xmalloc_set_program_name (program_name);

  expandargv (&argc, &argv);

  if (is_ranlib < 0)

    {

      char *temp;

      temp = strrchr (program_name, '/');

#ifdef HAVE_DOS_BASED_FILE_SYSTEM

      {

        /* We could have foo/bar\\baz, or foo\\bar, or d:bar.  */

        char *bslash = strrchr (program_name, '\\');

        if (temp == NULL || (bslash != NULL && bslash > temp))

          temp = bslash;

        if (temp == NULL && program_name[0] != '\0' && program_name[1] == ':')

          temp = program_name + 1;

      }

#endif

      if (temp == NULL)

        temp = program_name;

      else

        ++temp;

      if (strlen (temp) >= 6

          && FILENAME_CMP (temp + strlen (temp) - 6, "ranlib") == 0)

        is_ranlib = 1;

      else

        is_ranlib = 0;

    }

  if (argc > 1 && argv[1][0] == '-')

    {

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

        usage (1);

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

        {

          if (is_ranlib)

            print_version ("ranlib");

          else

            print_version ("ar");

        }

    }

  START_PROGRESS (program_name, 0);

  bfd_init ();

  set_default_bfd_target ();

  show_version = 0;

  xatexit (remove_output);

  for (i = 1; i < argc; i++)

    if (! ar_emul_parse_arg (argv[i]))

      break;

  argv += (i - 1);

  argc -= (i - 1);

  if (is_ranlib)

    {

      int status = 0;

      bfd_boolean touch = FALSE;

      if (argc < 2

          || strcmp (argv[1], "--help") == 0

          || strcmp (argv[1], "-h") == 0

          || strcmp (argv[1], "-H") == 0)

        usage (0);

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

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

          || CONST_STRNEQ (argv[1], "--v"))

        print_version ("ranlib");

      arg_index = 1;

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

        {

          ++arg_index;

          touch = TRUE;

        }

      while (arg_index < argc)

        {

          if (! touch)

            status |= ranlib_only (argv[arg_index]);

          else

            status |= ranlib_touch (argv[arg_index]);

          ++arg_index;

        }

      xexit (status);

    }

  if (argc == 2 && strcmp (argv[1], "-M") == 0)

    {

      mri_emul ();

      xexit (0);

    }

  if (argc < 2)

    usage (0);

  arg_index = 1;

  arg_ptr = argv[arg_index];

  if (*arg_ptr == '-')

    {

      /* When the first option starts with '-' we support POSIX-compatible

         option parsing.  */

      do_posix = 1;

      ++arg_ptr;                        /* compatibility */

    }

  do

    {

      while ((c = *arg_ptr++) != '\0')

        {

          switch (c)

            {

            case 'd':

            case 'm':

            case 'p':

            case 'q':

            case 'r':

            case 't':

            case 'x':

              if (operation != none)

                fatal (_("two different operation options specified"));

              switch (c)

                {

                case 'd':

                  operation = delete;

                  operation_alters_arch = TRUE;

                  break;

                case 'm':

                  operation = move;

                  operation_alters_arch = TRUE;

                  break;

                case 'p':

                  operation = print_files;

                  break;

                case 'q':

                  operation = quick_append;

                  operation_alters_arch = TRUE;

                  break;

                case 'r':

                  operation = replace;

                  operation_alters_arch = TRUE;

                  break;

                case 't':

                  operation = print_table;

                  break;

                case 'x':

                  operation = extract;

                  break;

                }

            case 'l':

              break;

            case 'c':

              silent_create = 1;

              break;

            case 'o':

              preserve_dates = 1;

              break;

            case 'V':

              show_version = TRUE;

              break;

            case 's':

              write_armap = 1;

              break;

            case 'S':

              write_armap = -1;

              break;

            case 'u':

              newer_only = 1;

              break;

            case 'v':

              verbose = 1;

              break;

            case 'a':

              postype = pos_after;

              break;

            case 'b':

              postype = pos_before;

              break;

            case 'i':

              postype = pos_before;

              break;

            case 'M':

              mri_mode = 1;

              break;

            case 'N':

              counted_name_mode = TRUE;

              break;

            case 'f':

              ar_truncate = TRUE;

              break;

            case 'P':

              full_pathname = TRUE;

              break;

            case 'T':

              make_thin_archive = TRUE;

              break;

            default:

              /* xgettext:c-format */

              non_fatal (_("illegal option -- %c"), c);

              usage (0);

            }

        }

      /* With POSIX-compatible option parsing continue with the next

         argument if it starts with '-'.  */

      if (do_posix && arg_index + 1 < argc && argv[arg_index + 1][0] == '-')

        arg_ptr = argv[++arg_index] + 1;

      else

        do_posix = 0;

    }

  while (do_posix);

  if (show_version)

    print_version ("ar");

  ++arg_index;

  if (arg_index >= argc)

    usage (0);

  if (mri_mode)

    {

      mri_emul ();

    }

  else

    {

      bfd *arch;

      /* We don't use do_quick_append any more.  Too many systems

         expect ar to always rebuild the symbol table even when q is

         used.  */

      /* We can't write an armap when using ar q, so just do ar r

         instead.  */

      if (operation == quick_append && write_armap)

        operation = replace;

      if ((operation == none || operation == print_table)

          && write_armap == 1)

        xexit (ranlib_only (argv[arg_index]));

      if (operation == none)

        fatal (_("no operation specified"));

      if (newer_only && operation != replace)

        fatal (_("`u' is only meaningful with the `r' option."));

      if (postype != pos_default)

        posname = argv[arg_index++];

      if (counted_name_mode)

        {

          if (operation != extract && operation != delete)

             fatal (_("`N' is only meaningful with the `x' and `d' options."));

          counted_name_counter = atoi (argv[arg_index++]);

          if (counted_name_counter <= 0)

            fatal (_("Value for `N' must be positive."));

        }

      inarch_filename = argv[arg_index++];

      files = arg_index < argc ? argv + arg_index : NULL;

      file_count = argc - arg_index;

      arch = open_inarch (inarch_filename,

                          files == NULL ? (char *) NULL : files[0]);

      if (operation == extract && bfd_is_thin_archive (arch))

        fatal (_("`x' cannot be used on thin archives."));

      switch (operation)

        {

        case print_table:

          map_over_members (arch, print_descr, files, file_count);

          break;

        case print_files:

          map_over_members (arch, print_contents, files, file_count);

          break;

        case extract:

          map_over_members (arch, extract_file, files, file_count);

          break;

        case delete:

          if (files != NULL)

            delete_members (arch, files);

          else

            output_filename = NULL;

          break;