![[BACK]](/icons/back.gif){kind=icon}
Return to process.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / sed|
Return to process.c CVS log | Up to [local] / src / usr.bin / sed |
1.1 ! deraadt 1: /*-
! 2: * Copyright (c) 1992 Diomidis Spinellis.
! 3: * Copyright (c) 1992, 1993
! 4: * The Regents of the University of California. All rights reserved.
! 5: *
! 6: * This code is derived from software contributed to Berkeley by
! 7: * Diomidis Spinellis of Imperial College, University of London.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above copyright
! 15: * notice, this list of conditions and the following disclaimer in the
! 16: * documentation and/or other materials provided with the distribution.
! 17: * 3. All advertising materials mentioning features or use of this software
! 18: * must display the following acknowledgement:
! 19: * This product includes software developed by the University of
! 20: * California, Berkeley and its contributors.
! 21: * 4. Neither the name of the University nor the names of its contributors
! 22: * may be used to endorse or promote products derived from this software
! 23: * without specific prior written permission.
! 24: *
! 25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 35: * SUCH DAMAGE.
! 36: */
! 37:
! 38: #ifndef lint
! 39: /* from: static char sccsid[] = "@(#)process.c 8.1 (Berkeley) 6/6/93"; */
! 40: static char *rcsid = "$Id: process.c,v 1.17 1995/07/11 04:09:50 cgd Exp $";
! 41: #endif /* not lint */
! 42:
! 43: #include <sys/types.h>
! 44: #include <sys/stat.h>
! 45: #include <sys/ioctl.h>
! 46: #include <sys/uio.h>
! 47:
! 48: #include <ctype.h>
! 49: #include <errno.h>
! 50: #include <fcntl.h>
! 51: #include <limits.h>
! 52: #include <regex.h>
! 53: #include <stdio.h>
! 54: #include <stdlib.h>
! 55: #include <string.h>
! 56: #include <unistd.h>
! 57:
! 58: #include "defs.h"
! 59: #include "extern.h"
! 60:
! 61: static SPACE HS, PS, SS;
! 62: #define pd PS.deleted
! 63: #define ps PS.space
! 64: #define psl PS.len
! 65: #define hs HS.space
! 66: #define hsl HS.len
! 67:
! 68: static inline int applies __P((struct s_command *));
! 69: static void flush_appends __P((void));
! 70: static void lputs __P((char *));
! 71: static inline int regexec_e __P((regex_t *, const char *, int, int, size_t));
! 72: static void regsub __P((SPACE *, char *, char *));
! 73: static int substitute __P((struct s_command *));
! 74:
! 75: struct s_appends *appends; /* Array of pointers to strings to append. */
! 76: static int appendx; /* Index into appends array. */
! 77: int appendnum; /* Size of appends array. */
! 78:
! 79: static int lastaddr; /* Set by applies if last address of a range. */
! 80: static int sdone; /* If any substitutes since last line input. */
! 81: /* Iov structure for 'w' commands. */
! 82: static regex_t *defpreg;
! 83: size_t maxnsub;
! 84: regmatch_t *match;
! 85:
! 86: #define OUT(s) { fwrite(s, sizeof(u_char), psl, stdout); }
! 87:
! 88: void
! 89: process()
! 90: {
! 91: struct s_command *cp;
! 92: SPACE tspace;
! 93: size_t len, oldpsl;
! 94: char *p;
! 95:
! 96: for (linenum = 0; mf_fgets(&PS, REPLACE);) {
! 97: pd = 0;
! 98: top:
! 99: cp = prog;
! 100: redirect:
! 101: while (cp != NULL) {
! 102: if (!applies(cp)) {
! 103: cp = cp->next;
! 104: continue;
! 105: }
! 106: switch (cp->code) {
! 107: case '{':
! 108: cp = cp->u.c;
! 109: goto redirect;
! 110: case 'a':
! 111: if (appendx >= appendnum)
! 112: appends = xrealloc(appends,
! 113: sizeof(struct s_appends) *
! 114: (appendnum *= 2));
! 115: appends[appendx].type = AP_STRING;
! 116: appends[appendx].s = cp->t;
! 117: appends[appendx].len = strlen(cp->t);
! 118: appendx++;
! 119: break;
! 120: case 'b':
! 121: cp = cp->u.c;
! 122: goto redirect;
! 123: case 'c':
! 124: pd = 1;
! 125: psl = 0;
! 126: if (cp->a2 == NULL || lastaddr)
! 127: (void)printf("%s", cp->t);
! 128: break;
! 129: case 'd':
! 130: pd = 1;
! 131: goto new;
! 132: case 'D':
! 133: if (pd)
! 134: goto new;
! 135: if ((p = memchr(ps, '\n', psl - 1)) == NULL) {
! 136: pd = 1;
! 137: goto new;
! 138: } else {
! 139: psl -= (p + 1) - ps;
! 140: memmove(ps, p + 1, psl);
! 141: goto top;
! 142: }
! 143: case 'g':
! 144: cspace(&PS, hs, hsl, REPLACE);
! 145: break;
! 146: case 'G':
! 147: cspace(&PS, hs, hsl, 0);
! 148: break;
! 149: case 'h':
! 150: cspace(&HS, ps, psl, REPLACE);
! 151: break;
! 152: case 'H':
! 153: cspace(&HS, ps, psl, 0);
! 154: break;
! 155: case 'i':
! 156: (void)printf("%s", cp->t);
! 157: break;
! 158: case 'l':
! 159: lputs(ps);
! 160: break;
! 161: case 'n':
! 162: if (!nflag && !pd)
! 163: OUT(ps)
! 164: flush_appends();
! 165: if (!mf_fgets(&PS, REPLACE))
! 166: exit(0);
! 167: pd = 0;
! 168: break;
! 169: case 'N':
! 170: flush_appends();
! 171: if (!mf_fgets(&PS, 0)) {
! 172: if (!nflag && !pd)
! 173: OUT(ps)
! 174: exit(0);
! 175: }
! 176: break;
! 177: case 'p':
! 178: if (pd)
! 179: break;
! 180: OUT(ps)
! 181: break;
! 182: case 'P':
! 183: if (pd)
! 184: break;
! 185: if ((p = memchr(ps, '\n', psl - 1)) != NULL) {
! 186: oldpsl = psl;
! 187: psl = (p + 1) - ps;
! 188: }
! 189: OUT(ps)
! 190: if (p != NULL)
! 191: psl = oldpsl;
! 192: break;
! 193: case 'q':
! 194: if (!nflag && !pd)
! 195: OUT(ps)
! 196: flush_appends();
! 197: exit(0);
! 198: case 'r':
! 199: if (appendx >= appendnum)
! 200: appends = xrealloc(appends,
! 201: sizeof(struct s_appends) *
! 202: (appendnum *= 2));
! 203: appends[appendx].type = AP_FILE;
! 204: appends[appendx].s = cp->t;
! 205: appends[appendx].len = strlen(cp->t);
! 206: appendx++;
! 207: break;
! 208: case 's':
! 209: sdone |= substitute(cp);
! 210: break;
! 211: case 't':
! 212: if (sdone) {
! 213: sdone = 0;
! 214: cp = cp->u.c;
! 215: goto redirect;
! 216: }
! 217: break;
! 218: case 'w':
! 219: if (pd)
! 220: break;
! 221: if (cp->u.fd == -1 && (cp->u.fd = open(cp->t,
! 222: O_WRONLY|O_APPEND|O_CREAT|O_TRUNC,
! 223: DEFFILEMODE)) == -1)
! 224: err(FATAL, "%s: %s\n",
! 225: cp->t, strerror(errno));
! 226: if (write(cp->u.fd, ps, psl) != psl)
! 227: err(FATAL, "%s: %s\n",
! 228: cp->t, strerror(errno));
! 229: break;
! 230: case 'x':
! 231: if (hs == NULL)
! 232: cspace(&HS, "\n", 1, REPLACE);
! 233: tspace = PS;
! 234: PS = HS;
! 235: HS = tspace;
! 236: break;
! 237: case 'y':
! 238: if (pd)
! 239: break;
! 240: for (p = ps, len = psl; --len; ++p)
! 241: *p = cp->u.y[*p];
! 242: break;
! 243: case ':':
! 244: case '}':
! 245: break;
! 246: case '=':
! 247: (void)printf("%lu\n", linenum);
! 248: }
! 249: cp = cp->next;
! 250: } /* for all cp */
! 251:
! 252: new: if (!nflag && !pd)
! 253: OUT(ps)
! 254: flush_appends();
! 255: } /* for all lines */
! 256: }
! 257:
! 258: /*
! 259: * TRUE if the address passed matches the current program state
! 260: * (lastline, linenumber, ps).
! 261: */
! 262: #define MATCH(a) \
! 263: (a)->type == AT_RE ? regexec_e((a)->u.r, ps, 0, 1, psl) : \
! 264: (a)->type == AT_LINE ? linenum == (a)->u.l : lastline
! 265:
! 266: /*
! 267: * Return TRUE if the command applies to the current line. Sets the inrange
! 268: * flag to process ranges. Interprets the non-select (``!'') flag.
! 269: */
! 270: static inline int
! 271: applies(cp)
! 272: struct s_command *cp;
! 273: {
! 274: int r;
! 275:
! 276: lastaddr = 0;
! 277: if (cp->a1 == NULL && cp->a2 == NULL)
! 278: r = 1;
! 279: else if (cp->a2)
! 280: if (cp->inrange) {
! 281: if (MATCH(cp->a2)) {
! 282: cp->inrange = 0;
! 283: lastaddr = 1;
! 284: }
! 285: r = 1;
! 286: } else if (MATCH(cp->a1)) {
! 287: /*
! 288: * If the second address is a number less than or
! 289: * equal to the line number first selected, only
! 290: * one line shall be selected.
! 291: * -- POSIX 1003.2
! 292: */
! 293: if (cp->a2->type == AT_LINE &&
! 294: linenum >= cp->a2->u.l)
! 295: lastaddr = 1;
! 296: else
! 297: cp->inrange = 1;
! 298: r = 1;
! 299: } else
! 300: r = 0;
! 301: else
! 302: r = MATCH(cp->a1);
! 303: return (cp->nonsel ? ! r : r);
! 304: }
! 305:
! 306: /*
! 307: * substitute --
! 308: * Do substitutions in the pattern space. Currently, we build a
! 309: * copy of the new pattern space in the substitute space structure
! 310: * and then swap them.
! 311: */
! 312: static int
! 313: substitute(cp)
! 314: struct s_command *cp;
! 315: {
! 316: SPACE tspace;
! 317: regex_t *re;
! 318: size_t re_off, slen;
! 319: int n, lastempty;
! 320: char *s;
! 321:
! 322: s = ps;
! 323: re = cp->u.s->re;
! 324: if (re == NULL) {
! 325: if (defpreg != NULL && cp->u.s->maxbref > defpreg->re_nsub) {
! 326: linenum = cp->u.s->linenum;
! 327: err(COMPILE, "\\%d not defined in the RE",
! 328: cp->u.s->maxbref);
! 329: }
! 330: }
! 331: if (!regexec_e(re, s, 0, 0, psl))
! 332: return (0);
! 333:
! 334: SS.len = 0; /* Clean substitute space. */
! 335: slen = psl;
! 336: n = cp->u.s->n;
! 337: lastempty = 1;
! 338:
! 339: switch (n) {
! 340: case 0: /* Global */
! 341: do {
! 342: if (lastempty || match[0].rm_so != match[0].rm_eo) {
! 343: /* Locate start of replaced string. */
! 344: re_off = match[0].rm_so;
! 345: /* Copy leading retained string. */
! 346: cspace(&SS, s, re_off, APPEND);
! 347: /* Add in regular expression. */
! 348: regsub(&SS, s, cp->u.s->new);
! 349: }
! 350:
! 351: /* Move past this match. */
! 352: if (match[0].rm_so != match[0].rm_eo) {
! 353: s += match[0].rm_eo;
! 354: slen -= match[0].rm_eo;
! 355: lastempty = 0;
! 356: } else {
! 357: if (match[0].rm_so == 0)
! 358: cspace(&SS, s, match[0].rm_so + 1,
! 359: APPEND);
! 360: else
! 361: cspace(&SS, s + match[0].rm_so, 1,
! 362: APPEND);
! 363: s += match[0].rm_so + 1;
! 364: slen -= match[0].rm_so + 1;
! 365: lastempty = 1;
! 366: }
! 367: } while (slen > 0 && regexec_e(re, s, REG_NOTBOL, 0, slen));
! 368: /* Copy trailing retained string. */
! 369: if (slen > 0)
! 370: cspace(&SS, s, slen, APPEND);
! 371: break;
! 372: default: /* Nth occurrence */
! 373: while (--n) {
! 374: s += match[0].rm_eo;
! 375: slen -= match[0].rm_eo;
! 376: if (!regexec_e(re, s, REG_NOTBOL, 0, slen))
! 377: return (0);
! 378: }
! 379: /* FALLTHROUGH */
! 380: case 1: /* 1st occurrence */
! 381: /* Locate start of replaced string. */
! 382: re_off = match[0].rm_so + (s - ps);
! 383: /* Copy leading retained string. */
! 384: cspace(&SS, ps, re_off, APPEND);
! 385: /* Add in regular expression. */
! 386: regsub(&SS, s, cp->u.s->new);
! 387: /* Copy trailing retained string. */
! 388: s += match[0].rm_eo;
! 389: slen -= match[0].rm_eo;
! 390: cspace(&SS, s, slen, APPEND);
! 391: break;
! 392: }
! 393:
! 394: /*
! 395: * Swap the substitute space and the pattern space, and make sure
! 396: * that any leftover pointers into stdio memory get lost.
! 397: */
! 398: tspace = PS;
! 399: PS = SS;
! 400: SS = tspace;
! 401: SS.space = SS.back;
! 402:
! 403: /* Handle the 'p' flag. */
! 404: if (cp->u.s->p)
! 405: OUT(ps)
! 406:
! 407: /* Handle the 'w' flag. */
! 408: if (cp->u.s->wfile && !pd) {
! 409: if (cp->u.s->wfd == -1 && (cp->u.s->wfd = open(cp->u.s->wfile,
! 410: O_WRONLY|O_APPEND|O_CREAT|O_TRUNC, DEFFILEMODE)) == -1)
! 411: err(FATAL, "%s: %s\n", cp->u.s->wfile, strerror(errno));
! 412: if (write(cp->u.s->wfd, ps, psl) != psl)
! 413: err(FATAL, "%s: %s\n", cp->u.s->wfile, strerror(errno));
! 414: }
! 415: return (1);
! 416: }
! 417:
! 418: /*
! 419: * Flush append requests. Always called before reading a line,
! 420: * therefore it also resets the substitution done (sdone) flag.
! 421: */
! 422: static void
! 423: flush_appends()
! 424: {
! 425: FILE *f;
! 426: int count, i;
! 427: char buf[8 * 1024];
! 428:
! 429: for (i = 0; i < appendx; i++)
! 430: switch (appends[i].type) {
! 431: case AP_STRING:
! 432: fwrite(appends[i].s, sizeof(char), appends[i].len,
! 433: stdout);
! 434: break;
! 435: case AP_FILE:
! 436: /*
! 437: * Read files probably shouldn't be cached. Since
! 438: * it's not an error to read a non-existent file,
! 439: * it's possible that another program is interacting
! 440: * with the sed script through the file system. It
! 441: * would be truly bizarre, but possible. It's probably
! 442: * not that big a performance win, anyhow.
! 443: */
! 444: if ((f = fopen(appends[i].s, "r")) == NULL)
! 445: break;
! 446: while (count = fread(buf, sizeof(char), sizeof(buf), f))
! 447: (void)fwrite(buf, sizeof(char), count, stdout);
! 448: (void)fclose(f);
! 449: break;
! 450: }
! 451: if (ferror(stdout))
! 452: err(FATAL, "stdout: %s", strerror(errno ? errno : EIO));
! 453: appendx = sdone = 0;
! 454: }
! 455:
! 456: static void
! 457: lputs(s)
! 458: register char *s;
! 459: {
! 460: register int count;
! 461: register char *escapes, *p;
! 462: struct winsize win;
! 463: static int termwidth = -1;
! 464:
! 465: if (termwidth == -1)
! 466: if (p = getenv("COLUMNS"))
! 467: termwidth = atoi(p);
! 468: else if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) == 0 &&
! 469: win.ws_col > 0)
! 470: termwidth = win.ws_col;
! 471: else
! 472: termwidth = 60;
! 473:
! 474: for (count = 0; *s; ++s) {
! 475: if (count >= termwidth) {
! 476: (void)printf("\\\n");
! 477: count = 0;
! 478: }
! 479: if (isascii(*s) && isprint(*s) && *s != '\\') {
! 480: (void)putchar(*s);
! 481: count++;
! 482: } else {
! 483: escapes = "\\\a\b\f\n\r\t\v";
! 484: (void)putchar('\\');
! 485: if (p = strchr(escapes, *s)) {
! 486: (void)putchar("\\abfnrtv"[p - escapes]);
! 487: count += 2;
! 488: } else {
! 489: (void)printf("%03o", *(u_char *)s);
! 490: count += 4;
! 491: }
! 492: }
! 493: }
! 494: (void)putchar('$');
! 495: (void)putchar('\n');
! 496: if (ferror(stdout))
! 497: err(FATAL, "stdout: %s", strerror(errno ? errno : EIO));
! 498: }
! 499:
! 500: static inline int
! 501: regexec_e(preg, string, eflags, nomatch, slen)
! 502: regex_t *preg;
! 503: const char *string;
! 504: int eflags, nomatch;
! 505: size_t slen;
! 506: {
! 507: int eval;
! 508:
! 509: if (preg == NULL) {
! 510: if (defpreg == NULL)
! 511: err(FATAL, "first RE may not be empty");
! 512: } else
! 513: defpreg = preg;
! 514:
! 515: /* Set anchors, discounting trailing newline (if any). */
! 516: if (slen > 0 && string[slen - 1] == '\n')
! 517: slen--;
! 518: match[0].rm_so = 0;
! 519: match[0].rm_eo = slen;
! 520:
! 521: eval = regexec(defpreg, string,
! 522: nomatch ? 0 : maxnsub + 1, match, eflags | REG_STARTEND);
! 523: switch(eval) {
! 524: case 0:
! 525: return (1);
! 526: case REG_NOMATCH:
! 527: return (0);
! 528: }
! 529: err(FATAL, "RE error: %s", strregerror(eval, defpreg));
! 530: /* NOTREACHED */
! 531: }
! 532:
! 533: /*
! 534: * regsub - perform substitutions after a regexp match
! 535: * Based on a routine by Henry Spencer
! 536: */
! 537: static void
! 538: regsub(sp, string, src)
! 539: SPACE *sp;
! 540: char *string, *src;
! 541: {
! 542: register int len, no;
! 543: register char c, *dst;
! 544:
! 545: #define NEEDSP(reqlen) \
! 546: if (sp->len >= sp->blen - (reqlen) - 1) { \
! 547: sp->blen += (reqlen) + 1024; \
! 548: sp->space = sp->back = xrealloc(sp->back, sp->blen); \
! 549: dst = sp->space + sp->len; \
! 550: }
! 551:
! 552: dst = sp->space + sp->len;
! 553: while ((c = *src++) != '\0') {
! 554: if (c == '&')
! 555: no = 0;
! 556: else if (c == '\\' && isdigit(*src))
! 557: no = *src++ - '0';
! 558: else
! 559: no = -1;
! 560: if (no < 0) { /* Ordinary character. */
! 561: if (c == '\\' && (*src == '\\' || *src == '&'))
! 562: c = *src++;
! 563: NEEDSP(1);
! 564: *dst++ = c;
! 565: ++sp->len;
! 566: } else if (match[no].rm_so != -1 && match[no].rm_eo != -1) {
! 567: len = match[no].rm_eo - match[no].rm_so;
! 568: NEEDSP(len);
! 569: memmove(dst, string + match[no].rm_so, len);
! 570: dst += len;
! 571: sp->len += len;
! 572: }
! 573: }
! 574: NEEDSP(1);
! 575: *dst = '\0';
! 576: }
! 577:
! 578: /*
! 579: * aspace --
! 580: * Append the source space to the destination space, allocating new
! 581: * space as necessary.
! 582: */
! 583: void
! 584: cspace(sp, p, len, spflag)
! 585: SPACE *sp;
! 586: char *p;
! 587: size_t len;
! 588: enum e_spflag spflag;
! 589: {
! 590: size_t tlen;
! 591:
! 592: /* Make sure SPACE has enough memory and ramp up quickly. */
! 593: tlen = sp->len + len + 1;
! 594: if (tlen > sp->blen) {
! 595: sp->blen = tlen + 1024;
! 596: sp->space = sp->back = xrealloc(sp->back, sp->blen);
! 597: }
! 598:
! 599: if (spflag == REPLACE)
! 600: sp->len = 0;
! 601:
! 602: memmove(sp->space + sp->len, p, len);
! 603:
! 604: sp->space[sp->len += len] = '\0';
! 605: }
! 606:
! 607: /*
! 608: * Close all cached opened files and report any errors
! 609: */
! 610: void
! 611: cfclose(cp, end)
! 612: register struct s_command *cp, *end;
! 613: {
! 614:
! 615: for (; cp != end; cp = cp->next)
! 616: switch(cp->code) {
! 617: case 's':
! 618: if (cp->u.s->wfd != -1 && close(cp->u.s->wfd))
! 619: err(FATAL,
! 620: "%s: %s", cp->u.s->wfile, strerror(errno));
! 621: cp->u.s->wfd = -1;
! 622: break;
! 623: case 'w':
! 624: if (cp->u.fd != -1 && close(cp->u.fd))
! 625: err(FATAL, "%s: %s", cp->t, strerror(errno));
! 626: cp->u.fd = -1;
! 627: break;
! 628: case '{':
! 629: cfclose(cp->u.c, cp->next);
! 630: break;
! 631: }
! 632: }