/* ar.c - Archive modify and extract.
- Copyright 1991, 1992 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 2 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
-
+ Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+ 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+ 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. */
+\f
/*
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 consistant.
-*/
-#include "bfd.h"
+ more consistent. */
+
#include "sysdep.h"
-#include "bucomm.h"
+#include "bfd.h"
+#include "libiberty.h"
+#include "progress.h"
#include "aout/ar.h"
-#include "../bfd/libbfd.h"
+#include "libbfd.h"
+#include "bucomm.h"
#include "arsup.h"
-#include <stdio.h>
-#ifdef POSIX_UTIME
-#include <utime.h>
-#else /* ! POSIX_UTIME */
-#ifdef USE_UTIME
-#include <time.h>
-#else /* ! USE_UTIME */
-#include <sys/time.h>
-#endif /* ! USE_UTIME */
-#endif /* ! POSIX_UTIME */
-#include <errno.h>
-#ifndef errno
-extern int errno;
-#endif
-#define BUFSIZE 8192
-
-/* Kludge declaration from BFD! This is ugly! FIXME! XXX */
-
-struct ar_hdr *
-bfd_special_undocumented_glue PARAMS ((bfd *abfd, char *filename));
-
-/* Forward declarations */
-
-static void
-print_contents PARAMS ((bfd * member));
-
-static void
-delete_members PARAMS ((char **files_to_delete));
-
-static void
-do_quick_append PARAMS ((char *archive_filename, char **files_to_append));
-
-static void
-move_members PARAMS ((char **files_to_move));
+#include "filenames.h"
+#include "binemul.h"
+#include "plugin.h"
+#include <sys/stat.h>
-static void
-replace_members PARAMS ((char **files_to_replace));
+#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
-static void
-print_descr PARAMS ((bfd * abfd));
+/* Static declarations. */
-static void
-ranlib_only PARAMS ((char *archname));
+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);
-/** Globals and flags */
+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);
+\f
+/** Globals and flags. */
-char *program_name = NULL;
-bfd *inarch; /* The input arch we're manipulating */
+static int mri_mode;
-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. */
+ -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;
+int silent_create = 0;
+
/* Nonzero means describe each action performed. */
-int verbose = 0;
+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;
-/* write a __.SYMDEF member into the modified archive. */
-boolean write_armap = false;
-/*
- Nonzero means don't update __.SYMDEF unless command line explicitly
- requested it
-*/
-int ignore_symdef = 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.
+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;
+ 0 is the default.
+ 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;
+
+/* Operate in deterministic mode: write zero for timestamps, uids,
+ and gids for archive members and the archive symbol table, and write
+ consistent file modes. */
+int deterministic = 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 {
+ should also be zero. */
+enum pos
+ {
pos_default, pos_before, pos_after, pos_end
-} postype = pos_default;
+ } 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;
-#ifdef GNU960
- char *default_target;
+/* 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;
- void
- gnu960_verify_target(abfd)
- bfd *abfd;
+/* 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)
{
- if ( abfd->format == bfd_unknown ){
- bfd_check_format(abfd, bfd_object);
- /* Don't really care if it's an object --
- * just want to get the correct xvec.
- */
+ 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);
}
- if ( !BFD_COFF_FILE_P(abfd) ){
- fatal( "'%s' not a COFF file -- operation aborted",
- abfd->filename );
+ 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);
}
}
-#endif
-int interactive = 0;
-void
-DEFUN_VOID(mri_emul)
+ if (!found)
+ /* xgettext:c-format */
+ fprintf (stderr, _("no entry %s in archive\n"), *files);
+ }
+}
+\f
+bfd_boolean operation_alters_arch = FALSE;
+
+static void
+usage (int help)
{
- interactive = isatty(fileno(stdin)) ;
- yyparse();
+ FILE *s;
+
+ s = help ? stdout : stderr;
+
+ if (! is_ranlib)
+ {
+ /* xgettext:c-format */
+ const char * command_line =
+#if BFD_SUPPORTS_PLUGINS
+ _("Usage: %s [emulation options] [--plugin <name>] [-]{dmpqrstx}[abcfilNoPsSuvV] [member-name] [count] archive-file file...\n");
+#else
+ _("Usage: %s [emulation options] [-]{dmpqrstx}[abcfilNoPsSuvV] [member-name] [count] archive-file file...\n");
+#endif
+ fprintf (s, command_line, 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, _(" [D] - use zero for timestamps and uids/gids\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"));
+#if BFD_SUPPORTS_PLUGINS
+ fprintf (s, _(" optional:\n"));
+ fprintf (s, _(" --plugin <p> - load the specified plugin\n"));
+#endif
+ 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"));
+#if BFD_SUPPORTS_PLUGINS
+ fprintf (s, _("\
+ --plugin <name> Load the specified plugin\n"));
+#endif
+ fprintf (s, _("\
+ -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);
}
-/*
- 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
-*/
-void
-DEFUN(map_over_members,(function, files, count),
- void (*function) () AND
- char **files AND
- int count)
+/* 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)
{
- bfd *head;
-
- if (count == 0) {
- for (head = inarch->next; head; head = head->next)
- 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--) {
- boolean found = false;
- for (head = inarch->next; head; head = head->next)
- {
- if (head->filename == NULL)
- {
- /* Some archive formats don't get the filenames filled in
- 'till the elements are opened */
- struct stat buf;
- bfd_stat_arch_elt(head, &buf);
- }
- if ((head->filename != NULL) &&
- (!strcmp(*files, head->filename))) {
- found = true;
- function(head);
- }
+ const char *filename;
+
+ if (full_pathname)
+ return file;
+
+ filename = lbasename (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;
}
- if (!found)
- fprintf(stderr, "No entry %s in archive.\n", *files);
- }
+
+ return filename;
}
+/* Remove any output file. This is only called via xatexit. */
-boolean operation_alters_arch = false;
+static const char *output_filename = NULL;
+static FILE *output_file = NULL;
+static bfd *output_bfd = NULL;
-void
-do_show_version ()
+static void
+remove_output (void)
{
- extern char *program_version;
- printf ("%s version %s\n", program_name, program_version);
+ 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.
-*/
+/* The option parsing should be in its own function.
+ It will be when I have getopt working. */
+
+int main (int, char **);
+
int
-main(argc, argv)
- int argc;
- char **argv;
+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;
- char *inarch_filename;
- char *temp;
- int show_version;
-
- bfd_init();
- show_version = 0;
-#ifdef GNU960
- check_v960( argc, argv );
- default_target = bfd_make_targ_name(BFD_COFF_FORMAT,HOST_BYTE_ORDER_BIG_P);
+ char *arg_ptr;
+ char c;
+ enum
+ {
+ none = 0, del, 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);
+#if BFD_SUPPORTS_PLUGINS
+ bfd_plugin_set_program_name (program_name);
+#endif
- temp = strrchr(program_name, '/');
- if (temp == (char *) NULL)
- temp = program_name; /* shouldn't happen, but... */
- else
- ++temp;
- if (is_ranlib > 0 || (is_ranlib < 0 && strcmp(temp, "ranlib") == 0)) {
- if (argc < 2)
- fatal("Too few command arguments.");
- arg_ptr = argv[1];
- if (strcmp(argv[1], "-V") == 0 || strcmp(argv[1], "-v") == 0) {
- do_show_version();
- if (argc == 2)
- exit(0);
- arg_ptr = argv[2];
- }
- ranlib_only(arg_ptr);
- }
-
- if (argc == 2 && strcmp(argv[1],"-M") == 0) {
- mri_emul();
- exit(0);
- }
+ expandargv (&argc, &argv);
- if (argc < 2)
- fatal("Too few command arguments.");
+ if (is_ranlib < 0)
+ {
+ const char *temp = lbasename (program_name);
- arg_ptr = argv[1];
+ if (strlen (temp) >= 6
+ && FILENAME_CMP (temp + strlen (temp) - 6, "ranlib") == 0)
+ is_ranlib = 1;
+ else
+ is_ranlib = 0;
+ }
- if (*arg_ptr == '-')
- ++arg_ptr; /* compatibility */
-
- while (c = *arg_ptr++) {
- switch (c) {
- case 'd':
- case 'm':
- case 'p':
- case 'q':
- case 'r':
- case 't':
- case 'x':
- if (operation != none)
- fatal("two different operation switches 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 = true;
- 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':
+ 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);
- mri_mode = 1;
+ for (i = 1; i < argc; i++)
+ if (! ar_emul_parse_arg (argv[i]))
break;
- default:
- fatal("invalid option %c", c);
+ 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 (show_version)
- do_show_version();
+ if (argc == 2 && strcmp (argv[1], "-M") == 0)
+ {
+ mri_emul ();
+ xexit (0);
+ }
- if (argc < 3)
- if (show_version)
- exit(0);
- else
- fatal("Too few command arguments.");
+ if (argc < 2)
+ usage (0);
- if (mri_mode) {
- mri_emul();
- }
- else {
- if ((operation == none || operation == print_table)
- && write_armap == true)
- ranlib_only(argv[2]);
+ arg_index = 1;
+ arg_ptr = argv[arg_index];
- if (operation == none)
- fatal("no operation specified");
+ if (strcmp (arg_ptr, "--plugin") == 0)
+ {
+#if BFD_SUPPORTS_PLUGINS
+ if (argc < 4)
+ usage (1);
- if (newer_only && operation != replace)
- fatal("'u' only meaningful with 'r' option.");
+ bfd_plugin_set_plugin (argv[2]);
- arg_index = 2;
+ arg_index += 2;
+ arg_ptr = argv[arg_index];
+#else
+ fprintf (stderr, _("sorry - this program has been built without plugin support\n"));
+ xexit (1);
+#endif
+ }
- if (postype != pos_default)
- posname = argv[arg_index++];
+ if (*arg_ptr == '-')
+ {
+ /* When the first option starts with '-' we support POSIX-compatible
+ option parsing. */
+ do_posix = 1;
+ ++arg_ptr; /* compatibility */
+ }
- inarch_filename = argv[arg_index++];
+ 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 = del;
+ 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;
+ case 'D':
+ deterministic = TRUE;
+ break;
+ default:
+ /* xgettext:c-format */
+ non_fatal (_("illegal option -- %c"), c);
+ usage (0);
+ }
+ }
- if (arg_index < argc) {
- files = argv + arg_index;
- while (arg_index < argc)
- if (!strcmp(argv[arg_index++], "__.SYMDEF")) {
- ignore_symdef = 1;
- break;
- }
+ /* 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;
}
- else
- files = NULL;
+ while (do_posix);
+
+ if (show_version)
+ print_version ("ar");
+
+ ++arg_index;
+ if (arg_index >= argc)
+ usage (0);
- if (operation == quick_append) {
- if (files != NULL)
- do_quick_append(inarch_filename, files);
- exit(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. */
- open_inarch(inarch_filename);
+ /* We can't write an armap when using ar q, so just do ar r
+ instead. */
+ if (operation == quick_append && write_armap)
+ operation = replace;
- switch (operation) {
+ if ((operation == none || operation == print_table)
+ && write_armap == 1)
+ xexit (ranlib_only (argv[arg_index]));
- case print_table:
- map_over_members(print_descr, files, argc - 3);
- break;
+ if (operation == none)
+ fatal (_("no operation specified"));
- case print_files:
- map_over_members(print_contents, files, argc - 3);
- break;
+ if (newer_only && operation != replace)
+ fatal (_("`u' is only meaningful with the `r' option."));
- case extract:
- map_over_members(extract_file, files, argc - 3);
- break;
+ if (newer_only && deterministic)
+ fatal (_("`u' is not meaningful with the `D' option."));
- case delete:
- if (files != NULL)
- delete_members(files);
- break;
+ if (postype != pos_default)
+ posname = argv[arg_index++];
- case move:
- if (files != NULL)
- move_members(files);
- break;
+ if (counted_name_mode)
+ {
+ if (operation != extract && operation != del)
+ 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."));
+ }
- case replace:
- if (files != NULL || write_armap)
- replace_members(files);
- break;
+ inarch_filename = argv[arg_index++];
- /* Shouldn't happen! */
- default:
- fprintf(stderr, "Sorry; this option not implemented.\n");
- }
- }
- return (0);
-} /* main() */
+ files = arg_index < argc ? argv + arg_index : NULL;
+ file_count = argc - arg_index;
-static
-char *normalize(file)
-char *file;
-{
- char * filename = strrchr(file, '/');
- if (filename != (char *)NULL) {
- filename ++;
- }
- else {
- filename = file;
+ 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 del:
+ if (files != NULL)
+ delete_members (arch, files);
+ else
+ output_filename = NULL;
+ break;
+
+ case move:
+ if (files != NULL)
+ move_members (arch, files);
+ else
+ output_filename = NULL;
+ break;
+
+ case replace:
+ case quick_append:
+ if (files != NULL || write_armap > 0)
+ replace_members (arch, files, operation == quick_append);
+ else
+ output_filename = NULL;
+ break;
+
+ /* Shouldn't happen! */
+ default:
+ /* xgettext:c-format */
+ fatal (_("internal error -- this option not implemented"));
+ }
}
- return filename;
+
+ END_PROGRESS (program_name);
+
+ xexit (0);
+ return 0;
}
-int
-open_inarch(archive_filename)
- char *archive_filename;
+bfd *
+open_inarch (const char *archive_filename, const char *file)
{
- bfd **last_one;
- bfd *next_one;
- struct stat sbuf;
- bfd_error = no_error;
- if (stat(archive_filename, &sbuf) != 0) {
- if (errno != ENOENT)
- bfd_fatal(archive_filename);
- if (!operation_alters_arch) {
- fprintf (stderr, "%s: %s not found.\n", program_name,
- archive_filename);
- maybequit();
- return 0;
- }
-
- /* This routine is one way to forcibly create the archive. */
- do_quick_append(archive_filename, 0);
- }
-
-#ifdef GNU960
- inarch = bfd_openr(archive_filename, default_target);
-#else
- inarch = bfd_openr(archive_filename, NULL);
-#endif
- if (inarch == NULL) {
- bloser:
- bfd_perror(archive_filename);
- exit(1);
- }
+ 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. */
- if (bfd_check_format(inarch, bfd_archive) != true)
- fatal("File %s is not an archive.", archive_filename);
-#ifdef GNU960
- gnu960_verify_target(inarch); /* Exits on failure */
+/* 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
- last_one = &(inarch->next);
- /* Read all the contents right away, regardless. */
- for (next_one = bfd_openr_next_archived_file(inarch, NULL);
- next_one;
- next_one = bfd_openr_next_archived_file(inarch, next_one)) {
- *last_one = next_one;
- last_one = &next_one->next;
- }
- *last_one = (bfd *) NULL;
- if (bfd_error != no_more_archived_files)
- goto bloser;
- return 1;
-}
+ 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->archive_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->archive_next;
+ }
+ *last_one = (bfd *) NULL;
+ if (bfd_get_error () != bfd_error_no_more_archived_files)
+ goto bloser;
+ return arch;
+}
static void
-print_contents(abfd)
- bfd *abfd;
+print_contents (bfd *abfd)
{
- int ncopied = 0;
- struct stat buf;
- long size;
- if (bfd_stat_arch_elt(abfd, &buf) != 0)
- fatal("Internal stat error on %s", abfd->filename);
-
- if (verbose)
- printf("\n<member %s>\n\n", abfd->filename);
-
- bfd_seek(abfd, 0, SEEK_SET);
-
- size = buf.st_size;
- while (ncopied < size) {
- char cbuf[BUFSIZE];
- int nread;
- int tocopy = size - ncopied;
- if (tocopy > BUFSIZE)
- tocopy = BUFSIZE;
-
- nread = bfd_read(cbuf, 1, tocopy, abfd); /* oops -- broke
- abstraction! */
+ size_t ncopied = 0;
+ char *cbuf = (char *) 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)
+ {
- if (nread != tocopy)
- fatal("file %s not a valid archive", abfd->my_archive->filename);
- fwrite(cbuf, 1, nread, stdout);
- ncopied += tocopy;
+ 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);
}
+/* Extract a member of the archive into its own file.
-/*
- Extract a member of the archive into its own file.
-
-We defer opening the new file until after we have read a BUFSIZ chunk of the
+ We defer opening the new file until after we have read a BUFSIZ chunk of the
old one, since we know we have just read the archive header for the old
one. Since most members are shorter than BUFSIZ, this means we will read
the old header, read the old data, write a new inode for the new file, and
write the new data, and be done. This 'optimization' is what comes from
sitting next to a bare disk and hearing it every time it seeks. -- Gnu
- Gilmore
-*/
+ Gilmore */
void
-extract_file(abfd)
- bfd *abfd;
+extract_file (bfd *abfd)
{
- FILE *ostream;
- char cbuf[BUFSIZE];
- int nread,
- tocopy;
- int ncopied = 0;
- long size;
- struct stat buf;
- if (bfd_stat_arch_elt(abfd, &buf) != 0)
- fatal("Internal stat error on %s", abfd->filename);
- size = buf.st_size;
-
- if (verbose)
- printf("x - %s\n", abfd->filename);
-
- bfd_seek(abfd, 0, SEEK_SET);
-
- ostream = 0;
- if (size == 0) {
+ FILE *ostream;
+ char *cbuf = (char *) 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! */
- ostream = fopen(abfd->filename, FOPEN_WB);
- if (!ostream) {
- perror(abfd->filename);
- exit(1);
- }
- } else
- while (ncopied < size) {
+ 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;
+ tocopy = BUFSIZE;
- nread = bfd_read(cbuf, 1, tocopy, abfd);
+ nread = bfd_bread (cbuf, (bfd_size_type) tocopy, abfd);
if (nread != tocopy)
- fatal("file %s not a valid archive", abfd->my_archive->filename);
+ /* 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) {
+ if (ostream == NULL)
+ {
/* Seems like an abstraction violation, eh? Well it's OK! */
- ostream = fopen(abfd->filename, FOPEN_WB);
- if (!ostream) {
- perror(abfd->filename);
- exit(1);
- }
- }
- fwrite(cbuf, 1, nread, ostream);
+ 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;
- }
-
- fclose(ostream);
- chmod(abfd->filename, buf.st_mode);
-
- if (preserve_dates) {
-#ifdef POSIX_UTIME
- struct utimbuf tb;
- tb.actime = buf.st_mtime;
- tb.modtime = buf.st_mtime;
- utime(abfd->filename, tb); /* FIXME check result */
-#else /* ! POSIX_UTIME */
-#ifdef USE_UTIME
- long tb[2];
- tb[0] = buf.st_mtime;
- tb[1] = buf.st_mtime;
- utime(abfd->filename, tb); /* FIXME check result */
-#else /* ! USE_UTIME */
- struct timeval tv[2];
- tv[0].tv_sec = buf.st_mtime;
- tv[0].tv_usec = 0;
- tv[1].tv_sec = buf.st_mtime;
- tv[1].tv_usec = 0;
- utimes(abfd->filename, tv); /* FIXME check result */
-#endif /* ! USE_UTIME */
-#endif /* ! POSIX_UTIME */
- }
-}
-
+ }
-/* Just do it quickly; don't worry about dups, armap, or anything like that */
+ if (ostream != NULL)
+ fclose (ostream);
-static void
-do_quick_append(archive_filename, files_to_append)
- char *archive_filename;
- char **files_to_append;
+ output_file = NULL;
+ output_filename = NULL;
-{
- FILE *ofile,
- *ifile;
- char buf[BUFSIZE];
- long tocopy,
- thistime;
- bfd *temp;
- struct stat sbuf;
- boolean newfile = false;
- bfd_error = no_error;
+ chmod (bfd_get_filename (abfd), buf.st_mode);
- if (stat(archive_filename, &sbuf) != 0) {
- if (errno != ENOENT)
- bfd_fatal(archive_filename);
- newfile = true;
+ 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);
+}
- ofile = fopen(archive_filename, FOPEN_AUB);
- if (ofile == NULL) {
- perror(program_name);
- exit(1);
- }
-
- /* bletch */
-#ifdef GNU960
- temp = bfd_openr(archive_filename, default_target);
-#else
- temp = bfd_openr(archive_filename, NULL);
-#endif
- if (temp == NULL) {
- bfd_perror(archive_filename);
- exit(1);
- }
- if (newfile == false) {
- if (bfd_check_format(temp, bfd_archive) != true)
- fatal("File %s is not an archive.", archive_filename);
-#ifdef GNU960
- gnu960_verify_target(temp); /* Exits on failure */
-#endif
- }
- else {
- fwrite(ARMAG, 1, SARMAG, ofile);
- if (!silent_create)
- fprintf(stderr, "%s: creating %s\n", program_name, archive_filename);
- }
+static void
+write_archive (bfd *iarch)
+{
+ bfd *obfd;
+ char *old_name, *new_name;
+ bfd *contents_head = iarch->archive_next;
- /* assume it's an achive, go straight to the end, sans $200 */
- fseek(ofile, 0, 2);
+ old_name = (char *) xmalloc (strlen (bfd_get_filename (iarch)) + 1);
+ strcpy (old_name, bfd_get_filename (iarch));
+ new_name = make_tempname (old_name);
- for (; files_to_append && *files_to_append; ++files_to_append) {
- struct ar_hdr *hdr = bfd_special_undocumented_glue(temp, *files_to_append);
- if (hdr == NULL) {
- bfd_perror(*files_to_append);
- exit(1);
- }
+ if (new_name == NULL)
+ bfd_fatal ("could not create temporary file whilst writing archive");
- BFD_SEND(temp, _bfd_truncate_arname, (temp, *files_to_append, (char *) hdr));
+ output_filename = new_name;
- ifile = fopen(*files_to_append, FOPEN_RB);
- if (ifile == NULL)
- bfd_perror(program_name);
+ obfd = bfd_openw (new_name, bfd_get_target (iarch));
- if (stat(*files_to_append, &sbuf) != 0)
- bfd_perror(*files_to_append);
+ if (obfd == NULL)
+ bfd_fatal (old_name);
- tocopy = sbuf.st_size;
+ output_bfd = obfd;
- /* XXX should do error-checking! */
- fwrite(hdr, 1, sizeof(struct ar_hdr), ofile);
+ 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;
- while (tocopy > 0) {
- thistime = tocopy;
- if (thistime > BUFSIZE)
- thistime = BUFSIZE;
- fread(buf, 1, thistime, ifile);
- fwrite(buf, 1, thistime, ofile);
- tocopy -= thistime;
- }
- fclose(ifile);
- if ((sbuf.st_size % 2) == 1)
- putc('\n', ofile);
+ if (ar_truncate)
+ {
+ /* This should really use bfd_set_file_flags, but that rejects
+ archives. */
+ obfd->flags |= BFD_TRADITIONAL_FORMAT;
}
- fclose(ofile);
- bfd_close(temp);
-}
+ if (deterministic)
+ obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
-void
-write_archive()
-{
- bfd *obfd;
- int namelen = strlen(inarch->filename);
- char *new_name = xmalloc(namelen + 6);
- bfd *contents_head = inarch->next;
-
- strcpy(new_name, inarch->filename);
- strcpy(new_name + namelen, "-art");
- obfd = bfd_openw(new_name,
- /* FIXME: violates abstraction; need a better protocol */
- (inarch->xvec ? bfd_get_target(inarch) : NULL));
+ if (make_thin_archive || bfd_is_thin_archive (iarch))
+ bfd_is_thin_archive (obfd) = 1;
- if (obfd == NULL)
- bfd_fatal(inarch->filename);
+ if (!bfd_set_archive_head (obfd, contents_head))
+ bfd_fatal (old_name);
- bfd_set_format(obfd, bfd_archive);
- obfd->has_armap = write_armap;
+ if (!bfd_close (obfd))
+ bfd_fatal (old_name);
- if (bfd_set_archive_head(obfd, contents_head) != true)
- bfd_fatal(inarch->filename);
+ output_bfd = NULL;
+ output_filename = NULL;
- if (!bfd_close(obfd))
- bfd_fatal(inarch->filename);
+ /* We don't care if this fails; we might be creating the archive. */
+ bfd_close (iarch);
- /* We don't care if this fails, we might be creating the
- archive */
- (void) unlink(inarch->filename);
-
- if (rename(new_name, inarch->filename) != 0)
- bfd_fatal(inarch->filename);
+ if (smart_rename (new_name, old_name, 0) != 0)
+ xexit (1);
}
+/* Return a pointer to the pointer to the entry which should be rplacd'd
+ into when altering. DEFAULT_POS should be how to interpret pos_default,
+ and should be a pos value. */
-
-/*
- returns a pointer to the pointer to the entry which should be rplacd'd
- into when altering. default_pos should be how to interpret pos_default,
- and should be a pos value.
-*/
-
-bfd **
-get_pos_bfd(contents, default_pos)
- bfd **contents;
- enum pos default_pos;
+static bfd **
+get_pos_bfd (bfd **contents, enum pos default_pos, const char *default_posname)
{
- bfd **after_bfd = contents;
- enum pos realpos = (postype == pos_default ? default_pos : postype);
-
- if (realpos == pos_end) {
- while (*after_bfd)
- after_bfd = &((*after_bfd)->next);
- }
- else {
- for ( ; *after_bfd; after_bfd = &(*after_bfd)->next)
- if (!strcmp((*after_bfd)->filename, posname)) {
- if (realpos == pos_after)
- after_bfd = &(*after_bfd)->next;
- break;
- }
+ 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;
}
- return after_bfd;
-}
+ if (realpos == pos_end)
+ {
+ while (*after_bfd)
+ after_bfd = &((*after_bfd)->archive_next);
+ }
+ else
+ {
+ for (; *after_bfd; after_bfd = &(*after_bfd)->archive_next)
+ if (FILENAME_CMP ((*after_bfd)->filename, realposname) == 0)
+ {
+ if (realpos == pos_after)
+ after_bfd = &(*after_bfd)->archive_next;
+ break;
+ }
+ }
+ return after_bfd;
+}
static void
-delete_members(files_to_delete)
- char **files_to_delete;
+delete_members (bfd *arch, char **files_to_delete)
{
- bfd **current_ptr_ptr;
- boolean found;
- boolean something_changed = false;
- 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. The name is NULL in COFF archives, so using this as a
- key is as good as anything I suppose
- */
- if (!strcmp(*files_to_delete, "__.SYMDEF")) {
- inarch->has_armap = false;
- write_armap = false;
- continue;
- }
+ bfd **current_ptr_ptr;
+ bfd_boolean found;
+ bfd_boolean something_changed = FALSE;
+ int match_count;
- found = false;
- current_ptr_ptr = &(inarch->next);
- while (*current_ptr_ptr) {
- if (strcmp(*files_to_delete, (*current_ptr_ptr)->filename) == 0) {
- found = true;
- something_changed = true;
- if (verbose)
- printf("d - %s\n",
- *files_to_delete);
- *current_ptr_ptr = ((*current_ptr_ptr)->next);
- goto next_file;
+ 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 */
- }
- else {
- current_ptr_ptr = &((*current_ptr_ptr)->next);
- }
+ if (!strcmp (*files_to_delete, "__.SYMDEF"))
+ {
+ arch->has_armap = FALSE;
+ write_armap = -1;
+ continue;
}
- if (verbose && found == false) {
- printf("No member named `%s'\n", *files_to_delete);
+ found = FALSE;
+ match_count = 0;
+ current_ptr_ptr = &(arch->archive_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)->archive_next);
+ goto next_file;
+ }
+ }
+
+ current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
}
-next_file:;
+ if (verbose && !found)
+ {
+ /* xgettext:c-format */
+ printf (_("No member named `%s'\n"), *files_to_delete);
+ }
+ next_file:
+ ;
}
- if (something_changed == true) {
- write_archive();
- }
+ if (something_changed)
+ write_archive (arch);
+ else
+ output_filename = NULL;
}
/* Reposition existing members within an archive */
static void
-move_members(files_to_move)
- char **files_to_move;
+move_members (bfd *arch, char **files_to_move)
{
- 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 = &(inarch->next);
- while (*current_ptr_ptr) {
- bfd *current_ptr = *current_ptr_ptr;
- if (strcmp(normalize(*files_to_move), current_ptr->filename) == 0) {
- /*
- Move this file to the end of the list - first cut from
- where it is.
- */
- *current_ptr_ptr = current_ptr->next;
-
- /* Now glue to end */
- after_bfd = get_pos_bfd(&inarch->next, pos_end);
- *after_bfd = current_ptr;
- current_ptr->next = (bfd *) NULL;
+ bfd **after_bfd; /* New entries go after this one */
+ bfd **current_ptr_ptr; /* cdr pointer into contents */
- if (verbose)
- printf("m - %s\n", *files_to_move);
-
- goto next_file;
+ for (; *files_to_move; ++files_to_move)
+ {
+ current_ptr_ptr = &(arch->archive_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_bfd;
+ *current_ptr_ptr = current_ptr->archive_next;
+
+ /* Now glue to end */
+ after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
+ link_bfd = *after_bfd;
+ *after_bfd = current_ptr;
+ current_ptr->archive_next = link_bfd;
+
+ if (verbose)
+ printf ("m - %s\n", *files_to_move);
+
+ goto next_file;
}
- current_ptr_ptr = &((*current_ptr_ptr)->next);
+
+ current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
}
- fprintf(stderr, "No entry %s in archive %s!\n",
- *files_to_move, inarch->filename);
- exit(1);
-next_file:;
+ /* xgettext:c-format */
+ fatal (_("no entry %s in archive %s!"), *files_to_move, arch->filename);
+
+ next_file:;
}
- write_archive();
+ write_archive (arch);
}
-
-/* Ought to default to replacing in place, but this is existing practice! */
+/* Ought to default to replacing in place, but this is existing practice! */
static void
-replace_members(files_to_move)
- char **files_to_move;
+replace_members (bfd *arch, char **files_to_move, bfd_boolean quick)
{
- bfd **after_bfd; /* New entries go after this one */
- bfd *current;
- bfd **current_ptr;
- bfd *temp;
- /*
- If the first item in the archive is an __.SYMDEF then remove it
- */
- if (inarch->next &&
- strcmp(inarch->next->filename, "__.SYMDEF") == 0) {
- inarch->next = inarch->next->next;
- }
-
-
-
- while (files_to_move && *files_to_move) {
- current_ptr = &inarch->next;
- while (*current_ptr) {
- current = *current_ptr;
-
- if (!strcmp(normalize(*files_to_move), current->filename)) {
- if (newer_only) {
- struct stat fsbuf,
- asbuf;
-
- if (current->arelt_data == NULL) {
- /* This can only happen if you specify a file on the
- command line more than once. */
- fprintf (stderr, "Duplicate file specified: %s -- skipping.\n", *files_to_move);
- goto next_file;
- }
+ bfd_boolean changed = FALSE;
+ bfd **after_bfd; /* New entries go after this one. */
+ bfd *current;
+ bfd **current_ptr;
- if (stat(*files_to_move, &fsbuf) != 0) {
- if (errno != ENOENT)
- bfd_fatal(*files_to_move);
+ while (files_to_move && *files_to_move)
+ {
+ if (! quick)
+ {
+ current_ptr = &arch->archive_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;
}
- if (bfd_stat_arch_elt(current, &asbuf) != 0)
- fatal("Internal stat error on %s", current->filename);
- if (fsbuf.st_mtime <= asbuf.st_mtime)
- goto next_file;
- }
-
- /* snip out this entry from the chain */
- *current_ptr = current->next;
-
- after_bfd = get_pos_bfd(&inarch->next, pos_end);
- temp = *after_bfd;
- *after_bfd = bfd_openr(*files_to_move, NULL);
- if (*after_bfd == (bfd *) NULL) {
- fprintf(stderr, "Can't open file %s\n", *files_to_move);
- exit(1);
- }
-#ifdef GNU960
- gnu960_verify_target(*after_bfd); /* Exits on failure */
-#endif
- (*after_bfd)->next = temp;
+ after_bfd = get_pos_bfd (&arch->archive_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)->archive_next;
+ changed = TRUE;
+ }
- if (verbose) {
- printf("%c - %s\n", (postype == pos_after ? 'r' : 'a'),
- *files_to_move);
+ goto next_file;
}
- goto next_file;
+ current_ptr = &(current->archive_next);
}
- current_ptr = &(current->next);
}
- /* It isn't in there, so add to end */
+ /* Add to the end of the archive. */
+ after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
- after_bfd = get_pos_bfd(&inarch->next, pos_end);
- temp = *after_bfd;
- *after_bfd = bfd_openr(*files_to_move, NULL);
- if (*after_bfd == (bfd *) NULL) {
- fprintf(stderr, "Can't open file %s\n", *files_to_move);
- exit(1);
- }
-#ifdef GNU960
- gnu960_verify_target(*after_bfd); /* Exits on failure */
-#endif
- if (verbose) {
- printf("c - %s\n", *files_to_move);
- }
+ if (ar_emul_append (after_bfd, *files_to_move, verbose,
+ make_thin_archive))
+ changed = TRUE;
- (*after_bfd)->next = temp;
+ next_file:;
-next_file:;
-
- files_to_move++;
+ files_to_move++;
}
-
- write_archive();
+ if (changed)
+ write_archive (arch);
+ else
+ output_filename = NULL;
}
-static void
-ranlib_only(archname)
- char *archname;
+static int
+ranlib_only (const char *archname)
{
- write_armap = true;
- open_inarch(archname);
- write_archive();
- exit(0);
+ 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;
}
+/* Update the timestamp of the symbol map of an archive. */
+
+static int
+ranlib_touch (const char *archname)
+{
+#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;
+}
/* Things which are interesting to map over all or some of the files: */
static void
-print_descr(abfd)
- bfd *abfd;
+print_descr (bfd *abfd)
{
- print_arelt_descr(stdout,abfd, verbose);
+ print_arelt_descr (stdout, abfd, verbose);
}