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