/usr/src/usr.bin/awk/run.c

Bug Summary

File:	src/usr.bin/awk/run.c
Warning:	line 123, column 3 Use of memory after it is freed
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name run.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.bin/awk/obj -resource-dir /usr/local/lib/clang/13.0.0 -I . -I /usr/src/usr.bin/awk -D HAS_ISBLANK -D NDEBUG -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.bin/awk/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/usr.bin/awk/run.c
1/*	$OpenBSD: run.c,v 1.70 2021/11/01 18:28:24 millert Exp $	*/
2/****************************************************************
3Copyright (C) Lucent Technologies 1997
4All Rights Reserved

6Permission to use, copy, modify, and distribute this software and
7its documentation for any purpose and without fee is hereby
8granted, provided that the above copyright notice appear in all
9copies and that both that the copyright notice and this
10permission notice and warranty disclaimer appear in supporting
11documentation, and that the name Lucent Technologies or any of
12its entities not be used in advertising or publicity pertaining
13to distribution of the software without specific, written prior
14permission.

16LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
18IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
19SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
20WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
21IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
22ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
23THIS SOFTWARE.
24****************************************************************/

26#define DEBUG
27#include <stdio.h>
28#include <ctype.h>
29#include <errno(*__errno()).h>
30#include <wchar.h>
31#include <wctype.h>
32#include <fcntl.h>
33#include <setjmp.h>
34#include <limits.h>
35#include <math.h>
36#include <string.h>
37#include <stdlib.h>
38#include <time.h>
39#include <sys/types.h>
40#include <sys/wait.h>
41#include "awk.h"
42#include "awkgram.tab.h"

44static void stdinit(void);
45static void flush_all(void);

47#if 1
48#define tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0)	do { if (istemp(x)((x)->csub == 4)) tfree(x); } while (/*CONSTCOND*/0)
49#else
50void tempfree(Cell *p)do { if (((Cell *p)->csub == 4)) tfree(Cell *p); } while (
 0) {
if (p->ctype == OCELL1 && (p->csub < CUNK0 || p->csub > CFREE7)) {
WARNING("bad csub %d in Cell %d %s",
	p->csub, p->ctype, p->sval);
}
if (istemp(p)((p)->csub == 4))
tfree(p);
57}
58#endif

60/* do we really need these? */
61/* #ifdef _NFILE */
62/* #ifndef FOPEN_MAX */
63/* #define FOPEN_MAX _NFILE */
64/* #endif */
65/* #endif */
66/*  */
67/* #ifndef	FOPEN_MAX */
68/* #define	FOPEN_MAX	40 */	/* max number of open files */
69/* #endif */
70/*  */
71/* #ifndef RAND_MAX */
72/* #define RAND_MAX	32767 */	/* all that ansi guarantees */
73/* #endif */

75jmp_buf env;
76extern	int	pairstack[];
77extern	Awkfloat	srand_seed;

79Node	*winner = NULL((void *)0);	/* root of parse tree */
80Cell	*tmps;		/* free temporary cells for execution */

82static Cell	truecell	={ OBOOL2, BTRUE11, 0, 0, 1.0, NUM01, NULL((void *)0), NULL((void *)0) };
83Cell	*True	= &truecell;
84static Cell	falsecell	={ OBOOL2, BFALSE12, 0, 0, 0.0, NUM01, NULL((void *)0), NULL((void *)0) };
85Cell	*False	= &falsecell;
86static Cell	breakcell	={ OJUMP3, JBREAK23, 0, 0, 0.0, NUM01, NULL((void *)0), NULL((void *)0) };
87Cell	*jbreak	= &breakcell;
88static Cell	contcell	={ OJUMP3, JCONT24, 0, 0, 0.0, NUM01, NULL((void *)0), NULL((void *)0) };
89Cell	*jcont	= &contcell;
90static Cell	nextcell	={ OJUMP3, JNEXT22, 0, 0, 0.0, NUM01, NULL((void *)0), NULL((void *)0) };
91Cell	*jnext	= &nextcell;
92static Cell	nextfilecell	={ OJUMP3, JNEXTFILE26, 0, 0, 0.0, NUM01, NULL((void *)0), NULL((void *)0) };
93Cell	*jnextfile	= &nextfilecell;
94static Cell	exitcell	={ OJUMP3, JEXIT21, 0, 0, 0.0, NUM01, NULL((void *)0), NULL((void *)0) };
95Cell	*jexit	= &exitcell;
96static Cell	retcell		={ OJUMP3, JRET25, 0, 0, 0.0, NUM01, NULL((void *)0), NULL((void *)0) };
97Cell	*jret	= &retcell;
98static Cell	tempcell	={ OCELL1, CTEMP4, 0, EMPTY, 0.0, NUM01|STR02|DONTFREE04, NULL((void *)0), NULL((void *)0) };

100Node	*curnode = NULL((void *)0);	/* the node being executed, for debugging */

102/* buffer memory management */
103int adjbuf(char **pbuf, int *psiz, int minlen, int quantum, char **pbptr,
const char *whatrtn)
105/* pbuf:    address of pointer to buffer being managed
* psiz:    address of buffer size variable
* minlen:  minimum length of buffer needed
* quantum: buffer size quantum
* pbptr:   address of movable pointer into buffer, or 0 if none
* whatrtn: name of the calling routine if failure should cause fatal error
*
* return   0 for realloc failure, !=0 for success
*/
114{
if (minlen > *psiz) {
23
←
Assuming the condition is true→
24
←
Taking true branch→
char *tbuf;
int rminlen = quantum ? minlen % quantum : 0;
25
←
Assuming 'quantum' is 0→
26
←
'?' condition is false→
int boff = pbptr26.1
'pbptr' is non-null
 ? *pbptr - *pbuf : 0;
27
←
'?' condition is true→
/* round up to next multiple of quantum */
if (rminlen27.1
'rminlen' is 0
)
28
←
Taking false branch→
	minlen += quantum - rminlen;
tbuf = (char *) realloc(*pbuf, minlen);
29
←
Memory is released→
DPRINTF("adjbuf %s: %d %d (pbuf=%p, tbuf=%p)\n", whatrtn, *psiz, minlen, (void*)*pbuf, (void*)tbuf)if (dbg) printf("adjbuf %s: %d %d (pbuf=%p, tbuf=%p)\n", whatrtn
, *psiz, minlen, (void*)*pbuf, (void*)tbuf);
30
←
Assuming 'dbg' is not equal to 0→
31
←
Taking true branch→
32
←
Use of memory after it is freed
if (tbuf == NULL((void *)0)) {
	if (whatrtn)
		FATAL("out of memory in %s", whatrtn);
	return 0;
}
*pbuf = tbuf;
*psiz = minlen;
if (pbptr)
	*pbptr = tbuf + boff;
}
return 1;
135}

137void run(Node *a)	/* execution of parse tree starts here */
138{

stdinit();
execute(a);
closeall();
143}

145Cell *execute(Node *u)	/* execute a node of the parse tree */
146{
Cell *(*proc)(Node **, int);
Cell *x;
Node *a;

if (u == NULL((void *)0))
return(True);
for (a = u; ; a = a->nnext) {
curnode = a;
if (isvalue(a)((a)->ntype == 1)) {
	x = (Cell *) (a->narg[0]);
	if (isfld(x)((x)->tval & 0100) && !donefld)
		fldbld();
	else if (isrec(x)((x)->tval & 0200) && !donerec)
		recbld();
	return(x);
}
if (notlegal(a->nobj)(a->nobj <= 257 || a->nobj >= 352 || proctab[a->
nobj-257] == nullproc))	/* probably a Cell* but too risky to print */
	FATAL("illegal statement");
proc = proctab[a->nobj-FIRSTTOKEN257];
x = (*proc)(a->narg, a->nobj);
if (isfld(x)((x)->tval & 0100) && !donefld)
	fldbld();
else if (isrec(x)((x)->tval & 0200) && !donerec)
	recbld();
if (isexpr(a)((a)->ntype == 3))
	return(x);
if (isjump(x)((x)->ctype == 3))
	return(x);
if (a->nnext == NULL((void *)0))
	return(x);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
}
179}


182Cell *program(Node **a, int n)	/* execute an awk program */
183{				/* a[0] = BEGIN, a[1] = body, a[2] = END */
Cell *x;

if (setjmp(env) != 0)
goto ex;
if (a[0]) {		/* BEGIN */
x = execute(a[0]);
if (isexit(x)((x)->csub == 21))
	return(True);
if (isjump(x)((x)->ctype == 3))
	FATAL("illegal break, continue, next or nextfile from BEGIN");
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
}
if (a[1] || a[2])
while (getrec(&record, &recsize, true1) > 0) {
	x = execute(a[1]);
	if (isexit(x)((x)->csub == 21))
		break;
	tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
}
ex:
if (setjmp(env) != 0)	/* handles exit within END */
goto ex1;
if (a[2]) {		/* END */
x = execute(a[2]);
if (isbreak(x)((x)->csub == 23) || isnext(x)((x)->csub == 22 || (x)->csub == 26) || iscont(x)((x)->csub == 24))
	FATAL("illegal break, continue, next or nextfile from END");
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
}
ex1:
return(True);
214}

216struct Frame {	/* stack frame for awk function calls */
int nargs;	/* number of arguments in this call */
Cell *fcncell;	/* pointer to Cell for function */
Cell **args;	/* pointer to array of arguments after execute */
Cell *retval;	/* return value */
221};

223#define	NARGS50	50	/* max args in a call */

225struct Frame *frame = NULL((void *)0);	/* base of stack frames; dynamically allocated */
226int	nframe = 0;		/* number of frames allocated */
227struct Frame *frp = NULL((void *)0);	/* frame pointer. bottom level unused */

