![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sh.lex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / cmd / oldcsh|
Return to sh.lex.c CVS log | Up to [CSRG BSD Unix] / 41BSD / cmd / oldcsh |
1.1 ! root 1: /* Copyright (c) 1979 Regents of the University of California */ ! 2: #include "sh.h" ! 3: ! 4: /* ! 5: * C shell ! 6: */ ! 7: ! 8: /* ! 9: * These lexical routines read input and form lists of words. ! 10: * There is some involved processing here, because of the complications ! 11: * of input buffering, and especially because of history substitution. ! 12: */ ! 13: ! 14: char *word(); ! 15: ! 16: /* ! 17: * Peekc is a peek characer for getC, peekread for readc. ! 18: * There is a subtlety here in many places... history routines ! 19: * will read ahead and then insert stuff into the input stream. ! 20: * If they push back a character then they must push it behind ! 21: * the text substituted by the history substitution. On the other ! 22: * hand in several places we need 2 peek characters. To make this ! 23: * all work, the history routines read with getC, and make use both ! 24: * of ungetC and unreadc. The key observation is that the state ! 25: * of getC at the call of a history reference is such that calls ! 26: * to getC from the history routines will always yield calls of ! 27: * readc, unless this peeking is involved. That is to say that during ! 28: * getexcl the variables lap, exclp, and exclnxt are all zero. ! 29: * ! 30: * Getdol invokes history substitution, hence the extra peek, peekd, ! 31: * which it can ungetD to be before history substitutions. ! 32: */ ! 33: char peekc, peekd; ! 34: char peekread; ! 35: ! 36: char *exclp; /* (Tail of) current word from ! subst */ ! 37: struct wordent *exclnxt; /* The rest of the ! subst words */ ! 38: int exclc; /* Count of remainig words in ! subst */ ! 39: char *alvecp; /* "Globp" for alias resubstitution */ ! 40: ! 41: /* ! 42: * Lex returns to its caller not only a wordlist (as a "var" parameter) ! 43: * but also whether a history substitution occurred. This is used in ! 44: * the main (process) routine to determine whether to echo, and also ! 45: * when called by the alias routine to determine whether to keep the ! 46: * argument list. ! 47: */ ! 48: bool hadhist; ! 49: ! 50: #define ungetC(c) peekc = c ! 51: #define ungetD(c) peekd = c ! 52: ! 53: lex(hp) ! 54: register struct wordent *hp; ! 55: { ! 56: register struct wordent *wdp; ! 57: int c; ! 58: ! 59: lineloc = btell(); ! 60: hp->next = hp->prev = hp; ! 61: hp->word = ""; ! 62: alvecp = 0, hadhist = 0; ! 63: do ! 64: c = readc(0); ! 65: while (c == ' ' || c == '\t'); ! 66: if (c == '^' && intty) ! 67: /* ^lef^rit from tty is short !:s^lef^rit */ ! 68: getexcl(c); ! 69: else ! 70: unreadc(c); ! 71: wdp = hp; ! 72: /* ! 73: * The following loop is written so that the links needed ! 74: * by freelex will be ready and rarin to go even if it is ! 75: * interrupted. ! 76: */ ! 77: do { ! 78: register struct wordent *new = (struct wordent *) calloc(1, sizeof *wdp); ! 79: ! 80: new->prev = wdp; ! 81: new->next = hp; ! 82: wdp->next = new; ! 83: wdp = new; ! 84: wdp->word = word(); ! 85: } while (wdp->word[0] != '\n'); ! 86: hp->prev = wdp; ! 87: return (hadhist); ! 88: } ! 89: ! 90: prlex(sp0) ! 91: struct wordent *sp0; ! 92: { ! 93: register struct wordent *sp = sp0->next; ! 94: ! 95: for (;;) { ! 96: printf("%s", sp->word); ! 97: sp = sp->next; ! 98: if (sp == sp0) ! 99: break; ! 100: printf(" "); ! 101: } ! 102: } ! 103: ! 104: copylex(hp, fp) ! 105: register struct wordent *hp; ! 106: struct wordent *fp; ! 107: { ! 108: register struct wordent *wdp; ! 109: ! 110: wdp = hp; ! 111: fp = fp->next; ! 112: do { ! 113: register struct wordent *new = (struct wordent *) calloc(1, sizeof *wdp); ! 114: ! 115: new->prev = wdp; ! 116: new->next = hp; ! 117: wdp->next = new; ! 118: wdp = new; ! 119: wdp->word = savestr(fp->word); ! 120: fp = fp->next; ! 121: } while (wdp->word[0] != '\n'); ! 122: hp->prev = wdp; ! 123: } ! 124: ! 125: freelex(vp) ! 126: register struct wordent *vp; ! 127: { ! 128: register struct wordent *fp; ! 129: ! 130: while (vp->next != vp) { ! 131: fp = vp->next; ! 132: vp->next = fp->next; ! 133: xfree(fp->word); ! 134: xfree(fp); ! 135: } ! 136: vp->prev = vp; ! 137: } ! 138: ! 139: char *WORDMETA = "# '`\"\t;&<>()|\n"; ! 140: ! 141: char * ! 142: word() ! 143: { ! 144: register char c, c1; ! 145: register char *wp; ! 146: char wbuf[BUFSIZ]; ! 147: register bool dolflg; ! 148: register int i; ! 149: ! 150: wp = wbuf; ! 151: i = BUFSIZ - 4; ! 152: loop: ! 153: c = getC(DOALL); ! 154: switch (c) { ! 155: ! 156: case ' ': ! 157: case '\t': ! 158: goto loop; ! 159: ! 160: case '`': ! 161: case '\'': ! 162: case '"': ! 163: *wp++ = c, --i, c1 = c; ! 164: dolflg = c == '"' ? DOALL : DOEXCL; ! 165: for (;;) { ! 166: c = getC(dolflg); ! 167: if (c == c1) ! 168: break; ! 169: if (c == '\n') { ! 170: seterrc("Unmatched ", c1); ! 171: ungetC(c); ! 172: goto ret; ! 173: } ! 174: if (c == '\\') { ! 175: c = getC(0); ! 176: if (c == '!') ! 177: c |= QUOTE; ! 178: else { ! 179: if (c == '\n' && c1 != '`') ! 180: c |= QUOTE; ! 181: ungetC(c), c = '\\'; ! 182: } ! 183: } ! 184: if (--i <= 0) ! 185: goto toochars; ! 186: *wp++ = c; ! 187: } ! 188: *wp++ = c, --i; ! 189: goto pack; ! 190: ! 191: case '&': ! 192: case '|': ! 193: case '<': ! 194: case '>': ! 195: *wp++ = c; ! 196: c1 = getC(DOALL); ! 197: if (c1 == c) ! 198: *wp++ = c1; ! 199: else ! 200: ungetC(c1); ! 201: goto ret; ! 202: ! 203: case '#': ! 204: if (intty) ! 205: break; ! 206: if (wp != wbuf) { ! 207: ungetC(c); ! 208: goto ret; ! 209: } ! 210: c = 0; ! 211: do { ! 212: c1 = c; ! 213: c = getC(0); ! 214: } while (c != '\n'); ! 215: if (c1 == '\\') ! 216: goto loop; ! 217: /* fall into ... */ ! 218: ! 219: case ';': ! 220: case '(': ! 221: case ')': ! 222: case '\n': ! 223: *wp++ = c; ! 224: goto ret; ! 225: ! 226: casebksl: ! 227: case '\\': ! 228: c = getC(0); ! 229: if (c == '\n') { ! 230: if (onelflg == 1) ! 231: onelflg = 2; ! 232: goto loop; ! 233: } ! 234: if (c != '!') ! 235: *wp++ = '\\', --i; ! 236: c |= QUOTE; ! 237: break; ! 238: } ! 239: ungetC(c); ! 240: pack: ! 241: for (;;) { ! 242: c = getC(DOALL); ! 243: if (c == '\\') { ! 244: c = getC(0); ! 245: if (c == '\n') { ! 246: if (onelflg == 1) ! 247: onelflg = 2; ! 248: goto ret; ! 249: } ! 250: if (c != '!') ! 251: *wp++ = '\\', --i; ! 252: c |= QUOTE; ! 253: } ! 254: if (any(c, WORDMETA + intty)) { ! 255: ungetC(c); ! 256: if (any(c, "\"'`")) ! 257: goto loop; ! 258: goto ret; ! 259: } ! 260: if (--i <= 0) ! 261: goto toochars; ! 262: *wp++ = c; ! 263: } ! 264: toochars: ! 265: seterr("Word too long"); ! 266: wp = &wbuf[1]; ! 267: ret: ! 268: *wp = 0; ! 269: return (savestr(wbuf)); ! 270: } ! 271: ! 272: getC(flag) ! 273: register int flag; ! 274: { ! 275: register char c; ! 276: ! 277: top: ! 278: if (c = peekc) { ! 279: peekc = 0; ! 280: return (c); ! 281: } ! 282: if (lap) { ! 283: c = *lap++; ! 284: if (c == 0) { ! 285: lap = 0; ! 286: goto top; ! 287: } ! 288: if (any(c, WORDMETA + intty)) ! 289: c |= QUOTE; ! 290: return (c); ! 291: } ! 292: if (c = peekd) { ! 293: peekd = 0; ! 294: return (c); ! 295: } ! 296: if (exclp) { ! 297: if (c = *exclp++) ! 298: return (c); ! 299: if (exclnxt && --exclc >= 0) { ! 300: exclnxt = exclnxt->next; ! 301: setexclp(exclnxt->word); ! 302: return (' '); ! 303: } ! 304: exclp = 0; ! 305: exclnxt = 0; ! 306: } ! 307: if (exclnxt) { ! 308: exclnxt = exclnxt->next; ! 309: if (--exclc < 0) ! 310: exclnxt = 0; ! 311: else ! 312: setexclp(exclnxt->word); ! 313: goto top; ! 314: } ! 315: c = readc(0); ! 316: if (c == '$' && (flag & DODOL)) { ! 317: getdol(); ! 318: goto top; ! 319: } ! 320: if (c == '!' && (flag & DOEXCL)) { ! 321: getexcl(0); ! 322: goto top; ! 323: } ! 324: return (c); ! 325: } ! 326: ! 327: getdol() ! 328: { ! 329: register char *np; ! 330: char name[40]; ! 331: register int c; ! 332: int sc; ! 333: bool special = 0; ! 334: ! 335: np = name, *np++ = '$'; ! 336: c = sc = getC(DOEXCL); ! 337: if (any(c, "\t \n")) { ! 338: ungetD(c); ! 339: ungetC('$' | QUOTE); ! 340: return; ! 341: } ! 342: if (c == '{') ! 343: *np++ = c, c = getC(DOEXCL); ! 344: if (c == '#' || c == '?') ! 345: special++, *np++ = c, c = getC(DOEXCL); ! 346: *np++ = c; ! 347: switch (c) { ! 348: ! 349: case '$': ! 350: if (special) ! 351: goto vsyn; ! 352: goto ret; ! 353: ! 354: case '\n': ! 355: ungetD(c); ! 356: np--; ! 357: goto vsyn; ! 358: ! 359: case '*': ! 360: if (special) ! 361: goto vsyn; ! 362: goto ret; ! 363: ! 364: default: ! 365: if (digit(c)) { ! 366: /* ! 367: * let $?0 pass for now ! 368: if (special) ! 369: goto vsyn; ! 370: */ ! 371: while (digit(c = getC(DOEXCL))) { ! 372: if (np < &name[sizeof name / 2]) ! 373: *np++ = c; ! 374: } ! 375: } else if (letter(c)) ! 376: while (letter(c = getC(DOEXCL))) { ! 377: if (np < &name[sizeof name / 2]) ! 378: *np++ = c; ! 379: } ! 380: else ! 381: goto vsyn; ! 382: } ! 383: if (c == '[') { ! 384: *np++ = c; ! 385: do { ! 386: c = getC(DOEXCL); ! 387: if (c == '\n') { ! 388: ungetD(c); ! 389: np--; ! 390: goto vsyn; ! 391: } ! 392: if (np >= &name[sizeof name - 8]) ! 393: goto vsyn; ! 394: *np++ = c; ! 395: } while (c != ']'); ! 396: c = getC(DOEXCL); ! 397: } ! 398: if (c == ':') { ! 399: *np++ = c, c = getC(DOEXCL); ! 400: if (c == 'g') ! 401: *np++ = c, c = getC(DOEXCL); ! 402: *np++ = c; ! 403: if (!any(c, "htrqx")) ! 404: goto vsyn; ! 405: } else ! 406: ungetD(c); ! 407: if (sc == '{') { ! 408: c = getC(DOEXCL); ! 409: if (c != '}') { ! 410: ungetC(c); ! 411: goto vsyn; ! 412: } ! 413: *np++ = c; ! 414: } ! 415: ret: ! 416: *np = 0; ! 417: addla(name); ! 418: return; ! 419: ! 420: vsyn: ! 421: seterr("Variable syntax"); ! 422: goto ret; ! 423: } ! 424: ! 425: addla(cp) ! 426: char *cp; ! 427: { ! 428: char buf[BUFSIZ]; ! 429: ! 430: if (lap != 0 && strlen(cp) + strlen(lap) >= BUFSIZ - 4) { ! 431: seterr("Expansion buf ovflo"); ! 432: return; ! 433: } ! 434: if (lap) ! 435: strcpy(buf, lap); ! 436: strcpy(labuf, cp); ! 437: if (lap) ! 438: strcat(labuf, buf); ! 439: lap = labuf; ! 440: } ! 441: ! 442: char lhsb[32]; ! 443: char slhs[32]; ! 444: char rhsb[64]; ! 445: int quesarg; ! 446: ! 447: getexcl(sc) ! 448: char sc; ! 449: { ! 450: register struct wordent *hp, *ip; ! 451: int left, right, dol; ! 452: register int c; ! 453: ! 454: if (sc == 0) { ! 455: sc = getC(0); ! 456: if (sc != '{') { ! 457: ungetC(sc); ! 458: sc = 0; ! 459: } ! 460: } ! 461: quesarg = -1; ! 462: lastev = eventno; ! 463: hp = gethent(sc); ! 464: if (hp == 0) ! 465: return; ! 466: hadhist = 1; ! 467: dol = 0; ! 468: if (hp == alhistp) ! 469: for (ip = hp->next->next; ip != alhistt; ip = ip->next) ! 470: dol++; ! 471: else ! 472: for (ip = hp->next->next; ip != hp->prev; ip = ip->next) ! 473: dol++; ! 474: left = 0, right = dol; ! 475: if (sc == '^') { ! 476: ungetC('s'), unreadc('^'), c = ':'; ! 477: goto subst; ! 478: } ! 479: c = getC(0); ! 480: if (!any(c, ":^$*-%")) ! 481: goto subst; ! 482: left = right = -1; ! 483: if (c == ':') { ! 484: c = getC(0); ! 485: unreadc(c); ! 486: if (letter(c) || c == '&') { ! 487: c = ':'; ! 488: left = 0, right = dol; ! 489: goto subst; ! 490: } ! 491: } else ! 492: ungetC(c); ! 493: if (!getsel(&left, &right, dol)) ! 494: return; ! 495: c = getC(0); ! 496: if (c == '*') ! 497: ungetC(c), c = '-'; ! 498: if (c == '-') { ! 499: if (!getsel(&left, &right, dol)) ! 500: return; ! 501: c = getC(0); ! 502: } ! 503: subst: ! 504: exclc = right - left + 1; ! 505: while (--left >= 0) ! 506: hp = hp->next; ! 507: if (sc == '^' || c == ':') { ! 508: do { ! 509: hp = getsub(hp); ! 510: c = getC(0); ! 511: } while (c == ':'); ! 512: } ! 513: unreadc(c); ! 514: if (sc == '{') { ! 515: c = getC(0); ! 516: if (c != '}') ! 517: seterr("Bad ! form"); ! 518: } ! 519: exclnxt = hp; ! 520: } ! 521: ! 522: struct wordent * ! 523: getsub(en) ! 524: struct wordent *en; ! 525: { ! 526: register char *cp; ! 527: int delim; ! 528: register int c; ! 529: int sc; ! 530: bool global = 0; ! 531: char orhsb[sizeof rhsb]; ! 532: ! 533: exclnxt = 0; ! 534: sc = c = getC(0); ! 535: if (c == 'g') ! 536: global++, c = getC(0); ! 537: switch (c) { ! 538: ! 539: case 'p': ! 540: justpr++; ! 541: goto ret; ! 542: ! 543: case 'x': ! 544: case 'q': ! 545: global++; ! 546: /* fall into ... */ ! 547: ! 548: case 'h': ! 549: case 'r': ! 550: case 't': ! 551: break; ! 552: ! 553: case '&': ! 554: if (slhs[0] == 0) { ! 555: seterr("No prev sub"); ! 556: goto ret; ! 557: } ! 558: strcpy(lhsb, slhs); ! 559: break; ! 560: ! 561: /* ! 562: case '~': ! 563: if (lhsb[0] == 0) ! 564: goto badlhs; ! 565: break; ! 566: */ ! 567: ! 568: case 's': ! 569: delim = getC(0); ! 570: if (letter(delim) || digit(delim) || any(delim, " \t\n")) { ! 571: unreadc(delim); ! 572: bads: ! 573: lhsb[0] = 0; ! 574: seterr("Bad substitute"); ! 575: goto ret; ! 576: } ! 577: cp = lhsb; ! 578: for (;;) { ! 579: c = getC(0); ! 580: if (c == '\n') { ! 581: unreadc(c); ! 582: goto bads; ! 583: } ! 584: if (c == delim) ! 585: break; ! 586: if (cp > &lhsb[sizeof lhsb - 2]) ! 587: goto bads; ! 588: if (c == '\\') { ! 589: c = getC(0); ! 590: if (c != delim && c != '\\') ! 591: *cp++ = '\\'; ! 592: } ! 593: *cp++ = c; ! 594: } ! 595: if (cp != lhsb) ! 596: *cp++ = 0; ! 597: else if (lhsb[0] == 0) { ! 598: badlhs: ! 599: seterr("No prev lhs"); ! 600: goto ret; ! 601: } ! 602: cp = rhsb; ! 603: strcpy(orhsb, cp); ! 604: for (;;) { ! 605: c = getC(0); ! 606: if (c == '\n') { ! 607: unreadc(c); ! 608: break; ! 609: } ! 610: if (c == delim) ! 611: break; ! 612: /* ! 613: if (c == '~') { ! 614: if (&cp[strlen(orhsb)] > &rhsb[sizeof rhsb - 2]) ! 615: goto toorhs; ! 616: cp = strend(strcpy(cp, orhsb)); ! 617: continue; ! 618: } ! 619: */ ! 620: if (cp > &rhsb[sizeof rhsb - 2]) { ! 621: toorhs: ! 622: seterr("Rhs too long"); ! 623: goto ret; ! 624: } ! 625: if (c == '\\') { ! 626: c = getC(0); ! 627: if (c != delim /* && c != '~' */) ! 628: *cp++ = '\\'; ! 629: } ! 630: *cp++ = c; ! 631: } ! 632: *cp++ = 0; ! 633: break; ! 634: ! 635: default: ! 636: if (c == '\n') ! 637: unreadc(c); ! 638: seterrc("Bad ! modifier: ", c); ! 639: goto ret; ! 640: } ! 641: strcpy(slhs, lhsb); ! 642: if (exclc) ! 643: en = dosub(sc, en, global); ! 644: ret: ! 645: return (en); ! 646: } ! 647: ! 648: struct wordent * ! 649: dosub(sc, en, global) ! 650: int sc; ! 651: struct wordent *en; ! 652: bool global; ! 653: { ! 654: struct wordent lex; ! 655: bool didsub = 0; ! 656: struct wordent *hp = &lex; ! 657: register struct wordent *wdp; ! 658: register int i = exclc; ! 659: ! 660: wdp = hp; ! 661: while (--i >= 0) { ! 662: register struct wordent *new = (struct wordent *) calloc(1, sizeof *wdp); ! 663: ! 664: new->prev = wdp; ! 665: new->next = hp; ! 666: wdp->next = new; ! 667: wdp = new; ! 668: en = en->next; ! 669: wdp->word = global || didsub == 0 ? ! 670: subword(en->word, sc, &didsub) : savestr(en->word); ! 671: } ! 672: if (didsub == 0) ! 673: seterr("Modifier failed"); ! 674: hp->prev = wdp; ! 675: return (&enthist(-1000, &lex, 0)->Hlex); ! 676: } ! 677: ! 678: char * ! 679: subword(cp, type, adid) ! 680: char *cp; ! 681: int type; ! 682: bool *adid; ! 683: { ! 684: char wbuf[BUFSIZ]; ! 685: register char *wp, *mp, *np; ! 686: register int i; ! 687: ! 688: switch (type) { ! 689: ! 690: case 'r': ! 691: case 'h': ! 692: case 't': ! 693: case 'q': ! 694: case 'x': ! 695: wp = domod(cp, type); ! 696: if (wp == 0) ! 697: return (savestr(cp)); ! 698: *adid = 1; ! 699: return (wp); ! 700: ! 701: default: ! 702: wp = wbuf; ! 703: i = BUFSIZ - 4; ! 704: for (mp = cp; *mp; mp++) ! 705: if (matchs(mp, lhsb)) { ! 706: for (np = cp; np < mp;) ! 707: *wp++ = *np++, --i; ! 708: for (np = rhsb; *np; np++) switch (*np) { ! 709: ! 710: case '\\': ! 711: if (np[1] == '&') ! 712: np++; ! 713: /* fall into ... */ ! 714: ! 715: default: ! 716: if (--i < 0) ! 717: goto ovflo; ! 718: *wp++ = *np; ! 719: continue; ! 720: ! 721: case '&': ! 722: i -= strlen(lhsb); ! 723: if (i < 0) ! 724: goto ovflo; ! 725: *wp = 0; ! 726: strcat(wp, lhsb); ! 727: wp = strend(wp); ! 728: continue; ! 729: } ! 730: mp += strlen(lhsb); ! 731: i -= strlen(mp); ! 732: if (i < 0) { ! 733: ovflo: ! 734: seterr("Subst buf ovflo"); ! 735: return (""); ! 736: } ! 737: *wp = 0; ! 738: strcat(wp, mp); ! 739: *adid = 1; ! 740: return (savestr(wbuf)); ! 741: } ! 742: return (savestr(cp)); ! 743: } ! 744: } ! 745: ! 746: char * ! 747: domod(cp, type) ! 748: char *cp; ! 749: int type; ! 750: { ! 751: register char *wp, *xp; ! 752: register int c; ! 753: ! 754: switch (type) { ! 755: ! 756: case 'x': ! 757: case 'q': ! 758: wp = savestr(cp); ! 759: for (xp = wp; c = *xp; xp++) ! 760: if ((c != ' ' && c != '\t') || type == 'q') ! 761: *xp |= QUOTE; ! 762: return (wp); ! 763: ! 764: case 'h': ! 765: case 't': ! 766: if (!any('/', cp)) ! 767: return (0); ! 768: wp = strend(cp); ! 769: while (*--wp != '/') ! 770: continue; ! 771: if (type == 'h') ! 772: take: ! 773: xp = savestr(cp), xp[wp - cp] = 0; ! 774: else ! 775: xp = savestr(wp + 1); ! 776: return (xp); ! 777: ! 778: case 'r': ! 779: wp = strend(cp); ! 780: for (wp--; wp >= cp && *wp != '.'; wp--) ! 781: if (*wp == '/') ! 782: return (0); ! 783: if (wp < cp) ! 784: return (0); ! 785: goto take; ! 786: } ! 787: return (0); ! 788: } ! 789: ! 790: matchs(str, pat) ! 791: register char *str, *pat; ! 792: { ! 793: ! 794: while (*str && *pat && *str == *pat) ! 795: str++, pat++; ! 796: return (*pat == 0); ! 797: } ! 798: ! 799: getsel(al, ar, dol) ! 800: register int *al, *ar; ! 801: int dol; ! 802: { ! 803: register int c = getC(0); ! 804: register int i; ! 805: bool first = *al < 0; ! 806: ! 807: switch (c) { ! 808: ! 809: case '%': ! 810: if (quesarg == -1) ! 811: goto bad; ! 812: if (*al < 0) ! 813: *al = quesarg; ! 814: *ar = quesarg; ! 815: break; ! 816: ! 817: case '-': ! 818: if (*al < 0) { ! 819: *al = 0; ! 820: *ar = dol - 1; ! 821: unreadc(c); ! 822: } ! 823: return (1); ! 824: ! 825: case '^': ! 826: if (*al < 0) ! 827: *al = 1; ! 828: *ar = 1; ! 829: break; ! 830: ! 831: case '$': ! 832: if (*al < 0) ! 833: *al = dol; ! 834: *ar = dol; ! 835: break; ! 836: ! 837: case '*': ! 838: if (*al < 0) ! 839: *al = 1; ! 840: *ar = dol; ! 841: if (*ar < *al) { ! 842: *ar = 0; ! 843: *al = 1; ! 844: return (1); ! 845: } ! 846: break; ! 847: ! 848: default: ! 849: if (digit(c)) { ! 850: i = 0; ! 851: while (digit(c)) { ! 852: i = i * 10 + c - '0'; ! 853: c = getC(0); ! 854: } ! 855: if (i < 0) ! 856: i = dol + 1; ! 857: if (*al < 0) ! 858: *al = i; ! 859: *ar = i; ! 860: } else ! 861: if (*al < 0) ! 862: *al = 0, *ar = dol; ! 863: else ! 864: *ar = dol - 1; ! 865: unreadc(c); ! 866: break; ! 867: } ! 868: if (first) { ! 869: c = getC(0); ! 870: unreadc(c); ! 871: if (any(c, "-$*")) ! 872: return (1); ! 873: } ! 874: if (*al > *ar || *ar > dol) { ! 875: bad: ! 876: seterr("Bad ! arg selector"); ! 877: return (0); ! 878: } ! 879: return (1); ! 880: } ! 881: ! 882: struct wordent * ! 883: gethent(sc) ! 884: int sc; ! 885: { ! 886: register struct Hist *hp; ! 887: register char *np; ! 888: register int c; ! 889: int event; ! 890: bool back = 0; ! 891: ! 892: c = sc == '^' ? '!' : getC(0); ! 893: switch (c) { ! 894: ! 895: case ':': ! 896: case '^': ! 897: case '$': ! 898: case '*': ! 899: case '%': ! 900: ungetC(c); ! 901: if (lastev == eventno && alhistp) ! 902: return (alhistp); ! 903: event = lastev; ! 904: break; ! 905: ! 906: case '!': ! 907: event = eventno; ! 908: break; ! 909: ! 910: case '-': ! 911: back = 1; ! 912: c = getC(0); ! 913: goto number; ! 914: ! 915: default: ! 916: if (any(c, "(=")) { ! 917: unreadc(c); ! 918: ungetC('!'); ! 919: return (0); ! 920: } ! 921: if (digit(c)) ! 922: goto number; ! 923: np = lhsb; ! 924: while (!any(c, ": \t\\\n}")) { ! 925: if (np < &lhsb[sizeof lhsb - 2]) ! 926: *np++ = c; ! 927: c = getC(0); ! 928: } ! 929: unreadc(c); ! 930: if (np == lhsb) { ! 931: ungetC('!'); ! 932: return (0); ! 933: } ! 934: *np++ = 0; ! 935: hp = findev(lhsb, 0); ! 936: if (hp) ! 937: lastev = hp->Hnum; ! 938: return (&hp->Hlex); ! 939: ! 940: case '?': ! 941: np = lhsb; ! 942: for (;;) { ! 943: c = getC(0); ! 944: if (c == '\n') { ! 945: unreadc(c); ! 946: break; ! 947: } ! 948: if (c == '?') ! 949: break; ! 950: if (np < &lhsb[sizeof lhsb - 2]) ! 951: *np++ = c; ! 952: } ! 953: if (np == lhsb) { ! 954: if (lhsb[0] == 0) { ! 955: seterr("No prev search"); ! 956: return (0); ! 957: } ! 958: } else ! 959: *np++ = 0; ! 960: hp = findev(lhsb, 1); ! 961: if (hp) ! 962: lastev = hp->Hnum; ! 963: return (&hp->Hlex); ! 964: ! 965: number: ! 966: event = 0; ! 967: while (digit(c)) { ! 968: event = event * 10 + c - '0'; ! 969: c = getC(0); ! 970: } ! 971: if (back) ! 972: event = eventno + (alhistp == 0) - (event ? event : 0); ! 973: unreadc(c); ! 974: break; ! 975: } ! 976: for (hp = Histlist.Hnext; hp; hp = hp->Hnext) ! 977: if (hp->Hnum == event) { ! 978: hp->Href = eventno; ! 979: lastev = hp->Hnum; ! 980: return (&hp->Hlex); ! 981: } ! 982: np = putn(event); ! 983: noev(np); ! 984: return (0); ! 985: } ! 986: ! 987: struct Hist * ! 988: findev(cp, anyarg) ! 989: char *cp; ! 990: bool anyarg; ! 991: { ! 992: register struct Hist *hp; ! 993: ! 994: for (hp = Histlist.Hnext; hp; hp = hp->Hnext) ! 995: if (matchev(hp, cp, anyarg)) ! 996: return (hp); ! 997: noev(cp); ! 998: return (0); ! 999: } ! 1000: ! 1001: noev(cp) ! 1002: char *cp; ! 1003: { ! 1004: ! 1005: seterr2(cp, ": Event not found"); ! 1006: } ! 1007: ! 1008: matchev(hp, cp, anyarg) ! 1009: register struct Hist *hp; ! 1010: char *cp; ! 1011: bool anyarg; ! 1012: { ! 1013: register char *dp; ! 1014: struct wordent *lp = &hp->Hlex; ! 1015: int argno = 0; ! 1016: ! 1017: for (;;) { ! 1018: lp = lp->next; ! 1019: if (lp->word[0] == '\n') ! 1020: return (0); ! 1021: for (dp = lp->word; *dp; dp++) { ! 1022: if (matchs(dp, cp)) { ! 1023: if (anyarg) ! 1024: quesarg = argno; ! 1025: return (1); ! 1026: } ! 1027: if (!anyarg) ! 1028: return (0); ! 1029: } ! 1030: argno++; ! 1031: } ! 1032: } ! 1033: ! 1034: setexclp(cp) ! 1035: register char *cp; ! 1036: { ! 1037: ! 1038: if (cp[0] == '\n') ! 1039: return; ! 1040: exclp = cp; ! 1041: } ! 1042: ! 1043: unreadc(c) ! 1044: char c; ! 1045: { ! 1046: ! 1047: peekread = c; ! 1048: } ! 1049: ! 1050: readc(wanteof) ! 1051: bool wanteof; ! 1052: { ! 1053: register int c; ! 1054: ! 1055: if (c = peekread) { ! 1056: peekread = 0; ! 1057: return (c); ! 1058: } ! 1059: top: ! 1060: if (alvecp) { ! 1061: if (c = *alvecp++) ! 1062: return (c); ! 1063: if (*alvec) { ! 1064: alvecp = *alvec++; ! 1065: return (' '); ! 1066: } ! 1067: } ! 1068: if (alvec) { ! 1069: if (alvecp = *alvec) { ! 1070: alvec++; ! 1071: goto top; ! 1072: } ! 1073: /* Infinite source! */ ! 1074: return ('\n'); ! 1075: } ! 1076: do { ! 1077: if (arginp == (char *) 1 || onelflg == 1) { ! 1078: if (wanteof) ! 1079: return (-1); ! 1080: exitstat(); ! 1081: } ! 1082: if (arginp) { ! 1083: if ((c = *arginp++) == 0) { ! 1084: arginp = (char *) 1; ! 1085: return ('\n'); ! 1086: } ! 1087: return (c); ! 1088: } ! 1089: c = bgetc(); ! 1090: if (c < 0) { ! 1091: #include <sgtty.h> ! 1092: struct sgttyb tty; ! 1093: ! 1094: if (wanteof) ! 1095: return (-1); ! 1096: /* was isatty but raw with ignoreeof yields problems */ ! 1097: if (adrof("ignoreeof") && gtty(SHIN, &tty)==0 && (tty.sg_flags & RAW) == 0) { ! 1098: if (loginsh) ! 1099: printf("\nUse \"logout\" to logout.\n"); ! 1100: else ! 1101: printf("\nUse \"exit\" to leave csh.\n"); ! 1102: reset(); ! 1103: } ! 1104: doneinp = 1; ! 1105: reset(); ! 1106: } ! 1107: if (c == '\n' && onelflg) ! 1108: onelflg--; ! 1109: } while (c == 0); ! 1110: return (c); ! 1111: } ! 1112: ! 1113: bgetc() ! 1114: { ! 1115: register int buf, off, c; ! 1116: ! 1117: #ifdef TELL ! 1118: if (cantell) { ! 1119: if (fseekp < fbobp || fseekp > feobp) { ! 1120: fbobp = feobp = fseekp; ! 1121: lseek(SHIN, fseekp, 0); ! 1122: } ! 1123: if (fseekp == feobp) { ! 1124: fbobp = feobp; ! 1125: do ! 1126: c = read(SHIN, fbuf[0], BUFSIZ); ! 1127: while (c < 0 && errno == EINTR); ! 1128: if (c <= 0) ! 1129: return (-1); ! 1130: feobp += c; ! 1131: } ! 1132: c = fbuf[0][fseekp - fbobp]; ! 1133: fseekp++; ! 1134: return (c); ! 1135: } ! 1136: #endif ! 1137: again: ! 1138: buf = (int) fseekp / BUFSIZ; ! 1139: if (buf >= fblocks) { ! 1140: register char **nfbuf = (char **) calloc(fblocks+2, sizeof (char **)); ! 1141: ! 1142: if (fbuf) { ! 1143: blkcpy(nfbuf, fbuf); ! 1144: xfree(fbuf); ! 1145: } ! 1146: fbuf = nfbuf; ! 1147: fbuf[fblocks] = calloc(BUFSIZ, sizeof (char)); ! 1148: fblocks++; ! 1149: goto again; ! 1150: } ! 1151: if (fseekp >= feobp) { ! 1152: buf = (int) feobp / BUFSIZ; ! 1153: off = (int) feobp % BUFSIZ; ! 1154: do ! 1155: c = read(SHIN, fbuf[buf] + off, BUFSIZ - off); ! 1156: while (c < 0 && errno == EINTR); ! 1157: if (c <= 0) ! 1158: return (-1); ! 1159: feobp += c; ! 1160: goto again; ! 1161: } ! 1162: c = fbuf[buf][(int) fseekp % BUFSIZ]; ! 1163: fseekp++; ! 1164: return (c); ! 1165: } ! 1166: ! 1167: bfree() ! 1168: { ! 1169: register int sb, i; ! 1170: ! 1171: #ifdef TELL ! 1172: if (cantell) ! 1173: return; ! 1174: #endif ! 1175: if (whyles) ! 1176: return; ! 1177: sb = (int) (fseekp - 1) / BUFSIZ; ! 1178: if (sb > 0) { ! 1179: for (i = 0; i < sb; i++) ! 1180: xfree(fbuf[i]); ! 1181: blkcpy(fbuf, &fbuf[sb]); ! 1182: fseekp -= BUFSIZ * sb; ! 1183: feobp -= BUFSIZ * sb; ! 1184: fblocks -= sb; ! 1185: } ! 1186: } ! 1187: ! 1188: bseek(l) ! 1189: long l; ! 1190: { ! 1191: register struct whyle *wp; ! 1192: ! 1193: fseekp = l; ! 1194: #ifdef TELL ! 1195: if (!cantell) { ! 1196: #endif ! 1197: if (!whyles) ! 1198: return; ! 1199: for (wp = whyles; wp->w_next; wp = wp->w_next) ! 1200: continue; ! 1201: if (wp->w_start > l) ! 1202: l = wp->w_start; ! 1203: #ifdef TELL ! 1204: } ! 1205: #endif ! 1206: } ! 1207: ! 1208: /* any similarity to bell telephone is purely accidental */ ! 1209: long ! 1210: btell() ! 1211: { ! 1212: ! 1213: return (fseekp); ! 1214: } ! 1215: ! 1216: btoeof() ! 1217: { ! 1218: ! 1219: lseek(SHIN, 0l, 2); ! 1220: fseekp = feobp; ! 1221: wfree(); ! 1222: bfree(); ! 1223: } ! 1224: ! 1225: #ifdef TELL ! 1226: settell() ! 1227: { ! 1228: ! 1229: cantell = 0; ! 1230: if (arginp || onelflg || intty) ! 1231: return; ! 1232: if (lseek(SHIN, 0l, 1) < 0 || errno == ESPIPE) ! 1233: return; ! 1234: fbuf = (char **) calloc(2, sizeof (char **)); ! 1235: fblocks = 1; ! 1236: fbuf[0] = calloc(BUFSIZ, sizeof (char)); ! 1237: fseekp = fbobp = feobp = tell(SHIN); ! 1238: cantell = 1; ! 1239: } ! 1240: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.