cxxfilt 0.1.0 → 0.1.1
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +5 -5
- data/Gemfile.lock +2 -2
- data/README.md +32 -3
- data/cxxfilt.gemspec +1 -1
- data/ext/cxxfilt/cp-demangle.c +6772 -0
- data/ext/cxxfilt/cp-demangle.h +194 -0
- data/ext/cxxfilt/cp-demint.c +237 -0
- data/ext/cxxfilt/cplus-dem.c +5032 -0
- data/ext/cxxfilt/cxxfilt.c +2 -1
- data/ext/cxxfilt/d-demangle.c +1646 -0
- data/ext/cxxfilt/demangle.h +723 -0
- data/ext/cxxfilt/environ.h +35 -0
- data/ext/cxxfilt/extconf.rb +0 -1
- data/ext/cxxfilt/libiberty.h +755 -0
- data/ext/cxxfilt/rust-demangle.c +348 -0
- data/ext/cxxfilt/safe-ctype.c +254 -0
- data/ext/cxxfilt/safe-ctype.h +150 -0
- data/ext/cxxfilt/xexit.c +52 -0
- data/ext/cxxfilt/xmalloc.c +184 -0
- data/ext/cxxfilt/xmemdup.c +41 -0
- data/ext/cxxfilt/xstrdup.c +36 -0
- data/lib/cxxfilt/cxxfilt.rb +6 -6
- data/lib/cxxfilt/version.rb +1 -1
- metadata +19 -4
@@ -0,0 +1,755 @@
|
|
1
|
+
/* Function declarations for libiberty.
|
2
|
+
|
3
|
+
Copyright (C) 1997-2018 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., 51 Franklin Street - Fifth Floor,
|
25
|
+
Boston, MA 02110-1301, 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
|
+
/* If the OS supports it, ensure that the supplied stream is setup to
|
52
|
+
avoid any multi-threaded locking. Otherwise leave the FILE pointer
|
53
|
+
unchanged. If the stream is NULL do nothing. */
|
54
|
+
|
55
|
+
extern void unlock_stream (FILE *);
|
56
|
+
|
57
|
+
/* If the OS supports it, ensure that the standard I/O streams, stdin,
|
58
|
+
stdout and stderr are setup to avoid any multi-threaded locking.
|
59
|
+
Otherwise do nothing. */
|
60
|
+
|
61
|
+
extern void unlock_std_streams (void);
|
62
|
+
|
63
|
+
/* Open and return a FILE pointer. If the OS supports it, ensure that
|
64
|
+
the stream is setup to avoid any multi-threaded locking. Otherwise
|
65
|
+
return the FILE pointer unchanged. */
|
66
|
+
|
67
|
+
extern FILE *fopen_unlocked (const char *, const char *);
|
68
|
+
extern FILE *fdopen_unlocked (int, const char *);
|
69
|
+
extern FILE *freopen_unlocked (const char *, const char *, FILE *);
|
70
|
+
|
71
|
+
/* Build an argument vector from a string. Allocates memory using
|
72
|
+
malloc. Use freeargv to free the vector. */
|
73
|
+
|
74
|
+
extern char **buildargv (const char *) ATTRIBUTE_MALLOC;
|
75
|
+
|
76
|
+
/* Free a vector returned by buildargv. */
|
77
|
+
|
78
|
+
extern void freeargv (char **);
|
79
|
+
|
80
|
+
/* Duplicate an argument vector. Allocates memory using malloc. Use
|
81
|
+
freeargv to free the vector. */
|
82
|
+
|
83
|
+
extern char **dupargv (char * const *) ATTRIBUTE_MALLOC;
|
84
|
+
|
85
|
+
/* Expand "@file" arguments in argv. */
|
86
|
+
|
87
|
+
extern void expandargv (int *, char ***);
|
88
|
+
|
89
|
+
/* Write argv to an @-file, inserting necessary quoting. */
|
90
|
+
|
91
|
+
extern int writeargv (char * const *, FILE *);
|
92
|
+
|
93
|
+
/* Return the number of elements in argv. */
|
94
|
+
|
95
|
+
extern int countargv (char * const *);
|
96
|
+
|
97
|
+
/* Return the last component of a path name. Note that we can't use a
|
98
|
+
prototype here because the parameter is declared inconsistently
|
99
|
+
across different systems, sometimes as "char *" and sometimes as
|
100
|
+
"const char *" */
|
101
|
+
|
102
|
+
/* HAVE_DECL_* is a three-state macro: undefined, 0 or 1. If it is
|
103
|
+
undefined, we haven't run the autoconf check so provide the
|
104
|
+
declaration without arguments. If it is 0, we checked and failed
|
105
|
+
to find the declaration so provide a fully prototyped one. If it
|
106
|
+
is 1, we found it so don't provide any declaration at all. */
|
107
|
+
#if !HAVE_DECL_BASENAME
|
108
|
+
#if defined (__GNU_LIBRARY__ ) || defined (__linux__) \
|
109
|
+
|| defined (__FreeBSD__) || defined (__OpenBSD__) || defined (__NetBSD__) \
|
110
|
+
|| defined (__CYGWIN__) || defined (__CYGWIN32__) || defined (__MINGW32__) \
|
111
|
+
|| defined (__DragonFly__) || defined (HAVE_DECL_BASENAME)
|
112
|
+
extern char *basename (const char *) ATTRIBUTE_RETURNS_NONNULL ATTRIBUTE_NONNULL(1);
|
113
|
+
#else
|
114
|
+
/* Do not allow basename to be used if there is no prototype seen. We
|
115
|
+
either need to use the above prototype or have one from
|
116
|
+
autoconf which would result in HAVE_DECL_BASENAME being set. */
|
117
|
+
#define basename basename_cannot_be_used_without_a_prototype
|
118
|
+
#endif
|
119
|
+
#endif
|
120
|
+
|
121
|
+
/* A well-defined basename () that is always compiled in. */
|
122
|
+
|
123
|
+
extern const char *lbasename (const char *) ATTRIBUTE_RETURNS_NONNULL ATTRIBUTE_NONNULL(1);
|
124
|
+
|
125
|
+
/* Same, but assumes DOS semantics (drive name, backslash is also a
|
126
|
+
dir separator) regardless of host. */
|
127
|
+
|
128
|
+
extern const char *dos_lbasename (const char *) ATTRIBUTE_RETURNS_NONNULL ATTRIBUTE_NONNULL(1);
|
129
|
+
|
130
|
+
/* Same, but assumes Unix semantics (absolute paths always start with
|
131
|
+
a slash, only forward slash is accepted as dir separator)
|
132
|
+
regardless of host. */
|
133
|
+
|
134
|
+
extern const char *unix_lbasename (const char *) ATTRIBUTE_RETURNS_NONNULL ATTRIBUTE_NONNULL(1);
|
135
|
+
|
136
|
+
/* A well-defined realpath () that is always compiled in. */
|
137
|
+
|
138
|
+
extern char *lrealpath (const char *);
|
139
|
+
|
140
|
+
/* Concatenate an arbitrary number of strings. You must pass NULL as
|
141
|
+
the last argument of this function, to terminate the list of
|
142
|
+
strings. Allocates memory using xmalloc. */
|
143
|
+
|
144
|
+
extern char *concat (const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL ATTRIBUTE_SENTINEL;
|
145
|
+
|
146
|
+
/* Concatenate an arbitrary number of strings. You must pass NULL as
|
147
|
+
the last argument of this function, to terminate the list of
|
148
|
+
strings. Allocates memory using xmalloc. The first argument is
|
149
|
+
not one of the strings to be concatenated, but if not NULL is a
|
150
|
+
pointer to be freed after the new string is created, similar to the
|
151
|
+
way xrealloc works. */
|
152
|
+
|
153
|
+
extern char *reconcat (char *, const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL ATTRIBUTE_SENTINEL;
|
154
|
+
|
155
|
+
/* Determine the length of concatenating an arbitrary number of
|
156
|
+
strings. You must pass NULL as the last argument of this function,
|
157
|
+
to terminate the list of strings. */
|
158
|
+
|
159
|
+
extern unsigned long concat_length (const char *, ...) ATTRIBUTE_SENTINEL;
|
160
|
+
|
161
|
+
/* Concatenate an arbitrary number of strings into a SUPPLIED area of
|
162
|
+
memory. You must pass NULL as the last argument of this function,
|
163
|
+
to terminate the list of strings. The supplied memory is assumed
|
164
|
+
to be large enough. */
|
165
|
+
|
166
|
+
extern char *concat_copy (char *, const char *, ...) ATTRIBUTE_RETURNS_NONNULL ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL;
|
167
|
+
|
168
|
+
/* Concatenate an arbitrary number of strings into a GLOBAL area of
|
169
|
+
memory. You must pass NULL as the last argument of this function,
|
170
|
+
to terminate the list of strings. The supplied memory is assumed
|
171
|
+
to be large enough. */
|
172
|
+
|
173
|
+
extern char *concat_copy2 (const char *, ...) ATTRIBUTE_RETURNS_NONNULL ATTRIBUTE_SENTINEL;
|
174
|
+
|
175
|
+
/* This is the global area used by concat_copy2. */
|
176
|
+
|
177
|
+
extern char *libiberty_concat_ptr;
|
178
|
+
|
179
|
+
/* Concatenate an arbitrary number of strings. You must pass NULL as
|
180
|
+
the last argument of this function, to terminate the list of
|
181
|
+
strings. Allocates memory using alloca. The arguments are
|
182
|
+
evaluated twice! */
|
183
|
+
#define ACONCAT(ACONCAT_PARAMS) \
|
184
|
+
(libiberty_concat_ptr = (char *) alloca (concat_length ACONCAT_PARAMS + 1), \
|
185
|
+
concat_copy2 ACONCAT_PARAMS)
|
186
|
+
|
187
|
+
/* Check whether two file descriptors refer to the same file. */
|
188
|
+
|
189
|
+
extern int fdmatch (int fd1, int fd2);
|
190
|
+
|
191
|
+
/* Return the position of the first bit set in the argument. */
|
192
|
+
/* Prototypes vary from system to system, so we only provide a
|
193
|
+
prototype on systems where we know that we need it. */
|
194
|
+
#if defined (HAVE_DECL_FFS) && !HAVE_DECL_FFS
|
195
|
+
extern int ffs(int);
|
196
|
+
#endif
|
197
|
+
|
198
|
+
/* Get the working directory. The result is cached, so don't call
|
199
|
+
chdir() between calls to getpwd(). */
|
200
|
+
|
201
|
+
extern char * getpwd (void);
|
202
|
+
|
203
|
+
/* Get the current time. */
|
204
|
+
/* Prototypes vary from system to system, so we only provide a
|
205
|
+
prototype on systems where we know that we need it. */
|
206
|
+
#ifdef __MINGW32__
|
207
|
+
/* Forward declaration to avoid #include <sys/time.h>. */
|
208
|
+
struct timeval;
|
209
|
+
extern int gettimeofday (struct timeval *, void *);
|
210
|
+
#endif
|
211
|
+
|
212
|
+
/* Get the amount of time the process has run, in microseconds. */
|
213
|
+
|
214
|
+
extern long get_run_time (void);
|
215
|
+
|
216
|
+
/* Generate a relocated path to some installation directory. Allocates
|
217
|
+
return value using malloc. */
|
218
|
+
|
219
|
+
extern char *make_relative_prefix (const char *, const char *,
|
220
|
+
const char *) ATTRIBUTE_MALLOC;
|
221
|
+
|
222
|
+
/* Generate a relocated path to some installation directory without
|
223
|
+
attempting to follow any soft links. Allocates
|
224
|
+
return value using malloc. */
|
225
|
+
|
226
|
+
extern char *make_relative_prefix_ignore_links (const char *, const char *,
|
227
|
+
const char *) ATTRIBUTE_MALLOC;
|
228
|
+
|
229
|
+
/* Returns a pointer to a directory path suitable for creating temporary
|
230
|
+
files in. */
|
231
|
+
|
232
|
+
extern const char *choose_tmpdir (void) ATTRIBUTE_RETURNS_NONNULL;
|
233
|
+
|
234
|
+
/* Choose a temporary directory to use for scratch files. */
|
235
|
+
|
236
|
+
extern char *choose_temp_base (void) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL;
|
237
|
+
|
238
|
+
/* Return a temporary file name or NULL if unable to create one. */
|
239
|
+
|
240
|
+
extern char *make_temp_file (const char *) ATTRIBUTE_MALLOC;
|
241
|
+
|
242
|
+
/* Return a temporary file name with given PREFIX and SUFFIX
|
243
|
+
or NULL if unable to create one. */
|
244
|
+
|
245
|
+
extern char *make_temp_file_with_prefix (const char *, const char *) ATTRIBUTE_MALLOC;
|
246
|
+
|
247
|
+
/* Remove a link to a file unless it is special. */
|
248
|
+
|
249
|
+
extern int unlink_if_ordinary (const char *);
|
250
|
+
|
251
|
+
/* Allocate memory filled with spaces. Allocates using malloc. */
|
252
|
+
|
253
|
+
extern const char *spaces (int count);
|
254
|
+
|
255
|
+
/* Return the maximum error number for which strerror will return a
|
256
|
+
string. */
|
257
|
+
|
258
|
+
extern int errno_max (void);
|
259
|
+
|
260
|
+
/* Return the name of an errno value (e.g., strerrno (EINVAL) returns
|
261
|
+
"EINVAL"). */
|
262
|
+
|
263
|
+
extern const char *strerrno (int);
|
264
|
+
|
265
|
+
/* Given the name of an errno value, return the value. */
|
266
|
+
|
267
|
+
extern int strtoerrno (const char *);
|
268
|
+
|
269
|
+
/* ANSI's strerror(), but more robust. */
|
270
|
+
|
271
|
+
extern char *xstrerror (int) ATTRIBUTE_RETURNS_NONNULL;
|
272
|
+
|
273
|
+
/* Return the maximum signal number for which strsignal will return a
|
274
|
+
string. */
|
275
|
+
|
276
|
+
extern int signo_max (void);
|
277
|
+
|
278
|
+
/* Return a signal message string for a signal number
|
279
|
+
(e.g., strsignal (SIGHUP) returns something like "Hangup"). */
|
280
|
+
/* This is commented out as it can conflict with one in system headers.
|
281
|
+
We still document its existence though. */
|
282
|
+
|
283
|
+
/*extern const char *strsignal (int);*/
|
284
|
+
|
285
|
+
/* Return the name of a signal number (e.g., strsigno (SIGHUP) returns
|
286
|
+
"SIGHUP"). */
|
287
|
+
|
288
|
+
extern const char *strsigno (int);
|
289
|
+
|
290
|
+
/* Given the name of a signal, return its number. */
|
291
|
+
|
292
|
+
extern int strtosigno (const char *);
|
293
|
+
|
294
|
+
/* Register a function to be run by xexit. Returns 0 on success. */
|
295
|
+
|
296
|
+
extern int xatexit (void (*fn) (void));
|
297
|
+
|
298
|
+
/* Exit, calling all the functions registered with xatexit. */
|
299
|
+
|
300
|
+
extern void xexit (int status) ATTRIBUTE_NORETURN;
|
301
|
+
|
302
|
+
/* Set the program name used by xmalloc. */
|
303
|
+
|
304
|
+
extern void xmalloc_set_program_name (const char *);
|
305
|
+
|
306
|
+
/* Report an allocation failure. */
|
307
|
+
extern void xmalloc_failed (size_t) ATTRIBUTE_NORETURN;
|
308
|
+
|
309
|
+
/* Allocate memory without fail. If malloc fails, this will print a
|
310
|
+
message to stderr (using the name set by xmalloc_set_program_name,
|
311
|
+
if any) and then call xexit. */
|
312
|
+
|
313
|
+
extern void *xmalloc (size_t) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL;
|
314
|
+
|
315
|
+
/* Reallocate memory without fail. This works like xmalloc. Note,
|
316
|
+
realloc type functions are not suitable for attribute malloc since
|
317
|
+
they may return the same address across multiple calls. */
|
318
|
+
|
319
|
+
extern void *xrealloc (void *, size_t) ATTRIBUTE_RETURNS_NONNULL;
|
320
|
+
|
321
|
+
/* Allocate memory without fail and set it to zero. This works like
|
322
|
+
xmalloc. */
|
323
|
+
|
324
|
+
extern void *xcalloc (size_t, size_t) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL;
|
325
|
+
|
326
|
+
/* Copy a string into a memory buffer without fail. */
|
327
|
+
|
328
|
+
extern char *xstrdup (const char *) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL;
|
329
|
+
|
330
|
+
/* Copy at most N characters from string into a buffer without fail. */
|
331
|
+
|
332
|
+
extern char *xstrndup (const char *, size_t) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL;
|
333
|
+
|
334
|
+
/* Copy an existing memory buffer to a new memory buffer without fail. */
|
335
|
+
|
336
|
+
extern void *xmemdup (const void *, size_t, size_t) ATTRIBUTE_MALLOC ATTRIBUTE_RETURNS_NONNULL;
|
337
|
+
|
338
|
+
/* Physical memory routines. Return values are in BYTES. */
|
339
|
+
extern double physmem_total (void);
|
340
|
+
extern double physmem_available (void);
|
341
|
+
|
342
|
+
/* Compute the 32-bit CRC of a block of memory. */
|
343
|
+
extern unsigned int xcrc32 (const unsigned char *, int, unsigned int);
|
344
|
+
|
345
|
+
/* These macros provide a K&R/C89/C++-friendly way of allocating structures
|
346
|
+
with nice encapsulation. The XDELETE*() macros are technically
|
347
|
+
superfluous, but provided here for symmetry. Using them consistently
|
348
|
+
makes it easier to update client code to use different allocators such
|
349
|
+
as new/delete and new[]/delete[]. */
|
350
|
+
|
351
|
+
/* Scalar allocators. */
|
352
|
+
|
353
|
+
#define XALLOCA(T) ((T *) alloca (sizeof (T)))
|
354
|
+
#define XNEW(T) ((T *) xmalloc (sizeof (T)))
|
355
|
+
#define XCNEW(T) ((T *) xcalloc (1, sizeof (T)))
|
356
|
+
#define XDUP(T, P) ((T *) xmemdup ((P), sizeof (T), sizeof (T)))
|
357
|
+
#define XDELETE(P) free ((void*) (P))
|
358
|
+
|
359
|
+
/* Array allocators. */
|
360
|
+
|
361
|
+
#define XALLOCAVEC(T, N) ((T *) alloca (sizeof (T) * (N)))
|
362
|
+
#define XNEWVEC(T, N) ((T *) xmalloc (sizeof (T) * (N)))
|
363
|
+
#define XCNEWVEC(T, N) ((T *) xcalloc ((N), sizeof (T)))
|
364
|
+
#define XDUPVEC(T, P, N) ((T *) xmemdup ((P), sizeof (T) * (N), sizeof (T) * (N)))
|
365
|
+
#define XRESIZEVEC(T, P, N) ((T *) xrealloc ((void *) (P), sizeof (T) * (N)))
|
366
|
+
#define XDELETEVEC(P) free ((void*) (P))
|
367
|
+
|
368
|
+
/* Allocators for variable-sized structures and raw buffers. */
|
369
|
+
|
370
|
+
#define XALLOCAVAR(T, S) ((T *) alloca ((S)))
|
371
|
+
#define XNEWVAR(T, S) ((T *) xmalloc ((S)))
|
372
|
+
#define XCNEWVAR(T, S) ((T *) xcalloc (1, (S)))
|
373
|
+
#define XDUPVAR(T, P, S1, S2) ((T *) xmemdup ((P), (S1), (S2)))
|
374
|
+
#define XRESIZEVAR(T, P, S) ((T *) xrealloc ((P), (S)))
|
375
|
+
|
376
|
+
/* Type-safe obstack allocator. */
|
377
|
+
|
378
|
+
#define XOBNEW(O, T) ((T *) obstack_alloc ((O), sizeof (T)))
|
379
|
+
#define XOBNEWVEC(O, T, N) ((T *) obstack_alloc ((O), sizeof (T) * (N)))
|
380
|
+
#define XOBNEWVAR(O, T, S) ((T *) obstack_alloc ((O), (S)))
|
381
|
+
#define XOBFINISH(O, T) ((T) obstack_finish ((O)))
|
382
|
+
|
383
|
+
/* hex character manipulation routines */
|
384
|
+
|
385
|
+
#define _hex_array_size 256
|
386
|
+
#define _hex_bad 99
|
387
|
+
extern const unsigned char _hex_value[_hex_array_size];
|
388
|
+
extern void hex_init (void);
|
389
|
+
#define hex_p(c) (hex_value (c) != _hex_bad)
|
390
|
+
/* If you change this, note well: Some code relies on side effects in
|
391
|
+
the argument being performed exactly once. */
|
392
|
+
#define hex_value(c) ((unsigned int) _hex_value[(unsigned char) (c)])
|
393
|
+
|
394
|
+
/* Flags for pex_init. These are bits to be or'ed together. */
|
395
|
+
|
396
|
+
/* Record subprocess times, if possible. */
|
397
|
+
#define PEX_RECORD_TIMES 0x1
|
398
|
+
|
399
|
+
/* Use pipes for communication between processes, if possible. */
|
400
|
+
#define PEX_USE_PIPES 0x2
|
401
|
+
|
402
|
+
/* Save files used for communication between processes. */
|
403
|
+
#define PEX_SAVE_TEMPS 0x4
|
404
|
+
|
405
|
+
/* Max number of alloca bytes per call before we must switch to malloc.
|
406
|
+
|
407
|
+
?? Swiped from gnulib's regex_internal.h header. Is this actually
|
408
|
+
the case? This number seems arbitrary, though sane.
|
409
|
+
|
410
|
+
The OS usually guarantees only one guard page at the bottom of the stack,
|
411
|
+
and a page size can be as small as 4096 bytes. So we cannot safely
|
412
|
+
allocate anything larger than 4096 bytes. Also care for the possibility
|
413
|
+
of a few compiler-allocated temporary stack slots. */
|
414
|
+
#define MAX_ALLOCA_SIZE 4032
|
415
|
+
|
416
|
+
/* Prepare to execute one or more programs, with standard output of
|
417
|
+
each program fed to standard input of the next.
|
418
|
+
FLAGS As above.
|
419
|
+
PNAME The name of the program to report in error messages.
|
420
|
+
TEMPBASE A base name to use for temporary files; may be NULL to
|
421
|
+
use a random name.
|
422
|
+
Returns NULL on error. */
|
423
|
+
|
424
|
+
extern struct pex_obj *pex_init (int flags, const char *pname,
|
425
|
+
const char *tempbase) ATTRIBUTE_RETURNS_NONNULL;
|
426
|
+
|
427
|
+
/* Flags for pex_run. These are bits to be or'ed together. */
|
428
|
+
|
429
|
+
/* Last program in pipeline. Standard output of program goes to
|
430
|
+
OUTNAME, or, if OUTNAME is NULL, to standard output of caller. Do
|
431
|
+
not set this if you want to call pex_read_output. After this is
|
432
|
+
set, pex_run may no longer be called with the same struct
|
433
|
+
pex_obj. */
|
434
|
+
#define PEX_LAST 0x1
|
435
|
+
|
436
|
+
/* Search for program in executable search path. */
|
437
|
+
#define PEX_SEARCH 0x2
|
438
|
+
|
439
|
+
/* OUTNAME is a suffix. */
|
440
|
+
#define PEX_SUFFIX 0x4
|
441
|
+
|
442
|
+
/* Send program's standard error to standard output. */
|
443
|
+
#define PEX_STDERR_TO_STDOUT 0x8
|
444
|
+
|
445
|
+
/* Input file should be opened in binary mode. This flag is ignored
|
446
|
+
on Unix. */
|
447
|
+
#define PEX_BINARY_INPUT 0x10
|
448
|
+
|
449
|
+
/* Output file should be opened in binary mode. This flag is ignored
|
450
|
+
on Unix. For proper behaviour PEX_BINARY_INPUT and
|
451
|
+
PEX_BINARY_OUTPUT have to match appropriately--i.e., a call using
|
452
|
+
PEX_BINARY_OUTPUT should be followed by a call using
|
453
|
+
PEX_BINARY_INPUT. */
|
454
|
+
#define PEX_BINARY_OUTPUT 0x20
|
455
|
+
|
456
|
+
/* Capture stderr to a pipe. The output can be read by
|
457
|
+
calling pex_read_err and reading from the returned
|
458
|
+
FILE object. This flag may be specified only for
|
459
|
+
the last program in a pipeline.
|
460
|
+
|
461
|
+
This flag is supported only on Unix and Windows. */
|
462
|
+
#define PEX_STDERR_TO_PIPE 0x40
|
463
|
+
|
464
|
+
/* Capture stderr in binary mode. This flag is ignored
|
465
|
+
on Unix. */
|
466
|
+
#define PEX_BINARY_ERROR 0x80
|
467
|
+
|
468
|
+
/* Append stdout to existing file instead of truncating it. */
|
469
|
+
#define PEX_STDOUT_APPEND 0x100
|
470
|
+
|
471
|
+
/* Thes same as PEX_STDOUT_APPEND, but for STDERR. */
|
472
|
+
#define PEX_STDERR_APPEND 0x200
|
473
|
+
|
474
|
+
/* Execute one program. Returns NULL on success. On error returns an
|
475
|
+
error string (typically just the name of a system call); the error
|
476
|
+
string is statically allocated.
|
477
|
+
|
478
|
+
OBJ Returned by pex_init.
|
479
|
+
|
480
|
+
FLAGS As above.
|
481
|
+
|
482
|
+
EXECUTABLE The program to execute.
|
483
|
+
|
484
|
+
ARGV NULL terminated array of arguments to pass to the program.
|
485
|
+
|
486
|
+
OUTNAME Sets the output file name as follows:
|
487
|
+
|
488
|
+
PEX_SUFFIX set (OUTNAME may not be NULL):
|
489
|
+
TEMPBASE parameter to pex_init not NULL:
|
490
|
+
Output file name is the concatenation of TEMPBASE
|
491
|
+
and OUTNAME.
|
492
|
+
TEMPBASE is NULL:
|
493
|
+
Output file name is a random file name ending in
|
494
|
+
OUTNAME.
|
495
|
+
PEX_SUFFIX not set:
|
496
|
+
OUTNAME not NULL:
|
497
|
+
Output file name is OUTNAME.
|
498
|
+
OUTNAME NULL, TEMPBASE not NULL:
|
499
|
+
Output file name is randomly chosen using
|
500
|
+
TEMPBASE.
|
501
|
+
OUTNAME NULL, TEMPBASE NULL:
|
502
|
+
Output file name is randomly chosen.
|
503
|
+
|
504
|
+
If PEX_LAST is not set, the output file name is the
|
505
|
+
name to use for a temporary file holding stdout, if
|
506
|
+
any (there will not be a file if PEX_USE_PIPES is set
|
507
|
+
and the system supports pipes). If a file is used, it
|
508
|
+
will be removed when no longer needed unless
|
509
|
+
PEX_SAVE_TEMPS is set.
|
510
|
+
|
511
|
+
If PEX_LAST is set, and OUTNAME is not NULL, standard
|
512
|
+
output is written to the output file name. The file
|
513
|
+
will not be removed. If PEX_LAST and PEX_SUFFIX are
|
514
|
+
both set, TEMPBASE may not be NULL.
|
515
|
+
|
516
|
+
ERRNAME If not NULL, this is the name of a file to which
|
517
|
+
standard error is written. If NULL, standard error of
|
518
|
+
the program is standard error of the caller.
|
519
|
+
|
520
|
+
ERR On an error return, *ERR is set to an errno value, or
|
521
|
+
to 0 if there is no relevant errno.
|
522
|
+
*/
|
523
|
+
|
524
|
+
extern const char *pex_run (struct pex_obj *obj, int flags,
|
525
|
+
const char *executable, char * const *argv,
|
526
|
+
const char *outname, const char *errname,
|
527
|
+
int *err);
|
528
|
+
|
529
|
+
/* As for pex_run (), but takes an extra parameter to enable the
|
530
|
+
environment for the child process to be specified.
|
531
|
+
|
532
|
+
ENV The environment for the child process, specified as
|
533
|
+
an array of character pointers. Each element of the
|
534
|
+
array should point to a string of the form VAR=VALUE,
|
535
|
+
with the exception of the last element which must be
|
536
|
+
a null pointer.
|
537
|
+
*/
|
538
|
+
|
539
|
+
extern const char *pex_run_in_environment (struct pex_obj *obj, int flags,
|
540
|
+
const char *executable,
|
541
|
+
char * const *argv,
|
542
|
+
char * const *env,
|
543
|
+
const char *outname,
|
544
|
+
const char *errname, int *err);
|
545
|
+
|
546
|
+
/* Return a stream for a temporary file to pass to the first program
|
547
|
+
in the pipeline as input. The file name is chosen as for pex_run.
|
548
|
+
pex_run closes the file automatically; don't close it yourself. */
|
549
|
+
|
550
|
+
extern FILE *pex_input_file (struct pex_obj *obj, int flags,
|
551
|
+
const char *in_name);
|
552
|
+
|
553
|
+
/* Return a stream for a pipe connected to the standard input of the
|
554
|
+
first program in the pipeline. You must have passed
|
555
|
+
`PEX_USE_PIPES' to `pex_init'. Close the returned stream
|
556
|
+
yourself. */
|
557
|
+
|
558
|
+
extern FILE *pex_input_pipe (struct pex_obj *obj, int binary);
|
559
|
+
|
560
|
+
/* Read the standard output of the last program to be executed.
|
561
|
+
pex_run can not be called after this. BINARY should be non-zero if
|
562
|
+
the file should be opened in binary mode; this is ignored on Unix.
|
563
|
+
Returns NULL on error. Don't call fclose on the returned FILE; it
|
564
|
+
will be closed by pex_free. */
|
565
|
+
|
566
|
+
extern FILE *pex_read_output (struct pex_obj *, int binary);
|
567
|
+
|
568
|
+
/* Read the standard error of the last program to be executed.
|
569
|
+
pex_run can not be called after this. BINARY should be non-zero if
|
570
|
+
the file should be opened in binary mode; this is ignored on Unix.
|
571
|
+
Returns NULL on error. Don't call fclose on the returned FILE; it
|
572
|
+
will be closed by pex_free. */
|
573
|
+
|
574
|
+
extern FILE *pex_read_err (struct pex_obj *, int binary);
|
575
|
+
|
576
|
+
/* Return exit status of all programs in VECTOR. COUNT indicates the
|
577
|
+
size of VECTOR. The status codes in the vector are in the order of
|
578
|
+
the calls to pex_run. Returns 0 on error, 1 on success. */
|
579
|
+
|
580
|
+
extern int pex_get_status (struct pex_obj *, int count, int *vector);
|
581
|
+
|
582
|
+
/* Return times of all programs in VECTOR. COUNT indicates the size
|
583
|
+
of VECTOR. struct pex_time is really just struct timeval, but that
|
584
|
+
is not portable to all systems. Returns 0 on error, 1 on
|
585
|
+
success. */
|
586
|
+
|
587
|
+
struct pex_time
|
588
|
+
{
|
589
|
+
unsigned long user_seconds;
|
590
|
+
unsigned long user_microseconds;
|
591
|
+
unsigned long system_seconds;
|
592
|
+
unsigned long system_microseconds;
|
593
|
+
};
|
594
|
+
|
595
|
+
extern int pex_get_times (struct pex_obj *, int count,
|
596
|
+
struct pex_time *vector);
|
597
|
+
|
598
|
+
/* Clean up a pex_obj. If you have not called pex_get_times or
|
599
|
+
pex_get_status, this will try to kill the subprocesses. */
|
600
|
+
|
601
|
+
extern void pex_free (struct pex_obj *);
|
602
|
+
|
603
|
+
/* Just execute one program. Return value is as for pex_run.
|
604
|
+
FLAGS Combination of PEX_SEARCH and PEX_STDERR_TO_STDOUT.
|
605
|
+
EXECUTABLE As for pex_run.
|
606
|
+
ARGV As for pex_run.
|
607
|
+
PNAME As for pex_init.
|
608
|
+
OUTNAME As for pex_run when PEX_LAST is set.
|
609
|
+
ERRNAME As for pex_run.
|
610
|
+
STATUS Set to exit status on success.
|
611
|
+
ERR As for pex_run.
|
612
|
+
*/
|
613
|
+
|
614
|
+
extern const char *pex_one (int flags, const char *executable,
|
615
|
+
char * const *argv, const char *pname,
|
616
|
+
const char *outname, const char *errname,
|
617
|
+
int *status, int *err);
|
618
|
+
|
619
|
+
/* pexecute and pwait are the old pexecute interface, still here for
|
620
|
+
backward compatibility. Don't use these for new code. Instead,
|
621
|
+
use pex_init/pex_run/pex_get_status/pex_free, or pex_one. */
|
622
|
+
|
623
|
+
/* Definitions used by the pexecute routine. */
|
624
|
+
|
625
|
+
#define PEXECUTE_FIRST 1
|
626
|
+
#define PEXECUTE_LAST 2
|
627
|
+
#define PEXECUTE_ONE (PEXECUTE_FIRST + PEXECUTE_LAST)
|
628
|
+
#define PEXECUTE_SEARCH 4
|
629
|
+
#define PEXECUTE_VERBOSE 8
|
630
|
+
|
631
|
+
/* Execute a program. */
|
632
|
+
|
633
|
+
extern int pexecute (const char *, char * const *, const char *,
|
634
|
+
const char *, char **, char **, int);
|
635
|
+
|
636
|
+
/* Wait for pexecute to finish. */
|
637
|
+
|
638
|
+
extern int pwait (int, int *, int);
|
639
|
+
|
640
|
+
#if defined(HAVE_DECL_ASPRINTF) && !HAVE_DECL_ASPRINTF
|
641
|
+
/* Like sprintf but provides a pointer to malloc'd storage, which must
|
642
|
+
be freed by the caller. */
|
643
|
+
|
644
|
+
extern int asprintf (char **, const char *, ...) ATTRIBUTE_PRINTF_2;
|
645
|
+
#endif
|
646
|
+
|
647
|
+
/* Like asprintf but allocates memory without fail. This works like
|
648
|
+
xmalloc. */
|
649
|
+
|
650
|
+
extern char *xasprintf (const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_PRINTF_1;
|
651
|
+
|
652
|
+
#if !HAVE_DECL_VASPRINTF
|
653
|
+
/* Like vsprintf but provides a pointer to malloc'd storage, which
|
654
|
+
must be freed by the caller. */
|
655
|
+
|
656
|
+
extern int vasprintf (char **, const char *, va_list) ATTRIBUTE_PRINTF(2,0);
|
657
|
+
#endif
|
658
|
+
|
659
|
+
/* Like vasprintf but allocates memory without fail. This works like
|
660
|
+
xmalloc. */
|
661
|
+
|
662
|
+
extern char *xvasprintf (const char *, va_list) ATTRIBUTE_MALLOC ATTRIBUTE_PRINTF(1,0);
|
663
|
+
|
664
|
+
#if defined(HAVE_DECL_SNPRINTF) && !HAVE_DECL_SNPRINTF
|
665
|
+
/* Like sprintf but prints at most N characters. */
|
666
|
+
extern int snprintf (char *, size_t, const char *, ...) ATTRIBUTE_PRINTF_3;
|
667
|
+
#endif
|
668
|
+
|
669
|
+
#if defined(HAVE_DECL_VSNPRINTF) && !HAVE_DECL_VSNPRINTF
|
670
|
+
/* Like vsprintf but prints at most N characters. */
|
671
|
+
extern int vsnprintf (char *, size_t, const char *, va_list) ATTRIBUTE_PRINTF(3,0);
|
672
|
+
#endif
|
673
|
+
|
674
|
+
#if defined (HAVE_DECL_STRNLEN) && !HAVE_DECL_STRNLEN
|
675
|
+
extern size_t strnlen (const char *, size_t);
|
676
|
+
#endif
|
677
|
+
|
678
|
+
#if defined(HAVE_DECL_STRVERSCMP) && !HAVE_DECL_STRVERSCMP
|
679
|
+
/* Compare version strings. */
|
680
|
+
extern int strverscmp (const char *, const char *);
|
681
|
+
#endif
|
682
|
+
|
683
|
+
#if defined(HAVE_DECL_STRTOL) && !HAVE_DECL_STRTOL
|
684
|
+
extern long int strtol (const char *nptr,
|
685
|
+
char **endptr, int base);
|
686
|
+
#endif
|
687
|
+
|
688
|
+
#if defined(HAVE_DECL_STRTOUL) && !HAVE_DECL_STRTOUL
|
689
|
+
extern unsigned long int strtoul (const char *nptr,
|
690
|
+
char **endptr, int base);
|
691
|
+
#endif
|
692
|
+
|
693
|
+
#if defined(HAVE_LONG_LONG) && defined(HAVE_DECL_STRTOLL) && !HAVE_DECL_STRTOLL
|
694
|
+
__extension__
|
695
|
+
extern long long int strtoll (const char *nptr,
|
696
|
+
char **endptr, int base);
|
697
|
+
#endif
|
698
|
+
|
699
|
+
#if defined(HAVE_LONG_LONG) && defined(HAVE_DECL_STRTOULL) && !HAVE_DECL_STRTOULL
|
700
|
+
__extension__
|
701
|
+
extern unsigned long long int strtoull (const char *nptr,
|
702
|
+
char **endptr, int base);
|
703
|
+
#endif
|
704
|
+
|
705
|
+
#if defined(HAVE_DECL_STRVERSCMP) && !HAVE_DECL_STRVERSCMP
|
706
|
+
/* Compare version strings. */
|
707
|
+
extern int strverscmp (const char *, const char *);
|
708
|
+
#endif
|
709
|
+
|
710
|
+
/* Set the title of a process */
|
711
|
+
extern void setproctitle (const char *name, ...);
|
712
|
+
|
713
|
+
/* Increase stack limit if possible. */
|
714
|
+
extern void stack_limit_increase (unsigned long);
|
715
|
+
|
716
|
+
#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
|
717
|
+
|
718
|
+
/* Drastically simplified alloca configurator. If we're using GCC,
|
719
|
+
we use __builtin_alloca; otherwise we use the C alloca. The C
|
720
|
+
alloca is always available. You can override GCC by defining
|
721
|
+
USE_C_ALLOCA yourself. The canonical autoconf macro C_ALLOCA is
|
722
|
+
also set/unset as it is often used to indicate whether code needs
|
723
|
+
to call alloca(0). */
|
724
|
+
extern void *C_alloca (size_t) ATTRIBUTE_MALLOC;
|
725
|
+
#undef alloca
|
726
|
+
#if GCC_VERSION >= 2000 && !defined USE_C_ALLOCA
|
727
|
+
# define alloca(x) __builtin_alloca(x)
|
728
|
+
# undef C_ALLOCA
|
729
|
+
# define ASTRDUP(X) \
|
730
|
+
(__extension__ ({ const char *const libiberty_optr = (X); \
|
731
|
+
const unsigned long libiberty_len = strlen (libiberty_optr) + 1; \
|
732
|
+
char *const libiberty_nptr = (char *) alloca (libiberty_len); \
|
733
|
+
(char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len); }))
|
734
|
+
#else
|
735
|
+
# define alloca(x) C_alloca(x)
|
736
|
+
# undef USE_C_ALLOCA
|
737
|
+
# define USE_C_ALLOCA 1
|
738
|
+
# undef C_ALLOCA
|
739
|
+
# define C_ALLOCA 1
|
740
|
+
extern const char *libiberty_optr;
|
741
|
+
extern char *libiberty_nptr;
|
742
|
+
extern unsigned long libiberty_len;
|
743
|
+
# define ASTRDUP(X) \
|
744
|
+
(libiberty_optr = (X), \
|
745
|
+
libiberty_len = strlen (libiberty_optr) + 1, \
|
746
|
+
libiberty_nptr = (char *) alloca (libiberty_len), \
|
747
|
+
(char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len))
|
748
|
+
#endif
|
749
|
+
|
750
|
+
#ifdef __cplusplus
|
751
|
+
}
|
752
|
+
#endif
|
753
|
+
|
754
|
+
|
755
|
+
#endif /* ! defined (LIBIBERTY_H) */
|