xv6源码分析 003

xv6源码分析 003

在开始今晚的内容之前我先纠正以下昨天的一个错误

struct cmd {
    int type;
};

代表的是在sh.c开头就定义的宏常量，系统调用号是通过汇编代码来传入的。修改之后的内容如下：

好啦，我们继续昨晚的内容吧。

在sh.c 的 main函数中，主要工作的是这三个函数

• getcmd()
• parsescmd()
• runcmd()

我们昨天已经看了第一个getcmd()，而且我也大致的给出了第二个函数的实现的思路，现在就来正式的看看吧。

sh.c — parsescmd()

在看看具体的实现之前我们先看看两个基本的函数peek()和gettoken()

• peek()

  函数strchr(const char *s, char c)的作用的是找到字符串中第一个匹配字符c的字符的位置，并将对应的指针返回

  其实通过whitespace我们也能够看出这个函数是用来将一整条命令前面的一个单词进行过滤指向第二个单词

  我们看看这几个参数的含义：

  ps：表示一个字符串的起始地址

  es：表示需要检索的字符串的结束地址

  toks：表示在切割后的字符串中，查找我们传递进去的目标字符集是否存在

  char whitespace[] = " \t\r\n\v";
  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);
  }
  

• gettoken()

  有点复杂，有待考究，我们只需要知道这个函数是用来解析命令即可

  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;
  }
  

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){
    fprintf(2, "leftovers: %s\n", s);
    panic("syntax");
  }
  nulterminate(cmd);
  return cmd;
}

可以看到在parsecmd(char *s)首先调用到了函数parseline(char **, char*)来处理命令，我们步进去看看

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);			// <----- backcmd()
  }
  if(peek(ps, es, ";")){
    gettoken(ps, es, 0, 0);
    cmd = listcmd(cmd, parseline(ps, es));		// <----- listcmd()
  }
  return cmd;
}

在parseline(char **, char *)中，函数在调用真正的命令处理函数之前，又调用了parsepipe(char **, char *)

struct cmd*
parsepipe(char **ps, char *es)
{
  struct cmd *cmd;

  cmd = parseexec(ps, es);					// <----- parseexec()
  if(peek(ps, es, "|")){
    gettoken(ps, es, 0, 0);
    cmd = pipecmd(cmd, parsepipe(ps, es));	// <------ pipecmd()
  }
  return cmd;
}

和上面一样在正式对命令进行处理之前，调用了parseexec(char **, char *)

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);		// <------ parseblock()
    							  // 内部调用的是parseredir()

  ret = execcmd();
  cmd = (struct execcmd*)ret;

  argc = 0;
  ret = parseredirs(ret, ps, es);	// <----- parseredirs()
  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);		// <----- parseredirs()
  }
  cmd->argv[argc] = 0;
  cmd->eargv[argc] = 0;
  return ret;
}

parseblock(char **, char *)

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;
}

今天是2024/4/9，发现我也看不懂了，不死磕了大佬们，简单做了个实验，发现我还是太年轻了，

大致就是这个情况，好像并不会调用其他的函数，可能是我的测试命令太简单了，但是大致的调用流程和我上面给出的流程图是一样的，这种设计思路我们可以学习学习，其实我们也能够用函数指针的方法来实现，可能是由于我们命令有时候会比较复杂，比如当我们调用xarg或者grep这种复合命令的时候，就需要这种过滤的思维，来逐个解析命令。