Back to index

cell-binutils  2.17cvs20070401
libiberty.h
Go to the documentation of this file.
00001 /* Function declarations for libiberty.
00002 
00003    Copyright 2001, 2002, 2005 Free Software Foundation, Inc.
00004    
00005    Note - certain prototypes declared in this header file are for
00006    functions whoes implementation copyright does not belong to the
00007    FSF.  Those prototypes are present in this file for reference
00008    purposes only and their presence in this file should not construed
00009    as an indication of ownership by the FSF of the implementation of
00010    those functions in any way or form whatsoever.
00011 
00012    This program is free software; you can redistribute it and/or modify
00013    it under the terms of the GNU General Public License as published by
00014    the Free Software Foundation; either version 2, or (at your option)
00015    any later version.
00016 
00017    This program is distributed in the hope that it will be useful,
00018    but WITHOUT ANY WARRANTY; without even the implied warranty of
00019    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00020    GNU General Public License for more details.
00021 
00022    You should have received a copy of the GNU General Public License
00023    along with this program; if not, write to the Free Software
00024    Foundation, Inc., 51 Franklin Street - Fifth Floor,
00025    Boston, MA 02110-1301, USA.
00026    
00027    Written by Cygnus Support, 1994.
00028 
00029    The libiberty library provides a number of functions which are
00030    missing on some operating systems.  We do not declare those here,
00031    to avoid conflicts with the system header files on operating
00032    systems that do support those functions.  In this file we only
00033    declare those functions which are specific to libiberty.  */
00034 
00035 #ifndef LIBIBERTY_H
00036 #define LIBIBERTY_H
00037 
00038 #ifdef __cplusplus
00039 extern "C" {
00040 #endif
00041 
00042 #include "ansidecl.h"
00043 
00044 /* Get a definition for size_t.  */
00045 #include <stddef.h>
00046 /* Get a definition for va_list.  */
00047 #include <stdarg.h>
00048 
00049 #include <stdio.h>
00050 
00051 /* If the OS supports it, ensure that the supplied stream is setup to
00052    avoid any multi-threaded locking.  Otherwise leave the FILE pointer
00053    unchanged.  If the stream is NULL do nothing.  */
00054 
00055 extern void unlock_stream (FILE *);
00056 
00057 /* If the OS supports it, ensure that the standard I/O streams, stdin,
00058    stdout and stderr are setup to avoid any multi-threaded locking.
00059    Otherwise do nothing.  */
00060 
00061 extern void unlock_std_streams (void);
00062 
00063 /* Open and return a FILE pointer.  If the OS supports it, ensure that
00064    the stream is setup to avoid any multi-threaded locking.  Otherwise
00065    return the FILE pointer unchanged.  */
00066 
00067 extern FILE *fopen_unlocked (const char *, const char *);
00068 extern FILE *fdopen_unlocked (int, const char *);
00069 extern FILE *freopen_unlocked (const char *, const char *, FILE *);
00070 
00071 /* Build an argument vector from a string.  Allocates memory using
00072    malloc.  Use freeargv to free the vector.  */
00073 
00074 extern char **buildargv (const char *) ATTRIBUTE_MALLOC;
00075 
00076 /* Free a vector returned by buildargv.  */
00077 
00078 extern void freeargv (char **);
00079 
00080 /* Duplicate an argument vector. Allocates memory using malloc.  Use
00081    freeargv to free the vector.  */
00082 
00083 extern char **dupargv (char **) ATTRIBUTE_MALLOC;
00084 
00085 /* Expand "@file" arguments in argv.  */
00086 
00087 extern void expandargv PARAMS ((int *, char ***));
00088 
00089 /* Return the last component of a path name.  Note that we can't use a
00090    prototype here because the parameter is declared inconsistently
00091    across different systems, sometimes as "char *" and sometimes as
00092    "const char *" */
00093 
00094 /* HAVE_DECL_* is a three-state macro: undefined, 0 or 1.  If it is
00095    undefined, we haven't run the autoconf check so provide the
00096    declaration without arguments.  If it is 0, we checked and failed
00097    to find the declaration so provide a fully prototyped one.  If it
00098    is 1, we found it so don't provide any declaration at all.  */
00099 #if !HAVE_DECL_BASENAME
00100 #if defined (__GNU_LIBRARY__ ) || defined (__linux__) || defined (__FreeBSD__) || defined (__OpenBSD__) || defined(__NetBSD__) || defined (__CYGWIN__) || defined (__CYGWIN32__) || defined (__MINGW32__) || defined (HAVE_DECL_BASENAME)
00101 extern char *basename (const char *);
00102 #else
00103 /* Do not allow basename to be used if there is no prototype seen.  We
00104    either need to use the above prototype or have one from
00105    autoconf which would result in HAVE_DECL_BASENAME being set.  */
00106 #define basename basename_cannot_be_used_without_a_prototype
00107 #endif
00108 #endif
00109 
00110 /* A well-defined basename () that is always compiled in.  */
00111 
00112 extern const char *lbasename (const char *);
00113 
00114 /* A well-defined realpath () that is always compiled in.  */
00115 
00116 extern char *lrealpath (const char *);
00117 
00118 /* Concatenate an arbitrary number of strings.  You must pass NULL as
00119    the last argument of this function, to terminate the list of
00120    strings.  Allocates memory using xmalloc.  */
00121 
00122 extern char *concat (const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL;
00123 
00124 /* Concatenate an arbitrary number of strings.  You must pass NULL as
00125    the last argument of this function, to terminate the list of
00126    strings.  Allocates memory using xmalloc.  The first argument is
00127    not one of the strings to be concatenated, but if not NULL is a
00128    pointer to be freed after the new string is created, similar to the
00129    way xrealloc works.  */
00130 
00131 extern char *reconcat (char *, const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL;
00132 
00133 /* Determine the length of concatenating an arbitrary number of
00134    strings.  You must pass NULL as the last argument of this function,
00135    to terminate the list of strings.  */
00136 
00137 extern unsigned long concat_length (const char *, ...) ATTRIBUTE_SENTINEL;
00138 
00139 /* Concatenate an arbitrary number of strings into a SUPPLIED area of
00140    memory.  You must pass NULL as the last argument of this function,
00141    to terminate the list of strings.  The supplied memory is assumed
00142    to be large enough.  */
00143 
00144 extern char *concat_copy (char *, const char *, ...) ATTRIBUTE_SENTINEL;
00145 
00146 /* Concatenate an arbitrary number of strings into a GLOBAL area of
00147    memory.  You must pass NULL as the last argument of this function,
00148    to terminate the list of strings.  The supplied memory is assumed
00149    to be large enough.  */
00150 
00151 extern char *concat_copy2 (const char *, ...) ATTRIBUTE_SENTINEL;
00152 
00153 /* This is the global area used by concat_copy2.  */
00154 
00155 extern char *libiberty_concat_ptr;
00156 
00157 /* Concatenate an arbitrary number of strings.  You must pass NULL as
00158    the last argument of this function, to terminate the list of
00159    strings.  Allocates memory using alloca.  The arguments are
00160    evaluated twice!  */
00161 #define ACONCAT(ACONCAT_PARAMS) \
00162   (libiberty_concat_ptr = (char *) alloca (concat_length ACONCAT_PARAMS + 1), \
00163    concat_copy2 ACONCAT_PARAMS)
00164 
00165 /* Check whether two file descriptors refer to the same file.  */
00166 
00167 extern int fdmatch (int fd1, int fd2);
00168 
00169 /* Return the position of the first bit set in the argument.  */
00170 /* Prototypes vary from system to system, so we only provide a
00171    prototype on systems where we know that we need it.  */
00172 #if defined (HAVE_DECL_FFS) && !HAVE_DECL_FFS
00173 extern int ffs(int);
00174 #endif
00175 
00176 /* Get the working directory.  The result is cached, so don't call
00177    chdir() between calls to getpwd().  */
00178 
00179 extern char * getpwd (void);
00180 
00181 /* Get the current time.  */
00182 /* Prototypes vary from system to system, so we only provide a
00183    prototype on systems where we know that we need it.  */
00184 #ifdef __MINGW32__
00185 /* Forward declaration to avoid #include <sys/time.h>.   */
00186 struct timeval;
00187 extern int gettimeofday (struct timeval *, void *); 
00188 #endif
00189 
00190 /* Get the amount of time the process has run, in microseconds.  */
00191 
00192 extern long get_run_time (void);
00193 
00194 /* Generate a relocated path to some installation directory.  Allocates
00195    return value using malloc.  */
00196 
00197 extern char *make_relative_prefix (const char *, const char *,
00198                                    const char *) ATTRIBUTE_MALLOC;
00199 
00200 /* Generate a relocated path to some installation directory without
00201    attempting to follow any soft links.  Allocates
00202    return value using malloc.  */
00203 
00204 extern char *make_relative_prefix_ignore_links (const char *, const char *,
00205                                           const char *) ATTRIBUTE_MALLOC;
00206 
00207 /* Choose a temporary directory to use for scratch files.  */
00208 
00209 extern char *choose_temp_base (void) ATTRIBUTE_MALLOC;
00210 
00211 /* Return a temporary file name or NULL if unable to create one.  */
00212 
00213 extern char *make_temp_file (const char *) ATTRIBUTE_MALLOC;
00214 
00215 /* Remove a link to a file unless it is special. */
00216 
00217 extern int unlink_if_ordinary (const char *);
00218 
00219 /* Allocate memory filled with spaces.  Allocates using malloc.  */
00220 
00221 extern const char *spaces (int count);
00222 
00223 /* Return the maximum error number for which strerror will return a
00224    string.  */
00225 
00226 extern int errno_max (void);
00227 
00228 /* Return the name of an errno value (e.g., strerrno (EINVAL) returns
00229    "EINVAL").  */
00230 
00231 extern const char *strerrno (int);
00232 
00233 /* Given the name of an errno value, return the value.  */
00234 
00235 extern int strtoerrno (const char *);
00236 
00237 /* ANSI's strerror(), but more robust.  */
00238 
00239 extern char *xstrerror (int);
00240 
00241 /* Return the maximum signal number for which strsignal will return a
00242    string.  */
00243 
00244 extern int signo_max (void);
00245 
00246 /* Return a signal message string for a signal number
00247    (e.g., strsignal (SIGHUP) returns something like "Hangup").  */
00248 /* This is commented out as it can conflict with one in system headers.
00249    We still document its existence though.  */
00250 
00251 /*extern const char *strsignal (int);*/
00252 
00253 /* Return the name of a signal number (e.g., strsigno (SIGHUP) returns
00254    "SIGHUP").  */
00255 
00256 extern const char *strsigno (int);
00257 
00258 /* Given the name of a signal, return its number.  */
00259 
00260 extern int strtosigno (const char *);
00261 
00262 /* Register a function to be run by xexit.  Returns 0 on success.  */
00263 
00264 extern int xatexit (void (*fn) (void));
00265 
00266 /* Exit, calling all the functions registered with xatexit.  */
00267 
00268 extern void xexit (int status) ATTRIBUTE_NORETURN;
00269 
00270 /* Set the program name used by xmalloc.  */
00271 
00272 extern void xmalloc_set_program_name (const char *);
00273 
00274 /* Report an allocation failure.  */
00275 extern void xmalloc_failed (size_t) ATTRIBUTE_NORETURN;
00276 
00277 /* Allocate memory without fail.  If malloc fails, this will print a
00278    message to stderr (using the name set by xmalloc_set_program_name,
00279    if any) and then call xexit.  */
00280 
00281 extern void *xmalloc (size_t) ATTRIBUTE_MALLOC;
00282 
00283 /* Reallocate memory without fail.  This works like xmalloc.  Note,
00284    realloc type functions are not suitable for attribute malloc since
00285    they may return the same address across multiple calls. */
00286 
00287 extern void *xrealloc (void *, size_t);
00288 
00289 /* Allocate memory without fail and set it to zero.  This works like
00290    xmalloc.  */
00291 
00292 extern void *xcalloc (size_t, size_t) ATTRIBUTE_MALLOC;
00293 
00294 /* Copy a string into a memory buffer without fail.  */
00295 
00296 extern char *xstrdup (const char *) ATTRIBUTE_MALLOC;
00297 
00298 /* Copy at most N characters from string into a buffer without fail.  */
00299 
00300 extern char *xstrndup (const char *, size_t) ATTRIBUTE_MALLOC;
00301 
00302 /* Copy an existing memory buffer to a new memory buffer without fail.  */
00303 
00304 extern void *xmemdup (const void *, size_t, size_t) ATTRIBUTE_MALLOC;
00305 
00306 /* Physical memory routines.  Return values are in BYTES.  */
00307 extern double physmem_total (void);
00308 extern double physmem_available (void);
00309 
00310 
00311 /* These macros provide a K&R/C89/C++-friendly way of allocating structures
00312    with nice encapsulation.  The XDELETE*() macros are technically
00313    superfluous, but provided here for symmetry.  Using them consistently
00314    makes it easier to update client code to use different allocators such
00315    as new/delete and new[]/delete[].  */
00316 
00317 /* Scalar allocators.  */
00318 
00319 #define XNEW(T)                    ((T *) xmalloc (sizeof (T)))
00320 #define XCNEW(T)            ((T *) xcalloc (1, sizeof (T)))
00321 #define XDELETE(P)          free ((void*) (P))
00322 
00323 /* Array allocators.  */
00324 
00325 #define XNEWVEC(T, N)              ((T *) xmalloc (sizeof (T) * (N)))
00326 #define XCNEWVEC(T, N)             ((T *) xcalloc ((N), sizeof (T)))
00327 #define XRESIZEVEC(T, P, N) ((T *) xrealloc ((void *) (P), sizeof (T) * (N)))
00328 #define XDELETEVEC(P)              free ((void*) (P))
00329 
00330 /* Allocators for variable-sized structures and raw buffers.  */
00331 
00332 #define XNEWVAR(T, S)              ((T *) xmalloc ((S)))
00333 #define XCNEWVAR(T, S)             ((T *) xcalloc (1, (S)))
00334 #define XRESIZEVAR(T, P, S) ((T *) xrealloc ((P), (S)))
00335 
00336 /* Type-safe obstack allocator.  */
00337 
00338 #define XOBNEW(O, T)        ((T *) obstack_alloc ((O), sizeof (T)))
00339 #define XOBFINISH(O, T)         ((T) obstack_finish ((O)))
00340 
00341 /* hex character manipulation routines */
00342 
00343 #define _hex_array_size 256
00344 #define _hex_bad     99
00345 extern const unsigned char _hex_value[_hex_array_size];
00346 extern void hex_init (void);
00347 #define hex_p(c)     (hex_value (c) != _hex_bad)
00348 /* If you change this, note well: Some code relies on side effects in
00349    the argument being performed exactly once.  */
00350 #define hex_value(c) ((unsigned int) _hex_value[(unsigned char) (c)])
00351 
00352 /* Flags for pex_init.  These are bits to be or'ed together.  */
00353 
00354 /* Record subprocess times, if possible.  */
00355 #define PEX_RECORD_TIMES    0x1
00356 
00357 /* Use pipes for communication between processes, if possible.  */
00358 #define PEX_USE_PIPES              0x2
00359 
00360 /* Save files used for communication between processes.  */
00361 #define PEX_SAVE_TEMPS             0x4
00362 
00363 /* Prepare to execute one or more programs, with standard output of
00364    each program fed to standard input of the next.
00365    FLAGS      As above.
00366    PNAME      The name of the program to report in error messages.
00367    TEMPBASE   A base name to use for temporary files; may be NULL to
00368               use a random name.
00369    Returns NULL on error.  */
00370 
00371 extern struct pex_obj *pex_init (int flags, const char *pname,
00372                              const char *tempbase);
00373 
00374 /* Flags for pex_run.  These are bits to be or'ed together.  */
00375 
00376 /* Last program in pipeline.  Standard output of program goes to
00377    OUTNAME, or, if OUTNAME is NULL, to standard output of caller.  Do
00378    not set this if you want to call pex_read_output.  After this is
00379    set, pex_run may no longer be called with the same struct
00380    pex_obj.  */
00381 #define PEX_LAST            0x1
00382 
00383 /* Search for program in executable search path.  */
00384 #define PEX_SEARCH          0x2
00385 
00386 /* OUTNAME is a suffix.  */
00387 #define PEX_SUFFIX          0x4
00388 
00389 /* Send program's standard error to standard output.  */
00390 #define PEX_STDERR_TO_STDOUT       0x8
00391 
00392 /* Input file should be opened in binary mode.  This flag is ignored
00393    on Unix.  */
00394 #define PEX_BINARY_INPUT    0x10
00395 
00396 /* Output file should be opened in binary mode.  This flag is ignored
00397    on Unix.  For proper behaviour PEX_BINARY_INPUT and
00398    PEX_BINARY_OUTPUT have to match appropriately--i.e., a call using
00399    PEX_BINARY_OUTPUT should be followed by a call using
00400    PEX_BINARY_INPUT.  */
00401 #define PEX_BINARY_OUTPUT   0x20
00402 
00403 /* Capture stderr to a pipe.  The output can be read by
00404    calling pex_read_err and reading from the returned
00405    FILE object.  This flag may be specified only for
00406    the last program in a pipeline.  
00407 
00408    This flag is supported only on Unix and Windows.  */
00409 #define PEX_STDERR_TO_PIPE  0x40
00410 
00411 /* Capture stderr in binary mode.  This flag is ignored
00412    on Unix.  */
00413 #define PEX_BINARY_ERROR    0x80
00414 
00415 
00416 /* Execute one program.  Returns NULL on success.  On error returns an
00417    error string (typically just the name of a system call); the error
00418    string is statically allocated.
00419 
00420    OBJ        Returned by pex_init.
00421 
00422    FLAGS      As above.
00423 
00424    EXECUTABLE The program to execute.
00425 
00426    ARGV              NULL terminated array of arguments to pass to the program.
00427 
00428    OUTNAME    Sets the output file name as follows:
00429 
00430               PEX_SUFFIX set (OUTNAME may not be NULL):
00431                 TEMPBASE parameter to pex_init not NULL:
00432                   Output file name is the concatenation of TEMPBASE
00433                   and OUTNAME.
00434                 TEMPBASE is NULL:
00435                   Output file name is a random file name ending in
00436                   OUTNAME.
00437               PEX_SUFFIX not set:
00438                 OUTNAME not NULL:
00439                   Output file name is OUTNAME.
00440                 OUTNAME NULL, TEMPBASE not NULL:
00441                   Output file name is randomly chosen using
00442                   TEMPBASE.
00443                 OUTNAME NULL, TEMPBASE NULL:
00444                   Output file name is randomly chosen.
00445 
00446               If PEX_LAST is not set, the output file name is the
00447               name to use for a temporary file holding stdout, if
00448               any (there will not be a file if PEX_USE_PIPES is set
00449               and the system supports pipes).  If a file is used, it
00450               will be removed when no longer needed unless
00451               PEX_SAVE_TEMPS is set.
00452 
00453               If PEX_LAST is set, and OUTNAME is not NULL, standard
00454               output is written to the output file name.  The file
00455               will not be removed.  If PEX_LAST and PEX_SUFFIX are
00456               both set, TEMPBASE may not be NULL.
00457 
00458    ERRNAME    If not NULL, this is the name of a file to which
00459               standard error is written.  If NULL, standard error of
00460               the program is standard error of the caller.
00461 
00462    ERR        On an error return, *ERR is set to an errno value, or
00463               to 0 if there is no relevant errno.
00464 */
00465 
00466 extern const char *pex_run (struct pex_obj *obj, int flags,
00467                          const char *executable, char * const *argv,
00468                          const char *outname, const char *errname,
00469                          int *err);
00470 
00471 /* As for pex_run (), but takes an extra parameter to enable the
00472    environment for the child process to be specified.
00473 
00474    ENV        The environment for the child process, specified as
00475               an array of character pointers.  Each element of the
00476               array should point to a string of the form VAR=VALUE,
00477                 with the exception of the last element which must be
00478                 a null pointer.
00479 */
00480 
00481 extern const char *pex_run_in_environment (struct pex_obj *obj, int flags,
00482                                         const char *executable,
00483                                            char * const *argv,
00484                                            char * const *env,
00485                                              const char *outname,
00486                                       const char *errname, int *err);
00487 
00488 /* Return a stream for a temporary file to pass to the first program
00489    in the pipeline as input.  The file name is chosen as for pex_run.
00490    pex_run closes the file automatically; don't close it yourself.  */
00491 
00492 extern FILE *pex_input_file (struct pex_obj *obj, int flags,
00493                              const char *in_name);
00494 
00495 /* Return a stream for a pipe connected to the standard input of the
00496    first program in the pipeline.  You must have passed
00497    `PEX_USE_PIPES' to `pex_init'.  Close the returned stream
00498    yourself.  */
00499 
00500 extern FILE *pex_input_pipe (struct pex_obj *obj, int binary);
00501 
00502 /* Read the standard output of the last program to be executed.
00503    pex_run can not be called after this.  BINARY should be non-zero if
00504    the file should be opened in binary mode; this is ignored on Unix.
00505    Returns NULL on error.  Don't call fclose on the returned FILE; it
00506    will be closed by pex_free.  */
00507 
00508 extern FILE *pex_read_output (struct pex_obj *, int binary);
00509 
00510 /* Read the standard error of the last program to be executed.
00511    pex_run can not be called after this.  BINARY should be non-zero if
00512    the file should be opened in binary mode; this is ignored on Unix.
00513    Returns NULL on error.  Don't call fclose on the returned FILE; it
00514    will be closed by pex_free.  */
00515 
00516 extern FILE *pex_read_err (struct pex_obj *, int binary);
00517 
00518 /* Return exit status of all programs in VECTOR.  COUNT indicates the
00519    size of VECTOR.  The status codes in the vector are in the order of
00520    the calls to pex_run.  Returns 0 on error, 1 on success.  */
00521 
00522 extern int pex_get_status (struct pex_obj *, int count, int *vector);
00523 
00524 /* Return times of all programs in VECTOR.  COUNT indicates the size
00525    of VECTOR.  struct pex_time is really just struct timeval, but that
00526    is not portable to all systems.  Returns 0 on error, 1 on
00527    success.  */
00528 
00529 struct pex_time
00530 {
00531   unsigned long user_seconds;
00532   unsigned long user_microseconds;
00533   unsigned long system_seconds;
00534   unsigned long system_microseconds;
00535 };
00536 
00537 extern int pex_get_times (struct pex_obj *, int count,
00538                        struct pex_time *vector);
00539 
00540 /* Clean up a pex_obj.  */
00541 
00542 extern void pex_free (struct pex_obj *);
00543 
00544 /* Just execute one program.  Return value is as for pex_run.
00545    FLAGS      Combination of PEX_SEARCH and PEX_STDERR_TO_STDOUT.
00546    EXECUTABLE As for pex_run.
00547    ARGV              As for pex_run.
00548    PNAME      As for pex_init.
00549    OUTNAME    As for pex_run when PEX_LAST is set.
00550    ERRNAME    As for pex_run.
00551    STATUS     Set to exit status on success.
00552    ERR        As for pex_run.
00553 */
00554 
00555 extern const char *pex_one (int flags, const char *executable,
00556                          char * const *argv, const char *pname,
00557                          const char *outname, const char *errname,
00558                          int *status, int *err);
00559 
00560 /* pexecute and pwait are the old pexecute interface, still here for
00561    backward compatibility.  Don't use these for new code.  Instead,
00562    use pex_init/pex_run/pex_get_status/pex_free, or pex_one.  */
00563 
00564 /* Definitions used by the pexecute routine.  */
00565 
00566 #define PEXECUTE_FIRST   1
00567 #define PEXECUTE_LAST    2
00568 #define PEXECUTE_ONE     (PEXECUTE_FIRST + PEXECUTE_LAST)
00569 #define PEXECUTE_SEARCH  4
00570 #define PEXECUTE_VERBOSE 8
00571 
00572 /* Execute a program.  */
00573 
00574 extern int pexecute (const char *, char * const *, const char *,
00575                      const char *, char **, char **, int);
00576 
00577 /* Wait for pexecute to finish.  */
00578 
00579 extern int pwait (int, int *, int);
00580 
00581 #if !HAVE_DECL_ASPRINTF
00582 /* Like sprintf but provides a pointer to malloc'd storage, which must
00583    be freed by the caller.  */
00584 
00585 extern int asprintf (char **, const char *, ...) ATTRIBUTE_PRINTF_2;
00586 #endif
00587 
00588 #if !HAVE_DECL_VASPRINTF
00589 /* Like vsprintf but provides a pointer to malloc'd storage, which
00590    must be freed by the caller.  */
00591 
00592 extern int vasprintf (char **, const char *, va_list) ATTRIBUTE_PRINTF(2,0);
00593 #endif
00594 
00595 #if defined(HAVE_DECL_SNPRINTF) && !HAVE_DECL_SNPRINTF
00596 /* Like sprintf but prints at most N characters.  */
00597 extern int snprintf (char *, size_t, const char *, ...) ATTRIBUTE_PRINTF_3;
00598 #endif
00599 
00600 #if defined(HAVE_DECL_VSNPRINTF) && !HAVE_DECL_VSNPRINTF
00601 /* Like vsprintf but prints at most N characters.  */
00602 extern int vsnprintf (char *, size_t, const char *, va_list) ATTRIBUTE_PRINTF(3,0);
00603 #endif
00604 
00605 #if defined(HAVE_DECL_STRVERSCMP) && !HAVE_DECL_STRVERSCMP
00606 /* Compare version strings.  */
00607 extern int strverscmp (const char *, const char *);
00608 #endif
00609 
00610 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
00611 
00612 /* Drastically simplified alloca configurator.  If we're using GCC,
00613    we use __builtin_alloca; otherwise we use the C alloca.  The C
00614    alloca is always available.  You can override GCC by defining
00615    USE_C_ALLOCA yourself.  The canonical autoconf macro C_ALLOCA is
00616    also set/unset as it is often used to indicate whether code needs
00617    to call alloca(0).  */
00618 extern void *C_alloca (size_t) ATTRIBUTE_MALLOC;
00619 #undef alloca
00620 #if GCC_VERSION >= 2000 && !defined USE_C_ALLOCA
00621 # define alloca(x) __builtin_alloca(x)
00622 # undef C_ALLOCA
00623 # define ASTRDUP(X) \
00624   (__extension__ ({ const char *const libiberty_optr = (X); \
00625    const unsigned long libiberty_len = strlen (libiberty_optr) + 1; \
00626    char *const libiberty_nptr = (char *const) alloca (libiberty_len); \
00627    (char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len); }))
00628 #else
00629 # define alloca(x) C_alloca(x)
00630 # undef USE_C_ALLOCA
00631 # define USE_C_ALLOCA 1
00632 # undef C_ALLOCA
00633 # define C_ALLOCA 1
00634 extern const char *libiberty_optr;
00635 extern char *libiberty_nptr;
00636 extern unsigned long libiberty_len;
00637 # define ASTRDUP(X) \
00638   (libiberty_optr = (X), \
00639    libiberty_len = strlen (libiberty_optr) + 1, \
00640    libiberty_nptr = (char *) alloca (libiberty_len), \
00641    (char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len))
00642 #endif
00643 
00644 #ifdef __cplusplus
00645 }
00646 #endif
00647 
00648 
00649 #endif /* ! defined (LIBIBERTY_H) */