1 /* ar.c - Archive modify and extract.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
24 Bugs: GNU ar used to check file against filesystem in quick_update and
25 replace operations (would check mtime). Doesn't warn when name truncated.
26 No way to specify pos_end. Error messages should be more consistent. */
30 #include "libiberty.h"
37 #include "filenames.h"
43 #define EXT_NAME_LEN 3 /* Bufflen of addition to name if it's MS-DOS. */
45 #define EXT_NAME_LEN 6 /* Ditto for *NIX. */
48 /* Static declarations. */
50 static void mri_emul (void);
51 static const char *normalize (const char *, bfd *);
52 static void remove_output (void);
53 static void map_over_members (bfd *, void (*)(bfd *), char **, int);
54 static void print_contents (bfd * member);
55 static void delete_members (bfd *, char **files_to_delete);
57 static void move_members (bfd *, char **files_to_move);
58 static void replace_members
59 (bfd *, char **files_to_replace, bfd_boolean quick);
60 static void print_descr (bfd * abfd);
61 static void write_archive (bfd *);
62 static int ranlib_only (const char *archname);
63 static int ranlib_touch (const char *archname);
64 static void usage (int);
66 /** Globals and flags. */
70 /* This flag distinguishes between ar and ranlib:
71 1 means this is 'ranlib'; 0 means this is 'ar'.
72 -1 means if we should use argv[0] to decide. */
75 /* Nonzero means don't warn about creating the archive file if necessary. */
76 int silent_create = 0;
78 /* Nonzero means describe each action performed. */
81 /* Nonzero means preserve dates of members when extracting them. */
82 int preserve_dates = 0;
84 /* Nonzero means don't replace existing members whose dates are more recent
85 than the corresponding files. */
88 /* Controls the writing of an archive symbol table (in BSD: a __.SYMDEF
89 member). -1 means we've been explicitly asked to not write a symbol table;
90 +1 means we've been explicitly asked to write it;
92 Traditionally, the default in BSD has been to not write the table.
93 However, for POSIX.2 compliance the default is now to write a symbol table
94 if any of the members are object files. */
97 /* Operate in deterministic mode: write zero for timestamps, uids,
98 and gids for archive members and the archive symbol table, and write
99 consistent file modes. */
100 int deterministic = 0;
102 /* Nonzero means it's the name of an existing member; position new or moved
103 files with respect to this one. */
104 char *posname = NULL;
106 /* Sez how to use `posname': pos_before means position before that member.
107 pos_after means position after that member. pos_end means always at end.
108 pos_default means default appropriately. For the latter two, `posname'
109 should also be zero. */
112 pos_default, pos_before, pos_after, pos_end
113 } postype = pos_default;
117 none = 0, del, replace, print_table,
118 print_files, extract, move, quick_append
122 get_pos_bfd (bfd **, enum pos, const char *);
124 /* For extract/delete only. If COUNTED_NAME_MODE is TRUE, we only
125 extract the COUNTED_NAME_COUNTER instance of that name. */
126 static bfd_boolean counted_name_mode = 0;
127 static int counted_name_counter = 0;
129 /* Whether to truncate names of files stored in the archive. */
130 static bfd_boolean ar_truncate = FALSE;
132 /* Whether to use a full file name match when searching an archive.
133 This is convenient for archives created by the Microsoft lib
135 static bfd_boolean full_pathname = FALSE;
137 /* Whether to create a "thin" archive (symbol index only -- no files). */
138 static bfd_boolean make_thin_archive = FALSE;
140 static int show_version = 0;
142 static int show_help = 0;
144 static const char *plugin_target = NULL;
146 static const char *target = NULL;
148 #define OPTION_PLUGIN 201
149 #define OPTION_TARGET 202
151 static struct option long_options[] =
153 {"help", no_argument, &show_help, 1},
154 {"plugin", required_argument, NULL, OPTION_PLUGIN},
155 {"target", required_argument, NULL, OPTION_TARGET},
156 {"version", no_argument, &show_version, 1},
157 {NULL, no_argument, NULL, 0}
165 interactive = isatty (fileno (stdin));
169 /* If COUNT is 0, then FUNCTION is called once on each entry. If nonzero,
170 COUNT is the length of the FILES chain; FUNCTION is called on each entry
171 whose name matches one in FILES. */
174 map_over_members (bfd *arch, void (*function)(bfd *), char **files, int count)
181 for (head = arch->archive_next; head; head = head->archive_next)
189 /* This may appear to be a baroque way of accomplishing what we want.
190 However we have to iterate over the filenames in order to notice where
191 a filename is requested but does not exist in the archive. Ditto
192 mapping over each file each time -- we want to hack multiple
195 for (; count > 0; files++, count--)
197 bfd_boolean found = FALSE;
200 for (head = arch->archive_next; head; head = head->archive_next)
202 const char * filename;
205 filename = head->filename;
206 if (filename == NULL)
208 /* Some archive formats don't get the filenames filled in
209 until the elements are opened. */
211 bfd_stat_arch_elt (head, &buf);
213 else if (bfd_is_thin_archive (arch))
215 /* Thin archives store full pathnames. Need to normalize. */
216 filename = normalize (filename, arch);
219 if ((filename != NULL) &&
220 (!FILENAME_CMP (normalize (*files, arch), filename)))
223 if (counted_name_mode
224 && match_count != counted_name_counter)
226 /* Counting, and didn't match on count; go on to the
237 /* xgettext:c-format */
238 fprintf (stderr, _("no entry %s in archive\n"), *files);
242 bfd_boolean operation_alters_arch = FALSE;
249 s = help ? stdout : stderr;
251 /* xgettext:c-format */
252 const char * command_line =
253 #if BFD_SUPPORTS_PLUGINS
254 _("Usage: %s [emulation options] [-]{dmpqrstx}[abcfilNoPsSuvV] [--plugin <name>] [member-name] [count] archive-file file...\n");
256 _("Usage: %s [emulation options] [-]{dmpqrstx}[abcfilNoPsSuvV] [member-name] [count] archive-file file...\n");
258 fprintf (s, command_line, program_name);
260 /* xgettext:c-format */
261 fprintf (s, _(" %s -M [<mri-script]\n"), program_name);
262 fprintf (s, _(" commands:\n"));
263 fprintf (s, _(" d - delete file(s) from the archive\n"));
264 fprintf (s, _(" m[ab] - move file(s) in the archive\n"));
265 fprintf (s, _(" p - print file(s) found in the archive\n"));
266 fprintf (s, _(" q[f] - quick append file(s) to the archive\n"));
267 fprintf (s, _(" r[ab][f][u] - replace existing or insert new file(s) into the archive\n"));
268 fprintf (s, _(" s - act as ranlib\n"));
269 fprintf (s, _(" t - display contents of archive\n"));
270 fprintf (s, _(" x[o] - extract file(s) from the archive\n"));
271 fprintf (s, _(" command specific modifiers:\n"));
272 fprintf (s, _(" [a] - put file(s) after [member-name]\n"));
273 fprintf (s, _(" [b] - put file(s) before [member-name] (same as [i])\n"));
274 fprintf (s, _(" [D] - use zero for timestamps and uids/gids\n"));
275 fprintf (s, _(" [N] - use instance [count] of name\n"));
276 fprintf (s, _(" [f] - truncate inserted file names\n"));
277 fprintf (s, _(" [P] - use full path names when matching\n"));
278 fprintf (s, _(" [o] - preserve original dates\n"));
279 fprintf (s, _(" [u] - only replace files that are newer than current archive contents\n"));
280 fprintf (s, _(" generic modifiers:\n"));
281 fprintf (s, _(" [c] - do not warn if the library had to be created\n"));
282 fprintf (s, _(" [s] - create an archive index (cf. ranlib)\n"));
283 fprintf (s, _(" [S] - do not build a symbol table\n"));
284 fprintf (s, _(" [T] - make a thin archive\n"));
285 fprintf (s, _(" [v] - be verbose\n"));
286 fprintf (s, _(" [V] - display the version number\n"));
287 fprintf (s, _(" @<file> - read options from <file>\n"));
288 #if BFD_SUPPORTS_PLUGINS
289 fprintf (s, _(" optional:\n"));
290 fprintf (s, _(" --plugin <p> - load the specified plugin\n"));
295 list_supported_targets (program_name, s);
297 if (REPORT_BUGS_TO[0] && help)
298 fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO);
300 xexit (help ? 0 : 1);
304 ranlib_usage(int help)
308 s = help ? stdout : stderr;
310 /* xgettext:c-format */
311 fprintf (s, _("Usage: %s [options] archive\n"), program_name);
312 fprintf (s, _(" Generate an index to speed access to archives\n"));
313 fprintf (s, _(" The options are:\n\
314 @<file> Read options from <file>\n"));
315 #if BFD_SUPPORTS_PLUGINS
317 --plugin <name> Load the specified plugin\n"));
320 -t Update the archive's symbol map timestamp\n\
321 -h --help Print this help message\n\
322 -v --version Print version information\n"));
324 list_supported_targets (program_name, s);
326 if (REPORT_BUGS_TO[0] && help)
327 fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO);
329 xexit (help ? 0 : 1);
332 /* Normalize a file name specified on the command line into a file
333 name which we will use in an archive. */
336 normalize (const char *file, bfd *abfd)
338 const char *filename;
343 filename = lbasename (file);
347 && strlen (filename) > abfd->xvec->ar_max_namelen)
352 s = (char *) xmalloc (abfd->xvec->ar_max_namelen + 1);
353 memcpy (s, filename, abfd->xvec->ar_max_namelen);
354 s[abfd->xvec->ar_max_namelen] = '\0';
361 /* Remove any output file. This is only called via xatexit. */
363 static const char *output_filename = NULL;
364 static FILE *output_file = NULL;
365 static bfd *output_bfd = NULL;
370 if (output_filename != NULL)
372 if (output_bfd != NULL)
373 bfd_cache_close (output_bfd);
374 if (output_file != NULL)
375 fclose (output_file);
376 unlink_if_ordinary (output_filename);
381 decode_options(int argc, char **argv)
385 /* Convert old-style tar call by exploding option element and rearranging
386 options accordingly. */
388 if (argc > 1 && argv[1][0] != '-')
390 int new_argc; /* argc value for rearranged arguments */
391 char **new_argv; /* argv value for rearranged arguments */
392 char *const *in; /* cursor into original argv */
393 char **out; /* cursor into rearranged argv */
394 const char *letter; /* cursor into old option letters */
395 char buffer[3]; /* constructed option buffer */
397 /* Initialize a constructed option. */
402 /* Allocate a new argument array, and copy program name in it. */
404 new_argc = argc - 1 + strlen (argv[1]);
405 new_argv = xmalloc ((new_argc + 1) * sizeof (*argv));
410 /* Copy each old letter option as a separate option. */
412 for (letter = *in++; *letter; letter++)
415 *out++ = xstrdup (buffer);
418 /* Copy all remaining options. */
420 while (in < argv + argc)
424 /* Replace the old option list by the new one. */
430 while ((c = getopt_long (argc, argv, "hdmpqrstxabcfilNoPsSuvV",
431 long_options, NULL)) != EOF)
442 if (operation != none)
443 fatal (_("two different operation options specified"));
454 operation_alters_arch = TRUE;
458 operation_alters_arch = TRUE;
461 operation = print_files;
464 operation = quick_append;
465 operation_alters_arch = TRUE;
469 operation_alters_arch = TRUE;
472 operation = print_table;
504 postype = pos_before;
507 postype = pos_before;
513 counted_name_mode = TRUE;
519 full_pathname = TRUE;
522 make_thin_archive = TRUE;
525 deterministic = TRUE;
528 #if BFD_SUPPORTS_PLUGINS
529 plugin_target = "plugin";
530 bfd_plugin_set_plugin (optarg);
532 fprintf (stderr, _("sorry - this program has been built without plugin support\n"));
539 case 0: /* A long option that just sets a flag. */
542 /* xgettext:c-format */
543 non_fatal (_("illegal option -- '%d'"), c);
548 return &argv[optind];
552 ranlib_main(int argc, char **argv)
554 int arg_index, status = 0;
555 bfd_boolean touch = FALSE;
558 while ((c = getopt_long (argc, argv, "hHvVt", long_options, NULL)) != EOF)
583 print_version ("ranlib");
587 while (arg_index < argc)
590 status |= ranlib_only (argv[arg_index]);
592 status |= ranlib_touch (argv[arg_index]);
599 /* The option parsing should be in its own function.
600 It will be when I have getopt working. */
602 int main (int, char **);
605 main (int argc, char **argv)
610 char *inarch_filename;
613 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
614 setlocale (LC_MESSAGES, "");
616 #if defined (HAVE_SETLOCALE)
617 setlocale (LC_CTYPE, "");
619 bindtextdomain (PACKAGE, LOCALEDIR);
620 textdomain (PACKAGE);
622 program_name = argv[0];
623 xmalloc_set_program_name (program_name);
624 #if BFD_SUPPORTS_PLUGINS
625 bfd_plugin_set_program_name (program_name);
628 expandargv (&argc, &argv);
632 const char *temp = lbasename (program_name);
634 if (strlen (temp) >= 6
635 && FILENAME_CMP (temp + strlen (temp) - 6, "ranlib") == 0)
641 START_PROGRESS (program_name, 0);
644 set_default_bfd_target ();
646 xatexit (remove_output);
648 for (i = 1; i < argc; i++)
649 if (! ar_emul_parse_arg (argv[i]))
655 ranlib_main(argc, argv);
657 if (argc == 2 && strcmp (argv[1], "-M") == 0)
666 argv = decode_options(argc, argv);
672 print_version ("ar");
684 /* We don't use do_quick_append any more. Too many systems
685 expect ar to always rebuild the symbol table even when q is
688 /* We can't write an armap when using ar q, so just do ar r
690 if (operation == quick_append && write_armap)
693 if ((operation == none || operation == print_table)
695 xexit (ranlib_only (argv[arg_index]));
697 if (operation == none)
698 fatal (_("no operation specified"));
700 if (newer_only && operation != replace)
701 fatal (_("`u' is only meaningful with the `r' option."));
703 if (newer_only && deterministic)
704 fatal (_("`u' is not meaningful with the `D' option."));
706 if (postype != pos_default)
707 posname = argv[arg_index++];
709 if (counted_name_mode)
711 if (operation != extract && operation != del)
712 fatal (_("`N' is only meaningful with the `x' and `d' options."));
713 counted_name_counter = atoi (argv[arg_index++]);
714 if (counted_name_counter <= 0)
715 fatal (_("Value for `N' must be positive."));
718 inarch_filename = argv[arg_index++];
720 for (file_count = 0; argv[arg_index + file_count] != NULL; file_count++)
723 files = (file_count > 0) ? argv + arg_index : NULL;
725 arch = open_inarch (inarch_filename,
726 files == NULL ? (char *) NULL : files[0]);
728 if (operation == extract && bfd_is_thin_archive (arch))
729 fatal (_("`x' cannot be used on thin archives."));
734 map_over_members (arch, print_descr, files, file_count);
738 map_over_members (arch, print_contents, files, file_count);
742 map_over_members (arch, extract_file, files, file_count);
747 delete_members (arch, files);
749 output_filename = NULL;
754 move_members (arch, files);
756 output_filename = NULL;
761 if (files != NULL || write_armap > 0)
762 replace_members (arch, files, operation == quick_append);
764 output_filename = NULL;
767 /* Shouldn't happen! */
769 /* xgettext:c-format */
770 fatal (_("internal error -- this option not implemented"));
774 END_PROGRESS (program_name);
781 open_inarch (const char *archive_filename, const char *file)
789 bfd_set_error (bfd_error_no_error);
792 target = plugin_target;
794 if (stat (archive_filename, &sbuf) != 0)
796 #if !defined(__GO32__) || defined(__DJGPP__)
798 /* FIXME: I don't understand why this fragment was ifndef'ed
799 away for __GO32__; perhaps it was in the days of DJGPP v1.x.
800 stat() works just fine in v2.x, so I think this should be
801 removed. For now, I enable it for DJGPP v2. -- EZ. */
803 /* KLUDGE ALERT! Temporary fix until I figger why
804 stat() is wrong ... think it's buried in GO32's IDT - Jax */
806 bfd_fatal (archive_filename);
809 if (!operation_alters_arch)
811 fprintf (stderr, "%s: ", program_name);
812 perror (archive_filename);
817 /* Try to figure out the target to use for the archive from the
818 first object on the list. */
823 obj = bfd_openr (file, target);
826 if (bfd_check_format (obj, bfd_object))
827 target = bfd_get_target (obj);
828 (void) bfd_close (obj);
832 /* Create an empty archive. */
833 arch = bfd_openw (archive_filename, target);
835 || ! bfd_set_format (arch, bfd_archive)
836 || ! bfd_close (arch))
837 bfd_fatal (archive_filename);
838 else if (!silent_create)
839 non_fatal (_("creating %s"), archive_filename);
841 /* If we die creating a new archive, don't leave it around. */
842 output_filename = archive_filename;
845 arch = bfd_openr (archive_filename, target);
849 bfd_fatal (archive_filename);
852 if (! bfd_check_format_matches (arch, bfd_archive, &matching))
854 bfd_nonfatal (archive_filename);
855 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
857 list_matching_formats (matching);
863 last_one = &(arch->archive_next);
864 /* Read all the contents right away, regardless. */
865 for (next_one = bfd_openr_next_archived_file (arch, NULL);
867 next_one = bfd_openr_next_archived_file (arch, next_one))
870 *last_one = next_one;
871 last_one = &next_one->archive_next;
873 *last_one = (bfd *) NULL;
874 if (bfd_get_error () != bfd_error_no_more_archived_files)
880 print_contents (bfd *abfd)
883 char *cbuf = (char *) xmalloc (BUFSIZE);
886 if (bfd_stat_arch_elt (abfd, &buf) != 0)
887 /* xgettext:c-format */
888 fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
891 printf ("\n<%s>\n\n", bfd_get_filename (abfd));
893 bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
896 while (ncopied < size)
900 size_t tocopy = size - ncopied;
901 if (tocopy > BUFSIZE)
904 nread = bfd_bread (cbuf, (bfd_size_type) tocopy, abfd);
906 /* xgettext:c-format */
907 fatal (_("%s is not a valid archive"),
908 bfd_get_filename (bfd_my_archive (abfd)));
910 /* fwrite in mingw32 may return int instead of size_t. Cast the
911 return value to size_t to avoid comparison between signed and
913 if ((size_t) fwrite (cbuf, 1, nread, stdout) != nread)
914 fatal ("stdout: %s", strerror (errno));
920 /* Extract a member of the archive into its own file.
922 We defer opening the new file until after we have read a BUFSIZ chunk of the
923 old one, since we know we have just read the archive header for the old
924 one. Since most members are shorter than BUFSIZ, this means we will read
925 the old header, read the old data, write a new inode for the new file, and
926 write the new data, and be done. This 'optimization' is what comes from
927 sitting next to a bare disk and hearing it every time it seeks. -- Gnu
931 extract_file (bfd *abfd)
934 char *cbuf = (char *) xmalloc (BUFSIZE);
935 size_t nread, tocopy;
940 if (bfd_stat_arch_elt (abfd, &buf) != 0)
941 /* xgettext:c-format */
942 fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
946 printf ("x - %s\n", bfd_get_filename (abfd));
948 bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
953 /* Seems like an abstraction violation, eh? Well it's OK! */
954 output_filename = bfd_get_filename (abfd);
956 ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
959 perror (bfd_get_filename (abfd));
963 output_file = ostream;
966 while (ncopied < size)
968 tocopy = size - ncopied;
969 if (tocopy > BUFSIZE)
972 nread = bfd_bread (cbuf, (bfd_size_type) tocopy, abfd);
974 /* xgettext:c-format */
975 fatal (_("%s is not a valid archive"),
976 bfd_get_filename (bfd_my_archive (abfd)));
978 /* See comment above; this saves disk arm motion */
981 /* Seems like an abstraction violation, eh? Well it's OK! */
982 output_filename = bfd_get_filename (abfd);
984 ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
987 perror (bfd_get_filename (abfd));
991 output_file = ostream;
994 /* fwrite in mingw32 may return int instead of size_t. Cast
995 the return value to size_t to avoid comparison between
996 signed and unsigned values. */
997 if ((size_t) fwrite (cbuf, 1, nread, ostream) != nread)
998 fatal ("%s: %s", output_filename, strerror (errno));
1002 if (ostream != NULL)
1006 output_filename = NULL;
1008 chmod (bfd_get_filename (abfd), buf.st_mode);
1012 /* Set access time to modification time. Only st_mtime is
1013 initialized by bfd_stat_arch_elt. */
1014 buf.st_atime = buf.st_mtime;
1015 set_times (bfd_get_filename (abfd), &buf);
1022 write_archive (bfd *iarch)
1025 char *old_name, *new_name;
1026 bfd *contents_head = iarch->archive_next;
1028 old_name = (char *) xmalloc (strlen (bfd_get_filename (iarch)) + 1);
1029 strcpy (old_name, bfd_get_filename (iarch));
1030 new_name = make_tempname (old_name);
1032 if (new_name == NULL)
1033 bfd_fatal ("could not create temporary file whilst writing archive");
1035 output_filename = new_name;
1037 obfd = bfd_openw (new_name, bfd_get_target (iarch));
1040 bfd_fatal (old_name);
1044 bfd_set_format (obfd, bfd_archive);
1046 /* Request writing the archive symbol table unless we've
1047 been explicitly requested not to. */
1048 obfd->has_armap = write_armap >= 0;
1052 /* This should really use bfd_set_file_flags, but that rejects
1054 obfd->flags |= BFD_TRADITIONAL_FORMAT;
1058 obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
1060 if (make_thin_archive || bfd_is_thin_archive (iarch))
1061 bfd_is_thin_archive (obfd) = 1;
1063 if (!bfd_set_archive_head (obfd, contents_head))
1064 bfd_fatal (old_name);
1066 if (!bfd_close (obfd))
1067 bfd_fatal (old_name);
1070 output_filename = NULL;
1072 /* We don't care if this fails; we might be creating the archive. */
1075 if (smart_rename (new_name, old_name, 0) != 0)
1079 /* Return a pointer to the pointer to the entry which should be rplacd'd
1080 into when altering. DEFAULT_POS should be how to interpret pos_default,
1081 and should be a pos value. */
1084 get_pos_bfd (bfd **contents, enum pos default_pos, const char *default_posname)
1086 bfd **after_bfd = contents;
1088 const char *realposname;
1090 if (postype == pos_default)
1092 realpos = default_pos;
1093 realposname = default_posname;
1098 realposname = posname;
1101 if (realpos == pos_end)
1104 after_bfd = &((*after_bfd)->archive_next);
1108 for (; *after_bfd; after_bfd = &(*after_bfd)->archive_next)
1109 if (FILENAME_CMP ((*after_bfd)->filename, realposname) == 0)
1111 if (realpos == pos_after)
1112 after_bfd = &(*after_bfd)->archive_next;
1120 delete_members (bfd *arch, char **files_to_delete)
1122 bfd **current_ptr_ptr;
1124 bfd_boolean something_changed = FALSE;
1127 for (; *files_to_delete != NULL; ++files_to_delete)
1129 /* In a.out systems, the armap is optional. It's also called
1130 __.SYMDEF. So if the user asked to delete it, we should remember
1131 that fact. This isn't quite right for COFF systems (where
1132 __.SYMDEF might be regular member), but it's very unlikely
1133 to be a problem. FIXME */
1135 if (!strcmp (*files_to_delete, "__.SYMDEF"))
1137 arch->has_armap = FALSE;
1144 current_ptr_ptr = &(arch->archive_next);
1145 while (*current_ptr_ptr)
1147 if (FILENAME_CMP (normalize (*files_to_delete, arch),
1148 (*current_ptr_ptr)->filename) == 0)
1151 if (counted_name_mode
1152 && match_count != counted_name_counter)
1154 /* Counting, and didn't match on count; go on to the
1160 something_changed = TRUE;
1164 *current_ptr_ptr = ((*current_ptr_ptr)->archive_next);
1169 current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1172 if (verbose && !found)
1174 /* xgettext:c-format */
1175 printf (_("No member named `%s'\n"), *files_to_delete);
1181 if (something_changed)
1182 write_archive (arch);
1184 output_filename = NULL;
1188 /* Reposition existing members within an archive */
1191 move_members (bfd *arch, char **files_to_move)
1193 bfd **after_bfd; /* New entries go after this one */
1194 bfd **current_ptr_ptr; /* cdr pointer into contents */
1196 for (; *files_to_move; ++files_to_move)
1198 current_ptr_ptr = &(arch->archive_next);
1199 while (*current_ptr_ptr)
1201 bfd *current_ptr = *current_ptr_ptr;
1202 if (FILENAME_CMP (normalize (*files_to_move, arch),
1203 current_ptr->filename) == 0)
1205 /* Move this file to the end of the list - first cut from
1208 *current_ptr_ptr = current_ptr->archive_next;
1210 /* Now glue to end */
1211 after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1212 link_bfd = *after_bfd;
1213 *after_bfd = current_ptr;
1214 current_ptr->archive_next = link_bfd;
1217 printf ("m - %s\n", *files_to_move);
1222 current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1224 /* xgettext:c-format */
1225 fatal (_("no entry %s in archive %s!"), *files_to_move, arch->filename);
1230 write_archive (arch);
1233 /* Ought to default to replacing in place, but this is existing practice! */
1236 replace_members (bfd *arch, char **files_to_move, bfd_boolean quick)
1238 bfd_boolean changed = FALSE;
1239 bfd **after_bfd; /* New entries go after this one. */
1243 while (files_to_move && *files_to_move)
1247 current_ptr = &arch->archive_next;
1248 while (*current_ptr)
1250 current = *current_ptr;
1252 /* For compatibility with existing ar programs, we
1253 permit the same file to be added multiple times. */
1254 if (FILENAME_CMP (normalize (*files_to_move, arch),
1255 normalize (current->filename, arch)) == 0
1256 && current->arelt_data != NULL)
1260 struct stat fsbuf, asbuf;
1262 if (stat (*files_to_move, &fsbuf) != 0)
1264 if (errno != ENOENT)
1265 bfd_fatal (*files_to_move);
1268 if (bfd_stat_arch_elt (current, &asbuf) != 0)
1269 /* xgettext:c-format */
1270 fatal (_("internal stat error on %s"),
1273 if (fsbuf.st_mtime <= asbuf.st_mtime)
1277 after_bfd = get_pos_bfd (&arch->archive_next, pos_after,
1279 if (ar_emul_replace (after_bfd, *files_to_move,
1282 /* Snip out this entry from the chain. */
1283 *current_ptr = (*current_ptr)->archive_next;
1289 current_ptr = &(current->archive_next);
1293 /* Add to the end of the archive. */
1294 after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1296 if (ar_emul_append (after_bfd, *files_to_move, target,
1297 verbose, make_thin_archive))
1306 write_archive (arch);
1308 output_filename = NULL;
1312 ranlib_only (const char *archname)
1316 if (get_file_size (archname) < 1)
1319 arch = open_inarch (archname, (char *) NULL);
1322 write_archive (arch);
1326 /* Update the timestamp of the symbol map of an archive. */
1329 ranlib_touch (const char *archname)
1332 /* I don't think updating works on go32. */
1333 ranlib_only (archname);
1339 if (get_file_size (archname) < 1)
1341 f = open (archname, O_RDWR | O_BINARY, 0);
1344 bfd_set_error (bfd_error_system_call);
1345 bfd_fatal (archname);
1348 arch = bfd_fdopenr (archname, (const char *) NULL, f);
1350 bfd_fatal (archname);
1351 if (! bfd_check_format_matches (arch, bfd_archive, &matching))
1353 bfd_nonfatal (archname);
1354 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1356 list_matching_formats (matching);
1362 if (! bfd_has_map (arch))
1363 /* xgettext:c-format */
1364 fatal (_("%s: no archive map to update"), archname);
1366 bfd_update_armap_timestamp (arch);
1368 if (! bfd_close (arch))
1369 bfd_fatal (archname);
1374 /* Things which are interesting to map over all or some of the files: */
1377 print_descr (bfd *abfd)
1379 print_arelt_descr (stdout, abfd, verbose);