/* BFD library -- caching of file descriptors.
- Copyright (C) 1990-1991 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
Hacked by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
This file is part of BFD, the Binary File Descriptor library.
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-/*doc*
-@section File Caching
-The file caching mechanism is embedded within BFD and allows the application to open as many
-BFDs as it wants without regard to the underlying operating system's
-file descriptor limit (often as low as 20 open files).
-
-The module in @code{cache.c} maintains a least recently used list of
-@code{BFD_CACHE_MAX_OPEN} files, and exports the name
-@code{bfd_cache_lookup} which runs around and makes sure that the
-required BFD is open. If not, then it chooses a file to close, closes
-it and opens the one wanted, returning its file handle.
+/*
+SECTION
+ File caching
+
+ The file caching mechanism is embedded within BFD and allows
+ the application to open as many BFDs as it wants without
+ regard to the underlying operating system's file descriptor
+ limit (often as low as 20 open files). The module in
+ <<cache.c>> maintains a least recently used list of
+ <<BFD_CACHE_MAX_OPEN>> files, and exports the name
+ <<bfd_cache_lookup>>, which runs around and makes sure that
+ the required BFD is open. If not, then it chooses a file to
+ close, closes it and opens the one wanted, returning its file
+ handle.
*/
-
-
-/* $Id$ */
-#include <sysdep.h>
#include "bfd.h"
+#include "sysdep.h"
#include "libbfd.h"
+/*
+INTERNAL_FUNCTION
+ BFD_CACHE_MAX_OPEN macro
-/*proto-internal* BFD_CACHE_MAX_OPEN
-The maxiumum number of files which the cache will keep open at one
-time.
-*+
-#define BFD_CACHE_MAX_OPEN 10
-*-
+DESCRIPTION
+ The maximum number of files which the cache will keep open at
+ one time.
+
+.#define BFD_CACHE_MAX_OPEN 10
*/
+static boolean
+bfd_cache_delete PARAMS ((bfd *));
+
+/* Number of bfds on the chain. All such bfds have their file open;
+ if it closed, they get snipd()d from the chain. */
+
static int open_files;
static bfd *cache_sentinel; /* Chain of BFDs with active fds we've
opened */
-/*proto-internal* bfd_last_cache
-Zero, or a pointer to the topmost BFD on the chain. This is used by
-the @code{bfd_cache_lookup} macro in @file{libbfd.h} to determine when
-it can avoid a function call.
-*+
-extern bfd *bfd_last_cache;
-*-
-
-*/
+/*
+INTERNAL_FUNCTION
+ bfd_last_cache
-bfd *bfd_last_cache;
-
-/*proto-internal* bfd_cache_lookup
-Checks to see if the required BFD is the same as the last one looked
-up. If so then it can use the iostream in the BFD with impunity, since
-it can't have changed since the last lookup, otherwise it has to
-perform the complicated lookup function
-*+
-#define bfd_cache_lookup(x) \
- ((x)==bfd_last_cache? \
- (FILE*)(bfd_last_cache->iostream): \
- bfd_cache_lookup_worker(x))
-
-*-
+SYNOPSIS
+ extern bfd *bfd_last_cache;
+DESCRIPTION
+ Zero, or a pointer to the topmost BFD on the chain. This is
+ used by the <<bfd_cache_lookup>> macro in @file{libbfd.h} to
+ determine when it can avoid a function call.
*/
-static void bfd_cache_delete();
+bfd *bfd_last_cache;
+/*
+ INTERNAL_FUNCTION
+ bfd_cache_lookup
+
+ DESCRIPTION
+ Check to see if the required BFD is the same as the last one
+ looked up. If so, then it can use the stream in the BFD with
+ impunity, since it can't have changed since the last lookup;
+ otherwise, it has to perform the complicated lookup function.
+
+ .#define bfd_cache_lookup(x) \
+ . ((x)==bfd_last_cache? \
+ . (FILE*)(bfd_last_cache->iostream): \
+ . bfd_cache_lookup_worker(x))
+
+
+ */
static void
DEFUN_VOID(close_one)
}
kill->where = ftell((FILE *)(kill->iostream));
- bfd_cache_delete(kill);
+ (void) bfd_cache_delete(kill);
}
/* Cuts the BFD abfd out of the chain in the cache */
if (cache_sentinel == abfd) cache_sentinel = (bfd *)NULL;
}
-static void
+static boolean
DEFUN(bfd_cache_delete,(abfd),
bfd *abfd)
{
- fclose ((FILE *)(abfd->iostream));
+ boolean ret;
+
+ if (fclose ((FILE *)(abfd->iostream)) == 0)
+ ret = true;
+ else
+ {
+ ret = false;
+ bfd_error = system_call_error;
+ }
snip (abfd);
abfd->iostream = NULL;
open_files--;
bfd_last_cache = 0;
+ return ret;
}
static bfd *
}
\f
-/*proto-internal*
-*i bfd_cache_init
-Initialize a BFD by putting it on the cache LRU.
-*; PROTO(void, bfd_cache_init, (bfd *));
-*-*/
+/* Initialize a BFD by putting it on the cache LRU. */
void
DEFUN(bfd_cache_init,(abfd),
bfd *abfd)
{
+ if (open_files >= BFD_CACHE_MAX_OPEN)
+ close_one ();
cache_sentinel = insert(abfd, cache_sentinel);
+ ++open_files;
}
-/*proto-internal*
-*i bfd_cache_close
-Remove the BFD from the cache. If the attatched file is open, then close it too.
-*; PROTO(void, bfd_cache_close, (bfd *));
-*-*/
-void
+/*
+INTERNAL_FUNCTION
+ bfd_cache_close
+
+SYNOPSIS
+ boolean bfd_cache_close (bfd *abfd);
+
+DESCRIPTION
+ Remove the BFD @var{abfd} from the cache. If the attached file is open,
+ then close it too.
+
+RETURNS
+ <<false>> is returned if closing the file fails, <<true>> is
+ returned if all is well.
+*/
+boolean
DEFUN(bfd_cache_close,(abfd),
bfd *abfd)
{
/* If this file is open then remove from the chain */
if (abfd->iostream)
{
- bfd_cache_delete(abfd);
+ return bfd_cache_delete(abfd);
+ }
+ else
+ {
+ return true;
}
}
-/*proto-internal*
-*i bfd_open_file
-Call the OS to open a file for this BFD. Returns the FILE *
-(possibly null) that results from this operation. Sets up the
-BFD so that future accesses know the file is open. If the FILE *
-returned is null, then there is won't have been put in the cache, so
-it won't have to be removed from it.
-*; PROTO(FILE *, bfd_open_file, (bfd *));
-*-*/
+/*
+INTERNAL_FUNCTION
+ bfd_open_file
+
+SYNOPSIS
+ FILE* bfd_open_file(bfd *abfd);
+
+DESCRIPTION
+ Call the OS to open a file for @var{abfd}. Return the <<FILE *>>
+ (possibly NULL) that results from this operation. Set up the
+ BFD so that future accesses know the file is open. If the <<FILE *>>
+ returned is NULL, then it won't have been put in the
+ cache, so it won't have to be removed from it.
+*/
+
FILE *
DEFUN(bfd_open_file, (abfd),
bfd *abfd)
{
abfd->cacheable = true; /* Allow it to be closed later. */
+
if(open_files >= BFD_CACHE_MAX_OPEN) {
close_one();
}
+
switch (abfd->direction) {
case read_direction:
case no_direction:
- abfd->iostream = (char *) fopen(abfd->filename, "r");
+ abfd->iostream = (char *) fopen(abfd->filename, FOPEN_RB);
break;
case both_direction:
case write_direction:
if (abfd->opened_once == true) {
- abfd->iostream = (char *) fopen(abfd->filename, "r+");
+ abfd->iostream = (char *) fopen(abfd->filename, FOPEN_RUB);
if (!abfd->iostream) {
- abfd->iostream = (char *) fopen(abfd->filename, "w+");
+ abfd->iostream = (char *) fopen(abfd->filename, FOPEN_WUB);
}
} else {
/*open for creat */
- abfd->iostream = (char *) fopen(abfd->filename, "w");
+ abfd->iostream = (char *) fopen(abfd->filename, FOPEN_WB);
abfd->opened_once = true;
}
break;
}
+
if (abfd->iostream) {
- open_files++;
bfd_cache_init (abfd);
}
return (FILE *)(abfd->iostream);
}
-/*proto-internal*
-*i bfd_cache_lookup_worker
-Called when the macro @code{bfd_cache_lookup} fails to find a quick
-answer. Finds a file descriptor for this BFD. If necessary, it open it.
-If there are already more than BFD_CACHE_MAX_OPEN files open, it trys to close
-one first, to avoid running out of file descriptors.
-*; PROTO(FILE *, bfd_cache_lookup_worker, (bfd *));
+/*
+INTERNAL_FUNCTION
+ bfd_cache_lookup_worker
+
+SYNOPSIS
+ FILE *bfd_cache_lookup_worker(bfd *abfd);
-*-*/
+DESCRIPTION
+ Called when the macro <<bfd_cache_lookup>> fails to find a
+ quick answer. Find a file descriptor for @var{abfd}. If
+ necessary, it open it. If there are already more than
+ <<BFD_CACHE_MAX_OPEN>> files open, it tries to close one first, to
+ avoid running out of file descriptors.
+
+*/
FILE *
DEFUN(bfd_cache_lookup_worker,(abfd),
projects / deliverable / binutils-gdb.git / blobdiff