![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to awk5.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / awk|
Return to awk5.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / awk |
1.1 ! root 1: /* ! 2: * Awk - internal execution functions. ! 3: */ ! 4: ! 5: #include "awk.h" ! 6: #include "y.tab.h" ! 7: ! 8: FILE *xoutput(); ! 9: ! 10: /* ! 11: * `print' directive. ! 12: * First argument is the NODE (or list) to print ! 13: * and the second is the output. ! 14: * Have to close pipes specially. ! 15: * The ALIST stuff should be generalised ! 16: * so that functions can get their arguments ! 17: * a little more easily. ! 18: */ ! 19: xprint(np, xp) ! 20: register NODE *np; ! 21: register NODE *xp; ! 22: { ! 23: register FILE *ofp; ! 24: ! 25: ofp = xoutput(xp); ! 26: while (np != NULL) { ! 27: if (np->n_op == ALIST) { ! 28: xp = np->n_O1; ! 29: np = np->n_O2; ! 30: } else { ! 31: xp = np; ! 32: np = NULL; ! 33: } ! 34: xp = evalexpr(xp); ! 35: if (xp->t_flag & T_NUM) { ! 36: if (xp->t_flag & T_INT) ! 37: fprintf(ofp, OFMT, xp->t_INT); else ! 38: fprintf(ofp, "%.6g", xp->t_FLOAT); ! 39: } else ! 40: fprintf(ofp, "%s", xp->t_STRING); ! 41: if (np != NULL) ! 42: fprintf(ofp, "%s", OFS); ! 43: } ! 44: fprintf(ofp, "%s", ORS); ! 45: fflush(ofp); ! 46: } ! 47: ! 48: /* ! 49: * `printf' directive. ! 50: * First argument is list, second ! 51: * is output. ! 52: * If third argument is non-NULL, ! 53: * it is used for sprintf rather than ! 54: * printf. ! 55: */ ! 56: xprintf(np, xp, sp) ! 57: NODE *np; ! 58: NODE *xp; ! 59: STRING sp; ! 60: { ! 61: NODE *nextarg(); ! 62: int *pflist; ! 63: register CHAR *cp; ! 64: register int *pflp; ! 65: register int c; ! 66: register int i; ! 67: register FILE *ofp; ! 68: ! 69: pflp = pflist = (int *)xalloc(fnargs(np) * sizeof(double)); ! 70: if (sp == NULL) ! 71: ofp = xoutput(xp); else ! 72: *sp = '\0'; ! 73: i = 1; ! 74: *((CHAR **)pflp) = cp = evalstring(nextarg(np, i++)); ! 75: bump(pflp, CHAR*); ! 76: for (;;) { ! 77: while ((c = *cp++)!='%' && c!='\0') ! 78: ; ! 79: if (c == '\0') ! 80: break; ! 81: if (*cp == '-') ! 82: cp++; ! 83: if (*cp == '*') { ! 84: *pflp++ = evalint(nextarg(np, i++)); ! 85: cp++; ! 86: } else ! 87: while (isdigit(*cp)) ! 88: cp++; ! 89: if (*cp == '.') { ! 90: cp++; ! 91: if (*cp == '*') { ! 92: *pflp++ = evalint(nextarg(np, i++)); ! 93: cp++; ! 94: } else ! 95: while (isdigit(*cp)) ! 96: cp++; ! 97: } ! 98: if ((c = *cp++) == 'l') ! 99: c = toupper(*cp++); ! 100: switch (c) { ! 101: case 'd': ! 102: case 'u': ! 103: case 'x': ! 104: case 'o': ! 105: *pflp++ = evalint(nextarg(np, i++)); ! 106: break; ! 107: ! 108: case 'D': ! 109: case 'U': ! 110: case 'X': ! 111: case 'O': ! 112: *((long *)pflp) = (long)evalint(nextarg(np, i++)); ! 113: bump(pflp, long); ! 114: break; ! 115: ! 116: case 'e': ! 117: case 'f': ! 118: case 'g': ! 119: *((double *)pflp) = (double)evalfloat(nextarg(np, i++)); ! 120: bump(pflp, double); ! 121: break; ! 122: ! 123: case 'c': ! 124: xp = evalexpr(nextarg(np, i++)); ! 125: if (xp->n_flag & T_NUM) ! 126: *pflp++ = evalint(xp); else ! 127: *pflp++ = *evalstring(xp); ! 128: break; ! 129: ! 130: case 's': ! 131: *((CHAR **)pflp) = evalstring(nextarg(np, i++)); ! 132: bump(pflp, CHAR*); ! 133: break; ! 134: ! 135: case 'r': ! 136: awkwarn("%%r not available in sprintf/printf"); ! 137: break; ! 138: } ! 139: } ! 140: if (sp == NULL) { ! 141: fprintf(ofp, "%r", pflist); ! 142: fflush(ofp); ! 143: } else ! 144: sprintf(sp, "%r", pflist); ! 145: free(pflist); ! 146: } ! 147: ! 148: /* ! 149: * Return the next argument for printf. ! 150: */ ! 151: static NODE * ! 152: nextarg(anp, n) ! 153: register NODE *anp; ! 154: register int n; ! 155: { ! 156: if ((anp = fargn(anp, n)) == NULL) ! 157: awkerr("Missing argument to printf/sprintf"); ! 158: return (anp); ! 159: } ! 160: ! 161: /* ! 162: * Calculate the output ! 163: * stream for print or printf. ! 164: * This saves up names so that they ! 165: * don't get re-opened every time. ! 166: */ ! 167: FILE * ! 168: xoutput(np) ! 169: register NODE *np; ! 170: { ! 171: register CHAR *s; ! 172: register OFILE *ofp; ! 173: register OFILE *ofslot; ! 174: ! 175: if (np == NULL) ! 176: return (stdout); ! 177: s = evalstring(np->n_O1); ! 178: ofslot = NULL; ! 179: for (ofp = files; ofp < endof(files); ofp++) ! 180: if (ofp->of_fp != NULL) { ! 181: if (strcmp(ofp->of_name, s) == 0) ! 182: return (ofp->of_fp); ! 183: } else ! 184: ofslot = ofp; ! 185: if ((ofp = ofslot) == NULL) ! 186: awkerr("Too many output files or pipes"); ! 187: ofp->of_flag = 0; ! 188: switch (np->n_op) { ! 189: case AFOUT: ! 190: if ((ofp->of_fp = fopen(s, "w")) == NULL) ! 191: awkerr("Cannot open output `%s'", s); ! 192: break; ! 193: ! 194: case AFAPP: ! 195: if ((ofp->of_fp = fopen(s, "a")) == NULL) ! 196: awkerr("Cannot open `%s' for append", s); ! 197: break; ! 198: ! 199: case AFPIPE: ! 200: #ifndef GEMDOS ! 201: if ((ofp->of_fp = popen(s, "w")) == NULL) ! 202: #endif ! 203: awkerr("Cannot create pipe to `%s'", s); ! 204: ofp->of_flag = OFPIPE; ! 205: break; ! 206: ! 207: default: ! 208: awkerr("Bad output tree op %d", np->n_op); ! 209: } ! 210: ofp->of_name = xalloc(strlen(s) + sizeof(CHAR)); ! 211: strcpy(ofp->of_name, s); ! 212: setbuf(ofp->of_fp, outbuf); ! 213: return (ofp->of_fp); ! 214: } ! 215: ! 216: /* ! 217: * Do the form: for (i in array) stat ! 218: * `var' is the index and `stat' the statement. ! 219: */ ! 220: xforin(var, array, stat) ! 221: NODE *var; ! 222: register NODE *array; ! 223: NODE *stat; ! 224: { ! 225: register CHAR *cp; ! 226: register TERM *tp; ! 227: register int i; ! 228: register int j; ! 229: ! 230: for (i=0; i<NHASH; i++) ! 231: for (tp = symtab[i]; tp != NULL; tp = tp->t_next) ! 232: if (tp->t_ahval==array->t_hval && tp->t_flag&T_ARRAY ! 233: && streq(tp->t_name, array->t_name)) { ! 234: if ((j = setjmp(fwenv[fwlevel])) == ABREAK) ! 235: break; ! 236: else if (j == ACONTIN) ! 237: continue; ! 238: cp = tp->t_name; ! 239: while (*cp++ != '\0') ! 240: ; ! 241: xassign(var, snode(cp, 0)); ! 242: evalact(stat); ! 243: } ! 244: } ! 245: ! 246: /* ! 247: * Return a node associated with ! 248: * an array element. ! 249: * `array' is the array identifier, ! 250: * and `index' is the index expression ! 251: * represented as a STRING. ! 252: */ ! 253: NODE * ! 254: xarray(array, index) ! 255: NODE *array; ! 256: NODE *index; ! 257: { ! 258: return (alookup(array->t_name, evalstring(index))); ! 259: } ! 260: ! 261: /* ! 262: * Extract the field given by the expression. ! 263: * A negative field number is ! 264: * considered to be from the end. ! 265: * The `asval' is non-NULL when ! 266: * the string is to be assigned to a field. ! 267: */ ! 268: NODE * ! 269: xfield(i, asval) ! 270: int i; ! 271: STRING asval; ! 272: { ! 273: CHAR *xfield1(); ! 274: register CHAR *as, *s1, *s2; ! 275: register int c, i1; ! 276: register unsigned nb; ! 277: ! 278: if ((s1 = inline) == NULL) { ! 279: awkwarn("field, $%d, illegal in BEGIN or END", i); ! 280: return (snode(SNULL, 0)); ! 281: } ! 282: if (i == 0) { ! 283: if (asval != NULL) { ! 284: inline = xalloc(strlen(asval)+sizeof(CHAR)); ! 285: strcpy(inline, asval); ! 286: } ! 287: return (snode(inline, 0)); ! 288: } ! 289: if (i < 0) ! 290: if ((i += (int)NF + 1) == 0) ! 291: i = -1; ! 292: ! 293: i1 = i; ! 294: if (whitesw) { ! 295: do { ! 296: while ((c = *s1) && FSMAP[c]) ! 297: s1++; ! 298: if (!c || --i==0) ! 299: break; ! 300: while ((c = *s1) && !FSMAP[c]) ! 301: s1++; ! 302: } while (c); ! 303: } else { ! 304: do { ! 305: if (!*s1 || --i==0) ! 306: break; ! 307: while ((c = *s1) && !FSMAP[c]) ! 308: s1++; ! 309: if (FSMAP[*s1]) ! 310: s1++; ! 311: } while (c); ! 312: } ! 313: s2 = s1; ! 314: nb = sizeof(CHAR); ! 315: while ((c = *s2++)!='\0' && !FSMAP[c]) ! 316: nb++; ! 317: s2--; ! 318: if (asval != NULL) { ! 319: /* ! 320: * An attempt to set an arg past the end. ! 321: */ ! 322: if(0 < (i1 -= evalint(NFp))) { ! 323: if (whitesw && (i1 > 1)) ! 324: awkwarn("Assignment to unbuildable field"); ! 325: /* remove trailing delimeters */ ! 326: while ((--s1 > inline) && FSMAP[*s1]) ! 327: ; ! 328: s2 = ++s1; ! 329: as = xalloc(strlen(asval) + i1 + 1); ! 330: strcpy(as + i1, asval); ! 331: memset(as, FS[0], i1); ! 332: ! 333: inline = xfield1(inline, s1, as, s2, s2); ! 334: free(as); ! 335: return (snode(inline, 0)); ! 336: } ! 337: inline = as = xfield1(inline, s1, asval, s2, s2+strlen(s2)); ! 338: return (snode(inline, 0)); ! 339: } else { ! 340: as = xalloc(nb); ! 341: while (s1 < s2) ! 342: *as++ = *s1++; ! 343: *as++ = '\0'; ! 344: as -= nb; ! 345: } ! 346: return (snode(as, T_ALLOC)); ! 347: } ! 348: ! 349: /* ! 350: * Assignment of fields support. ! 351: * The arguments are: ! 352: * `f1', `f2', `middle', `e1', `e2' ! 353: * for the front start and stop, the middle ! 354: * and the end start and stop, respectively. ! 355: */ ! 356: CHAR * ! 357: xfield1(f1, f2, middle, e1, e2) ! 358: CHAR *f1, *f2; ! 359: CHAR *middle; ! 360: CHAR *e1, *e2; ! 361: { ! 362: register CHAR *p1, *p2; ! 363: register CHAR *as; ! 364: ! 365: as = xalloc(f2-f1 + e2-e1 + strlen(middle) + sizeof(CHAR)); ! 366: p1 = as; ! 367: p2 = f1; ! 368: while (p2 < f2) ! 369: *p1++ = *p2++; ! 370: p2 = middle; ! 371: while (*p2 != '\0') ! 372: *p1++ = *p2++; ! 373: p2 = e1; ! 374: while (p2 < e2) ! 375: *p1++ = *p2++; ! 376: *p1 = '\0'; ! 377: return (as); ! 378: } ! 379: ! 380: /* ! 381: * String catenation in two nodes. ! 382: */ ! 383: NODE * ! 384: xconc(n1, n2) ! 385: register NODE *n1, *n2; ! 386: { ! 387: register CHAR *ap; ! 388: register CHAR *cp1, *cp2; ! 389: register int n; ! 390: ! 391: n = strlen(ap = evalstring(n1)) + sizeof(CHAR); ! 392: if ((n1->t_un.t_flag & T_NUM) == 0) { ! 393: cp1 = xalloc(n); ! 394: strcpy(cp1, ap); ! 395: } else ! 396: cp1 = ap; ! 397: n += strlen(cp2 = evalstring(n2)); ! 398: ap = xalloc(n); ! 399: strcpy(ap, cp1); ! 400: strcat(ap, cp2); ! 401: if ((n1->t_un.t_flag & T_NUM) == 0) ! 402: free(cp1); ! 403: return (snode(ap, T_ALLOC)); ! 404: } ! 405: ! 406: /* ! 407: * Arithmetic operations -- ! 408: * ! 409: * Numeric addition ! 410: */ ! 411: NODE * ! 412: xadd(n1, n2) ! 413: register NODE *n1, *n2; ! 414: { ! 415: if (isfloat(n1) || isfloat(n2)) ! 416: return (fnode(evalfloat(n1) + evalfloat(n2))); ! 417: return (inode(evalint(n1) + evalint(n2))); ! 418: } ! 419: ! 420: /* ! 421: * Subtraction -- actually a numeric operation. ! 422: */ ! 423: NODE * ! 424: xsub(n1, n2) ! 425: register NODE *n1, *n2; ! 426: { ! 427: if (isfloat(n1) || isfloat(n2)) ! 428: return (fnode(evalfloat(n1) - evalfloat(n2))); ! 429: return (inode(evalint(n1) - evalint(n2))); ! 430: } ! 431: ! 432: /* ! 433: * Multiplication ! 434: */ ! 435: NODE * ! 436: xmul(n1, n2) ! 437: register NODE *n1, *n2; ! 438: { ! 439: if (isfloat(n1) || isfloat(n2)) ! 440: return (fnode(evalfloat(n1) * evalfloat(n2))); ! 441: return (inode(evalint(n1) * evalint(n2))); ! 442: } ! 443: ! 444: /* ! 445: * Negation ! 446: */ ! 447: NODE * ! 448: xneg(n1) ! 449: register NODE *n1; ! 450: { ! 451: if (isfloat(n1)) ! 452: return (fnode(-evalfloat(n1))); ! 453: return (inode(-evalint(n1))); ! 454: } ! 455: ! 456: /* ! 457: * Division ! 458: * If either numeric is of internal FLOAT type, ! 459: * the division will be a float one, otherwise use ! 460: * INT division. ! 461: */ ! 462: NODE * ! 463: xdiv(n1, n2) ! 464: register NODE *n1, *n2; ! 465: { ! 466: if (isfloat(n1) || isfloat(n2)) ! 467: return (fnode(evalfloat(n1) / evalfloat(n2))); ! 468: return (inode(evalint(n1) / evalint(n2))); ! 469: } ! 470: ! 471: /* ! 472: * Modulus ! 473: * Same type conversion rule as for division. ! 474: */ ! 475: NODE * ! 476: xmod(n1, n2) ! 477: register NODE *n1, *n2; ! 478: { ! 479: if (isfloat(n1) || isfloat(n2)) ! 480: awkwarn("Modulus operator not allowed on floating point"); ! 481: return (inode(evalint(n1) % evalint(n2))); ! 482: } ! 483: ! 484: /* ! 485: * Comparison operators -- ! 486: * string or numeric comparison ! 487: * for equality or non-equality. ! 488: * The tricks come in conversions ! 489: * between FLOAT and INT. ! 490: * The nodes passed should not be evaluated ! 491: * beforehand so that checks for fields can ! 492: * be made as here fields are always considered ! 493: * as strings. ! 494: */ ! 495: NODE * ! 496: xcmp(n1, n2, op) ! 497: register NODE *n1, *n2; ! 498: int op; ! 499: { ! 500: register int result; ! 501: register int isnum = 0; ! 502: ! 503: if (n1->n_op != AFIELD) ! 504: isnum = isnumeric(n1 = evalexpr(n1)); ! 505: else ! 506: n1 = evalexpr(n1); ! 507: if (n2->n_op != AFIELD) ! 508: isnum |= isnumeric(n2 = evalexpr(n2)); ! 509: else ! 510: n2 = evalexpr(n2); ! 511: if (isnum) { ! 512: result = 0; ! 513: if (isfloat(n1) || isfloat(n2)) { ! 514: register FLOAT f1, f2; ! 515: ! 516: if ((f1 = evalfloat(n1)) > (f2 = evalfloat(n2))) ! 517: result++; ! 518: else if (f1 < f2) ! 519: result--; ! 520: } else { ! 521: register INT i1, i2; ! 522: ! 523: if ((i1 = evalint(n1)) > (i2 = evalint(n2))) ! 524: result++; ! 525: else if (i1 < i2) ! 526: result--; ! 527: } ! 528: } else if ((n1->t_flag & T_NUM)==0 && (n2->t_flag & T_NUM)==0) ! 529: result = strcmp(n1->t_STRING, n2->t_STRING); ! 530: else ! 531: result = strcmp(evalstring(n1), evalstring(n2)); ! 532: switch (op) { ! 533: case AEQ: ! 534: result = result==0; ! 535: break; ! 536: ! 537: case ANE: ! 538: result = result!=0; ! 539: break; ! 540: ! 541: case AGT: ! 542: result = result>0; ! 543: break; ! 544: ! 545: case AGE: ! 546: result = result>=0; ! 547: break; ! 548: ! 549: case ALT: ! 550: result = result<0; ! 551: break; ! 552: ! 553: case ALE: ! 554: result = result<=0; ! 555: break; ! 556: } ! 557: return (inode((INT)result)); ! 558: } ! 559: ! 560: /* ! 561: * Assignment ! 562: * The two nodes `l' and `r' are the left ! 563: * and right sides of the assignment, ! 564: * respectively. ! 565: */ ! 566: NODE * ! 567: xassign(l, r) ! 568: register NODE *l, *r; ! 569: { ! 570: if (l->t_op == AFIELD) ! 571: return (xfield((int)evalint(l->n_O1), evalstring(r))); ! 572: else if (l->t_op == AARRAY) ! 573: l = xarray(l->n_O1, l->n_O2); ! 574: if ((l->t_flag & (T_ALLOC|T_NUM)) == T_ALLOC) ! 575: free(l->t_STRING); ! 576: l->t_flag &= ~(T_INT|T_NUM); ! 577: l->t_flag |= T_ALLOC|(r->t_flag & (T_INT|T_NUM)); ! 578: if (r->t_flag & T_NUM) ! 579: if (r->t_flag & T_INT) ! 580: l->t_INT = r->t_INT; else ! 581: l->t_FLOAT = r->t_FLOAT; ! 582: else { ! 583: l->t_STRING = xalloc(strlen(r->t_STRING)+sizeof(CHAR)); ! 584: strcpy(l->t_STRING, r->t_STRING); ! 585: } ! 586: if (l == FSp) ! 587: fsmapinit(evalstring(l)); ! 588: return (l); ! 589: } ! 590: ! 591: /* ! 592: * Post increment -- return the old ! 593: * value before the increment of the ! 594: * node. ! 595: */ ! 596: NODE * ! 597: xinca(np) ! 598: register NODE *np; ! 599: { ! 600: register NODE *rnp; ! 601: register NODE *enp; ! 602: ! 603: enp = evalexpr(np); ! 604: rnp = inode((INT)0); ! 605: xassign(rnp, enp); ! 606: xassign(np, xadd(enp, &xone)); ! 607: return (rnp); ! 608: } ! 609: ! 610: /* ! 611: * Post decrement -- return the old value ! 612: * but increment the variable. ! 613: */ ! 614: NODE * ! 615: xdeca(np) ! 616: register NODE *np; ! 617: { ! 618: register NODE *rnp; ! 619: register NODE *enp; ! 620: ! 621: enp = evalexpr(np); ! 622: rnp = inode((INT)0); ! 623: xassign(rnp, enp); ! 624: xassign(np, xsub(enp, &xone)); ! 625: return (rnp); ! 626: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.