1613 lines
45 KiB
C
Executable file
1613 lines
45 KiB
C
Executable file
/* 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 */
|