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

/* arsup.c - Archive support for MRI compatibility
   Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 1999
   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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 "bfd.h"
#include "arsup.h"
#include "libiberty.h"
#include "bucomm.h"

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

extern int verbose;

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

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

      head = arch->next;
      while (head != NULL)
	{
	  next = head->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)
	{
	  boolean found = false;
	  bfd *prev = arch;

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


FILE *outfile;

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

void
ar_directory (ar_name, list, output)
     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
DEFUN_VOID(prompt)
{
  extern int interactive;
  if (interactive) 
  {
    printf("AR >");
    fflush(stdout); 
  }
}

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


bfd *obfd;
char *real_name ; 
void
DEFUN(ar_open,(name, t),
      char *name AND
      int t)

{
  char *tname = (char *) xmalloc (strlen (name) + 10);
  real_name = name;
  sprintf(tname, "%s-tmp", name);
  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) != true) {
	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->next;
	element = bfd_openr_next_archived_file(ibfd, element);
      }
    }

    bfd_set_format(obfd, bfd_archive);

    obfd->has_armap = 1;
  }
}


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

void
ar_addlib (name, list)
     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 disasppear */
    }
}

void
DEFUN(ar_addmod, (list),
      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->next = obfd->archive_head;
	obfd->archive_head = abfd;
      }
      list = list->next;
    }
  }
}


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

void
DEFUN(ar_delete, (list),
      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 (strcmp(member->filename, list->name) == 0) {
	  *prev = member->next;
	  found = 1;
	}
	else {
	  prev = &(member->next);
	}
	  member = member->next;
      }
      if (!found)  {
	fprintf(stderr,_("%s: can't find module file %s\n"), program_name,
		list->name);
	maybequit();
      }
      list = list->next;
    }
  }
}


void
DEFUN_VOID(ar_save)
{

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


void
DEFUN(ar_replace, (list),
      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 (strcmp(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->next = member->next;
	    found = 1;
	  }
	}
	else {
	  prev = &(member->next);
	}
	member = member->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
DEFUN_VOID(ar_list)
{
  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->next) 
    {
      ar_directory_doer (abfd, (bfd *) NULL);
    }
  }
}


void 
DEFUN_VOID(ar_end)
{
  if (obfd)
  {
    fclose((FILE *)(obfd->iostream));
    unlink(bfd_get_filename (obfd));
  }
}
void
DEFUN(ar_extract,(list),
      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 (strcmp(member->filename, list->name) == 0) 
	{
	  extract_file(member);
	  found = 1;
	  }

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