1 /****************************************************************
2 Copyright (C) Lucent Technologies 1997
3 All Rights Reserved
4 
5 Permission to use, copy, modify, and distribute this software and
6 its documentation for any purpose and without fee is hereby
7 granted, provided that the above copyright notice appear in all
8 copies and that both that the copyright notice and this
9 permission notice and warranty disclaimer appear in supporting
10 documentation, and that the name Lucent Technologies or any of
11 its entities not be used in advertising or publicity pertaining
12 to distribution of the software without specific, written prior
13 permission.
14 
15 LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
16 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
17 IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
18 SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
20 IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
21 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
22 THIS SOFTWARE.
23 ****************************************************************/
24 
25 #define DEBUG
26 #include <stdio.h>
27 #include <ctype.h>
28 #include <setjmp.h>
29 #include <limits.h>
30 #include <math.h>
31 #include <string.h>
32 #include <stdlib.h>
33 #include <time.h>
34 #include "awk.h"
35 #include "ytab.h"
36 
37 #define tempfree(x)	if (istemp(x)) tfree(x); else
38 
39 /*
40 #undef tempfree
41 
42 void tempfree(Cell *p) {
43 	if (p->ctype == OCELL && (p->csub < CUNK || p->csub > CFREE)) {
44 		WARNING("bad csub %d in Cell %d %s",
45 			p->csub, p->ctype, p->sval);
46 	}
47 	if (istemp(p))
48 		tfree(p);
49 }
50 */
51 
52 /* do we really need these? */
53 /* #ifdef _NFILE */
54 /* #ifndef FOPEN_MAX */
55 /* #define FOPEN_MAX _NFILE */
56 /* #endif */
57 /* #endif */
58 /*  */
59 /* #ifndef	FOPEN_MAX */
60 /* #define	FOPEN_MAX	40 */	/* max number of open files */
61 /* #endif */
62 /*  */
63 /* #ifndef RAND_MAX */
64 /* #define RAND_MAX	32767 */	/* all that ansi guarantees */
65 /* #endif */
66 
67 jmp_buf env;
68 extern	int	pairstack[];
69 
70 Node	*winner = NULL;	/* root of parse tree */
71 Cell	*tmps;		/* free temporary cells for execution */
72 
73 static Cell	truecell	={ OBOOL, BTRUE, 0, 0, 1.0, NUM };
74 Cell	*True	= &truecell;
75 static Cell	falsecell	={ OBOOL, BFALSE, 0, 0, 0.0, NUM };
76 Cell	*False	= &falsecell;
77 static Cell	breakcell	={ OJUMP, JBREAK, 0, 0, 0.0, NUM };
78 Cell	*jbreak	= &breakcell;
79 static Cell	contcell	={ OJUMP, JCONT, 0, 0, 0.0, NUM };
80 Cell	*jcont	= &contcell;
81 static Cell	nextcell	={ OJUMP, JNEXT, 0, 0, 0.0, NUM };
82 Cell	*jnext	= &nextcell;
83 static Cell	nextfilecell	={ OJUMP, JNEXTFILE, 0, 0, 0.0, NUM };
84 Cell	*jnextfile	= &nextfilecell;
85 static Cell	exitcell	={ OJUMP, JEXIT, 0, 0, 0.0, NUM };
86 Cell	*jexit	= &exitcell;
87 static Cell	retcell		={ OJUMP, JRET, 0, 0, 0.0, NUM };
88 Cell	*jret	= &retcell;
89 static Cell	tempcell	={ OCELL, CTEMP, 0, "", 0.0, NUM|STR|DONTFREE };
90 
91 Node	*curnode = NULL;	/* the node being executed, for debugging */
92 
93 /* buffer memory management */
adjbuf(char ** pbuf,int * psiz,int minlen,int quantum,char ** pbptr,const char * whatrtn)94 int adjbuf(char **pbuf, int *psiz, int minlen, int quantum, char **pbptr,
95 	const char *whatrtn)
96 /* pbuf:    address of pointer to buffer being managed
97  * psiz:    address of buffer size variable
98  * minlen:  minimum length of buffer needed
99  * quantum: buffer size quantum
100  * pbptr:   address of movable pointer into buffer, or 0 if none
101  * whatrtn: name of the calling routine if failure should cause fatal error
102  *
103  * return   0 for realloc failure, !=0 for success
104  */
105 {
106 	if (minlen > *psiz) {
107 		char *tbuf;
108 		int rminlen = quantum ? minlen % quantum : 0;
109 		int boff = pbptr ? *pbptr - *pbuf : 0;
110 		/* round up to next multiple of quantum */
111 		if (rminlen)
112 			minlen += quantum - rminlen;
113 		tbuf = (char *) realloc(*pbuf, minlen);
114 		dprintf( ("adjbuf %s: %d %d (pbuf=%p, tbuf=%p)\n", whatrtn, *psiz, minlen, *pbuf, tbuf) );
115 		if (tbuf == NULL) {
116 			if (whatrtn)
117 				FATAL("out of memory in %s", whatrtn);
118 			return 0;
119 		}
120 		*pbuf = tbuf;
121 		*psiz = minlen;
122 		if (pbptr)
123 			*pbptr = tbuf + boff;
124 	}
125 	return 1;
126 }
127 
run(Node * a)128 void run(Node *a)	/* execution of parse tree starts here */
129 {
130 	extern void stdinit(void);
131 
132 	stdinit();
133 	execute(a);
134 	closeall();
135 }
136 
execute(Node * u)137 Cell *execute(Node *u)	/* execute a node of the parse tree */
138 {
139 	Cell *(*proc)(Node **, int);
140 	Cell *x;
141 	Node *a;
142 
143 	if (u == NULL)
144 		return(True);
145 	for (a = u; ; a = a->nnext) {
146 		curnode = a;
147 		if (isvalue(a)) {
148 			x = (Cell *) (a->narg[0]);
149 			if (isfld(x) && !donefld)
150 				fldbld();
151 			else if (isrec(x) && !donerec)
152 				recbld();
153 			return(x);
154 		}
155 		if (notlegal(a->nobj))	/* probably a Cell* but too risky to print */
156 			FATAL("illegal statement");
157 		proc = proctab[a->nobj-FIRSTTOKEN];
158 		x = (*proc)(a->narg, a->nobj);
159 		if (isfld(x) && !donefld)
160 			fldbld();
161 		else if (isrec(x) && !donerec)
162 			recbld();
163 		if (isexpr(a))
164 			return(x);
165 		if (isjump(x))
166 			return(x);
167 		if (a->nnext == NULL)
168 			return(x);
169 		tempfree(x);
170 	}
171 }
172 
173 
program(Node ** a,int n)174 Cell *program(Node **a, int n)	/* execute an awk program */
175 {				/* a[0] = BEGIN, a[1] = body, a[2] = END */
176 	Cell *x;
177 
178 	if (setjmp(env) != 0)
179 		goto ex;
180 	if (a[0]) {		/* BEGIN */
181 		x = execute(a[0]);
182 		if (isexit(x))
183 			return(True);
184 		if (isjump(x))
185 			FATAL("illegal break, continue, next or nextfile from BEGIN");
186 		tempfree(x);
187 	}
188 	if (a[1] || a[2])
189 		while (getrec(&record, &recsize, 1) > 0) {
190 			x = execute(a[1]);
191 			if (isexit(x))
192 				break;
193 			tempfree(x);
194 		}
195   ex:
196 	if (setjmp(env) != 0)	/* handles exit within END */
197 		goto ex1;
198 	if (a[2]) {		/* END */
199 		x = execute(a[2]);
200 		if (isbreak(x) || isnext(x) || iscont(x))
201 			FATAL("illegal break, continue, next or nextfile from END");
202 		tempfree(x);
203 	}
204   ex1:
205 	return(True);
206 }
207 
208 struct Frame {	/* stack frame for awk function calls */
209 	int nargs;	/* number of arguments in this call */
210 	Cell *fcncell;	/* pointer to Cell for function */
211 	Cell **args;	/* pointer to array of arguments after execute */
212 	Cell *retval;	/* return value */
213 };
214 
215 #define	NARGS	50	/* max args in a call */
216 
217 struct Frame *frame = NULL;	/* base of stack frames; dynamically allocated */
218 int	nframe = 0;		/* number of frames allocated */
219 struct Frame *fp = NULL;	/* frame pointer. bottom level unused */
220 
call(Node ** a,int n)221 Cell *call(Node **a, int n)	/* function call.  very kludgy and fragile */
222 {
223 	static Cell newcopycell = { OCELL, CCOPY, 0, "", 0.0, NUM|STR|DONTFREE };
224 	int i, ncall, ndef;
225 	int freed = 0; /* handles potential double freeing when fcn & param share a tempcell */
226 	Node *x;
227 	Cell *args[NARGS], *oargs[NARGS];	/* BUG: fixed size arrays */
228 	Cell *y, *z, *fcn;
229 	char *s;
230 
231 	fcn = execute(a[0]);	/* the function itself */
232 	s = fcn->nval;
233 	if (!isfcn(fcn))
234 		FATAL("calling undefined function %s", s);
235 	if (frame == NULL) {
236 		fp = frame = (struct Frame *) calloc(nframe += 100, sizeof(struct Frame));
237 		if (frame == NULL)
238 			FATAL("out of space for stack frames calling %s", s);
239 	}
240 	for (ncall = 0, x = a[1]; x != NULL; x = x->nnext)	/* args in call */
241 		ncall++;
242 	ndef = (int) fcn->fval;			/* args in defn */
243 	   dprintf( ("calling %s, %d args (%d in defn), fp=%d\n", s, ncall, ndef, (int) (fp-frame)) );
244 	if (ncall > ndef)
245 		WARNING("function %s called with %d args, uses only %d",
246 			s, ncall, ndef);
247 	if (ncall + ndef > NARGS)
248 		FATAL("function %s has %d arguments, limit %d", s, ncall+ndef, NARGS);
249 	for (i = 0, x = a[1]; x != NULL; i++, x = x->nnext) {	/* get call args */
250 		   dprintf( ("evaluate args[%d], fp=%d:\n", i, (int) (fp-frame)) );
251 		y = execute(x);
252 		oargs[i] = y;
253 		   dprintf( ("args[%d]: %s %f <%s>, t=%o\n",
254 			   i, NN(y->nval), y->fval, isarr(y) ? "(array)" : NN(y->sval), y->tval) );
255 		if (isfcn(y))
256 			FATAL("can't use function %s as argument in %s", y->nval, s);
257 		if (isarr(y))
258 			args[i] = y;	/* arrays by ref */
259 		else
260 			args[i] = copycell(y);
261 		tempfree(y);
262 	}
263 	for ( ; i < ndef; i++) {	/* add null args for ones not provided */
264 		args[i] = gettemp();
265 		*args[i] = newcopycell;
266 	}
267 	fp++;	/* now ok to up frame */
268 	if (fp >= frame + nframe) {
269 		int dfp = fp - frame;	/* old index */
270 		frame = (struct Frame *)
271 			realloc((char *) frame, (nframe += 100) * sizeof(struct Frame));
272 		if (frame == NULL)
273 			FATAL("out of space for stack frames in %s", s);
274 		fp = frame + dfp;
275 	}
276 	fp->fcncell = fcn;
277 	fp->args = args;
278 	fp->nargs = ndef;	/* number defined with (excess are locals) */
279 	fp->retval = gettemp();
280 
281 	   dprintf( ("start exec of %s, fp=%d\n", s, (int) (fp-frame)) );
282 	y = execute((Node *)(fcn->sval));	/* execute body */
283 	   dprintf( ("finished exec of %s, fp=%d\n", s, (int) (fp-frame)) );
284 
285 	for (i = 0; i < ndef; i++) {
286 		Cell *t = fp->args[i];
287 		if (isarr(t)) {
288 			if (t->csub == CCOPY) {
289 				if (i >= ncall) {
290 					freesymtab(t);
291 					t->csub = CTEMP;
292 					tempfree(t);
293 				} else {
294 					oargs[i]->tval = t->tval;
295 					oargs[i]->tval &= ~(STR|NUM|DONTFREE);
296 					oargs[i]->sval = t->sval;
297 					tempfree(t);
298 				}
299 			}
300 		} else if (t != y) {	/* kludge to prevent freeing twice */
301 			t->csub = CTEMP;
302 			tempfree(t);
303 		} else if (t == y && t->csub == CCOPY) {
304 			t->csub = CTEMP;
305 			tempfree(t);
306 			freed = 1;
307 		}
308 	}
309 	tempfree(fcn);
310 	if (isexit(y) || isnext(y))
311 		return y;
312 	if (freed == 0) {
313 		tempfree(y);	/* don't free twice! */
314 	}
315 	z = fp->retval;			/* return value */
316 	   dprintf( ("%s returns %g |%s| %o\n", s, getfval(z), getsval(z), z->tval) );
317 	fp--;
318 	return(z);
319 }
320 
copycell(Cell * x)321 Cell *copycell(Cell *x)	/* make a copy of a cell in a temp */
322 {
323 	Cell *y;
324 
325 	y = gettemp();
326 	y->csub = CCOPY;	/* prevents freeing until call is over */
327 	y->nval = x->nval;	/* BUG? */
328 	if (isstr(x))
329 		y->sval = tostring(x->sval);
330 	y->fval = x->fval;
331 	y->tval = x->tval & ~(CON|FLD|REC|DONTFREE);	/* copy is not constant or field */
332 							/* is DONTFREE right? */
333 	return y;
334 }
335 
arg(Node ** a,int n)336 Cell *arg(Node **a, int n)	/* nth argument of a function */
337 {
338 
339 	n = ptoi(a[0]);	/* argument number, counting from 0 */
340 	   dprintf( ("arg(%d), fp->nargs=%d\n", n, fp->nargs) );
341 	if (n+1 > fp->nargs)
342 		FATAL("argument #%d of function %s was not supplied",
343 			n+1, fp->fcncell->nval);
344 	return fp->args[n];
345 }
346 
jump(Node ** a,int n)347 Cell *jump(Node **a, int n)	/* break, continue, next, nextfile, return */
348 {
349 	Cell *y;
350 
351 	switch (n) {
352 	case EXIT:
353 		if (a[0] != NULL) {
354 			y = execute(a[0]);
355 			errorflag = (int) getfval(y);
356 			tempfree(y);
357 		}
358 		longjmp(env, 1);
359 	case RETURN:
360 		if (a[0] != NULL) {
361 			y = execute(a[0]);
362 			if ((y->tval & (STR|NUM)) == (STR|NUM)) {
363 				setsval(fp->retval, getsval(y));
364 				fp->retval->fval = getfval(y);
365 				fp->retval->tval |= NUM;
366 			}
367 			else if (y->tval & STR)
368 				setsval(fp->retval, getsval(y));
369 			else if (y->tval & NUM)
370 				setfval(fp->retval, getfval(y));
371 			else		/* can't happen */
372 				FATAL("bad type variable %d", y->tval);
373 			tempfree(y);
374 		}
375 		return(jret);
376 	case NEXT:
377 		return(jnext);
378 	case NEXTFILE:
379 		nextfile();
380 		return(jnextfile);
381 	case BREAK:
382 		return(jbreak);
383 	case CONTINUE:
384 		return(jcont);
385 	default:	/* can't happen */
386 		FATAL("illegal jump type %d", n);
387 	}
388 	return 0;	/* not reached */
389 }
390 
getline(Node ** a,int n)391 Cell *getline(Node **a, int n)	/* get next line from specific input */
392 {		/* a[0] is variable, a[1] is operator, a[2] is filename */
393 	Cell *r, *x;
394 	extern Cell **fldtab;
395 	FILE *fp;
396 	char *buf;
397 	int bufsize = recsize;
398 	int mode;
399 
400 	if ((buf = (char *) malloc(bufsize)) == NULL)
401 		FATAL("out of memory in getline");
402 
403 	fflush(stdout);	/* in case someone is waiting for a prompt */
404 	r = gettemp();
405 	if (a[1] != NULL) {		/* getline < file */
406 		x = execute(a[2]);		/* filename */
407 		mode = ptoi(a[1]);
408 		if (mode == '|')		/* input pipe */
409 			mode = LE;	/* arbitrary flag */
410 		fp = openfile(mode, getsval(x));
411 		tempfree(x);
412 		if (fp == NULL)
413 			n = -1;
414 		else
415 			n = readrec(&buf, &bufsize, fp);
416 		if (n <= 0) {
417 			;
418 		} else if (a[0] != NULL) {	/* getline var <file */
419 			x = execute(a[0]);
420 			setsval(x, buf);
421 			tempfree(x);
422 		} else {			/* getline <file */
423 			setsval(fldtab[0], buf);
424 			if (is_number(fldtab[0]->sval)) {
425 				fldtab[0]->fval = atof(fldtab[0]->sval);
426 				fldtab[0]->tval |= NUM;
427 			}
428 		}
429 	} else {			/* bare getline; use current input */
430 		if (a[0] == NULL)	/* getline */
431 			n = getrec(&record, &recsize, 1);
432 		else {			/* getline var */
433 			n = getrec(&buf, &bufsize, 0);
434 			x = execute(a[0]);
435 			setsval(x, buf);
436 			tempfree(x);
437 		}
438 	}
439 	setfval(r, (Awkfloat) n);
440 	free(buf);
441 	return r;
442 }
443 
getnf(Node ** a,int n)444 Cell *getnf(Node **a, int n)	/* get NF */
445 {
446 	if (donefld == 0)
447 		fldbld();
448 	return (Cell *) a[0];
449 }
450 
array(Node ** a,int n)451 Cell *array(Node **a, int n)	/* a[0] is symtab, a[1] is list of subscripts */
452 {
453 	Cell *x, *y, *z;
454 	char *s;
455 	Node *np;
456 	char *buf;
457 	int bufsz = recsize;
458 	int nsub = strlen(*SUBSEP);
459 
460 	if ((buf = (char *) malloc(bufsz)) == NULL)
461 		FATAL("out of memory in array");
462 
463 	x = execute(a[0]);	/* Cell* for symbol table */
464 	buf[0] = 0;
465 	for (np = a[1]; np; np = np->nnext) {
466 		y = execute(np);	/* subscript */
467 		s = getsval(y);
468 		if (!adjbuf(&buf, &bufsz, strlen(buf)+strlen(s)+nsub+1, recsize, 0, "array"))
469 			FATAL("out of memory for %s[%s...]", x->nval, buf);
470 		strcat(buf, s);
471 		if (np->nnext)
472 			strcat(buf, *SUBSEP);
473 		tempfree(y);
474 	}
475 	if (!isarr(x)) {
476 		   dprintf( ("making %s into an array\n", NN(x->nval)) );
477 		if (freeable(x))
478 			xfree(x->sval);
479 		x->tval &= ~(STR|NUM|DONTFREE);
480 		x->tval |= ARR;
481 		x->sval = (char *) makesymtab(NSYMTAB);
482 	}
483 	z = setsymtab(buf, "", 0.0, STR|NUM, (Array *) x->sval);
484 	z->ctype = OCELL;
485 	z->csub = CVAR;
486 	tempfree(x);
487 	free(buf);
488 	return(z);
489 }
490 
awkdelete(Node ** a,int n)491 Cell *awkdelete(Node **a, int n)	/* a[0] is symtab, a[1] is list of subscripts */
492 {
493 	Cell *x, *y;
494 	Node *np;
495 	char *s;
496 	int nsub = strlen(*SUBSEP);
497 
498 	x = execute(a[0]);	/* Cell* for symbol table */
499 	if (!isarr(x))
500 		return True;
501 	if (a[1] == 0) {	/* delete the elements, not the table */
502 		freesymtab(x);
503 		x->tval &= ~STR;
504 		x->tval |= ARR;
505 		x->sval = (char *) makesymtab(NSYMTAB);
506 	} else {
507 		int bufsz = recsize;
508 		char *buf;
509 		if ((buf = (char *) malloc(bufsz)) == NULL)
510 			FATAL("out of memory in adelete");
511 		buf[0] = 0;
512 		for (np = a[1]; np; np = np->nnext) {
513 			y = execute(np);	/* subscript */
514 			s = getsval(y);
515 			if (!adjbuf(&buf, &bufsz, strlen(buf)+strlen(s)+nsub+1, recsize, 0, "awkdelete"))
516 				FATAL("out of memory deleting %s[%s...]", x->nval, buf);
517 			strcat(buf, s);
518 			if (np->nnext)
519 				strcat(buf, *SUBSEP);
520 			tempfree(y);
521 		}
522 		freeelem(x, buf);
523 		free(buf);
524 	}
525 	tempfree(x);
526 	return True;
527 }
528 
intest(Node ** a,int n)529 Cell *intest(Node **a, int n)	/* a[0] is index (list), a[1] is symtab */
530 {
531 	Cell *x, *ap, *k;
532 	Node *p;
533 	char *buf;
534 	char *s;
535 	int bufsz = recsize;
536 	int nsub = strlen(*SUBSEP);
537 
538 	ap = execute(a[1]);	/* array name */
539 	if (!isarr(ap)) {
540 		   dprintf( ("making %s into an array\n", ap->nval) );
541 		if (freeable(ap))
542 			xfree(ap->sval);
543 		ap->tval &= ~(STR|NUM|DONTFREE);
544 		ap->tval |= ARR;
545 		ap->sval = (char *) makesymtab(NSYMTAB);
546 	}
547 	if ((buf = (char *) malloc(bufsz)) == NULL) {
548 		FATAL("out of memory in intest");
549 	}
550 	buf[0] = 0;
551 	for (p = a[0]; p; p = p->nnext) {
552 		x = execute(p);	/* expr */
553 		s = getsval(x);
554 		if (!adjbuf(&buf, &bufsz, strlen(buf)+strlen(s)+nsub+1, recsize, 0, "intest"))
555 			FATAL("out of memory deleting %s[%s...]", x->nval, buf);
556 		strcat(buf, s);
557 		tempfree(x);
558 		if (p->nnext)
559 			strcat(buf, *SUBSEP);
560 	}
561 	k = lookup(buf, (Array *) ap->sval);
562 	tempfree(ap);
563 	free(buf);
564 	if (k == NULL)
565 		return(False);
566 	else
567 		return(True);
568 }
569 
570 
matchop(Node ** a,int n)571 Cell *matchop(Node **a, int n)	/* ~ and match() */
572 {
573 	Cell *x, *y;
574 	char *s, *t;
575 	int i;
576 	fa *pfa;
577 	int (*mf)(fa *, const char *) = match, mode = 0;
578 
579 	if (n == MATCHFCN) {
580 		mf = pmatch;
581 		mode = 1;
582 	}
583 	x = execute(a[1]);	/* a[1] = target text */
584 	s = getsval(x);
585 	if (a[0] == 0)		/* a[1] == 0: already-compiled reg expr */
586 		i = (*mf)((fa *) a[2], s);
587 	else {
588 		y = execute(a[2]);	/* a[2] = regular expr */
589 		t = getsval(y);
590 		pfa = makedfa(t, mode);
591 		i = (*mf)(pfa, s);
592 		tempfree(y);
593 	}
594 	tempfree(x);
595 	if (n == MATCHFCN) {
596 		int start = patbeg - s + 1;
597 		if (patlen < 0)
598 			start = 0;
599 		setfval(rstartloc, (Awkfloat) start);
600 		setfval(rlengthloc, (Awkfloat) patlen);
601 		x = gettemp();
602 		x->tval = NUM;
603 		x->fval = start;
604 		return x;
605 	} else if ((n == MATCH && i == 1) || (n == NOTMATCH && i == 0))
606 		return(True);
607 	else
608 		return(False);
609 }
610 
611 
boolop(Node ** a,int n)612 Cell *boolop(Node **a, int n)	/* a[0] || a[1], a[0] && a[1], !a[0] */
613 {
614 	Cell *x, *y;
615 	int i;
616 
617 	x = execute(a[0]);
618 	i = istrue(x);
619 	tempfree(x);
620 	switch (n) {
621 	case BOR:
622 		if (i) return(True);
623 		y = execute(a[1]);
624 		i = istrue(y);
625 		tempfree(y);
626 		if (i) return(True);
627 		else return(False);
628 	case AND:
629 		if ( !i ) return(False);
630 		y = execute(a[1]);
631 		i = istrue(y);
632 		tempfree(y);
633 		if (i) return(True);
634 		else return(False);
635 	case NOT:
636 		if (i) return(False);
637 		else return(True);
638 	default:	/* can't happen */
639 		FATAL("unknown boolean operator %d", n);
640 	}
641 	return 0;	/*NOTREACHED*/
642 }
643 
relop(Node ** a,int n)644 Cell *relop(Node **a, int n)	/* a[0 < a[1], etc. */
645 {
646 	int i;
647 	Cell *x, *y;
648 	Awkfloat j;
649 
650 	x = execute(a[0]);
651 	y = execute(a[1]);
652 	if (x->tval&NUM && y->tval&NUM) {
653 		j = x->fval - y->fval;
654 		i = j<0? -1: (j>0? 1: 0);
655 	} else {
656 		i = strcmp(getsval(x), getsval(y));
657 	}
658 	tempfree(x);
659 	tempfree(y);
660 	switch (n) {
661 	case LT:	if (i<0) return(True);
662 			else return(False);
663 	case LE:	if (i<=0) return(True);
664 			else return(False);
665 	case NE:	if (i!=0) return(True);
666 			else return(False);
667 	case EQ:	if (i == 0) return(True);
668 			else return(False);
669 	case GE:	if (i>=0) return(True);
670 			else return(False);
671 	case GT:	if (i>0) return(True);
672 			else return(False);
673 	default:	/* can't happen */
674 		FATAL("unknown relational operator %d", n);
675 	}
676 	return 0;	/*NOTREACHED*/
677 }
678 
tfree(Cell * a)679 void tfree(Cell *a)	/* free a tempcell */
680 {
681 	if (freeable(a)) {
682 		   dprintf( ("freeing %s %s %o\n", NN(a->nval), NN(a->sval), a->tval) );
683 		xfree(a->sval);
684 	}
685 	if (a == tmps)
686 		FATAL("tempcell list is curdled");
687 	a->cnext = tmps;
688 	tmps = a;
689 }
690 
gettemp(void)691 Cell *gettemp(void)	/* get a tempcell */
692 {	int i;
693 	Cell *x;
694 
695 	if (!tmps) {
696 		tmps = (Cell *) calloc(100, sizeof(Cell));
697 		if (!tmps)
698 			FATAL("out of space for temporaries");
699 		for(i = 1; i < 100; i++)
700 			tmps[i-1].cnext = &tmps[i];
701 		tmps[i-1].cnext = 0;
702 	}
703 	x = tmps;
704 	tmps = x->cnext;
705 	*x = tempcell;
706 	return(x);
707 }
708 
indirect(Node ** a,int n)709 Cell *indirect(Node **a, int n)	/* $( a[0] ) */
710 {
711 	Awkfloat val;
712 	Cell *x;
713 	int m;
714 	char *s;
715 
716 	x = execute(a[0]);
717 	val = getfval(x);	/* freebsd: defend against super large field numbers */
718 	if ((Awkfloat)INT_MAX < val)
719 		FATAL("trying to access out of range field %s", x->nval);
720 	m = (int) val;
721 	if (m == 0 && !is_number(s = getsval(x)))	/* suspicion! */
722 		FATAL("illegal field $(%s), name \"%s\"", s, x->nval);
723 		/* BUG: can x->nval ever be null??? */
724 	tempfree(x);
725 	x = fieldadr(m);
726 	x->ctype = OCELL;	/* BUG?  why are these needed? */
727 	x->csub = CFLD;
728 	return(x);
729 }
730 
substr(Node ** a,int nnn)731 Cell *substr(Node **a, int nnn)		/* substr(a[0], a[1], a[2]) */
732 {
733 	int k, m, n;
734 	char *s;
735 	int temp;
736 	Cell *x, *y, *z = 0;
737 
738 	x = execute(a[0]);
739 	y = execute(a[1]);
740 	if (a[2] != 0)
741 		z = execute(a[2]);
742 	s = getsval(x);
743 	k = strlen(s) + 1;
744 	if (k <= 1) {
745 		tempfree(x);
746 		tempfree(y);
747 		if (a[2] != 0) {
748 			tempfree(z);
749 		}
750 		x = gettemp();
751 		setsval(x, "");
752 		return(x);
753 	}
754 	m = (int) getfval(y);
755 	if (m <= 0)
756 		m = 1;
757 	else if (m > k)
758 		m = k;
759 	tempfree(y);
760 	if (a[2] != 0) {
761 		n = (int) getfval(z);
762 		tempfree(z);
763 	} else
764 		n = k - 1;
765 	if (n < 0)
766 		n = 0;
767 	else if (n > k - m)
768 		n = k - m;
769 	   dprintf( ("substr: m=%d, n=%d, s=%s\n", m, n, s) );
770 	y = gettemp();
771 	temp = s[n+m-1];	/* with thanks to John Linderman */
772 	s[n+m-1] = '\0';
773 	setsval(y, s + m - 1);
774 	s[n+m-1] = temp;
775 	tempfree(x);
776 	return(y);
777 }
778 
sindex(Node ** a,int nnn)779 Cell *sindex(Node **a, int nnn)		/* index(a[0], a[1]) */
780 {
781 	Cell *x, *y, *z;
782 	char *s1, *s2, *p1, *p2, *q;
783 	Awkfloat v = 0.0;
784 
785 	x = execute(a[0]);
786 	s1 = getsval(x);
787 	y = execute(a[1]);
788 	s2 = getsval(y);
789 
790 	z = gettemp();
791 	for (p1 = s1; *p1 != '\0'; p1++) {
792 		for (q=p1, p2=s2; *p2 != '\0' && *q == *p2; q++, p2++)
793 			;
794 		if (*p2 == '\0') {
795 			v = (Awkfloat) (p1 - s1 + 1);	/* origin 1 */
796 			break;
797 		}
798 	}
799 	tempfree(x);
800 	tempfree(y);
801 	setfval(z, v);
802 	return(z);
803 }
804 
805 #define	MAXNUMSIZE	50
806 
format(char ** pbuf,int * pbufsize,const char * s,Node * a)807 int format(char **pbuf, int *pbufsize, const char *s, Node *a)	/* printf-like conversions */
808 {
809 	char *fmt;
810 	char *p, *t;
811 	const char *os;
812 	Cell *x;
813 	int flag = 0, n;
814 	int fmtwd; /* format width */
815 	int fmtsz = recsize;
816 	char *buf = *pbuf;
817 	int bufsize = *pbufsize;
818 
819 	os = s;
820 	p = buf;
821 	if ((fmt = (char *) malloc(fmtsz)) == NULL)
822 		FATAL("out of memory in format()");
823 	while (*s) {
824 		adjbuf(&buf, &bufsize, MAXNUMSIZE+1+p-buf, recsize, &p, "format1");
825 		if (*s != '%') {
826 			*p++ = *s++;
827 			continue;
828 		}
829 		if (*(s+1) == '%') {
830 			*p++ = '%';
831 			s += 2;
832 			continue;
833 		}
834 		/* have to be real careful in case this is a huge number, eg, %100000d */
835 		fmtwd = atoi(s+1);
836 		if (fmtwd < 0)
837 			fmtwd = -fmtwd;
838 		adjbuf(&buf, &bufsize, fmtwd+1+p-buf, recsize, &p, "format2");
839 		for (t = fmt; (*t++ = *s) != '\0'; s++) {
840 			if (!adjbuf(&fmt, &fmtsz, MAXNUMSIZE+1+t-fmt, recsize, &t, "format3"))
841 				FATAL("format item %.30s... ran format() out of memory", os);
842 			if (isalpha((uschar)*s) && *s != 'l' && *s != 'h' && *s != 'L')
843 				break;	/* the ansi panoply */
844 			if (*s == '*') {
845 				x = execute(a);
846 				a = a->nnext;
847 				sprintf(t-1, "%d", fmtwd=(int) getfval(x));
848 				if (fmtwd < 0)
849 					fmtwd = -fmtwd;
850 				adjbuf(&buf, &bufsize, fmtwd+1+p-buf, recsize, &p, "format");
851 				t = fmt + strlen(fmt);
852 				tempfree(x);
853 			}
854 		}
855 		*t = '\0';
856 		if (fmtwd < 0)
857 			fmtwd = -fmtwd;
858 		adjbuf(&buf, &bufsize, fmtwd+1+p-buf, recsize, &p, "format4");
859 
860 		switch (*s) {
861 		case 'f': case 'e': case 'g': case 'E': case 'G':
862 			flag = 'f';
863 			break;
864 		case 'd': case 'i':
865 			flag = 'd';
866 			if(*(s-1) == 'l') break;
867 			*(t-1) = 'l';
868 			*t = 'd';
869 			*++t = '\0';
870 			break;
871 		case 'o': case 'x': case 'X': case 'u':
872 			flag = *(s-1) == 'l' ? 'd' : 'u';
873 			break;
874 		case 's':
875 			flag = 's';
876 			break;
877 		case 'c':
878 			flag = 'c';
879 			break;
880 		default:
881 			WARNING("weird printf conversion %s", fmt);
882 			flag = '?';
883 			break;
884 		}
885 		if (a == NULL)
886 			FATAL("not enough args in printf(%s)", os);
887 		x = execute(a);
888 		a = a->nnext;
889 		n = MAXNUMSIZE;
890 		if (fmtwd > n)
891 			n = fmtwd;
892 		adjbuf(&buf, &bufsize, 1+n+p-buf, recsize, &p, "format5");
893 		switch (flag) {
894 		case '?':	sprintf(p, "%s", fmt);	/* unknown, so dump it too */
895 			t = getsval(x);
896 			n = strlen(t);
897 			if (fmtwd > n)
898 				n = fmtwd;
899 			adjbuf(&buf, &bufsize, 1+strlen(p)+n+p-buf, recsize, &p, "format6");
900 			p += strlen(p);
901 			sprintf(p, "%s", t);
902 			break;
903 		case 'f':	sprintf(p, fmt, getfval(x)); break;
904 		case 'd':	sprintf(p, fmt, (long) getfval(x)); break;
905 		case 'u':	sprintf(p, fmt, (int) getfval(x)); break;
906 		case 's':
907 			t = getsval(x);
908 			n = strlen(t);
909 			if (fmtwd > n)
910 				n = fmtwd;
911 			if (!adjbuf(&buf, &bufsize, 1+n+p-buf, recsize, &p, "format7"))
912 				FATAL("huge string/format (%d chars) in printf %.30s... ran format() out of memory", n, t);
913 			sprintf(p, fmt, t);
914 			break;
915 		case 'c':
916 			if (isnum(x)) {
917 				if (getfval(x))
918 					sprintf(p, fmt, (int) getfval(x));
919 				else {
920 					*p++ = '\0'; /* explicit null byte */
921 					*p = '\0';   /* next output will start here */
922 				}
923 			} else
924 				sprintf(p, fmt, getsval(x)[0]);
925 			break;
926 		default:
927 			FATAL("can't happen: bad conversion %c in format()", flag);
928 		}
929 		tempfree(x);
930 		p += strlen(p);
931 		s++;
932 	}
933 	*p = '\0';
934 	free(fmt);
935 	for ( ; a; a = a->nnext)		/* evaluate any remaining args */
936 		execute(a);
937 	*pbuf = buf;
938 	*pbufsize = bufsize;
939 	return p - buf;
940 }
941 
awksprintf(Node ** a,int n)942 Cell *awksprintf(Node **a, int n)		/* sprintf(a[0]) */
943 {
944 	Cell *x;
945 	Node *y;
946 	char *buf;
947 	int bufsz=3*recsize;
948 
949 	if ((buf = (char *) malloc(bufsz)) == NULL)
950 		FATAL("out of memory in awksprintf");
951 	y = a[0]->nnext;
952 	x = execute(a[0]);
953 	if (format(&buf, &bufsz, getsval(x), y) == -1)
954 		FATAL("sprintf string %.30s... too long.  can't happen.", buf);
955 	tempfree(x);
956 	x = gettemp();
957 	x->sval = buf;
958 	x->tval = STR;
959 	return(x);
960 }
961 
awkprintf(Node ** a,int n)962 Cell *awkprintf(Node **a, int n)		/* printf */
963 {	/* a[0] is list of args, starting with format string */
964 	/* a[1] is redirection operator, a[2] is redirection file */
965 	FILE *fp;
966 	Cell *x;
967 	Node *y;
968 	char *buf;
969 	int len;
970 	int bufsz=3*recsize;
971 
972 	if ((buf = (char *) malloc(bufsz)) == NULL)
973 		FATAL("out of memory in awkprintf");
974 	y = a[0]->nnext;
975 	x = execute(a[0]);
976 	if ((len = format(&buf, &bufsz, getsval(x), y)) == -1)
977 		FATAL("printf string %.30s... too long.  can't happen.", buf);
978 	tempfree(x);
979 	if (a[1] == NULL) {
980 		/* fputs(buf, stdout); */
981 		fwrite(buf, len, 1, stdout);
982 		if (ferror(stdout))
983 			FATAL("write error on stdout");
984 	} else {
985 		fp = redirect(ptoi(a[1]), a[2]);
986 		/* fputs(buf, fp); */
987 		fwrite(buf, len, 1, fp);
988 		fflush(fp);
989 		if (ferror(fp))
990 			FATAL("write error on %s", filename(fp));
991 	}
992 	free(buf);
993 	return(True);
994 }
995 
arith(Node ** a,int n)996 Cell *arith(Node **a, int n)	/* a[0] + a[1], etc.  also -a[0] */
997 {
998 	Awkfloat i, j = 0;
999 	double v;
1000 	Cell *x, *y, *z;
1001 
1002 	x = execute(a[0]);
1003 	i = getfval(x);
1004 	tempfree(x);
1005 	if (n != UMINUS) {
1006 		y = execute(a[1]);
1007 		j = getfval(y);
1008 		tempfree(y);
1009 	}
1010 	z = gettemp();
1011 	switch (n) {
1012 	case ADD:
1013 		i += j;
1014 		break;
1015 	case MINUS:
1016 		i -= j;
1017 		break;
1018 	case MULT:
1019 		i *= j;
1020 		break;
1021 	case DIVIDE:
1022 		if (j == 0)
1023 			FATAL("division by zero");
1024 		i /= j;
1025 		break;
1026 	case MOD:
1027 		if (j == 0)
1028 			FATAL("division by zero in mod");
1029 		modf(i/j, &v);
1030 		i = i - j * v;
1031 		break;
1032 	case UMINUS:
1033 		i = -i;
1034 		break;
1035 	case POWER:
1036 		if (j >= 0 && modf(j, &v) == 0.0)	/* pos integer exponent */
1037 			i = ipow(i, (int) j);
1038 		else
1039 			i = errcheck(pow(i, j), "pow");
1040 		break;
1041 	default:	/* can't happen */
1042 		FATAL("illegal arithmetic operator %d", n);
1043 	}
1044 	setfval(z, i);
1045 	return(z);
1046 }
1047 
ipow(double x,int n)1048 double ipow(double x, int n)	/* x**n.  ought to be done by pow, but isn't always */
1049 {
1050 	double v;
1051 
1052 	if (n <= 0)
1053 		return 1;
1054 	v = ipow(x, n/2);
1055 	if (n % 2 == 0)
1056 		return v * v;
1057 	else
1058 		return x * v * v;
1059 }
1060 
incrdecr(Node ** a,int n)1061 Cell *incrdecr(Node **a, int n)		/* a[0]++, etc. */
1062 {
1063 	Cell *x, *z;
1064 	int k;
1065 	Awkfloat xf;
1066 
1067 	x = execute(a[0]);
1068 	xf = getfval(x);
1069 	k = (n == PREINCR || n == POSTINCR) ? 1 : -1;
1070 	if (n == PREINCR || n == PREDECR) {
1071 		setfval(x, xf + k);
1072 		return(x);
1073 	}
1074 	z = gettemp();
1075 	setfval(z, xf);
1076 	setfval(x, xf + k);
1077 	tempfree(x);
1078 	return(z);
1079 }
1080 
assign(Node ** a,int n)1081 Cell *assign(Node **a, int n)	/* a[0] = a[1], a[0] += a[1], etc. */
1082 {		/* this is subtle; don't muck with it. */
1083 	Cell *x, *y;
1084 	Awkfloat xf, yf;
1085 	double v;
1086 
1087 	y = execute(a[1]);
1088 	x = execute(a[0]);
1089 	if (n == ASSIGN) {	/* ordinary assignment */
1090 		if (x == y && !(x->tval & (FLD|REC)))	/* self-assignment: */
1091 			;		/* leave alone unless it's a field */
1092 		else if ((y->tval & (STR|NUM)) == (STR|NUM)) {
1093 			setsval(x, getsval(y));
1094 			x->fval = getfval(y);
1095 			x->tval |= NUM;
1096 		}
1097 		else if (isstr(y))
1098 			setsval(x, getsval(y));
1099 		else if (isnum(y))
1100 			setfval(x, getfval(y));
1101 		else
1102 			funnyvar(y, "read value of");
1103 		tempfree(y);
1104 		return(x);
1105 	}
1106 	xf = getfval(x);
1107 	yf = getfval(y);
1108 	switch (n) {
1109 	case ADDEQ:
1110 		xf += yf;
1111 		break;
1112 	case SUBEQ:
1113 		xf -= yf;
1114 		break;
1115 	case MULTEQ:
1116 		xf *= yf;
1117 		break;
1118 	case DIVEQ:
1119 		if (yf == 0)
1120 			FATAL("division by zero in /=");
1121 		xf /= yf;
1122 		break;
1123 	case MODEQ:
1124 		if (yf == 0)
1125 			FATAL("division by zero in %%=");
1126 		modf(xf/yf, &v);
1127 		xf = xf - yf * v;
1128 		break;
1129 	case POWEQ:
1130 		if (yf >= 0 && modf(yf, &v) == 0.0)	/* pos integer exponent */
1131 			xf = ipow(xf, (int) yf);
1132 		else
1133 			xf = errcheck(pow(xf, yf), "pow");
1134 		break;
1135 	default:
1136 		FATAL("illegal assignment operator %d", n);
1137 		break;
1138 	}
1139 	tempfree(y);
1140 	setfval(x, xf);
1141 	return(x);
1142 }
1143 
cat(Node ** a,int q)1144 Cell *cat(Node **a, int q)	/* a[0] cat a[1] */
1145 {
1146 	Cell *x, *y, *z;
1147 	int n1, n2;
1148 	char *s;
1149 
1150 	x = execute(a[0]);
1151 	y = execute(a[1]);
1152 	getsval(x);
1153 	getsval(y);
1154 	n1 = strlen(x->sval);
1155 	n2 = strlen(y->sval);
1156 	s = (char *) malloc(n1 + n2 + 1);
1157 	if (s == NULL)
1158 		FATAL("out of space concatenating %.15s... and %.15s...",
1159 			x->sval, y->sval);
1160 	strcpy(s, x->sval);
1161 	strcpy(s+n1, y->sval);
1162 	tempfree(y);
1163 	z = gettemp();
1164 	z->sval = s;
1165 	z->tval = STR;
1166 	tempfree(x);
1167 	return(z);
1168 }
1169 
pastat(Node ** a,int n)1170 Cell *pastat(Node **a, int n)	/* a[0] { a[1] } */
1171 {
1172 	Cell *x;
1173 
1174 	if (a[0] == 0)
1175 		x = execute(a[1]);
1176 	else {
1177 		x = execute(a[0]);
1178 		if (istrue(x)) {
1179 			tempfree(x);
1180 			x = execute(a[1]);
1181 		}
1182 	}
1183 	return x;
1184 }
1185 
dopa2(Node ** a,int n)1186 Cell *dopa2(Node **a, int n)	/* a[0], a[1] { a[2] } */
1187 {
1188 	Cell *x;
1189 	int pair;
1190 
1191 	pair = ptoi(a[3]);
1192 	if (pairstack[pair] == 0) {
1193 		x = execute(a[0]);
1194 		if (istrue(x))
1195 			pairstack[pair] = 1;
1196 		tempfree(x);
1197 	}
1198 	if (pairstack[pair] == 1) {
1199 		x = execute(a[1]);
1200 		if (istrue(x))
1201 			pairstack[pair] = 0;
1202 		tempfree(x);
1203 		x = execute(a[2]);
1204 		return(x);
1205 	}
1206 	return(False);
1207 }
1208 
split(Node ** a,int nnn)1209 Cell *split(Node **a, int nnn)	/* split(a[0], a[1], a[2]); a[3] is type */
1210 {
1211 	Cell *x = 0, *y, *ap;
1212 	char *s;
1213 	int sep;
1214 	char *t, temp, num[50], *fs = 0;
1215 	int n, tempstat, arg3type;
1216 
1217 	y = execute(a[0]);	/* source string */
1218 	s = getsval(y);
1219 	arg3type = ptoi(a[3]);
1220 	if (a[2] == 0)		/* fs string */
1221 		fs = *FS;
1222 	else if (arg3type == STRING) {	/* split(str,arr,"string") */
1223 		x = execute(a[2]);
1224 		fs = getsval(x);
1225 	} else if (arg3type == REGEXPR)
1226 		fs = "(regexpr)";	/* split(str,arr,/regexpr/) */
1227 	else
1228 		FATAL("illegal type of split");
1229 	sep = *fs;
1230 	ap = execute(a[1]);	/* array name */
1231 	freesymtab(ap);
1232 	   dprintf( ("split: s=|%s|, a=%s, sep=|%s|\n", s, NN(ap->nval), fs) );
1233 	ap->tval &= ~STR;
1234 	ap->tval |= ARR;
1235 	ap->sval = (char *) makesymtab(NSYMTAB);
1236 
1237 	n = 0;
1238 	if (*s != '\0' && (strlen(fs) > 1 || arg3type == REGEXPR)) {	/* reg expr */
1239 		fa *pfa;
1240 		if (arg3type == REGEXPR) {	/* it's ready already */
1241 			pfa = (fa *) a[2];
1242 		} else {
1243 			pfa = makedfa(fs, 1);
1244 		}
1245 		if (nematch(pfa,s)) {
1246 			tempstat = pfa->initstat;
1247 			pfa->initstat = 2;
1248 			do {
1249 				n++;
1250 				sprintf(num, "%d", n);
1251 				temp = *patbeg;
1252 				*patbeg = '\0';
1253 				if (is_number(s))
1254 					setsymtab(num, s, atof(s), STR|NUM, (Array *) ap->sval);
1255 				else
1256 					setsymtab(num, s, 0.0, STR, (Array *) ap->sval);
1257 				*patbeg = temp;
1258 				s = patbeg + patlen;
1259 				if (*(patbeg+patlen-1) == 0 || *s == 0) {
1260 					n++;
1261 					sprintf(num, "%d", n);
1262 					setsymtab(num, "", 0.0, STR, (Array *) ap->sval);
1263 					pfa->initstat = tempstat;
1264 					goto spdone;
1265 				}
1266 			} while (nematch(pfa,s));
1267 			pfa->initstat = tempstat; 	/* bwk: has to be here to reset */
1268 							/* cf gsub and refldbld */
1269 		}
1270 		n++;
1271 		sprintf(num, "%d", n);
1272 		if (is_number(s))
1273 			setsymtab(num, s, atof(s), STR|NUM, (Array *) ap->sval);
1274 		else
1275 			setsymtab(num, s, 0.0, STR, (Array *) ap->sval);
1276   spdone:
1277 		pfa = NULL;
1278 	} else if (sep == ' ') {
1279 		for (n = 0; ; ) {
1280 			while (*s == ' ' || *s == '\t' || *s == '\n')
1281 				s++;
1282 			if (*s == 0)
1283 				break;
1284 			n++;
1285 			t = s;
1286 			do
1287 				s++;
1288 			while (*s!=' ' && *s!='\t' && *s!='\n' && *s!='\0');
1289 			temp = *s;
1290 			*s = '\0';
1291 			sprintf(num, "%d", n);
1292 			if (is_number(t))
1293 				setsymtab(num, t, atof(t), STR|NUM, (Array *) ap->sval);
1294 			else
1295 				setsymtab(num, t, 0.0, STR, (Array *) ap->sval);
1296 			*s = temp;
1297 			if (*s != 0)
1298 				s++;
1299 		}
1300 	} else if (sep == 0) {	/* new: split(s, a, "") => 1 char/elem */
1301 		for (n = 0; *s != 0; s++) {
1302 			char buf[2];
1303 			n++;
1304 			sprintf(num, "%d", n);
1305 			buf[0] = *s;
1306 			buf[1] = 0;
1307 			if (isdigit((uschar)buf[0]))
1308 				setsymtab(num, buf, atof(buf), STR|NUM, (Array *) ap->sval);
1309 			else
1310 				setsymtab(num, buf, 0.0, STR, (Array *) ap->sval);
1311 		}
1312 	} else if (*s != 0) {
1313 		for (;;) {
1314 			n++;
1315 			t = s;
1316 			while (*s != sep && *s != '\n' && *s != '\0')
1317 				s++;
1318 			temp = *s;
1319 			*s = '\0';
1320 			sprintf(num, "%d", n);
1321 			if (is_number(t))
1322 				setsymtab(num, t, atof(t), STR|NUM, (Array *) ap->sval);
1323 			else
1324 				setsymtab(num, t, 0.0, STR, (Array *) ap->sval);
1325 			*s = temp;
1326 			if (*s++ == 0)
1327 				break;
1328 		}
1329 	}
1330 	tempfree(ap);
1331 	tempfree(y);
1332 	if (a[2] != 0 && arg3type == STRING) {
1333 		tempfree(x);
1334 	}
1335 	x = gettemp();
1336 	x->tval = NUM;
1337 	x->fval = n;
1338 	return(x);
1339 }
1340 
condexpr(Node ** a,int n)1341 Cell *condexpr(Node **a, int n)	/* a[0] ? a[1] : a[2] */
1342 {
1343 	Cell *x;
1344 
1345 	x = execute(a[0]);
1346 	if (istrue(x)) {
1347 		tempfree(x);
1348 		x = execute(a[1]);
1349 	} else {
1350 		tempfree(x);
1351 		x = execute(a[2]);
1352 	}
1353 	return(x);
1354 }
1355 
ifstat(Node ** a,int n)1356 Cell *ifstat(Node **a, int n)	/* if (a[0]) a[1]; else a[2] */
1357 {
1358 	Cell *x;
1359 
1360 	x = execute(a[0]);
1361 	if (istrue(x)) {
1362 		tempfree(x);
1363 		x = execute(a[1]);
1364 	} else if (a[2] != 0) {
1365 		tempfree(x);
1366 		x = execute(a[2]);
1367 	}
1368 	return(x);
1369 }
1370 
whilestat(Node ** a,int n)1371 Cell *whilestat(Node **a, int n)	/* while (a[0]) a[1] */
1372 {
1373 	Cell *x;
1374 
1375 	for (;;) {
1376 		x = execute(a[0]);
1377 		if (!istrue(x))
1378 			return(x);
1379 		tempfree(x);
1380 		x = execute(a[1]);
1381 		if (isbreak(x)) {
1382 			x = True;
1383 			return(x);
1384 		}
1385 		if (isnext(x) || isexit(x) || isret(x))
1386 			return(x);
1387 		tempfree(x);
1388 	}
1389 }
1390 
dostat(Node ** a,int n)1391 Cell *dostat(Node **a, int n)	/* do a[0]; while(a[1]) */
1392 {
1393 	Cell *x;
1394 
1395 	for (;;) {
1396 		x = execute(a[0]);
1397 		if (isbreak(x))
1398 			return True;
1399 		if (isnext(x) || isexit(x) || isret(x))
1400 			return(x);
1401 		tempfree(x);
1402 		x = execute(a[1]);
1403 		if (!istrue(x))
1404 			return(x);
1405 		tempfree(x);
1406 	}
1407 }
1408 
forstat(Node ** a,int n)1409 Cell *forstat(Node **a, int n)	/* for (a[0]; a[1]; a[2]) a[3] */
1410 {
1411 	Cell *x;
1412 
1413 	x = execute(a[0]);
1414 	tempfree(x);
1415 	for (;;) {
1416 		if (a[1]!=0) {
1417 			x = execute(a[1]);
1418 			if (!istrue(x)) return(x);
1419 			else tempfree(x);
1420 		}
1421 		x = execute(a[3]);
1422 		if (isbreak(x))		/* turn off break */
1423 			return True;
1424 		if (isnext(x) || isexit(x) || isret(x))
1425 			return(x);
1426 		tempfree(x);
1427 		x = execute(a[2]);
1428 		tempfree(x);
1429 	}
1430 }
1431 
instat(Node ** a,int n)1432 Cell *instat(Node **a, int n)	/* for (a[0] in a[1]) a[2] */
1433 {
1434 	Cell *x, *vp, *arrayp, *cp, *ncp;
1435 	Array *tp;
1436 	int i;
1437 
1438 	vp = execute(a[0]);
1439 	arrayp = execute(a[1]);
1440 	if (!isarr(arrayp)) {
1441 		return True;
1442 	}
1443 	tp = (Array *) arrayp->sval;
1444 	tempfree(arrayp);
1445 	for (i = 0; i < tp->size; i++) {	/* this routine knows too much */
1446 		for (cp = tp->tab[i]; cp != NULL; cp = ncp) {
1447 			setsval(vp, cp->nval);
1448 			ncp = cp->cnext;
1449 			x = execute(a[2]);
1450 			if (isbreak(x)) {
1451 				tempfree(vp);
1452 				return True;
1453 			}
1454 			if (isnext(x) || isexit(x) || isret(x)) {
1455 				tempfree(vp);
1456 				return(x);
1457 			}
1458 			tempfree(x);
1459 		}
1460 	}
1461 	return True;
1462 }
1463 
bltin(Node ** a,int n)1464 Cell *bltin(Node **a, int n)	/* builtin functions. a[0] is type, a[1] is arg list */
1465 {
1466 	Cell *x, *y;
1467 	Awkfloat u;
1468 	int t;
1469 	char *p, *buf;
1470 	Node *nextarg;
1471 	FILE *fp;
1472 	void flush_all(void);
1473 
1474 	t = ptoi(a[0]);
1475 	x = execute(a[1]);
1476 	nextarg = a[1]->nnext;
1477 	switch (t) {
1478 	case FLENGTH:
1479 		if (isarr(x))
1480 			u = ((Array *) x->sval)->nelem;	/* GROT.  should be function*/
1481 		else
1482 			u = strlen(getsval(x));
1483 		break;
1484 	case FLOG:
1485 		u = errcheck(log(getfval(x)), "log"); break;
1486 	case FINT:
1487 		modf(getfval(x), &u); break;
1488 	case FEXP:
1489 		u = errcheck(exp(getfval(x)), "exp"); break;
1490 	case FSQRT:
1491 		u = errcheck(sqrt(getfval(x)), "sqrt"); break;
1492 	case FSIN:
1493 		u = sin(getfval(x)); break;
1494 	case FCOS:
1495 		u = cos(getfval(x)); break;
1496 	case FATAN:
1497 		if (nextarg == 0) {
1498 			WARNING("atan2 requires two arguments; returning 1.0");
1499 			u = 1.0;
1500 		} else {
1501 			y = execute(a[1]->nnext);
1502 			u = atan2(getfval(x), getfval(y));
1503 			tempfree(y);
1504 			nextarg = nextarg->nnext;
1505 		}
1506 		break;
1507 	case FSYSTEM:
1508 		fflush(stdout);		/* in case something is buffered already */
1509 		u = (Awkfloat) system(getsval(x)) / 256;   /* 256 is unix-dep */
1510 		break;
1511 	case FRAND:
1512 		/* in principle, rand() returns something in 0..RAND_MAX */
1513 		u = (Awkfloat) (rand() % RAND_MAX) / RAND_MAX;
1514 		break;
1515 	case FSRAND:
1516 		if (isrec(x))	/* no argument provided */
1517 			u = time((time_t *)0);
1518 		else
1519 			u = getfval(x);
1520 		srand((unsigned int) u);
1521 		break;
1522 	case FTOUPPER:
1523 	case FTOLOWER:
1524 		buf = tostring(getsval(x));
1525 		if (t == FTOUPPER) {
1526 			for (p = buf; *p; p++)
1527 				if (islower((uschar) *p))
1528 					*p = toupper((uschar)*p);
1529 		} else {
1530 			for (p = buf; *p; p++)
1531 				if (isupper((uschar) *p))
1532 					*p = tolower((uschar)*p);
1533 		}
1534 		tempfree(x);
1535 		x = gettemp();
1536 		setsval(x, buf);
1537 		free(buf);
1538 		return x;
1539 	case FFLUSH:
1540 		if (isrec(x) || strlen(getsval(x)) == 0) {
1541 			flush_all();	/* fflush() or fflush("") -> all */
1542 			u = 0;
1543 		} else if ((fp = openfile(FFLUSH, getsval(x))) == NULL)
1544 			u = EOF;
1545 		else
1546 			u = fflush(fp);
1547 		break;
1548 	default:	/* can't happen */
1549 		FATAL("illegal function type %d", t);
1550 		break;
1551 	}
1552 	tempfree(x);
1553 	x = gettemp();
1554 	setfval(x, u);
1555 	if (nextarg != 0) {
1556 		WARNING("warning: function has too many arguments");
1557 		for ( ; nextarg; nextarg = nextarg->nnext)
1558 			execute(nextarg);
1559 	}
1560 	return(x);
1561 }
1562 
printstat(Node ** a,int n)1563 Cell *printstat(Node **a, int n)	/* print a[0] */
1564 {
1565 	Node *x;
1566 	Cell *y;
1567 	FILE *fp;
1568 
1569 	if (a[1] == 0)	/* a[1] is redirection operator, a[2] is file */
1570 		fp = stdout;
1571 	else
1572 		fp = redirect(ptoi(a[1]), a[2]);
1573 	for (x = a[0]; x != NULL; x = x->nnext) {
1574 		y = execute(x);
1575 		fputs(getpssval(y), fp);
1576 		tempfree(y);
1577 		if (x->nnext == NULL)
1578 			fputs(*ORS, fp);
1579 		else
1580 			fputs(*OFS, fp);
1581 	}
1582 	if (a[1] != 0)
1583 		fflush(fp);
1584 	if (ferror(fp))
1585 		FATAL("write error on %s", filename(fp));
1586 	return(True);
1587 }
1588 
nullproc(Node ** a,int n)1589 Cell *nullproc(Node **a, int n)
1590 {
1591 	n = n;
1592 	a = a;
1593 	return 0;
1594 }
1595 
1596 
redirect(int a,Node * b)1597 FILE *redirect(int a, Node *b)	/* set up all i/o redirections */
1598 {
1599 	FILE *fp;
1600 	Cell *x;
1601 	char *fname;
1602 
1603 	x = execute(b);
1604 	fname = getsval(x);
1605 	fp = openfile(a, fname);
1606 	if (fp == NULL)
1607 		FATAL("can't open file %s", fname);
1608 	tempfree(x);
1609 	return fp;
1610 }
1611 
1612 struct files {
1613 	FILE	*fp;
1614 	const char	*fname;
1615 	int	mode;	/* '|', 'a', 'w' => LE/LT, GT */
1616 } files[FOPEN_MAX] ={
1617 	{ NULL,  "/dev/stdin",  LT },	/* watch out: don't free this! */
1618 	{ NULL, "/dev/stdout", GT },
1619 	{ NULL, "/dev/stderr", GT }
1620 };
1621 
stdinit(void)1622 void stdinit(void)	/* in case stdin, etc., are not constants */
1623 {
1624 	files[0].fp = stdin;
1625 	files[1].fp = stdout;
1626 	files[2].fp = stderr;
1627 }
1628 
openfile(int a,const char * us)1629 FILE *openfile(int a, const char *us)
1630 {
1631 	const char *s = us;
1632 	int i, m;
1633 	FILE *fp = 0;
1634 
1635 	if (*s == '\0')
1636 		FATAL("null file name in print or getline");
1637 	for (i=0; i < FOPEN_MAX; i++)
1638 		if (files[i].fname && strcmp(s, files[i].fname) == 0) {
1639 			if (a == files[i].mode || (a==APPEND && files[i].mode==GT))
1640 				return files[i].fp;
1641 			if (a == FFLUSH)
1642 				return files[i].fp;
1643 		}
1644 	if (a == FFLUSH)	/* didn't find it, so don't create it! */
1645 		return NULL;
1646 
1647 	for (i=0; i < FOPEN_MAX; i++)
1648 		if (files[i].fp == 0)
1649 			break;
1650 	if (i >= FOPEN_MAX)
1651 		FATAL("%s makes too many open files", s);
1652 	fflush(stdout);	/* force a semblance of order */
1653 	m = a;
1654 	if (a == GT) {
1655 		fp = fopen(s, "w");
1656 	} else if (a == APPEND) {
1657 		fp = fopen(s, "a");
1658 		m = GT;	/* so can mix > and >> */
1659 	} else if (a == '|') {	/* output pipe */
1660 		fp = popen(s, "w");
1661 	} else if (a == LE) {	/* input pipe */
1662 		fp = popen(s, "r");
1663 	} else if (a == LT) {	/* getline <file */
1664 		fp = strcmp(s, "-") == 0 ? stdin : fopen(s, "r");	/* "-" is stdin */
1665 	} else	/* can't happen */
1666 		FATAL("illegal redirection %d", a);
1667 	if (fp != NULL) {
1668 		files[i].fname = tostring(s);
1669 		files[i].fp = fp;
1670 		files[i].mode = m;
1671 	}
1672 	return fp;
1673 }
1674 
filename(FILE * fp)1675 const char *filename(FILE *fp)
1676 {
1677 	int i;
1678 
1679 	for (i = 0; i < FOPEN_MAX; i++)
1680 		if (fp == files[i].fp)
1681 			return files[i].fname;
1682 	return "???";
1683 }
1684 
closefile(Node ** a,int n)1685 Cell *closefile(Node **a, int n)
1686 {
1687 	Cell *x;
1688 	int i, stat;
1689 
1690 	n = n;
1691 	x = execute(a[0]);
1692 	getsval(x);
1693 	stat = -1;
1694 	for (i = 0; i < FOPEN_MAX; i++) {
1695 		if (files[i].fname && strcmp(x->sval, files[i].fname) == 0) {
1696 			if (ferror(files[i].fp))
1697 				WARNING( "i/o error occurred on %s", files[i].fname );
1698 			if (files[i].mode == '|' || files[i].mode == LE)
1699 				stat = pclose(files[i].fp);
1700 			else
1701 				stat = fclose(files[i].fp);
1702 			if (stat == EOF)
1703 				WARNING( "i/o error occurred closing %s", files[i].fname );
1704 			if (i > 2)	/* don't do /dev/std... */
1705 				xfree(files[i].fname);
1706 			files[i].fname = NULL;	/* watch out for ref thru this */
1707 			files[i].fp = NULL;
1708 		}
1709 	}
1710 	tempfree(x);
1711 	x = gettemp();
1712 	setfval(x, (Awkfloat) stat);
1713 	return(x);
1714 }
1715 
closeall(void)1716 void closeall(void)
1717 {
1718 	int i, stat;
1719 
1720 	for (i = 0; i < FOPEN_MAX; i++) {
1721 		if (files[i].fp) {
1722 			if (ferror(files[i].fp))
1723 				WARNING( "i/o error occurred on %s", files[i].fname );
1724 			if (files[i].mode == '|' || files[i].mode == LE)
1725 				stat = pclose(files[i].fp);
1726 			else
1727 				stat = fclose(files[i].fp);
1728 			if (stat == EOF)
1729 				WARNING( "i/o error occurred while closing %s", files[i].fname );
1730 		}
1731 	}
1732 }
1733 
flush_all(void)1734 void flush_all(void)
1735 {
1736 	int i;
1737 
1738 	for (i = 0; i < FOPEN_MAX; i++)
1739 		if (files[i].fp)
1740 			fflush(files[i].fp);
1741 }
1742 
1743 void backsub(char **pb_ptr, char **sptr_ptr);
1744 
sub(Node ** a,int nnn)1745 Cell *sub(Node **a, int nnn)	/* substitute command */
1746 {
1747 	char *sptr, *pb, *q;
1748 	Cell *x, *y, *result;
1749 	char *t, *buf;
1750 	fa *pfa;
1751 	int bufsz = recsize;
1752 
1753 	if ((buf = (char *) malloc(bufsz)) == NULL)
1754 		FATAL("out of memory in sub");
1755 	x = execute(a[3]);	/* target string */
1756 	t = getsval(x);
1757 	if (a[0] == 0)		/* 0 => a[1] is already-compiled regexpr */
1758 		pfa = (fa *) a[1];	/* regular expression */
1759 	else {
1760 		y = execute(a[1]);
1761 		pfa = makedfa(getsval(y), 1);
1762 		tempfree(y);
1763 	}
1764 	y = execute(a[2]);	/* replacement string */
1765 	result = False;
1766 	if (pmatch(pfa, t)) {
1767 		sptr = t;
1768 		adjbuf(&buf, &bufsz, 1+patbeg-sptr, recsize, 0, "sub");
1769 		pb = buf;
1770 		while (sptr < patbeg)
1771 			*pb++ = *sptr++;
1772 		sptr = getsval(y);
1773 		while (*sptr != 0) {
1774 			adjbuf(&buf, &bufsz, 5+pb-buf, recsize, &pb, "sub");
1775 			if (*sptr == '\\') {
1776 				backsub(&pb, &sptr);
1777 			} else if (*sptr == '&') {
1778 				sptr++;
1779 				adjbuf(&buf, &bufsz, 1+patlen+pb-buf, recsize, &pb, "sub");
1780 				for (q = patbeg; q < patbeg+patlen; )
1781 					*pb++ = *q++;
1782 			} else
1783 				*pb++ = *sptr++;
1784 		}
1785 		*pb = '\0';
1786 		if (pb > buf + bufsz)
1787 			FATAL("sub result1 %.30s too big; can't happen", buf);
1788 		sptr = patbeg + patlen;
1789 		if ((patlen == 0 && *patbeg) || (patlen && *(sptr-1))) {
1790 			adjbuf(&buf, &bufsz, 1+strlen(sptr)+pb-buf, 0, &pb, "sub");
1791 			while ((*pb++ = *sptr++) != 0)
1792 				;
1793 		}
1794 		if (pb > buf + bufsz)
1795 			FATAL("sub result2 %.30s too big; can't happen", buf);
1796 		setsval(x, buf);	/* BUG: should be able to avoid copy */
1797 		result = True;;
1798 	}
1799 	tempfree(x);
1800 	tempfree(y);
1801 	free(buf);
1802 	return result;
1803 }
1804 
gsub(Node ** a,int nnn)1805 Cell *gsub(Node **a, int nnn)	/* global substitute */
1806 {
1807 	Cell *x, *y;
1808 	char *rptr, *sptr, *t, *pb, *q;
1809 	char *buf;
1810 	fa *pfa;
1811 	int mflag, tempstat, num;
1812 	int bufsz = recsize;
1813 
1814 	if ((buf = (char *) malloc(bufsz)) == NULL)
1815 		FATAL("out of memory in gsub");
1816 	mflag = 0;	/* if mflag == 0, can replace empty string */
1817 	num = 0;
1818 	x = execute(a[3]);	/* target string */
1819 	t = getsval(x);
1820 	if (a[0] == 0)		/* 0 => a[1] is already-compiled regexpr */
1821 		pfa = (fa *) a[1];	/* regular expression */
1822 	else {
1823 		y = execute(a[1]);
1824 		pfa = makedfa(getsval(y), 1);
1825 		tempfree(y);
1826 	}
1827 	y = execute(a[2]);	/* replacement string */
1828 	if (pmatch(pfa, t)) {
1829 		tempstat = pfa->initstat;
1830 		pfa->initstat = 2;
1831 		pb = buf;
1832 		rptr = getsval(y);
1833 		do {
1834 			if (patlen == 0 && *patbeg != 0) {	/* matched empty string */
1835 				if (mflag == 0) {	/* can replace empty */
1836 					num++;
1837 					sptr = rptr;
1838 					while (*sptr != 0) {
1839 						adjbuf(&buf, &bufsz, 5+pb-buf, recsize, &pb, "gsub");
1840 						if (*sptr == '\\') {
1841 							backsub(&pb, &sptr);
1842 						} else if (*sptr == '&') {
1843 							sptr++;
1844 							adjbuf(&buf, &bufsz, 1+patlen+pb-buf, recsize, &pb, "gsub");
1845 							for (q = patbeg; q < patbeg+patlen; )
1846 								*pb++ = *q++;
1847 						} else
1848 							*pb++ = *sptr++;
1849 					}
1850 				}
1851 				if (*t == 0)	/* at end */
1852 					goto done;
1853 				adjbuf(&buf, &bufsz, 2+pb-buf, recsize, &pb, "gsub");
1854 				*pb++ = *t++;
1855 				if (pb > buf + bufsz)	/* BUG: not sure of this test */
1856 					FATAL("gsub result0 %.30s too big; can't happen", buf);
1857 				mflag = 0;
1858 			}
1859 			else {	/* matched nonempty string */
1860 				num++;
1861 				sptr = t;
1862 				adjbuf(&buf, &bufsz, 1+(patbeg-sptr)+pb-buf, recsize, &pb, "gsub");
1863 				while (sptr < patbeg)
1864 					*pb++ = *sptr++;
1865 				sptr = rptr;
1866 				while (*sptr != 0) {
1867 					adjbuf(&buf, &bufsz, 5+pb-buf, recsize, &pb, "gsub");
1868 					if (*sptr == '\\') {
1869 						backsub(&pb, &sptr);
1870 					} else if (*sptr == '&') {
1871 						sptr++;
1872 						adjbuf(&buf, &bufsz, 1+patlen+pb-buf, recsize, &pb, "gsub");
1873 						for (q = patbeg; q < patbeg+patlen; )
1874 							*pb++ = *q++;
1875 					} else
1876 						*pb++ = *sptr++;
1877 				}
1878 				t = patbeg + patlen;
1879 				if (patlen == 0 || *t == 0 || *(t-1) == 0)
1880 					goto done;
1881 				if (pb > buf + bufsz)
1882 					FATAL("gsub result1 %.30s too big; can't happen", buf);
1883 				mflag = 1;
1884 			}
1885 		} while (pmatch(pfa,t));
1886 		sptr = t;
1887 		adjbuf(&buf, &bufsz, 1+strlen(sptr)+pb-buf, 0, &pb, "gsub");
1888 		while ((*pb++ = *sptr++) != 0)
1889 			;
1890 	done:	if (pb > buf + bufsz)
1891 			FATAL("gsub result2 %.30s too big; can't happen", buf);
1892 		*pb = '\0';
1893 		setsval(x, buf);	/* BUG: should be able to avoid copy + free */
1894 		pfa->initstat = tempstat;
1895 	}
1896 	tempfree(x);
1897 	tempfree(y);
1898 	x = gettemp();
1899 	x->tval = NUM;
1900 	x->fval = num;
1901 	free(buf);
1902 	return(x);
1903 }
1904 
backsub(char ** pb_ptr,char ** sptr_ptr)1905 void backsub(char **pb_ptr, char **sptr_ptr)	/* handle \\& variations */
1906 {						/* sptr[0] == '\\' */
1907 	char *pb = *pb_ptr, *sptr = *sptr_ptr;
1908 
1909 	if (sptr[1] == '\\') {
1910 		if (sptr[2] == '\\' && sptr[3] == '&') { /* \\\& -> \& */
1911 			*pb++ = '\\';
1912 			*pb++ = '&';
1913 			sptr += 4;
1914 		} else if (sptr[2] == '&') {	/* \\& -> \ + matched */
1915 			*pb++ = '\\';
1916 			sptr += 2;
1917 		} else {			/* \\x -> \\x */
1918 			*pb++ = *sptr++;
1919 			*pb++ = *sptr++;
1920 		}
1921 	} else if (sptr[1] == '&') {	/* literal & */
1922 		sptr++;
1923 		*pb++ = *sptr++;
1924 	} else				/* literal \ */
1925 		*pb++ = *sptr++;
1926 
1927 	*pb_ptr = pb;
1928 	*sptr_ptr = sptr;
1929 }
1930