--- /dev/null
+/* sed - stream editor Author: Eric S. Raymond */
+
+/* This used to be three different files with the following makefile:
+ * (Note the chmem).
+
+CFLAGS= -F -T.
+
+OBJS= sedcomp.s sedexec.s
+
+sed: $(OBJS)
+ cc -T. -o sed $(OBJS)
+ @chmem =13312 sed
+
+$(OBJS): sed.h
+
+ * If you want longer lines: increase MAXBUF.
+ * If you want scripts with more text: increase POOLSIZE.
+ * If you want more commands per script: increase MAXCMDS.
+ */
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+
+/*+++++++++++++++*/
+
+/* Sed.h -- types and constants for the stream editor */
+
+/* Data area sizes used by both modules */
+#define MAXBUF 4000 /* current line buffer size */
+#define MAXAPPENDS 20 /* maximum number of appends */
+#define MAXTAGS 9 /* tagged patterns are \1 to \9 */
+
+/* Constants for compiled-command representation */
+#define EQCMD 0x01 /* = -- print current line number */
+#define ACMD 0x02 /* a -- append text after current line */
+#define BCMD 0x03 /* b -- branch to label */
+#define CCMD 0x04 /* c -- change current line */
+#define DCMD 0x05 /* d -- delete all of pattern space */
+#define CDCMD 0x06 /* D -- delete first line of pattern space */
+#define GCMD 0x07 /* g -- copy hold space to pattern space */
+#define CGCMD 0x08 /* G -- append hold space to pattern space */
+#define HCMD 0x09 /* h -- copy pattern space to hold space */
+#define CHCMD 0x0A /* H -- append pattern space to hold space */
+#define ICMD 0x0B /* i -- insert text before current line */
+#define LCMD 0x0C /* l -- print pattern space in escaped form */
+#define NCMD 0x0D /* n -- get next line into pattern space */
+#define CNCMD 0x0E /* N -- append next line to pattern space */
+#define PCMD 0x0F /* p -- print pattern space to output */
+#define CPCMD 0x10 /* P -- print first line of pattern space */
+#define QCMD 0x11 /* q -- exit the stream editor */
+#define RCMD 0x12 /* r -- read in a file after current line */
+#define SCMD 0x13 /* s -- regular-expression substitute */
+#define TCMD 0x14 /* t -- branch on any substitute successful */
+#define CTCMD 0x15 /* T -- branch on any substitute failed */
+#define WCMD 0x16 /* w -- write pattern space to file */
+#define CWCMD 0x17 /* W -- write first line of pattern space */
+#define XCMD 0x18 /* x -- exhange pattern and hold spaces */
+#define YCMD 0x19 /* y -- transliterate text */
+
+struct cmd_t { /* compiled-command representation */
+ char *addr1; /* first address for command */
+ char *addr2; /* second address for command */
+ union {
+ char *lhs; /* s command lhs */
+ struct cmd_t *link; /* label link */
+ } u;
+ char command; /* command code */
+ char *rhs; /* s command replacement string */
+ FILE *fout; /* associated output file descriptor */
+ struct {
+ char allbut; /* was negation specified? */
+ char global; /* was g postfix specified? */
+ char print; /* was p postfix specified? */
+ char inrange; /* in an address range? */
+ } flags;
+};
+typedef struct cmd_t sedcmd; /* use this name for declarations */
+
+#define BAD ((char *) -1) /* guaranteed not a string ptr */
+
+
+
+/* Address and regular expression compiled-form markers */
+#define STAR 1 /* marker for Kleene star */
+#define CCHR 2 /* non-newline character to be matched
+ * follows */
+#define CDOT 4 /* dot wild-card marker */
+#define CCL 6 /* character class follows */
+#define CNL 8 /* match line start */
+#define CDOL 10 /* match line end */
+#define CBRA 12 /* tagged pattern start marker */
+#define CKET 14 /* tagged pattern end marker */
+#define CBACK 16 /* backslash-digit pair marker */
+#define CLNUM 18 /* numeric-address index follows */
+#define CEND 20 /* symbol for end-of-source */
+#define CEOF 22 /* end-of-field mark */
+
+/* Sed.h ends here */
+
+#ifndef CMASK
+#define CMASK 0xFF /* some char type should have been unsigned
+ * char? */
+#endif
+
+/*+++++++++++++++*/
+
+/* Sed - stream editor Author: Eric S. Raymond */
+
+/*
+ The stream editor compiles its command input (from files or -e options)
+ into an internal form using compile() then executes the compiled form using
+ execute(). Main() just initializes data structures, interprets command line
+ options, and calls compile() and execute() in appropriate sequence.
+
+ The data structure produced by compile() is an array of compiled-command
+ structures (type sedcmd). These contain several pointers into pool[], the
+ regular-expression and text-data pool, plus a command code and g & p flags.
+ In the special case that the command is a label the struct will hold a ptr
+ into the labels array labels[] during most of the compile, until resolve()
+ resolves references at the end.
+
+ The operation of execute() is described in its source module.
+*/
+
+/* #include <stdio.h> */
+/* #include "sed.h" */
+
+/* Imported functions */
+
+/***** public stuff ******/
+
+#define MAXCMDS 500 /* maximum number of compiled commands */
+#define MAXLINES 256 /* max # numeric addresses to compile */
+
+/* Main data areas */
+char linebuf[MAXBUF + 1]; /* current-line buffer */
+sedcmd cmds[MAXCMDS + 1]; /* hold compiled commands */
+long linenum[MAXLINES]; /* numeric-addresses table */
+
+/* Miscellaneous shared variables */
+int nflag; /* -n option flag */
+int eargc; /* scratch copy of argument count */
+char **eargv; /* scratch copy of argument list */
+char bits[] = {1, 2, 4, 8, 16, 32, 64, 128};
+
+/***** module common stuff *****/
+
+#define POOLSIZE 20000 /* size of string-pool space */
+#define WFILES 10 /* max # w output files that can be compiled */
+#define RELIMIT 256 /* max chars in compiled RE */
+#define MAXDEPTH 20 /* maximum {}-nesting level */
+#define MAXLABS 50 /* max # of labels that can be handled */
+
+#define SKIPWS(pc) while ((*pc==' ') || (*pc=='\t')) pc++
+#define ABORT(msg) (fprintf(stderr, msg, linebuf), quit(2))
+#define IFEQ(x, v) if (*x == v) x++ , /* do expression */
+
+/* Error messages */
+static char AGMSG[] = "sed: garbled address %s\n";
+static char CGMSG[] = "sed: garbled command %s\n";
+static char TMTXT[] = "sed: too much text: %s\n";
+static char AD1NG[] = "sed: no addresses allowed for %s\n";
+static char AD2NG[] = "sed: only one address allowed for %s\n";
+static char TMCDS[] = "sed: too many commands, last was %s\n";
+static char COCFI[] = "sed: cannot open command-file %s\n";
+static char UFLAG[] = "sed: unknown flag %c\n";
+static char CCOFI[] = "sed: cannot create %s\n";
+static char ULABL[] = "sed: undefined label %s\n";
+static char TMLBR[] = "sed: too many {'s\n";
+static char FRENL[] = "sed: first RE must be non-null\n";
+static char NSCAX[] = "sed: no such command as %s\n";
+static char TMRBR[] = "sed: too many }'s\n";
+static char DLABL[] = "sed: duplicate label %s\n";
+static char TMLAB[] = "sed: too many labels: %s\n";
+static char TMWFI[] = "sed: too many w files\n";
+static char REITL[] = "sed: RE too long: %s\n";
+static char TMLNR[] = "sed: too many line numbers\n";
+static char TRAIL[] = "sed: command \"%s\" has trailing garbage\n";
+
+typedef struct { /* represent a command label */
+ char *name; /* the label name */
+ sedcmd *last; /* it's on the label search list */
+ sedcmd *address; /* pointer to the cmd it labels */
+}
+
+ label;
+
+/* Label handling */
+static label labels[MAXLABS]; /* here's the label table */
+static label *lab = labels + 1; /* pointer to current label */
+static label *lablst = labels; /* header for search list */
+
+/* String pool for regular expressions, append text, etc. etc. */
+static char pool[POOLSIZE]; /* the pool */
+static char *fp = pool; /* current pool pointer */
+static char *poolend = pool + POOLSIZE; /* pointer past pool end */
+
+/* Compilation state */
+static FILE *cmdf = NULL; /* current command source */
+static char *cp = linebuf; /* compile pointer */
+static sedcmd *cmdp = cmds; /* current compiled-cmd ptr */
+static char *lastre = NULL; /* old RE pointer */
+static int bdepth = 0; /* current {}-nesting level */
+static int bcount = 0; /* # tagged patterns in current RE */
+
+/* Compilation flags */
+static int eflag; /* -e option flag */
+static int gflag; /* -g option flag */
+
+_PROTOTYPE(int main, (int argc, char **argv));
+_PROTOTYPE(static void compile, (void));
+_PROTOTYPE(static int cmdcomp, (int cchar));
+_PROTOTYPE(static char *rhscomp, (char *rhsp, int delim));
+_PROTOTYPE(static char *recomp, (char *expbuf, int redelim));
+_PROTOTYPE(static int cmdline, (char *cbuf));
+_PROTOTYPE(static char *address, (char *expbuf));
+_PROTOTYPE(static char *gettext, (char *txp));
+_PROTOTYPE(static label *search, (label *ptr));
+_PROTOTYPE(static void resolve, (void));
+_PROTOTYPE(static char *ycomp, (char *ep, int delim));
+_PROTOTYPE(void quit, (int n));
+_PROTOTYPE(void execute, (void));
+_PROTOTYPE(static int selected, (sedcmd *ipc));
+_PROTOTYPE(static int match, (char *expbuf, int gf));
+_PROTOTYPE(static int advance, (char *lp, char *ep));
+_PROTOTYPE(static int substitute, (sedcmd *ipc));
+_PROTOTYPE(static void dosub, (char *rhsbuf));
+_PROTOTYPE(static char *place, (char *asp, char *al1, char *al2));
+_PROTOTYPE(static void listto, (char *p1, FILE *fp));
+_PROTOTYPE(static void truncated, (int h));
+_PROTOTYPE(static void command, (sedcmd *ipc));
+_PROTOTYPE(static void openfile, (char *file));
+_PROTOTYPE(static void get, (void));
+_PROTOTYPE(static void initget, (void));
+_PROTOTYPE(static char *getline, (char *buf));
+_PROTOTYPE(static int Memcmp, (char *a, char *b, int count));
+_PROTOTYPE(static void readout, (void));
+
+int main(argc, argv)
+/* Main sequence of the stream editor */
+int argc;
+char *argv[];
+{
+ eargc = argc; /* set local copy of argument count */
+ eargv = argv; /* set local copy of argument list */
+ cmdp->addr1 = pool; /* 1st addr expand will be at pool start */
+ if (eargc == 1) quit(0); /* exit immediately if no arguments */
+ /* Scan through the arguments, interpreting each one */
+ while ((--eargc > 0) && (**++eargv == '-')) switch (eargv[0][1]) {
+ case 'e':
+ eflag++;
+ compile(); /* compile with e flag on */
+ eflag = 0;
+ continue; /* get another argument */
+ case 'f':
+ if (eargc-- <= 0) /* barf if no -f file */
+ quit(2);
+ if ((cmdf = fopen(*++eargv, "r")) == NULL) {
+ fprintf(stderr, COCFI, *eargv);
+ quit(2);
+ }
+ compile(); /* file is O.K., compile it */
+ fclose(cmdf);
+ continue; /* go back for another argument */
+ case 'g':
+ gflag++; /* set global flag on all s cmds */
+ continue;
+ case 'n':
+ nflag++; /* no print except on p flag or w */
+ continue;
+ default:
+ fprintf(stdout, UFLAG, eargv[0][1]);
+ continue;
+ }
+
+
+ if (cmdp == cmds) { /* no commands have been compiled */
+ eargv--;
+ eargc++;
+ eflag++;
+ compile();
+ eflag = 0;
+ eargv++;
+ eargc--;
+ }
+ if (bdepth) /* we have unbalanced squigglies */
+ ABORT(TMLBR);
+
+ lablst->address = cmdp; /* set up header of label linked list */
+ resolve(); /* resolve label table indirections */
+ execute(); /* execute commands */
+ quit(0); /* everything was O.K. if we got here */
+ return(0);
+}
+
+
+#define H 0x80 /* 128 bit, on if there's really code for
+ * command */
+#define LOWCMD 56 /* = '8', lowest char indexed in cmdmask */
+
+/* Indirect through this to get command internal code, if it exists */
+static char cmdmask[] =
+{
+ 0, 0, H, 0, 0, H + EQCMD, 0, 0,
+ 0, 0, 0, 0, H + CDCMD, 0, 0, CGCMD,
+ CHCMD, 0, 0, 0, 0, 0, CNCMD, 0,
+ CPCMD, 0, 0, 0, H + CTCMD, 0, 0, H + CWCMD,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, H + ACMD, H + BCMD, H + CCMD, DCMD, 0, 0, GCMD,
+ HCMD, H + ICMD, 0, 0, H + LCMD, 0, NCMD, 0,
+ PCMD, H + QCMD, H + RCMD, H + SCMD, H + TCMD, 0, 0, H + WCMD,
+ XCMD, H + YCMD, 0, H + BCMD, 0, H, 0, 0,
+};
+
+static void compile()
+/* Precompile sed commands out of a file */
+{
+ char ccode;
+
+
+ for (;;) { /* main compilation loop */
+ if (*cp == '\0') { /* get a new command line */
+ *linebuf = '\0'; /* K.H */
+ if (cmdline(cp = linebuf) < 0) break;
+ }
+ SKIPWS(cp);
+ if (*cp == '\0') /* empty */
+ continue;
+ if (*cp == '#') { /* comment */
+ while (*cp) ++cp;
+ continue;
+ }
+ if (*cp == ';') { /* ; separates cmds */
+ cp++;
+ continue;
+ }
+
+ /* Compile first address */
+ if (fp > poolend)
+ ABORT(TMTXT);
+ else if ((fp = address(cmdp->addr1 = fp)) == BAD)
+ ABORT(AGMSG);
+
+ if (fp == cmdp->addr1) {/* if empty RE was found */
+ if (lastre) /* if there was previous RE */
+ cmdp->addr1 = lastre; /* use it */
+ else
+ ABORT(FRENL);
+ } else if (fp == NULL) {/* if fp was NULL */
+ fp = cmdp->addr1; /* use current pool location */
+ cmdp->addr1 = NULL;
+ } else {
+ lastre = cmdp->addr1;
+ if (*cp == ',' || *cp == ';') { /* there's 2nd addr */
+ cp++;
+ if (fp > poolend) ABORT(TMTXT);
+ fp = address(cmdp->addr2 = fp);
+ if (fp == BAD || fp == NULL) ABORT(AGMSG);
+ if (fp == cmdp->addr2)
+ cmdp->addr2 = lastre;
+ else
+ lastre = cmdp->addr2;
+ } else
+ cmdp->addr2 = NULL; /* no 2nd address */
+ }
+ if (fp > poolend) ABORT(TMTXT);
+
+ SKIPWS(cp); /* discard whitespace after address */
+ IFEQ(cp, '!') cmdp->flags.allbut = 1;
+
+ SKIPWS(cp); /* get cmd char, range-check it */
+ if ((*cp < LOWCMD) || (*cp > '~')
+ || ((ccode = cmdmask[*cp - LOWCMD]) == 0))
+ ABORT(NSCAX);
+
+ cmdp->command = ccode & ~H; /* fill in command value */
+ if ((ccode & H) == 0) /* if no compile-time code */
+ cp++; /* discard command char */
+ else if (cmdcomp(*cp++))/* execute it; if ret = 1 */
+ continue; /* skip next line read */
+
+ if (++cmdp >= cmds + MAXCMDS) ABORT(TMCDS);
+
+ SKIPWS(cp); /* look for trailing stuff */
+ if (*cp != '\0' && *cp != ';' && *cp != '#') ABORT(TRAIL);
+ }
+}
+
+static int cmdcomp(cchar)
+/* Compile a single command */
+register char cchar; /* character name of command */
+{
+ static sedcmd **cmpstk[MAXDEPTH]; /* current cmd stack for {} */
+ static char *fname[WFILES]; /* w file name pointers */
+ static FILE *fout[WFILES]; /* w file file ptrs */
+ static int nwfiles = 1; /* count of open w files */
+ int i; /* indexing dummy used in w */
+ sedcmd *sp1, *sp2; /* temps for label searches */
+ label *lpt;
+ char redelim; /* current RE delimiter */
+
+ fout[0] = stdout;
+ switch (cchar) {
+ case '{': /* start command group */
+ cmdp->flags.allbut = !cmdp->flags.allbut;
+ cmpstk[bdepth++] = &(cmdp->u.link);
+ if (++cmdp >= cmds + MAXCMDS) ABORT(TMCDS);
+ return(1);
+
+ case '}': /* end command group */
+ if (cmdp->addr1) ABORT(AD1NG); /* no addresses allowed */
+ if (--bdepth < 0) ABORT(TMRBR); /* too many right braces */
+ *cmpstk[bdepth] = cmdp; /* set the jump address */
+ return(1);
+
+ case '=': /* print current source line number */
+ case 'q': /* exit the stream editor */
+ if (cmdp->addr2) ABORT(AD2NG);
+ break;
+
+ case ':': /* label declaration */
+ if (cmdp->addr1) ABORT(AD1NG); /* no addresses allowed */
+ fp = gettext(lab->name = fp); /* get the label name */
+ if (lpt = search(lab)) {/* does it have a double? */
+ if (lpt->address) ABORT(DLABL); /* yes, abort */
+ } else { /* check that it doesn't overflow label table */
+ lab->last = NULL;
+ lpt = lab;
+ if (++lab >= labels + MAXLABS) ABORT(TMLAB);
+ }
+ lpt->address = cmdp;
+ return(1);
+
+ case 'b': /* branch command */
+ case 't': /* branch-on-succeed command */
+ case 'T': /* branch-on-fail command */
+ SKIPWS(cp);
+ if (*cp == '\0') { /* if branch is to start of cmds... */
+ /* Add current command to end of label last */
+ if (sp1 = lablst->last) {
+ while (sp2 = sp1->u.link) sp1 = sp2;
+ sp1->u.link = cmdp;
+ } else /* lablst->last == NULL */
+ lablst->last = cmdp;
+ break;
+ }
+ fp = gettext(lab->name = fp); /* else get label into pool */
+ if (lpt = search(lab)) {/* enter branch to it */
+ if (lpt->address)
+ cmdp->u.link = lpt->address;
+ else {
+ sp1 = lpt->last;
+ while (sp2 = sp1->u.link) sp1 = sp2;
+ sp1->u.link = cmdp;
+ }
+ } else { /* matching named label not found */
+ lab->last = cmdp; /* add the new label */
+ lab->address = NULL; /* it's forward of here */
+ if (++lab >= labels + MAXLABS) /* overflow if last */
+ ABORT(TMLAB);
+ }
+ break;
+
+ case 'a': /* append text */
+ case 'i': /* insert text */
+ case 'r': /* read file into stream */
+ if (cmdp->addr2) ABORT(AD2NG);
+ case 'c': /* change text */
+ if ((*cp == '\\') && (*++cp == '\n')) cp++;
+ fp = gettext(cmdp->u.lhs = fp);
+ break;
+
+ case 'D': /* delete current line in hold space */
+ cmdp->u.link = cmds;
+ break;
+
+ case 's': /* substitute regular expression */
+ redelim = *cp++; /* get delimiter from 1st ch */
+ if ((fp = recomp(cmdp->u.lhs = fp, redelim)) == BAD) ABORT(CGMSG);
+ if (fp == cmdp->u.lhs) /* if compiled RE zero len */
+ cmdp->u.lhs = lastre; /* use the previous one */
+ else /* otherwise */
+ lastre = cmdp->u.lhs; /* save the one just found */
+ if ((cmdp->rhs = fp) > poolend) ABORT(TMTXT);
+ if ((fp = rhscomp(cmdp->rhs, redelim)) == BAD) ABORT(CGMSG);
+ if (gflag) cmdp->flags.global ++;
+ while (*cp == 'g' || *cp == 'p' || *cp == 'P') {
+ IFEQ(cp, 'g') cmdp->flags.global ++;
+ IFEQ(cp, 'p') cmdp->flags.print = 1;
+ IFEQ(cp, 'P') cmdp->flags.print = 2;
+ }
+
+ case 'l': /* list pattern space */
+ if (*cp == 'w')
+ cp++; /* and execute a w command! */
+ else
+ break; /* s or l is done */
+
+ case 'w': /* write-pattern-space command */
+ case 'W': /* write-first-line command */
+ if (nwfiles >= WFILES) ABORT(TMWFI);
+ fp = gettext(fname[nwfiles] = fp); /* filename will be in pool */
+ for (i = nwfiles - 1; i >= 0; i--) /* match it in table */
+ if ((fname[i] != NULL) &&
+ (strcmp(fname[nwfiles], fname[i]) == 0)) {
+ cmdp->fout = fout[i];
+ return(0);
+ }
+
+ /* If didn't find one, open new out file */
+ if ((cmdp->fout = fopen(fname[nwfiles], "w")) == NULL) {
+ fprintf(stderr, CCOFI, fname[nwfiles]);
+ quit(2);
+ }
+ fout[nwfiles++] = cmdp->fout;
+ break;
+
+ case 'y': /* transliterate text */
+ fp = ycomp(cmdp->u.lhs = fp, *cp++); /* compile translit */
+ if (fp == BAD) ABORT(CGMSG); /* fail on bad form */
+ if (fp > poolend) ABORT(TMTXT); /* fail on overflow */
+ break;
+ }
+ return(0); /* succeeded in interpreting one command */
+}
+
+static char *rhscomp(rhsp, delim) /* uses bcount */
+ /* Generate replacement string for substitute command right hand side */
+register char *rhsp; /* place to compile expression to */
+register char delim; /* regular-expression end-mark to look for */
+{
+ register char *p = cp; /* strictly for speed */
+
+ for (;;)
+ if ((*rhsp = *p++) == '\\') { /* copy; if it's a \, */
+ *rhsp = *p++; /* copy escaped char */
+ /* Check validity of pattern tag */
+ if (*rhsp > bcount + '0' && *rhsp <= '9') return(BAD);
+ *rhsp++ |= 0x80;/* mark the good ones */
+ continue;
+ } else if (*rhsp == delim) { /* found RE end, hooray... */
+ *rhsp++ = '\0'; /* cap the expression string */
+ cp = p;
+ return(rhsp); /* pt at 1 past the RE */
+ } else if (*rhsp++ == '\0') /* last ch not RE end, help! */
+ return(BAD);
+}
+
+static char *recomp(expbuf, redelim) /* uses cp, bcount */
+ /* Compile a regular expression to internal form */
+char *expbuf; /* place to compile it to */
+char redelim; /* RE end-marker to look for */
+{
+ register char *ep = expbuf; /* current-compiled-char pointer */
+ register char *sp = cp; /* source-character ptr */
+ register int c; /* current-character pointer */
+ char negclass; /* all-but flag */
+ char *lastep; /* ptr to last expr compiled */
+ char *svclass; /* start of current char class */
+ char brnest[MAXTAGS]; /* bracket-nesting array */
+ char *brnestp; /* ptr to current bracket-nest */
+ int classct; /* class element count */
+ int tags; /* # of closed tags */
+
+ if (*cp == redelim) /* if first char is RE endmarker */
+ return(cp++, expbuf); /* leave existing RE unchanged */
+
+ lastep = NULL; /* there's no previous RE */
+ brnestp = brnest; /* initialize ptr to brnest array */
+ tags = bcount = 0; /* initialize counters */
+
+ if (*ep++ = (*sp == '^')) /* check for start-of-line syntax */
+ sp++;
+
+ for (;;) {
+ if (ep >= expbuf + RELIMIT) /* match is too large */
+ return(cp = sp, BAD);
+ if ((c = *sp++) == redelim) { /* found the end of the RE */
+ cp = sp;
+ if (brnestp != brnest) /* \(, \) unbalanced */
+ return(BAD);
+ *ep++ = CEOF; /* write end-of-pattern mark */
+ return(ep); /* return ptr to compiled RE */
+ }
+ if (c != '*') /* if we're a postfix op */
+ lastep = ep; /* get ready to match last */
+
+ switch (c) {
+ case '\\':
+ if ((c = *sp++) == '(') { /* start tagged section */
+ if (bcount >= MAXTAGS) return(cp = sp, BAD);
+ *brnestp++ = bcount; /* update tag stack */
+ *ep++ = CBRA; /* enter tag-start */
+ *ep++ = bcount++; /* bump tag count */
+ continue;
+ } else if (c == ')') { /* end tagged section */
+ if (brnestp <= brnest) /* extra \) */
+ return(cp = sp, BAD);
+ *ep++ = CKET; /* enter end-of-tag */
+ *ep++ = *--brnestp; /* pop tag stack */
+ tags++; /* count closed tags */
+ continue;
+ } else if (c >= '1' && c <= '9') { /* tag use */
+ if ((c -= '1') >= tags) /* too few */
+ return(BAD);
+ *ep++ = CBACK; /* enter tag mark */
+ *ep++ = c; /* and the number */
+ continue;
+ } else if (c == '\n') /* escaped newline no good */
+ return(cp = sp, BAD);
+ else if (c == 'n') /* match a newline */
+ c = '\n';
+ else if (c == 't') /* match a tab */
+ c = '\t';
+ else if (c == 'r') /* match a return */
+ c = '\r';
+ goto defchar;
+
+ case '\0': /* ignore nuls */
+ continue;
+
+ case '\n': /* trailing pattern delimiter is missing */
+ return(cp = sp, BAD);
+
+ case '.': /* match any char except newline */
+ *ep++ = CDOT;
+ continue;
+ case '*': /* 0..n repeats of previous pattern */
+ if (lastep == NULL) /* if * isn't first on line */
+ goto defchar; /* match a literal * */
+ if (*lastep == CKET) /* can't iterate a tag */
+ return(cp = sp, BAD);
+ *lastep |= STAR;/* flag previous pattern */
+ continue;
+
+ case '$': /* match only end-of-line */
+ if (*sp != redelim) /* if we're not at end of RE */
+ goto defchar; /* match a literal $ */
+ *ep++ = CDOL; /* insert end-symbol mark */
+ continue;
+
+ case '[': /* begin character set pattern */
+ if (ep + 17 >= expbuf + RELIMIT) ABORT(REITL);
+ *ep++ = CCL; /* insert class mark */
+ if (negclass = ((c = *sp++) == '^')) c = *sp++;
+ svclass = sp; /* save ptr to class start */
+ do {
+ if (c == '\0') ABORT(CGMSG);
+
+ /* Handle character ranges */
+ if (c == '-' && sp > svclass && *sp != ']')
+ for (c = sp[-2]; c < *sp; c++)
+ ep[c >> 3] |= bits[c & 7];
+
+ /* Handle escape sequences in sets */
+ if (c == '\\')
+ if ((c = *sp++) == 'n')
+ c = '\n';
+ else if (c == 't')
+ c = '\t';
+ else if (c == 'r')
+ c = '\r';
+
+ /* Enter (possibly translated) char in set */
+ ep[c >> 3] |= bits[c & 7];
+ } while
+ ((c = *sp++) != ']');
+
+ /* Invert the bitmask if all-but was specified */
+ if (negclass) for (classct = 0; classct < 16; classct++)
+ ep[classct] ^= 0xFF;
+ ep[0] &= 0xFE; /* never match ASCII 0 */
+ ep += 16; /* advance ep past set mask */
+ continue;
+
+ defchar: /* match literal character */
+ default: /* which is what we'd do by default */
+ *ep++ = CCHR; /* insert character mark */
+ *ep++ = c;
+ }
+ }
+}
+
+static int cmdline(cbuf) /* uses eflag, eargc, cmdf */
+ /* Read next command from -e argument or command file */
+register char *cbuf;
+{
+ register int inc; /* not char because must hold EOF */
+
+ *cbuf-- = 0; /* so pre-increment points us at cbuf */
+
+ /* E command flag is on */
+ if (eflag) {
+ register char *p; /* ptr to current -e argument */
+ static char *savep; /* saves previous value of p */
+
+ if (eflag > 0) { /* there are pending -e arguments */
+ eflag = -1;
+ if (eargc-- <= 0) quit(2); /* if no arguments, barf */
+
+ /* Else transcribe next e argument into cbuf */
+ p = *++eargv;
+ while (*++cbuf = *p++)
+ if (*cbuf == '\\') {
+ if ((*++cbuf = *p++) == '\0')
+ return(savep = NULL, -1);
+ else
+ continue;
+ } else if (*cbuf == '\n') { /* end of 1 cmd line */
+ *cbuf = '\0';
+ return(savep = p, 1);
+ /* We'll be back for the rest... */
+ }
+
+ /* Found end-of-string; can advance to next argument */
+ return(savep = NULL, 1);
+ }
+ if ((p = savep) == NULL) return(-1);
+
+ while (*++cbuf = *p++)
+ if (*cbuf == '\\') {
+ if ((*++cbuf = *p++) == '0')
+ return(savep = NULL, -1);
+ else
+ continue;
+ } else if (*cbuf == '\n') {
+ *cbuf = '\0';
+ return(savep = p, 1);
+ }
+ return(savep = NULL, 1);
+ }
+
+ /* If no -e flag read from command file descriptor */
+ while ((inc = getc(cmdf)) != EOF) /* get next char */
+ if ((*++cbuf = inc) == '\\') /* if it's escape */
+ *++cbuf = inc = getc(cmdf); /* get next char */
+ else if (*cbuf == '\n') /* end on newline */
+ return(*cbuf = '\0', 1); /* cap the string */
+
+ return(*++cbuf = '\0', -1); /* end-of-file, no more chars */
+}
+
+static char *address(expbuf) /* uses cp, linenum */
+ /* Expand an address at *cp... into expbuf, return ptr at following char */
+register char *expbuf;
+{
+ static int numl = 0; /* current ind in addr-number table */
+ register char *rcp; /* temp compile ptr for forwd look */
+ long lno; /* computed value of numeric address */
+
+ if (*cp == '$') { /* end-of-source address */
+ *expbuf++ = CEND; /* write symbolic end address */
+ *expbuf++ = CEOF; /* and the end-of-address mark (!) */
+ cp++; /* go to next source character */
+ return(expbuf); /* we're done */
+ }
+ if (*cp == '/' || *cp == '\\') { /* start of regular-expression match */
+ if (*cp == '\\') cp++;
+ return(recomp(expbuf, *cp++)); /* compile the RE */
+ }
+
+ rcp = cp;
+ lno = 0; /* now handle a numeric address */
+ while (*rcp >= '0' && *rcp <= '9') /* collect digits */
+ lno = lno * 10 + *rcp++ - '0'; /* compute their value */
+
+ if (rcp > cp) { /* if we caught a number... */
+ *expbuf++ = CLNUM; /* put a numeric-address marker */
+ *expbuf++ = numl; /* and the address table index */
+ linenum[numl++] = lno; /* and set the table entry */
+ if (numl >= MAXLINES) /* oh-oh, address table overflow */
+ ABORT(TMLNR); /* abort with error message */
+ *expbuf++ = CEOF; /* write the end-of-address marker */
+ cp = rcp; /* point compile past the address */
+ return(expbuf); /* we're done */
+ }
+ return(NULL); /* no legal address was found */
+}
+
+static char *gettext(txp) /* uses global cp */
+ /* Accept multiline input from *cp..., discarding leading whitespace */
+register char *txp; /* where to put the text */
+{
+ register char *p = cp; /* this is for speed */
+
+ SKIPWS(p); /* discard whitespace */
+ do {
+ if ((*txp = *p++) == '\\') /* handle escapes */
+ *txp = *p++;
+ if (*txp == '\0') /* we're at end of input */
+ return(cp = --p, ++txp);
+ else if (*txp == '\n') /* also SKIPWS after newline */
+ SKIPWS(p);
+ } while
+ (txp++); /* keep going till we find that nul */
+ return(txp);
+}
+
+static label *search(ptr) /* uses global lablst */
+ /* Find the label matching *ptr, return NULL if none */
+register label *ptr;
+{
+ register label *rp;
+ for (rp = lablst; rp < ptr; rp++)
+ if ((rp->name != NULL) && (strcmp(rp->name, ptr->name) == 0))
+ return(rp);
+ return(NULL);
+}
+
+static void resolve()
+{ /* uses global lablst */
+ /* Write label links into the compiled-command space */
+ register label *lptr;
+ register sedcmd *rptr, *trptr;
+
+ /* Loop through the label table */
+ for (lptr = lablst; lptr < lab; lptr++)
+ if (lptr->address == NULL) { /* barf if not defined */
+ fprintf(stderr, ULABL, lptr->name);
+ quit(2);
+ } else if (lptr->last) {/* if last is non-null */
+ rptr = lptr->last; /* chase it */
+ while (trptr = rptr->u.link) { /* resolve refs */
+ rptr->u.link = lptr->address;
+ rptr = trptr;
+ }
+ rptr->u.link = lptr->address;
+ }
+}
+
+static char *ycomp(ep, delim)
+/* Compile a y (transliterate) command */
+register char *ep; /* where to compile to */
+char delim; /* end delimiter to look for */
+{
+ register char *tp, *sp;
+ register int c;
+
+ /* Scan the 'from' section for invalid chars */
+ for (sp = tp = cp; *tp != delim; tp++) {
+ if (*tp == '\\') tp++;
+ if ((*tp == '\n') || (*tp == '\0')) return (BAD);
+ }
+ tp++; /* tp now points at first char of 'to'
+ * section */
+
+ /* Now rescan the 'from' section */
+ while ((c = *sp++ & 0x7F) != delim) {
+ if (c == '\\' && *sp == 'n') {
+ sp++;
+ c = '\n';
+ }
+ if ((ep[c] = *tp++) == '\\' && *tp == 'n') {
+ ep[c] = '\n';
+ tp++;
+ }
+ if ((ep[c] == delim) || (ep[c] == '\0')) return(BAD);
+ }
+
+ if (*tp != delim) /* 'to', 'from' parts have unequal lengths */
+ return(BAD);
+
+ cp = ++tp; /* point compile ptr past translit */
+
+ for (c = 0; c < 128; c++) /* fill in self-map entries in table */
+ if (ep[c] == 0) ep[c] = c;
+
+ return(ep + 0x80); /* return first free location past table end */
+}
+
+void quit(n)
+int n;
+{
+/* Flush buffers and exit. Now a historical relic. Rely on exit to flush
+ * the buffers.
+ */
+ exit(n);
+}
+
+/*+++++++++++++++*/
+
+/*
+ sedexec.c -- execute compiled form of stream editor commands
+
+ The single entry point of this module is the function execute(). It
+ may take a string argument (the name of a file to be used as text) or
+ the argument NULL which tells it to filter standard input. It executes
+ the compiled commands in cmds[] on each line in turn.
+
+ The function command() does most of the work. Match() and advance()
+ are used for matching text against precompiled regular expressions and
+ dosub() does right-hand-side substitution. Getline() does text input;
+ readout() and Memcmp() are output and string-comparison utilities.
+*/
+
+/* #include <stdio.h> */
+/* #include <ctype.h> */
+/* #include "sed.h" */
+
+/***** shared variables imported from the main ******/
+
+/* Main data areas */
+extern char linebuf[]; /* current-line buffer */
+extern sedcmd cmds[]; /* hold compiled commands */
+extern long linenum[]; /* numeric-addresses table */
+
+/* Miscellaneous shared variables */
+extern int nflag; /* -n option flag */
+extern int eargc; /* scratch copy of argument count */
+extern char **eargv; /* scratch copy of argument list */
+extern char bits[]; /* the bits table */
+
+/***** end of imported stuff *****/
+
+#define MAXHOLD MAXBUF /* size of the hold space */
+#define GENSIZ MAXBUF /* maximum genbuf size */
+
+#define TRUE 1
+#define FALSE 0
+
+static char LTLMSG[] = "sed: line too long\n";
+
+static char *spend; /* current end-of-line-buffer pointer */
+static long lnum = 0L; /* current source line number */
+
+/* Append buffer maintenance */
+static sedcmd *appends[MAXAPPENDS]; /* array of ptrs to a,i,c commands */
+static sedcmd **aptr = appends; /* ptr to current append */
+
+/* Genbuf and its pointers */
+static char genbuf[GENSIZ];
+static char *loc1;
+static char *loc2;
+static char *locs;
+
+/* Command-logic flags */
+static int lastline; /* do-line flag */
+static int jump; /* jump to cmd's link address if set */
+static int delete; /* delete command flag */
+
+/* Tagged-pattern tracking */
+static char *bracend[MAXTAGS]; /* tagged pattern start pointers */
+static char *brastart[MAXTAGS]; /* tagged pattern end pointers */
+
+static int anysub; /* true if any s on current line succeeded */
+
+
+void execute()
+/* Execute the compiled commands in cmds[] */
+{
+ register char *p1; /* dummy copy ptrs */
+ register sedcmd *ipc; /* ptr to current command */
+ char *execp; /* ptr to source */
+
+
+ initget();
+
+ /* Here's the main command-execution loop */
+ for (;;) {
+
+ /* Get next line to filter */
+ if ((execp = getline(linebuf)) == BAD) return;
+ spend = execp;
+ anysub = FALSE;
+
+ /* Loop through compiled commands, executing them */
+ for (ipc = cmds; ipc->command;) {
+ if (!selected(ipc)) {
+ ipc++;
+ continue;
+ }
+ command(ipc); /* execute the command pointed at */
+
+ if (delete) /* if delete flag is set */
+ break; /* don't exec rest of compiled cmds */
+
+ if (jump) { /* if jump set, follow cmd's link */
+ jump = FALSE;
+ if ((ipc = ipc->u.link) == 0) {
+ ipc = cmds;
+ break;
+ }
+ } else /* normal goto next command */
+ ipc++;
+ }
+
+ /* We've now done all modification commands on the line */
+
+ /* Here's where the transformed line is output */
+ if (!nflag && !delete) {
+ for (p1 = linebuf; p1 < spend; p1++) putc(*p1, stdout);
+ putc('\n', stdout);
+ }
+
+ /* If we've been set up for append, emit the text from it */
+ if (aptr > appends) readout();
+
+ delete = FALSE; /* clear delete flag; about to get next cmd */
+ }
+}
+
+static int selected(ipc)
+/* Is current command selected */
+sedcmd *ipc;
+{
+ register char *p1 = ipc->addr1; /* point p1 at first address */
+ register char *p2 = ipc->addr2; /* and p2 at second */
+ int c;
+ int sel = TRUE; /* select by default */
+
+ if (!p1) /* No addresses: always selected */
+ ;
+ else if (ipc->flags.inrange) {
+ if (*p2 == CEND);
+ else if (*p2 == CLNUM) {
+ c = p2[1] & CMASK;
+ if (lnum >= linenum[c]) {
+ ipc->flags.inrange = FALSE;
+ if (lnum > linenum[c]) sel = FALSE;
+ }
+ } else if (match(p2, 0))
+ ipc->flags.inrange = FALSE;
+ } else if (*p1 == CEND) {
+ if (!lastline) sel = FALSE;
+ } else if (*p1 == CLNUM) {
+ c = p1[1] & CMASK;
+ if (lnum != linenum[c])
+ sel = FALSE;
+ else if (p2)
+ ipc->flags.inrange = TRUE;
+ } else if (match(p1, 0)) {
+ if (p2) ipc->flags.inrange = TRUE;
+ } else
+ sel = FALSE;
+
+ return ipc->flags.allbut ? !sel : sel;
+}
+
+static int match(expbuf, gf) /* uses genbuf */
+ /* Match RE at expbuf against linebuf; if gf set, copy linebuf from genbuf */
+char *expbuf;
+int gf;
+{
+ register char *p1, *p2, c;
+
+ if (gf) {
+ if (*expbuf) return(FALSE);
+ p1 = linebuf;
+ p2 = genbuf;
+ while (*p1++ = *p2++);
+ locs = p1 = loc2;
+ } else {
+ p1 = linebuf;
+ locs = FALSE;
+ }
+
+ p2 = expbuf;
+ if (*p2++) {
+ loc1 = p1;
+ if (*p2 == CCHR && p2[1] != *p1) /* 1st char is wrong */
+ return(FALSE); /* so fail */
+ return(advance(p1, p2));/* else try to match rest */
+ }
+
+ /* Quick check for 1st character if it's literal */
+ if (*p2 == CCHR) {
+ c = p2[1]; /* pull out character to search for */
+ do {
+ if (*p1 != c) continue; /* scan the source string */
+ if (advance(p1, p2)) /* found it, match the rest */
+ return(loc1 = p1, 1);
+ } while
+ (*p1++);
+ return(FALSE); /* didn't find that first char */
+ }
+
+ /* Else try for unanchored match of the pattern */
+ do {
+ if (advance(p1, p2)) return(loc1 = p1, 1);
+ } while
+ (*p1++);
+
+ /* If got here, didn't match either way */
+ return(FALSE);
+}
+
+static int advance(lp, ep)
+/* Attempt to advance match pointer by one pattern element */
+register char *lp; /* source (linebuf) ptr */
+register char *ep; /* regular expression element ptr */
+{
+ register char *curlp; /* save ptr for closures */
+ char c; /* scratch character holder */
+ char *bbeg;
+ int ct;
+
+ for (;;) switch (*ep++) {
+ case CCHR: /* literal character */
+ if (*ep++ == *lp++) /* if chars are equal */
+ continue; /* matched */
+ return(FALSE); /* else return false */
+
+ case CDOT: /* anything but newline */
+ if (*lp++) /* first NUL is at EOL */
+ continue; /* keep going if didn't find */
+ return(FALSE); /* else return false */
+
+ case CNL: /* start-of-line */
+ case CDOL: /* end-of-line */
+ if (*lp == 0) /* found that first NUL? */
+ continue; /* yes, keep going */
+ return(FALSE); /* else return false */
+
+ case CEOF: /* end-of-address mark */
+ loc2 = lp; /* set second loc */
+ return(TRUE); /* return true */
+
+ case CCL: /* a closure */
+ c = *lp++ & 0177;
+ if (ep[c >> 3] & bits[c & 07]) { /* is char in set? */
+ ep += 16; /* then skip rest of bitmask */
+ continue; /* and keep going */
+ }
+ return(FALSE); /* else return false */
+
+ case CBRA: /* start of tagged pattern */
+ brastart[*ep++] = lp; /* mark it */
+ continue; /* and go */
+
+ case CKET: /* end of tagged pattern */
+ bracend[*ep++] = lp; /* mark it */
+ continue; /* and go */
+
+ case CBACK:
+ bbeg = brastart[*ep];
+ ct = bracend[*ep++] - bbeg;
+
+ if (Memcmp(bbeg, lp, ct)) {
+ lp += ct;
+ continue;
+ }
+ return(FALSE);
+
+ case CBACK | STAR:
+ bbeg = brastart[*ep];
+ ct = bracend[*ep++] - bbeg;
+ curlp = lp;
+ while (Memcmp(bbeg, lp, ct)) lp += ct;
+
+ while (lp >= curlp) {
+ if (advance(lp, ep)) return(TRUE);
+ lp -= ct;
+ }
+ return(FALSE);
+
+
+ case CDOT | STAR: /* match .* */
+ curlp = lp; /* save closure start loc */
+ while (*lp++); /* match anything */
+ goto star; /* now look for followers */
+
+ case CCHR | STAR: /* match <literal char>* */
+ curlp = lp; /* save closure start loc */
+ while (*lp++ == *ep); /* match many of that char */
+ ep++; /* to start of next element */
+ goto star; /* match it and followers */
+
+ case CCL | STAR: /* match [...]* */
+ curlp = lp; /* save closure start loc */
+ do {
+ c = *lp++ & 0x7F; /* match any in set */
+ } while
+ (ep[c >> 3] & bits[c & 07]);
+ ep += 16; /* skip past the set */
+ goto star; /* match followers */
+
+ star: /* the recursion part of a * or + match */
+ if (--lp == curlp) /* 0 matches */
+ continue;
+
+ if (*ep == CCHR) {
+ c = ep[1];
+ do {
+ if (*lp != c) continue;
+ if (advance(lp, ep)) return (TRUE);
+ } while
+ (lp-- > curlp);
+ return(FALSE);
+ }
+ if (*ep == CBACK) {
+ c = *(brastart[ep[1]]);
+ do {
+ if (*lp != c) continue;
+ if (advance(lp, ep)) return (TRUE);
+ } while
+ (lp-- > curlp);
+ return(FALSE);
+ }
+ do {
+ if (lp == locs) break;
+ if (advance(lp, ep)) return (TRUE);
+ } while
+ (lp-- > curlp);
+ return(FALSE);
+
+ default:
+ fprintf(stderr, "sed: RE error, %o\n", *--ep);
+ quit(2);
+ }
+}
+
+static int substitute(ipc)
+/* Perform s command */
+sedcmd *ipc; /* ptr to s command struct */
+{
+ int nullmatch;
+
+ if (match(ipc->u.lhs, 0)) { /* if no match */
+ nullmatch = (loc1 == loc2);
+ dosub(ipc->rhs); /* perform it once */
+ } else
+ return(FALSE); /* command fails */
+
+ if (ipc->flags.global) /* if global flag enabled */
+ while (*loc2) { /* cycle through possibles */
+ if (nullmatch) loc2++;
+ if (match(ipc->u.lhs, 1)) { /* found another */
+ nullmatch = (loc1 == loc2);
+ dosub(ipc->rhs); /* so substitute */
+ } else /* otherwise, */
+ break; /* we're done */
+ }
+ return(TRUE); /* we succeeded */
+}
+
+static void dosub(rhsbuf) /* uses linebuf, genbuf, spend */
+ /* Generate substituted right-hand side (of s command) */
+char *rhsbuf; /* where to put the result */
+{
+ register char *lp, *sp, *rp;
+ int c;
+
+ /* Copy linebuf to genbuf up to location 1 */
+ lp = linebuf;
+ sp = genbuf;
+ while (lp < loc1) *sp++ = *lp++;
+
+ for (rp = rhsbuf; c = *rp++;) {
+ if (c == '&') {
+ sp = place(sp, loc1, loc2);
+ continue;
+ } else if (c & 0200 && (c &= 0177) >= '1' && c < MAXTAGS + '1') {
+ sp = place(sp, brastart[c - '1'], bracend[c - '1']);
+ continue;
+ }
+ *sp++ = c & 0177;
+ if (sp >= genbuf + MAXBUF) fprintf(stderr, LTLMSG);
+ }
+ lp = loc2;
+ loc2 = sp - genbuf + linebuf;
+ while (*sp++ = *lp++)
+ if (sp >= genbuf + MAXBUF) fprintf(stderr, LTLMSG);
+ lp = linebuf;
+ sp = genbuf;
+ while (*lp++ = *sp++);
+ spend = lp - 1;
+}
+
+static char *place(asp, al1, al2) /* uses genbuf */
+ /* Place chars at *al1...*(al1 - 1) at asp... in genbuf[] */
+register char *asp, *al1, *al2;
+{
+ while (al1 < al2) {
+ *asp++ = *al1++;
+ if (asp >= genbuf + MAXBUF) fprintf(stderr, LTLMSG);
+ }
+ return(asp);
+}
+
+static void listto(p1, fp)
+/* Write a hex dump expansion of *p1... to fp */
+register char *p1; /* the source */
+FILE *fp; /* output stream to write to */
+{
+ p1--;
+ while (*p1++)
+ if (isprint(*p1))
+ putc(*p1, fp); /* pass it through */
+ else {
+ putc('\\', fp); /* emit a backslash */
+ switch (*p1) {
+ case '\b':
+ putc('b', fp);
+ break; /* BS */
+ case '\t':
+ putc('t', fp);
+ break; /* TAB */
+ case '\n':
+ putc('n', fp);
+ break; /* NL */
+ case '\r':
+ putc('r', fp);
+ break; /* CR */
+ case '\33':
+ putc('e', fp);
+ break; /* ESC */
+ default:
+ fprintf(fp, "%02x", *p1 & 0xFF);
+ }
+ }
+ putc('\n', fp);
+}
+
+static void truncated(h)
+int h;
+{
+ static long last = 0L;
+
+ if (lnum == last) return;
+ last = lnum;
+
+ fprintf(stderr, "sed: ");
+ fprintf(stderr, h ? "hold space" : "line %ld", lnum);
+ fprintf(stderr, " truncated to %d characters\n", MAXBUF);
+}
+
+static void command(ipc)
+/* Execute compiled command pointed at by ipc */
+sedcmd *ipc;
+{
+ static char holdsp[MAXHOLD + 1]; /* the hold space */
+ static char *hspend = holdsp; /* hold space end pointer */
+ register char *p1, *p2;
+ char *execp;
+ int didsub; /* true if last s succeeded */
+
+ switch (ipc->command) {
+ case ACMD: /* append */
+ *aptr++ = ipc;
+ if (aptr >= appends + MAXAPPENDS) fprintf(stderr,
+ "sed: too many appends after line %ld\n",
+ lnum);
+ *aptr = 0;
+ break;
+
+ case CCMD: /* change pattern space */
+ delete = TRUE;
+ if (!ipc->flags.inrange || lastline) printf("%s\n", ipc->u.lhs);
+ break;
+
+ case DCMD: /* delete pattern space */
+ delete++;
+ break;
+
+ case CDCMD: /* delete a line in hold space */
+ p1 = p2 = linebuf;
+ while (*p1 != '\n')
+ if (delete = (*p1++ == 0)) return;
+ p1++;
+ while (*p2++ = *p1++) continue;
+ spend = p2 - 1;
+ jump++;
+ break;
+
+ case EQCMD: /* show current line number */
+ fprintf(stdout, "%ld\n", lnum);
+ break;
+
+ case GCMD: /* copy hold space to pattern space */
+ p1 = linebuf;
+ p2 = holdsp;
+ while (*p1++ = *p2++);
+ spend = p1 - 1;
+ break;
+
+ case CGCMD: /* append hold space to pattern space */
+ *spend++ = '\n';
+ p1 = spend;
+ p2 = holdsp;
+ do
+ if (p1 > linebuf + MAXBUF) {
+ truncated(0);
+ p1[-1] = 0;
+ break;
+ }
+ while (*p1++ = *p2++);
+
+ spend = p1 - 1;
+ break;
+
+ case HCMD: /* copy pattern space to hold space */
+ p1 = holdsp;
+ p2 = linebuf;
+ while (*p1++ = *p2++);
+ hspend = p1 - 1;
+ break;
+
+ case CHCMD: /* append pattern space to hold space */
+ *hspend++ = '\n';
+ p1 = hspend;
+ p2 = linebuf;
+ do
+ if (p1 > holdsp + MAXBUF) {
+ truncated(1);
+ p1[-1] = 0;
+ break;
+ }
+ while (*p1++ = *p2++);
+
+ hspend = p1 - 1;
+ break;
+
+ case ICMD: /* insert text */
+ printf("%s\n", ipc->u.lhs);
+ break;
+
+ case BCMD: /* branch to label */
+ jump = TRUE;
+ break;
+
+ case LCMD: /* list text */
+ listto(linebuf, (ipc->fout != NULL) ? ipc->fout : stdout);
+ break;
+
+ case NCMD: /* read next line into pattern space */
+ if (!nflag) puts(linebuf); /* flush out the current line */
+ if (aptr > appends) readout(); /* do pending a, r commands */
+ if ((execp = getline(linebuf)) == BAD) {
+ delete = TRUE;
+ break;
+ }
+ spend = execp;
+ anysub = FALSE;
+ break;
+
+ case CNCMD: /* append next line to pattern space */
+ if (aptr > appends) readout();
+ *spend++ = '\n';
+ if ((execp = getline(spend)) == BAD) {
+ *--spend = 0;
+ break;
+ }
+ spend = execp;
+ anysub = FALSE;
+ break;
+
+ case PCMD: /* print pattern space */
+ puts(linebuf);
+ break;
+
+ case CPCMD: /* print one line from pattern space */
+cpcom: /* so s command can jump here */
+ for (p1 = linebuf; *p1 != '\n' && *p1 != '\0';) putc(*p1++, stdout);
+ putc('\n', stdout);
+ break;
+
+ case QCMD: /* quit the stream editor */
+ if (!nflag) puts(linebuf); /* flush out the current line */
+ if (aptr > appends)
+ readout(); /* do any pending a and r commands */
+ quit(0);
+
+ case RCMD: /* read a file into the stream */
+ *aptr++ = ipc;
+ if (aptr >= appends + MAXAPPENDS) fprintf(stderr,
+ "sed: too many reads after line %ld\n",
+ lnum);
+ *aptr = 0;
+ break;
+
+ case SCMD: /* substitute RE */
+ didsub = substitute(ipc);
+ if (didsub) anysub = TRUE;
+ if (ipc->flags.print && didsub)
+ if (ipc->flags.print == TRUE)
+ puts(linebuf);
+ else
+ goto cpcom;
+ if (didsub && ipc->fout) fprintf(ipc->fout, "%s\n", linebuf);
+ break;
+
+ case TCMD: /* branch on any s successful */
+ case CTCMD: /* branch on any s failed */
+ if (anysub == (ipc->command == CTCMD))
+ break; /* no branch if any s failed, else */
+ anysub = FALSE;
+ jump = TRUE; /* set up to jump to assoc'd label */
+ break;
+
+ case CWCMD: /* write one line from pattern space */
+ for (p1 = linebuf; *p1 != '\n' && *p1 != '\0';)
+ putc(*p1++, ipc->fout);
+ putc('\n', ipc->fout);
+ break;
+
+ case WCMD: /* write pattern space to file */
+ fprintf(ipc->fout, "%s\n", linebuf);
+ break;
+
+ case XCMD: /* exchange pattern and hold spaces */
+ p1 = linebuf;
+ p2 = genbuf;
+ while (*p2++ = *p1++) continue;
+ p1 = holdsp;
+ p2 = linebuf;
+ while (*p2++ = *p1++) continue;
+ spend = p2 - 1;
+ p1 = genbuf;
+ p2 = holdsp;
+ while (*p2++ = *p1++) continue;
+ hspend = p2 - 1;
+ break;
+
+ case YCMD:
+ p1 = linebuf;
+ p2 = ipc->u.lhs;
+ while (*p1 = p2[*p1]) p1++;
+ break;
+ }
+}
+
+static void openfile(file)
+char *file;
+/* Replace stdin by given file */
+{
+ if (freopen(file, "r", stdin) == NULL) {
+ fprintf(stderr, "sed: can't open %s\n", file);
+ quit(1);
+ }
+}
+
+static int c; /* Will be the next char to read, a kind of
+ * lookahead */
+
+static void get()
+/* Read next character into c treating all argument files as run through cat */
+{
+ while ((c = getchar()) == EOF && --eargc >= 0) openfile(*eargv++);
+}
+
+static void initget()
+/* Initialise character input */
+{
+ if (--eargc >= 0) openfile(*eargv++); /* else input == stdin */
+ get();
+}
+
+static char *getline(buf)
+/* Get next line of text to be edited, return pointer to end */
+register char *buf; /* where to send the input */
+{
+ if (c == EOF) return BAD;
+
+ lnum++; /* we can read a new line */
+
+ do {
+ if (c == '\n') {
+ get();
+ break;
+ }
+ if (buf <= linebuf + MAXBUF) *buf++ = c;
+ get();
+ } while (c != EOF);
+
+ if (c == EOF) lastline = TRUE;
+
+ if (buf > linebuf + MAXBUF) {
+ truncated(0);
+ --buf;
+ }
+ *buf = 0;
+ return buf;
+}
+
+static int Memcmp(a, b, count)
+/* Return TRUE if *a... == *b... for count chars, FALSE otherwise */
+register char *a, *b;
+int count;
+{
+ while (count--) /* look at count characters */
+ if (*a++ != *b++) /* if any are nonequal */
+ return(FALSE); /* return FALSE for false */
+ return(TRUE); /* compare succeeded */
+}
+
+static void readout()
+/* Write file indicated by r command to output */
+{
+ register int t; /* hold input char or EOF */
+ FILE *fi; /* ptr to file to be read */
+
+ aptr = appends - 1; /* arrange for pre-increment to work right */
+ while (*++aptr)
+ if ((*aptr)->command == ACMD) /* process "a" cmd */
+ printf("%s\n", (*aptr)->u.lhs);
+ else { /* process "r" cmd */
+ if ((fi = fopen((*aptr)->u.lhs, "r")) == NULL) {
+ fprintf(stderr, "sed: can't open %s\n",
+ (*aptr)->u.lhs);
+ continue;
+ }
+ while ((t = getc(fi)) != EOF) putc((char) t, stdout);
+ fclose(fi);
+ }
+ aptr = appends; /* reset the append ptr */
+ *aptr = 0;
+}
+
+/* Sedexec.c ends here */