229Cell *call(Node **a, int n)	/* function call.  very kludgy and fragile */
230{
static const Cell newcopycell = { OCELL1, CCOPY6, 0, EMPTY, 0.0, NUM01|STR02|DONTFREE04, NULL((void *)0), NULL((void *)0) };
int i, ncall, ndef;
int freed = 0; /* handles potential double freeing when fcn & param share a tempcell */
Node *x;
Cell *args[NARGS50], *oargs[NARGS50];	/* BUG: fixed size arrays */
Cell *y, *z, *fcn;
char *s;

fcn = execute(a[0]);	/* the function itself */
s = fcn->nval;
if (!isfcn(fcn)((fcn)->tval & 040))
FATAL("calling undefined function %s", s);
if (frame == NULL((void *)0)) {
frp = frame = (struct Frame *) calloc(nframe += 100, sizeof(*frame));
if (frame == NULL((void *)0))
	FATAL("out of space for stack frames calling %s", s);
}
for (ncall = 0, x = a[1]; x != NULL((void *)0); x = x->nnext)	/* args in call */
ncall++;
ndef = (int) fcn->fval;			/* args in defn */
DPRINTF("calling %s, %d args (%d in defn), frp=%d\n", s, ncall, ndef, (int) (frp-frame))if (dbg) printf("calling %s, %d args (%d in defn), frp=%d\n",
 s, ncall, ndef, (int) (frp-frame));
if (ncall > ndef)
WARNING("function %s called with %d args, uses only %d",
	s, ncall, ndef);
if (ncall + ndef > NARGS50)
FATAL("function %s has %d arguments, limit %d", s, ncall+ndef, NARGS50);
for (i = 0, x = a[1]; x != NULL((void *)0); i++, x = x->nnext) {	/* get call args */
DPRINTF("evaluate args[%d], frp=%d:\n", i, (int) (frp-frame))if (dbg) printf("evaluate args[%d], frp=%d:\n", i, (int) (frp
-frame));
y = execute(x);
oargs[i] = y;
DPRINTF("args[%d]: %s %f <%s>, t=%o\n",if (dbg) printf("args[%d]: %s %f <%s>, t=%o\n", i, ((y->
nval) ? (y->nval) : "(null)"), y->fval, ((y)->tval &
 020) ? "(array)" : ((y->sval) ? (y->sval) : "(null)"),
 y->tval)
	i, NN(y->nval), y->fval, isarr(y) ? "(array)" : NN(y->sval), y->tval)if (dbg) printf("args[%d]: %s %f <%s>, t=%o\n", i, ((y->
nval) ? (y->nval) : "(null)"), y->fval, ((y)->tval &
 020) ? "(array)" : ((y->sval) ? (y->sval) : "(null)"),
 y->tval);
if (isfcn(y)((y)->tval & 040))
	FATAL("can't use function %s as argument in %s", y->nval, s);
if (isarr(y)((y)->tval & 020))
	args[i] = y;	/* arrays by ref */
else
	args[i] = copycell(y);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
}
for ( ; i < ndef; i++) {	/* add null args for ones not provided */
args[i] = gettemp();
*args[i] = newcopycell;
}
frp++;	/* now ok to up frame */
if (frp >= frame + nframe) {
int dfp = frp - frame;	/* old index */
frame = (struct Frame *) reallocarray(frame, (nframe += 100), sizeof(*frame));
if (frame == NULL((void *)0))
	FATAL("out of space for stack frames in %s", s);
frp = frame + dfp;
}
frp->fcncell = fcn;
frp->args = args;
frp->nargs = ndef;	/* number defined with (excess are locals) */
frp->retval = gettemp();

DPRINTF("start exec of %s, frp=%d\n", s, (int) (frp-frame))if (dbg) printf("start exec of %s, frp=%d\n", s, (int) (frp-frame
));
y = execute((Node *)(fcn->sval));	/* execute body */
DPRINTF("finished exec of %s, frp=%d\n", s, (int) (frp-frame))if (dbg) printf("finished exec of %s, frp=%d\n", s, (int) (frp
-frame));

for (i = 0; i < ndef; i++) {
Cell *t = frp->args[i];
if (isarr(t)((t)->tval & 020)) {
	if (t->csub == CCOPY6) {
		if (i >= ncall) {
			freesymtab(t);
			t->csub = CTEMP4;
			tempfree(t)do { if (((t)->csub == 4)) tfree(t); } while ( 0);
		} else {
			oargs[i]->tval = t->tval;
			oargs[i]->tval &= ~(STR02|NUM01|DONTFREE04);
			oargs[i]->sval = t->sval;
			tempfree(t)do { if (((t)->csub == 4)) tfree(t); } while ( 0);
		}
	}
} else if (t != y) {	/* kludge to prevent freeing twice */
	t->csub = CTEMP4;
	tempfree(t)do { if (((t)->csub == 4)) tfree(t); } while ( 0);
} else if (t == y && t->csub == CCOPY6) {
	t->csub = CTEMP4;
	tempfree(t)do { if (((t)->csub == 4)) tfree(t); } while ( 0);
	freed = 1;
}
}
tempfree(fcn)do { if (((fcn)->csub == 4)) tfree(fcn); } while ( 0);
if (isexit(y)((y)->csub == 21) || isnext(y)((y)->csub == 22 || (y)->csub == 26))
return y;
if (freed == 0) {
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);	/* don't free twice! */
}
z = frp->retval;			/* return value */
DPRINTF("%s returns %g |%s| %o\n", s, getfval(z), getsval(z), z->tval)if (dbg) printf("%s returns %g |%s| %o\n", s, getfval(z), getsval
(z), z->tval);
frp--;
return(z);
326}

328Cell *copycell(Cell *x)	/* make a copy of a cell in a temp */
329{
Cell *y;

/* copy is not constant or field */

y = gettemp();
y->tval = x->tval & ~(CON010|FLD0100|REC0200);
y->csub = CCOPY6;	/* prevents freeing until call is over */
y->nval = x->nval;	/* BUG? */
if (isstr(x)((x)->tval & 02) /* || x->ctype == OCELL */) {
y->sval = tostring(x->sval);
y->tval &= ~DONTFREE04;
} else
y->tval |= DONTFREE04;
y->fval = x->fval;
return y;
345}

347Cell *arg(Node **a, int n)	/* nth argument of a function */
348{

n = ptoi(a[0]);	/* argument number, counting from 0 */
DPRINTF("arg(%d), frp->nargs=%d\n", n, frp->nargs)if (dbg) printf("arg(%d), frp->nargs=%d\n", n, frp->nargs
);
if (n+1 > frp->nargs)
FATAL("argument #%d of function %s was not supplied",
	n+1, frp->fcncell->nval);
return frp->args[n];
356}

358Cell *jump(Node **a, int n)	/* break, continue, next, nextfile, return */
359{
Cell *y;

switch (n) {
case EXIT297:
if (a[0] != NULL((void *)0)) {
	y = execute(a[0]);
	errorflag = (int) getfval(y);
	tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
}
longjmp(env, 1);
case RETURN340:
if (a[0] != NULL((void *)0)) {
	y = execute(a[0]);
	if ((y->tval & (STR02|NUM01)) == (STR02|NUM01)) {
		setsval(frp->retval, getsval(y));
		frp->retval->fval = getfval(y);
		frp->retval->tval |= NUM01;
	}
	else if (y->tval & STR02)
		setsval(frp->retval, getsval(y));
	else if (y->tval & NUM01)
		setfval(frp->retval, getfval(y));
	else		/* can't happen */
		FATAL("bad type variable %d", y->tval);
	tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
}
return(jret);
case NEXT307:
return(jnext);
case NEXTFILE308:
nextfile();
return(jnextfile);
case BREAK292:
return(jbreak);
case CONTINUE294:
return(jcont);
default:	/* can't happen */
FATAL("illegal jump type %d", n);
}
return 0;	/* not reached */
400}

402Cell *awkgetline(Node **a, int n)	/* get next line from specific input */
403{		/* a[0] is variable, a[1] is operator, a[2] is filename */
Cell *r, *x;
extern Cell **fldtab;
FILE *fp;
char *buf;
int bufsize = recsize;
int mode;
bool_Bool newflag;
double result;

if ((buf = (char *) malloc(bufsize)) == NULL((void *)0))
FATAL("out of memory in getline");

fflush(stdout(&__sF[1]));	/* in case someone is waiting for a prompt */
r = gettemp();
if (a[1] != NULL((void *)0)) {		/* getline < file */
x = execute(a[2]);		/* filename */
mode = ptoi(a[1]);
if (mode == '|')		/* input pipe */
	mode = LE286;	/* arbitrary flag */
fp = openfile(mode, getsval(x), &newflag);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
if (fp == NULL((void *)0))
	n = -1;
else
	n = readrec(&buf, &bufsize, fp, newflag);
if (n <= 0) {
	;
} else if (a[0] != NULL((void *)0)) {	/* getline var <file */
	x = execute(a[0]);
	setsval(x, buf);
	if (is_number(x->sval, & result)is_valid_number(x->sval, 0, ((void *)0), & result)) {
		x->fval = result;
		x->tval |= NUM01;
	}
	tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
} else {			/* getline <file */
	setsval(fldtab[0], buf);
	if (is_number(fldtab[0]->sval, & result)is_valid_number(fldtab[0]->sval, 0, ((void *)0), & result
)) {
		fldtab[0]->fval = result;
		fldtab[0]->tval |= NUM01;
	}
}
} else {			/* bare getline; use current input */
if (a[0] == NULL((void *)0))	/* getline */
	n = getrec(&record, &recsize, true1);
else {			/* getline var */
	n = getrec(&buf, &bufsize, false0);
	if (n > 0) {
		x = execute(a[0]);
		setsval(x, buf);
		if (is_number(x->sval, & result)is_valid_number(x->sval, 0, ((void *)0), & result)) {
			x->fval = result;
			x->tval |= NUM01;
		}
		tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
	}
}
}
setfval(r, (Awkfloat) n);
free(buf);
return r;
465}

467Cell *getnf(Node **a, int n)	/* get NF */
468{
if (!donefld)
fldbld();
return (Cell *) a[0];
472}

474static char *
475makearraystring(Node *p, const char *func)
476{
char *buf;
int bufsz = recsize;
size_t blen;

if ((buf = (char *) malloc(bufsz)) == NULL((void *)0)) {
FATAL("%s: out of memory", func);
}

blen = 0;
buf[blen] = '\0';

for (; p; p = p->nnext) {
Cell *x = execute(p);	/* expr */
char *s = getsval(x);
size_t seplen = strlen(getsval(subseploc));
size_t nsub = p->nnext ? seplen : 0;
size_t slen = strlen(s);
size_t tlen = blen + slen + nsub;

if (!adjbuf(&buf, &bufsz, tlen + 1, recsize, 0, func)) {
	FATAL("%s: out of memory %s[%s...]",
	    func, x->nval, buf);
}
memcpy(buf + blen, s, slen);
if (nsub) {
	memcpy(buf + blen + slen, *SUBSEP, nsub);
}
buf[tlen] = '\0';
blen = tlen;
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
}
return buf;
509}

