text: // Shell.
  
  #include "types.h"
  #include "user.h"
  #include "fcntl.h"
  
  // Parsed command representation
  #define EXEC  1
  #define REDIR 2
  #define PIPE  3
  #define LIST  4
  #define BACK  5
  
  #define MAXARGS 10
  
  struct cmd {
    int type;
  };
  
  struct execcmd {
    int type;
    char *argv[MAXARGS];
    char *eargv[MAXARGS];
  };
  
  struct redircmd {
    int type;
    struct cmd *cmd;
    char *file;
    char *efile;
    int mode;
    int fd;
  };
  
  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;
  };
  
  int fork1(void);  // Fork but panics on failure.
  void panic(char*);
  struct cmd *parsecmd(char*);
  
  // 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)
      exit();
  
    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;
  
    case LIST:
      lcmd = (struct listcmd*)cmd;
      if(fork1() == 0)
        runcmd(lcmd->left);
      wait();
      runcmd(lcmd->right);
      break;
  
    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;
    }
    exit();
  }
  
  int
  getcmd(char *buf, int nbuf)
  {
    printf(2, "$ ");
    memset(buf, 0, nbuf);
    gets(buf, nbuf);
    if(buf[0] == 0) // EOF
      return -1;
    return 0;
  }
  
  int
  main(void)
  {
    static char buf[100];
    static char prevBuf[100];
    int fd;
    int i;
  
    // Ensure that three file descriptors are open.
    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(buf[0] == 'p' && buf[1] == '\n'){
  		if(fork1() == 0)
  			runcmd(parsecmd(prevBuf));
  		wait();
  	} else {
      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)
          printf(2, "cannot cd %s\n", buf+3);
        continue;
      }
  	  
      if(fork1() == 0)
        runcmd(parsecmd(buf));
  	// Codigo actualizar prevBuf
  	i = 0;
  	for(i = 0; i < 100; i++){
  		prevBuf[i] = buf[i];
  	}
      wait();
  	}
    }
    exit();
  }
  
  void
  panic(char *s)
  {
    printf(2, "%s\n", s);
    exit();
  }
  
  int
  fork1(void)
  {
    int pid;
  
    pid = fork();
    if(pid == -1)
      panic("fork");
    return pid;
  }
  
  //PAGEBREAK!
  // Constructors
  
  struct cmd*
  execcmd(void)
  {
    struct execcmd *cmd;
  
    cmd = malloc(sizeof(*cmd));
    memset(cmd, 0, sizeof(*cmd));
    cmd->type = EXEC;
    return (struct cmd*)cmd;
  }
  
  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;
  }
  
  struct cmd*
  pipecmd(struct cmd *left, struct cmd *right)
  {
    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;
  }
  
  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;
  }
  
  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;
  }
  //PAGEBREAK!
  // 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++;
      }
      break;
    default:
      ret = 'a';
      while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
        s++;
      break;
    }
    if(eq)
      *eq = s;
  
    while(s < es && strchr(whitespace, *s))
      s++;
    *ps = s;
    return ret;
  }
  
  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);
  }
  
  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)
  {
    char *es;
    struct cmd *cmd;
  
    es = s + strlen(s);
    cmd = parseline(&s, es);
    peek(&s, es, "");
    if(s != es){
      printf(2, "leftovers: %s\n", s);
      panic("syntax");
    }
    nulterminate(cmd);
    return cmd;
  }
  
  struct cmd*
  parseline(char **ps, char *es)
  {
    struct cmd *cmd;
  
    cmd = parsepipe(ps, es);
    while(peek(ps, es, "&")){
      gettoken(ps, es, 0, 0);
      cmd = backcmd(cmd);
    }
    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 *cmd;
  
    cmd = parseexec(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)
  {
    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;
      }
    }
    return cmd;
  }
  
  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;
  }
  
  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);
    }
    cmd->argv[argc] = 0;
    cmd->eargv[argc] = 0;
    return ret;
  }
  
  // NUL-terminate all the counted strings.
  struct cmd*
  nulterminate(struct cmd *cmd)
  {
    int i;
    struct backcmd *bcmd;
    struct execcmd *ecmd;
    struct listcmd *lcmd;
    struct pipecmd *pcmd;
    struct redircmd *rcmd;
  
    if(cmd == 0)
      return 0;
  
    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;
    }
    return cmd;
  }
  