xv6-cs450/sh.c

495 lines
8.1 KiB
C
Raw Normal View History

2007-08-28 05:28:29 +02:00
// Shell.
#include "types.h"
#include "user.h"
#include "fcntl.h"
2007-08-28 05:28:29 +02:00
// Parsed command representation
#define EXEC 1
#define REDIR 2
#define PIPE 3
#define LIST 4
#define BACK 5
2007-08-28 05:28:29 +02:00
#define MAXARGS 10
2007-08-28 05:28:29 +02:00
struct cmd {
int type;
};
2007-08-28 05:28:29 +02:00
struct execcmd {
int type;
char *argv[MAXARGS];
2007-08-28 05:28:29 +02:00
char *eargv[MAXARGS];
};
2007-08-28 05:28:29 +02:00
struct redircmd {
int type;
struct cmd *cmd;
char *file;
char *efile;
int mode;
int fd;
};
2007-08-28 05:28:29 +02:00
struct pipecmd {
int type;
struct cmd *left;
struct cmd *right;
};
struct listcmd {
int type;
struct cmd *left;
struct cmd *right;
};
struct backcmd {
int type;
struct cmd *cmd;
};
2007-08-28 05:46:58 +02:00
int fork1(void); // Fork but panics on failure.
2007-08-28 05:28:29 +02:00
void panic(char*);
2007-08-28 05:46:58 +02:00
struct cmd *parsecmd(char*);
2007-08-28 05:28:29 +02:00
// Execute cmd. Never returns.
void
runcmd(struct cmd *cmd)
{
int p[2];
struct backcmd *bcmd;
struct execcmd *ecmd;
struct listcmd *lcmd;
struct pipecmd *pcmd;
struct redircmd *rcmd;
if(cmd == 0)
2007-08-28 07:19:45 +02:00
exit();
2007-08-28 05:28:29 +02:00
switch(cmd->type){
default:
panic("runcmd");
case EXEC:
ecmd = (struct execcmd*)cmd;
if(ecmd->argv[0] == 0)
exit();
exec(ecmd->argv[0], ecmd->argv);
printf(2, "exec %s failed\n", ecmd->argv[0]);
break;
case REDIR:
rcmd = (struct redircmd*)cmd;
close(rcmd->fd);
if(open(rcmd->file, rcmd->mode) < 0){
printf(2, "open %s failed\n", rcmd->file);
exit();
}
runcmd(rcmd->cmd);
break;
2007-08-28 05:46:58 +02:00
case LIST:
lcmd = (struct listcmd*)cmd;
if(fork1() == 0)
runcmd(lcmd->left);
wait();
runcmd(lcmd->right);
break;
2007-08-28 05:28:29 +02:00
case PIPE:
pcmd = (struct pipecmd*)cmd;
if(pipe(p) < 0)
panic("pipe");
if(fork1() == 0){
close(1);
dup(p[1]);
close(p[0]);
close(p[1]);
runcmd(pcmd->left);
}
if(fork1() == 0){
close(0);
dup(p[0]);
close(p[0]);
close(p[1]);
runcmd(pcmd->right);
}
close(p[0]);
close(p[1]);
wait();
wait();
break;
case BACK:
bcmd = (struct backcmd*)cmd;
if(fork1() == 0)
runcmd(bcmd->cmd);
break;
}
2007-08-08 10:39:07 +02:00
exit();
}
2007-08-10 19:00:00 +02:00
int
getcmd(char *buf, int nbuf)
{
printf(2, "$ ");
2007-08-10 19:00:00 +02:00
memset(buf, 0, nbuf);
gets(buf, nbuf);
if(buf[0] == 0) // EOF
return -1;
return 0;
}
2006-09-06 19:27:19 +02:00
int
2007-08-28 05:28:29 +02:00
main(void)
{
2007-08-28 05:28:29 +02:00
static char buf[100];
2007-08-28 05:46:58 +02:00
int fd;
// Assumes three file descriptors open.
while((fd = open("console", O_RDWR)) >= 0){
if(fd >= 3){
close(fd);
break;
}
}
// Read and run input commands.
2007-08-28 20:32:08 +02:00
while(getcmd(buf, sizeof(buf)) >= 0){
2007-08-30 20:30:26 +02:00
if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
// Clumsy but will have to do for now.
// Chdir has no effect on the parent if run in the child.
buf[strlen(buf)-1] = 0; // chop \n
if(chdir(buf+3) < 0)
printf(2, "cannot cd %s\n", buf+3);
continue;
}
2007-08-28 05:28:29 +02:00
if(fork1() == 0)
runcmd(parsecmd(buf));
wait();
}
2007-08-28 05:28:29 +02:00
exit();
}
2006-09-06 19:27:19 +02:00
2007-08-28 05:28:29 +02:00
void
panic(char *s)
{
printf(2, "%s\n", s);
exit();
}
2007-08-28 05:46:58 +02:00
int
fork1(void)
{
int pid;
pid = fork();
if(pid == -1)
panic("fork");
return pid;
}
//PAGEBREAK!
2007-08-28 05:28:29 +02:00
// Constructors
2007-08-28 05:28:29 +02:00
struct cmd*
execcmd(void)
{
struct execcmd *cmd;
2006-09-06 19:27:19 +02:00
2007-08-28 05:28:29 +02:00
cmd = malloc(sizeof(*cmd));
memset(cmd, 0, sizeof(*cmd));
cmd->type = EXEC;
return (struct cmd*)cmd;
}
2006-09-06 19:27:19 +02:00
2007-08-28 05:28:29 +02:00
struct cmd*
redircmd(struct cmd *subcmd, char *file, char *efile, int mode, int fd)
{
struct redircmd *cmd;
cmd = malloc(sizeof(*cmd));
memset(cmd, 0, sizeof(*cmd));
cmd->type = REDIR;
cmd->cmd = subcmd;
cmd->file = file;
cmd->efile = efile;
cmd->mode = mode;
cmd->fd = fd;
return (struct cmd*)cmd;
}
2007-08-28 05:28:29 +02:00
struct cmd*
pipecmd(struct cmd *left, struct cmd *right)
{
2007-08-28 05:28:29 +02:00
struct pipecmd *cmd;
cmd = malloc(sizeof(*cmd));
memset(cmd, 0, sizeof(*cmd));
cmd->type = PIPE;
cmd->left = left;
cmd->right = right;
return (struct cmd*)cmd;
}
2007-08-28 05:28:29 +02:00
struct cmd*
listcmd(struct cmd *left, struct cmd *right)
{
struct listcmd *cmd;
cmd = malloc(sizeof(*cmd));
memset(cmd, 0, sizeof(*cmd));
cmd->type = LIST;
cmd->left = left;
cmd->right = right;
return (struct cmd*)cmd;
}
2007-08-28 05:28:29 +02:00
struct cmd*
backcmd(struct cmd *subcmd)
{
struct backcmd *cmd;
2007-08-28 05:28:29 +02:00
cmd = malloc(sizeof(*cmd));
memset(cmd, 0, sizeof(*cmd));
cmd->type = BACK;
cmd->cmd = subcmd;
return (struct cmd*)cmd;
}
2007-08-28 05:46:58 +02:00
//PAGEBREAK!
2007-08-28 05:28:29 +02:00
// Parsing
char whitespace[] = " \t\r\n\v";
char symbols[] = "<|>&;()";
int
gettoken(char **ps, char *es, char **q, char **eq)
{
char *s;
int ret;
s = *ps;
while(s < es && strchr(whitespace, *s))
s++;
if(q)
*q = s;
ret = *s;
switch(*s){
case 0:
break;
case '|':
case '(':
case ')':
case ';':
case '&':
case '<':
s++;
break;
case '>':
s++;
if(*s == '>'){
ret = '+';
s++;
}
2007-08-28 05:28:29 +02:00
break;
default:
ret = 'a';
while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
s++;
break;
}
2007-08-28 05:28:29 +02:00
if(eq)
*eq = s;
while(s < es && strchr(whitespace, *s))
s++;
*ps = s;
return ret;
}
2007-08-28 05:46:58 +02:00
int
peek(char **ps, char *es, char *toks)
{
char *s;
s = *ps;
while(s < es && strchr(whitespace, *s))
s++;
*ps = s;
return *s && strchr(toks, *s);
}
2007-08-28 05:28:29 +02:00
struct cmd *parseline(char**, char*);
struct cmd *parsepipe(char**, char*);
struct cmd *parseexec(char**, char*);
2007-08-28 05:46:58 +02:00
struct cmd *nulterminate(struct cmd*);
2007-08-28 05:28:29 +02:00
struct cmd*
parsecmd(char *s)
{
2007-08-28 05:28:29 +02:00
char *es;
struct cmd *cmd;
2007-08-28 05:28:29 +02:00
es = s + strlen(s);
cmd = parseline(&s, es);
peek(&s, es, "");
if(s != es){
printf(2, "leftovers: %s\n", s);
panic("syntax");
}
2007-08-28 05:28:29 +02:00
nulterminate(cmd);
return cmd;
}
2007-08-28 05:28:29 +02:00
struct cmd*
parseline(char **ps, char *es)
{
2007-08-28 05:28:29 +02:00
struct cmd *cmd;
2007-08-28 05:28:29 +02:00
cmd = parsepipe(ps, es);
while(peek(ps, es, "&")){
gettoken(ps, es, 0, 0);
cmd = backcmd(cmd);
}
2007-08-28 05:28:29 +02:00
if(peek(ps, es, ";")){
gettoken(ps, es, 0, 0);
cmd = listcmd(cmd, parseline(ps, es));
}
return cmd;
}
2007-08-28 05:28:29 +02:00
struct cmd*
parsepipe(char **ps, char *es)
{
struct cmd *cmd;
2007-08-28 05:28:29 +02:00
cmd = parseexec(ps, es);
if(peek(ps, es, "|")){
gettoken(ps, es, 0, 0);
cmd = pipecmd(cmd, parsepipe(ps, es));
}
return cmd;
}
2007-08-28 05:28:29 +02:00
struct cmd*
parseredirs(struct cmd *cmd, char **ps, char *es)
{
int tok;
char *q, *eq;
while(peek(ps, es, "<>")){
tok = gettoken(ps, es, 0, 0);
if(gettoken(ps, es, &q, &eq) != 'a')
panic("missing file for redirection");
switch(tok){
case '<':
cmd = redircmd(cmd, q, eq, O_RDONLY, 0);
break;
case '>':
cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
break;
case '+': // >>
cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
break;
}
}
2007-08-28 05:28:29 +02:00
return cmd;
}
2007-08-28 05:46:58 +02:00
struct cmd*
parseblock(char **ps, char *es)
{
struct cmd *cmd;
if(!peek(ps, es, "("))
panic("parseblock");
gettoken(ps, es, 0, 0);
cmd = parseline(ps, es);
if(!peek(ps, es, ")"))
panic("syntax - missing )");
gettoken(ps, es, 0, 0);
cmd = parseredirs(cmd, ps, es);
return cmd;
}
2007-08-28 05:28:29 +02:00
struct cmd*
parseexec(char **ps, char *es)
{
char *q, *eq;
int tok, argc;
struct execcmd *cmd;
struct cmd *ret;
if(peek(ps, es, "("))
return parseblock(ps, es);
ret = execcmd();
cmd = (struct execcmd*)ret;
argc = 0;
ret = parseredirs(ret, ps, es);
while(!peek(ps, es, "|)&;")){
if((tok=gettoken(ps, es, &q, &eq)) == 0)
break;
if(tok != 'a')
panic("syntax");
cmd->argv[argc] = q;
cmd->eargv[argc] = eq;
argc++;
if(argc >= MAXARGS)
panic("too many args");
ret = parseredirs(ret, ps, es);
}
2007-08-28 05:28:29 +02:00
cmd->argv[argc] = 0;
cmd->eargv[argc] = 0;
return ret;
}
2007-08-28 05:28:29 +02:00
// NUL-terminate all the counted strings.
2007-08-28 06:19:47 +02:00
struct cmd*
2007-08-28 05:28:29 +02:00
nulterminate(struct cmd *cmd)
{
int i;
struct backcmd *bcmd;
struct execcmd *ecmd;
struct listcmd *lcmd;
struct pipecmd *pcmd;
struct redircmd *rcmd;
if(cmd == 0)
2007-08-28 05:46:58 +02:00
return 0;
2007-08-28 05:28:29 +02:00
switch(cmd->type){
case EXEC:
ecmd = (struct execcmd*)cmd;
for(i=0; ecmd->argv[i]; i++)
*ecmd->eargv[i] = 0;
break;
case REDIR:
rcmd = (struct redircmd*)cmd;
nulterminate(rcmd->cmd);
*rcmd->efile = 0;
break;
case PIPE:
pcmd = (struct pipecmd*)cmd;
nulterminate(pcmd->left);
nulterminate(pcmd->right);
break;
case LIST:
lcmd = (struct listcmd*)cmd;
nulterminate(lcmd->left);
nulterminate(lcmd->right);
break;
case BACK:
bcmd = (struct backcmd*)cmd;
nulterminate(bcmd->cmd);
break;
}
2007-08-28 05:46:58 +02:00
return cmd;
2007-08-28 05:28:29 +02:00
}