1 /* ar.c - Archive modify and extract.
2 Copyright (C) 1991-2017 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"
34 #include "filenames.h"
36 #include "plugin-api.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 bfd_set_error_program_name (program_name);
695 #if BFD_SUPPORTS_PLUGINS
696 bfd_plugin_set_program_name (program_name);
699 expandargv (&argc, &argv);
703 const char *temp = lbasename (program_name);
705 if (strlen (temp) >= 6
706 && FILENAME_CMP (temp + strlen (temp) - 6, "ranlib") == 0)
712 START_PROGRESS (program_name, 0);
715 set_default_bfd_target ();
717 xatexit (remove_output);
719 for (i = 1; i < argc; i++)
720 if (! ar_emul_parse_arg (argv[i]))
726 ranlib_main (argc, argv);
731 argv = decode_options (argc, argv);
737 print_version ("ar");
743 default_deterministic ();
750 /* We don't use do_quick_append any more. Too many systems
751 expect ar to always rebuild the symbol table even when q is
754 /* We can't write an armap when using ar q, so just do ar r
756 if (operation == quick_append && write_armap)
759 if ((operation == none || operation == print_table)
761 xexit (ranlib_only (argv[arg_index]));
763 if (operation == none)
764 fatal (_("no operation specified"));
766 if (newer_only && operation != replace)
767 fatal (_("`u' is only meaningful with the `r' option."));
769 if (newer_only && deterministic > 0)
770 fatal (_("`u' is not meaningful with the `D' option."));
772 if (newer_only && deterministic < 0 && DEFAULT_AR_DETERMINISTIC)
774 `u' modifier ignored since `D' is the default (see `U')"));
776 default_deterministic ();
778 if (postype != pos_default)
779 posname = argv[arg_index++];
781 if (counted_name_mode)
783 if (operation != extract && operation != del)
784 fatal (_("`N' is only meaningful with the `x' and `d' options."));
785 counted_name_counter = atoi (argv[arg_index++]);
786 if (counted_name_counter <= 0)
787 fatal (_("Value for `N' must be positive."));
790 inarch_filename = argv[arg_index++];
791 if (inarch_filename == NULL)
794 for (file_count = 0; argv[arg_index + file_count] != NULL; file_count++)
797 files = (file_count > 0) ? argv + arg_index : NULL;
799 arch = open_inarch (inarch_filename,
800 files == NULL ? (char *) NULL : files[0]);
802 if (operation == extract && bfd_is_thin_archive (arch))
803 fatal (_("`x' cannot be used on thin archives."));
808 map_over_members (arch, print_descr, files, file_count);
812 map_over_members (arch, print_contents, files, file_count);
816 map_over_members (arch, extract_file, files, file_count);
821 delete_members (arch, files);
823 output_filename = NULL;
827 /* PR 12558: Creating and moving at the same time does
828 not make sense. Just create the archive instead. */
832 move_members (arch, files);
834 output_filename = NULL;
841 if (files != NULL || write_armap > 0)
842 replace_members (arch, files, operation == quick_append);
844 output_filename = NULL;
847 /* Shouldn't happen! */
849 /* xgettext:c-format */
850 fatal (_("internal error -- this option not implemented"));
854 END_PROGRESS (program_name);
861 open_inarch (const char *archive_filename, const char *file)
869 bfd_set_error (bfd_error_no_error);
872 target = plugin_target;
874 if (stat (archive_filename, &sbuf) != 0)
876 #if !defined(__GO32__) || defined(__DJGPP__)
878 /* FIXME: I don't understand why this fragment was ifndef'ed
879 away for __GO32__; perhaps it was in the days of DJGPP v1.x.
880 stat() works just fine in v2.x, so I think this should be
881 removed. For now, I enable it for DJGPP v2. -- EZ. */
883 /* KLUDGE ALERT! Temporary fix until I figger why
884 stat() is wrong ... think it's buried in GO32's IDT - Jax */
886 bfd_fatal (archive_filename);
889 if (!operation_alters_arch)
891 fprintf (stderr, "%s: ", program_name);
892 perror (archive_filename);
897 /* If the target isn't set, try to figure out the target to use
898 for the archive from the first object on the list. */
899 if (target == NULL && file != NULL)
903 obj = bfd_openr (file, target);
906 if (bfd_check_format (obj, bfd_object))
907 target = bfd_get_target (obj);
908 (void) bfd_close (obj);
912 /* Create an empty archive. */
913 arch = bfd_openw (archive_filename, target);
915 || ! bfd_set_format (arch, bfd_archive)
916 || ! bfd_close (arch))
917 bfd_fatal (archive_filename);
918 else if (!silent_create)
919 non_fatal (_("creating %s"), archive_filename);
921 /* If we die creating a new archive, don't leave it around. */
922 output_filename = archive_filename;
925 arch = bfd_openr (archive_filename, target);
929 bfd_fatal (archive_filename);
932 if (! bfd_check_format_matches (arch, bfd_archive, &matching))
934 bfd_nonfatal (archive_filename);
935 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
937 list_matching_formats (matching);
943 if ((operation == replace || operation == quick_append)
944 && bfd_openr_next_archived_file (arch, NULL) != NULL)
946 /* PR 15140: Catch attempts to convert a normal
947 archive into a thin archive or vice versa. */
948 if (make_thin_archive && ! bfd_is_thin_archive (arch))
950 fatal (_("Cannot convert existing library %s to thin format"),
951 bfd_get_filename (arch));
954 else if (! make_thin_archive && bfd_is_thin_archive (arch))
956 fatal (_("Cannot convert existing thin library %s to normal format"),
957 bfd_get_filename (arch));
962 last_one = &(arch->archive_next);
963 /* Read all the contents right away, regardless. */
964 for (next_one = bfd_openr_next_archived_file (arch, NULL);
966 next_one = bfd_openr_next_archived_file (arch, next_one))
969 *last_one = next_one;
970 last_one = &next_one->archive_next;
972 *last_one = (bfd *) NULL;
973 if (bfd_get_error () != bfd_error_no_more_archived_files)
979 print_contents (bfd *abfd)
981 bfd_size_type ncopied = 0;
983 char *cbuf = (char *) xmalloc (BUFSIZE);
986 if (bfd_stat_arch_elt (abfd, &buf) != 0)
987 /* xgettext:c-format */
988 fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
991 printf ("\n<%s>\n\n", bfd_get_filename (abfd));
993 bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
996 while (ncopied < size)
999 bfd_size_type tocopy = size - ncopied;
1001 if (tocopy > BUFSIZE)
1004 nread = bfd_bread (cbuf, tocopy, abfd);
1005 if (nread != tocopy)
1006 /* xgettext:c-format */
1007 fatal (_("%s is not a valid archive"),
1008 bfd_get_filename (abfd->my_archive));
1010 /* fwrite in mingw32 may return int instead of bfd_size_type. Cast the
1011 return value to bfd_size_type to avoid comparison between signed and
1013 if ((bfd_size_type) fwrite (cbuf, 1, nread, stdout) != nread)
1014 fatal ("stdout: %s", strerror (errno));
1020 /* Extract a member of the archive into its own file.
1022 We defer opening the new file until after we have read a BUFSIZ chunk of the
1023 old one, since we know we have just read the archive header for the old
1024 one. Since most members are shorter than BUFSIZ, this means we will read
1025 the old header, read the old data, write a new inode for the new file, and
1026 write the new data, and be done. This 'optimization' is what comes from
1027 sitting next to a bare disk and hearing it every time it seeks. -- Gnu
1031 extract_file (bfd *abfd)
1034 char *cbuf = (char *) xmalloc (BUFSIZE);
1035 bfd_size_type nread, tocopy;
1036 bfd_size_type ncopied = 0;
1040 /* PR binutils/17533: Do not allow directory traversal
1041 outside of the current directory tree. */
1042 if (! is_valid_archive_path (bfd_get_filename (abfd)))
1044 non_fatal (_("illegal pathname found in archive member: %s"),
1045 bfd_get_filename (abfd));
1050 if (bfd_stat_arch_elt (abfd, &buf) != 0)
1051 /* xgettext:c-format */
1052 fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
1056 printf ("x - %s\n", bfd_get_filename (abfd));
1058 bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
1063 /* Seems like an abstraction violation, eh? Well it's OK! */
1064 output_filename = bfd_get_filename (abfd);
1066 ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
1067 if (ostream == NULL)
1069 perror (bfd_get_filename (abfd));
1073 output_file = ostream;
1076 while (ncopied < size)
1078 tocopy = size - ncopied;
1079 if (tocopy > BUFSIZE)
1082 nread = bfd_bread (cbuf, tocopy, abfd);
1083 if (nread != tocopy)
1084 /* xgettext:c-format */
1085 fatal (_("%s is not a valid archive"),
1086 bfd_get_filename (abfd->my_archive));
1088 /* See comment above; this saves disk arm motion */
1089 if (ostream == NULL)
1091 /* Seems like an abstraction violation, eh? Well it's OK! */
1092 output_filename = bfd_get_filename (abfd);
1094 ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
1095 if (ostream == NULL)
1097 perror (bfd_get_filename (abfd));
1101 output_file = ostream;
1104 /* fwrite in mingw32 may return int instead of bfd_size_type. Cast
1105 the return value to bfd_size_type to avoid comparison between
1106 signed and unsigned values. */
1107 if ((bfd_size_type) fwrite (cbuf, 1, nread, ostream) != nread)
1108 fatal ("%s: %s", output_filename, strerror (errno));
1112 if (ostream != NULL)
1116 output_filename = NULL;
1118 chmod (bfd_get_filename (abfd), buf.st_mode);
1122 /* Set access time to modification time. Only st_mtime is
1123 initialized by bfd_stat_arch_elt. */
1124 buf.st_atime = buf.st_mtime;
1125 set_times (bfd_get_filename (abfd), &buf);
1132 write_archive (bfd *iarch)
1135 char *old_name, *new_name;
1136 bfd *contents_head = iarch->archive_next;
1138 old_name = (char *) xmalloc (strlen (bfd_get_filename (iarch)) + 1);
1139 strcpy (old_name, bfd_get_filename (iarch));
1140 new_name = make_tempname (old_name);
1142 if (new_name == NULL)
1143 bfd_fatal (_("could not create temporary file whilst writing archive"));
1145 output_filename = new_name;
1147 obfd = bfd_openw (new_name, bfd_get_target (iarch));
1150 bfd_fatal (old_name);
1154 bfd_set_format (obfd, bfd_archive);
1156 /* Request writing the archive symbol table unless we've
1157 been explicitly requested not to. */
1158 obfd->has_armap = write_armap >= 0;
1162 /* This should really use bfd_set_file_flags, but that rejects
1164 obfd->flags |= BFD_TRADITIONAL_FORMAT;
1168 obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
1170 if (make_thin_archive || bfd_is_thin_archive (iarch))
1171 bfd_is_thin_archive (obfd) = 1;
1173 if (!bfd_set_archive_head (obfd, contents_head))
1174 bfd_fatal (old_name);
1176 if (!bfd_close (obfd))
1177 bfd_fatal (old_name);
1180 output_filename = NULL;
1182 /* We don't care if this fails; we might be creating the archive. */
1185 if (smart_rename (new_name, old_name, 0) != 0)
1190 /* Return a pointer to the pointer to the entry which should be rplacd'd
1191 into when altering. DEFAULT_POS should be how to interpret pos_default,
1192 and should be a pos value. */
1195 get_pos_bfd (bfd **contents, enum pos default_pos, const char *default_posname)
1197 bfd **after_bfd = contents;
1199 const char *realposname;
1201 if (postype == pos_default)
1203 realpos = default_pos;
1204 realposname = default_posname;
1209 realposname = posname;
1212 if (realpos == pos_end)
1215 after_bfd = &((*after_bfd)->archive_next);
1219 for (; *after_bfd; after_bfd = &(*after_bfd)->archive_next)
1220 if (FILENAME_CMP ((*after_bfd)->filename, realposname) == 0)
1222 if (realpos == pos_after)
1223 after_bfd = &(*after_bfd)->archive_next;
1231 delete_members (bfd *arch, char **files_to_delete)
1233 bfd **current_ptr_ptr;
1235 bfd_boolean something_changed = FALSE;
1238 for (; *files_to_delete != NULL; ++files_to_delete)
1240 /* In a.out systems, the armap is optional. It's also called
1241 __.SYMDEF. So if the user asked to delete it, we should remember
1242 that fact. This isn't quite right for COFF systems (where
1243 __.SYMDEF might be regular member), but it's very unlikely
1244 to be a problem. FIXME */
1246 if (!strcmp (*files_to_delete, "__.SYMDEF"))
1248 arch->has_armap = FALSE;
1255 current_ptr_ptr = &(arch->archive_next);
1256 while (*current_ptr_ptr)
1258 if (FILENAME_CMP (normalize (*files_to_delete, arch),
1259 (*current_ptr_ptr)->filename) == 0)
1262 if (counted_name_mode
1263 && match_count != counted_name_counter)
1265 /* Counting, and didn't match on count; go on to the
1271 something_changed = TRUE;
1275 *current_ptr_ptr = ((*current_ptr_ptr)->archive_next);
1280 current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1283 if (verbose && !found)
1285 /* xgettext:c-format */
1286 printf (_("No member named `%s'\n"), *files_to_delete);
1292 if (something_changed)
1293 write_archive (arch);
1295 output_filename = NULL;
1299 /* Reposition existing members within an archive */
1302 move_members (bfd *arch, char **files_to_move)
1304 bfd **after_bfd; /* New entries go after this one */
1305 bfd **current_ptr_ptr; /* cdr pointer into contents */
1307 for (; *files_to_move; ++files_to_move)
1309 current_ptr_ptr = &(arch->archive_next);
1310 while (*current_ptr_ptr)
1312 bfd *current_ptr = *current_ptr_ptr;
1313 if (FILENAME_CMP (normalize (*files_to_move, arch),
1314 current_ptr->filename) == 0)
1316 /* Move this file to the end of the list - first cut from
1319 *current_ptr_ptr = current_ptr->archive_next;
1321 /* Now glue to end */
1322 after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1323 link_bfd = *after_bfd;
1324 *after_bfd = current_ptr;
1325 current_ptr->archive_next = link_bfd;
1328 printf ("m - %s\n", *files_to_move);
1333 current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1335 /* xgettext:c-format */
1336 fatal (_("no entry %s in archive %s!"), *files_to_move, arch->filename);
1341 write_archive (arch);
1344 /* Ought to default to replacing in place, but this is existing practice! */
1347 replace_members (bfd *arch, char **files_to_move, bfd_boolean quick)
1349 bfd_boolean changed = FALSE;
1350 bfd **after_bfd; /* New entries go after this one. */
1354 while (files_to_move && *files_to_move)
1358 current_ptr = &arch->archive_next;
1359 while (*current_ptr)
1361 current = *current_ptr;
1363 /* For compatibility with existing ar programs, we
1364 permit the same file to be added multiple times. */
1365 if (FILENAME_CMP (normalize (*files_to_move, arch),
1366 normalize (current->filename, arch)) == 0
1367 && current->arelt_data != NULL)
1371 struct stat fsbuf, asbuf;
1373 if (stat (*files_to_move, &fsbuf) != 0)
1375 if (errno != ENOENT)
1376 bfd_fatal (*files_to_move);
1379 if (bfd_stat_arch_elt (current, &asbuf) != 0)
1380 /* xgettext:c-format */
1381 fatal (_("internal stat error on %s"),
1384 if (fsbuf.st_mtime <= asbuf.st_mtime)
1388 after_bfd = get_pos_bfd (&arch->archive_next, pos_after,
1390 if (ar_emul_replace (after_bfd, *files_to_move,
1393 /* Snip out this entry from the chain. */
1394 *current_ptr = (*current_ptr)->archive_next;
1400 current_ptr = &(current->archive_next);
1404 /* Add to the end of the archive. */
1405 after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1407 if (ar_emul_append (after_bfd, *files_to_move, target,
1408 verbose, make_thin_archive))
1417 write_archive (arch);
1419 output_filename = NULL;
1423 ranlib_only (const char *archname)
1427 if (get_file_size (archname) < 1)
1430 arch = open_inarch (archname, (char *) NULL);
1433 write_archive (arch);
1437 /* Update the timestamp of the symbol map of an archive. */
1440 ranlib_touch (const char *archname)
1443 /* I don't think updating works on go32. */
1444 ranlib_only (archname);
1450 if (get_file_size (archname) < 1)
1452 f = open (archname, O_RDWR | O_BINARY, 0);
1455 bfd_set_error (bfd_error_system_call);
1456 bfd_fatal (archname);
1459 arch = bfd_fdopenr (archname, (const char *) NULL, f);
1461 bfd_fatal (archname);
1462 if (! bfd_check_format_matches (arch, bfd_archive, &matching))
1464 bfd_nonfatal (archname);
1465 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1467 list_matching_formats (matching);
1473 if (! bfd_has_map (arch))
1474 /* xgettext:c-format */
1475 fatal (_("%s: no archive map to update"), archname);
1478 arch->flags |= BFD_DETERMINISTIC_OUTPUT;
1480 bfd_update_armap_timestamp (arch);
1482 if (! bfd_close (arch))
1483 bfd_fatal (archname);
1488 /* Things which are interesting to map over all or some of the files: */
1491 print_descr (bfd *abfd)
1493 print_arelt_descr (stdout, abfd, verbose);