io.c File Reference

#include "awk.h"
#include <fcntl.h>

Go to the source code of this file.

Classes
struct	recmatch
Defines
#define	O_ACCMODE   (O_RDONLY|O_WRONLY|O_RDWR)
#define	ENFILE   EMFILE
#define	at_eof(iop)   ((iop->flag & IOP_AT_EOF) != 0)
#define	has_no_data(iop)   (iop->dataend == NULL)
#define	no_data_left(iop)   (iop->off >= iop->dataend)
#define	binmode(mode)   (mode)
#define	getpgrp_arg()   getpid()
#define	set_RT_to_null()
#define	set_RT(str, len)
#define	min(x, y)   (x < y ? x : y)
Typedefs
typedef enum recvalues	RECVALUE
typedef enum scanstate	SCANSTATE
Enumerations
enum	two_way_close_type { CLOSE_ALL, CLOSE_TO, CLOSE_FROM }
enum	recvalues { REC_OK, NOTERM, TERMATEND, TERMNEAREND }
Functions
static IOBUF *nextfile	P ((int skipping))
void	do_nextfile ()
static IOBUF *	nextfile (int skipping)
void	set_FNR ()
void	set_NR ()
static int	inrec (IOBUF *iop)
static int	iop_close (IOBUF *iop)
void	do_input ()
const char *	redflags2str (int flags)
redirect *	redirect (NODE *tree, int *errflg)
redirect *	getredirect (const char *str, int len)
static void	close_one ()
NODE *	do_close (NODE *tree)
static int	close_redir (register struct redirect *rp, int exitwarn, two_way_close_type how)
int	flush_io ()
int	close_io ()
static int	str2mode (const char *mode)
int	devopen (const char *name, const char *mode)
static void	spec_setup (IOBUF *iop, int len, int allocate)
static int	specfdopen (IOBUF *iop, const char *name, const char *mode)
static int	pidopen (IOBUF *iop, const char *name, const char *mode ATTRIBUTE_UNUSED)
static int	useropen (IOBUF *iop, const char *name ATTRIBUTE_UNUSED, const char *mode ATTRIBUTE_UNUSED)
static IOBUF *	iop_open (const char *name, const char *mode, IOBUF *iop)
static int	two_way_open (const char *str, struct redirect *rp)
static int	wait_any (int interesting)
static IOBUF *	gawk_popen (const char *cmd, struct redirect *rp)
static int	gawk_pclose (struct redirect *rp)
NODE *	do_getline (NODE *tree)
int	pathopen (const char *file)
static int	do_pathopen (const char *file)
static IOBUF *	iop_alloc (int fd, const char *name, IOBUF *iop)
static void	grow_iop_buffer (IOBUF *iop)
static RECVALUE	rs1scan (IOBUF *iop, struct recmatch *recm, SCANSTATE *state)
static RECVALUE	rsrescan (IOBUF *iop, struct recmatch *recm, SCANSTATE *state)
static RECVALUE	rsnullscan (IOBUF *iop, struct recmatch *recm, SCANSTATE *state)
int	get_a_record (char **out, IOBUF *iop, int *errcode)
void	set_RS ()
static int	pty_vs_pipe (const char *command)
const char *	iopflags2str (int flag)
Variables
int	MRL
static struct redirect *	red_head = NULL
static NODE *	RS
static Regexp *	RS_re_yes_case
static Regexp *	RS_re_no_case
static Regexp *	RS_regexp
int	RS_is_null
int	output_is_tty
NODE *	ARGC_node
NODE *	ARGV_node
NODE *	ARGIND_node
NODE *	ERRNO_node
NODE **	fields_arr
static jmp_buf	filebuf

---

Define Documentation

#define at_eof (  iop   )     ((iop->flag & IOP_AT_EOF) != 0)

Definition at line 110 of file io.c. Referenced by get_a_record(), inrec(), and nextfile().

#define binmode (  mode   )     (mode)

Definition at line 221 of file io.c. Referenced by nextfile(), and redirect().

#define ENFILE   EMFILE

Definition at line 68 of file io.c. Referenced by redirect().

#define getpgrp_arg (   )     getpid()

Definition at line 1428 of file io.c. Referenced by load_procinfo(), and pidopen().

#define has_no_data (  iop   )     (iop->dataend == NULL)

Definition at line 111 of file io.c. Referenced by get_a_record().

#define min (  x, y   )     (x < y ? x : y)

