Back to index

cell-binutils  2.17cvs20070401
Defines | Enumerations | Functions | Variables
ar.c File Reference
#include "bfd.h"
#include "libiberty.h"
#include "progress.h"
#include "bucomm.h"
#include "aout/ar.h"
#include "libbfd.h"
#include "arsup.h"
#include "filenames.h"
#include "binemul.h"
#include <sys/stat.h>

Go to the source code of this file.

Defines

#define EXT_NAME_LEN   6 /* ditto for *NIX */
#define O_BINARY   0

Enumerations

enum  pos { pos_default, pos_before, pos_after, pos_end }

Functions

struct ar_hdrbfd_special_undocumented_glue (bfd *abfd, const char *filename)
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)
static bfd ** get_pos_bfd (bfd **, enum pos, const char *)
int main (int, char **)
bfdopen_inarch (const char *archive_filename, const char *file)
void extract_file (bfd *abfd)

Variables

static int mri_mode
 Globals and flags.
int is_ranlib
int silent_create = 0
int verbose = 0
int preserve_dates = 0
int newer_only = 0
int write_armap = 0
char * posname = NULL
enum pos postype
static bfd_boolean counted_name_mode = 0
static int counted_name_counter = 0
static bfd_boolean ar_truncate = FALSE
static bfd_boolean full_pathname = FALSE
int interactive = 0
bfd_boolean operation_alters_arch = FALSE
static const char * output_filename = NULL
static FILE * output_file = NULL
static bfdoutput_bfd = NULL

Define Documentation

#define EXT_NAME_LEN   6 /* ditto for *NIX */

Definition at line 43 of file ar.c.

#define O_BINARY   0

Definition at line 49 of file ar.c.


Enumeration Type Documentation

enum pos
Enumerator:
pos_default 
pos_before 
pos_after 
pos_end 

Definition at line 114 of file ar.c.


Function Documentation

struct ar_hdr* bfd_special_undocumented_glue ( bfd abfd,
const char *  filename 
) [read]

Definition at line 1429 of file archive.c.

{
  struct areltdata *ar_elt = bfd_ar_hdr_from_filesystem (abfd, filename, 0);
  if (ar_elt == NULL)
    return NULL;
  return (struct ar_hdr *) ar_elt->arch_header;
}

Here is the call graph for this function:

static void delete_members ( bfd arch,
char **  files_to_delete 
) [static]

Definition at line 1013 of file ar.c.

{
  bfd **current_ptr_ptr;
  bfd_boolean found;
  bfd_boolean something_changed = FALSE;
  int match_count;

  for (; *files_to_delete != NULL; ++files_to_delete)
    {
      /* In a.out systems, the armap is optional.  It's also called
        __.SYMDEF.  So if the user asked to delete it, we should remember
        that fact. This isn't quite right for COFF systems (where
        __.SYMDEF might be regular member), but it's very unlikely
        to be a problem.  FIXME */

      if (!strcmp (*files_to_delete, "__.SYMDEF"))
       {
         arch->has_armap = FALSE;
         write_armap = -1;
         continue;
       }

      found = FALSE;
      match_count = 0;
      current_ptr_ptr = &(arch->next);
      while (*current_ptr_ptr)
       {
         if (FILENAME_CMP (normalize (*files_to_delete, arch),
                         (*current_ptr_ptr)->filename) == 0)
           {
             ++match_count;
             if (counted_name_mode
                && match_count != counted_name_counter)
              {
                /* Counting, and didn't match on count; go on to the
                     next one.  */
              }
             else
              {
                found = TRUE;
                something_changed = TRUE;
                if (verbose)
                  printf ("d - %s\n",
                         *files_to_delete);
                *current_ptr_ptr = ((*current_ptr_ptr)->next);
                goto next_file;
              }
           }

         current_ptr_ptr = &((*current_ptr_ptr)->next);
       }

      if (verbose && !found)
       {
         /* xgettext:c-format */
         printf (_("No member named `%s'\n"), *files_to_delete);
       }
    next_file:
      ;
    }

  if (something_changed)
    write_archive (arch);
  else
    output_filename = NULL;
}

