1 /* ar.c - Archive modify and extract.
2 Copyright (C) 1991-2014 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
22 Bugs: GNU ar used to check file against filesystem in quick_update and
23 replace operations (would check mtime). Doesn't warn when name truncated.
24 No way to specify pos_end. Error messages should be more consistent. */
28 #include "libiberty.h"
35 #include "filenames.h"
40 #define EXT_NAME_LEN 3 /* Bufflen of addition to name if it's MS-DOS. */
42 #define EXT_NAME_LEN 6 /* Ditto for *NIX. */
45 /* Static declarations. */
47 static void mri_emul (void);
48 static const char *normalize (const char *, bfd *);
49 static void remove_output (void);
50 static void map_over_members (bfd *, void (*)(bfd *), char **, int);
51 static void print_contents (bfd * member);
52 static void delete_members (bfd *, char **files_to_delete);
54 static void move_members (bfd *, char **files_to_move);
55 static void replace_members
56 (bfd *, char **files_to_replace, bfd_boolean quick);
57 static void print_descr (bfd * abfd);
58 static void write_archive (bfd *);
59 static int ranlib_only (const char *archname);
60 static int ranlib_touch (const char *archname);
61 static void usage (int);
63 /** Globals and flags. */
67 /* This flag distinguishes between ar and ranlib:
68 1 means this is 'ranlib'; 0 means this is 'ar'.
69 -1 means if we should use argv[0] to decide. */
72 /* Nonzero means don't warn about creating the archive file if necessary. */
73 int silent_create = 0;
75 /* Nonzero means describe each action performed. */
78 /* Nonzero means preserve dates of members when extracting them. */
79 int preserve_dates = 0;
81 /* Nonzero means don't replace existing members whose dates are more recent
82 than the corresponding files. */
85 /* Controls the writing of an archive symbol table (in BSD: a __.SYMDEF
86 member). -1 means we've been explicitly asked to not write a symbol table;
87 +1 means we've been explicitly asked to write it;
89 Traditionally, the default in BSD has been to not write the table.
90 However, for POSIX.2 compliance the default is now to write a symbol table
91 if any of the members are object files. */
94 /* Operate in deterministic mode: write zero for timestamps, uids,
95 and gids for archive members and the archive symbol table, and write
96 consistent file modes. */
97 int deterministic = -1; /* Determinism indeterminate. */
99 /* Nonzero means it's the name of an existing member; position new or moved
100 files with respect to this one. */
101 char *posname = NULL;
103 /* Sez how to use `posname': pos_before means position before that member.
104 pos_after means position after that member. pos_end means always at end.
105 pos_default means default appropriately. For the latter two, `posname'
106 should also be zero. */
109 pos_default, pos_before, pos_after, pos_end
110 } postype = pos_default;
114 none = 0, del, replace, print_table,
115 print_files, extract, move, quick_append
119 get_pos_bfd (bfd **, enum pos, const char *);
121 /* For extract/delete only. If COUNTED_NAME_MODE is TRUE, we only
122 extract the COUNTED_NAME_COUNTER instance of that name. */
123 static bfd_boolean counted_name_mode = 0;
124 static int counted_name_counter = 0;
126 /* Whether to truncate names of files stored in the archive. */
127 static bfd_boolean ar_truncate = FALSE;
129 /* Whether to use a full file name match when searching an archive.
130 This is convenient for archives created by the Microsoft lib
132 static bfd_boolean full_pathname = FALSE;
134 /* Whether to create a "thin" archive (symbol index only -- no files). */
135 static bfd_boolean make_thin_archive = FALSE;
137 static int show_version = 0;
139 static int show_help = 0;
141 #if BFD_SUPPORTS_PLUGINS
142 static const char *plugin_target = "plugin";
144 static const char *plugin_target = NULL;
147 static const char *target = NULL;
149 #define OPTION_PLUGIN 201
150 #define OPTION_TARGET 202
152 static struct option long_options[] =
154 {"help", no_argument, &show_help, 1},
155 {"plugin", required_argument, NULL, OPTION_PLUGIN},
156 {"target", required_argument, NULL, OPTION_TARGET},
157 {"version", no_argument, &show_version, 1},
158 {NULL, no_argument, NULL, 0}
166 interactive = isatty (fileno (stdin));
170 /* If COUNT is 0, then FUNCTION is called once on each entry. If nonzero,
171 COUNT is the length of the FILES chain; FUNCTION is called on each entry
172 whose name matches one in FILES. */
175 map_over_members (bfd *arch, void (*function)(bfd *), char **files, int count)
182 for (head = arch->archive_next; head; head = head->archive_next)
190 /* This may appear to be a baroque way of accomplishing what we want.
191 However we have to iterate over the filenames in order to notice where
192 a filename is requested but does not exist in the archive. Ditto
193 mapping over each file each time -- we want to hack multiple
196 for (head = arch->archive_next; head; head = head->archive_next)
197 head->archive_pass = 0;
199 for (; count > 0; files++, count--)
201 bfd_boolean found = FALSE;
204 for (head = arch->archive_next; head; head = head->archive_next)
206 const char * filename;
209 /* PR binutils/15796: Once an archive element has been matched
210 do not match it again. If the user provides multiple same-named
211 parameters on the command line their intent is to match multiple
212 same-named entries in the archive, not the same entry multiple
214 if (head->archive_pass)
217 filename = head->filename;
218 if (filename == NULL)
220 /* Some archive formats don't get the filenames filled in
221 until the elements are opened. */
223 bfd_stat_arch_elt (head, &buf);
225 else if (bfd_is_thin_archive (arch))
227 /* Thin archives store full pathnames. Need to normalize. */
228 filename = normalize (filename, arch);
232 && !FILENAME_CMP (normalize (*files, arch), filename))
235 if (counted_name_mode
236 && match_count != counted_name_counter)
238 /* Counting, and didn't match on count; go on to the
245 head->archive_pass = 1;
246 /* PR binutils/15796: Once a file has been matched, do not
247 match any more same-named files in the archive. If the
248 user does want to match multiple same-name files in an
249 archive they should provide multiple same-name parameters
250 to the ar command. */
256 /* xgettext:c-format */
257 fprintf (stderr, _("no entry %s in archive\n"), *files);
261 bfd_boolean operation_alters_arch = FALSE;
268 #if BFD_SUPPORTS_PLUGINS
269 /* xgettext:c-format */
270 const char *command_line
271 = _("Usage: %s [emulation options] [-]{dmpqrstx}[abcDfilMNoPsSTuvV]"
272 " [--plugin <name>] [member-name] [count] archive-file file...\n");
275 /* xgettext:c-format */
276 const char *command_line
277 = _("Usage: %s [emulation options] [-]{dmpqrstx}[abcDfilMNoPsSTuvV]"
278 " [member-name] [count] archive-file file...\n");
280 s = help ? stdout : stderr;
282 fprintf (s, command_line, program_name);
284 /* xgettext:c-format */
285 fprintf (s, _(" %s -M [<mri-script]\n"), program_name);
286 fprintf (s, _(" commands:\n"));
287 fprintf (s, _(" d - delete file(s) from the archive\n"));
288 fprintf (s, _(" m[ab] - move file(s) in the archive\n"));
289 fprintf (s, _(" p - print file(s) found in the archive\n"));
290 fprintf (s, _(" q[f] - quick append file(s) to the archive\n"));
291 fprintf (s, _(" r[ab][f][u] - replace existing or insert new file(s) into the archive\n"));
292 fprintf (s, _(" s - act as ranlib\n"));
293 fprintf (s, _(" t - display contents of archive\n"));
294 fprintf (s, _(" x[o] - extract file(s) from the archive\n"));
295 fprintf (s, _(" command specific modifiers:\n"));
296 fprintf (s, _(" [a] - put file(s) after [member-name]\n"));
297 fprintf (s, _(" [b] - put file(s) before [member-name] (same as [i])\n"));
298 if (DEFAULT_AR_DETERMINISTIC)
301 [D] - use zero for timestamps and uids/gids (default)\n"));
303 [U] - use actual timestamps and uids/gids\n"));
308 [D] - use zero for timestamps and uids/gids\n"));
310 [U] - use actual timestamps and uids/gids (default)\n"));
312 fprintf (s, _(" [N] - use instance [count] of name\n"));
313 fprintf (s, _(" [f] - truncate inserted file names\n"));
314 fprintf (s, _(" [P] - use full path names when matching\n"));
315 fprintf (s, _(" [o] - preserve original dates\n"));
316 fprintf (s, _(" [u] - only replace files that are newer than current archive contents\n"));
317 fprintf (s, _(" generic modifiers:\n"));
318 fprintf (s, _(" [c] - do not warn if the library had to be created\n"));
319 fprintf (s, _(" [s] - create an archive index (cf. ranlib)\n"));
320 fprintf (s, _(" [S] - do not build a symbol table\n"));
321 fprintf (s, _(" [T] - make a thin archive\n"));
322 fprintf (s, _(" [v] - be verbose\n"));
323 fprintf (s, _(" [V] - display the version number\n"));
324 fprintf (s, _(" @<file> - read options from <file>\n"));
325 fprintf (s, _(" --target=BFDNAME - specify the target object format as BFDNAME\n"));
326 #if BFD_SUPPORTS_PLUGINS
327 fprintf (s, _(" optional:\n"));
328 fprintf (s, _(" --plugin <p> - load the specified plugin\n"));
333 list_supported_targets (program_name, s);
335 if (REPORT_BUGS_TO[0] && help)
336 fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO);
338 xexit (help ? 0 : 1);
342 ranlib_usage (int help)
346 s = help ? stdout : stderr;
348 /* xgettext:c-format */
349 fprintf (s, _("Usage: %s [options] archive\n"), program_name);
350 fprintf (s, _(" Generate an index to speed access to archives\n"));
351 fprintf (s, _(" The options are:\n\
352 @<file> Read options from <file>\n"));
353 #if BFD_SUPPORTS_PLUGINS
355 --plugin <name> Load the specified plugin\n"));
357 if (DEFAULT_AR_DETERMINISTIC)
359 -D Use zero for symbol map timestamp (default)\n\
360 -U Use an actual symbol map timestamp\n"));
363 -D Use zero for symbol map timestamp\n\
364 -U Use actual symbol map timestamp (default)\n"));
366 -t Update the archive's symbol map timestamp\n\
367 -h --help Print this help message\n\
368 -v --version Print version information\n"));
370 list_supported_targets (program_name, s);
372 if (REPORT_BUGS_TO[0] && help)
373 fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO);
375 xexit (help ? 0 : 1);
378 /* Normalize a file name specified on the command line into a file
379 name which we will use in an archive. */
382 normalize (const char *file, bfd *abfd)
384 const char *filename;
389 filename = lbasename (file);
393 && strlen (filename) > abfd->xvec->ar_max_namelen)
398 s = (char *) xmalloc (abfd->xvec->ar_max_namelen + 1);
399 memcpy (s, filename, abfd->xvec->ar_max_namelen);
400 s[abfd->xvec->ar_max_namelen] = '\0';
407 /* Remove any output file. This is only called via xatexit. */
409 static const char *output_filename = NULL;
410 static FILE *output_file = NULL;
411 static bfd *output_bfd = NULL;
416 if (output_filename != NULL)
418 if (output_bfd != NULL)
419 bfd_cache_close (output_bfd);
420 if (output_file != NULL)
421 fclose (output_file);
422 unlink_if_ordinary (output_filename);
427 decode_options (int argc, char **argv)
431 /* Convert old-style tar call by exploding option element and rearranging
432 options accordingly. */
434 if (argc > 1 && argv[1][0] != '-')
436 int new_argc; /* argc value for rearranged arguments */
437 char **new_argv; /* argv value for rearranged arguments */
438 char *const *in; /* cursor into original argv */
439 char **out; /* cursor into rearranged argv */
440 const char *letter; /* cursor into old option letters */
441 char buffer[3]; /* constructed option buffer */
443 /* Initialize a constructed option. */
448 /* Allocate a new argument array, and copy program name in it. */
450 new_argc = argc - 1 + strlen (argv[1]);
451 new_argv = xmalloc ((new_argc + 1) * sizeof (*argv));
456 /* Copy each old letter option as a separate option. */
458 for (letter = *in++; *letter; letter++)
461 *out++ = xstrdup (buffer);
464 /* Copy all remaining options. */
466 while (in < argv + argc)
470 /* Replace the old option list by the new one. */
476 while ((c = getopt_long (argc, argv, "hdmpqrtxlcoVsSuvabiMNfPTDU",
477 long_options, NULL)) != EOF)
488 if (operation != none)
489 fatal (_("two different operation options specified"));
500 operation_alters_arch = TRUE;
504 operation_alters_arch = TRUE;
507 operation = print_files;
510 operation = quick_append;
511 operation_alters_arch = TRUE;
515 operation_alters_arch = TRUE;
518 operation = print_table;
550 postype = pos_before;
553 postype = pos_before;
559 counted_name_mode = TRUE;
565 full_pathname = TRUE;
568 make_thin_archive = TRUE;
571 deterministic = TRUE;
574 deterministic = FALSE;
577 #if BFD_SUPPORTS_PLUGINS
578 bfd_plugin_set_plugin (optarg);
580 fprintf (stderr, _("sorry - this program has been built without plugin support\n"));
587 case 0: /* A long option that just sets a flag. */
594 return &argv[optind];
597 /* If neither -D nor -U was specified explicitly,
598 then use the configured default. */
600 default_deterministic (void)
602 if (deterministic < 0)
603 deterministic = DEFAULT_AR_DETERMINISTIC;
607 ranlib_main (int argc, char **argv)
609 int arg_index, status = 0;
610 bfd_boolean touch = FALSE;
613 while ((c = getopt_long (argc, argv, "DhHUvVt", long_options, NULL)) != EOF)
618 deterministic = TRUE;
621 deterministic = FALSE;
635 /* PR binutils/13493: Support plugins. */
637 #if BFD_SUPPORTS_PLUGINS
638 bfd_plugin_set_plugin (optarg);
640 fprintf (stderr, _("sorry - this program has been built without plugin support\n"));
654 print_version ("ranlib");
656 default_deterministic ();
660 while (arg_index < argc)
663 status |= ranlib_only (argv[arg_index]);
665 status |= ranlib_touch (argv[arg_index]);
672 int main (int, char **);
675 main (int argc, char **argv)
680 char *inarch_filename;
683 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
684 setlocale (LC_MESSAGES, "");
686 #if defined (HAVE_SETLOCALE)
687 setlocale (LC_CTYPE, "");
689 bindtextdomain (PACKAGE, LOCALEDIR);
690 textdomain (PACKAGE);
692 program_name = argv[0];
693 xmalloc_set_program_name (program_name);
694 #if BFD_SUPPORTS_PLUGINS
695 bfd_plugin_set_program_name (program_name);
698 expandargv (&argc, &argv);
702 const char *temp = lbasename (program_name);
704 if (strlen (temp) >= 6
705 && FILENAME_CMP (temp + strlen (temp) - 6, "ranlib") == 0)
711 START_PROGRESS (program_name, 0);
714 set_default_bfd_target ();
716 xatexit (remove_output);
718 for (i = 1; i < argc; i++)
719 if (! ar_emul_parse_arg (argv[i]))
725 ranlib_main (argc, argv);
730 argv = decode_options (argc, argv);
736 print_version ("ar");
742 default_deterministic ();
749 /* We don't use do_quick_append any more. Too many systems
750 expect ar to always rebuild the symbol table even when q is
753 /* We can't write an armap when using ar q, so just do ar r
755 if (operation == quick_append && write_armap)
758 if ((operation == none || operation == print_table)
760 xexit (ranlib_only (argv[arg_index]));
762 if (operation == none)
763 fatal (_("no operation specified"));
765 if (newer_only && operation != replace)
766 fatal (_("`u' is only meaningful with the `r' option."));
768 if (newer_only && deterministic > 0)
769 fatal (_("`u' is not meaningful with the `D' option."));
771 if (newer_only && deterministic < 0 && DEFAULT_AR_DETERMINISTIC)
773 `u' modifier ignored since `D' is the default (see `U')"));
775 default_deterministic ();
777 if (postype != pos_default)
778 posname = argv[arg_index++];
780 if (counted_name_mode)
782 if (operation != extract && operation != del)
783 fatal (_("`N' is only meaningful with the `x' and `d' options."));
784 counted_name_counter = atoi (argv[arg_index++]);
785 if (counted_name_counter <= 0)
786 fatal (_("Value for `N' must be positive."));
789 inarch_filename = argv[arg_index++];
791 for (file_count = 0; argv[arg_index + file_count] != NULL; file_count++)
794 files = (file_count > 0) ? argv + arg_index : NULL;
796 arch = open_inarch (inarch_filename,
797 files == NULL ? (char *) NULL : files[0]);
799 if (operation == extract && bfd_is_thin_archive (arch))
800 fatal (_("`x' cannot be used on thin archives."));
805 map_over_members (arch, print_descr, files, file_count);
809 map_over_members (arch, print_contents, files, file_count);
813 map_over_members (arch, extract_file, files, file_count);
818 delete_members (arch, files);
820 output_filename = NULL;
824 /* PR 12558: Creating and moving at the same time does
825 not make sense. Just create the archive instead. */
829 move_members (arch, files);
831 output_filename = NULL;
838 if (files != NULL || write_armap > 0)
839 replace_members (arch, files, operation == quick_append);
841 output_filename = NULL;
844 /* Shouldn't happen! */
846 /* xgettext:c-format */
847 fatal (_("internal error -- this option not implemented"));
851 END_PROGRESS (program_name);
858 open_inarch (const char *archive_filename, const char *file)
866 bfd_set_error (bfd_error_no_error);
869 target = plugin_target;
871 if (stat (archive_filename, &sbuf) != 0)
873 #if !defined(__GO32__) || defined(__DJGPP__)
875 /* FIXME: I don't understand why this fragment was ifndef'ed
876 away for __GO32__; perhaps it was in the days of DJGPP v1.x.
877 stat() works just fine in v2.x, so I think this should be
878 removed. For now, I enable it for DJGPP v2. -- EZ. */
880 /* KLUDGE ALERT! Temporary fix until I figger why
881 stat() is wrong ... think it's buried in GO32's IDT - Jax */
883 bfd_fatal (archive_filename);
886 if (!operation_alters_arch)
888 fprintf (stderr, "%s: ", program_name);
889 perror (archive_filename);
894 /* If the target isn't set, try to figure out the target to use
895 for the archive from the first object on the list. */
896 if (target == NULL && file != NULL)
900 obj = bfd_openr (file, target);
903 if (bfd_check_format (obj, bfd_object))
904 target = bfd_get_target (obj);
905 (void) bfd_close (obj);
909 /* Create an empty archive. */
910 arch = bfd_openw (archive_filename, target);
912 || ! bfd_set_format (arch, bfd_archive)
913 || ! bfd_close (arch))
914 bfd_fatal (archive_filename);
915 else if (!silent_create)
916 non_fatal (_("creating %s"), archive_filename);
918 /* If we die creating a new archive, don't leave it around. */
919 output_filename = archive_filename;
922 arch = bfd_openr (archive_filename, target);
926 bfd_fatal (archive_filename);
929 if (! bfd_check_format_matches (arch, bfd_archive, &matching))
931 bfd_nonfatal (archive_filename);
932 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
934 list_matching_formats (matching);
940 if ((operation == replace || operation == quick_append)
941 && bfd_openr_next_archived_file (arch, NULL) != NULL)
943 /* PR 15140: Catch attempts to convert a normal
944 archive into a thin archive or vice versa. */
945 if (make_thin_archive && ! bfd_is_thin_archive (arch))
947 fatal (_("Cannot convert existing library %s to thin format"),
948 bfd_get_filename (arch));
951 else if (! make_thin_archive && bfd_is_thin_archive (arch))
953 fatal (_("Cannot convert existing thin library %s to normal format"),
954 bfd_get_filename (arch));
959 last_one = &(arch->archive_next);
960 /* Read all the contents right away, regardless. */
961 for (next_one = bfd_openr_next_archived_file (arch, NULL);
963 next_one = bfd_openr_next_archived_file (arch, next_one))
966 *last_one = next_one;
967 last_one = &next_one->archive_next;
969 *last_one = (bfd *) NULL;
970 if (bfd_get_error () != bfd_error_no_more_archived_files)
976 print_contents (bfd *abfd)
978 bfd_size_type ncopied = 0;
980 char *cbuf = (char *) xmalloc (BUFSIZE);
983 if (bfd_stat_arch_elt (abfd, &buf) != 0)
984 /* xgettext:c-format */
985 fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
988 printf ("\n<%s>\n\n", bfd_get_filename (abfd));
990 bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
993 while (ncopied < size)
996 bfd_size_type tocopy = size - ncopied;
998 if (tocopy > BUFSIZE)
1001 nread = bfd_bread (cbuf, tocopy, abfd);
1002 if (nread != tocopy)
1003 /* xgettext:c-format */
1004 fatal (_("%s is not a valid archive"),
1005 bfd_get_filename (bfd_my_archive (abfd)));
1007 /* fwrite in mingw32 may return int instead of bfd_size_type. Cast the
1008 return value to bfd_size_type to avoid comparison between signed and
1010 if ((bfd_size_type) fwrite (cbuf, 1, nread, stdout) != nread)
1011 fatal ("stdout: %s", strerror (errno));
1017 /* Extract a member of the archive into its own file.
1019 We defer opening the new file until after we have read a BUFSIZ chunk of the
1020 old one, since we know we have just read the archive header for the old
1021 one. Since most members are shorter than BUFSIZ, this means we will read
1022 the old header, read the old data, write a new inode for the new file, and
1023 write the new data, and be done. This 'optimization' is what comes from
1024 sitting next to a bare disk and hearing it every time it seeks. -- Gnu
1028 extract_file (bfd *abfd)
1031 char *cbuf = (char *) xmalloc (BUFSIZE);
1032 bfd_size_type nread, tocopy;
1033 bfd_size_type ncopied = 0;
1037 /* PR binutils/17533: Do not allow directory traversal
1038 outside of the current directory tree. */
1039 if (! is_valid_archive_path (bfd_get_filename (abfd)))
1041 non_fatal (_("illegal pathname found in archive member: %s"),
1042 bfd_get_filename (abfd));
1046 if (bfd_stat_arch_elt (abfd, &buf) != 0)
1047 /* xgettext:c-format */
1048 fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
1052 printf ("x - %s\n", bfd_get_filename (abfd));
1054 bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
1059 /* Seems like an abstraction violation, eh? Well it's OK! */
1060 output_filename = bfd_get_filename (abfd);
1062 ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
1063 if (ostream == NULL)
1065 perror (bfd_get_filename (abfd));
1069 output_file = ostream;
1072 while (ncopied < size)
1074 tocopy = size - ncopied;
1075 if (tocopy > BUFSIZE)
1078 nread = bfd_bread (cbuf, tocopy, abfd);
1079 if (nread != tocopy)
1080 /* xgettext:c-format */
1081 fatal (_("%s is not a valid archive"),
1082 bfd_get_filename (bfd_my_archive (abfd)));
1084 /* See comment above; this saves disk arm motion */
1085 if (ostream == NULL)
1087 /* Seems like an abstraction violation, eh? Well it's OK! */
1088 output_filename = bfd_get_filename (abfd);
1090 ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
1091 if (ostream == NULL)
1093 perror (bfd_get_filename (abfd));
1097 output_file = ostream;
1100 /* fwrite in mingw32 may return int instead of bfd_size_type. Cast
1101 the return value to bfd_size_type to avoid comparison between
1102 signed and unsigned values. */
1103 if ((bfd_size_type) fwrite (cbuf, 1, nread, ostream) != nread)
1104 fatal ("%s: %s", output_filename, strerror (errno));
1108 if (ostream != NULL)
1112 output_filename = NULL;
1114 chmod (bfd_get_filename (abfd), buf.st_mode);
1118 /* Set access time to modification time. Only st_mtime is
1119 initialized by bfd_stat_arch_elt. */
1120 buf.st_atime = buf.st_mtime;
1121 set_times (bfd_get_filename (abfd), &buf);
1128 write_archive (bfd *iarch)
1131 char *old_name, *new_name;
1132 bfd *contents_head = iarch->archive_next;
1134 old_name = (char *) xmalloc (strlen (bfd_get_filename (iarch)) + 1);
1135 strcpy (old_name, bfd_get_filename (iarch));
1136 new_name = make_tempname (old_name);
1138 if (new_name == NULL)
1139 bfd_fatal (_("could not create temporary file whilst writing archive"));
1141 output_filename = new_name;
1143 obfd = bfd_openw (new_name, bfd_get_target (iarch));
1146 bfd_fatal (old_name);
1150 bfd_set_format (obfd, bfd_archive);
1152 /* Request writing the archive symbol table unless we've
1153 been explicitly requested not to. */
1154 obfd->has_armap = write_armap >= 0;
1158 /* This should really use bfd_set_file_flags, but that rejects
1160 obfd->flags |= BFD_TRADITIONAL_FORMAT;
1164 obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
1166 if (make_thin_archive || bfd_is_thin_archive (iarch))
1167 bfd_is_thin_archive (obfd) = 1;
1169 if (!bfd_set_archive_head (obfd, contents_head))
1170 bfd_fatal (old_name);
1172 if (!bfd_close (obfd))
1173 bfd_fatal (old_name);
1176 output_filename = NULL;
1178 /* We don't care if this fails; we might be creating the archive. */
1181 if (smart_rename (new_name, old_name, 0) != 0)
1186 /* Return a pointer to the pointer to the entry which should be rplacd'd
1187 into when altering. DEFAULT_POS should be how to interpret pos_default,
1188 and should be a pos value. */
1191 get_pos_bfd (bfd **contents, enum pos default_pos, const char *default_posname)
1193 bfd **after_bfd = contents;
1195 const char *realposname;
1197 if (postype == pos_default)
1199 realpos = default_pos;
1200 realposname = default_posname;
1205 realposname = posname;
1208 if (realpos == pos_end)
1211 after_bfd = &((*after_bfd)->archive_next);
1215 for (; *after_bfd; after_bfd = &(*after_bfd)->archive_next)
1216 if (FILENAME_CMP ((*after_bfd)->filename, realposname) == 0)
1218 if (realpos == pos_after)
1219 after_bfd = &(*after_bfd)->archive_next;
1227 delete_members (bfd *arch, char **files_to_delete)
1229 bfd **current_ptr_ptr;
1231 bfd_boolean something_changed = FALSE;
1234 for (; *files_to_delete != NULL; ++files_to_delete)
1236 /* In a.out systems, the armap is optional. It's also called
1237 __.SYMDEF. So if the user asked to delete it, we should remember
1238 that fact. This isn't quite right for COFF systems (where
1239 __.SYMDEF might be regular member), but it's very unlikely
1240 to be a problem. FIXME */
1242 if (!strcmp (*files_to_delete, "__.SYMDEF"))
1244 arch->has_armap = FALSE;
1251 current_ptr_ptr = &(arch->archive_next);
1252 while (*current_ptr_ptr)
1254 if (FILENAME_CMP (normalize (*files_to_delete, arch),
1255 (*current_ptr_ptr)->filename) == 0)
1258 if (counted_name_mode
1259 && match_count != counted_name_counter)
1261 /* Counting, and didn't match on count; go on to the
1267 something_changed = TRUE;
1271 *current_ptr_ptr = ((*current_ptr_ptr)->archive_next);
1276 current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1279 if (verbose && !found)
1281 /* xgettext:c-format */
1282 printf (_("No member named `%s'\n"), *files_to_delete);
1288 if (something_changed)
1289 write_archive (arch);
1291 output_filename = NULL;
1295 /* Reposition existing members within an archive */
1298 move_members (bfd *arch, char **files_to_move)
1300 bfd **after_bfd; /* New entries go after this one */
1301 bfd **current_ptr_ptr; /* cdr pointer into contents */
1303 for (; *files_to_move; ++files_to_move)
1305 current_ptr_ptr = &(arch->archive_next);
1306 while (*current_ptr_ptr)
1308 bfd *current_ptr = *current_ptr_ptr;
1309 if (FILENAME_CMP (normalize (*files_to_move, arch),
1310 current_ptr->filename) == 0)
1312 /* Move this file to the end of the list - first cut from
1315 *current_ptr_ptr = current_ptr->archive_next;
1317 /* Now glue to end */
1318 after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1319 link_bfd = *after_bfd;
1320 *after_bfd = current_ptr;
1321 current_ptr->archive_next = link_bfd;
1324 printf ("m - %s\n", *files_to_move);
1329 current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1331 /* xgettext:c-format */
1332 fatal (_("no entry %s in archive %s!"), *files_to_move, arch->filename);
1337 write_archive (arch);
1340 /* Ought to default to replacing in place, but this is existing practice! */
1343 replace_members (bfd *arch, char **files_to_move, bfd_boolean quick)
1345 bfd_boolean changed = FALSE;
1346 bfd **after_bfd; /* New entries go after this one. */
1350 while (files_to_move && *files_to_move)
1354 current_ptr = &arch->archive_next;
1355 while (*current_ptr)
1357 current = *current_ptr;
1359 /* For compatibility with existing ar programs, we
1360 permit the same file to be added multiple times. */
1361 if (FILENAME_CMP (normalize (*files_to_move, arch),
1362 normalize (current->filename, arch)) == 0
1363 && current->arelt_data != NULL)
1367 struct stat fsbuf, asbuf;
1369 if (stat (*files_to_move, &fsbuf) != 0)
1371 if (errno != ENOENT)
1372 bfd_fatal (*files_to_move);
1375 if (bfd_stat_arch_elt (current, &asbuf) != 0)
1376 /* xgettext:c-format */
1377 fatal (_("internal stat error on %s"),
1380 if (fsbuf.st_mtime <= asbuf.st_mtime)
1384 after_bfd = get_pos_bfd (&arch->archive_next, pos_after,
1386 if (ar_emul_replace (after_bfd, *files_to_move,
1389 /* Snip out this entry from the chain. */
1390 *current_ptr = (*current_ptr)->archive_next;
1396 current_ptr = &(current->archive_next);
1400 /* Add to the end of the archive. */
1401 after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1403 if (ar_emul_append (after_bfd, *files_to_move, target,
1404 verbose, make_thin_archive))
1413 write_archive (arch);
1415 output_filename = NULL;
1419 ranlib_only (const char *archname)
1423 if (get_file_size (archname) < 1)
1426 arch = open_inarch (archname, (char *) NULL);
1429 write_archive (arch);
1433 /* Update the timestamp of the symbol map of an archive. */
1436 ranlib_touch (const char *archname)
1439 /* I don't think updating works on go32. */
1440 ranlib_only (archname);
1446 if (get_file_size (archname) < 1)
1448 f = open (archname, O_RDWR | O_BINARY, 0);
1451 bfd_set_error (bfd_error_system_call);
1452 bfd_fatal (archname);
1455 arch = bfd_fdopenr (archname, (const char *) NULL, f);
1457 bfd_fatal (archname);
1458 if (! bfd_check_format_matches (arch, bfd_archive, &matching))
1460 bfd_nonfatal (archname);
1461 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1463 list_matching_formats (matching);
1469 if (! bfd_has_map (arch))
1470 /* xgettext:c-format */
1471 fatal (_("%s: no archive map to update"), archname);
1474 arch->flags |= BFD_DETERMINISTIC_OUTPUT;
1476 bfd_update_armap_timestamp (arch);
1478 if (! bfd_close (arch))
1479 bfd_fatal (archname);
1484 /* Things which are interesting to map over all or some of the files: */
1487 print_descr (bfd *abfd)
1489 print_arelt_descr (stdout, abfd, verbose);