pagetable lab initialized

user/sh.c

@@ -1,16 +1,15 @@
 // Shell.
 
-#include "kernel/fcntl.h"
-#include "kernel/fs.h"
 #include "kernel/types.h"
 #include "user/user.h"
+#include "kernel/fcntl.h"
 
 // Parsed command representation
-#define EXEC 1
+#define EXEC  1
 #define REDIR 2
-#define PIPE 3
-#define LIST 4
-#define BACK 5
+#define PIPE  3
+#define LIST  4
+#define BACK  5
 
 #define MAXARGS 10
 
@@ -50,15 +49,15 @@ struct backcmd {
   struct cmd *cmd;
 };
 
-int fork1(void); // Fork but panics on failure.
-void panic(char *);
-struct cmd *parsecmd(char *);
-void runcmd(struct cmd *) __attribute__((noreturn));
-// void handle_tab_completion(char *buf, int *i, int nbuf);
-// 尝试添加tab补全功能
+int fork1(void);  // Fork but panics on failure.
+void panic(char*);
+struct cmd *parsecmd(char*);
+void runcmd(struct cmd*) __attribute__((noreturn));
 
 // Execute cmd.  Never returns.
-void runcmd(struct cmd *cmd) {
+void
+runcmd(struct cmd *cmd)
+{
   int p[2];
   struct backcmd *bcmd;
   struct execcmd *ecmd;
@@ -66,25 +65,25 @@ void runcmd(struct cmd *cmd) {
   struct pipecmd *pcmd;
   struct redircmd *rcmd;
 
-  if (cmd == 0)
+  if(cmd == 0)
     exit(1);
 
-  switch (cmd->type) {
+  switch(cmd->type){
   default:
     panic("runcmd");
 
   case EXEC:
-    ecmd = (struct execcmd *)cmd;
-    if (ecmd->argv[0] == 0)
+    ecmd = (struct execcmd*)cmd;
+    if(ecmd->argv[0] == 0)
       exit(1);
     exec(ecmd->argv[0], ecmd->argv);
     fprintf(2, "exec %s failed\n", ecmd->argv[0]);
     break;
 
   case REDIR:
-    rcmd = (struct redircmd *)cmd;
+    rcmd = (struct redircmd*)cmd;
     close(rcmd->fd);
-    if (open(rcmd->file, rcmd->mode) < 0) {
+    if(open(rcmd->file, rcmd->mode) < 0){
       fprintf(2, "open %s failed\n", rcmd->file);
       exit(1);
     }
@@ -92,25 +91,25 @@ void runcmd(struct cmd *cmd) {
     break;
 
   case LIST:
-    lcmd = (struct listcmd *)cmd;
-    if (fork1() == 0)
+    lcmd = (struct listcmd*)cmd;
+    if(fork1() == 0)
       runcmd(lcmd->left);
     wait(0);
     runcmd(lcmd->right);
     break;
 
   case PIPE:
-    pcmd = (struct pipecmd *)cmd;
-    if (pipe(p) < 0)
+    pcmd = (struct pipecmd*)cmd;
+    if(pipe(p) < 0)
       panic("pipe");
-    if (fork1() == 0) {
+    if(fork1() == 0){
       close(1);
       dup(p[1]);
       close(p[0]);
       close(p[1]);
       runcmd(pcmd->left);
     }
-    if (fork1() == 0) {
+    if(fork1() == 0){
       close(0);
       dup(p[0]);
       close(p[0]);
@@ -124,82 +123,90 @@ void runcmd(struct cmd *cmd) {
     break;
 
   case BACK:
-    bcmd = (struct backcmd *)cmd;
-    if (fork1() == 0)
+    bcmd = (struct backcmd*)cmd;
+    if(fork1() == 0)
       runcmd(bcmd->cmd);
     break;
   }
   exit(0);
 }
 
-int getcmd(char *buf, int nbuf) {
+int
+getcmd(char *buf, int nbuf)
+{
   write(2, "$ ", 2);
   memset(buf, 0, nbuf);
   gets(buf, nbuf);
-  if (buf[0] == 0) // EOF
+  if(buf[0] == 0) // EOF
     return -1;
   return 0;
 }
 
-int main(void) {
+int
+main(void)
+{
   static char buf[100];
   int fd;
 
   // Ensure that three file descriptors are open.
-  while ((fd = open("console", O_RDWR)) >= 0) {
-    if (fd >= 3) {
+  while((fd = open("console", O_RDWR)) >= 0){
+    if(fd >= 3){
       close(fd);
       break;
     }
   }
 
   // Read and run input commands.
-  while (getcmd(buf, sizeof(buf)) >= 0) {
-    if (strcmp(buf, "exit\n") == 0) {
-      exit(0);
-    }
-    if (buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' ') {
+  while(getcmd(buf, sizeof(buf)) >= 0){
+    if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
       // Chdir must be called by the parent, not the child.
-      buf[strlen(buf) - 1] = 0; // chop \n
-      if (chdir(buf + 3) < 0)
-        fprintf(2, "cannot cd %s\n", buf + 3);
+      buf[strlen(buf)-1] = 0;  // chop \n
+      if(chdir(buf+3) < 0)
+        fprintf(2, "cannot cd %s\n", buf+3);
       continue;
     }
-    if (fork1() == 0)
+    if(fork1() == 0)
       runcmd(parsecmd(buf));
     wait(0);
   }
   exit(0);
 }
 
-void panic(char *s) {
+void
+panic(char *s)
+{
   fprintf(2, "%s\n", s);
   exit(1);
 }
 
-int fork1(void) {
+int
+fork1(void)
+{
   int pid;
 
   pid = fork();
-  if (pid == -1)
+  if(pid == -1)
     panic("fork");
   return pid;
 }
 
-// PAGEBREAK!
-//  Constructors
+//PAGEBREAK!
+// Constructors
 
-struct cmd *execcmd(void) {
+struct cmd*
+execcmd(void)
+{
   struct execcmd *cmd;
 
   cmd = malloc(sizeof(*cmd));
   memset(cmd, 0, sizeof(*cmd));
   cmd->type = EXEC;
-  return (struct cmd *)cmd;
+  return (struct cmd*)cmd;
 }
 
-struct cmd *redircmd(struct cmd *subcmd, char *file, char *efile, int mode,
-                     int fd) {
+struct cmd*
+redircmd(struct cmd *subcmd, char *file, char *efile, int mode, int fd)
+{
   struct redircmd *cmd;
 
   cmd = malloc(sizeof(*cmd));
@@ -210,10 +217,12 @@ struct cmd *redircmd(struct cmd *subcmd, char *file, char *efile, int mode,
   cmd->efile = efile;
   cmd->mode = mode;
   cmd->fd = fd;
-  return (struct cmd *)cmd;
+  return (struct cmd*)cmd;
 }
 
-struct cmd *pipecmd(struct cmd *left, struct cmd *right) {
+struct cmd*
+pipecmd(struct cmd *left, struct cmd *right)
+{
   struct pipecmd *cmd;
 
   cmd = malloc(sizeof(*cmd));
@@ -221,10 +230,12 @@ struct cmd *pipecmd(struct cmd *left, struct cmd *right) {
   cmd->type = PIPE;
   cmd->left = left;
   cmd->right = right;
-  return (struct cmd *)cmd;
+  return (struct cmd*)cmd;
 }
 
-struct cmd *listcmd(struct cmd *left, struct cmd *right) {
+struct cmd*
+listcmd(struct cmd *left, struct cmd *right)
+{
   struct listcmd *cmd;
 
   cmd = malloc(sizeof(*cmd));
@@ -232,35 +243,39 @@ struct cmd *listcmd(struct cmd *left, struct cmd *right) {
   cmd->type = LIST;
   cmd->left = left;
   cmd->right = right;
-  return (struct cmd *)cmd;
+  return (struct cmd*)cmd;
 }
 
-struct cmd *backcmd(struct cmd *subcmd) {
+struct cmd*
+backcmd(struct cmd *subcmd)
+{
   struct backcmd *cmd;
 
   cmd = malloc(sizeof(*cmd));
   memset(cmd, 0, sizeof(*cmd));
   cmd->type = BACK;
   cmd->cmd = subcmd;
-  return (struct cmd *)cmd;
+  return (struct cmd*)cmd;
 }
-// PAGEBREAK!
-//  Parsing
+//PAGEBREAK!
+// Parsing
 
 char whitespace[] = " \t\r\n\v";
 char symbols[] = "<|>&;()";
 
-int gettoken(char **ps, char *es, char **q, char **eq) {
+int
+gettoken(char **ps, char *es, char **q, char **eq)
+{
   char *s;
   int ret;
 
   s = *ps;
-  while (s < es && strchr(whitespace, *s))
+  while(s < es && strchr(whitespace, *s))
     s++;
-  if (q)
+  if(q)
     *q = s;
   ret = *s;
-  switch (*s) {
+  switch(*s){
   case 0:
     break;
   case '|':
@@ -273,49 +288,53 @@ int gettoken(char **ps, char *es, char **q, char **eq) {
     break;
   case '>':
     s++;
-    if (*s == '>') {
+    if(*s == '>'){
       ret = '+';
       s++;
     }
     break;
   default:
     ret = 'a';
-    while (s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
+    while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
       s++;
     break;
   }
-  if (eq)
+  if(eq)
     *eq = s;
 
-  while (s < es && strchr(whitespace, *s))
+  while(s < es && strchr(whitespace, *s))
     s++;
   *ps = s;
   return ret;
 }
 
-int peek(char **ps, char *es, char *toks) {
+int
+peek(char **ps, char *es, char *toks)
+{
   char *s;
 
   s = *ps;
-  while (s < es && strchr(whitespace, *s))
+  while(s < es && strchr(whitespace, *s))
     s++;
   *ps = s;
   return *s && strchr(toks, *s);
 }
 
-struct cmd *parseline(char **, char *);
-struct cmd *parsepipe(char **, char *);
-struct cmd *parseexec(char **, char *);
-struct cmd *nulterminate(struct cmd *);
+struct cmd *parseline(char**, char*);
+struct cmd *parsepipe(char**, char*);
+struct cmd *parseexec(char**, char*);
+struct cmd *nulterminate(struct cmd*);
 
-struct cmd *parsecmd(char *s) {
+struct cmd*
+parsecmd(char *s)
+{
   char *es;
   struct cmd *cmd;
 
   es = s + strlen(s);
   cmd = parseline(&s, es);
   peek(&s, es, "");
-  if (s != es) {
+  if(s != es){
     fprintf(2, "leftovers: %s\n", s);
     panic("syntax");
   }
@@ -323,92 +342,102 @@ struct cmd *parsecmd(char *s) {
   return cmd;
 }
 
-struct cmd *parseline(char **ps, char *es) {
+struct cmd*
+parseline(char **ps, char *es)
+{
   struct cmd *cmd;
 
   cmd = parsepipe(ps, es);
-  while (peek(ps, es, "&")) {
+  while(peek(ps, es, "&")){
     gettoken(ps, es, 0, 0);
     cmd = backcmd(cmd);
   }
-  if (peek(ps, es, ";")) {
+  if(peek(ps, es, ";")){
     gettoken(ps, es, 0, 0);
     cmd = listcmd(cmd, parseline(ps, es));
   }
   return cmd;
 }
 
-struct cmd *parsepipe(char **ps, char *es) {
+struct cmd*
+parsepipe(char **ps, char *es)
+{
   struct cmd *cmd;
 
   cmd = parseexec(ps, es);
-  if (peek(ps, es, "|")) {
+  if(peek(ps, es, "|")){
     gettoken(ps, es, 0, 0);
     cmd = pipecmd(cmd, parsepipe(ps, es));
   }
   return cmd;
 }
 
-struct cmd *parseredirs(struct cmd *cmd, char **ps, char *es) {
+struct cmd*
+parseredirs(struct cmd *cmd, char **ps, char *es)
+{
   int tok;
   char *q, *eq;
 
-  while (peek(ps, es, "<>")) {
+  while(peek(ps, es, "<>")){
     tok = gettoken(ps, es, 0, 0);
-    if (gettoken(ps, es, &q, &eq) != 'a')
+    if(gettoken(ps, es, &q, &eq) != 'a')
       panic("missing file for redirection");
-    switch (tok) {
+    switch(tok){
     case '<':
       cmd = redircmd(cmd, q, eq, O_RDONLY, 0);
       break;
     case '>':
-      cmd = redircmd(cmd, q, eq, O_WRONLY | O_CREATE | O_TRUNC, 1);
+      cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE|O_TRUNC, 1);
       break;
-    case '+': // >>
-      cmd = redircmd(cmd, q, eq, O_WRONLY | O_CREATE, 1);
+    case '+':  // >>
+      cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
       break;
     }
   }
   return cmd;
 }
 
-struct cmd *parseblock(char **ps, char *es) {
+struct cmd*
+parseblock(char **ps, char *es)
+{
   struct cmd *cmd;
 
-  if (!peek(ps, es, "("))
+  if(!peek(ps, es, "("))
     panic("parseblock");
   gettoken(ps, es, 0, 0);
   cmd = parseline(ps, es);
-  if (!peek(ps, es, ")"))
+  if(!peek(ps, es, ")"))
     panic("syntax - missing )");
   gettoken(ps, es, 0, 0);
   cmd = parseredirs(cmd, ps, es);
   return cmd;
 }
 
-struct cmd *parseexec(char **ps, char *es) {
+struct cmd*
+parseexec(char **ps, char *es)
+{
   char *q, *eq;
   int tok, argc;
   struct execcmd *cmd;
   struct cmd *ret;
 
-  if (peek(ps, es, "("))
+  if(peek(ps, es, "("))
     return parseblock(ps, es);
 
   ret = execcmd();
-  cmd = (struct execcmd *)ret;
+  cmd = (struct execcmd*)ret;
 
   argc = 0;
   ret = parseredirs(ret, ps, es);
-  while (!peek(ps, es, "|)&;")) {
-    if ((tok = gettoken(ps, es, &q, &eq)) == 0)
+  while(!peek(ps, es, "|)&;")){
+    if((tok=gettoken(ps, es, &q, &eq)) == 0)
       break;
-    if (tok != 'a')
+    if(tok != 'a')
       panic("syntax");
     cmd->argv[argc] = q;
     cmd->eargv[argc] = eq;
     argc++;
-    if (argc >= MAXARGS)
+    if(argc >= MAXARGS)
       panic("too many args");
     ret = parseredirs(ret, ps, es);
   }
@@ -418,7 +447,9 @@ struct cmd *parseexec(char **ps, char *es) {
 }
 
 // NUL-terminate all the counted strings.
-struct cmd *nulterminate(struct cmd *cmd) {
+struct cmd*
+nulterminate(struct cmd *cmd)
+{
   int i;
   struct backcmd *bcmd;
   struct execcmd *ecmd;
@@ -426,36 +457,36 @@ struct cmd *nulterminate(struct cmd *cmd) {
   struct pipecmd *pcmd;
   struct redircmd *rcmd;
 
-  if (cmd == 0)
+  if(cmd == 0)
     return 0;
 
-  switch (cmd->type) {
+  switch(cmd->type){
   case EXEC:
-    ecmd = (struct execcmd *)cmd;
-    for (i = 0; ecmd->argv[i]; i++)
+    ecmd = (struct execcmd*)cmd;
+    for(i=0; ecmd->argv[i]; i++)
       *ecmd->eargv[i] = 0;
     break;
 
   case REDIR:
-    rcmd = (struct redircmd *)cmd;
+    rcmd = (struct redircmd*)cmd;
     nulterminate(rcmd->cmd);
     *rcmd->efile = 0;
     break;
 
   case PIPE:
-    pcmd = (struct pipecmd *)cmd;
+    pcmd = (struct pipecmd*)cmd;
     nulterminate(pcmd->left);
     nulterminate(pcmd->right);
     break;
 
   case LIST:
-    lcmd = (struct listcmd *)cmd;
+    lcmd = (struct listcmd*)cmd;
     nulterminate(lcmd->left);
     nulterminate(lcmd->right);
     break;
 
   case BACK:
-    bcmd = (struct backcmd *)cmd;
+    bcmd = (struct backcmd*)cmd;
     nulterminate(bcmd->cmd);
     break;
   }