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