Referenced by __mktime_internal(), and get_a_record().

#define no_data_left (  iop   )     (iop->off >= iop->dataend)

Definition at line 112 of file io.c. Referenced by get_a_record(), and inrec().

#define O_ACCMODE   (O_RDONLY|O_WRONLY|O_RDWR)

Definition at line 37 of file io.c. Referenced by devopen().

#define set_RT (  str, len   )

Value: (void)(! do_traditional && (unref(RT_node->var_value), \ RT_node->var_value = make_string(str, len))) Definition at line 2440 of file io.c. Referenced by get_a_record().

#define set_RT_to_null (   )

Value: (void)(! do_traditional && (unref(RT_node->var_value), \ RT_node->var_value = Nnull_string)) Definition at line 2436 of file io.c. Referenced by get_a_record().

---

Typedef Documentation

typedef enum recvalues RECVALUE

typedef enum scanstate SCANSTATE

---

Enumeration Type Documentation

enum recvalues

Enumerator: REC_OK  NOTERM  TERMATEND  TERMNEAREND  Definition at line 121 of file io.c. { REC_OK, /* record and terminator found, recmatch struct filled in */ NOTERM, /* no terminator found, give me more input data */ TERMATEND, /* found terminator at end of buffer */ TERMNEAREND, /* found terminator close to end of buffer, for RE might be bigger */ } RECVALUE;

enum two_way_close_type

Enumerator: CLOSE_ALL  CLOSE_TO  CLOSE_FROM  Definition at line 104 of file io.c. { CLOSE_ALL, CLOSE_TO, CLOSE_FROM } two_way_close_type;

---

Function Documentation

int close_io (   )

Definition at line 1015 of file io.c. References _, CLOSE_ALL, close_redir(), do_lint, errno, redirect::next, NULL, red_head, redirect::status, strerror, and warning(). Referenced by main(). { register struct redirect *rp; register struct redirect *next; int status = 0; errno = 0; for (rp = red_head; rp != NULL; rp = next) { next = rp->next; /* * close_redir() will print a message if needed * if do_lint, warn about lack of explicit close */ if (close_redir(rp, do_lint, CLOSE_ALL)) status++; rp = NULL; } /* * Some of the non-Unix os's have problems doing an fclose * on stdout and stderr. Since we don't really need to close * them, we just flush them, and do that across the board. */ if (fflush(stdout)) { warning(_("error writing standard output (%s)"), strerror(errno)); status++; } if (fflush(stderr)) { warning(_("error writing standard error (%s)"), strerror(errno)); status++; } return status; }

static void close_one (   )  [static]

Definition at line 756 of file io.c. References _, do_lint, errno, FALSE, fatal, fclose, redirect::flag, redirect::fp, lintwarn, redirect::next, NULL, redirect::prev, RED_FILE, red_head, RED_USED, strerror, TRUE, redirect::value, and warning(). Referenced by redirect(). { register struct redirect *rp; register struct redirect *rplast = NULL; static short warned = FALSE; if (do_lint && ! warned) { warned = TRUE; lintwarn(_("reached system limit for open files: starting to multiplex file descriptors")); } /* go to end of list first, to pick up least recently used entry */ for (rp = red_head; rp != NULL; rp = rp->next) rplast = rp; /* now work back up through the list */ for (rp = rplast; rp != NULL; rp = rp->prev) if (rp->fp != NULL && (rp->flag & RED_FILE) != 0) { rp->flag |= RED_USED; errno = 0; if (/* do_lint && */ fclose(rp->fp) != 0) warning(_("close of `%s' failed (%s)."), rp->value, strerror(errno)); rp->fp = NULL; break; } if (rp == NULL) /* surely this is the only reason ??? */ fatal(_("too many pipes or input files open")); }

static int close_redir (  register struct redirect *  rp, int  exitwarn, two_way_close_type  how )  [static]

