[deliverable/binutils-gdb.git] / binutils / arsup.c

/* arsup.c - Archive support for MRI compatibility
   Copyright 1992, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2003,
   2004, 2007 Free Software Foundation, Inc.

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */


/* Contributed by Steve Chamberlain
   sac@cygnus.com

   This file looks after requests from arparse.y, to provide the MRI
   style librarian command syntax + 1 word LIST.  */

#include "sysdep.h"
#include "bfd.h"
#include "libiberty.h"
#include "filenames.h"
#include "bucomm.h"
#include "arsup.h"

static void map_over_list
  (bfd *, void (*function) (bfd *, bfd *), struct list *);
static void ar_directory_doer (bfd *, bfd *);
static void ar_addlib_doer (bfd *, bfd *);

extern int verbose;

static bfd *obfd;
static char *real_name;
static FILE *outfile;

static void
map_over_list (bfd *arch, void (*function) (bfd *, bfd *), struct list *list)
{
  bfd *head;

  if (list == NULL)
    {
      bfd *next;

      head = arch->archive_next;
      while (head != NULL)
	{
	  next = head->archive_next;
	  function (head, (bfd *) NULL);
	  head = next;
	}
    }
  else
    {
      struct list *ptr;

      /* This may appear to be a baroque way of accomplishing what we
	 want.  however we have to iterate over the filenames in order
	 to notice where a filename is requested but does not exist in
	 the archive.  Ditto mapping over each file each time -- we
	 want to hack multiple references.  */
      for (ptr = list; ptr; ptr = ptr->next)
	{
	  bfd_boolean found = FALSE;
	  bfd *prev = arch;

	  for (head = arch->archive_next; head; head = head->archive_next)
	    {
	      if (head->filename != NULL
		  && FILENAME_CMP (ptr->name, head->filename) == 0)
		{
		  found = TRUE;
		  function (head, prev);
		}
	      prev = head;
	    }
	  if (! found)
	    fprintf (stderr, _("No entry %s in archive.\n"), ptr->name);
	}
    }
}


static void
ar_directory_doer (bfd *abfd, bfd *ignore ATTRIBUTE_UNUSED)
{
  print_arelt_descr(outfile, abfd, verbose);
}

void
ar_directory (char *ar_name, struct list *list, char *output)
{
  bfd *arch;

  arch = open_inarch (ar_name, (char *) NULL);
  if (output)
    {
      outfile = fopen(output,"w");
      if (outfile == 0)
	{
	  outfile = stdout;
	  fprintf (stderr,_("Can't open file %s\n"), output);
	  output = 0;
	}
    }
  else
    outfile = stdout;

  map_over_list (arch, ar_directory_doer, list);

  bfd_close (arch);

  if (output)
   fclose (outfile);
}

void
prompt (void)
{
  extern int interactive;

  if (interactive)
    {
      printf ("AR >");
      fflush (stdout);
    }
}

void
maybequit (void)
{
  if (! interactive)
    xexit (9);
}


void
ar_open (char *name, int t)
{
  char *tname = (char *) xmalloc (strlen (name) + 10);
  const char *bname = lbasename (name);
  real_name = name;

  /* Prepend tmp- to the beginning, to avoid file-name clashes after
     truncation on filesystems with limited namespaces (DOS).  */
  sprintf (tname, "%.*stmp-%s", (int) (bname - name), name, bname);
  obfd = bfd_openw (tname, NULL);

  if (!obfd)
    {
      fprintf (stderr,
	       _("%s: Can't open output archive %s\n"),
	       program_name,  tname);

      maybequit ();
    }
  else
    {
      if (!t)
	{
	  bfd **ptr;
	  bfd *element;
	  bfd *ibfd;

	  ibfd = bfd_openr (name, NULL);

	  if (!ibfd)
	    {
	      fprintf (stderr,_("%s: Can't open input archive %s\n"),
		       program_name, name);
	      maybequit ();
	      return;
	    }

	  if (!bfd_check_format(ibfd, bfd_archive))
	    {
	      fprintf (stderr,
		       _("%s: file %s is not an archive\n"),
		       program_name, name);
	      maybequit ();
	      return;
	    }

	  ptr = &(obfd->archive_head);
	  element = bfd_openr_next_archived_file (ibfd, NULL);

	  while (element)
	    {
	      *ptr = element;
	      ptr = &element->archive_next;
	      element = bfd_openr_next_archived_file (ibfd, element);
	    }
	}

      bfd_set_format (obfd, bfd_archive);

      obfd->has_armap = 1;
    }
}

