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) */