static void
process(FILE *f)
{
int i, n;
char mac[5]; /* The current macro or nroff command */
int pl;
stktop = -1;
for (lineno = 1; fgets(line, sizeof(line), f); lineno++) {
if (line[0] == '.') {
/*
* find and isolate the macro/command name.
*/
strncpy(mac, line + 1, 4);
if (isspace(mac[0])) {
pe(lineno);
printf("Empty command\n");
} else if (isspace(mac[1])) {
mac[1] = 0;
} else if (isspace(mac[2])) {
mac[2] = 0;
} else if (mac[0] != '\\' || mac[1] != '\"') {
pe(lineno);
printf("Command too long\n");
}
/*
* Is it a known command?
*/
checkknown(mac);
/*
* Should we add it?
*/
if (eq(mac, "de"))
addcmd(line);
chkcmd(mac);
}
/*
* At this point we process the line looking
* for \s and \f.
*/
for (i = 0; line[i]; i++) {
if (line[i] == '\\' && (i == 0 || line[i-1] != '\\')) {
if (!sflag && line[++i] == 's') {
pl = line[++i];
if (isdigit(pl)) {
n = pl - '0';
pl = ' ';
} else
n = 0;
while (isdigit(line[++i]))
n = 10 * n + line[i] - '0';
i--;
if (n == 0) {
if (stk[stktop].opno == SZ) {
stktop--;
} else {
pe(lineno);
printf("unmatched \\s0\n");
}
} else {
stk[++stktop].opno = SZ;
stk[stktop].pl = pl;
stk[stktop].parm = n;
stk[stktop].lno = lineno;
}
} else if (!fflag && line[i] == 'f') {
n = line[++i];
if (n == 'P') {
if (stk[stktop].opno == FT) {
stktop--;
} else {
pe(lineno);
printf("unmatched \\fP\n");
}
} else {
stk[++stktop].opno = FT;
stk[stktop].pl = 1;
stk[stktop].parm = n;
stk[stktop].lno = lineno;
}
}
}
}
}
/*
* We've hit the end and look at all this stuff that hasn't been
* matched yet! Complain, complain.
*/
for (i = stktop; i >= 0; i--) {
complain(i);
}
}
interact()
{
int i, intrpt();
char cmd[80], *rest, *index();
for (;;) {
if (firsttime++ == 0) {
signal(SIGINT, intrpt, -1);
setret(env);
}
if (cmdinp(cmd) < 0)
return (0);
rest = index(cmd, ' ');
if (rest)
*rest++ = '\0';
i = chkcmd(cmd);
#ifdef DEBUG
printf("command: %s, ind: %d\n", cmd, i);
#endif
switch (i) {
default:
errinp;
break;
case CMD_DIR:
case CMD_LS:
dispdir();
break;
case CMD_RENAME:
rename(rest);
break;
case CMD_OCOPY:
copyc(rest, 0);
break;
case CMD_ICOPY:
pip(rest, 0);
break;
case CMD_DELETE:
case CMD_ERASE:
delete(rest);
break;
case CMD_EXIT:
case CMD_LOGOUT:
return(0);
case CMD_TYPE:
copy(rest, stdout, 0);
break;
case CMD_HELP:
help();
break;
case CMD_OCCOPY:
copyc(rest, 1);
break;
case CMD_ICCOPY:
pip(rest,1);
break;
case CMD_DUMP:
dump(rest);
break;
case CMD_UNIX:
system(rest);
break;
case CMD_DISK:
disk();
break;
}
}
}
int
main(int argc, char *argv[])
{
extern int optind;
extern char *optarg;
enum S command = COMMAND, state;
DB *dbp;
DBT data, key, keydata;
size_t len;
int ch, oflags, sflag;
char *fname, *infoarg, *p, *t, buf[8 * 1024];
bool unlink_dbfile;
infoarg = NULL;
fname = NULL;
unlink_dbfile = false;
oflags = O_CREAT | O_RDWR;
sflag = 0;
while ((ch = getopt(argc, argv, "f:i:lo:s")) != -1)
switch (ch) {
case 'f':
fname = optarg;
break;
case 'i':
infoarg = optarg;
break;
case 'l':
oflags |= DB_LOCK;
break;
case 'o':
if ((ofd = open(optarg,
O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
err(1, "Cannot create `%s'", optarg);
break;
case 's':
sflag = 1;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
/* Set the type. */
type = dbtype(*argv++);
/* Open the descriptor file. */
if (strcmp(*argv, "-") && freopen(*argv, "r", stdin) == NULL)
err(1, "Cannot reopen `%s'", *argv);
/* Set up the db structure as necessary. */
if (infoarg == NULL)
infop = NULL;
else
for (p = strtok(infoarg, ",\t "); p != NULL;
p = strtok(0, ",\t "))
if (*p != '\0')
infop = setinfo(type, p);
/*
* Open the DB. Delete any preexisting copy, you almost never
* want it around, and it often screws up tests.
*/
if (fname == NULL) {
const char *q = getenv("TMPDIR");
if (q == NULL)
q = "/var/tmp";
(void)snprintf(buf, sizeof(buf), "%s/__dbtest", q);
fname = buf;
(void)unlink(buf);
unlink_dbfile = true;
} else if (!sflag)
(void)unlink(fname);
if ((dbp = dbopen(fname,
oflags, S_IRUSR | S_IWUSR, type, infop)) == NULL)
err(1, "Cannot dbopen `%s'", fname);
XXdbp = dbp;
if (unlink_dbfile)
(void)unlink(fname);
state = COMMAND;
for (lineno = 1;
(p = fgets(buf, sizeof(buf), stdin)) != NULL; ++lineno) {
/* Delete the newline, displaying the key/data is easier. */
if (ofd == STDOUT_FILENO && (t = strchr(p, '\n')) != NULL)
*t = '\0';
if ((len = strlen(buf)) == 0 || isspace((unsigned char)*p) ||
*p == '#')
continue;
/* Convenient gdb break point. */
if (XXlineno == lineno)
XXlineno = 1;
switch (*p) {
case 'c': /* compare */
chkcmd(state);
state = KEY;
command = COMPARE;
break;
case 'e': /* echo */
chkcmd(state);
/* Don't display the newline, if CR at EOL. */
if (p[len - 2] == '\r')
--len;
if (write(ofd, p + 1, len - 1) != (ssize_t)len - 1 ||
write(ofd, "\n", 1) != 1)
err(1, "write failed");
break;
case 'g': /* get */
chkcmd(state);
state = KEY;
command = GET;
break;
case 'p': /* put */
chkcmd(state);
state = KEY;
command = PUT;
break;
case 'r': /* remove */
chkcmd(state);
if (flags == R_CURSOR) {
rem(dbp, &key);
state = COMMAND;
} else {
state = KEY;
command = REMOVE;
}
break;
case 'S': /* sync */
chkcmd(state);
synk(dbp);
state = COMMAND;
break;
case 's': /* seq */
chkcmd(state);
if (flags == R_CURSOR) {
state = KEY;
command = SEQ;
} else
seq(dbp, &key);
break;
case 'f':
flags = setflags(p + 1);
break;
case 'D': /* data file */
chkdata(state);
data.data = rfile(p + 1, &data.size);
goto ldata;
case 'd': /* data */
chkdata(state);
data.data = xcopy(p + 1, len - 1);
data.size = len - 1;
ldata: switch (command) {
case COMPARE:
compare(&keydata, &data);
break;
case PUT:
put(dbp, &key, &data);
break;
default:
errx(1, "line %zu: command doesn't take data",
lineno);
}
if (type != DB_RECNO)
free(key.data);
free(data.data);
state = COMMAND;
break;
case 'K': /* key file */
chkkey(state);
if (type == DB_RECNO)
errx(1, "line %zu: 'K' not available for recno",
lineno);
key.data = rfile(p + 1, &key.size);
goto lkey;
case 'k': /* key */
chkkey(state);
if (type == DB_RECNO) {
static recno_t recno;
recno = atoi(p + 1);
key.data = &recno;
key.size = sizeof(recno);
} else {
key.data = xcopy(p + 1, len - 1);
key.size = len - 1;
}
lkey: switch (command) {
case COMPARE:
getdata(dbp, &key, &keydata);
state = DATA;
break;
case GET:
get(dbp, &key);
if (type != DB_RECNO)
free(key.data);
state = COMMAND;
break;
case PUT:
state = DATA;
break;
case REMOVE:
rem(dbp, &key);
if ((type != DB_RECNO) && (flags != R_CURSOR))
free(key.data);
state = COMMAND;
break;
case SEQ:
seq(dbp, &key);
if ((type != DB_RECNO) && (flags != R_CURSOR))
free(key.data);
state = COMMAND;
break;
default:
errx(1, "line %zu: command doesn't take a key",
lineno);
}
break;
case 'o':
dump(dbp, p[1] == 'r', 0);
break;
#ifdef __NetBSD__
case 'O':
dump(dbp, p[1] == 'r', 1);
break;
case 'u':
unlinkpg(dbp);
break;
#endif
default:
errx(1, "line %zu: %s: unknown command character",
lineno, p);
}
}
#ifdef STATISTICS
/*
* -l must be used (DB_LOCK must be set) for this to be
* used, otherwise a page will be locked and it will fail.
*/
if (type == DB_BTREE && oflags & DB_LOCK)
__bt_stat(dbp);
#endif
if ((*dbp->close)(dbp))
err(1, "db->close failed");
(void)close(ofd);
return 0;
}