511Cell *array(Node **a, int n)	/* a[0] is symtab, a[1] is list of subscripts */
512{
Cell *x, *z;
char *buf;

x = execute(a[0]);	/* Cell* for symbol table */
buf = makearraystring(a[1], __func__);
if (!isarr(x)((x)->tval & 020)) {
DPRINTF("making %s into an array\n", NN(x->nval))if (dbg) printf("making %s into an array\n", ((x->nval) ? (
x->nval) : "(null)"));
if (freeable(x)( ((x)->tval & (02|04)) == 02 ))
	xfree(x->sval){ if ((x->sval) != ((void *)0)) { free((void *)(intptr_t)(
x->sval)); (x->sval) = ((void *)0); } };
x->tval &= ~(STR02|NUM01|DONTFREE04);
x->tval |= ARR020;
x->sval = (char *) makesymtab(NSYMTAB50);
}
z = setsymtab(buf, "", 0.0, STR02|NUM01, (Array *) x->sval);
z->ctype = OCELL1;
z->csub = CVAR2;
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
free(buf);
return(z);
532}

534Cell *awkdelete(Node **a, int n)	/* a[0] is symtab, a[1] is list of subscripts */
535{
Cell *x;

x = execute(a[0]);	/* Cell* for symbol table */
if (x == symtabloc) {
FATAL("cannot delete SYMTAB or its elements");
}
if (!isarr(x)((x)->tval & 020))
return True;
if (a[1] == NULL((void *)0)) {	/* delete the elements, not the table */
freesymtab(x);
x->tval &= ~STR02;
x->tval |= ARR020;
x->sval = (char *) makesymtab(NSYMTAB50);
} else {
char *buf = makearraystring(a[1], __func__);
freeelem(x, buf);
free(buf);
}
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
return True;
556}

558Cell *intest(Node **a, int n)	/* a[0] is index (list), a[1] is symtab */
559{
Cell *ap, *k;
char *buf;

ap = execute(a[1]);	/* array name */
if (!isarr(ap)((ap)->tval & 020)) {
DPRINTF("making %s into an array\n", ap->nval)if (dbg) printf("making %s into an array\n", ap->nval);
if (freeable(ap)( ((ap)->tval & (02|04)) == 02 ))
	xfree(ap->sval){ if ((ap->sval) != ((void *)0)) { free((void *)(intptr_t)
(ap->sval)); (ap->sval) = ((void *)0); } };
ap->tval &= ~(STR02|NUM01|DONTFREE04);
ap->tval |= ARR020;
ap->sval = (char *) makesymtab(NSYMTAB50);
}
buf = makearraystring(a[0], __func__);
k = lookup(buf, (Array *) ap->sval);
tempfree(ap)do { if (((ap)->csub == 4)) tfree(ap); } while ( 0);
free(buf);
if (k == NULL((void *)0))
return(False);
else
return(True);
580}


583Cell *matchop(Node **a, int n)	/* ~ and match() */
584{
Cell *x, *y;
char *s, *t;
int i;
fa *pfa;
int (*mf)(fa *, const char *) = match, mode = 0;

if (n == MATCHFCN306) {
mf = pmatch;
mode = 1;
}
x = execute(a[1]);	/* a[1] = target text */
s = getsval(x);
if (a[0] == NULL((void *)0))	/* a[1] == 0: already-compiled reg expr */
i = (*mf)((fa *) a[2], s);
else {
y = execute(a[2]);	/* a[2] = regular expr */
t = getsval(y);
pfa = makedfa(t, mode);
i = (*mf)(pfa, s);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
}
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
if (n == MATCHFCN306) {
int start = patbeg - s + 1;
if (patlen < 0)
	start = 0;
setfval(rstartloc, (Awkfloat) start);
setfval(rlengthloc, (Awkfloat) patlen);
x = gettemp();
x->tval = NUM01;
x->fval = start;
return x;
} else if ((n == MATCH265 && i == 1) || (n == NOTMATCH266 && i == 0))
return(True);
else
return(False);
621}


624Cell *boolop(Node **a, int n)	/* a[0] || a[1], a[0] && a[1], !a[0] */
625{
Cell *x, *y;
int i;

x = execute(a[0]);
i = istrue(x)((x)->csub == 11);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
switch (n) {
case BOR281:
if (i) return(True);
y = execute(a[1]);
i = istrue(y)((y)->csub == 11);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
if (i) return(True);
else return(False);
case AND280:
if ( !i ) return(False);
y = execute(a[1]);
i = istrue(y)((y)->csub == 11);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
if (i) return(True);
else return(False);
case NOT345:
if (i) return(False);
else return(True);
default:	/* can't happen */
FATAL("unknown boolean operator %d", n);
}
return 0;	/*NOTREACHED*/
654}

656Cell *relop(Node **a, int n)	/* a[0 < a[1], etc. */
657{
int i;
Cell *x, *y;
Awkfloat j;

x = execute(a[0]);
y = execute(a[1]);
if (x->tval&NUM01 && y->tval&NUM01) {
j = x->fval - y->fval;
i = j<0? -1: (j>0? 1: 0);
} else {
i = strcmp(getsval(x), getsval(y));
}
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
switch (n) {
case LT287:	if (i<0) return(True);
	else return(False);
case LE286:	if (i<=0) return(True);
	else return(False);
case NE288:	if (i!=0) return(True);
	else return(False);
case EQ283:	if (i == 0) return(True);
	else return(False);
case GE284:	if (i>=0) return(True);
	else return(False);
case GT285:	if (i>0) return(True);
	else return(False);
default:	/* can't happen */
FATAL("unknown relational operator %d", n);
}
return 0;	/*NOTREACHED*/
689}

691void tfree(Cell *a)	/* free a tempcell */
692{
if (freeable(a)( ((a)->tval & (02|04)) == 02 )) {
DPRINTF("freeing %s %s %o\n", NN(a->nval), NN(a->sval), a->tval)if (dbg) printf("freeing %s %s %o\n", ((a->nval) ? (a->
nval) : "(null)"), ((a->sval) ? (a->sval) : "(null)"), a
->tval);
xfree(a->sval){ if ((a->sval) != ((void *)0)) { free((void *)(intptr_t)(
a->sval)); (a->sval) = ((void *)0); } };
}
if (a == tmps)
FATAL("tempcell list is curdled");
a->cnext = tmps;
tmps = a;
701}

703Cell *gettemp(void)	/* get a tempcell */
704{	int i;
Cell *x;

if (!tmps) {
tmps = (Cell *) calloc(100, sizeof(*tmps));
if (!tmps)
	FATAL("out of space for temporaries");
for (i = 1; i < 100; i++)
	tmps[i-1].cnext = &tmps[i];
tmps[i-1].cnext = NULL((void *)0);
}
x = tmps;
tmps = x->cnext;
*x = tempcell;
return(x);
719}

721Cell *indirect(Node **a, int n)	/* $( a[0] ) */
722{
Awkfloat val;
Cell *x;
int m;
char *s;

x = execute(a[0]);
val = getfval(x);	/* freebsd: defend against super large field numbers */
if ((Awkfloat)INT_MAX2147483647 < val)
FATAL("trying to access out of range field %s", x->nval);
m = (int) val;
if (m == 0 && !is_number(s = getsval(x), NULL)is_valid_number(s = getsval(x), 0, ((void *)0), ((void *)0)))	/* suspicion! */
FATAL("illegal field $(%s), name \"%s\"", s, x->nval);
/* BUG: can x->nval ever be null??? */
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = fieldadr(m);
x->ctype = OCELL1;	/* BUG?  why are these needed? */
x->csub = CFLD1;
return(x);
741}

743Cell *substr(Node **a, int nnn)		/* substr(a[0], a[1], a[2]) */
744{
int k, m, n;
char *s;
int temp;
Cell *x, *y, *z = NULL((void *)0);

x = execute(a[0]);
y = execute(a[1]);
if (a[2] != NULL((void *)0))
z = execute(a[2]);
s = getsval(x);
k = strlen(s) + 1;
if (k <= 1) {
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
if (a[2] != NULL((void *)0)) {
	tempfree(z)do { if (((z)->csub == 4)) tfree(z); } while ( 0);
}
x = gettemp();
setsval(x, "");
return(x);
}
m = (int) getfval(y);
if (m <= 0)
m = 1;
else if (m > k)
m = k;
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
if (a[2] != NULL((void *)0)) {
n = (int) getfval(z);
tempfree(z)do { if (((z)->csub == 4)) tfree(z); } while ( 0);
} else
n = k - 1;
if (n < 0)
n = 0;
else if (n > k - m)
n = k - m;
DPRINTF("substr: m=%d, n=%d, s=%s\n", m, n, s)if (dbg) printf("substr: m=%d, n=%d, s=%s\n", m, n, s);
y = gettemp();
temp = s[n+m-1];	/* with thanks to John Linderman */
s[n+m-1] = '\0';
setsval(y, s + m - 1);
s[n+m-1] = temp;
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
return(y);
789}

791Cell *sindex(Node **a, int nnn)		/* index(a[0], a[1]) */
792{
Cell *x, *y, *z;
char *s1, *s2, *p1, *p2, *q;
Awkfloat v = 0.0;

x = execute(a[0]);
s1 = getsval(x);
y = execute(a[1]);
s2 = getsval(y);

z = gettemp();
for (p1 = s1; *p1 != '\0'; p1++) {
for (q = p1, p2 = s2; *p2 != '\0' && *q == *p2; q++, p2++)
	continue;
if (*p2 == '\0') {
	v = (Awkfloat) (p1 - s1 + 1);	/* origin 1 */
	break;
}
}
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
setfval(z, v);
return(z);
815}

817#define	MAXNUMSIZE50	50

