Mercurial > hg > CbC > CbC_gcc
annotate libiberty/pex-common.c @ 145:1830386684a0
gcc-9.2.0
| author | anatofuz |
|---|---|
| date | Thu, 13 Feb 2020 11:34:05 +0900 |
| parents | 84e7813d76e9 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* Common code for executing a program in a sub-process. |
| 145 | 2 Copyright (C) 2005-2020 Free Software Foundation, Inc. |
| 0 | 3 Written by Ian Lance Taylor <ian@airs.com>. |
| 4 | |
| 5 This file is part of the libiberty library. | |
| 6 Libiberty is free software; you can redistribute it and/or | |
| 7 modify it under the terms of the GNU Library General Public | |
| 8 License as published by the Free Software Foundation; either | |
| 9 version 2 of the License, or (at your option) any later version. | |
| 10 | |
| 11 Libiberty is distributed in the hope that it will be useful, | |
| 12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 14 Library General Public License for more details. | |
| 15 | |
| 16 You should have received a copy of the GNU Library General Public | |
| 17 License along with libiberty; see the file COPYING.LIB. If not, | |
| 18 write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, | |
| 19 Boston, MA 02110-1301, USA. */ | |
| 20 | |
| 21 #include "config.h" | |
| 22 #include "libiberty.h" | |
| 23 #include "pex-common.h" | |
| 24 | |
| 25 #include <stdio.h> | |
| 26 #include <errno.h> | |
| 27 #ifdef NEED_DECLARATION_ERRNO | |
| 28 extern int errno; | |
| 29 #endif | |
| 30 #ifdef HAVE_STDLIB_H | |
| 31 #include <stdlib.h> | |
| 32 #endif | |
| 33 #ifdef HAVE_STRING_H | |
| 34 #include <string.h> | |
| 35 #endif | |
| 36 #ifdef HAVE_UNISTD_H | |
| 37 #include <unistd.h> | |
| 38 #endif | |
| 39 | |
| 40 extern int mkstemps (char *, int); | |
| 41 | |
| 42 /* This file contains subroutines for the program execution routines | |
| 43 (pex_init, pex_run, etc.). This file is compiled on all | |
| 44 systems. */ | |
| 45 | |
| 46 static void pex_add_remove (struct pex_obj *, const char *, int); | |
| 47 static int pex_get_status_and_time (struct pex_obj *, int, const char **, | |
| 48 int *); | |
| 49 | |
| 50 /* Initialize a pex_obj structure. */ | |
| 51 | |
| 52 struct pex_obj * | |
| 53 pex_init_common (int flags, const char *pname, const char *tempbase, | |
| 54 const struct pex_funcs *funcs) | |
| 55 { | |
| 56 struct pex_obj *obj; | |
| 57 | |
| 58 obj = XNEW (struct pex_obj); | |
| 59 obj->flags = flags; | |
| 60 obj->pname = pname; | |
| 61 obj->tempbase = tempbase; | |
| 62 obj->next_input = STDIN_FILE_NO; | |
| 63 obj->next_input_name = NULL; | |
| 64 obj->next_input_name_allocated = 0; | |
| 65 obj->stderr_pipe = -1; | |
| 66 obj->count = 0; | |
| 67 obj->children = NULL; | |
| 68 obj->status = NULL; | |
| 69 obj->time = NULL; | |
| 70 obj->number_waited = 0; | |
| 71 obj->input_file = NULL; | |
| 72 obj->read_output = NULL; | |
| 73 obj->read_err = NULL; | |
| 74 obj->remove_count = 0; | |
| 75 obj->remove = NULL; | |
| 76 obj->funcs = funcs; | |
| 77 obj->sysdep = NULL; | |
| 78 return obj; | |
| 79 } | |
| 80 | |
| 81 /* Add a file to be removed when we are done. */ | |
| 82 | |
| 83 static void | |
| 84 pex_add_remove (struct pex_obj *obj, const char *name, int allocated) | |
| 85 { | |
| 86 char *add; | |
| 87 | |
| 88 ++obj->remove_count; | |
| 89 obj->remove = XRESIZEVEC (char *, obj->remove, obj->remove_count); | |
| 90 if (allocated) | |
| 91 add = (char *) name; | |
| 92 else | |
| 93 add = xstrdup (name); | |
| 94 obj->remove[obj->remove_count - 1] = add; | |
| 95 } | |
| 96 | |
| 97 /* Generate a temporary file name based on OBJ, FLAGS, and NAME. | |
| 98 Return NULL if we were unable to reserve a temporary filename. | |
| 99 | |
| 100 If non-NULL, the result is either allocated with malloc, or the | |
| 101 same pointer as NAME. */ | |
| 102 static char * | |
| 103 temp_file (struct pex_obj *obj, int flags, char *name) | |
| 104 { | |
| 105 if (name == NULL) | |
| 106 { | |
| 107 if (obj->tempbase == NULL) | |
| 108 { | |
| 109 name = make_temp_file (NULL); | |
| 110 } | |
| 111 else | |
| 112 { | |
| 113 int len = strlen (obj->tempbase); | |
| 114 int out; | |
| 115 | |
| 116 if (len >= 6 | |
| 117 && strcmp (obj->tempbase + len - 6, "XXXXXX") == 0) | |
| 118 name = xstrdup (obj->tempbase); | |
| 119 else | |
| 120 name = concat (obj->tempbase, "XXXXXX", NULL); | |
| 121 | |
| 122 out = mkstemps (name, 0); | |
| 123 if (out < 0) | |
| 124 { | |
| 125 free (name); | |
| 126 return NULL; | |
| 127 } | |
| 128 | |
| 129 /* This isn't obj->funcs->close because we got the | |
| 130 descriptor from mkstemps, not from a function in | |
| 131 obj->funcs. Calling close here is just like what | |
| 132 make_temp_file does. */ | |
| 133 close (out); | |
| 134 } | |
| 135 } | |
| 136 else if ((flags & PEX_SUFFIX) != 0) | |
| 137 { | |
| 138 if (obj->tempbase == NULL) | |
| 139 name = make_temp_file (name); | |
| 140 else | |
| 141 name = concat (obj->tempbase, name, NULL); | |
| 142 } | |
| 143 | |
| 144 return name; | |
| 145 } | |
| 146 | |
| 147 | |
| 148 /* As for pex_run (), but permits the environment for the child process | |
| 149 to be specified. */ | |
| 150 | |
| 151 const char * | |
| 152 pex_run_in_environment (struct pex_obj *obj, int flags, const char *executable, | |
| 153 char * const * argv, char * const * env, | |
| 154 const char *orig_outname, const char *errname, | |
| 155 int *err) | |
| 156 { | |
| 157 const char *errmsg; | |
| 158 int in, out, errdes; | |
| 159 char *outname; | |
| 160 int outname_allocated; | |
| 161 int p[2]; | |
| 162 int toclose; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
163 pid_t pid; |
| 0 | 164 |
| 165 in = -1; | |
| 166 out = -1; | |
| 167 errdes = -1; | |
| 168 outname = (char *) orig_outname; | |
| 169 outname_allocated = 0; | |
| 170 | |
| 171 /* If the user called pex_input_file, close the file now. */ | |
| 172 if (obj->input_file) | |
| 173 { | |
| 174 if (fclose (obj->input_file) == EOF) | |
| 175 { | |
| 176 errmsg = "closing pipeline input file"; | |
| 177 goto error_exit; | |
| 178 } | |
| 179 obj->input_file = NULL; | |
| 180 } | |
| 181 | |
| 182 /* Set IN. */ | |
| 183 | |
| 184 if (obj->next_input_name != NULL) | |
| 185 { | |
| 186 /* We have to make sure that the previous process has completed | |
| 187 before we try to read the file. */ | |
| 188 if (!pex_get_status_and_time (obj, 0, &errmsg, err)) | |
| 189 goto error_exit; | |
| 190 | |
| 191 in = obj->funcs->open_read (obj, obj->next_input_name, | |
| 192 (flags & PEX_BINARY_INPUT) != 0); | |
| 193 if (in < 0) | |
| 194 { | |
| 195 *err = errno; | |
| 196 errmsg = "open temporary file"; | |
| 197 goto error_exit; | |
| 198 } | |
| 199 if (obj->next_input_name_allocated) | |
| 200 { | |
| 201 free (obj->next_input_name); | |
| 202 obj->next_input_name_allocated = 0; | |
| 203 } | |
| 204 obj->next_input_name = NULL; | |
| 205 } | |
| 206 else | |
| 207 { | |
| 208 in = obj->next_input; | |
| 209 if (in < 0) | |
| 210 { | |
| 211 *err = 0; | |
| 212 errmsg = "pipeline already complete"; | |
| 213 goto error_exit; | |
| 214 } | |
| 215 } | |
| 216 | |
| 217 /* Set OUT and OBJ->NEXT_INPUT/OBJ->NEXT_INPUT_NAME. */ | |
| 218 | |
| 219 if ((flags & PEX_LAST) != 0) | |
| 220 { | |
| 221 if (outname == NULL) | |
| 222 out = STDOUT_FILE_NO; | |
| 223 else if ((flags & PEX_SUFFIX) != 0) | |
| 224 { | |
| 225 outname = concat (obj->tempbase, outname, NULL); | |
| 226 outname_allocated = 1; | |
| 227 } | |
| 228 obj->next_input = -1; | |
| 229 } | |
| 230 else if ((obj->flags & PEX_USE_PIPES) == 0) | |
| 231 { | |
| 232 outname = temp_file (obj, flags, outname); | |
| 233 if (! outname) | |
| 234 { | |
| 235 *err = 0; | |
| 236 errmsg = "could not create temporary file"; | |
| 237 goto error_exit; | |
| 238 } | |
| 239 | |
| 240 if (outname != orig_outname) | |
| 241 outname_allocated = 1; | |
| 242 | |
| 243 if ((obj->flags & PEX_SAVE_TEMPS) == 0) | |
| 244 { | |
| 245 pex_add_remove (obj, outname, outname_allocated); | |
| 246 outname_allocated = 0; | |
| 247 } | |
| 248 | |
| 249 /* Hand off ownership of outname to the next stage. */ | |
| 250 obj->next_input_name = outname; | |
| 251 obj->next_input_name_allocated = outname_allocated; | |
| 252 outname_allocated = 0; | |
| 253 } | |
| 254 else | |
| 255 { | |
| 256 if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_OUTPUT) != 0) < 0) | |
| 257 { | |
| 258 *err = errno; | |
| 259 errmsg = "pipe"; | |
| 260 goto error_exit; | |
| 261 } | |
| 262 | |
| 263 out = p[WRITE_PORT]; | |
| 264 obj->next_input = p[READ_PORT]; | |
| 265 } | |
| 266 | |
| 267 if (out < 0) | |
| 268 { | |
| 269 out = obj->funcs->open_write (obj, outname, | |
| 111 | 270 (flags & PEX_BINARY_OUTPUT) != 0, |
| 271 (flags & PEX_STDOUT_APPEND) != 0); | |
| 0 | 272 if (out < 0) |
| 273 { | |
| 274 *err = errno; | |
| 275 errmsg = "open temporary output file"; | |
| 276 goto error_exit; | |
| 277 } | |
| 278 } | |
| 279 | |
| 280 if (outname_allocated) | |
| 281 { | |
| 282 free (outname); | |
| 283 outname_allocated = 0; | |
| 284 } | |
| 285 | |
| 286 /* Set ERRDES. */ | |
| 287 | |
| 288 if (errname != NULL && (flags & PEX_STDERR_TO_PIPE) != 0) | |
| 289 { | |
| 290 *err = 0; | |
| 291 errmsg = "both ERRNAME and PEX_STDERR_TO_PIPE specified."; | |
| 292 goto error_exit; | |
| 293 } | |
| 294 | |
| 295 if (obj->stderr_pipe != -1) | |
| 296 { | |
| 297 *err = 0; | |
| 298 errmsg = "PEX_STDERR_TO_PIPE used in the middle of pipeline"; | |
| 299 goto error_exit; | |
| 300 } | |
| 301 | |
| 302 if (errname == NULL) | |
| 303 { | |
| 304 if (flags & PEX_STDERR_TO_PIPE) | |
| 305 { | |
| 306 if (obj->funcs->pipe (obj, p, (flags & PEX_BINARY_ERROR) != 0) < 0) | |
| 307 { | |
| 308 *err = errno; | |
| 309 errmsg = "pipe"; | |
| 310 goto error_exit; | |
| 311 } | |
| 312 | |
| 313 errdes = p[WRITE_PORT]; | |
| 314 obj->stderr_pipe = p[READ_PORT]; | |
| 315 } | |
| 316 else | |
| 317 { | |
| 318 errdes = STDERR_FILE_NO; | |
| 319 } | |
| 320 } | |
| 321 else | |
| 322 { | |
| 111 | 323 errdes = obj->funcs->open_write (obj, errname, |
| 324 (flags & PEX_BINARY_ERROR) != 0, | |
| 325 (flags & PEX_STDERR_APPEND) != 0); | |
| 0 | 326 if (errdes < 0) |
| 327 { | |
| 328 *err = errno; | |
| 329 errmsg = "open error file"; | |
| 330 goto error_exit; | |
| 331 } | |
| 332 } | |
| 333 | |
| 334 /* If we are using pipes, the child process has to close the next | |
| 335 input pipe. */ | |
| 336 | |
| 337 if ((obj->flags & PEX_USE_PIPES) == 0) | |
| 338 toclose = -1; | |
| 339 else | |
| 340 toclose = obj->next_input; | |
| 341 | |
| 342 /* Run the program. */ | |
| 343 | |
| 344 pid = obj->funcs->exec_child (obj, flags, executable, argv, env, | |
| 345 in, out, errdes, toclose, &errmsg, err); | |
| 346 if (pid < 0) | |
| 347 goto error_exit; | |
| 348 | |
| 349 ++obj->count; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
350 obj->children = XRESIZEVEC (pid_t, obj->children, obj->count); |
| 0 | 351 obj->children[obj->count - 1] = pid; |
| 352 | |
| 353 return NULL; | |
| 354 | |
| 355 error_exit: | |
| 356 if (in >= 0 && in != STDIN_FILE_NO) | |
| 357 obj->funcs->close (obj, in); | |
| 358 if (out >= 0 && out != STDOUT_FILE_NO) | |
| 359 obj->funcs->close (obj, out); | |
| 360 if (errdes >= 0 && errdes != STDERR_FILE_NO) | |
| 361 obj->funcs->close (obj, errdes); | |
| 362 if (outname_allocated) | |
| 363 free (outname); | |
| 364 return errmsg; | |
| 365 } | |
| 366 | |
| 367 /* Run a program. */ | |
| 368 | |
| 369 const char * | |
| 370 pex_run (struct pex_obj *obj, int flags, const char *executable, | |
| 371 char * const * argv, const char *orig_outname, const char *errname, | |
| 372 int *err) | |
| 373 { | |
| 374 return pex_run_in_environment (obj, flags, executable, argv, NULL, | |
| 375 orig_outname, errname, err); | |
| 376 } | |
| 377 | |
| 378 /* Return a FILE pointer for a temporary file to fill with input for | |
| 379 the pipeline. */ | |
| 380 FILE * | |
| 381 pex_input_file (struct pex_obj *obj, int flags, const char *in_name) | |
| 382 { | |
| 383 char *name = (char *) in_name; | |
| 384 FILE *f; | |
| 385 | |
| 386 /* This must be called before the first pipeline stage is run, and | |
| 387 there must not have been any other input selected. */ | |
| 388 if (obj->count != 0 | |
| 389 || (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO) | |
| 390 || obj->next_input_name) | |
| 391 { | |
| 392 errno = EINVAL; | |
| 393 return NULL; | |
| 394 } | |
| 395 | |
| 396 name = temp_file (obj, flags, name); | |
| 397 if (! name) | |
| 398 return NULL; | |
| 399 | |
| 400 f = fopen (name, (flags & PEX_BINARY_OUTPUT) ? "wb" : "w"); | |
| 401 if (! f) | |
| 402 { | |
| 403 free (name); | |
| 404 return NULL; | |
| 405 } | |
| 406 | |
| 407 obj->input_file = f; | |
| 408 obj->next_input_name = name; | |
| 409 obj->next_input_name_allocated = (name != in_name); | |
| 410 | |
| 411 return f; | |
| 412 } | |
| 413 | |
| 414 /* Return a stream for a pipe connected to the standard input of the | |
| 415 first stage of the pipeline. */ | |
| 416 FILE * | |
| 417 pex_input_pipe (struct pex_obj *obj, int binary) | |
| 418 { | |
| 419 int p[2]; | |
| 420 FILE *f; | |
| 421 | |
| 422 /* You must call pex_input_pipe before the first pex_run or pex_one. */ | |
| 423 if (obj->count > 0) | |
| 424 goto usage_error; | |
| 425 | |
| 426 /* You must be using pipes. Implementations that don't support | |
| 427 pipes clear this flag before calling pex_init_common. */ | |
| 428 if (! (obj->flags & PEX_USE_PIPES)) | |
| 429 goto usage_error; | |
| 430 | |
| 431 /* If we have somehow already selected other input, that's a | |
| 432 mistake. */ | |
| 433 if ((obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO) | |
| 434 || obj->next_input_name) | |
| 435 goto usage_error; | |
| 436 | |
| 437 if (obj->funcs->pipe (obj, p, binary != 0) < 0) | |
| 438 return NULL; | |
| 439 | |
| 440 f = obj->funcs->fdopenw (obj, p[WRITE_PORT], binary != 0); | |
| 441 if (! f) | |
| 442 { | |
| 443 int saved_errno = errno; | |
| 444 obj->funcs->close (obj, p[READ_PORT]); | |
| 445 obj->funcs->close (obj, p[WRITE_PORT]); | |
| 446 errno = saved_errno; | |
| 447 return NULL; | |
| 448 } | |
| 449 | |
| 450 obj->next_input = p[READ_PORT]; | |
| 451 | |
| 452 return f; | |
| 453 | |
| 454 usage_error: | |
| 455 errno = EINVAL; | |
| 456 return NULL; | |
| 457 } | |
| 458 | |
| 459 /* Return a FILE pointer for the output of the last program | |
| 460 executed. */ | |
| 461 | |
| 462 FILE * | |
| 463 pex_read_output (struct pex_obj *obj, int binary) | |
| 464 { | |
| 465 if (obj->next_input_name != NULL) | |
| 466 { | |
| 467 const char *errmsg; | |
| 468 int err; | |
| 469 | |
| 470 /* We have to make sure that the process has completed before we | |
| 471 try to read the file. */ | |
| 472 if (!pex_get_status_and_time (obj, 0, &errmsg, &err)) | |
| 473 { | |
| 474 errno = err; | |
| 475 return NULL; | |
| 476 } | |
| 477 | |
| 478 obj->read_output = fopen (obj->next_input_name, binary ? "rb" : "r"); | |
| 479 | |
| 480 if (obj->next_input_name_allocated) | |
| 481 { | |
| 482 free (obj->next_input_name); | |
| 483 obj->next_input_name_allocated = 0; | |
| 484 } | |
| 485 obj->next_input_name = NULL; | |
| 486 } | |
| 487 else | |
| 488 { | |
| 489 int o; | |
| 490 | |
| 491 o = obj->next_input; | |
| 492 if (o < 0 || o == STDIN_FILE_NO) | |
| 493 return NULL; | |
| 494 obj->read_output = obj->funcs->fdopenr (obj, o, binary); | |
| 495 obj->next_input = -1; | |
| 496 } | |
| 497 | |
| 498 return obj->read_output; | |
| 499 } | |
| 500 | |
| 501 FILE * | |
| 502 pex_read_err (struct pex_obj *obj, int binary) | |
| 503 { | |
| 504 int o; | |
| 505 | |
| 506 o = obj->stderr_pipe; | |
| 507 if (o < 0 || o == STDIN_FILE_NO) | |
| 508 return NULL; | |
| 509 obj->read_err = obj->funcs->fdopenr (obj, o, binary); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
510 obj->stderr_pipe = -1; |
| 0 | 511 return obj->read_err; |
| 512 } | |
| 513 | |
| 514 /* Get the exit status and, if requested, the resource time for all | |
| 515 the child processes. Return 0 on failure, 1 on success. */ | |
| 516 | |
| 517 static int | |
| 518 pex_get_status_and_time (struct pex_obj *obj, int done, const char **errmsg, | |
| 519 int *err) | |
| 520 { | |
| 521 int ret; | |
| 522 int i; | |
| 523 | |
| 524 if (obj->number_waited == obj->count) | |
| 525 return 1; | |
| 526 | |
| 527 obj->status = XRESIZEVEC (int, obj->status, obj->count); | |
| 528 if ((obj->flags & PEX_RECORD_TIMES) != 0) | |
| 529 obj->time = XRESIZEVEC (struct pex_time, obj->time, obj->count); | |
| 530 | |
| 531 ret = 1; | |
| 532 for (i = obj->number_waited; i < obj->count; ++i) | |
| 533 { | |
| 534 if (obj->funcs->wait (obj, obj->children[i], &obj->status[i], | |
| 535 obj->time == NULL ? NULL : &obj->time[i], | |
| 536 done, errmsg, err) < 0) | |
| 537 ret = 0; | |
| 538 } | |
| 539 obj->number_waited = i; | |
| 540 | |
| 541 return ret; | |
| 542 } | |
| 543 | |
| 544 /* Get exit status of executed programs. */ | |
| 545 | |
| 546 int | |
| 547 pex_get_status (struct pex_obj *obj, int count, int *vector) | |
| 548 { | |
| 549 if (obj->status == NULL) | |
| 550 { | |
| 551 const char *errmsg; | |
| 552 int err; | |
| 553 | |
| 554 if (!pex_get_status_and_time (obj, 0, &errmsg, &err)) | |
| 555 return 0; | |
| 556 } | |
| 557 | |
| 558 if (count > obj->count) | |
| 559 { | |
| 560 memset (vector + obj->count, 0, (count - obj->count) * sizeof (int)); | |
| 561 count = obj->count; | |
| 562 } | |
| 563 | |
| 564 memcpy (vector, obj->status, count * sizeof (int)); | |
| 565 | |
| 566 return 1; | |
| 567 } | |
| 568 | |
| 569 /* Get process times of executed programs. */ | |
| 570 | |
| 571 int | |
| 572 pex_get_times (struct pex_obj *obj, int count, struct pex_time *vector) | |
| 573 { | |
| 574 if (obj->status == NULL) | |
| 575 { | |
| 576 const char *errmsg; | |
| 577 int err; | |
| 578 | |
| 579 if (!pex_get_status_and_time (obj, 0, &errmsg, &err)) | |
| 580 return 0; | |
| 581 } | |
| 582 | |
| 583 if (obj->time == NULL) | |
| 584 return 0; | |
| 585 | |
| 586 if (count > obj->count) | |
| 587 { | |
| 588 memset (vector + obj->count, 0, | |
| 589 (count - obj->count) * sizeof (struct pex_time)); | |
| 590 count = obj->count; | |
| 591 } | |
| 592 | |
| 593 memcpy (vector, obj->time, count * sizeof (struct pex_time)); | |
| 594 | |
| 595 return 1; | |
| 596 } | |
| 597 | |
| 598 /* Free a pex_obj structure. */ | |
| 599 | |
| 600 void | |
| 601 pex_free (struct pex_obj *obj) | |
| 602 { | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
603 /* Close pipe file descriptors corresponding to child's stdout and |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
604 stderr so that the child does not hang trying to output something |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
605 while we're waiting for it. */ |
| 0 | 606 if (obj->next_input >= 0 && obj->next_input != STDIN_FILE_NO) |
| 607 obj->funcs->close (obj, obj->next_input); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
608 if (obj->stderr_pipe >= 0 && obj->stderr_pipe != STDIN_FILE_NO) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
609 obj->funcs->close (obj, obj->stderr_pipe); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
610 if (obj->read_output != NULL) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
611 fclose (obj->read_output); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
612 if (obj->read_err != NULL) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
613 fclose (obj->read_err); |
| 0 | 614 |
| 615 /* If the caller forgot to wait for the children, we do it here, to | |
| 616 avoid zombies. */ | |
| 617 if (obj->status == NULL) | |
| 618 { | |
| 619 const char *errmsg; | |
| 620 int err; | |
| 621 | |
| 622 obj->flags &= ~ PEX_RECORD_TIMES; | |
| 623 pex_get_status_and_time (obj, 1, &errmsg, &err); | |
| 624 } | |
| 625 | |
| 626 if (obj->next_input_name_allocated) | |
| 627 free (obj->next_input_name); | |
| 111 | 628 free (obj->children); |
| 629 free (obj->status); | |
| 630 free (obj->time); | |
| 0 | 631 |
| 632 if (obj->remove_count > 0) | |
| 633 { | |
| 634 int i; | |
| 635 | |
| 636 for (i = 0; i < obj->remove_count; ++i) | |
| 637 { | |
| 638 remove (obj->remove[i]); | |
| 639 free (obj->remove[i]); | |
| 640 } | |
| 641 free (obj->remove); | |
| 642 } | |
| 643 | |
| 644 if (obj->funcs->cleanup != NULL) | |
| 645 obj->funcs->cleanup (obj); | |
| 646 | |
| 647 free (obj); | |
| 648 } |