![[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] / researchv8dc / cmd / awk|
Return to run.c CVS log | Up to [Research Unix] / researchv8dc / cmd / awk |
1.1 root 1: #define tempfree(x) if (istemp(x)) tfree(x); else
2:
3: #define execute(p) (isvalue(p) ? (Cell *)((p)->narg[0]) : real_execute(p))
4: /* #define execute(p) real_execute(p) */
5:
6: #define DEBUG
7: #include "awk.h"
8: #include <math.h>
9: #include "y.tab.h"
10: #include <stdio.h>
11: #include <ctype.h>
12:
13: #define getfval(p) (((p)->tval & (ARR|FLD|REC|NUM)) == NUM ? (p)->fval : real_getfval(p))
14: #define getsval(p) (((p)->tval & (ARR|FLD|REC|STR)) == STR ? (p)->sval : real_getsval(p))
15:
16: extern Awkfloat real_getfval();
17: extern char *real_getsval();
18: extern Cell *real_execute(), *fieldel(), *dopa2(), *gettemp(), *copycell();
19: extern FILE *openfile(), *redirect();
20: extern fa *makedfa();
21: extern double errcheck();
22:
23: #define PA2NUM 29
24: int pairstack[PA2NUM], paircnt;
25: Node *winner = NULL;
26: Cell *tmps;
27:
28: static Cell truecell ={ OBOOL, BTRUE, 0, 0, 1.0, NUM };
29: Cell *true = &truecell;
30: static Cell falsecell ={ OBOOL, BFALSE, 0, 0, 0.0, NUM };
31: Cell *false = &falsecell;
32: static Cell breakcell ={ OJUMP, JBREAK, 0, 0, 0.0, NUM };
33: Cell *jbreak = &breakcell;
34: static Cell contcell ={ OJUMP, JCONT, 0, 0, 0.0, NUM };
35: Cell *jcont = &contcell;
36: static Cell nextcell ={ OJUMP, JNEXT, 0, 0, 0.0, NUM };
37: Cell *jnext = &nextcell;
38: static Cell exitcell ={ OJUMP, JEXIT, 0, 0, 0.0, NUM };
39: Cell *jexit = &exitcell;
40: static Cell retcell ={ OJUMP, JRET, 0, 0, 0.0, NUM };
41: Cell *jret = &retcell;
42: static Cell tempcell ={ OCELL, CTEMP, 0, 0, 0.0, NUM };
43:
44: Node *curnode = NULL; /* the node being executed, for debugging */
45:
46: run(a) Node *a;
47: {
48: execute(a);
49: closeall();
50: }
51:
52: Cell *real_execute(u) Node *u;
53: {
54: register Cell *(*proc)();
55: register Cell *x;
56: register Node *a;
57:
58: if (u == NULL)
59: return(true);
60: for (a = u; ; a = a->nnext) {
61: curnode = a;
62: if (isvalue(a) || a->ntype == NFIELD) {
63: x = (Cell *) (a->narg[0]);
64: x->ctype = OCELL;
65: if ((x->tval & FLD) && !donefld)
66: fldbld();
67: else if ((x->tval & REC) && !donerec)
68: recbld();
69: return(x);
70: }
71: if (notlegal(a->nobj)) /* probably a Cell* but too risky to print */
72: error(FATAL, "illegal statement");
73: proc = proctab[a->nobj-FIRSTTOKEN];
74: x = (*proc)(a->narg, a->nobj);
75: if ((x->tval & FLD) && !donefld)
76: fldbld();
77: else if ((x->tval & REC) && !donerec)
78: recbld();
79: if (isexpr(a))
80: return(x);
81: /* a statement, goto next statement */
82: if (isjump(x))
83: return(x);
84: if (a->nnext == (Node *)NULL)
85: return(x);
86: tempfree(x);
87: }
88: }
89:
90: Cell *program(a, n) register Node **a;
91: {
92: register Cell *x;
93:
94: if (a[0] != NULL) { /* BEGIN */
95: x = execute(a[0]);
96: if (isexit(x))
97: return(true);
98: if (isjump(x))
99: error(FATAL, "unexpected break, continue or next");
100: tempfree(x);
101: }
102: loop:
103: while (getrec(record) > 0) {
104: x = execute(a[1]);
105: if (isexit(x))
106: break;
107: tempfree(x);
108: }
109: if (a[2] != NULL) { /* END */
110: x = execute(a[2]);
111: if (iscont(x)) /* read some more */
112: goto loop;
113: if (isbreak(x) || isnext(x))
114: error(FATAL, "unexpected break or next");
115: tempfree(x);
116: }
117: return(true);
118: }
119:
120: #define FRAME 100
121: struct Frame {
122: int nargs; /* number of arguments in this call */
123: Cell *fcncell; /* pointer to Cell for function */
124: Cell **args; /* pointer to array of arguments after execute */
125: Cell *retval; /* return value */
126: } frame[FRAME];
127:
128: struct Frame *fp = frame; /* frame pointer. bottom level unused */
129:
130: Cell *call(a, n) Node **a;
131: {
132: int i, ncall, ndef;
133: Node *x;
134: Cell **args, *y, *z, *fcn;
135: char *s;
136:
137: fcn = execute(a[0]); /* the function itself */
138: s = fcn->nval;
139: if (!isfunc(fcn))
140: error(FATAL, "calling undefined function %s", s);
141: for (ncall = 0, x = a[1]; x != NULL; x = x->nnext) /* args in call */
142: ncall++;
143: ndef = (int) fcn->fval; /* args in defn */
144: dprintf("calling %s, %d args (%d in defn), fp=%d\n", s, ncall, ndef, fp-frame);
145: args = (Cell **) Calloc(ndef>ncall ? ndef : ncall, sizeof (Cell *));
146: for (i = 0, x = a[1]; x != NULL; i++, x = x->nnext) { /* get call args */
147: dprintf("evaluate args[%d], fp=%d:\n", i, fp-frame);
148: y = execute(x);
149: dprintf("args[%d]: %s %f <%s>, t=%o\n",
150: i, y->nval, getfval(y), getsval(y), y->tval);
151: if (!isarr(y)) {
152: args[i] = copycell(y);
153: } else {
154: args[i] = y; /* arrays by ref */
155: }
156: tempfree(y);
157: }
158: for ( ; i < ndef; i++) { /* add null args for ones not provided */
159: args[i] = gettemp();
160: args[i]->sval = "";
161: args[i]->tval = STR|NUM|DONTFREE;
162: args[i]->csub = CCOPY;
163: }
164: fp++; /* now ok to up frame */
165: if (fp >= frame+FRAME)
166: error(FATAL, "function %s nested too deeply", s);
167: fp->fcncell = fcn;
168: fp->args = args;
169: fp->nargs = ndef; /* number defined with (can be more than call) */
170: fp->retval = gettemp();
171:
172: dprintf("start exec of %s, fp=%d\n", s, fp-frame);
173: y = execute((Node *)(fcn->sval)); /* execute body */
174: dprintf("finished exec of %s, fp=%d\n", s, fp-frame);
175:
176: for (i = 0; i < ndef; i++) {
177: Cell *t = fp->args[i];
178: if (t->csub == CCOPY) {
179: if (isarr(t))
180: freesymtab(t);
181: t->csub = CTEMP;
182: }
183: tempfree(t);
184: }
185: if (isexit(y) || isnext(y))
186: return y;
187: z = fp->retval; /* return value */
188: dprintf("%s returns %g |%s| %o\n", s, getfval(z), getsval(z), z->tval);
189: xfree(fp->args);
190: fp--;
191: tempfree(fcn);
192: return(z);
193: }
194:
195: Cell *copycell(x) /* make a copy of a cell in a temp */
196: Cell *x;
197: {
198: Cell *y;
199:
200: y = gettemp();
201: y->csub = CCOPY; /* prevents freeing until call is over */
202: y->nval = x->nval;
203: y->sval = x->sval ? tostring(x->sval) : NULL;
204: y->fval = x->fval;
205: y->tval = x->tval & ~CON; /* copy is not a constant */
206: return y;
207: }
208:
209: Cell *arg(a,n) Node **a;
210: {
211: int n;
212:
213: n = (int) a[0]; /* argument number, counting from 0 */
214: dprintf("arg(%d), fp->nargs=%d\n", n, fp->nargs);
215: if (n+1 > fp->nargs)
216: error(FATAL, "argument #%d of function %s was not supplied",
217: n+1, fp->fcncell->nval);
218: return fp->args[n];
219: }
220:
221: Cell *jump(a, n) Node **a;
222: {
223: register Cell *y;
224:
225: switch (n) {
226: case EXIT:
227: if (a[0] != NULL) {
228: y = execute(a[0]);
229: errorflag = getfval(y);
230: tempfree(y);
231: }
232: return(jexit);
233: case RETURN:
234: if (a[0] != NULL) {
235: y = execute(a[0]);
236: if ((y->tval & (STR|NUM)) == (STR|NUM)) {
237: setsval(fp->retval, getsval(y));
238: fp->retval->fval = getfval(y);
239: fp->retval->tval |= NUM;
240: }
241: else if (y->tval & STR)
242: setsval(fp->retval, getsval(y));
243: else if (y->tval & NUM)
244: setfval(fp->retval, getfval(y));
245: tempfree(y);
246: }
247: return(jret);
248: case NEXT:
249: return(jnext);
250: case BREAK:
251: return(jbreak);
252: case CONTINUE:
253: return(jcont);
254: default:
255: error(FATAL, "illegal jump type %d", n);
256: }
257: }
258:
259: Cell *getline(a, n) Node **a; int n;
260: {
261: /* a[0] is variable, a[1] is operator, a[2] is filename */
262: register Cell *r, *x;
263: char buf[RECSIZE];
264: FILE *fp;
265:
266: fflush(stdout); /* in case someone is waiting for a prompt */
267: r = gettemp();
268: if (a[1] != NULL) { /* getline < file */
269: x = execute(a[2]); /* filename */
270: if ((int) a[1] == '|') /* input pipe */
271: a[1] = (Node *) LE; /* arbitrary flag */
272: fp = openfile((int) a[1], getsval(x));
273: tempfree(x);
274: if (fp == NULL)
275: n = -1;
276: else
277: n = readrec(buf, sizeof(buf), fp);
278: if (n <= 0) {
279: ;
280: } else if (a[0] != NULL) { /* getline var <file */
281: setsval(execute(a[0]), buf);
282: } else { /* getline <file */
283: if (!(recloc->tval & DONTFREE))
284: xfree(recloc->sval);
285: strcpy(record, buf);
286: recloc->sval = record;
287: recloc->tval = REC | STR | DONTFREE;
288: donerec = 1; donefld = 0;
289: }
290: } else { /* bare getline; use current input */
291: if (a[0] == NULL) /* getline */
292: n = getrec(record);
293: else { /* getline var */
294: n = getrec(buf);
295: setsval(execute(a[0]), buf);
296: }
297: }
298: setfval(r, (Awkfloat) n);
299: return r;
300: }
301:
302: Cell *getnf(a,n) register Node **a;
303: {
304: if (donefld == 0)
305: fldbld();
306: return (Cell *) a[0];
307: }
308:
309: Cell *array(a,n) register Node **a;
310: {
311: register Cell *x, *y, *z;
312: register char *s;
313:
314: x = execute(a[0]); /* Cell* for symbol table */
315: y = execute(a[1]); /* subscript */
316: s = getsval(y);
317: if (!isarr(x)) {
318: xfree(x->sval);
319: x->tval &= ~STR;
320: x->tval |= ARR;
321: x->sval = (char *) makesymtab();
322: }
323: z = setsymtab(s, "", 0.0, STR|NUM, x->sval);
324: z->ctype = OCELL;
325: z->csub = CVAR;
326: tempfree(x);
327: tempfree(y);
328: return(z);
329: }
330:
331: Cell *delete(a, n) Node **a;
332: {
333: Cell *x, *y;
334:
335: x = execute(a[0]); /* Cell* for symbol table */
336: y = execute(a[1]); /* subscript */
337: freeelem(x, getsval(y));
338: tempfree(y);
339: tempfree(x);
340: return true;
341: }
342:
343: Cell *intest(a, n) Node **a;
344: {
345: register Cell *x, *ap;
346: int k;
347:
348: ap = execute(a[1]); /* array name */
349: if (!isarr(ap))
350: error(FATAL, "%s is not an array", ap->nval);
351: x = execute(a[0]); /* expr */
352: getsval(x);
353: k = lookup(x->sval, (Cell **) ap->sval) == NULL;
354: tempfree(x);
355: tempfree(ap);
356: if (k)
357: return(false);
358: else
359: return(true);
360: }
361:
362:
363: Cell *matchop(a,n) Node **a;
364: {
365: register Cell *x, *y;
366: register char *s, *t;
367: register int i;
368: static struct fa *pfa = NULL;
369: static char *prevre = NULL;
370:
371: x = execute(a[1]);
372: s = getsval(x);
373: if (a[0] == 0)
374: i = match(a[2], s);
375: else {
376: y = execute(a[2]);
377: t = getsval(y);
378: if (pfa == NULL) {
379: pfa = makedfa(reparse(t), 0);
380: prevre = tostring(t);
381: } else if (strcmp(t, prevre) != 0) {
382: free(prevre);
383: prevre = tostring(t);
384: freefa(pfa);
385: pfa = makedfa(reparse(t), 0);
386: }
387: i = match(pfa, s);
388: tempfree(y);
389: }
390: tempfree(x);
391: if (n == MATCH && i == 1 || n == NOTMATCH && i == 0)
392: return(true);
393: else
394: return(false);
395: }
396:
397:
398: Cell *boolop(a,n) Node **a;
399: {
400: register Cell *x, *y;
401: register int i;
402:
403: x = execute(a[0]);
404: i = istrue(x);
405: tempfree(x);
406: switch (n) {
407: case BOR:
408: if (i) return(true);
409: y = execute(a[1]);
410: i = istrue(y);
411: tempfree(y);
412: if (i) return(true);
413: else return(false);
414: case AND:
415: if ( !i ) return(false);
416: y = execute(a[1]);
417: i = istrue(y);
418: tempfree(y);
419: if (i) return(true);
420: else return(false);
421: case NOT:
422: if (i) return(false);
423: else return(true);
424: default:
425: error(FATAL, "unknown boolean operator %d", n);
426: }
427: }
428:
429: Cell *relop(a,n) Node **a;
430: {
431: register int i;
432: register Cell *x, *y;
433: Awkfloat j;
434:
435: x = execute(a[0]);
436: y = execute(a[1]);
437: if (x->tval&NUM && y->tval&NUM) {
438: j = x->fval - y->fval;
439: i = j<0? -1: (j>0? 1: 0);
440: } else {
441: i = strcmp(getsval(x), getsval(y));
442: }
443: tempfree(x);
444: tempfree(y);
445: switch (n) {
446: case LT: if (i<0) return(true);
447: else return(false);
448: case LE: if (i<=0) return(true);
449: else return(false);
450: case NE: if (i!=0) return(true);
451: else return(false);
452: case EQ: if (i == 0) return(true);
453: else return(false);
454: case GE: if (i>=0) return(true);
455: else return(false);
456: case GT: if (i>0) return(true);
457: else return(false);
458: default:
459: error(FATAL, "unknown relational operator %d", n);
460: }
461: }
462:
463: tfree(a) register Cell *a;
464: {
465: xfree(a->sval);
466: a->tval = 0;
467: a->ctype = OCELL;
468: a->cnext = tmps;
469: tmps = a;
470: }
471:
472: Cell *gettemp()
473: { int i;
474: register Cell *x;
475:
476: if (!tmps) {
477: tmps = (Cell *) Calloc(100, sizeof(Cell));
478: if (!tmps)
479: error(FATAL, "no space for temporaries");
480: for(i = 1; i < 100; i++)
481: tmps[i-1].cnext = &tmps[i];
482: tmps[i-1].cnext = 0;
483: }
484: x = tmps;
485: tmps = x->cnext;
486: *x = tempcell;
487: return(x);
488: }
489:
490: Cell *indirect(a,n) Node **a;
491: {
492: register Cell *x;
493: register int m;
494: register char *s;
495: Cell *fieldadr();
496:
497: x = execute(a[0]);
498: m = getfval(x);
499: if (m == 0 && !isnumber(s = getsval(x))) /* suspicion! */
500: error(FATAL, "illegal field $(%s)", s);
501: tempfree(x);
502: x = fieldadr(m);
503: x->ctype = OCELL;
504: x->csub = CFLD;
505: return(x);
506: }
507:
508: Cell *substr(a, nnn) Node **a;
509: {
510: register int k, m, n;
511: register char *s, temp;
512: register Cell *x;
513:
514: x = execute(a[0]);
515: s = getsval(x);
516: k = strlen(s) + 1;
517: tempfree(x);
518: if (k <= 1) {
519: x = gettemp();
520: setsval(x, "");
521: return(x);
522: }
523: x = execute(a[1]);
524: m = getfval(x);
525: if (m <= 0)
526: m = 1;
527: else if (m > k)
528: m = k;
529: tempfree(x);
530: if (a[2] != 0) {
531: x = execute(a[2]);
532: n = getfval(x);
533: tempfree(x);
534: }
535: else
536: n = k - 1;
537: if (n < 0)
538: n = 0;
539: else if (n > k - m)
540: n = k - m;
541: dprintf("substr: m=%d, n=%d, s=%s\n", m, n, s);
542: x = gettemp();
543: temp = s[n+m-1]; /* with thanks to John Linderman */
544: s[n+m-1] = '\0';
545: setsval(x, s + m - 1);
546: s[n+m-1] = temp;
547: return(x);
548: }
549:
550: Cell *sindex(a, nnn) Node **a;
551: {
552: register Cell *x;
553: register char *s1, *s2, *p1, *p2, *q;
554:
555: x = execute(a[0]);
556: s1 = getsval(x);
557: tempfree(x);
558: x = execute(a[1]);
559: s2 = getsval(x);
560: tempfree(x);
561:
562: x = gettemp();
563: for (p1 = s1; *p1 != '\0'; p1++) {
564: for (q=p1, p2=s2; *p2 != '\0' && *q == *p2; q++, p2++)
565: ;
566: if (*p2 == '\0') {
567: setfval(x, (Awkfloat) (p1 - s1 + 1)); /* origin 1 */
568: return(x);
569: }
570: }
571: setfval(x, 0.0);
572: return(x);
573: }
574:
575: char *format(buf, s, a) char *buf, *s; Node *a;
576: {
577: char fmt[RECSIZE];
578: register char *p, *t, *os;
579: register Cell *x;
580: int flag = 0;
581: Awkfloat xf;
582:
583: os = s;
584: p = buf;
585: while (*s) {
586: if (*s != '%') {
587: *p++ = *s++;
588: continue;
589: }
590: if (*(s+1) == '%') {
591: *p++ = '%';
592: s += 2;
593: continue;
594: }
595: for (t=fmt; (*t++ = *s) != '\0'; s++)
596: if (islower(*s) && *s != 'l')
597: break;
598: *t = '\0';
599: if (t >= fmt + sizeof(fmt))
600: error(FATAL, "format item %.20s... too long", os);
601: switch (*s) {
602: case 'f': case 'e': case 'g':
603: flag = 1;
604: break;
605: case 'd':
606: flag = 2;
607: if(*(s-1) == 'l') break;
608: *(t-1) = 'l';
609: *t = 'd';
610: *++t = '\0';
611: break;
612: case 'o': case 'x': case 'u':
613: flag = *(s-1) == 'l' ? 2 : 3;
614: break;
615: case 's':
616: flag = 4;
617: break;
618: case 'c':
619: flag = 5;
620: break;
621: default:
622: flag = 0;
623: break;
624: }
625: if (flag == 0) {
626: sprintf(p, "%s", fmt);
627: p += strlen(p);
628: continue;
629: }
630: if (a == NULL)
631: error(FATAL, "not enough args in printf(%s)", os);
632: x = execute(a);
633: a = a->nnext;
634: if (flag != 4) /* watch out for converting to numbers! */
635: xf = getfval(x);
636: switch (flag) {
637: case 1: sprintf(p, fmt, xf); break;
638: case 2: sprintf(p, fmt, (long) xf); break;
639: case 3: sprintf(p, fmt, (int) xf); break;
640: case 4: sprintf(p, fmt, getsval(x)); break;
641: case 5: sprintf(p, fmt, (int) xf); break;
642: }
643: tempfree(x);
644: p += strlen(p);
645: s++;
646: }
647: *p = '\0';
648: return buf;
649: }
650:
651: Cell *asprintf(a,n) Node **a;
652: {
653: register Cell *x;
654: register Node *y;
655: char buf[RECSIZE];
656:
657: y = a[0]->nnext;
658: x = execute(a[0]);
659: format(buf, getsval(x), y);
660: tempfree(x);
661: x = gettemp();
662: x->sval = tostring(buf);
663: x->tval = STR;
664: return(x);
665: }
666:
667: Cell *aprintf(a,n) Node **a;
668: {
669: FILE *fp;
670: register Cell *x;
671: register Node *y;
672: char buf[RECSIZE];
673:
674: y = a[0]->nnext;
675: x = execute(a[0]);
676: format(buf, getsval(x), y);
677: tempfree(x);
678: if (a[1] == NULL)
679: fputs(buf, stdout);
680: else {
681: fp = redirect((int)a[1], a[2]);
682: fputs(buf, fp);
683: fflush(fp);
684: }
685: return(true);
686: }
687:
688: Cell *arith(a,n) Node **a;
689: {
690: Awkfloat i, j;
691: register Cell *x, *y, *z;
692:
693: x = execute(a[0]);
694: i = getfval(x);
695: tempfree(x);
696: if (n != UMINUS) {
697: y = execute(a[1]);
698: j = getfval(y);
699: tempfree(y);
700: }
701: z = gettemp();
702: switch (n) {
703: case ADD:
704: i += j;
705: break;
706: case MINUS:
707: i -= j;
708: break;
709: case MULT:
710: i *= j;
711: break;
712: case DIVIDE:
713: if (j == 0)
714: error(FATAL, "division by zero");
715: i /= j;
716: break;
717: case MOD:
718: if (j == 0)
719: error(FATAL, "division by zero in mod");
720: i = i - j*(long)(i/j);
721: break;
722: case UMINUS:
723: i = -i;
724: break;
725: case POWER:
726: i = errcheck(pow(i, j), "pow");
727: break;
728: default:
729: error(FATAL, "illegal arithmetic operator %d", n);
730: }
731: setfval(z, i);
732: return(z);
733: }
734:
735: Cell *incrdecr(a, n) Node **a;
736: {
737: register Cell *x, *z;
738: register int k;
739: Awkfloat xf;
740:
741: x = execute(a[0]);
742: xf = getfval(x);
743: k = (n == PREINCR || n == POSTINCR) ? 1 : -1;
744: if (n == PREINCR || n == PREDECR) {
745: setfval(x, xf + k);
746: return(x);
747: }
748: z = gettemp();
749: setfval(z, xf);
750: setfval(x, xf + k);
751: tempfree(x);
752: return(z);
753: }
754:
755: Cell *assign(a,n) Node **a;
756: {
757: register Cell *x, *y;
758: Awkfloat xf, yf;
759:
760: x = execute(a[0]);
761: y = execute(a[1]);
762: if (n == ASSIGN) { /* ordinary assignment */
763: if ((y->tval & (STR|NUM)) == (STR|NUM)) {
764: setsval(x, getsval(y));
765: x->fval = getfval(y);
766: x->tval |= NUM;
767: }
768: else if (y->tval & STR)
769: setsval(x, getsval(y));
770: else if (y->tval & NUM)
771: setfval(x, getfval(y));
772: tempfree(y);
773: return(x);
774: }
775: xf = getfval(x);
776: yf = getfval(y);
777: switch (n) {
778: case ADDEQ:
779: xf += yf;
780: break;
781: case SUBEQ:
782: xf -= yf;
783: break;
784: case MULTEQ:
785: xf *= yf;
786: break;
787: case DIVEQ:
788: if (yf == 0)
789: error(FATAL, "division by zero");
790: xf /= yf;
791: break;
792: case MODEQ:
793: if (yf == 0)
794: error(FATAL, "division by zero");
795: xf = xf - yf*(long)(xf/yf);
796: break;
797: case POWEQ:
798: xf = errcheck(pow(xf, yf), "pow");
799: break;
800: default:
801: error(FATAL, "illegal assignment operator %d", n);
802: break;
803: }
804: tempfree(y);
805: setfval(x, xf);
806: return(x);
807: }
808:
809: Cell *cat(a,q) Node **a;
810: {
811: register Cell *x, *y, *z;
812: register int n1, n2;
813: register char *s;
814:
815: x = execute(a[0]);
816: y = execute(a[1]);
817: getsval(x);
818: getsval(y);
819: n1 = strlen(x->sval);
820: n2 = strlen(y->sval);
821: s = (char *) Malloc(n1 + n2 + 1);
822: strcpy(s, x->sval);
823: strcpy(s+n1, y->sval);
824: tempfree(y);
825: z = gettemp();
826: z->sval = s;
827: z->tval = STR;
828: tempfree(x);
829: return(z);
830: }
831:
832: Cell *pastat(a,n) Node **a;
833: {
834: register Cell *x;
835:
836: if (a[0] == 0)
837: x = execute(a[1]);
838: else {
839: x = execute(a[0]);
840: if (istrue(x)) {
841: tempfree(x);
842: x = execute(a[1]);
843: }
844: }
845: return x;
846: }
847:
848: Cell *dopa2(a,n) Node **a;
849: {
850: register Cell *x;
851: register int pair;
852:
853: pair = (int) a[3];
854: if (pairstack[pair] == 0) {
855: x = execute(a[0]);
856: if (istrue(x))
857: pairstack[pair] = 1;
858: tempfree(x);
859: }
860: if (pairstack[pair] == 1) {
861: x = execute(a[1]);
862: if (istrue(x))
863: pairstack[pair] = 0;
864: tempfree(x);
865: x = execute(a[2]);
866: return(x);
867: }
868: return(false);
869: }
870:
871: Cell *split(a,nnn) Node **a;
872: {
873: Cell *x, *y, *ap;
874: register char *s;
875: register int sep;
876: char *t, temp, num[5], *fs;
877: int n, tempstat;
878:
879: y = execute(a[0]);
880: s = getsval(y);
881: if (a[2] == 0)
882: fs = *FS;
883: else {
884: x = execute(a[2]);
885: fs = getsval(x);
886: }
887: sep = *fs;
888: ap = execute(a[1]); /* array name */
889: freesymtab(ap);
890: dprintf("split: s=|%s|, a=%s, sep=|%s|\n", s, ap->nval, fs);
891: ap->tval &= ~STR;
892: ap->tval |= ARR;
893: ap->sval = (char *) makesymtab();
894:
895: n = 0;
896: if (*s != '\0' && strlen(fs) > 1) { /* reg expr */
897: extern char *patbeg;
898: extern int patlen;
899: static fa *pfa = NULL;
900: static char *prevfs = NULL;
901: if (pfa == NULL) { /* first time thru */
902: pfa = makedfa(reparse(fs), 1);
903: prevfs = tostring(fs);
904: } else if (strcmp(fs, prevfs) != 0) { /* new fa needed for new FS */
905: freefa(pfa);
906: Free(prevfs);
907: pfa = makedfa(reparse(fs), 1);
908: prevfs = tostring(fs);
909: }
910: if (nematch(pfa,s)) {
911: tempstat = pfa->initstat;
912: pfa->initstat = 2;
913: do {
914: n++;
915: sprintf(num, "%d", n);
916: temp = *patbeg;
917: *patbeg = '\0';
918: if (isnumber(s))
919: setsymtab(num, s, atof(s), STR|NUM, ap->sval);
920: else
921: setsymtab(num, s, 0.0, STR, ap->sval);
922: *patbeg = temp;
923: s = patbeg + patlen;
924: if ((*(patbeg+patlen-1) == 0) || (*s == 0)) {
925: n++;
926: sprintf(num, "%d", n);
927: setsymtab(num, "", 0.0, STR, ap->sval);
928: pfa->initstat = tempstat;
929: goto spdone;
930: }
931: } while(nematch(pfa,s));
932: }
933: n++;
934: sprintf(num, "%d", n);
935: if (isnumber(s))
936: setsymtab(num, s, atof(s), STR|NUM, ap->sval);
937: else
938: setsymtab(num, s, 0.0, STR, ap->sval);
939: } else if (sep == ' ') {
940: for (n = 0; ; ) {
941: while (*s == ' ' || *s == '\t' || *s == '\n')
942: s++;
943: if (*s == 0)
944: break;
945: n++;
946: t = s;
947: do
948: s++;
949: while (*s!=' ' && *s!='\t' && *s!='\n' && *s!='\0');
950: temp = *s;
951: *s = '\0';
952: sprintf(num, "%d", n);
953: if (isnumber(t))
954: setsymtab(num, t, atof(t), STR|NUM, ap->sval);
955: else
956: setsymtab(num, t, 0.0, STR, ap->sval);
957: *s = temp;
958: if (*s != 0)
959: s++;
960: }
961: } else if (*s != 0) {
962: for (;;) {
963: n++;
964: t = s;
965: while (*s != sep && *s != '\n' && *s != '\0')
966: s++;
967: temp = *s;
968: *s = '\0';
969: sprintf(num, "%d", n);
970: if (isnumber(t))
971: setsymtab(num, t, atof(t), STR|NUM, ap->sval);
972: else
973: setsymtab(num, t, 0.0, STR, ap->sval);
974: *s = temp;
975: if (*s++ == 0)
976: break;
977: }
978: }
979: spdone:
980: tempfree(ap);
981: tempfree(y);
982: if (a[2] != 0)
983: tempfree(x);
984: x = gettemp();
985: x->tval = NUM;
986: x->fval = n;
987: return(x);
988: }
989:
990: Cell *ifstat(a,n) Node **a;
991: {
992: register Cell *x;
993:
994: x = execute(a[0]);
995: if (istrue(x)) {
996: tempfree(x);
997: x = execute(a[1]);
998: }
999: else if (a[2] != 0) {
1000: tempfree(x);
1001: x = execute(a[2]);
1002: }
1003: return(x);
1004: }
1005:
1006: Cell *whilestat(a,n) Node **a;
1007: {
1008: register Cell *x;
1009:
1010: for (;;) {
1011: x = execute(a[0]);
1012: if (!istrue(x)) return(x);
1013: tempfree(x);
1014: x = execute(a[1]);
1015: if (isbreak(x)) {
1016: x = true;
1017: return(x);
1018: }
1019: if (isnext(x) || isexit(x) || isret(x))
1020: return(x);
1021: tempfree(x);
1022: }
1023: }
1024:
1025: Cell *forstat(a,n) Node **a;
1026: {
1027: register Cell *x;
1028:
1029: x = execute(a[0]);
1030: tempfree(x);
1031: for (;;) {
1032: if (a[1]!=0) {
1033: x = execute(a[1]);
1034: if (!istrue(x)) return(x);
1035: else tempfree(x);
1036: }
1037: x = execute(a[3]);
1038: if (isbreak(x)) { /* turn off break */
1039: x = true;
1040: return(x);
1041: }
1042: if (isnext(x) || isexit(x) || isret(x))
1043: return(x);
1044: tempfree(x);
1045: x = execute(a[2]);
1046: tempfree(x);
1047: }
1048: }
1049:
1050: int indepth = 0; /* depth of for (i in ...) statements */
1051:
1052: Cell *instat(a, n) Node **a;
1053: {
1054: register Cell *x, *vp, *arrayp, *cp, *ncp, **tp;
1055: int i;
1056:
1057: vp = execute(a[0]);
1058: arrayp = execute(a[1]);
1059: if (!isarr(arrayp))
1060: error(FATAL, "%s is not an array", arrayp->nval);
1061: tp = (Cell **) arrayp->sval;
1062: tempfree(arrayp);
1063: indepth++;
1064: for (i = 0; i < MAXSYM; i++) { /* this routine knows too much */
1065: for (cp = tp[i]; cp != NULL; cp = ncp) {
1066: setsval(vp, cp->nval);
1067: ncp = cp->cnext;
1068: x = execute(a[2]);
1069: if (isbreak(x)) {
1070: tempfree(vp);
1071: x = true;
1072: indepth--;
1073: return(x);
1074: }
1075: if (isnext(x) || isexit(x) || isret(x)) {
1076: tempfree(vp);
1077: indepth--;
1078: return(x);
1079: }
1080: tempfree(x);
1081: }
1082: }
1083: indepth--;
1084: }
1085:
1086: Cell *bltin(a,n) Node **a;
1087: {
1088: register Cell *x, *y;
1089: Awkfloat u;
1090: register int t;
1091:
1092: t = (int) a[0];
1093: x = execute(a[1]);
1094: switch (t) {
1095: case FLENGTH:
1096: u = (Awkfloat) strlen(getsval(x)); break;
1097: case FLOG:
1098: u = errcheck(log(getfval(x)), "log"); break;
1099: case FINT:
1100: u = (Awkfloat) (long) getfval(x); break;
1101: case FEXP:
1102: u = errcheck(exp(getfval(x)), "exp"); break;
1103: case FSQRT:
1104: u = errcheck(sqrt(getfval(x)), "sqrt"); break;
1105: case FSIN:
1106: u = sin(getfval(x)); break;
1107: case FCOS:
1108: u = cos(getfval(x)); break;
1109: case FATAN:
1110: y = execute(a[1]->nnext);
1111: u = atan2(getfval(x), getfval(y));
1112: tempfree(y);
1113: break;
1114: case FSYSTEM:
1115: fflush(stdout); /* in case something buffered already */
1116: u = (Awkfloat) system(getsval(x)) / 256;
1117: break;
1118: case FRAND:
1119: u = (Awkfloat) rand() / 32767.0; break; /* 2^31-1 better on some systems? */
1120: case FSRAND:
1121: if (x->tval & REC)
1122: u = (Awkfloat) srand(time(0));
1123: else
1124: u = (Awkfloat) srand((int)getfval(x));
1125: break;
1126: default:
1127: error(FATAL, "illegal function type %d", t); break;
1128: }
1129: tempfree(x);
1130: x = gettemp();
1131: setfval(x, u);
1132: return(x);
1133: }
1134:
1135: Cell *print(a,n) Node **a;
1136: {
1137: register Node *x;
1138: register Cell *y;
1139: FILE *fp;
1140:
1141: if (a[1] == 0)
1142: fp = stdout;
1143: else
1144: fp = redirect((int)a[1], a[2]);
1145: for (x=a[0]; x!=NULL; x=x->nnext) {
1146: y = execute(x);
1147: fputs(getsval(y), fp);
1148: tempfree(y);
1149: if (x->nnext == NULL)
1150: fputs(*ORS, fp);
1151: else
1152: fputs(*OFS, fp);
1153: }
1154: if (a[1] != 0)
1155: fflush(fp);
1156: return(true);
1157: }
1158:
1159: Cell *nullproc() {}
1160:
1161:
1162: #define FILENUM 15
1163: struct
1164: {
1165: FILE *fp;
1166: char *fname;
1167: int mode; /* '|', 'a', 'w' */
1168: int imode; /* GT, LE, ... */
1169: } files[FILENUM];
1170: FILE *popen();
1171:
1172: FILE *redirect(a, b)
1173: Node *b;
1174: {
1175: FILE *fp;
1176: Cell *x;
1177: char *fname;
1178:
1179: x = execute(b);
1180: fname = getsval(x);
1181: fp = openfile(a, fname);
1182: if (fp == NULL)
1183: error(FATAL, "can't open file %s", fname);
1184: tempfree(x);
1185: return fp;
1186: }
1187:
1188: FILE *openfile(a, s)
1189: char *s;
1190: {
1191: register int i;
1192:
1193: if (*s == '\0')
1194: error(FATAL, "null file name in print or getline");
1195: for (i=0; i < FILENUM; i++)
1196: if (strcmp(s, files[i].fname) == 0 && files[i].imode == a)
1197: return files[i].fp;
1198: for (i=0; i < FILENUM; i++)
1199: if (files[i].fp == 0)
1200: break;
1201: if (i >= FILENUM)
1202: error(FATAL, "%s makes too many open files", s);
1203: if (a == GT) {
1204: files[i].fp = fopen(s, "w");
1205: files[i].mode = 'w';
1206: } else if (a == APPEND) {
1207: files[i].fp = fopen(s, "a");
1208: files[i].mode = 'a';
1209: } else if (a == '|') { /* output pipe */
1210: files[i].fp = popen(s, "w");
1211: files[i].mode = '|';
1212: } else if (a == LE) { /* input pipe */
1213: files[i].fp = popen(s, "r");
1214: files[i].mode = LE;
1215: } else if (a == LT) { /* getline <file */
1216: files[i].fp = fopen(s, "r");
1217: files[i].mode = 'r';
1218: } else
1219: error(FATAL, "illegal redirection");
1220: if (files[i].fp != NULL)
1221: files[i].fname = tostring(s);
1222: files[i].imode = a;
1223: return files[i].fp;
1224: }
1225:
1226:
1227: Cell *closefile(a) Node **a;
1228: {
1229: register Cell *x;
1230: int i;
1231:
1232: x = execute(a[0]);
1233: getsval(x);
1234: for (i = 0; i < FILENUM; i++)
1235: if (strcmp(x->sval, files[i].fname) == 0) {
1236: if (files[i].mode == '|' || files[i].mode == LE)
1237: pclose(files[i].fp);
1238: else
1239: fclose(files[i].fp);
1240: xfree(files[i].fname);
1241: files[i].fname = NULL; /* watch out for ref thru this */
1242: files[i].fp = NULL;
1243: }
1244: return(x);
1245: }
1246:
1247: closeall()
1248: {
1249: int i;
1250:
1251: for (i = 0; i < FILENUM; i++)
1252: if (files[i].fp) {
1253: if (files[i].mode == '|' || files[i].mode == LE)
1254: pclose(files[i].fp);
1255: else
1256: fclose(files[i].fp);
1257: }
1258: }
1259:
1260: Cell *sub(a, nnn) Node **a;
1261: {
1262: register char *sptr, *pb, *q;
1263: register Cell *x, *y;
1264: char buf[RECSIZE], *t;
1265: fa *pfa;
1266:
1267: extern char *patbeg;
1268: extern int patlen;
1269: x = execute(a[3]); /* source string */
1270: t = getsval(x);
1271: if (a[0] == 0)
1272: pfa = (fa *) a[1]; /* regular expression */
1273: else {
1274: y = execute(a[1]);
1275: pfa = makedfa(reparse(getsval(y)), 1);
1276: tempfree(y);
1277: }
1278: if (pmatch(pfa, t)) {
1279: pb = buf;
1280: sptr = t;
1281: while (sptr < patbeg)
1282: *pb++ = *sptr++;
1283: y = execute(a[2]); /* replacement */
1284: sptr = getsval(y);
1285: while (*sptr != 0)
1286: if (*sptr == '\\' && *(sptr+1) == '&') {
1287: sptr++; /* skip \, */
1288: *pb++ = *sptr++; /* add & */
1289: } else if (*sptr == '&') {
1290: sptr++;
1291: for (q = patbeg; q < patbeg+patlen; )
1292: *pb++ = *q++;
1293: } else
1294: *pb++ = *sptr++;
1295: tempfree(y);
1296: sptr = patbeg + patlen;
1297: while (*pb++ = *sptr++)
1298: ;
1299: setsval(x, buf);
1300: tempfree(x);
1301: return (true);
1302: }
1303: tempfree(x);
1304: return (false);
1305: }
1306:
1307: Cell *gsub(a, nnn) Node **a;
1308: {
1309: register Cell *x, *y;
1310: register char *rptr, *sptr, *t, *pb;
1311: char buf[RECSIZE];
1312: register fa *pfa;
1313: int mflag, tempstat, num;
1314:
1315: extern char *patbeg;
1316: extern int patlen;
1317:
1318: mflag = 0;
1319: num = 0;
1320: x = execute(a[3]);
1321: t = getsval(x);
1322: if (a[0] == 0)
1323: pfa = (fa *) a[1];
1324: else {
1325: y = execute(a[1]);
1326: pfa = makedfa(reparse(getsval(y)), 1);
1327: tempfree(y);
1328: }
1329: if (pmatch(pfa, t)) {
1330: tempstat = pfa->initstat;
1331: pfa->initstat = 2;
1332: pb = buf;
1333: y = execute(a[2]);
1334: rptr = getsval(y);
1335: do {
1336: /*
1337: char *p;
1338: int i;
1339: printf("target string: %s, *patbeg = %c, patlen = %d\n", t, *patbeg, patlen);
1340: printf(" match found: ");
1341: p=patbeg;
1342: for (i=0; i<patlen; i++)
1343: printf("%c", *p++);
1344: printf("\n");
1345: */
1346: num++;
1347: if (patlen == 0) { /* matched empty string */
1348: if (mflag == 0) { /* can replace empty */
1349: sptr = rptr;
1350: while (*sptr != 0)
1351: if (*sptr == '\\' && *(sptr+1) == '&') {
1352: sptr++;
1353: *pb++ = *sptr++;
1354: } else if (*sptr == '&') {
1355: char *q;
1356: sptr++;
1357: for (q = patbeg; q < patbeg+patlen; )
1358: *pb++ = *q++;
1359: } else
1360: *pb++ = *sptr++;
1361: }
1362: *pb++ = *t;
1363: if (*t == 0) /* at end */
1364: goto done;
1365: t++;
1366: mflag = 0;
1367: }
1368: else { /* matched nonempty string */
1369: if (*t == 0) { /* matched $ */
1370: if (mflag == 0) { /* can replace empty */
1371: sptr = rptr;
1372: while (*sptr != 0)
1373: if (*sptr == '\\' && *(sptr+1) == '&') {
1374: sptr++;
1375: *pb++ = *sptr++;
1376: } else if (*sptr == '&') {
1377: char *q;
1378: sptr++;
1379: for (q = patbeg; q < patbeg+patlen; )
1380: *pb++ = *q++;
1381: } else
1382: *pb++ = *sptr++;
1383: }
1384: *pb++ = 0;
1385: goto done;
1386: }
1387: sptr = t;
1388: while (sptr < patbeg)
1389: *pb++ = *sptr++;
1390: sptr = rptr;
1391: while (*sptr != 0)
1392: if (*sptr == '\\' && *(sptr+1) == '&') {
1393: sptr++;
1394: *pb++ = *sptr++;
1395: } else if (*sptr == '&') {
1396: char *q;
1397: sptr++;
1398: for (q = patbeg; q < patbeg+patlen; )
1399: *pb++ = *q++;
1400: } else
1401: *pb++ = *sptr++;
1402: mflag = 1;
1403: t = patbeg + patlen;
1404: if (*t == 0) {
1405: *pb = 0;
1406: goto done;
1407: }
1408: }
1409: } while (pmatch(pfa,t));
1410: sptr = t;
1411: while (*pb++ = *sptr++)
1412: ;
1413: done: tempfree(y);
1414: setsval(x, buf);
1415: pfa->initstat = tempstat;
1416: }
1417: tempfree(x);
1418: x = gettemp();
1419: x->tval = NUM;
1420: x->fval = num;
1421: return(x);
1422: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.