819int format(char **pbuf, int *pbufsize, const char *s, Node *a)	/* printf-like conversions */
820{
char *fmt;
char *p, *t;
const char *os;
Cell *x;
int flag = 0, n;
int fmtwd; /* format width */
int fmtsz = recsize;
char *buf = *pbuf;
int bufsize = *pbufsize;
830#define FMTSZ(a)(fmtsz - ((a) - fmt))   (fmtsz - ((a) - fmt))
831#define BUFSZ(a)(bufsize - ((a) - buf))   (bufsize - ((a) - buf))

static bool_Bool first = true1;
static bool_Bool have_a_format = false0;

if (first) {
char xbuf[100];

snprintf(xbuf, sizeof(xbuf), "%a", 42.0);
have_a_format = (strcmp(xbuf, "0x1.5p+5") == 0);
first = false0;
}

os = s;
p = buf;
if ((fmt = (char *) malloc(fmtsz)) == NULL((void *)0))
FATAL("out of memory in format()");
while (*s) {
adjbuf(&buf, &bufsize, MAXNUMSIZE50+1+p-buf, recsize, &p, "format1");
if (*s != '%') {
	*p++ = *s++;
	continue;
}
if (*(s+1) == '%') {
	*p++ = '%';
	s += 2;
	continue;
}
/* have to be real careful in case this is a huge number, eg, %100000d */
fmtwd = atoi(s+1);
if (fmtwd < 0)
	fmtwd = -fmtwd;
adjbuf(&buf, &bufsize, fmtwd+1+p-buf, recsize, &p, "format2");
for (t = fmt; (*t++ = *s) != '\0'; s++) {
	if (!adjbuf(&fmt, &fmtsz, MAXNUMSIZE50+1+t-fmt, recsize, &t, "format3"))
		FATAL("format item %.30s... ran format() out of memory", os);
	/* Ignore size specifiers */
	if (strchr("hjLlqtz", *s) != NULL((void *)0)) {	/* the ansi panoply */
		t--;
		continue;
	}
	if (isalpha((uschar)*s))
		break;
	if (*s == '$') {
		FATAL("'$' not permitted in awk formats");
	}
	if (*s == '*') {
		if (a == NULL((void *)0)) {
			FATAL("not enough args in printf(%s)", os);
		}
		x = execute(a);
		a = a->nnext;
		snprintf(t - 1, FMTSZ(t - 1)(fmtsz - ((t - 1) - fmt)),
		    "%d", fmtwd=(int) getfval(x));
		if (fmtwd < 0)
			fmtwd = -fmtwd;
		adjbuf(&buf, &bufsize, fmtwd+1+p-buf, recsize, &p, "format");
		t = fmt + strlen(fmt);
		tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
	}
}
*t = '\0';
if (fmtwd < 0)
	fmtwd = -fmtwd;
adjbuf(&buf, &bufsize, fmtwd+1+p-buf, recsize, &p, "format4");
switch (*s) {
case 'a': case 'A':
	if (have_a_format)
		flag = *s;
	else
		flag = 'f';
	break;
case 'f': case 'e': case 'g': case 'E': case 'G':
	flag = 'f';
	break;
case 'd': case 'i': case 'o': case 'x': case 'X': case 'u':
	flag = (*s == 'd' || *s == 'i') ? 'd' : 'u';
	*(t-1) = 'j';
	*t = *s;
	*++t = '\0';
	break;
case 's':
	flag = 's';
	break;
case 'c':
	flag = 'c';
	break;
default:
	WARNING("weird printf conversion %s", fmt);
	flag = '?';
	break;
}
if (a == NULL((void *)0))
	FATAL("not enough args in printf(%s)", os);
x = execute(a);
a = a->nnext;
n = MAXNUMSIZE50;
if (fmtwd > n)
	n = fmtwd;
adjbuf(&buf, &bufsize, 1+n+p-buf, recsize, &p, "format5");
switch (flag) {
case '?':	snprintf(p, BUFSZ(p)(bufsize - ((p) - buf)), "%s", fmt);	/* unknown, so dump it too */
	t = getsval(x);
	n = strlen(t);
	if (fmtwd > n)
		n = fmtwd;
	adjbuf(&buf, &bufsize, 1+strlen(p)+n+p-buf, recsize, &p, "format6");
	p += strlen(p);
	snprintf(p, BUFSZ(p)(bufsize - ((p) - buf)), "%s", t);
	break;
case 'a':
case 'A':
case 'f':	snprintf(p, BUFSZ(p)(bufsize - ((p) - buf)), fmt, getfval(x)); break;
case 'd':	snprintf(p, BUFSZ(p)(bufsize - ((p) - buf)), fmt, (intmax_t) getfval(x)); break;
case 'u':	snprintf(p, BUFSZ(p)(bufsize - ((p) - buf)), fmt, (uintmax_t) getfval(x)); break;
case 's':
	t = getsval(x);
	n = strlen(t);
	if (fmtwd > n)
		n = fmtwd;
	if (!adjbuf(&buf, &bufsize, 1+n+p-buf, recsize, &p, "format7"))
		FATAL("huge string/format (%d chars) in printf %.30s... ran format() out of memory", n, t);
	snprintf(p, BUFSZ(p)(bufsize - ((p) - buf)), fmt, t);
	break;
case 'c':
	if (isnum(x)((x)->tval & 01)) {
		if ((int)getfval(x))
			snprintf(p, BUFSZ(p)(bufsize - ((p) - buf)), fmt, (int) getfval(x));
		else {
			*p++ = '\0'; /* explicit null byte */
			*p = '\0';   /* next output will start here */
		}
	} else
		snprintf(p, BUFSZ(p)(bufsize - ((p) - buf)), fmt, getsval(x)[0]);
	break;
default:
	FATAL("can't happen: bad conversion %c in format()", flag);
}
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
p += strlen(p);
s++;
}
*p = '\0';
free(fmt);
for ( ; a; a = a->nnext)		/* evaluate any remaining args */
execute(a);
*pbuf = buf;
*pbufsize = bufsize;
return p - buf;
980}

982Cell *awksprintf(Node **a, int n)		/* sprintf(a[0]) */
983{
Cell *x;
Node *y;
char *buf;
int bufsz=3*recsize;

if ((buf = (char *) malloc(bufsz)) == NULL((void *)0))
FATAL("out of memory in awksprintf");
y = a[0]->nnext;
x = execute(a[0]);
if (format(&buf, &bufsz, getsval(x), y) == -1)
FATAL("sprintf string %.30s... too long.  can't happen.", buf);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = gettemp();
x->sval = buf;
x->tval = STR02;
return(x);
1000}

1002Cell *awkprintf(Node **a, int n)		/* printf */
1003{	/* a[0] is list of args, starting with format string */
/* a[1] is redirection operator, a[2] is redirection file */
FILE *fp;
Cell *x;
Node *y;
char *buf;
int len;
int bufsz=3*recsize;

if ((buf = (char *) malloc(bufsz)) == NULL((void *)0))
FATAL("out of memory in awkprintf");
y = a[0]->nnext;
x = execute(a[0]);
if ((len = format(&buf, &bufsz, getsval(x), y)) == -1)
FATAL("printf string %.30s... too long.  can't happen.", buf);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
if (a[1] == NULL((void *)0)) {
/* fputs(buf, stdout); */
fwrite(buf, len, 1, stdout(&__sF[1]));
if (ferror(stdout)(!__isthreaded ? ((((&__sF[1]))->_flags & 0x0040) !=
 0) : (ferror)((&__sF[1]))))
	FATAL("write error on stdout");
} else {
fp = redirect(ptoi(a[1]), a[2]);
/* fputs(buf, fp); */
fwrite(buf, len, 1, fp);
fflush(fp);
if (ferror(fp)(!__isthreaded ? (((fp)->_flags & 0x0040) != 0) : (ferror
)(fp)))
	FATAL("write error on %s", filename(fp));
}
free(buf);
return(True);
1034}

1036Cell *arith(Node **a, int n)	/* a[0] + a[1], etc.  also -a[0] */
1037{
Awkfloat i, j = 0;
double v;
Cell *x, *y, *z;

x = execute(a[0]);
i = getfval(x);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
if (n != UMINUS346 && n != UPLUS347) {
y = execute(a[1]);
j = getfval(y);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
}
z = gettemp();
switch (n) {
case ADD309:
i += j;
break;
case MINUS310:
i -= j;
break;
case MULT311:
i *= j;
break;
case DIVIDE312:
if (j == 0)
	FATAL("division by zero");
i /= j;
break;
case MOD313:
if (j == 0)
	FATAL("division by zero in mod");
modf(i/j, &v);
i = i - j * v;
break;
case UMINUS346:
i = -i;
break;
case UPLUS347: /* handled by getfval(), above */
break;
case POWER348:
if (j >= 0 && modf(j, &v) == 0.0)	/* pos integer exponent */
	i = ipow(i, (int) j);
             else {
	errno(*__errno()) = 0;
	i = errcheck(pow(i, j), "pow");
             }
break;
default:	/* can't happen */
FATAL("illegal arithmetic operator %d", n);
}
setfval(z, i);
return(z);
1090}

1092double ipow(double x, int n)	/* x**n.  ought to be done by pow, but isn't always */
1093{
double v;

if (n <= 0)
return 1;
v = ipow(x, n/2);
if (n % 2 == 0)
return v * v;
else
return x * v * v;
1103}

1105Cell *incrdecr(Node **a, int n)		/* a[0]++, etc. */
1106{
Cell *x, *z;
int k;
Awkfloat xf;

x = execute(a[0]);
xf = getfval(x);
k = (n == PREINCR329 || n == POSTINCR328) ? 1 : -1;
if (n == PREINCR329 || n == PREDECR331) {
setfval(x, xf + k);
return(x);
}
z = gettemp();
setfval(z, xf);
setfval(x, xf + k);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
return(z);
1123}

1125Cell *assign(Node **a, int n)	/* a[0] = a[1], a[0] += a[1], etc. */
1126{		/* this is subtle; don't muck with it. */
Cell *x, *y;
Awkfloat xf, yf;
double v;

y = execute(a[1]);
x = execute(a[0]);
if (n == ASSIGN314) {	/* ordinary assignment */
if (x == y && !(x->tval & (FLD0100|REC0200)) && x != nfloc)
	;	/* self-assignment: leave alone unless it's a field or NF */
else if ((y->tval & (STR02|NUM01)) == (STR02|NUM01)) {
	setsval(x, getsval(y));
	x->fval = getfval(y);
	x->tval |= NUM01;
}
else if (isstr(y)((y)->tval & 02))
	setsval(x, getsval(y));
else if (isnum(y)((y)->tval & 01))
	setfval(x, getfval(y));
else
	funnyvar(y, "read value of");
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
return(x);
}
xf = getfval(x);
yf = getfval(y);
switch (n) {
case ADDEQ316:
xf += yf;
break;
case SUBEQ317:
xf -= yf;
break;
case MULTEQ318:
xf *= yf;
break;
case DIVEQ319:
if (yf == 0)
	FATAL("division by zero in /=");
xf /= yf;
break;
case MODEQ320:
if (yf == 0)
	FATAL("division by zero in %%=");
modf(xf/yf, &v);
xf = xf - yf * v;
break;
case POWEQ321:
if (yf >= 0 && modf(yf, &v) == 0.0)	/* pos integer exponent */
	xf = ipow(xf, (int) yf);
             else {
	errno(*__errno()) = 0;
	xf = errcheck(pow(xf, yf), "pow");
             }
break;
default:
FATAL("illegal assignment operator %d", n);
break;
}
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
setfval(x, xf);
return(x);
1188}

