libiberty:
[external/binutils.git] / include / libiberty.h
1 /* Function declarations for libiberty.
2
3    Copyright 2001, 2002, 2005 Free Software Foundation, Inc.
4    
5    Note - certain prototypes declared in this header file are for
6    functions whoes implementation copyright does not belong to the
7    FSF.  Those prototypes are present in this file for reference
8    purposes only and their presence in this file should not construed
9    as an indication of ownership by the FSF of the implementation of
10    those functions in any way or form whatsoever.
11
12    This program is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 2, or (at your option)
15    any later version.
16
17    This program is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20    GNU General Public License for more details.
21
22    You should have received a copy of the GNU General Public License
23    along with this program; if not, write to the Free Software
24    Foundation, Inc., 59 Temple Place - Suite 330,
25    Boston, MA 02111-1307, USA.
26    
27    Written by Cygnus Support, 1994.
28
29    The libiberty library provides a number of functions which are
30    missing on some operating systems.  We do not declare those here,
31    to avoid conflicts with the system header files on operating
32    systems that do support those functions.  In this file we only
33    declare those functions which are specific to libiberty.  */
34
35 #ifndef LIBIBERTY_H
36 #define LIBIBERTY_H
37
38 #ifdef __cplusplus
39 extern "C" {
40 #endif
41
42 #include "ansidecl.h"
43
44 /* Get a definition for size_t.  */
45 #include <stddef.h>
46 /* Get a definition for va_list.  */
47 #include <stdarg.h>
48
49 #include <stdio.h>
50
51 /* Build an argument vector from a string.  Allocates memory using
52    malloc.  Use freeargv to free the vector.  */
53
54 extern char **buildargv (const char *) ATTRIBUTE_MALLOC;
55
56 /* Free a vector returned by buildargv.  */
57
58 extern void freeargv (char **);
59
60 /* Duplicate an argument vector. Allocates memory using malloc.  Use
61    freeargv to free the vector.  */
62
63 extern char **dupargv (char **) ATTRIBUTE_MALLOC;
64
65
66 /* Return the last component of a path name.  Note that we can't use a
67    prototype here because the parameter is declared inconsistently
68    across different systems, sometimes as "char *" and sometimes as
69    "const char *" */
70
71 /* HAVE_DECL_* is a three-state macro: undefined, 0 or 1.  If it is
72    undefined, we haven't run the autoconf check so provide the
73    declaration without arguments.  If it is 0, we checked and failed
74    to find the declaration so provide a fully prototyped one.  If it
75    is 1, we found it so don't provide any declaration at all.  */
76 #if !HAVE_DECL_BASENAME
77 #if defined (__GNU_LIBRARY__ ) || defined (__linux__) || defined (__FreeBSD__) || defined (__OpenBSD__) || defined(__NetBSD__) || defined (__CYGWIN__) || defined (__CYGWIN32__) || defined (__MINGW32__) || defined (HAVE_DECL_BASENAME)
78 extern char *basename (const char *);
79 #else
80 extern char *basename ();
81 #endif
82 #endif
83
84 /* A well-defined basename () that is always compiled in.  */
85
86 extern const char *lbasename (const char *);
87
88 /* A well-defined realpath () that is always compiled in.  */
89
90 extern char *lrealpath (const char *);
91
92 /* Concatenate an arbitrary number of strings.  You must pass NULL as
93    the last argument of this function, to terminate the list of
94    strings.  Allocates memory using xmalloc.  */
95
96 extern char *concat (const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL;
97
98 /* Concatenate an arbitrary number of strings.  You must pass NULL as
99    the last argument of this function, to terminate the list of
100    strings.  Allocates memory using xmalloc.  The first argument is
101    not one of the strings to be concatenated, but if not NULL is a
102    pointer to be freed after the new string is created, similar to the
103    way xrealloc works.  */
104
105 extern char *reconcat (char *, const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL;
106
107 /* Determine the length of concatenating an arbitrary number of
108    strings.  You must pass NULL as the last argument of this function,
109    to terminate the list of strings.  */
110
111 extern unsigned long concat_length (const char *, ...) ATTRIBUTE_SENTINEL;
112
113 /* Concatenate an arbitrary number of strings into a SUPPLIED area of
114    memory.  You must pass NULL as the last argument of this function,
115    to terminate the list of strings.  The supplied memory is assumed
116    to be large enough.  */
117
118 extern char *concat_copy (char *, const char *, ...) ATTRIBUTE_SENTINEL;
119
120 /* Concatenate an arbitrary number of strings into a GLOBAL area of
121    memory.  You must pass NULL as the last argument of this function,
122    to terminate the list of strings.  The supplied memory is assumed
123    to be large enough.  */
124
125 extern char *concat_copy2 (const char *, ...) ATTRIBUTE_SENTINEL;
126
127 /* This is the global area used by concat_copy2.  */
128
129 extern char *libiberty_concat_ptr;
130
131 /* Concatenate an arbitrary number of strings.  You must pass NULL as
132    the last argument of this function, to terminate the list of
133    strings.  Allocates memory using alloca.  The arguments are
134    evaluated twice!  */
135 #define ACONCAT(ACONCAT_PARAMS) \
136   (libiberty_concat_ptr = alloca (concat_length ACONCAT_PARAMS + 1), \
137    concat_copy2 ACONCAT_PARAMS)
138
139 /* Check whether two file descriptors refer to the same file.  */
140
141 extern int fdmatch (int fd1, int fd2);
142
143 /* Return the position of the first bit set in the argument.  */
144 /* Prototypes vary from system to system, so we only provide a
145    prototype on systems where we know that we need it.  */
146 #if defined (HAVE_DECL_FFS) && !HAVE_DECL_FFS
147 extern int ffs(int);
148 #endif
149
150 /* Get the working directory.  The result is cached, so don't call
151    chdir() between calls to getpwd().  */
152
153 extern char * getpwd (void);
154
155 /* Get the current time.  */
156 /* Prototypes vary from system to system, so we only provide a
157    prototype on systems where we know that we need it.  */
158 #ifdef __MINGW32__
159 /* Forward declaration to avoid #include <sys/time.h>.   */
160 struct timeval;
161 extern int gettimeofday (struct timeval *, void *); 
162 #endif
163
164 /* Get the amount of time the process has run, in microseconds.  */
165
166 extern long get_run_time (void);
167
168 /* Generate a relocated path to some installation directory.  Allocates
169    return value using malloc.  */
170
171 extern char *make_relative_prefix (const char *, const char *,
172                                    const char *) ATTRIBUTE_MALLOC;
173
174 /* Choose a temporary directory to use for scratch files.  */
175
176 extern char *choose_temp_base (void) ATTRIBUTE_MALLOC;
177
178 /* Return a temporary file name or NULL if unable to create one.  */
179
180 extern char *make_temp_file (const char *) ATTRIBUTE_MALLOC;
181
182 /* Remove a link to a file unless it is special. */
183
184 extern int unlink_if_ordinary (const char *);
185
186 /* Allocate memory filled with spaces.  Allocates using malloc.  */
187
188 extern const char *spaces (int count);
189
190 /* Return the maximum error number for which strerror will return a
191    string.  */
192
193 extern int errno_max (void);
194
195 /* Return the name of an errno value (e.g., strerrno (EINVAL) returns
196    "EINVAL").  */
197
198 extern const char *strerrno (int);
199
200 /* Given the name of an errno value, return the value.  */
201
202 extern int strtoerrno (const char *);
203
204 /* ANSI's strerror(), but more robust.  */
205
206 extern char *xstrerror (int);
207
208 /* Return the maximum signal number for which strsignal will return a
209    string.  */
210
211 extern int signo_max (void);
212
213 /* Return a signal message string for a signal number
214    (e.g., strsignal (SIGHUP) returns something like "Hangup").  */
215 /* This is commented out as it can conflict with one in system headers.
216    We still document its existence though.  */
217
218 /*extern const char *strsignal (int);*/
219
220 /* Return the name of a signal number (e.g., strsigno (SIGHUP) returns
221    "SIGHUP").  */
222
223 extern const char *strsigno (int);
224
225 /* Given the name of a signal, return its number.  */
226
227 extern int strtosigno (const char *);
228
229 /* Register a function to be run by xexit.  Returns 0 on success.  */
230
231 extern int xatexit (void (*fn) (void));
232
233 /* Exit, calling all the functions registered with xatexit.  */
234
235 extern void xexit (int status) ATTRIBUTE_NORETURN;
236
237 /* Set the program name used by xmalloc.  */
238
239 extern void xmalloc_set_program_name (const char *);
240
241 /* Report an allocation failure.  */
242 extern void xmalloc_failed (size_t) ATTRIBUTE_NORETURN;
243
244 /* Allocate memory without fail.  If malloc fails, this will print a
245    message to stderr (using the name set by xmalloc_set_program_name,
246    if any) and then call xexit.  */
247
248 extern PTR xmalloc (size_t) ATTRIBUTE_MALLOC;
249
250 /* Reallocate memory without fail.  This works like xmalloc.  Note,
251    realloc type functions are not suitable for attribute malloc since
252    they may return the same address across multiple calls. */
253
254 extern PTR xrealloc (PTR, size_t);
255
256 /* Allocate memory without fail and set it to zero.  This works like
257    xmalloc.  */
258
259 extern PTR xcalloc (size_t, size_t) ATTRIBUTE_MALLOC;
260
261 /* Copy a string into a memory buffer without fail.  */
262
263 extern char *xstrdup (const char *) ATTRIBUTE_MALLOC;
264
265 /* Copy at most N characters from string into a buffer without fail.  */
266
267 extern char *xstrndup (const char *, size_t) ATTRIBUTE_MALLOC;
268
269 /* Copy an existing memory buffer to a new memory buffer without fail.  */
270
271 extern PTR xmemdup (const PTR, size_t, size_t) ATTRIBUTE_MALLOC;
272
273 /* Physical memory routines.  Return values are in BYTES.  */
274 extern double physmem_total (void);
275 extern double physmem_available (void);
276
277
278 /* These macros provide a K&R/C89/C++-friendly way of allocating structures
279    with nice encapsulation.  The XDELETE*() macros are technically
280    superfluous, but provided here for symmetry.  Using them consistently
281    makes it easier to update client code to use different allocators such
282    as new/delete and new[]/delete[].  */
283
284 /* Scalar allocators.  */
285
286 #define XNEW(T)                 ((T *) xmalloc (sizeof (T)))
287 #define XCNEW(T)                ((T *) xcalloc (1, sizeof (T)))
288 #define XDELETE(P)              free ((void*) (P))
289
290 /* Array allocators.  */
291
292 #define XNEWVEC(T, N)           ((T *) xmalloc (sizeof (T) * (N)))
293 #define XCNEWVEC(T, N)          ((T *) xcalloc ((N), sizeof (T)))
294 #define XRESIZEVEC(T, P, N)     ((T *) xrealloc ((void *) (P), sizeof (T) * (N)))
295 #define XDELETEVEC(P)           free ((void*) (P))
296
297 /* Allocators for variable-sized structures and raw buffers.  */
298
299 #define XNEWVAR(T, S)           ((T *) xmalloc ((S)))
300 #define XCNEWVAR(T, S)          ((T *) xcalloc (1, (S)))
301 #define XRESIZEVAR(T, P, S)     ((T *) xrealloc ((P), (S)))
302
303 /* Type-safe obstack allocator.  */
304
305 #define XOBNEW(O, T)            ((T *) obstack_alloc ((O), sizeof (T)))
306
307
308 /* hex character manipulation routines */
309
310 #define _hex_array_size 256
311 #define _hex_bad        99
312 extern const unsigned char _hex_value[_hex_array_size];
313 extern void hex_init (void);
314 #define hex_p(c)        (hex_value (c) != _hex_bad)
315 /* If you change this, note well: Some code relies on side effects in
316    the argument being performed exactly once.  */
317 #define hex_value(c)    ((unsigned int) _hex_value[(unsigned char) (c)])
318
319 /* Flags for pex_init.  These are bits to be or'ed together.  */
320
321 /* Record subprocess times, if possible.  */
322 #define PEX_RECORD_TIMES        0x1
323
324 /* Use pipes for communication between processes, if possible.  */
325 #define PEX_USE_PIPES           0x2
326
327 /* Save files used for communication between processes.  */
328 #define PEX_SAVE_TEMPS          0x4
329
330 /* Prepare to execute one or more programs, with standard output of
331    each program fed to standard input of the next.
332    FLAGS        As above.
333    PNAME        The name of the program to report in error messages.
334    TEMPBASE     A base name to use for temporary files; may be NULL to
335                 use a random name.
336    Returns NULL on error.  */
337
338 extern struct pex_obj *pex_init (int flags, const char *pname,
339                                  const char *tempbase);
340
341 /* Flags for pex_run.  These are bits to be or'ed together.  */
342
343 /* Last program in pipeline.  Standard output of program goes to
344    OUTNAME, or, if OUTNAME is NULL, to standard output of caller.  Do
345    not set this if you want to call pex_read_output.  After this is
346    set, pex_run may no longer be called with the same struct
347    pex_obj.  */
348 #define PEX_LAST                0x1
349
350 /* Search for program in executable search path.  */
351 #define PEX_SEARCH              0x2
352
353 /* OUTNAME is a suffix.  */
354 #define PEX_SUFFIX              0x4
355
356 /* Send program's standard error to standard output.  */
357 #define PEX_STDERR_TO_STDOUT    0x8
358
359 /* Input file should be opened in binary mode.  This flag is ignored
360    on Unix.  */
361 #define PEX_BINARY_INPUT        0x10
362
363 /* Output file should be opened in binary mode.  This flag is ignored
364    on Unix.  For proper behaviour PEX_BINARY_INPUT and
365    PEX_BINARY_OUTPUT have to match appropriately--i.e., a call using
366    PEX_BINARY_OUTPUT should be followed by a call using
367    PEX_BINARY_INPUT.  */
368 #define PEX_BINARY_OUTPUT       0x20
369
370 /* Execute one program.  Returns NULL on success.  On error returns an
371    error string (typically just the name of a system call); the error
372    string is statically allocated.
373
374    OBJ          Returned by pex_init.
375
376    FLAGS        As above.
377
378    EXECUTABLE   The program to execute.
379
380    ARGV         NULL terminated array of arguments to pass to the program.
381
382    OUTNAME      Sets the output file name as follows:
383
384                 PEX_SUFFIX set (OUTNAME may not be NULL):
385                   TEMPBASE parameter to pex_init not NULL:
386                     Output file name is the concatenation of TEMPBASE
387                     and OUTNAME.
388                   TEMPBASE is NULL:
389                     Output file name is a random file name ending in
390                     OUTNAME.
391                 PEX_SUFFIX not set:
392                   OUTNAME not NULL:
393                     Output file name is OUTNAME.
394                   OUTNAME NULL, TEMPBASE not NULL:
395                     Output file name is randomly chosen using
396                     TEMPBASE.
397                   OUTNAME NULL, TEMPBASE NULL:
398                     Output file name is randomly chosen.
399
400                 If PEX_LAST is not set, the output file name is the
401                 name to use for a temporary file holding stdout, if
402                 any (there will not be a file if PEX_USE_PIPES is set
403                 and the system supports pipes).  If a file is used, it
404                 will be removed when no longer needed unless
405                 PEX_SAVE_TEMPS is set.
406
407                 If PEX_LAST is set, and OUTNAME is not NULL, standard
408                 output is written to the output file name.  The file
409                 will not be removed.  If PEX_LAST and PEX_SUFFIX are
410                 both set, TEMPBASE may not be NULL.
411
412    ERRNAME      If not NULL, this is the name of a file to which
413                 standard error is written.  If NULL, standard error of
414                 the program is standard error of the caller.
415
416    ERR          On an error return, *ERR is set to an errno value, or
417                 to 0 if there is no relevant errno.
418 */
419
420 extern const char *pex_run (struct pex_obj *obj, int flags,
421                             const char *executable, char * const *argv,
422                             const char *outname, const char *errname,
423                             int *err);
424
425 /* Read the standard output of the last program to be executed.
426    pex_run can not be called after this.  BINARY should be non-zero if
427    the file should be opened in binary mode; this is ignored on Unix.
428    Returns NULL on error.  Don't call fclose on the returned FILE; it
429    will be closed by pex_free.  */
430
431 extern FILE *pex_read_output (struct pex_obj *, int binary);
432
433 /* Return exit status of all programs in VECTOR.  COUNT indicates the
434    size of VECTOR.  The status codes in the vector are in the order of
435    the calls to pex_run.  Returns 0 on error, 1 on success.  */
436
437 extern int pex_get_status (struct pex_obj *, int count, int *vector);
438
439 /* Return times of all programs in VECTOR.  COUNT indicates the size
440    of VECTOR.  struct pex_time is really just struct timeval, but that
441    is not portable to all systems.  Returns 0 on error, 1 on
442    success.  */
443
444 struct pex_time
445 {
446   unsigned long user_seconds;
447   unsigned long user_microseconds;
448   unsigned long system_seconds;
449   unsigned long system_microseconds;
450 };
451
452 extern int pex_get_times (struct pex_obj *, int count,
453                           struct pex_time *vector);
454
455 /* Clean up a pex_obj.  */
456
457   extern void pex_free (struct pex_obj *);
458
459 /* Just execute one program.  Return value is as for pex_run.
460    FLAGS        Combination of PEX_SEARCH and PEX_STDERR_TO_STDOUT.
461    EXECUTABLE   As for pex_run.
462    ARGV         As for pex_run.
463    PNAME        As for pex_init.
464    OUTNAME      As for pex_run when PEX_LAST is set.
465    ERRNAME      As for pex_run.
466    STATUS       Set to exit status on success.
467    ERR          As for pex_run.
468 */
469
470 extern const char *pex_one (int flags, const char *executable,
471                             char * const *argv, const char *pname,
472                             const char *outname, const char *errname,
473                             int *status, int *err);
474
475 /* pexecute and pwait are the old pexecute interface, still here for
476    backward compatibility.  Don't use these for new code.  Instead,
477    use pex_init/pex_run/pex_get_status/pex_free, or pex_one.  */
478
479 /* Definitions used by the pexecute routine.  */
480
481 #define PEXECUTE_FIRST   1
482 #define PEXECUTE_LAST    2
483 #define PEXECUTE_ONE     (PEXECUTE_FIRST + PEXECUTE_LAST)
484 #define PEXECUTE_SEARCH  4
485 #define PEXECUTE_VERBOSE 8
486
487 /* Execute a program.  */
488
489 extern int pexecute (const char *, char * const *, const char *,
490                      const char *, char **, char **, int);
491
492 /* Wait for pexecute to finish.  */
493
494 extern int pwait (int, int *, int);
495
496 #if !HAVE_DECL_ASPRINTF
497 /* Like sprintf but provides a pointer to malloc'd storage, which must
498    be freed by the caller.  */
499
500 extern int asprintf (char **, const char *, ...) ATTRIBUTE_PRINTF_2;
501 #endif
502
503 #if !HAVE_DECL_VASPRINTF
504 /* Like vsprintf but provides a pointer to malloc'd storage, which
505    must be freed by the caller.  */
506
507 extern int vasprintf (char **, const char *, va_list)
508   ATTRIBUTE_PRINTF(2,0);
509 #endif
510
511 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
512
513 /* Drastically simplified alloca configurator.  If we're using GCC,
514    we use __builtin_alloca; otherwise we use the C alloca.  The C
515    alloca is always available.  You can override GCC by defining
516    USE_C_ALLOCA yourself.  The canonical autoconf macro C_ALLOCA is
517    also set/unset as it is often used to indicate whether code needs
518    to call alloca(0).  */
519 extern PTR C_alloca (size_t) ATTRIBUTE_MALLOC;
520 #undef alloca
521 #if GCC_VERSION >= 2000 && !defined USE_C_ALLOCA
522 # define alloca(x) __builtin_alloca(x)
523 # undef C_ALLOCA
524 # define ASTRDUP(X) \
525   (__extension__ ({ const char *const libiberty_optr = (X); \
526    const unsigned long libiberty_len = strlen (libiberty_optr) + 1; \
527    char *const libiberty_nptr = (char *const) alloca (libiberty_len); \
528    (char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len); }))
529 #else
530 # define alloca(x) C_alloca(x)
531 # undef USE_C_ALLOCA
532 # define USE_C_ALLOCA 1
533 # undef C_ALLOCA
534 # define C_ALLOCA 1
535 extern const char *libiberty_optr;
536 extern char *libiberty_nptr;
537 extern unsigned long libiberty_len;
538 # define ASTRDUP(X) \
539   (libiberty_optr = (X), \
540    libiberty_len = strlen (libiberty_optr) + 1, \
541    libiberty_nptr = (char *) alloca (libiberty_len), \
542    (char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len))
543 #endif
544
545 #ifdef __cplusplus
546 }
547 #endif
548
549
550 #endif /* ! defined (LIBIBERTY_H) */