static void
ar_addlib_doer (bfd *abfd, bfd *prev)
{
  /* Add this module to the output bfd.  */
  if (prev != NULL)
    prev->archive_next = abfd->archive_next;

  abfd->archive_next = obfd->archive_head;
  obfd->archive_head = abfd;
}

void
ar_addlib (char *name, struct list *list)
{
  if (obfd == NULL)
    {
      fprintf (stderr, _("%s: no output archive specified yet\n"), program_name);
      maybequit ();
    }
  else
    {
      bfd *arch;

      arch = open_inarch (name, (char *) NULL);
      if (arch != NULL)
	map_over_list (arch, ar_addlib_doer, list);

      /* Don't close the bfd, since it will make the elements disappear.  */
    }
}

void
ar_addmod (struct list *list)
{
  if (!obfd)
    {
      fprintf (stderr, _("%s: no open output archive\n"), program_name);
      maybequit ();
    }
  else
    {
      while (list)
	{
	  bfd *abfd = bfd_openr (list->name, NULL);

	  if (!abfd)
	    {
	      fprintf (stderr, _("%s: can't open file %s\n"),
		       program_name, list->name);
	      maybequit ();
	    }
	  else
	    {
	      abfd->archive_next = obfd->archive_head;
	      obfd->archive_head = abfd;
	    }
	  list = list->next;
	}
    }
}


void
ar_clear (void)
{
  if (obfd)
    obfd->archive_head = 0;
}

void
ar_delete (struct list *list)
{
  if (!obfd)
    {
      fprintf (stderr, _("%s: no open output archive\n"), program_name);
      maybequit ();
    }
  else
    {
      while (list)
	{
	  /* Find this name in the archive.  */
	  bfd *member = obfd->archive_head;
	  bfd **prev = &(obfd->archive_head);
	  int found = 0;

	  while (member)
	    {
	      if (FILENAME_CMP(member->filename, list->name) == 0)
		{
		  *prev = member->archive_next;
		  found = 1;
		}
	      else
		prev = &(member->archive_next);

	      member = member->archive_next;
	    }

	  if (!found)
	    {
	      fprintf (stderr, _("%s: can't find module file %s\n"),
		       program_name, list->name);
	      maybequit ();
	    }

	  list = list->next;
	}
    }
}

void
ar_save (void)
{
  if (!obfd)
    {
      fprintf (stderr, _("%s: no open output archive\n"), program_name);
      maybequit ();
    }
  else
    {
      char *ofilename = xstrdup (bfd_get_filename (obfd));

      bfd_close (obfd);

      smart_rename (ofilename, real_name, 0);
      obfd = 0;
      free (ofilename);
    }
}

void
ar_replace (struct list *list)
{
  if (!obfd)
    {
      fprintf (stderr, _("%s: no open output archive\n"), program_name);
      maybequit ();
    }
  else
    {
      while (list)
	{
	  /* Find this name in the archive.  */
	  bfd *member = obfd->archive_head;
	  bfd **prev = &(obfd->archive_head);
	  int found = 0;

	  while (member)
	    {
	      if (FILENAME_CMP (member->filename, list->name) == 0)
		{
		  /* Found the one to replace.  */
		  bfd *abfd = bfd_openr (list->name, 0);

		  if (!abfd)
		    {
		      fprintf (stderr, _("%s: can't open file %s\n"),
			       program_name, list->name);
		      maybequit ();
		    }
		  else
		    {
		      *prev = abfd;
		      abfd->archive_next = member->archive_next;
		      found = 1;
		    }
		}
	      else
		{
		  prev = &(member->archive_next);
		}
	      member = member->archive_next;
	    }

	  if (!found)
	    {
	      bfd *abfd = bfd_openr (list->name, 0);

	      fprintf (stderr,_("%s: can't find module file %s\n"),
		       program_name, list->name);
	      if (!abfd)
		{
		  fprintf (stderr, _("%s: can't open file %s\n"),
			   program_name, list->name);
		  maybequit ();
		}
	      else
		*prev = abfd;
	    }

	  list = list->next;
	}
    }
}

/* And I added this one.  */
void
ar_list (void)
{
  if (!obfd)
    {
      fprintf (stderr, _("%s: no open output archive\n"), program_name);
      maybequit ();
    }
  else
    {
      bfd *abfd;

      outfile = stdout;
      verbose =1 ;
      printf (_("Current open archive is %s\n"), bfd_get_filename (obfd));

      for (abfd = obfd->archive_head;
	   abfd != (bfd *)NULL;
	   abfd = abfd->archive_next)
	ar_directory_doer (abfd, (bfd *) NULL);
    }
}