1190Cell *cat(Node **a, int q)	/* a[0] cat a[1] */
1191{
Cell *x, *y, *z;
int n1, n2;
char *s = NULL((void *)0);
int ssz = 0;

x = execute(a[0]);
n1 = strlen(getsval(x));
adjbuf(&s, &ssz, n1, recsize, 0, "cat1");
memcpy(s, x->sval, n1);

y = execute(a[1]);
n2 = strlen(getsval(y));
adjbuf(&s, &ssz, n1 + n2 + 1, recsize, 0, "cat2");
memcpy(s + n1, y->sval, n2);
s[n1 + n2] = '\0';

tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);

z = gettemp();
z->sval = s;
z->tval = STR02;

return(z);
1216}

1218Cell *pastat(Node **a, int n)	/* a[0] { a[1] } */
1219{
Cell *x;

if (a[0] == NULL((void *)0))
x = execute(a[1]);
else {
x = execute(a[0]);
if (istrue(x)((x)->csub == 11)) {
	tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
	x = execute(a[1]);
}
}
return x;
1232}

1234Cell *dopa2(Node **a, int n)	/* a[0], a[1] { a[2] } */
1235{
Cell *x;
int pair;

pair = ptoi(a[3]);
if (pairstack[pair] == 0) {
x = execute(a[0]);
if (istrue(x)((x)->csub == 11))
	pairstack[pair] = 1;
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
}
if (pairstack[pair] == 1) {
x = execute(a[1]);
if (istrue(x)((x)->csub == 11))
	pairstack[pair] = 0;
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = execute(a[2]);
return(x);
}
return(False);
1255}

1257Cell *split(Node **a, int nnn)	/* split(a[0], a[1], a[2]); a[3] is type */
1258{
Cell *x = NULL((void *)0), *y, *ap;
const char *s, *origs, *t;
const char *fs = NULL((void *)0);
char *origfs = NULL((void *)0);
int sep;
char temp, num[50];
int n, tempstat, arg3type;
double result;

y = execute(a[0]);	/* source string */
origs = s = strdup(getsval(y));
if (s == NULL((void *)0))
FATAL("out of space in split");
arg3type = ptoi(a[3]);
if (a[2] == NULL((void *)0))		/* fs string */
fs = getsval(fsloc);
else if (arg3type == STRING337) {	/* split(str,arr,"string") */
x = execute(a[2]);
fs = origfs = strdup(getsval(x));
if (fs == NULL((void *)0))
	FATAL("out of space in split");
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
} else if (arg3type == REGEXPR338)
fs = "(regexpr)";	/* split(str,arr,/regexpr/) */
else
FATAL("illegal type of split");
sep = *fs;
ap = execute(a[1]);	/* array name */
freesymtab(ap);
DPRINTF("split: s=|%s|, a=%s, sep=|%s|\n", s, NN(ap->nval), fs)if (dbg) printf("split: s=|%s|, a=%s, sep=|%s|\n", s, ((ap->
nval) ? (ap->nval) : "(null)"), fs);
ap->tval &= ~STR02;
ap->tval |= ARR020;
ap->sval = (char *) makesymtab(NSYMTAB50);

n = 0;
      if (arg3type == REGEXPR338 && strlen((char*)((fa*)a[2])->restr) == 0) {
/* split(s, a, //); have to arrange that it looks like empty sep */
arg3type = 0;
fs = "";
sep = 0;
}
if (*s != '\0' && (strlen(fs) > 1 || arg3type == REGEXPR338)) {	/* reg expr */
fa *pfa;
if (arg3type == REGEXPR338) {	/* it's ready already */
	pfa = (fa *) a[2];
} else {
	pfa = makedfa(fs, 1);
}
if (nematch(pfa,s)) {
	tempstat = pfa->initstat;
	pfa->initstat = 2;
	do {
		n++;
		snprintf(num, sizeof(num), "%d", n);
		temp = *patbeg;
		setptr(patbeg, '\0')(*(char *)(intptr_t)(patbeg)) = ('\0');
		if (is_number(s, & result)is_valid_number(s, 0, ((void *)0), & result))
			setsymtab(num, s, result, STR02|NUM01, (Array *) ap->sval);
		else
			setsymtab(num, s, 0.0, STR02, (Array *) ap->sval);
		setptr(patbeg, temp)(*(char *)(intptr_t)(patbeg)) = (temp);
		s = patbeg + patlen;
		if (*(patbeg+patlen-1) == '\0' || *s == '\0') {
			n++;
			snprintf(num, sizeof(num), "%d", n);
			setsymtab(num, "", 0.0, STR02, (Array *) ap->sval);
			pfa->initstat = tempstat;
			goto spdone;
		}
	} while (nematch(pfa,s));
	pfa->initstat = tempstat; 	/* bwk: has to be here to reset */
					/* cf gsub and refldbld */
}
n++;
snprintf(num, sizeof(num), "%d", n);
if (is_number(s, & result)is_valid_number(s, 0, ((void *)0), & result))
	setsymtab(num, s, result, STR02|NUM01, (Array *) ap->sval);
else
	setsymtab(num, s, 0.0, STR02, (Array *) ap->sval);
spdone:
pfa = NULL((void *)0);
} else if (sep == ' ') {
for (n = 0; ; ) {
1342#define ISWS(c)((c) == ' ' || (c) == '\t' || (c) == '\n')	((c) == ' ' || (c) == '\t' || (c) == '\n')
	while (ISWS(*s)((*s) == ' ' || (*s) == '\t' || (*s) == '\n'))
		s++;
	if (*s == '\0')
		break;
	n++;
	t = s;
	do
		s++;
	while (*s != '\0' && !ISWS(*s)((*s) == ' ' || (*s) == '\t' || (*s) == '\n'));
	temp = *s;
	setptr(s, '\0')(*(char *)(intptr_t)(s)) = ('\0');
	snprintf(num, sizeof(num), "%d", n);
	if (is_number(t, & result)is_valid_number(t, 0, ((void *)0), & result))
		setsymtab(num, t, result, STR02|NUM01, (Array *) ap->sval);
	else
		setsymtab(num, t, 0.0, STR02, (Array *) ap->sval);
	setptr(s, temp)(*(char *)(intptr_t)(s)) = (temp);
	if (*s != '\0')
		s++;
}
} else if (sep == 0) {	/* new: split(s, a, "") => 1 char/elem */
for (n = 0; *s != '\0'; s++) {
	char buf[2];
	n++;
	snprintf(num, sizeof(num), "%d", n);
	buf[0] = *s;
	buf[1] = '\0';
	if (isdigit((uschar)buf[0]))
		setsymtab(num, buf, atof(buf), STR02|NUM01, (Array *) ap->sval);
	else
		setsymtab(num, buf, 0.0, STR02, (Array *) ap->sval);
}
} else if (*s != '\0') {
for (;;) {
	n++;
	t = s;
	while (*s != sep && *s != '\n' && *s != '\0')
		s++;
	temp = *s;
	setptr(s, '\0')(*(char *)(intptr_t)(s)) = ('\0');
	snprintf(num, sizeof(num), "%d", n);
	if (is_number(t, & result)is_valid_number(t, 0, ((void *)0), & result))
		setsymtab(num, t, result, STR02|NUM01, (Array *) ap->sval);
	else
		setsymtab(num, t, 0.0, STR02, (Array *) ap->sval);
	setptr(s, temp)(*(char *)(intptr_t)(s)) = (temp);
	if (*s++ == '\0')
		break;
}
}
tempfree(ap)do { if (((ap)->csub == 4)) tfree(ap); } while ( 0);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
xfree(origs){ if ((origs) != ((void *)0)) { free((void *)(intptr_t)(origs
)); (origs) = ((void *)0); } };
xfree(origfs){ if ((origfs) != ((void *)0)) { free((void *)(intptr_t)(origfs
)); (origfs) = ((void *)0); } };
x = gettemp();
x->tval = NUM01;
x->fval = n;
return(x);
1401}

1403Cell *condexpr(Node **a, int n)	/* a[0] ? a[1] : a[2] */
1404{
Cell *x;

x = execute(a[0]);
if (istrue(x)((x)->csub == 11)) {
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = execute(a[1]);
} else {
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = execute(a[2]);
}
return(x);
1416}

1418Cell *ifstat(Node **a, int n)	/* if (a[0]) a[1]; else a[2] */
1419{
Cell *x;

x = execute(a[0]);
if (istrue(x)((x)->csub == 11)) {
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = execute(a[1]);
} else if (a[2] != NULL((void *)0)) {
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = execute(a[2]);
}
return(x);
1431}

1433Cell *whilestat(Node **a, int n)	/* while (a[0]) a[1] */
1434{
Cell *x;

for (;;) {
x = execute(a[0]);
if (!istrue(x)((x)->csub == 11))
	return(x);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = execute(a[1]);
if (isbreak(x)((x)->csub == 23)) {
	x = True;
	return(x);
}
if (isnext(x)((x)->csub == 22 || (x)->csub == 26) || isexit(x)((x)->csub == 21) || isret(x)((x)->csub == 25))
	return(x);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
}
1451}

1453Cell *dostat(Node **a, int n)	/* do a[0]; while(a[1]) */
1454{
Cell *x;

for (;;) {
x = execute(a[0]);
if (isbreak(x)((x)->csub == 23))
	return True;
if (isnext(x)((x)->csub == 22 || (x)->csub == 26) || isexit(x)((x)->csub == 21) || isret(x)((x)->csub == 25))
	return(x);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = execute(a[1]);
if (!istrue(x)((x)->csub == 11))
	return(x);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
}
1469}

