/* Function declarations for libiberty.
- Copyright 2001, 2002, 2005 Free Software Foundation, Inc.
+ Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+ 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Note - certain prototypes declared in this header file are for
functions whoes implementation copyright does not belong to the
extern void expandargv PARAMS ((int *, char ***));
+/* Write argv to an @-file, inserting necessary quoting. */
+
+extern int writeargv PARAMS ((char **, FILE *));
+
/* Return the last component of a path name. Note that we can't use a
prototype here because the parameter is declared inconsistently
across different systems, sometimes as "char *" and sometimes as
extern const char *lbasename (const char *);
+/* Same, but assumes DOS semantics (drive name, backslash is also a
+ dir separator) regardless of host. */
+
+extern const char *dos_lbasename (const char *);
+
+/* Same, but assumes Unix semantics (absolute paths always start with
+ a slash, only forward slash is accepted as dir separator)
+ regardless of host. */
+
+extern const char *unix_lbasename (const char *);
+
/* A well-defined realpath () that is always compiled in. */
extern char *lrealpath (const char *);
extern double physmem_total (void);
extern double physmem_available (void);
+/* Compute the 32-bit CRC of a block of memory. */
+extern unsigned int xcrc32 (const unsigned char *, int, unsigned int);
/* These macros provide a K&R/C89/C++-friendly way of allocating structures
with nice encapsulation. The XDELETE*() macros are technically
/* Scalar allocators. */
+#define XALLOCA(T) ((T *) alloca (sizeof (T)))
#define XNEW(T) ((T *) xmalloc (sizeof (T)))
#define XCNEW(T) ((T *) xcalloc (1, sizeof (T)))
+#define XDUP(T, P) ((T *) xmemdup ((P), sizeof (T), sizeof (T)))
#define XDELETE(P) free ((void*) (P))
/* Array allocators. */
+#define XALLOCAVEC(T, N) ((T *) alloca (sizeof (T) * (N)))
#define XNEWVEC(T, N) ((T *) xmalloc (sizeof (T) * (N)))
#define XCNEWVEC(T, N) ((T *) xcalloc ((N), sizeof (T)))
+#define XDUPVEC(T, P, N) ((T *) xmemdup ((P), sizeof (T) * (N), sizeof (T) * (N)))
#define XRESIZEVEC(T, P, N) ((T *) xrealloc ((void *) (P), sizeof (T) * (N)))
#define XDELETEVEC(P) free ((void*) (P))
/* Allocators for variable-sized structures and raw buffers. */
+#define XALLOCAVAR(T, S) ((T *) alloca ((S)))
#define XNEWVAR(T, S) ((T *) xmalloc ((S)))
#define XCNEWVAR(T, S) ((T *) xcalloc (1, (S)))
+#define XDUPVAR(T, P, S1, S2) ((T *) xmemdup ((P), (S1), (S2)))
#define XRESIZEVAR(T, P, S) ((T *) xrealloc ((P), (S)))
/* Type-safe obstack allocator. */
#define XOBNEW(O, T) ((T *) obstack_alloc ((O), sizeof (T)))
+#define XOBNEWVEC(O, T, N) ((T *) obstack_alloc ((O), sizeof (T) * (N)))
+#define XOBNEWVAR(O, T, S) ((T *) obstack_alloc ((O), (S)))
#define XOBFINISH(O, T) ((T) obstack_finish ((O)))
/* hex character manipulation routines */
const char *outname,
const char *errname, int *err);
-/* Return a `FILE' pointer FP for the standard input of the first
- program in the pipeline; FP is opened for writing. You must have
- passed `PEX_USE_PIPES' to the `pex_init' call that returned OBJ.
- You must close FP yourself with `fclose' to indicate that the
- pipeline's input is complete.
-
- The file descriptor underlying FP is marked not to be inherited by
- child processes.
-
- This call is not supported on systems which do not support pipes;
- it returns with an error. (We could implement it by writing a
- temporary file, but then you would need to write all your data and
- close FP before your first call to `pex_run' -- and that wouldn't
- work on systems that do support pipes: the pipe would fill up, and
- you would block. So there isn't any easy way to conceal the
- differences between the two types of systems.)
-
- If you call both `pex_write_input' and `pex_read_output', be
- careful to avoid deadlock. If the output pipe fills up, so that
- each program in the pipeline is waiting for the next to read more
- data, and you fill the input pipe by writing more data to FP, then
- there is no way to make progress: the only process that could read
- data from the output pipe is you, but you are blocked on the input
- pipe. */
-
-extern FILE *pex_write_input (struct pex_obj *obj, int binary);
-
/* Return a stream for a temporary file to pass to the first program
in the pipeline as input. The file name is chosen as for pex_run.
pex_run closes the file automatically; don't close it yourself. */
extern int pex_get_times (struct pex_obj *, int count,
struct pex_time *vector);
-/* Clean up a pex_obj. */
+/* Clean up a pex_obj. If you have not called pex_get_times or
+ pex_get_status, this will try to kill the subprocesses. */
extern void pex_free (struct pex_obj *);
extern int strverscmp (const char *, const char *);
#endif
+/* Set the title of a process */
+extern void setproctitle (const char *name, ...);
+
#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
/* Drastically simplified alloca configurator. If we're using GCC,