~damien-moore/+junk/codeblocks

#if defined (__GNU_LIBRARY__ ) || defined (__linux__) || defined (__FreeBSD__) || defined (__OpenBSD__) || defined(__NetBSD__) || defined (__CYGWIN__) || defined (__CYGWIN32__) || defined (__MINGW32__) || defined (HAVE_DECL_BASENAME)

105

extern char *basename (const char *);

106

#else

107

/* Do not allow basename to be used if there is no prototype seen. We

108

either need to use the above prototype or have one from

109

autoconf which would result in HAVE_DECL_BASENAME being set. */

110

#define basename basename_cannot_be_used_without_a_prototype

111

#endif

112

#endif

113

114

/* A well-defined basename () that is always compiled in. */

115

116

extern const char *lbasename (const char *);

117

118

/* A well-defined realpath () that is always compiled in. */

119

120

extern char *lrealpath (const char *);

121

122

/* Concatenate an arbitrary number of strings. You must pass NULL as

123

the last argument of this function, to terminate the list of

124

strings. Allocates memory using xmalloc. */

125

126

extern char *concat (const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL;

127

128

/* Concatenate an arbitrary number of strings. You must pass NULL as

129

the last argument of this function, to terminate the list of

130

strings. Allocates memory using xmalloc. The first argument is

131

not one of the strings to be concatenated, but if not NULL is a

132

pointer to be freed after the new string is created, similar to the

133

way xrealloc works. */

134

135

extern char *reconcat (char *, const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL;

136

137

/* Determine the length of concatenating an arbitrary number of

138

strings. You must pass NULL as the last argument of this function,

139

to terminate the list of strings. */

140

141

extern unsigned long concat_length (const char *, ...) ATTRIBUTE_SENTINEL;

142

143

/* Concatenate an arbitrary number of strings into a SUPPLIED area of

144

memory. You must pass NULL as the last argument of this function,

145

to terminate the list of strings. The supplied memory is assumed

146

to be large enough. */

147

148

extern char *concat_copy (char *, const char *, ...) ATTRIBUTE_SENTINEL;

149

150

/* Concatenate an arbitrary number of strings into a GLOBAL area of

151

memory. You must pass NULL as the last argument of this function,

152

to terminate the list of strings. The supplied memory is assumed

153

to be large enough. */

154

155

extern char *concat_copy2 (const char *, ...) ATTRIBUTE_SENTINEL;

156

157

/* This is the global area used by concat_copy2. */

158

159

extern char *libiberty_concat_ptr;

160

161

/* Concatenate an arbitrary number of strings. You must pass NULL as

162

the last argument of this function, to terminate the list of

163

strings. Allocates memory using alloca. The arguments are

164

evaluated twice! */

165

#define ACONCAT(ACONCAT_PARAMS) \

166

(libiberty_concat_ptr = (char *) alloca (concat_length ACONCAT_PARAMS + 1), \

167

concat_copy2 ACONCAT_PARAMS)

168

169

/* Check whether two file descriptors refer to the same file. */

170

171

extern int fdmatch (int fd1, int fd2);

172

173

/* Return the position of the first bit set in the argument. */

174

/* Prototypes vary from system to system, so we only provide a

175

prototype on systems where we know that we need it. */

176

#if defined (HAVE_DECL_FFS) && !HAVE_DECL_FFS

177

extern int ffs(int);

178

#endif

179

180

/* Get the working directory. The result is cached, so don't call

181

chdir() between calls to getpwd(). */

182

183

extern char * getpwd (void);

184

185

/* Get the current time. */

186

/* Prototypes vary from system to system, so we only provide a

187

prototype on systems where we know that we need it. */

188

#ifdef __MINGW32__

189

/* Forward declaration to avoid #include <sys/time.h>. */

190

struct timeval;

191

extern int gettimeofday (struct timeval *, void *);

192

#endif

193

194

/* Get the amount of time the process has run, in microseconds. */

195

196

extern long get_run_time (void);

197

198

/* Generate a relocated path to some installation directory. Allocates

199

return value using malloc. */

200

201

extern char *make_relative_prefix (const char *, const char *,

202

const char *) ATTRIBUTE_MALLOC;

203

204

/* Generate a relocated path to some installation directory without

205

attempting to follow any soft links. Allocates

206

return value using malloc. */

207

208

extern char *make_relative_prefix_ignore_links (const char *, const char *,

209

const char *) ATTRIBUTE_MALLOC;

210

211

/* Choose a temporary directory to use for scratch files. */

212

213

extern char *choose_temp_base (void) ATTRIBUTE_MALLOC;

214

215

/* Return a temporary file name or NULL if unable to create one. */

216

217

extern char *make_temp_file (const char *) ATTRIBUTE_MALLOC;

218

219

/* Remove a link to a file unless it is special. */

220

221

extern int unlink_if_ordinary (const char *);

222

223

/* Allocate memory filled with spaces. Allocates using malloc. */

224

225

extern const char *spaces (int count);

226

227

/* Return the maximum error number for which strerror will return a

228

string. */

229

230

extern int errno_max (void);

231

232

/* Return the name of an errno value (e.g., strerrno (EINVAL) returns

233

"EINVAL"). */

234

235

extern const char *strerrno (int);

236

237

/* Given the name of an errno value, return the value. */

238

239

extern int strtoerrno (const char *);

240

241

/* ANSI's strerror(), but more robust. */

242

243

extern char *xstrerror (int);

244

245

/* Return the maximum signal number for which strsignal will return a

246

string. */

247

248

extern int signo_max (void);

249

250

/* Return a signal message string for a signal number

251

(e.g., strsignal (SIGHUP) returns something like "Hangup"). */

252

/* This is commented out as it can conflict with one in system headers.

253

We still document its existence though. */

254

255

/*extern const char *strsignal (int);*/

256

257

/* Return the name of a signal number (e.g., strsigno (SIGHUP) returns

258

"SIGHUP"). */

259

260

extern const char *strsigno (int);

261

262

/* Given the name of a signal, return its number. */

263

264

extern int strtosigno (const char *);

265

266

/* Register a function to be run by xexit. Returns 0 on success. */

267

268

extern int xatexit (void (*fn) (void));

269

270

/* Exit, calling all the functions registered with xatexit. */

271

272

extern void xexit (int status) ATTRIBUTE_NORETURN;

273

274

/* Set the program name used by xmalloc. */

275

276

extern void xmalloc_set_program_name (const char *);

277

278

/* Report an allocation failure. */

279

extern void xmalloc_failed (size_t) ATTRIBUTE_NORETURN;

280

281

/* Allocate memory without fail. If malloc fails, this will print a

282

message to stderr (using the name set by xmalloc_set_program_name,

283

if any) and then call xexit. */

284

285

extern void *xmalloc (size_t) ATTRIBUTE_MALLOC;

286

287

/* Reallocate memory without fail. This works like xmalloc. Note,

288

realloc type functions are not suitable for attribute malloc since

289

they may return the same address across multiple calls. */

290

291

extern void *xrealloc (void *, size_t);

292

293

/* Allocate memory without fail and set it to zero. This works like

294

xmalloc. */

295

296

extern void *xcalloc (size_t, size_t) ATTRIBUTE_MALLOC;

297

298

/* Copy a string into a memory buffer without fail. */

299

300

extern char *xstrdup (const char *) ATTRIBUTE_MALLOC;

301

302

/* Copy at most N characters from string into a buffer without fail. */

303

304

extern char *xstrndup (const char *, size_t) ATTRIBUTE_MALLOC;

305

306

/* Copy an existing memory buffer to a new memory buffer without fail. */

307

308

extern void *xmemdup (const void *, size_t, size_t) ATTRIBUTE_MALLOC;

309

310

/* Physical memory routines. Return values are in BYTES. */

311

extern double physmem_total (void);

312

extern double physmem_available (void);

313

314

315

/* These macros provide a K&R/C89/C++-friendly way of allocating structures

316

with nice encapsulation. The XDELETE*() macros are technically

317

superfluous, but provided here for symmetry. Using them consistently

318

makes it easier to update client code to use different allocators such

319

as new/delete and new[]/delete[]. */

320

321

/* Scalar allocators. */

322

323

#define XNEW(T) ((T *) xmalloc (sizeof (T)))

324

#define XCNEW(T) ((T *) xcalloc (1, sizeof (T)))

325

#define XDELETE(P) free ((void*) (P))

326

327

/* Array allocators. */

328

329

#define XNEWVEC(T, N) ((T *) xmalloc (sizeof (T) * (N)))

330

#define XCNEWVEC(T, N) ((T *) xcalloc ((N), sizeof (T)))

331

#define XRESIZEVEC(T, P, N) ((T *) xrealloc ((void *) (P), sizeof (T) * (N)))

332

#define XDELETEVEC(P) free ((void*) (P))

333

334

/* Allocators for variable-sized structures and raw buffers. */

335

336

#define XNEWVAR(T, S) ((T *) xmalloc ((S)))

337

#define XCNEWVAR(T, S) ((T *) xcalloc (1, (S)))

338

#define XRESIZEVAR(T, P, S) ((T *) xrealloc ((P), (S)))

339

340

/* Type-safe obstack allocator. */

341

342

#define XOBNEW(O, T) ((T *) obstack_alloc ((O), sizeof (T)))

343

#define XOBFINISH(O, T) ((T) obstack_finish ((O)))

344

345

/* hex character manipulation routines */

346

347

#define _hex_array_size 256

348

#define _hex_bad 99

349

extern const unsigned char _hex_value[_hex_array_size];

350

extern void hex_init (void);

351

#define hex_p(c) (hex_value (c) != _hex_bad)

352

/* If you change this, note well: Some code relies on side effects in

353

the argument being performed exactly once. */

354

#define hex_value(c) ((unsigned int) _hex_value[(unsigned char) (c)])

355

356

/* Flags for pex_init. These are bits to be or'ed together. */

357

358

/* Record subprocess times, if possible. */

359

#define PEX_RECORD_TIMES 0x1

360

361

/* Use pipes for communication between processes, if possible. */

362

#define PEX_USE_PIPES 0x2

363

364

/* Save files used for communication between processes. */

365

#define PEX_SAVE_TEMPS 0x4

366

367

/* Prepare to execute one or more programs, with standard output of

368

each program fed to standard input of the next.

369

FLAGS As above.

370

PNAME The name of the program to report in error messages.

371

TEMPBASE A base name to use for temporary files; may be NULL to

372

use a random name.

373

Returns NULL on error. */

374

375

extern struct pex_obj *pex_init (int flags, const char *pname,

376

const char *tempbase);

377

378

/* Flags for pex_run. These are bits to be or'ed together. */

379

380

/* Last program in pipeline. Standard output of program goes to

381

OUTNAME, or, if OUTNAME is NULL, to standard output of caller. Do

382

not set this if you want to call pex_read_output. After this is

383

set, pex_run may no longer be called with the same struct

384

pex_obj. */

385

#define PEX_LAST 0x1

386

387

/* Search for program in executable search path. */

388

#define PEX_SEARCH 0x2

389

390

/* OUTNAME is a suffix. */

391

#define PEX_SUFFIX 0x4

392

393

/* Send program's standard error to standard output. */

394

#define PEX_STDERR_TO_STDOUT 0x8

395

396

/* Input file should be opened in binary mode. This flag is ignored

397

on Unix. */

398

#define PEX_BINARY_INPUT 0x10

399

400

/* Output file should be opened in binary mode. This flag is ignored

401

on Unix. For proper behaviour PEX_BINARY_INPUT and

402

PEX_BINARY_OUTPUT have to match appropriately--i.e., a call using

403

PEX_BINARY_OUTPUT should be followed by a call using

404

PEX_BINARY_INPUT. */

405

#define PEX_BINARY_OUTPUT 0x20

406

407

/* Capture stderr to a pipe. The output can be read by

408

calling pex_read_err and reading from the returned

409

FILE object. This flag may be specified only for

410

the last program in a pipeline.

411

412

This flag is supported only on Unix and Windows. */

413

#define PEX_STDERR_TO_PIPE 0x40

414

415

/* Capture stderr in binary mode. This flag is ignored

416

on Unix. */

417

#define PEX_BINARY_ERROR 0x80

418

419

420

/* Execute one program. Returns NULL on success. On error returns an

421

error string (typically just the name of a system call); the error

422

string is statically allocated.

423

424

OBJ Returned by pex_init.

425

426

FLAGS As above.

427

428

EXECUTABLE The program to execute.

429

430

ARGV NULL terminated array of arguments to pass to the program.

431

432

OUTNAME Sets the output file name as follows:

433

434

PEX_SUFFIX set (OUTNAME may not be NULL):

435

TEMPBASE parameter to pex_init not NULL:

436

Output file name is the concatenation of TEMPBASE

437

and OUTNAME.

438

TEMPBASE is NULL:

439

Output file name is a random file name ending in

440

OUTNAME.

441

PEX_SUFFIX not set:

442

OUTNAME not NULL:

443

Output file name is OUTNAME.

444

OUTNAME NULL, TEMPBASE not NULL:

445

Output file name is randomly chosen using

446

TEMPBASE.

447

OUTNAME NULL, TEMPBASE NULL:

448

Output file name is randomly chosen.

449

450

If PEX_LAST is not set, the output file name is the

451

name to use for a temporary file holding stdout, if

452

any (there will not be a file if PEX_USE_PIPES is set

453

and the system supports pipes). If a file is used, it

454

will be removed when no longer needed unless

455

PEX_SAVE_TEMPS is set.

456

457

If PEX_LAST is set, and OUTNAME is not NULL, standard

458

output is written to the output file name. The file

459

will not be removed. If PEX_LAST and PEX_SUFFIX are

460

both set, TEMPBASE may not be NULL.

461

462

ERRNAME If not NULL, this is the name of a file to which

463

standard error is written. If NULL, standard error of

464

the program is standard error of the caller.

465

466

ERR On an error return, *ERR is set to an errno value, or

467

to 0 if there is no relevant errno.

468

469

470

extern const char *pex_run (struct pex_obj *obj, int flags,

471

const char *executable, char * const *argv,

472

const char *outname, const char *errname,

473

int *err);

474

475

/* As for pex_run (), but takes an extra parameter to enable the

476

environment for the child process to be specified.

477

478

ENV The environment for the child process, specified as

479

an array of character pointers. Each element of the

480

array should point to a string of the form VAR=VALUE,

481

with the exception of the last element which must be

482

a null pointer.

483

484

485

extern const char *pex_run_in_environment (struct pex_obj *obj, int flags,

486

const char *executable,

487

char * const *argv,

488

char * const *env,

489

const char *outname,

490

const char *errname, int *err);

491

492

/* Return a stream for a temporary file to pass to the first program

493

in the pipeline as input. The file name is chosen as for pex_run.

494

pex_run closes the file automatically; don't close it yourself. */

495

496

extern FILE *pex_input_file (struct pex_obj *obj, int flags,

497

const char *in_name);

498

499

/* Return a stream for a pipe connected to the standard input of the

500

first program in the pipeline. You must have passed

501

`PEX_USE_PIPES' to `pex_init'. Close the returned stream

502

yourself. */

503

504

extern FILE *pex_input_pipe (struct pex_obj *obj, int binary);

505

506

/* Read the standard output of the last program to be executed.

507

pex_run can not be called after this. BINARY should be non-zero if

508

the file should be opened in binary mode; this is ignored on Unix.

509

Returns NULL on error. Don't call fclose on the returned FILE; it

510

will be closed by pex_free. */

511

512

extern FILE *pex_read_output (struct pex_obj *, int binary);

513

514

/* Read the standard error of the last program to be executed.

515

pex_run can not be called after this. BINARY should be non-zero if

516

the file should be opened in binary mode; this is ignored on Unix.

517

Returns NULL on error. Don't call fclose on the returned FILE; it

518

will be closed by pex_free. */

519

520

extern FILE *pex_read_err (struct pex_obj *, int binary);

521

522

/* Return exit status of all programs in VECTOR. COUNT indicates the

523

size of VECTOR. The status codes in the vector are in the order of

524

the calls to pex_run. Returns 0 on error, 1 on success. */

525

526

extern int pex_get_status (struct pex_obj *, int count, int *vector);

527

528

/* Return times of all programs in VECTOR. COUNT indicates the size

529

of VECTOR. struct pex_time is really just struct timeval, but that

530

is not portable to all systems. Returns 0 on error, 1 on

531

success. */

532

533

struct pex_time

534

{

535

unsigned long user_seconds;

536

unsigned long user_microseconds;

537

unsigned long system_seconds;

538

unsigned long system_microseconds;

539

};

540

541

extern int pex_get_times (struct pex_obj *, int count,

542

struct pex_time *vector);

543

544

/* Clean up a pex_obj. */

545

546

extern void pex_free (struct pex_obj *);

547

548

/* Just execute one program. Return value is as for pex_run.

549

FLAGS Combination of PEX_SEARCH and PEX_STDERR_TO_STDOUT.

550

EXECUTABLE As for pex_run.

551

ARGV As for pex_run.

552

PNAME As for pex_init.

553

OUTNAME As for pex_run when PEX_LAST is set.

554

ERRNAME As for pex_run.

555

STATUS Set to exit status on success.

556

ERR As for pex_run.

557

558

559

extern const char *pex_one (int flags, const char *executable,

560

char * const *argv, const char *pname,

561

const char *outname, const char *errname,

562

int *status, int *err);

563

564

/* pexecute and pwait are the old pexecute interface, still here for

565

backward compatibility. Don't use these for new code. Instead,

566

use pex_init/pex_run/pex_get_status/pex_free, or pex_one. */

567

568

/* Definitions used by the pexecute routine. */

569

570

#define PEXECUTE_FIRST 1

571

#define PEXECUTE_LAST 2

572

#define PEXECUTE_ONE (PEXECUTE_FIRST + PEXECUTE_LAST)

573

#define PEXECUTE_SEARCH 4

574

#define PEXECUTE_VERBOSE 8

575

576

/* Execute a program. */

577

578

extern int pexecute (const char *, char * const *, const char *,

579

const char *, char **, char **, int);

580

581

/* Wait for pexecute to finish. */

582

583

extern int pwait (int, int *, int);

584

585

#if !HAVE_DECL_ASPRINTF

586

/* Like sprintf but provides a pointer to malloc'd storage, which must

587

be freed by the caller. */

588

589

extern int asprintf (char **, const char *, ...) ATTRIBUTE_PRINTF_2;

590

#endif

591

592

#if !HAVE_DECL_VASPRINTF

593

/* Like vsprintf but provides a pointer to malloc'd storage, which

594

must be freed by the caller. */

595

596

extern int vasprintf (char **, const char *, va_list) ATTRIBUTE_PRINTF(2,0);

597

#endif

598

599

#if defined(HAVE_DECL_SNPRINTF) && !HAVE_DECL_SNPRINTF

600

/* Like sprintf but prints at most N characters. */

601

extern int snprintf (char *, size_t, const char *, ...) ATTRIBUTE_PRINTF_3;

602

#endif

603

604

#if defined(HAVE_DECL_VSNPRINTF) && !HAVE_DECL_VSNPRINTF

605

/* Like vsprintf but prints at most N characters. */

606

extern int vsnprintf (char *, size_t, const char *, va_list) ATTRIBUTE_PRINTF(3,0);

607

#endif

608

609

#if defined(HAVE_DECL_STRVERSCMP) && !HAVE_DECL_STRVERSCMP

610

/* Compare version strings. */

611

extern int strverscmp (const char *, const char *);

612

#endif

613

614

#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))

615

616

/* Drastically simplified alloca configurator. If we're using GCC,

617

we use __builtin_alloca; otherwise we use the C alloca. The C

618

alloca is always available. You can override GCC by defining

619

USE_C_ALLOCA yourself. The canonical autoconf macro C_ALLOCA is

620

also set/unset as it is often used to indicate whether code needs

621

to call alloca(0). */

622

extern void *C_alloca (size_t) ATTRIBUTE_MALLOC;

623

#undef alloca

624

#if GCC_VERSION >= 2000 && !defined USE_C_ALLOCA

625

# define alloca(x) __builtin_alloca(x)

626

# undef C_ALLOCA

627

# define ASTRDUP(X) \

628

(__extension__ ({ const char *const libiberty_optr = (X); \

629

const unsigned long libiberty_len = strlen (libiberty_optr) + 1; \

630

char *const libiberty_nptr = (char *const) alloca (libiberty_len); \

631

(char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len); }))

632

#else

633

# define alloca(x) C_alloca(x)

634

# undef USE_C_ALLOCA

635

# define USE_C_ALLOCA 1

636

# undef C_ALLOCA

637

# define C_ALLOCA 1

638

extern const char *libiberty_optr;

639

extern char *libiberty_nptr;

640

extern unsigned long libiberty_len;

641

# define ASTRDUP(X) \

642

(libiberty_optr = (X), \

643

libiberty_len = strlen (libiberty_optr) + 1, \

644

libiberty_nptr = (char *) alloca (libiberty_len), \

645

(char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len))

646

#endif

647

648

#ifdef __cplusplus

649

}

650

#endif

651

652

653

#endif /* ! defined (LIBIBERTY_H) */