1471Cell *forstat(Node **a, int n)	/* for (a[0]; a[1]; a[2]) a[3] */
1472{
Cell *x;

x = execute(a[0]);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
for (;;) {
if (a[1]!=NULL((void *)0)) {
	x = execute(a[1]);
	if (!istrue(x)((x)->csub == 11)) return(x);
	else tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
}
x = execute(a[3]);
if (isbreak(x)((x)->csub == 23))		/* turn off break */
	return True;
if (isnext(x)((x)->csub == 22 || (x)->csub == 26) || isexit(x)((x)->csub == 21) || isret(x)((x)->csub == 25))
	return(x);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = execute(a[2]);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
}
1492}

1494Cell *instat(Node **a, int n)	/* for (a[0] in a[1]) a[2] */
1495{
Cell *x, *vp, *arrayp, *cp, *ncp;
Array *tp;
int i;

vp = execute(a[0]);
arrayp = execute(a[1]);
if (!isarr(arrayp)((arrayp)->tval & 020)) {
return True;
}
tp = (Array *) arrayp->sval;
tempfree(arrayp)do { if (((arrayp)->csub == 4)) tfree(arrayp); } while ( 0
);
for (i = 0; i < tp->size; i++) {	/* this routine knows too much */
for (cp = tp->tab[i]; cp != NULL((void *)0); cp = ncp) {
	setsval(vp, cp->nval);
	ncp = cp->cnext;
	x = execute(a[2]);
	if (isbreak(x)((x)->csub == 23)) {
		tempfree(vp)do { if (((vp)->csub == 4)) tfree(vp); } while ( 0);
		return True;
	}
	if (isnext(x)((x)->csub == 22 || (x)->csub == 26) || isexit(x)((x)->csub == 21) || isret(x)((x)->csub == 25)) {
		tempfree(vp)do { if (((vp)->csub == 4)) tfree(vp); } while ( 0);
		return(x);
	}
	tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
}
}
return True;
1524}

1526static char *nawk_convert(const char *s, int (*fun_c)(int),
  wint_t (*fun_wc)(wint_t))
1528{
char *buf      = NULL((void *)0);
char *pbuf     = NULL((void *)0);
const char *ps = NULL((void *)0);
size_t n       = 0;
wchar_t wc;
size_t sz = MB_CUR_MAX__mb_cur_max();

if (sz == 1) {
buf = tostring(s);

for (pbuf = buf; *pbuf; pbuf++)
	*pbuf = fun_c((uschar)*pbuf);

return buf;
} else {
/* upper/lower character may be shorter/longer */
buf = tostringN(s, strlen(s) * sz + 1);

(void) mbtowc(NULL((void *)0), NULL((void *)0), 0);	/* reset internal state */
/*
 * Reset internal state here too.
 * Assign result to avoid a compiler warning. (Casting to void
 * doesn't work.)
 * Increment said variable to avoid a different warning.
 */
int unused = wctomb(NULL((void *)0), L'\0');
unused++;

ps   = s;
pbuf = buf;
while (n = mbtowc(&wc, ps, sz),
       n > 0 && n != (size_t)-1 && n != (size_t)-2)
{
	ps += n;

	n = wctomb(pbuf, fun_wc(wc));
	if (n == (size_t)-1)
		FATAL("illegal wide character %s", s);

	pbuf += n;
}

*pbuf = '\0';

if (n)
	FATAL("illegal byte sequence %s", s);

return buf;
}
1578}

1580#ifdef __DJGPP__
1581static wint_t towupper(wint_t wc)
1582{
if (wc >= 0 && wc < 256)
return toupper(wc & 0xFF);

return wc;
1587}

1589static wint_t towlower(wint_t wc)
1590{
if (wc >= 0 && wc < 256)
return tolower(wc & 0xFF);

return wc;
1595}
1596#endif

1598static char *nawk_toupper(const char *s)
1599{
return nawk_convert(s, toupper, towupper);
1601}

1603static char *nawk_tolower(const char *s)
1604{
return nawk_convert(s, tolower, towlower);
1606}

1608Cell *bltin(Node **a, int n)	/* builtin functions. a[0] is type, a[1] is arg list */
1609{
Cell *x, *y;
Awkfloat u;
int t, sz;
Awkfloat tmp;
char *buf, *fmt;
Node *nextarg;
FILE *fp;
int status = 0;
time_t tv;
struct tm *tm, tmbuf;

t = ptoi(a[0]);
x = execute(a[1]);
nextarg = a[1]->nnext;
switch (t) {
case FLENGTH1:
if (isarr(x)((x)->tval & 020))
	u = ((Array *) x->sval)->nelem;	/* GROT.  should be function*/
else
	u = strlen(getsval(x));
break;
case FLOG4:
errno(*__errno()) = 0;
u = errcheck(log(getfval(x)), "log");
break;
case FINT5:
modf(getfval(x), &u); break;
case FEXP3:
errno(*__errno()) = 0;
u = errcheck(exp(getfval(x)), "exp");
break;
case FSQRT2:
errno(*__errno()) = 0;
u = errcheck(sqrt(getfval(x)), "sqrt");
break;
case FSIN9:
u = sin(getfval(x)); break;
case FCOS10:
u = cos(getfval(x)); break;
case FATAN11:
if (nextarg == NULL((void *)0)) {
	WARNING("atan2 requires two arguments; returning 1.0");
	u = 1.0;
} else {
	y = execute(a[1]->nnext);
	u = atan2(getfval(x), getfval(y));
	tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
	nextarg = nextarg->nnext;
}
break;
case FCOMPL18:
u = ~((int)getfval(x));
break;
case FAND15:
if (nextarg == 0) {
	WARNING("and requires two arguments; returning 0");
	u = 0;
	break;
}
y = execute(a[1]->nnext);
u = ((int)getfval(x)) & ((int)getfval(y));
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
nextarg = nextarg->nnext;
break;
case FFOR16:
if (nextarg == 0) {
	WARNING("or requires two arguments; returning 0");
	u = 0;
	break;
}
y = execute(a[1]->nnext);
u = ((int)getfval(x)) | ((int)getfval(y));
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
nextarg = nextarg->nnext;
break;
case FXOR17:
if (nextarg == 0) {
	WARNING("xor requires two arguments; returning 0");
	u = 0;
	break;
}
y = execute(a[1]->nnext);
u = ((int)getfval(x)) ^ ((int)getfval(y));
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
nextarg = nextarg->nnext;
break;
case FLSHIFT19:
if (nextarg == 0) {
	WARNING("lshift requires two arguments; returning 0");
	u = 0;
	break;
}
y = execute(a[1]->nnext);
u = ((int)getfval(x)) << ((int)getfval(y));
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
nextarg = nextarg->nnext;
break;
case FRSHIFT20:
if (nextarg == 0) {
	WARNING("rshift requires two arguments; returning 0");
	u = 0;
	break;
}
y = execute(a[1]->nnext);
u = ((int)getfval(x)) >> ((int)getfval(y));
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
nextarg = nextarg->nnext;
break;
case FSYSTEM6:
fflush(stdout(&__sF[1]));		/* in case something is buffered already */
status = system(getsval(x));
u = status;
if (status != -1) {
	if (WIFEXITED(status)(((status) & 0177) == 0)) {
		u = WEXITSTATUS(status)(int)(((unsigned)(status) >> 8) & 0xff);
	} else if (WIFSIGNALED(status)(((status) & 0177) != 0177 && ((status) & 0177
) != 0)) {
		u = WTERMSIG(status)(((status) & 0177)) + 256;
1727#ifdef WCOREDUMP
		if (WCOREDUMP(status)((status) & 0200))
			u += 256;
1730#endif
	} else	/* something else?!? */
		u = 0;
}
break;
case FRAND7:
/* random() returns numbers in [0..2^31-1]
 * in order to get a number in [0, 1), divide it by 2^31
 */
u = (Awkfloat) random() / (0x7fffffffL + 0x1UL);
break;
case FSRAND8:
if (isrec(x)((x)->tval & 0200)) {		/* no argument provided */
	u = time(NULL((void *)0));
	tmp = u;
	srandom((unsigned int) u);
} else {
	u = getfval(x);
	tmp = u;
	srandom_deterministic((unsigned int) u);
}
u = srand_seed;
srand_seed = tmp;
break;
case FTOUPPER12:
case FTOLOWER13:
if (t == FTOUPPER12)
	buf = nawk_toupper(getsval(x));
else
	buf = nawk_tolower(getsval(x));
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = gettemp();
setsval(x, buf);
free(buf);
return x;
case FFLUSH14:
if (isrec(x)((x)->tval & 0200) || strlen(getsval(x)) == 0) {
	flush_all();	/* fflush() or fflush("") -> all */
	u = 0;
} else if ((fp = openfile(FFLUSH14, getsval(x), NULL((void *)0))) == NULL((void *)0))
	u = EOF(-1);
else
	u = fflush(fp);
break;
case FMKTIME23:
memset(&tmbuf, 0, sizeof(tmbuf));
tm = &tmbuf;
t = sscanf(getsval(x), "%d %d %d %d %d %d %d",
    &tm->tm_year, &tm->tm_mon, &tm->tm_mday, &tm->tm_hour,
    &tm->tm_min, &tm->tm_sec, &tm->tm_isdst);
switch (t) {
case 6:
	tm->tm_isdst = -1;	/* let mktime figure it out */
	/* FALLTHROUGH */
case 7:
	tm->tm_year -= 1900;
	tm->tm_mon--;
	u = mktime(tm);
	break;
default:
	u = -1;
	break;
}
break;
case FSYSTIME21:
u = time((time_t *) 0);
break;
case FSTRFTIME22:
/* strftime([format [,timestamp]]) */
if (nextarg) {
	y = execute(nextarg);
	nextarg = nextarg->nnext;
	tv = (time_t) getfval(y);
	tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
} else
	tv = time((time_t *) 0);
tm = localtime(&tv);
if (tm == NULL((void *)0))
	FATAL("bad time %ld", (long)tv);

if (isrec(x)((x)->tval & 0200)) {
	/* format argument not provided, use default */
	fmt = tostring("%a %b %d %H:%M:%S %Z %Y");
} else
	fmt = tostring(getsval(x));

sz = 32;
buf = NULL((void *)0);
do {
	if ((buf = (char *) reallocarray(buf, 2, sz)) == NULL((void *)0))
		FATAL("out of memory in strftime");
	sz *= 2;
} while (strftime(buf, sz, fmt, tm) == 0 && fmt[0] != '\0');

y = gettemp();
setsval(y, buf);
free(fmt);
free(buf);

return y;
default:	/* can't happen */
FATAL("illegal function type %d", t);
break;
}
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = gettemp();
setfval(x, u);
if (nextarg != NULL((void *)0)) {
WARNING("warning: function has too many arguments");
for ( ; nextarg; nextarg = nextarg->nnext)
	execute(nextarg);
}
return(x);
1843}