Here is the call graph for this function:

void extract_file ( bfd abfd)

Definition at line 830 of file ar.c.

{
  FILE *ostream;
  char *cbuf = xmalloc (BUFSIZE);
  size_t nread, tocopy;
  size_t ncopied = 0;
  size_t size;
  struct stat buf;

  if (bfd_stat_arch_elt (abfd, &buf) != 0)
    /* xgettext:c-format */
    fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
  size = buf.st_size;

  if (verbose)
    printf ("x - %s\n", bfd_get_filename (abfd));

  bfd_seek (abfd, (file_ptr) 0, SEEK_SET);

  ostream = NULL;
  if (size == 0)
    {
      /* Seems like an abstraction violation, eh?  Well it's OK! */
      output_filename = bfd_get_filename (abfd);

      ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
      if (ostream == NULL)
       {
         perror (bfd_get_filename (abfd));
         xexit (1);
       }

      output_file = ostream;
    }
  else
    while (ncopied < size)
      {
       tocopy = size - ncopied;
       if (tocopy > BUFSIZE)
         tocopy = BUFSIZE;

       nread = bfd_bread (cbuf, (bfd_size_type) tocopy, abfd);
       if (nread != tocopy)
         /* xgettext:c-format */
         fatal (_("%s is not a valid archive"),
               bfd_get_filename (bfd_my_archive (abfd)));

       /* See comment above; this saves disk arm motion */
       if (ostream == NULL)
         {
           /* Seems like an abstraction violation, eh?  Well it's OK! */
           output_filename = bfd_get_filename (abfd);

           ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
           if (ostream == NULL)
             {
              perror (bfd_get_filename (abfd));
              xexit (1);
             }

           output_file = ostream;
         }

       /* fwrite in mingw32 may return int instead of size_t. Cast
          the return value to size_t to avoid comparison between
          signed and unsigned values.  */
       if ((size_t) fwrite (cbuf, 1, nread, ostream) != nread)
         fatal ("%s: %s", output_filename, strerror (errno));
       ncopied += tocopy;
      }

  if (ostream != NULL)
    fclose (ostream);

  output_file = NULL;
  output_filename = NULL;

  chmod (bfd_get_filename (abfd), buf.st_mode);

  if (preserve_dates)
    {
      /* Set access time to modification time.  Only st_mtime is
        initialized by bfd_stat_arch_elt.  */
      buf.st_atime = buf.st_mtime;
      set_times (bfd_get_filename (abfd), &buf);
    }

  free (cbuf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd ** get_pos_bfd ( bfd **  contents,
enum pos  default_pos,
const char *  default_posname 
) [static]

Definition at line 977 of file ar.c.

{
  bfd **after_bfd = contents;
  enum pos realpos;
  const char *realposname;

  if (postype == pos_default)
    {
      realpos = default_pos;
      realposname = default_posname;
    }
  else
    {
      realpos = postype;
      realposname = posname;
    }

  if (realpos == pos_end)
    {
      while (*after_bfd)
       after_bfd = &((*after_bfd)->next);
    }
  else
    {
      for (; *after_bfd; after_bfd = &(*after_bfd)->next)
       if (FILENAME_CMP ((*after_bfd)->filename, realposname) == 0)
         {
           if (realpos == pos_after)
             after_bfd = &(*after_bfd)->next;
           break;
         }
    }
  return after_bfd;
}

Here is the caller graph for this function:

int main ( int  argc,
char **  argv 
)
static void map_over_members ( bfd arch,
void(*)(bfd *)  function,
char **  files,
int  count 
) [static]

Definition at line 149 of file ar.c.

{
  bfd *head;
  int match_count;

  if (count == 0)
    {
      for (head = arch->next; head; head = head->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->next; head; head = head->next)
       {
         PROGRESS (1);
         if (head->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);
           }
         if ((head->filename != NULL) &&
             (!FILENAME_CMP (normalize (*files, arch), head->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);
    }
}

Here is the call graph for this function:

static void move_members ( bfd arch,
char **  files_to_move 
) [static]

Definition at line 1084 of file ar.c.

{
  bfd **after_bfd;          /* New entries go after this one */
  bfd **current_ptr_ptr;    /* cdr pointer into contents */

  for (; *files_to_move; ++files_to_move)
    {
      current_ptr_ptr = &(arch->next);
      while (*current_ptr_ptr)
       {
         bfd *current_ptr = *current_ptr_ptr;
         if (FILENAME_CMP (normalize (*files_to_move, arch),
                         current_ptr->filename) == 0)
           {
             /* Move this file to the end of the list - first cut from
               where it is.  */
             bfd *link;
             *current_ptr_ptr = current_ptr->next;

             /* Now glue to end */
             after_bfd = get_pos_bfd (&arch->next, pos_end, NULL);
             link = *after_bfd;
             *after_bfd = current_ptr;
             current_ptr->next = link;

             if (verbose)
              printf ("m - %s\n", *files_to_move);

             goto next_file;
           }

         current_ptr_ptr = &((*current_ptr_ptr)->next);
       }
      /* xgettext:c-format */
      fatal (_("no entry %s in archive %s!"), *files_to_move, arch->filename);

    next_file:;
    }

  write_archive (arch);
}

Here is the call graph for this function:

static void mri_emul ( void  ) [static]

Definition at line 138 of file ar.c.

{
  interactive = isatty (fileno (stdin));
  yyparse ();
}
static const char * normalize ( const char *  file,
bfd abfd 
) [static]

Definition at line 272 of file ar.c.

{
  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 = (char *) 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bfd* open_inarch ( const char *  archive_filename,
const char *  file 
)

Definition at line 679 of file ar.c.

{
  const char *target;
  bfd **last_one;
  bfd *next_one;
  struct stat sbuf;
  bfd *arch;
  char **matching;

  bfd_set_error (bfd_error_no_error);

  target = NULL;

  if (stat (archive_filename, &sbuf) != 0)
    {
#if !defined(__GO32__) || defined(__DJGPP__)

      /* FIXME: I don't understand why this fragment was ifndef'ed
        away for __GO32__; perhaps it was in the days of DJGPP v1.x.
        stat() works just fine in v2.x, so I think this should be
        removed.  For now, I enable it for DJGPP v2. -- EZ.  */

/* KLUDGE ALERT! Temporary fix until I figger why
   stat() is wrong ... think it's buried in GO32's IDT - Jax */
      if (errno != ENOENT)
       bfd_fatal (archive_filename);
#endif

      if (!operation_alters_arch)
       {
         fprintf (stderr, "%s: ", program_name);
         perror (archive_filename);
         maybequit ();
         return NULL;
       }

      /* Try to figure out the target to use for the archive from the
         first object on the list.  */
      if (file != NULL)
       {
         bfd *obj;

         obj = bfd_openr (file, NULL);
         if (obj != NULL)
           {
             if (bfd_check_format (obj, bfd_object))
              target = bfd_get_target (obj);
             (void) bfd_close (obj);
           }
       }

      /* Create an empty archive.  */
      arch = bfd_openw (archive_filename, target);
      if (arch == NULL
         || ! bfd_set_format (arch, bfd_archive)
         || ! bfd_close (arch))
       bfd_fatal (archive_filename);
      else if (!silent_create)
        non_fatal (_("creating %s"), archive_filename);

      /* If we die creating a new archive, don't leave it around.  */
      output_filename = archive_filename;
    }

  arch = bfd_openr (archive_filename, target);
  if (arch == NULL)
    {
    bloser:
      bfd_fatal (archive_filename);
    }

  if (! bfd_check_format_matches (arch, bfd_archive, &matching))
    {
      bfd_nonfatal (archive_filename);
      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
       {
         list_matching_formats (matching);
         free (matching);
       }
      xexit (1);
    }

  last_one = &(arch->next);
  /* Read all the contents right away, regardless.  */
  for (next_one = bfd_openr_next_archived_file (arch, NULL);
       next_one;
       next_one = bfd_openr_next_archived_file (arch, next_one))
    {
      PROGRESS (1);
      *last_one = next_one;
      last_one = &next_one->next;
    }
  *last_one = (bfd *) NULL;
  if (bfd_get_error () != bfd_error_no_more_archived_files)
    goto bloser;
  return arch;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void print_contents ( bfd member) [static]

Definition at line 778 of file ar.c.

{
  size_t ncopied = 0;
  char *cbuf = xmalloc (BUFSIZE);
  struct stat buf;
  size_t size;
  if (bfd_stat_arch_elt (abfd, &buf) != 0)
    /* xgettext:c-format */
    fatal (_("internal stat error on %s"), bfd_get_filename (abfd));

  if (verbose)
    /* xgettext:c-format */
    printf (_("\n<%s>\n\n"), bfd_get_filename (abfd));

  bfd_seek (abfd, (file_ptr) 0, SEEK_SET);

  size = buf.st_size;
  while (ncopied < size)
    {

      size_t nread;
      size_t tocopy = size - ncopied;
      if (tocopy > BUFSIZE)
       tocopy = BUFSIZE;

      nread = bfd_bread (cbuf, (bfd_size_type) tocopy, abfd);
      if (nread != tocopy)
       /* xgettext:c-format */
       fatal (_("%s is not a valid archive"),
              bfd_get_filename (bfd_my_archive (abfd)));

      /* fwrite in mingw32 may return int instead of size_t. Cast the
        return value to size_t to avoid comparison between signed and
        unsigned values.  */
      if ((size_t) fwrite (cbuf, 1, nread, stdout) != nread)
       fatal ("stdout: %s", strerror (errno));
      ncopied += tocopy;
    }
  free (cbuf);
}

Here is the call graph for this function:

static void print_descr ( bfd abfd) [static]

Definition at line 1269 of file ar.c.

{
  print_arelt_descr (stdout, abfd, verbose);
}

Here is the call graph for this function:

static int ranlib_only ( const char *  archname) [static]

Definition at line 1204 of file ar.c.

{
  bfd *arch;

  if (get_file_size (archname) < 1)
    return 1;
  write_armap = 1;
  arch = open_inarch (archname, (char *) NULL);
  if (arch == NULL)
    xexit (1);
  write_archive (arch);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int ranlib_touch ( const char *  archname) [static]

Definition at line 1221 of file ar.c.

{
#ifdef __GO32__
  /* I don't think updating works on go32.  */
  ranlib_only (archname);
#else
  int f;
  bfd *arch;
  char **matching;

  if (get_file_size (archname) < 1)
    return 1;
  f = open (archname, O_RDWR | O_BINARY, 0);
  if (f < 0)
    {
      bfd_set_error (bfd_error_system_call);
      bfd_fatal (archname);
    }

  arch = bfd_fdopenr (archname, (const char *) NULL, f);
  if (arch == NULL)
    bfd_fatal (archname);
  if (! bfd_check_format_matches (arch, bfd_archive, &matching))
    {
      bfd_nonfatal (archname);
      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
       {
         list_matching_formats (matching);
         free (matching);
       }
      xexit (1);
    }

  if (! bfd_has_map (arch))
    /* xgettext:c-format */
    fatal (_("%s: no archive map to update"), archname);

  bfd_update_armap_timestamp (arch);

  if (! bfd_close (arch))
    bfd_fatal (archname);
#endif
  return 0;
}

Here is the call graph for this function:

static void remove_output ( void  ) [static]

Definition at line 318 of file ar.c.

Here is the call graph for this function:

static void replace_members ( bfd arch,
char **  files_to_replace,
bfd_boolean  quick 
) [static]

Definition at line 1129 of file ar.c.

{
  bfd_boolean changed = FALSE;
  bfd **after_bfd;          /* New entries go after this one.  */
  bfd *current;
  bfd **current_ptr;

  while (files_to_move && *files_to_move)
    {
      if (! quick)
       {
         current_ptr = &arch->next;
         while (*current_ptr)
           {
             current = *current_ptr;

             /* For compatibility with existing ar programs, we
               permit the same file to be added multiple times.  */
             if (FILENAME_CMP (normalize (*files_to_move, arch),
                            normalize (current->filename, arch)) == 0
                && current->arelt_data != NULL)
              {
                if (newer_only)
                  {
                    struct stat fsbuf, asbuf;

                    if (stat (*files_to_move, &fsbuf) != 0)
                     {
                       if (errno != ENOENT)
                         bfd_fatal (*files_to_move);
                       goto next_file;
                     }
                    if (bfd_stat_arch_elt (current, &asbuf) != 0)
                     /* xgettext:c-format */
                     fatal (_("internal stat error on %s"),
                            current->filename);

                    if (fsbuf.st_mtime <= asbuf.st_mtime)
                     goto next_file;
                  }

                after_bfd = get_pos_bfd (&arch->next, pos_after,
                                      current->filename);
                if (ar_emul_replace (after_bfd, *files_to_move,
                                   verbose))
                  {
                    /* Snip out this entry from the chain.  */
                    *current_ptr = (*current_ptr)->next;
                    changed = TRUE;
                  }

                goto next_file;
              }
             current_ptr = &(current->next);
           }
       }

      /* Add to the end of the archive.  */
      after_bfd = get_pos_bfd (&arch->next, pos_end, NULL);

      if (ar_emul_append (after_bfd, *files_to_move, verbose))
       changed = TRUE;

    next_file:;

      files_to_move++;
    }

  if (changed)
    write_archive (arch);
  else
    output_filename = NULL;
}

Here is the call graph for this function:

static void usage ( int  help) [static]

Definition at line 210 of file ar.c.

{
  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, _("  [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\
  -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);
}

Here is the call graph for this function:

static void write_archive ( bfd iarch) [static]

Definition at line 921 of file ar.c.

{
  bfd *obfd;
  char *old_name, *new_name;
  bfd *contents_head = iarch->next;

  old_name = xmalloc (strlen (bfd_get_filename (iarch)) + 1);
  strcpy (old_name, bfd_get_filename (iarch));
  new_name = make_tempname (old_name);

  if (new_name == NULL)
    bfd_fatal ("could not create temporary file whilst writing archive");
  
  output_filename = new_name;

  obfd = bfd_openw (new_name, bfd_get_target (iarch));

  if (obfd == NULL)
    bfd_fatal (old_name);

  output_bfd = obfd;

  bfd_set_format (obfd, bfd_archive);

  /* Request writing the archive symbol table unless we've
     been explicitly requested not to.  */
  obfd->has_armap = write_armap >= 0;

  if (ar_truncate)
    {
      /* This should really use bfd_set_file_flags, but that rejects
         archives.  */
      obfd->flags |= BFD_TRADITIONAL_FORMAT;
    }

  if (!bfd_set_archive_head (obfd, contents_head))
    bfd_fatal (old_name);

  if (!bfd_close (obfd))
    bfd_fatal (old_name);

  output_bfd = NULL;
  output_filename = NULL;

  /* We don't care if this fails; we might be creating the archive.  */
  bfd_close (iarch);

  if (smart_rename (new_name, old_name, 0) != 0)
    xexit (1);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 128 of file ar.c.

int counted_name_counter = 0 [static]

Definition at line 125 of file ar.c.

Definition at line 124 of file ar.c.

Definition at line 133 of file ar.c.

Definition at line 135 of file ar.c.

Definition at line 3 of file is-ranlib.c.

int mri_mode [static]

Globals and flags.

Definition at line 77 of file ar.c.

Definition at line 95 of file ar.c.

Definition at line 207 of file ar.c.

bfd* output_bfd = NULL [static]

Definition at line 315 of file ar.c.

FILE* output_file = NULL [static]

Definition at line 314 of file ar.c.

const char* output_filename = NULL [static]

Definition at line 313 of file ar.c.

char* posname = NULL

Definition at line 108 of file ar.c.

enum pos postype

Definition at line 91 of file ar.c.

Definition at line 85 of file ar.c.

int verbose = 0

Definition at line 88 of file ar.c.

Definition at line 104 of file ar.c.