void
ar_end (void)
{
  if (obfd)
    {
      bfd_cache_close (obfd);
      unlink (bfd_get_filename (obfd));
    }
}

void
ar_extract (struct list *list)
{
  if (!obfd)
    {
      fprintf (stderr, _("%s: no open archive\n"), program_name);
      maybequit ();
    }
  else
    {
      while (list)
	{
	  /* Find this name in the archive.  */
	  bfd *member = obfd->archive_head;
	  int found = 0;

	  while (member && !found)
	    {
	      if (FILENAME_CMP (member->filename, list->name) == 0)
		{
		  extract_file (member);
		  found = 1;
		}

	      member = member->archive_next;
	    }

	  if (!found)
	    {
	      bfd_openr (list->name, 0);
	      fprintf (stderr, _("%s: can't find module file %s\n"),
		       program_name, list->name);
	    }

	  list = list->next;
	}
    }
}
Commit	Line	Data
	1	/* arsup.c - Archive support for MRI compatibility
	2	Copyright 1992, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2003,
	3	2004, 2007 Free Software Foundation, Inc.
	4
	5	This file is part of GNU Binutils.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
	20	MA 02110-1301, USA. */
	21
	22
	23	/* Contributed by Steve Chamberlain
	24	sac@cygnus.com
	25
	26	This file looks after requests from arparse.y, to provide the MRI
	27	style librarian command syntax + 1 word LIST. */
	28
	29	#include "sysdep.h"
	30	#include "bfd.h"
	31	#include "libiberty.h"
	32	#include "filenames.h"
	33	#include "bucomm.h"
	34	#include "arsup.h"
	35
	36	static void map_over_list
	37	(bfd , void (function) (bfd , bfd ), struct list *);
	38	static void ar_directory_doer (bfd , bfd );
	39	static void ar_addlib_doer (bfd , bfd );
	40
	41	extern int verbose;
	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);
	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	}
	211	}
	212
	213	static void
	214	ar_addlib_doer (bfd abfd, bfd prev)
	215	{
	216	/* Add this module to the output bfd. */
	217	if (prev != NULL)
	218	prev->archive_next = abfd->archive_next;
	219
	220	abfd->archive_next = obfd->archive_head;
	221	obfd->archive_head = abfd;
	222	}
	223
	224	void
	225	ar_addlib (char name, struct list list)
	226	{
	227	if (obfd == NULL)
	228	{
	229	fprintf (stderr, _("%s: no output archive specified yet\n"), program_name);
	230	maybequit ();
	231	}
	232	else
	233	{
	234	bfd *arch;
	235
	236	arch = open_inarch (name, (char *) NULL);
	237	if (arch != NULL)
	238	map_over_list (arch, ar_addlib_doer, list);
	239
	240	/* Don't close the bfd, since it will make the elements disappear. */
	241	}
	242	}
	243
	244	void
	245	ar_addmod (struct list *list)
	246	{
	247	if (!obfd)
	248	{
	249	fprintf (stderr, _("%s: no open output archive\n"), program_name);
	250	maybequit ();
	251	}
	252	else
	253	{
	254	while (list)
	255	{
	256	bfd *abfd = bfd_openr (list->name, NULL);
	257
	258	if (!abfd)
	259	{
	260	fprintf (stderr, _("%s: can't open file %s\n"),
	261	program_name, list->name);
	262	maybequit ();
	263	}
	264	else
	265	{
	266	abfd->archive_next = obfd->archive_head;
	267	obfd->archive_head = abfd;
	268	}
	269	list = list->next;
	270	}
	271	}
	272	}
	273
	274
	275	void
	276	ar_clear (void)
	277	{
	278	if (obfd)
	279	obfd->archive_head = 0;
	280	}
	281
	282	void
	283	ar_delete (struct list *list)
	284	{
	285	if (!obfd)
	286	{
	287	fprintf (stderr, _("%s: no open output archive\n"), program_name);
	288	maybequit ();
	289	}
	290	else
	291	{
	292	while (list)
	293	{
	294	/* Find this name in the archive. */
	295	bfd *member = obfd->archive_head;
	296	bfd **prev = &(obfd->archive_head);
	297	int found = 0;
	298
	299	while (member)
	300	{
	301	if (FILENAME_CMP(member->filename, list->name) == 0)
	302	{
	303	*prev = member->archive_next;
	304	found = 1;
	305	}
	306	else
	307	prev = &(member->archive_next);
	308
	309	member = member->archive_next;
	310	}
	311
	312	if (!found)
	313	{
	314	fprintf (stderr, _("%s: can't find module file %s\n"),
	315	program_name, list->name);
	316	maybequit ();
	317	}
	318
	319	list = list->next;
	320	}
	321	}
	322	}
	323
	324	void
	325	ar_save (void)
	326	{
	327	if (!obfd)
	328	{
	329	fprintf (stderr, _("%s: no open output archive\n"), program_name);
	330	maybequit ();
	331	}
	332	else
	333	{
	334	char *ofilename = xstrdup (bfd_get_filename (obfd));
	335
	336	bfd_close (obfd);
	337
	338	smart_rename (ofilename, real_name, 0);
	339	obfd = 0;
	340	free (ofilename);
	341	}
	342	}
	343
	344	void
	345	ar_replace (struct list *list)
	346	{
	347	if (!obfd)
	348	{
	349	fprintf (stderr, _("%s: no open output archive\n"), program_name);
	350	maybequit ();
	351	}
	352	else
	353	{
	354	while (list)
	355	{
	356	/* Find this name in the archive. */
	357	bfd *member = obfd->archive_head;
	358	bfd **prev = &(obfd->archive_head);
	359	int found = 0;
	360
	361	while (member)
	362	{
	363	if (FILENAME_CMP (member->filename, list->name) == 0)
	364	{
	365	/* Found the one to replace. */
	366	bfd *abfd = bfd_openr (list->name, 0);
	367
	368	if (!abfd)
	369	{
	370	fprintf (stderr, _("%s: can't open file %s\n"),
	371	program_name, list->name);
	372	maybequit ();
	373	}
	374	else
	375	{
	376	*prev = abfd;
	377	abfd->archive_next = member->archive_next;
	378	found = 1;
	379	}
	380	}
	381	else
	382	{
	383	prev = &(member->archive_next);
	384	}
	385	member = member->archive_next;
	386	}
	387
	388	if (!found)
	389	{
	390	bfd *abfd = bfd_openr (list->name, 0);
	391
	392	fprintf (stderr,_("%s: can't find module file %s\n"),
	393	program_name, list->name);
	394	if (!abfd)
	395	{
	396	fprintf (stderr, _("%s: can't open file %s\n"),
	397	program_name, list->name);
	398	maybequit ();
	399	}
	400	else
	401	*prev = abfd;
	402	}
	403
	404	list = list->next;
	405	}
	406	}
	407	}
	408
	409	/* And I added this one. */
	410	void
	411	ar_list (void)
	412	{
	413	if (!obfd)
	414	{
	415	fprintf (stderr, _("%s: no open output archive\n"), program_name);
	416	maybequit ();
	417	}
	418	else
	419	{
	420	bfd *abfd;
	421
	422	outfile = stdout;
	423	verbose =1 ;
	424	printf (_("Current open archive is %s\n"), bfd_get_filename (obfd));
	425
	426	for (abfd = obfd->archive_head;
	427	abfd != (bfd *)NULL;
	428	abfd = abfd->archive_next)
	429	ar_directory_doer (abfd, (bfd *) NULL);
	430	}
	431	}
	432
	433	void
	434	ar_end (void)
	435	{
	436	if (obfd)
	437	{
	438	bfd_cache_close (obfd);
	439	unlink (bfd_get_filename (obfd));
	440	}
	441	}
	442
	443	void
	444	ar_extract (struct list *list)
	445	{
	446	if (!obfd)
	447	{
	448	fprintf (stderr, _("%s: no open archive\n"), program_name);
	449	maybequit ();
	450	}
	451	else
	452	{
	453	while (list)
	454	{
	455	/* Find this name in the archive. */
	456	bfd *member = obfd->archive_head;
	457	int found = 0;
	458
	459	while (member && !found)
	460	{
	461	if (FILENAME_CMP (member->filename, list->name) == 0)
	462	{
	463	extract_file (member);
	464	found = 1;
	465	}
	466
	467	member = member->archive_next;
	468	}
	469
	470	if (!found)
	471	{
	472	bfd_openr (list->name, 0);
	473	fprintf (stderr, _("%s: can't find module file %s\n"),
	474	program_name, list->name);
	475	}
	476
	477	list = list->next;
	478	}
	479	}
	480	}