1845Cell *printstat(Node **a, int n)	/* print a[0] */
1846{
Node *x;
Cell *y;
FILE *fp;

if (a[1] == NULL((void *)0))	/* a[1] is redirection operator, a[2] is file */
fp = stdout(&__sF[1]);
else
fp = redirect(ptoi(a[1]), a[2]);
for (x = a[0]; x != NULL((void *)0); x = x->nnext) {
y = execute(x);
fputs(getpssval(y), fp);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
if (x->nnext == NULL((void *)0))
	fputs(getsval(orsloc), fp);
else
	fputs(getsval(ofsloc), fp);
}
if (a[1] != NULL((void *)0))
fflush(fp);
if (ferror(fp)(!__isthreaded ? (((fp)->_flags & 0x0040) != 0) : (ferror
)(fp)))
FATAL("write error on %s", filename(fp));
return(True);
1869}

1871Cell *nullproc(Node **a, int n)
1872{
return 0;
1874}


1877FILE *redirect(int a, Node *b)	/* set up all i/o redirections */
1878{
FILE *fp;
Cell *x;
char *fname;

x = execute(b);
fname = getsval(x);
fp = openfile(a, fname, NULL((void *)0));
if (fp == NULL((void *)0))
FATAL("can't open file %s", fname);
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
return fp;
1890}

1892struct files {
FILE	*fp;
const char	*fname;
int	mode;	/* '|', 'a', 'w' => LE/LT, GT */
1896} *files;

1898size_t nfiles;

1900static void stdinit(void)	/* in case stdin, etc., are not constants */
1901{
nfiles = FOPEN_MAX20;
files = (struct files *) calloc(nfiles, sizeof(*files));
if (files == NULL((void *)0))
FATAL("can't allocate file memory for %zu files", nfiles);
      files[0].fp = stdin(&__sF[0]);
files[0].fname = "/dev/stdin";
files[0].mode = LT287;
      files[1].fp = stdout(&__sF[1]);
files[1].fname = "/dev/stdout";
files[1].mode = GT285;
      files[2].fp = stderr(&__sF[2]);
files[2].fname = "/dev/stderr";
files[2].mode = GT285;
1915}

1917FILE *openfile(int a, const char *us, bool_Bool *pnewflag)
1918{
const char *s = us;
size_t i;
int m;
FILE *fp = NULL((void *)0);

if (*s == '\0')
FATAL("null file name in print or getline");
for (i = 0; i < nfiles; i++)
if (files[i].fname && strcmp(s, files[i].fname) == 0 &&
    (a == files[i].mode || (a==APPEND282 && files[i].mode==GT285) ||
     a == FFLUSH14)) {
	if (pnewflag)
		*pnewflag = false0;
	return files[i].fp;
}
if (a == FFLUSH14)	/* didn't find it, so don't create it! */
return NULL((void *)0);

for (i = 0; i < nfiles; i++)
if (files[i].fp == NULL((void *)0))
	break;
if (i >= nfiles) {
struct files *nf;
size_t nnf = nfiles + FOPEN_MAX20;
nf = (struct files *) reallocarray(files, nnf, sizeof(*nf));
if (nf == NULL((void *)0))
	FATAL("cannot grow files for %s and %zu files", s, nnf);
memset(&nf[nfiles], 0, FOPEN_MAX20 * sizeof(*nf));
nfiles = nnf;
files = nf;
}
fflush(stdout(&__sF[1]));	/* force a semblance of order */
m = a;
if (a == GT285) {
fp = fopen(s, "w");
} else if (a == APPEND282) {
fp = fopen(s, "a");
m = GT285;	/* so can mix > and >> */
} else if (a == '|') {	/* output pipe */
fp = popen(s, "w");
} else if (a == LE286) {	/* input pipe */
fp = popen(s, "r");
} else if (a == LT287) {	/* getline <file */
fp = strcmp(s, "-") == 0 ? stdin(&__sF[0]) : fopen(s, "r");	/* "-" is stdin */
} else	/* can't happen */
FATAL("illegal redirection %d", a);
if (fp != NULL((void *)0)) {
files[i].fname = tostring(s);
files[i].fp = fp;
files[i].mode = m;
if (pnewflag)
	*pnewflag = true1;
if (fp != stdin(&__sF[0]) && fp != stdout(&__sF[1]) && fp != stderr(&__sF[2]))
	(void) fcntl(fileno(fp)(!__isthreaded ? ((fp)->_file) : (fileno)(fp)), F_SETFD2, FD_CLOEXEC1);
}
return fp;
1975}

1977const char *filename(FILE *fp)
1978{
size_t i;

for (i = 0; i < nfiles; i++)
if (fp == files[i].fp)
	return files[i].fname;
return "???";
1985}

Cell *closefile(Node **a, int n)
{
Cell *x;
size_t i;
bool_Bool stat;

x = execute(a[0]);
getsval(x);
stat = true1;
for (i = 0; i < nfiles; i++) {
if (!files[i].fname || strcmp(x->sval, files[i].fname) != 0)
	continue;
if (ferror(files[i].fp)(!__isthreaded ? (((files[i].fp)->_flags & 0x0040) != 0
) : (ferror)(files[i].fp)))
	FATAL("i/o error occurred on %s", files[i].fname);
if (files[i].fp == stdin(&__sF[0]) || files[i].fp == stdout(&__sF[1]) ||
    files[i].fp == stderr(&__sF[2]))
	stat = freopen("/dev/null", "r+", files[i].fp) == NULL((void *)0);
else if (files[i].mode == '|' || files[i].mode == LE286)
	stat = pclose(files[i].fp) == -1;
else
	stat = fclose(files[i].fp) == EOF(-1);
if (stat)
	FATAL("i/o error occurred closing %s", files[i].fname);
if (i > 2)	/* don't do /dev/std... */
	xfree(files[i].fname){ if ((files[i].fname) != ((void *)0)) { free((void *)(intptr_t
)(files[i].fname)); (files[i].fname) = ((void *)0); } };
files[i].fname = NULL((void *)0);	/* watch out for ref thru this */
files[i].fp = NULL((void *)0);
break;
}
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
x = gettemp();
setfval(x, (Awkfloat) (stat ? -1 : 0));
return(x);
}

2022void closeall(void)
2023{
size_t i;
bool_Bool stat = false0;

for (i = 0; i < nfiles; i++) {
if (! files[i].fp)
	continue;
if (ferror(files[i].fp)(!__isthreaded ? (((files[i].fp)->_flags & 0x0040) != 0
) : (ferror)(files[i].fp)))
	FATAL( "i/o error occurred on %s", files[i].fname );
if (files[i].fp == stdin(&__sF[0]))
	continue;
if (files[i].mode == '|' || files[i].mode == LE286)
	stat = pclose(files[i].fp) == -1;
else if (files[i].fp == stdout(&__sF[1]) || files[i].fp == stderr(&__sF[2]))
	stat = fflush(files[i].fp) == EOF(-1);
else
	stat = fclose(files[i].fp) == EOF(-1);
if (stat)
	FATAL( "i/o error occurred while closing %s", files[i].fname );
}
2043}

2045static void flush_all(void)
2046{
size_t i;

for (i = 0; i < nfiles; i++)
if (files[i].fp)
	fflush(files[i].fp);
2052}

2054void backsub(char **pb_ptr, const char **sptr_ptr);

2056Cell *sub(Node **a, int nnn)	/* substitute command */
2057{
const char *sptr, *q;
Cell *x, *y, *result;
char *t, *buf, *pb;
fa *pfa;
int bufsz = recsize;

if ((buf = (char *) malloc(bufsz)) == NULL((void *)0))
FATAL("out of memory in sub");
x = execute(a[3]);	/* target string */
t = getsval(x);
if (a[0] == NULL((void *)0))	/* 0 => a[1] is already-compiled regexpr */
pfa = (fa *) a[1];	/* regular expression */
else {
y = execute(a[1]);
pfa = makedfa(getsval(y), 1);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
}
y = execute(a[2]);	/* replacement string */
result = False;
if (pmatch(pfa, t)) {
sptr = t;
adjbuf(&buf, &bufsz, 1+patbeg-sptr, recsize, 0, "sub");
pb = buf;
while (sptr < patbeg)
	*pb++ = *sptr++;
sptr = getsval(y);
while (*sptr != '\0') {
	adjbuf(&buf, &bufsz, 5+pb-buf, recsize, &pb, "sub");
	if (*sptr == '\\') {
		backsub(&pb, &sptr);
	} else if (*sptr == '&') {
		sptr++;
		adjbuf(&buf, &bufsz, 1+patlen+pb-buf, recsize, &pb, "sub");
		for (q = patbeg; q < patbeg+patlen; )
			*pb++ = *q++;
	} else
		*pb++ = *sptr++;
}
*pb = '\0';
if (pb > buf + bufsz)
	FATAL("sub result1 %.30s too big; can't happen", buf);
sptr = patbeg + patlen;
if ((patlen == 0 && *patbeg) || (patlen && *(sptr-1))) {
	adjbuf(&buf, &bufsz, 1+strlen(sptr)+pb-buf, 0, &pb, "sub");
	while ((*pb++ = *sptr++) != '\0')
		continue;
}
if (pb > buf + bufsz)
	FATAL("sub result2 %.30s too big; can't happen", buf);
setsval(x, buf);	/* BUG: should be able to avoid copy */
result = True;
}
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
free(buf);
return result;
2114}

