OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [include/] [libiberty.h] - Blame information for rev 840

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.