command.hpp

 
  void GetArgs()
  {
    for (int i = 0; input_line_[i] != '\0'; i++)
    {
      if (input_line_[i] == ' ')
      {
        input_line_[i] = '\0';
      }
      else if (i == 0 || input_line_[i - 1] == '\0')
      {
        if (arg_number_ >= MAX_ARG_NUMBER)
        {
          return;
        }
        arg_tab_[arg_number_++] = &input_line_[i];
      }
    }
  }
 
  RamFS::Dir* Path2Dir(char* path)
  {
    if (path == nullptr)
    {
      return nullptr;
    }
 
    size_t index = 0;
    RamFS::Dir* dir = current_dir_;
 
    if (*path == '/')
    {
      index++;
      dir = &ramfs_.root_;
      if (path[index] == '\0')
      {
        return dir;
      }
    }
 
    for (size_t i = 0; i < MAX_LINE_SIZE; i++)
    {
      auto tmp = strchr(path + index, '/');
      if (tmp == nullptr)
      {
        return dir->FindDir(path + index);
      }
      else if (tmp == path + index)
      {
        return nullptr;
      }
      else
      {
        tmp[0] = '\0';
        dir = dir->FindDir(path + index);
        tmp[0] = '/';
        index = static_cast<size_t>(tmp - path + 1);
        if (path[index] == '\0' || dir == nullptr)
        {
          return dir;
        }
      }
    }
 
    return nullptr;
  }
 
  RamFS::File* Path2File(char* path)
  {
    if (path == nullptr)
    {
      return nullptr;
    }
 
    auto name = StrchrRev(path, '/');
 
    if (name == nullptr)
    {
      return current_dir_->FindFile(path);
    }
 
    if (name[1] == '\0')
    {
      return nullptr;
    }
 
    *name = '\0';
    RamFS::Dir* dir = name == path ? &ramfs_.root_ : Path2Dir(path);
    *name = '/';
    if (dir != nullptr)
    {
      return dir->FindFile(name + 1);
    }
    else
    {
      return nullptr;
    }
  }
 
  void ExecuteCommand()
  {
    AddHistory();
 
    GetArgs();
 
    if (arg_number_ < 1 || arg_number_ > MAX_ARG_NUMBER)
    {
      return;
    }
 
    if (strcmp(arg_tab_[0], "cd") == 0)
    {
      RamFS::Dir* dir = arg_number_ >= 2 ? Path2Dir(arg_tab_[1]) : nullptr;
      if (dir != nullptr)
      {
        current_dir_ = dir;
      }
      LineFeed();
      return;
    }
 
    if (strcmp(arg_tab_[0], "ls") == 0)
    {
      auto ls_fun = [&](RamFS::FsNode& item)
      {
        switch (item.GetNodeType())
        {
          case RamFS::FsNodeType::DIR:
            write_stream_ << ConstRawData("d ");
            break;
          case RamFS::FsNodeType::FILE:
            if (static_cast<RamFS::File&>(item).IsExecutable())
            {
              write_stream_ << ConstRawData("x ");
            }
            else
            {
              write_stream_ << ConstRawData("f ");
            }
            break;
          case RamFS::FsNodeType::CUSTOM:
            write_stream_ << ConstRawData("? ");
            break;
          default:
            write_stream_ << ConstRawData("? ");
            break;
        }
        write_stream_ << ConstRawData(item.GetName());
        this->LineFeed();
        return ErrorCode::OK;
      };
 
      current_dir_->Foreach(ls_fun);
      return;
    }
 
    auto* ans = Path2File(arg_tab_[0]);
 
    if (ans == nullptr)
    {
      write_stream_ << ConstRawData("Command not found.");
      LineFeed();
      return;
    }
 
    if (!ans->IsExecutable())
    {
      write_stream_ << ConstRawData("Not an executable file.");
      LineFeed();
      return;
    }
 
    write_stream_.Commit();
    write_mutex_->Unlock();
    ans->Run(arg_number_, arg_tab_);
    write_mutex_->Lock();
  }
 
  void AutoComplete()
  {
    /* skip space */
    char* path = &input_line_[0];
    while (*path == ' ')
    {
      path++;
    }
 
    /* find last '/' in first argument */
    char *tmp = path, *path_end = path;
 
    while (*tmp != ' ' && *tmp != '\0')
    {
      if (*tmp == '/')
      {
        path_end = tmp;
      }
      tmp++;
    }
 
    /* return if not need complete */
    if (tmp - &input_line_[0] != static_cast<int>(input_line_.Size() + offset_))
    {
      return;
    }
 
    /* get start of prefix */
    char* prefix_start = nullptr;
    RamFS::Dir* dir = nullptr;
 
    if (path_end == path)
    {
      dir = current_dir_;
      prefix_start = path_end;
    }
    else
    {
      prefix_start = path_end + 1;
    }
 
    /* find dir*/
    if (dir == nullptr)
    {
      *path_end = '\0';
      dir = Path2Dir(path);
      *path_end = '/';
      if (dir == nullptr)
      {
        return;
      }
    }
 
    /* prepre for match */
    RamFS::FsNode* ans_node = nullptr;
    uint32_t number = 0;
    size_t shared_prefix_len = 0;
 
    if (*prefix_start == '/')
    {
      prefix_start++;
    }
 
    int prefix_len = static_cast<int>(tmp - prefix_start);
 
    auto foreach_fun_find = [&](RamFS::FsNode& node)
    {
      if (strncmp(node.GetName(), prefix_start, prefix_len) == 0)
      {
        ans_node = &node;
        number++;
      }
 
      return ErrorCode::OK;
    };
 
    /* start match */
    dir->Foreach(foreach_fun_find);
 
    if (number == 0)
    {
      return;
    }
    else if (number == 1)
    {
      auto name_len = strlen(ans_node->GetName());
      for (size_t i = 0; i < name_len - prefix_len; i++)
      {
        DisplayChar(ans_node->GetName()[i + prefix_len]);
      }
    }
    else
    {
      ans_node = nullptr;
      LineFeed();
 
      auto foreach_fun_show = [&](RamFS::FsNode& node)
      {
        if (strncmp(node.GetName(), prefix_start, prefix_len) == 0)
        {
          auto name_len = strlen(node.GetName());
          write_stream_ << ConstRawData(node.GetName(), name_len);
          this->LineFeed();
          if (ans_node == nullptr)
          {
            ans_node = &node;
            shared_prefix_len = name_len;
            return ErrorCode::OK;
          }
 
          for (size_t i = 0; i < name_len; i++)
          {
            if (node.GetName()[i] != ans_node->GetName()[i])
            {
              shared_prefix_len = i;
              break;
            }
          }
 
          // Once one candidate is shorter than the previously retained shared
          // prefix, the shared prefix must shrink to this candidate length.
          if (shared_prefix_len > name_len)
          {
            shared_prefix_len = name_len;
          }
 
          ans_node = &node;
        }
 
        return ErrorCode::OK;
      };
 
      dir->Foreach(foreach_fun_show);
 
      ShowHeader();
      write_stream_ << ConstRawData(&input_line_[0], input_line_.Size());
 
      for (size_t i = 0; i < shared_prefix_len - prefix_len; i++)
      {
        DisplayChar(ans_node->GetName()[i + prefix_len]);
      }
    }
  }