Definition at line 852 of file io.c. References _, BINMODE, CLOSE_ALL, CLOSE_FROM, CLOSE_TO, do_lint, do_traditional, errno, fclose, free(), fwrite, gawk_pclose(), iop_close(), lintwarn, redirect::next, NULL, O_BINARY, os_setbinmode(), pclose, red_head, RED_PIPE, RED_PTY, RED_SOCKET, RED_TCP, RED_TWOWAY, RED_WRITE, redirect::status, strerror, update_ERRNO(), and warning(). Referenced by close_io(), and do_close(). { int status = 0; if (rp == NULL) return 0; if (rp->fp == stdout || rp->fp == stderr) return 0; if (do_lint && (rp->flag & RED_TWOWAY) == 0 && how != CLOSE_ALL) lintwarn(_("close: redirection `%s' not opened with `|&', second argument ignored"), rp->value); errno = 0; if ((rp->flag & RED_TWOWAY) != 0) { /* two-way pipe */ /* write end: */ if ((how == CLOSE_ALL || how == CLOSE_TO) && rp->fp != NULL) { #ifdef HAVE_SOCKETS if ((rp->flag & RED_TCP) != 0) (void) shutdown(fileno(rp->fp), SHUT_WR); #endif /* HAVE_SOCKETS */ if ((rp->flag & RED_PTY) != 0) { fwrite("\004\n", sizeof("\004\n") - 1, 1, rp->fp); fflush(rp->fp); } status = fclose(rp->fp); rp->fp = NULL; } /* read end: */ if (how == CLOSE_ALL || how == CLOSE_FROM) { if ((rp->flag & RED_SOCKET) != 0 && rp->iop != NULL) { #ifdef HAVE_SOCKETS if ((rp->flag & RED_TCP) != 0) (void) shutdown(rp->iop->fd, SHUT_RD); #endif /* HAVE_SOCKETS */ (void) iop_close(rp->iop); } else status = gawk_pclose(rp); rp->iop = NULL; } } else if ((rp->flag & (RED_PIPE|RED_WRITE)) == (RED_PIPE|RED_WRITE)) { /* write to pipe */ status = pclose(rp->fp); if ((BINMODE & 1) != 0) os_setbinmode(fileno(stdin), O_BINARY); rp->fp = NULL; } else if (rp->fp != NULL) { /* write to file */ status = fclose(rp->fp); rp->fp = NULL; } else if (rp->iop != NULL) { /* read from pipe/file */ if ((rp->flag & RED_PIPE) != 0) /* read from pipe */ status = gawk_pclose(rp); /* gawk_pclose sets rp->iop to null */ else { /* read from file */ status = iop_close(rp->iop); rp->iop = NULL; } } /* SVR4 awk checks and warns about status of close */ if (status != 0) { char *s = strerror(errno); /* * Too many people have complained about this. * As of 2.15.6, it is now under lint control. */ if (do_lint) { if ((rp->flag & RED_PIPE) != 0) lintwarn(_("failure status (%d) on pipe close of `%s' (%s)"), status, rp->value, s); else lintwarn(_("failure status (%d) on file close of `%s' (%s)"), status, rp->value, s); } if (! do_traditional) { /* set ERRNO too so that program can get at it */ update_ERRNO(); } } if (exitwarn) { /* * Don't use lintwarn() here. If lint warnings are fatal, * doing so prevents us from closing other open redirections. * * Using multiple full messages instead of string parameters * for the types makes message translation easier. */ if ((rp->flag & RED_SOCKET) != 0) warning(_("no explicit close of socket `%s' provided"), rp->value); else if ((rp->flag & RED_TWOWAY) != 0) warning(_("no explicit close of co-process `%s' provided"), rp->value); else if ((rp->flag & RED_PIPE) != 0) warning(_("no explicit close of pipe `%s' provided"), rp->value); else warning(_("no explicit close of file `%s' provided"), rp->value); } /* remove it from the list if closing both or both ends have been closed */ if (how == CLOSE_ALL || (rp->iop == NULL && rp->fp == NULL)) { if (rp->next != NULL) rp->next->prev = rp->prev; if (rp->prev != NULL) rp->prev->next = rp->next; else red_head = rp->next; free(rp->value); free((char *) rp); } return status; }

int devopen (  const char *  name, const char *  mode )

Definition at line 1227 of file io.c. References _, do_traditional, fatal, INVALID_HANDLE, NULL, O_ACCMODE, O_RDONLY, O_WRONLY, open, os_close_on_exec(), os_devopen(), os_isdir(), str2mode(), STREQ, and STREQN. Referenced by do_pathopen(), init_fds(), redirect(), specfdopen(), and two_way_open(). { int openfd; char *cp; char *ptr; int flag = 0; extern double strtod(); flag = str2mode(mode); if (STREQ(name, "-")) return fileno(stdin); openfd = INVALID_HANDLE; if (do_traditional) goto strictopen; if ((openfd = os_devopen(name, flag)) != INVALID_HANDLE) { os_close_on_exec(openfd, name, "file", ""); return openfd; } if (STREQN(name, "/dev/", 5)) { cp = (char *) name + 5; if (STREQ(cp, "stdin") && (flag & O_ACCMODE) == O_RDONLY) openfd = fileno(stdin); else if (STREQ(cp, "stdout") && (flag & O_ACCMODE) == O_WRONLY) openfd = fileno(stdout); else if (STREQ(cp, "stderr") && (flag & O_ACCMODE) == O_WRONLY) openfd = fileno(stderr); else if (STREQN(cp, "fd/", 3)) { cp += 3; openfd = (int) strtod(cp, &ptr); if (openfd <= INVALID_HANDLE || ptr == cp) openfd = INVALID_HANDLE; } /* do not set close-on-exec for inherited fd's */ if (openfd != INVALID_HANDLE) return openfd; } else if (STREQN(name, "/inet/", 6)) { #ifdef HAVE_SOCKETS /* /inet/protocol/localport/hostname/remoteport */ enum inet_prot protocol = INET_NONE; int localport, remoteport; char *hostname; char *hostnameslastcharp; char *localpname; char proto[4]; struct servent *service; cp = (char *) name + 6; /* which protocol? */ if (STREQN(cp, "tcp/", 4)) protocol = INET_TCP; else if (STREQN(cp, "udp/", 4)) protocol = INET_UDP; else if (STREQN(cp, "raw/", 4)) protocol = INET_RAW; else fatal(_("no (known) protocol supplied in special filename `%s'"), name); proto[0] = cp[0]; proto[1] = cp[1]; proto[2] = cp[2]; proto[3] = '\0'; cp += 4; /* which localport? */ localpname = cp; while (*cp != '/' && *cp != '\0') cp++; /* * Require a port, let them explicitly put 0 if * they don't care. */ if (*cp != '/' || cp == localpname) fatal(_("special file name `%s' is incomplete"), name); /* We change the special file name temporarily because we * need a 0-terminated string here for conversion with atoi(). * By using atoi() the use of decimal numbers is enforced. */ *cp = '\0'; localport = atoi(localpname); if (strcmp(localpname, "0") != 0 && (localport <= 0 || localport > 65535)) { service = getservbyname(localpname, proto); if (service == NULL) fatal(_("local port invalid in `%s'"), name); else localport = ntohs(service->s_port); } *cp = '/'; /* which hostname? */ cp++; hostname = cp; while (*cp != '/' && *cp != '\0') cp++; if (*cp != '/' || cp == hostname) fatal(_("must supply a remote hostname to `/inet'")); *cp = '\0'; hostnameslastcharp = cp; /* which remoteport? */ cp++; /* * The remote port ends the special file name. * This means there already is a 0 at the end of the string. * Therefore no need to patch any string ending. * * Here too, require a port, let them explicitly put 0 if * they don't care. */ if (*cp == '\0') fatal(_("must supply a remote port to `/inet'")); remoteport = atoi(cp); if (strcmp(cp, "0") != 0 && (remoteport <= 0 || remoteport > 65535)) { service = getservbyname(cp, proto); if (service == NULL) fatal(_("remote port invalid in `%s'"), name); else remoteport = ntohs(service->s_port); } /* Open Sesame! */ openfd = socketopen(protocol, localport, remoteport, hostname); *hostnameslastcharp = '/'; #else /* ! HAVE_SOCKETS */ fatal(_("TCP/IP communications are not supported")); #endif /* HAVE_SOCKETS */ } strictopen: if (openfd == INVALID_HANDLE) openfd = open(name, flag, 0666); if (openfd != INVALID_HANDLE) { if (os_isdir(openfd)) fatal(_("file `%s' is a directory"), name); os_close_on_exec(openfd, name, "file", ""); } return openfd; }

NODE* do_close (  NODE *  tree  )

Definition at line 790 of file io.c. References _, AWKNUM, CLOSE_ALL, CLOSE_FROM, close_redir(), CLOSE_TO, do_lint, do_posix, ERRNO_node, FALSE, fatal, force_string, free_temp, lintwarn, make_string, redirect::next, NULL, red_head, strcasecmp, STREQN, tmp_number, tree_eval, unref(), and redirect::value. Referenced by snode(). { NODE *tmp, *tmp2; register struct redirect *rp; two_way_close_type how = CLOSE_ALL; /* default */ tmp = force_string(tree_eval(tree->lnode)); /* 1st arg: redir to close */ if (tree->rnode != NULL) { /* 2nd arg if present: "to" or "from" for two-way pipe */ /* DO NOT use _() on the strings here! */ tmp2 = force_string(tree->rnode->lnode); if (strcasecmp(tmp2->stptr, "to") == 0) how = CLOSE_TO; else if (strcasecmp(tmp2->stptr, "from") == 0) how = CLOSE_FROM; else fatal(_("close: second argument must be `to' or `from'")); free_temp(tmp2); } for (rp = red_head; rp != NULL; rp = rp->next) { if (strlen(rp->value) == tmp->stlen && STREQN(rp->value, tmp->stptr, tmp->stlen)) break; } if (rp == NULL) { /* no match, return -1 */ char *cp; if (do_lint) lintwarn(_("close: `%.*s' is not an open file, pipe or co-process"), tmp->stlen, tmp->stptr); /* update ERRNO manually, using errno = ENOENT is a stretch. */ cp = _("close of redirection that was never opened"); unref(ERRNO_node->var_value); ERRNO_node->var_value = make_string(cp, strlen(cp)); free_temp(tmp); return tmp_number((AWKNUM) -1.0); } free_temp(tmp); fflush(stdout); /* synchronize regular output */ tmp = tmp_number((AWKNUM) close_redir(rp, FALSE, how)); rp = NULL; /* * POSIX says close() returns 0 on success, non-zero otherwise. * For POSIX, at this point we just return 0. Otherwise we * return the exit status of the process or of pclose(), depending. * This whole business is a mess. */ if (do_posix) { free_temp(tmp); return tmp_number((AWKNUM) 0); } return tmp; }

NODE* do_getline (  NODE *  tree  )

Definition at line 2220 of file io.c. References AWKNUM, do_traditional, FALSE, redirect::flag, FNR, get_a_record(), get_lhs, redirect::iop, iop_close(), make_string, MAYBE_NUM, nextfile(), NR, NULL, RED_EOF, RED_PIPE, RED_TWOWAY, redirect(), set_record(), tmp_number, unref(), and update_ERRNO(). Referenced by r_tree_eval(). { struct redirect *rp = NULL; IOBUF *iop; int cnt = EOF; char *s = NULL; int errcode; while (cnt == EOF) { if (tree->rnode == NULL) { /* no redirection */ iop = nextfile(FALSE); if (iop == NULL) /* end of input */ return tmp_number((AWKNUM) 0.0); } else { int redir_error = 0; rp = redirect(tree->rnode, &redir_error); if (rp == NULL && redir_error) { /* failed redirect */ if (! do_traditional) update_ERRNO(); return tmp_number((AWKNUM) -1.0); } iop = rp->iop; if (iop == NULL) /* end of input */ return tmp_number((AWKNUM) 0.0); } errcode = 0; cnt = get_a_record(&s, iop, &errcode); if (errcode != 0) { if (! do_traditional) update_ERRNO(); return tmp_number((AWKNUM) -1.0); } if (cnt == EOF) { if (rp != NULL) { /* * Don't do iop_close() here if we are * reading from a pipe; otherwise * gawk_pclose will not be called. */ if ((rp->flag & (RED_PIPE|RED_TWOWAY)) == 0) { (void) iop_close(iop); rp->iop = NULL; } rp->flag |= RED_EOF; /* sticky EOF */ return tmp_number((AWKNUM) 0.0); } else continue; /* try another file */ } if (rp == NULL) { NR++; FNR++; } if (tree->lnode == NULL) /* no optional var. */ set_record(s, cnt); else { /* assignment to variable */ Func_ptr after_assign = NULL; NODE **lhs; lhs = get_lhs(tree->lnode, &after_assign, FALSE); unref(*lhs); *lhs = make_string(s, cnt); (*lhs)->flags |= MAYBE_NUM; /* we may have to regenerate $0 here! */ if (after_assign != NULL) (*after_assign)(); } } return tmp_number((AWKNUM) 1.0); }

void do_input (   )

Definition at line 431 of file io.c. References exiting, expression_value, FALSE, filebuf, inrec(), interpret(), redirect::iop, nextfile(), and NULL. Referenced by main(). { IOBUF *iop; extern int exiting; int rval1, rval2, rval3; (void) setjmp(filebuf); /* for `nextfile' */ while ((iop = nextfile(FALSE)) != NULL) { /* * This was: if (inrec(iop) == 0) while (interpret(expression_value) && inrec(iop) == 0) continue; * Now expand it out for ease of debugging. */ rval1 = inrec(iop); if (rval1 == 0) { for (;;) { rval2 = rval3 = -1; /* for debugging */ rval2 = interpret(expression_value); if (rval2 != 0) rval3 = inrec(iop); if (rval2 == 0 || rval3 != 0) break; } } if (exiting) break; } }

void do_nextfile (   )

Definition at line 236 of file io.c. References filebuf, nextfile(), and TRUE. Referenced by interpret(). { (void) nextfile(TRUE); longjmp(filebuf, 1); }

static int do_pathopen (  const char *  file  )  [static]

Definition at line 2329 of file io.c. References defpath, devopen(), do_traditional, emalloc, envsep, FALSE, free(), getenv, INVALID_HANDLE, isdirpunct(), ispath(), len, NULL, STREQ, and TRUE. Referenced by pathopen(). { static const char *savepath = NULL; static int first = TRUE; const char *awkpath; char *cp, *trypath; int fd; int len; if (STREQ(file, "-")) return (0); if (do_traditional) return (devopen(file, "r")); if (first) { first = FALSE; if ((awkpath = getenv("AWKPATH")) != NULL && *awkpath) savepath = awkpath; /* used for restarting */ else savepath = defpath; } awkpath = savepath; /* some kind of path name, no search */ if (ispath(file)) return (devopen(file, "r")); /* no arbitrary limits: */ len = strlen(awkpath) + strlen(file) + 2; emalloc(trypath, char *, len, "do_pathopen"); do { trypath[0] = '\0'; for (cp = trypath; *awkpath && *awkpath != envsep; ) *cp++ = *awkpath++; if (cp != trypath) { /* nun-null element in path */ /* add directory punctuation only if needed */ if (! isdirpunct(*(cp-1))) *cp++ = '/'; /* append filename */ strcpy(cp, file); } else strcpy(trypath, file); if ((fd = devopen(trypath, "r")) > INVALID_HANDLE) { free(trypath); return (fd); } /* no luck, keep going */ if(*awkpath == envsep && awkpath[1] != '\0') awkpath++; /* skip colon */ } while (*awkpath != '\0'); free(trypath); /* * You might have one of the awk paths defined, WITHOUT the current * working directory in it. Therefore try to open the file in the * current directory. */ return (devopen(file, "r")); }

int flush_io (   )

Definition at line 977 of file io.c. References _, errno, redirect::flag, redirect::fp, redirect::next, NULL, red_head, RED_PIPE, RED_TWOWAY, RED_WRITE, redirect::status, strerror, redirect::value, and warning(). Referenced by do_fflush(), do_system(), and redirect(). { register struct redirect *rp; int status = 0; errno = 0; if (fflush(stdout)) { warning(_("error writing standard output (%s)"), strerror(errno)); status++; } if (fflush(stderr)) { warning(_("error writing standard error (%s)"), strerror(errno)); status++; } for (rp = red_head; rp != NULL; rp = rp->next) /* flush both files and pipes, what the heck */ if ((rp->flag & RED_WRITE) && rp->fp != NULL) { if (fflush(rp->fp)) { if (rp->flag & RED_PIPE) warning(_("pipe flush of `%s' failed (%s)."), rp->value, strerror(errno)); else if (rp->flag & RED_TWOWAY) warning(_("co-process flush of pipe to `%s' failed (%s)."), rp->value, strerror(errno)); else warning(_("file flush of `%s' failed (%s)."), rp->value, strerror(errno)); status++; } } if (status != 0) status = -1; /* canonicalize it */ return status; }

static int gawk_pclose (  struct redirect *  rp  )  [static]

Definition at line 2097 of file io.c. References redirect::iop, iop_close(), NULL, redirect::pid, redirect::status, and wait_any(). Referenced by close_redir(). { if (rp->iop != NULL) (void) iop_close(rp->iop); rp->iop = NULL; /* process previously found, return stored status */ if (rp->pid == -1) return rp->status; rp->status = wait_any(rp->pid); rp->pid = -1; return rp->status; }

static IOBUF* gawk_popen (  const char *  cmd, struct redirect *  rp )  [static]