binutils/arsup.c

   1 /* arsup.c - Archive support for MRI compatibility
   2    Copyright (C) 1992-2019 Free Software Foundation, Inc.
   3
   4    This file is part of GNU Binutils.
   5
   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.
  10
  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.
  15
  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.  */
  20
  21
  22 /* Contributed by Steve Chamberlain
  23    sac@cygnus.com
  24
  25    This file looks after requests from arparse.y, to provide the MRI
  26    style librarian command syntax + 1 word LIST.  */
  27
  28 #include "sysdep.h"
  29 #include "bfd.h"
  30 #include "libiberty.h"
  31 #include "filenames.h"
  32 #include "bucomm.h"
  33 #include "arsup.h"
  34
  35 static void map_over_list
  36   (bfd *, void (*function) (bfd *, bfd *), struct list *);
  37 static void ar_directory_doer (bfd *, bfd *);
  38 static void ar_addlib_doer (bfd *, bfd *);
  39
  40 extern int verbose;
  41 extern int deterministic;
  42
  43 static bfd *obfd;
  44 static char *real_name;
  45 static FILE *outfile;
  46
  47 static void
  48 map_over_list (bfd *arch, void (*function) (bfd *, bfd *), struct list *list)
  49 {
  50   bfd *head;
  51
  52   if (list == NULL)
  53     {
  54       bfd *next;
  55
  56       head = arch->archive_next;
  57       while (head != NULL)
  58         {
  59           next = head->archive_next;
  60           function (head, (bfd *) NULL);
  61           head = next;
  62         }
  63     }
  64   else
  65     {
  66       struct list *ptr;
  67
  68       /* This may appear to be a baroque way of accomplishing what we
  69          want.  however we have to iterate over the filenames in order
  70          to notice where a filename is requested but does not exist in
  71          the archive.  Ditto mapping over each file each time -- we
  72          want to hack multiple references.  */
  73       for (ptr = list; ptr; ptr = ptr->next)
  74         {
  75           bfd_boolean found = FALSE;
  76           bfd *prev = arch;
  77
  78           for (head = arch->archive_next; head; head = head->archive_next)
  79             {
  80               if (head->filename != NULL
  81                   && FILENAME_CMP (ptr->name, head->filename) == 0)
  82                 {
  83                   found = TRUE;
  84                   function (head, prev);
  85                 }
  86               prev = head;
  87             }
  88           if (! found)
  89             fprintf (stderr, _("No entry %s in archive.\n"), ptr->name);
  90         }
  91     }
  92 }
  93
  94
  95
  96 static void
  97 ar_directory_doer (bfd *abfd, bfd *ignore ATTRIBUTE_UNUSED)
  98 {
  99   print_arelt_descr(outfile, abfd, verbose, FALSE);
 100 }
 101
 102 void
 103 ar_directory (char *ar_name, struct list *list, char *output)
 104 {
 105   bfd *arch;
 106
 107   arch = open_inarch (ar_name, (char *) NULL);
 108   if (output)
 109     {
 110       outfile = fopen(output,"w");
 111       if (outfile == 0)
 112         {
 113           outfile = stdout;
 114           fprintf (stderr,_("Can't open file %s\n"), output);
 115           output = 0;
 116         }
 117     }
 118   else
 119     outfile = stdout;
 120
 121   map_over_list (arch, ar_directory_doer, list);
 122
 123   bfd_close (arch);
 124
 125   if (output)
 126    fclose (outfile);
 127 }
 128
 129 void
 130 prompt (void)
 131 {
 132   extern int interactive;
 133
 134   if (interactive)
 135     {
 136       printf ("AR >");
 137       fflush (stdout);
 138     }
 139 }
 140
 141 void
 142 maybequit (void)
 143 {
 144   if (! interactive)
 145     xexit (9);
 146 }
 147
 148
 149 void
 150 ar_open (char *name, int t)
 151 {
 152   char *tname = (char *) xmalloc (strlen (name) + 10);
 153   const char *bname = lbasename (name);
 154   real_name = name;
 155
 156   /* Prepend tmp- to the beginning, to avoid file-name clashes after
 157      truncation on filesystems with limited namespaces (DOS).  */
 158   sprintf (tname, "%.*stmp-%s", (int) (bname - name), name, bname);
 159   obfd = bfd_openw (tname, NULL);
 160
 161   if (!obfd)
 162     {
 163       fprintf (stderr,
 164                _("%s: Can't open output archive %s\n"),
 165                program_name,  tname);
 166
 167       maybequit ();
 168     }
 169   else
 170     {
 171       if (!t)
 172         {
 173           bfd **ptr;
 174           bfd *element;
 175           bfd *ibfd;
 176
 177           ibfd = bfd_openr (name, NULL);
 178
 179           if (!ibfd)
 180             {
 181               fprintf (stderr,_("%s: Can't open input archive %s\n"),
 182                        program_name, name);
 183               maybequit ();
 184               return;
 185             }
 186
 187           if (!bfd_check_format(ibfd, bfd_archive))
 188             {
 189               fprintf (stderr,
 190                        _("%s: file %s is not an archive\n"),
 191                        program_name, name);
 192               maybequit ();
 193               return;
 194             }
 195
 196           ptr = &(obfd->archive_head);
 197           element = bfd_openr_next_archived_file (ibfd, NULL);
 198
 199           while (element)
 200             {
 201               *ptr = element;
 202               ptr = &element->archive_next;
 203               element = bfd_openr_next_archived_file (ibfd, element);
 204             }
 205         }
 206
 207       bfd_set_format (obfd, bfd_archive);
 208
 209       obfd->has_armap = 1;
 210       obfd->is_thin_archive = 0;
 211     }
 212 }
 213
 214 static void
 215 ar_addlib_doer (bfd *abfd, bfd *prev)
 216 {
 217   /* Add this module to the output bfd.  */
 218   if (prev != NULL)
 219     prev->archive_next = abfd->archive_next;
 220
 221   abfd->archive_next = obfd->archive_head;
 222   obfd->archive_head = abfd;
 223 }
 224
 225 void
 226 ar_addlib (char *name, struct list *list)
 227 {
 228   if (obfd == NULL)
 229     {
 230       fprintf (stderr, _("%s: no output archive specified yet\n"), program_name);
 231       maybequit ();
 232     }
 233   else
 234     {
 235       bfd *arch;
 236
 237       arch = open_inarch (name, (char *) NULL);
 238       if (arch != NULL)
 239         map_over_list (arch, ar_addlib_doer, list);
 240
 241       /* Don't close the bfd, since it will make the elements disappear.  */
 242     }
 243 }
 244
 245 void
 246 ar_addmod (struct list *list)
 247 {
 248   if (!obfd)
 249     {
 250       fprintf (stderr, _("%s: no open output archive\n"), program_name);
 251       maybequit ();
 252     }
 253   else
 254     {
 255       while (list)
 256         {
 257           bfd *abfd;
 258
 259 #if BFD_SUPPORTS_PLUGINS
 260           abfd = bfd_openr (list->name, "plugin");
 261 #else
 262           abfd = bfd_openr (list->name, NULL);
 263 #endif
 264           if (!abfd)
 265             {
 266               fprintf (stderr, _("%s: can't open file %s\n"),
 267                        program_name, list->name);
 268               maybequit ();
 269             }
 270           else
 271             {
 272               abfd->archive_next = obfd->archive_head;
 273               obfd->archive_head = abfd;
 274             }
 275           list = list->next;
 276         }
 277     }
 278 }
 279
 280
 281 void
 282 ar_clear (void)
 283 {
 284   if (obfd)
 285     obfd->archive_head = 0;
 286 }
 287
 288 void
 289 ar_delete (struct list *list)
 290 {
 291   if (!obfd)
 292     {
 293       fprintf (stderr, _("%s: no open output archive\n"), program_name);
 294       maybequit ();
 295     }
 296   else
 297     {
 298       while (list)
 299         {
 300           /* Find this name in the archive.  */
 301           bfd *member = obfd->archive_head;
 302           bfd **prev = &(obfd->archive_head);
 303           int found = 0;
 304
 305           while (member)
 306             {
 307               if (FILENAME_CMP(member->filename, list->name) == 0)
 308                 {
 309                   *prev = member->archive_next;
 310                   found = 1;
 311                 }
 312               else
 313                 prev = &(member->archive_next);
 314
 315               member = member->archive_next;
 316             }
 317
 318           if (!found)
 319             {
 320               fprintf (stderr, _("%s: can't find module file %s\n"),
 321                        program_name, list->name);
 322               maybequit ();
 323             }
 324
 325           list = list->next;
 326         }
 327     }
 328 }
 329
 330 void
 331 ar_save (void)
 332 {
 333   if (!obfd)
 334     {
 335       fprintf (stderr, _("%s: no open output archive\n"), program_name);
 336       maybequit ();
 337     }
 338   else
 339     {
 340       char *ofilename = xstrdup (bfd_get_filename (obfd));
 341
 342       if (deterministic > 0)
 343         obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
 344
 345       bfd_close (obfd);
 346
 347       smart_rename (ofilename, real_name, 0);
 348       obfd = 0;
 349       free (ofilename);
 350     }
 351 }
 352
 353 void
 354 ar_replace (struct list *list)
 355 {
 356   if (!obfd)
 357     {
 358       fprintf (stderr, _("%s: no open output archive\n"), program_name);
 359       maybequit ();
 360     }
 361   else
 362     {
 363       while (list)
 364         {
 365           /* Find this name in the archive.  */
 366           bfd *member = obfd->archive_head;
 367           bfd **prev = &(obfd->archive_head);
 368           int found = 0;
 369
 370           while (member)
 371             {
 372               if (FILENAME_CMP (member->filename, list->name) == 0)
 373                 {
 374                   /* Found the one to replace.  */
 375                   bfd *abfd = bfd_openr (list->name, NULL);
 376
 377                   if (!abfd)
 378                     {
 379                       fprintf (stderr, _("%s: can't open file %s\n"),
 380                                program_name, list->name);
 381                       maybequit ();
 382                     }
 383                   else
 384                     {
 385                       *prev = abfd;
 386                       abfd->archive_next = member->archive_next;
 387                       found = 1;
 388                     }
 389                 }
 390               else
 391                 {
 392                   prev = &(member->archive_next);
 393                 }
 394               member = member->archive_next;
 395             }
 396
 397           if (!found)
 398             {
 399               bfd *abfd = bfd_openr (list->name, NULL);
 400
 401               fprintf (stderr,_("%s: can't find module file %s\n"),
 402                        program_name, list->name);
 403               if (!abfd)
 404                 {
 405                   fprintf (stderr, _("%s: can't open file %s\n"),
 406                            program_name, list->name);
 407                   maybequit ();
 408                 }
 409               else
 410                 *prev = abfd;
 411             }
 412
 413           list = list->next;
 414         }
 415     }
 416 }
 417
 418 /* And I added this one.  */
 419 void
 420 ar_list (void)
 421 {
 422   if (!obfd)
 423     {
 424       fprintf (stderr, _("%s: no open output archive\n"), program_name);
 425       maybequit ();
 426     }
 427   else
 428     {
 429       bfd *abfd;
 430
 431       outfile = stdout;
 432       verbose =1 ;
 433       printf (_("Current open archive is %s\n"), bfd_get_filename (obfd));
 434
 435       for (abfd = obfd->archive_head;
 436            abfd != (bfd *)NULL;
 437            abfd = abfd->archive_next)
 438         ar_directory_doer (abfd, (bfd *) NULL);
 439     }
 440 }
 441
 442 void
 443 ar_end (void)
 444 {
 445   if (obfd)
 446     {
 447       bfd_cache_close (obfd);
 448       unlink (bfd_get_filename (obfd));
 449     }
 450 }
 451
 452 void
 453 ar_extract (struct list *list)
 454 {
 455   if (!obfd)
 456     {
 457       fprintf (stderr, _("%s: no open archive\n"), program_name);
 458       maybequit ();
 459     }
 460   else
 461     {
 462       while (list)
 463         {
 464           /* Find this name in the archive.  */
 465           bfd *member = obfd->archive_head;
 466           int found = 0;
 467
 468           while (member && !found)
 469             {
 470               if (FILENAME_CMP (member->filename, list->name) == 0)
 471                 {
 472                   extract_file (member);
 473                   found = 1;
 474                 }
 475
 476               member = member->archive_next;
 477             }
 478
 479           if (!found)
 480             {
 481               bfd_openr (list->name, NULL);
 482               fprintf (stderr, _("%s: can't find module file %s\n"),
 483                        program_name, list->name);
 484             }
 485
 486           list = list->next;
 487         }
 488     }
 489 }