2116Cell *gsub(Node **a, int nnn)	/* global substitute */
2117{
Cell *x, *y;
char *rptr, *pb;
const char *q, *t, *sptr;
char *buf;
fa *pfa;
int mflag, tempstat, num;
int bufsz = recsize;

if ((buf = (char *) malloc(bufsz)) == NULL((void *)0))
FATAL("out of memory in gsub");
mflag = 0;	/* if mflag == 0, can replace empty string */
num = 0;
x = execute(a[3]);	/* target string */
t = getsval(x);
if (a[0] == NULL((void *)0))	/* 0 => a[1] is already-compiled regexpr */
pfa = (fa *) a[1];	/* regular expression */
else {
y = execute(a[1]);
pfa = makedfa(getsval(y), 1);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
}
y = execute(a[2]);	/* replacement string */
if (pmatch(pfa, t)) {
tempstat = pfa->initstat;
pfa->initstat = 2;
pb = buf;
rptr = getsval(y);
do {
	if (patlen == 0 && *patbeg != '\0') {	/* matched empty string */
		if (mflag == 0) {	/* can replace empty */
			num++;
			sptr = rptr;
			while (*sptr != '\0') {
				adjbuf(&buf, &bufsz, 5+pb-buf, recsize, &pb, "gsub");
				if (*sptr == '\\') {
					backsub(&pb, &sptr);
				} else if (*sptr == '&') {
					sptr++;
					adjbuf(&buf, &bufsz, 1+patlen+pb-buf, recsize, &pb, "gsub");
					for (q = patbeg; q < patbeg+patlen; )
						*pb++ = *q++;
				} else
					*pb++ = *sptr++;
			}
		}
		if (*t == '\0')	/* at end */
			goto done;
		adjbuf(&buf, &bufsz, 2+pb-buf, recsize, &pb, "gsub");
		*pb++ = *t++;
		if (pb > buf + bufsz)	/* BUG: not sure of this test */
			FATAL("gsub result0 %.30s too big; can't happen", buf);
		mflag = 0;
	}
	else {	/* matched nonempty string */
		num++;
		sptr = t;
		adjbuf(&buf, &bufsz, 1+(patbeg-sptr)+pb-buf, recsize, &pb, "gsub");
		while (sptr < patbeg)
			*pb++ = *sptr++;
		sptr = rptr;
		while (*sptr != '\0') {
			adjbuf(&buf, &bufsz, 5+pb-buf, recsize, &pb, "gsub");
			if (*sptr == '\\') {
				backsub(&pb, &sptr);
			} else if (*sptr == '&') {
				sptr++;
				adjbuf(&buf, &bufsz, 1+patlen+pb-buf, recsize, &pb, "gsub");
				for (q = patbeg; q < patbeg+patlen; )
					*pb++ = *q++;
			} else
				*pb++ = *sptr++;
		}
		t = patbeg + patlen;
		if (patlen == 0 || *t == '\0' || *(t-1) == '\0')
			goto done;
		if (pb > buf + bufsz)
			FATAL("gsub result1 %.30s too big; can't happen", buf);
		mflag = 1;
	}
} while (pmatch(pfa,t));
sptr = t;
adjbuf(&buf, &bufsz, 1+strlen(sptr)+pb-buf, 0, &pb, "gsub");
while ((*pb++ = *sptr++) != '\0')
	continue;
done:	if (pb < buf + bufsz)
	*pb = '\0';
else if (*(pb-1) != '\0')
	FATAL("gsub result2 %.30s truncated; can't happen", buf);
setsval(x, buf);	/* BUG: should be able to avoid copy + free */
pfa->initstat = tempstat;
}
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
x = gettemp();
x->tval = NUM01;
x->fval = num;
free(buf);
return(x);
2216}

2218Cell *gensub(Node **a, int nnn)	/* global selective substitute */
/* XXX incomplete - doesn't support backreferences \0 ... \9 */
2220{
Cell *x, *y, *res, *h;
char *rptr;
const char *sptr;
char *buf, *pb;
const char *t, *q;
fa *pfa;
int mflag, tempstat, num, whichm;
int bufsz = recsize;

if ((buf = malloc(bufsz)) == NULL((void *)0))
1
Memory is allocated→
2
←
Assuming the condition is false→
3
←
Taking false branch→
FATAL("out of memory in gensub");
mflag = 0;	/* if mflag == 0, can replace empty string */
num = 0;
x = execute(a[4]);	/* source string */
t = getsval(x);
res = copycell(x);	/* target string - initially copy of source */
res->csub = CTEMP4;	/* result values are temporary */
if (a[0] == 0)		/* 0 => a[1] is already-compiled regexpr */
4
←
Assuming the condition is false→
5
←
Taking false branch→
pfa = (fa *) a[1];	/* regular expression */
else {
y = execute(a[1]);
pfa = makedfa(getsval(y), 1);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
6
←
Assuming field 'csub' is not equal to 4→
7
←
Taking false branch→
8
←
Loop condition is false.  Exiting loop→
}
y = execute(a[2]);	/* replacement string */
h = execute(a[3]);	/* which matches should be replaced */
sptr = getsval(h);
if (sptr[0] == 'g' || sptr[0] == 'G')
9
←
Assuming the condition is false→
10
←
Assuming the condition is false→
11
←
Taking false branch→
whichm = -1;
else {
/*
 * The specified number is index of replacement, starting
 * from 1. GNU awk treats index lower than 0 same as
 * 1, we do same for compatibility.
 */
whichm = (int) getfval(h) - 1;
if (whichm < 0)
12
←
Assuming 'whichm' is >= 0→
13
←
Taking false branch→
	whichm = 0;
}
tempfree(h)do { if (((h)->csub == 4)) tfree(h); } while ( 0);
14
←
Assuming field 'csub' is not equal to 4→
15
←
Taking false branch→
16
←
Loop condition is false.  Exiting loop→

if (pmatch(pfa, t)) {
17
←
Assuming the condition is true→
18
←
Taking true branch→
char *sl;

tempstat = pfa->initstat;
pfa->initstat = 2;
pb = buf;
rptr = getsval(y);
/*
 * XXX if there are any backreferences in subst string,
 * complain now.
 */
for (sl = rptr; (sl = strchr(sl, '\\')) && sl[1]; sl++) {
19
←
Assuming 'sl' is null→
	if (strchr("0123456789", sl[1])) {
		FATAL("gensub doesn't support backreferences (subst \"%s\")", rptr);
	}
}

do {
	if (whichm19.1
'whichm' is >= 0
 >= 0 && whichm != num) {
20
←
Assuming 'whichm' is not equal to 'num'→
21
←
Taking true branch→
		num++;
		adjbuf(&buf, &bufsz, (pb - buf) + (patbeg - t) + patlen, recsize, &pb, "gensub");
22
←
Calling 'adjbuf'→

		/* copy the part of string up to and including
		 * match to output buffer */
		while (t < patbeg + patlen)
			*pb++ = *t++;
		continue;
	}

	if (patlen == 0 && *patbeg != 0) {	/* matched empty string */
		if (mflag == 0) {	/* can replace empty */
			num++;
			sptr = rptr;
			while (*sptr != 0) {
				adjbuf(&buf, &bufsz, 5+pb-buf, recsize, &pb, "gensub");
				if (*sptr == '\\') {
					backsub(&pb, &sptr);
				} else if (*sptr == '&') {
					sptr++;
					adjbuf(&buf, &bufsz, 1+patlen+pb-buf, recsize, &pb, "gensub");
					for (q = patbeg; q < patbeg+patlen; )
						*pb++ = *q++;
				} else
					*pb++ = *sptr++;
			}
		}
		if (*t == 0)	/* at end */
			goto done;
		adjbuf(&buf, &bufsz, 2+pb-buf, recsize, &pb, "gensub");
		*pb++ = *t++;
		if (pb > buf + bufsz)	/* BUG: not sure of this test */
			FATAL("gensub result0 %.30s too big; can't happen", buf);
		mflag = 0;
	}
	else {	/* matched nonempty string */
		num++;
		sptr = t;
		adjbuf(&buf, &bufsz, 1+(patbeg-sptr)+pb-buf, recsize, &pb, "gensub");
		while (sptr < patbeg)
			*pb++ = *sptr++;
		sptr = rptr;
		while (*sptr != 0) {
			adjbuf(&buf, &bufsz, 5+pb-buf, recsize, &pb, "gensub");
			if (*sptr == '\\') {
				backsub(&pb, &sptr);
			} else if (*sptr == '&') {
				sptr++;
				adjbuf(&buf, &bufsz, 1+patlen+pb-buf, recsize, &pb, "gensub");
				for (q = patbeg; q < patbeg+patlen; )
					*pb++ = *q++;
			} else
				*pb++ = *sptr++;
		}
		t = patbeg + patlen;
		if (patlen == 0 || *t == 0 || *(t-1) == 0)
			goto done;
		if (pb > buf + bufsz)
			FATAL("gensub result1 %.30s too big; can't happen", buf);
		mflag = 1;
	}
} while (pmatch(pfa,t));
sptr = t;
adjbuf(&buf, &bufsz, 1+strlen(sptr)+pb-buf, 0, &pb, "gensub");
while ((*pb++ = *sptr++) != 0)
	;
done:	if (pb > buf + bufsz)
	FATAL("gensub result2 %.30s too big; can't happen", buf);
*pb = '\0';
setsval(res, buf);
pfa->initstat = tempstat;
}
tempfree(x)do { if (((x)->csub == 4)) tfree(x); } while ( 0);
tempfree(y)do { if (((y)->csub == 4)) tfree(y); } while ( 0);
free(buf);
return(res);
2357}

2359void backsub(char **pb_ptr, const char **sptr_ptr)	/* handle \\& variations */
2360{						/* sptr[0] == '\\' */
char *pb = *pb_ptr;
const char *sptr = *sptr_ptr;

if (sptr[1] == '\\') {
if (sptr[2] == '\\' && sptr[3] == '&') { /* \\\& -> \& */
	*pb++ = '\\';
	*pb++ = '&';
	sptr += 4;
} else if (sptr[2] == '&') {	/* \\& -> \ + matched */
	*pb++ = '\\';
	sptr += 2;
} else if (do_posix) {		/* \\x -> \x */
	sptr++;
	*pb++ = *sptr++;
} else {			/* \\x -> \\x */
	*pb++ = *sptr++;
	*pb++ = *sptr++;
}
} else if (sptr[1] == '&') {	/* literal & */
sptr++;
*pb++ = *sptr++;
} else				/* literal \ */
*pb++ = *sptr++;

*pb_ptr = pb;
*sptr_ptr = sptr;
2387}