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 /* Choose a temporary directory to use for scratch files. */ 00201 00202 extern char *choose_temp_base (void) ATTRIBUTE_MALLOC; 00203 00204 /* Return a temporary file name or NULL if unable to create one. */ 00205 00206 extern char *make_temp_file (const char *) ATTRIBUTE_MALLOC; 00207 00208 /* Remove a link to a file unless it is special. */ 00209 00210 extern int unlink_if_ordinary (const char *); 00211 00212 /* Allocate memory filled with spaces. Allocates using malloc. */ 00213 00214 extern const char *spaces (int count); 00215 00216 /* Return the maximum error number for which strerror will return a 00217 string. */ 00218 00219 extern int errno_max (void); 00220 00221 /* Return the name of an errno value (e.g., strerrno (EINVAL) returns 00222 "EINVAL"). */ 00223 00224 extern const char *strerrno (int); 00225 00226 /* Given the name of an errno value, return the value. */ 00227 00228 extern int strtoerrno (const char *); 00229 00230 /* ANSI's strerror(), but more robust. */ 00231 00232 extern char *xstrerror (int); 00233 00234 /* Return the maximum signal number for which strsignal will return a 00235 string. */ 00236 00237 extern int signo_max (void); 00238 00239 /* Return a signal message string for a signal number 00240 (e.g., strsignal (SIGHUP) returns something like "Hangup"). */ 00241 /* This is commented out as it can conflict with one in system headers. 00242 We still document its existence though. */ 00243 00244 /*extern const char *strsignal (int);*/ 00245 00246 /* Return the name of a signal number (e.g., strsigno (SIGHUP) returns 00247 "SIGHUP"). */ 00248 00249 extern const char *strsigno (int); 00250 00251 /* Given the name of a signal, return its number. */ 00252 00253 extern int strtosigno (const char *); 00254 00255 /* Register a function to be run by xexit. Returns 0 on success. */ 00256 00257 extern int xatexit (void (*fn) (void)); 00258 00259 /* Exit, calling all the functions registered with xatexit. */ 00260 00261 extern void xexit (int status) ATTRIBUTE_NORETURN; 00262 00263 /* Set the program name used by xmalloc. */ 00264 00265 extern void xmalloc_set_program_name (const char *); 00266 00267 /* Report an allocation failure. */ 00268 extern void xmalloc_failed (size_t) ATTRIBUTE_NORETURN; 00269 00270 /* Allocate memory without fail. If malloc fails, this will print a 00271 message to stderr (using the name set by xmalloc_set_program_name, 00272 if any) and then call xexit. */ 00273 00274 extern void *xmalloc (size_t) ATTRIBUTE_MALLOC; 00275 00276 /* Reallocate memory without fail. This works like xmalloc. Note, 00277 realloc type functions are not suitable for attribute malloc since 00278 they may return the same address across multiple calls. */ 00279 00280 extern void *xrealloc (void *, size_t); 00281 00282 /* Allocate memory without fail and set it to zero. This works like 00283 xmalloc. */ 00284 00285 extern void *xcalloc (size_t, size_t) ATTRIBUTE_MALLOC; 00286 00287 /* Copy a string into a memory buffer without fail. */ 00288 00289 extern char *xstrdup (const char *) ATTRIBUTE_MALLOC; 00290 00291 /* Copy at most N characters from string into a buffer without fail. */ 00292 00293 extern char *xstrndup (const char *, size_t) ATTRIBUTE_MALLOC; 00294 00295 /* Copy an existing memory buffer to a new memory buffer without fail. */ 00296 00297 extern void *xmemdup (const void *, size_t, size_t) ATTRIBUTE_MALLOC; 00298 00299 /* Physical memory routines. Return values are in BYTES. */ 00300 extern double physmem_total (void); 00301 extern double physmem_available (void); 00302 00303 00304 /* These macros provide a K&R/C89/C++-friendly way of allocating structures 00305 with nice encapsulation. The XDELETE*() macros are technically 00306 superfluous, but provided here for symmetry. Using them consistently 00307 makes it easier to update client code to use different allocators such 00308 as new/delete and new[]/delete[]. */ 00309 00310 /* Scalar allocators. */ 00311 00312 #define XNEW(T) ((T *) xmalloc (sizeof (T))) 00313 #define XCNEW(T) ((T *) xcalloc (1, sizeof (T))) 00314 #define XDELETE(P) free ((void*) (P)) 00315 00316 /* Array allocators. */ 00317 00318 #define XNEWVEC(T, N) ((T *) xmalloc (sizeof (T) * (N))) 00319 #define XCNEWVEC(T, N) ((T *) xcalloc ((N), sizeof (T))) 00320 #define XRESIZEVEC(T, P, N) ((T *) xrealloc ((void *) (P), sizeof (T) * (N))) 00321 #define XDELETEVEC(P) free ((void*) (P)) 00322 00323 /* Allocators for variable-sized structures and raw buffers. */ 00324 00325 #define XNEWVAR(T, S) ((T *) xmalloc ((S))) 00326 #define XCNEWVAR(T, S) ((T *) xcalloc (1, (S))) 00327 #define XRESIZEVAR(T, P, S) ((T *) xrealloc ((P), (S))) 00328 00329 /* Type-safe obstack allocator. */ 00330 00331 #define XOBNEW(O, T) ((T *) obstack_alloc ((O), sizeof (T))) 00332 #define XOBFINISH(O, T) ((T) obstack_finish ((O))) 00333 00334 /* hex character manipulation routines */ 00335 00336 #define _hex_array_size 256 00337 #define _hex_bad 99 00338 extern const unsigned char _hex_value[_hex_array_size]; 00339 extern void hex_init (void); 00340 #define hex_p(c) (hex_value (c) != _hex_bad) 00341 /* If you change this, note well: Some code relies on side effects in 00342 the argument being performed exactly once. */ 00343 #define hex_value(c) ((unsigned int) _hex_value[(unsigned char) (c)]) 00344 00345 /* Flags for pex_init. These are bits to be or'ed together. */ 00346 00347 /* Record subprocess times, if possible. */ 00348 #define PEX_RECORD_TIMES 0x1 00349 00350 /* Use pipes for communication between processes, if possible. */ 00351 #define PEX_USE_PIPES 0x2 00352 00353 /* Save files used for communication between processes. */ 00354 #define PEX_SAVE_TEMPS 0x4 00355 00356 /* Prepare to execute one or more programs, with standard output of 00357 each program fed to standard input of the next. 00358 FLAGS As above. 00359 PNAME The name of the program to report in error messages. 00360 TEMPBASE A base name to use for temporary files; may be NULL to 00361 use a random name. 00362 Returns NULL on error. */ 00363 00364 extern struct pex_obj *pex_init (int flags, const char *pname, 00365 const char *tempbase); 00366 00367 /* Flags for pex_run. These are bits to be or'ed together. */ 00368 00369 /* Last program in pipeline. Standard output of program goes to 00370 OUTNAME, or, if OUTNAME is NULL, to standard output of caller. Do 00371 not set this if you want to call pex_read_output. After this is 00372 set, pex_run may no longer be called with the same struct 00373 pex_obj. */ 00374 #define PEX_LAST 0x1 00375 00376 /* Search for program in executable search path. */ 00377 #define PEX_SEARCH 0x2 00378 00379 /* OUTNAME is a suffix. */ 00380 #define PEX_SUFFIX 0x4 00381 00382 /* Send program's standard error to standard output. */ 00383 #define PEX_STDERR_TO_STDOUT 0x8 00384 00385 /* Input file should be opened in binary mode. This flag is ignored 00386 on Unix. */ 00387 #define PEX_BINARY_INPUT 0x10 00388 00389 /* Output file should be opened in binary mode. This flag is ignored 00390 on Unix. For proper behaviour PEX_BINARY_INPUT and 00391 PEX_BINARY_OUTPUT have to match appropriately--i.e., a call using 00392 PEX_BINARY_OUTPUT should be followed by a call using 00393 PEX_BINARY_INPUT. */ 00394 #define PEX_BINARY_OUTPUT 0x20 00395 00396 /* Execute one program. Returns NULL on success. On error returns an 00397 error string (typically just the name of a system call); the error 00398 string is statically allocated. 00399 00400 OBJ Returned by pex_init. 00401 00402 FLAGS As above. 00403 00404 EXECUTABLE The program to execute. 00405 00406 ARGV NULL terminated array of arguments to pass to the program. 00407 00408 OUTNAME Sets the output file name as follows: 00409 00410 PEX_SUFFIX set (OUTNAME may not be NULL): 00411 TEMPBASE parameter to pex_init not NULL: 00412 Output file name is the concatenation of TEMPBASE 00413 and OUTNAME. 00414 TEMPBASE is NULL: 00415 Output file name is a random file name ending in 00416 OUTNAME. 00417 PEX_SUFFIX not set: 00418 OUTNAME not NULL: 00419 Output file name is OUTNAME. 00420 OUTNAME NULL, TEMPBASE not NULL: 00421 Output file name is randomly chosen using 00422 TEMPBASE. 00423 OUTNAME NULL, TEMPBASE NULL: 00424 Output file name is randomly chosen. 00425 00426 If PEX_LAST is not set, the output file name is the 00427 name to use for a temporary file holding stdout, if 00428 any (there will not be a file if PEX_USE_PIPES is set 00429 and the system supports pipes). If a file is used, it 00430 will be removed when no longer needed unless 00431 PEX_SAVE_TEMPS is set. 00432 00433 If PEX_LAST is set, and OUTNAME is not NULL, standard 00434 output is written to the output file name. The file 00435 will not be removed. If PEX_LAST and PEX_SUFFIX are 00436 both set, TEMPBASE may not be NULL. 00437 00438 ERRNAME If not NULL, this is the name of a file to which 00439 standard error is written. If NULL, standard error of 00440 the program is standard error of the caller. 00441 00442 ERR On an error return, *ERR is set to an errno value, or 00443 to 0 if there is no relevant errno. 00444 */ 00445 00446 extern const char *pex_run (struct pex_obj *obj, int flags, 00447 const char *executable, char * const *argv, 00448 const char *outname, const char *errname, 00449 int *err); 00450 00451 /* As for pex_run (), but takes an extra parameter to enable the 00452 environment for the child process to be specified. 00453 00454 ENV The environment for the child process, specified as 00455 an array of character pointers. Each element of the 00456 array should point to a string of the form VAR=VALUE, 00457 with the exception of the last element which must be 00458 a null pointer. 00459 */ 00460 00461 extern const char *pex_run_in_environment (struct pex_obj *obj, int flags, 00462 const char *executable, 00463 char * const *argv, 00464 char * const *env, 00465 const char *outname, 00466 const char *errname, int *err); 00467 00468 /* Return a stream for a temporary file to pass to the first program 00469 in the pipeline as input. The file name is chosen as for pex_run. 00470 pex_run closes the file automatically; don't close it yourself. */ 00471 00472 extern FILE *pex_input_file (struct pex_obj *obj, int flags, 00473 const char *in_name); 00474 00475 /* Return a stream for a pipe connected to the standard input of the 00476 first program in the pipeline. You must have passed 00477 `PEX_USE_PIPES' to `pex_init'. Close the returned stream 00478 yourself. */ 00479 00480 extern FILE *pex_input_pipe (struct pex_obj *obj, int binary); 00481 00482 /* Read the standard output of the last program to be executed. 00483 pex_run can not be called after this. BINARY should be non-zero if 00484 the file should be opened in binary mode; this is ignored on Unix. 00485 Returns NULL on error. Don't call fclose on the returned FILE; it 00486 will be closed by pex_free. */ 00487 00488 extern FILE *pex_read_output (struct pex_obj *, int binary); 00489 00490 /* Return exit status of all programs in VECTOR. COUNT indicates the 00491 size of VECTOR. The status codes in the vector are in the order of 00492 the calls to pex_run. Returns 0 on error, 1 on success. */ 00493 00494 extern int pex_get_status (struct pex_obj *, int count, int *vector); 00495 00496 /* Return times of all programs in VECTOR. COUNT indicates the size 00497 of VECTOR. struct pex_time is really just struct timeval, but that 00498 is not portable to all systems. Returns 0 on error, 1 on 00499 success. */ 00500 00501 struct pex_time 00502 { 00503 unsigned long user_seconds; 00504 unsigned long user_microseconds; 00505 unsigned long system_seconds; 00506 unsigned long system_microseconds; 00507 }; 00508 00509 extern int pex_get_times (struct pex_obj *, int count, 00510 struct pex_time *vector); 00511 00512 /* Clean up a pex_obj. */ 00513 00514 extern void pex_free (struct pex_obj *); 00515 00516 /* Just execute one program. Return value is as for pex_run. 00517 FLAGS Combination of PEX_SEARCH and PEX_STDERR_TO_STDOUT. 00518 EXECUTABLE As for pex_run. 00519 ARGV As for pex_run. 00520 PNAME As for pex_init. 00521 OUTNAME As for pex_run when PEX_LAST is set. 00522 ERRNAME As for pex_run. 00523 STATUS Set to exit status on success. 00524 ERR As for pex_run. 00525 */ 00526 00527 extern const char *pex_one (int flags, const char *executable, 00528 char * const *argv, const char *pname, 00529 const char *outname, const char *errname, 00530 int *status, int *err); 00531 00532 /* pexecute and pwait are the old pexecute interface, still here for 00533 backward compatibility. Don't use these for new code. Instead, 00534 use pex_init/pex_run/pex_get_status/pex_free, or pex_one. */ 00535 00536 /* Definitions used by the pexecute routine. */ 00537 00538 #define PEXECUTE_FIRST 1 00539 #define PEXECUTE_LAST 2 00540 #define PEXECUTE_ONE (PEXECUTE_FIRST + PEXECUTE_LAST) 00541 #define PEXECUTE_SEARCH 4 00542 #define PEXECUTE_VERBOSE 8 00543 00544 /* Execute a program. */ 00545 00546 extern int pexecute (const char *, char * const *, const char *, 00547 const char *, char **, char **, int); 00548 00549 /* Wait for pexecute to finish. */ 00550 00551 extern int pwait (int, int *, int); 00552 00553 #if !HAVE_DECL_ASPRINTF 00554 /* Like sprintf but provides a pointer to malloc'd storage, which must 00555 be freed by the caller. */ 00556 00557 extern int asprintf (char **, const char *, ...) ATTRIBUTE_PRINTF_2; 00558 #endif 00559 00560 #if !HAVE_DECL_VASPRINTF 00561 /* Like vsprintf but provides a pointer to malloc'd storage, which 00562 must be freed by the caller. */ 00563 00564 extern int vasprintf (char **, const char *, va_list) ATTRIBUTE_PRINTF(2,0); 00565 #endif 00566 00567 #if defined(HAVE_DECL_SNPRINTF) && !HAVE_DECL_SNPRINTF 00568 /* Like sprintf but prints at most N characters. */ 00569 extern int snprintf (char *, size_t, const char *, ...) ATTRIBUTE_PRINTF_3; 00570 #endif 00571 00572 #if defined(HAVE_DECL_VSNPRINTF) && !HAVE_DECL_VSNPRINTF 00573 /* Like vsprintf but prints at most N characters. */ 00574 extern int vsnprintf (char *, size_t, const char *, va_list) ATTRIBUTE_PRINTF(3,0); 00575 #endif 00576 00577 #if defined(HAVE_DECL_STRVERSCMP) && !HAVE_DECL_STRVERSCMP 00578 /* Compare version strings. */ 00579 extern int strverscmp (const char *, const char *); 00580 #endif 00581 00582 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0])) 00583 00584 /* Drastically simplified alloca configurator. If we're using GCC, 00585 we use __builtin_alloca; otherwise we use the C alloca. The C 00586 alloca is always available. You can override GCC by defining 00587 USE_C_ALLOCA yourself. The canonical autoconf macro C_ALLOCA is 00588 also set/unset as it is often used to indicate whether code needs 00589 to call alloca(0). */ 00590 extern void *C_alloca (size_t) ATTRIBUTE_MALLOC; 00591 #undef alloca 00592 #if GCC_VERSION >= 2000 && !defined USE_C_ALLOCA 00593 # define alloca(x) __builtin_alloca(x) 00594 # undef C_ALLOCA 00595 # define ASTRDUP(X) \ 00596 (__extension__ ({ const char *const libiberty_optr = (X); \ 00597 const unsigned long libiberty_len = strlen (libiberty_optr) + 1; \ 00598 char *const libiberty_nptr = (char *const) alloca (libiberty_len); \ 00599 (char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len); })) 00600 #else 00601 # define alloca(x) C_alloca(x) 00602 # undef USE_C_ALLOCA 00603 # define USE_C_ALLOCA 1 00604 # undef C_ALLOCA 00605 # define C_ALLOCA 1 00606 extern const char *libiberty_optr; 00607 extern char *libiberty_nptr; 00608 extern unsigned long libiberty_len; 00609 # define ASTRDUP(X) \ 00610 (libiberty_optr = (X), \ 00611 libiberty_len = strlen (libiberty_optr) + 1, \ 00612 libiberty_nptr = (char *) alloca (libiberty_len), \ 00613 (char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len)) 00614 #endif 00615 00616 #ifdef __cplusplus 00617 } 00618 #endif 00619 00620 00621 #endif /* ! defined (LIBIBERTY_H) */
1.5.6