Dax

At its core, a shell is a simple program that runs in a loop. In each iteration, it does the following:

1. Prints a prompt: This is to let the user know that the shell is ready to accept a command.
2. Reads a line of input: The shell waits for the user to type a command and press Enter.
3. Processes the command: The shell parses the input, figures out what the user wants to do, and then does it.

The main loop of the Dax shell is in the `main.cpp` file. It uses the `readline` library to provide a rich user experience with features like command history and arrow key navigation.

// main.cpp
while (true) {
    // 1. Print a prompt
    char* input = readline(prompt_str.c_str());

    // 2. Read a line of input
    if (!input) {
      std::cout << "\n";
      break;
    }

    line = input;
    free(input);

    if(line.empty()) continue;

    // 3. Process the command
    tokens = tokenize(line);
    if(tokens.empty()) continue;

    try {
        auto ast = parse(tokens);
        if (ast) {
            ast->execute();
        }
    } catch (const std::exception& e) {
        std::cerr << "Parse/Exec Error: " << e.what() << "\n";
    }
}

Before the shell can understand a command, it needs to break it down into smaller, more manageable pieces. This process is called tokenization. The tokenizer in Dax scans the input string and splits it into a sequence of tokens. For example, the command ls -l | grep cpp would be tokenized into ls, -l, |, grep, and cpp.

The tokenizer in tokenizer.cpp is implemented as a state machine. It can handle single quotes, double quotes, and special characters like |, ;, <, >, and >>.

## Making Sense of It All: Parsing and the AST

Once the input has been tokenized, the shell needs to make sense of the tokens. This is where the parser comes in. The parser takes the sequence of tokens and builds a data structure called an Abstract Syntax Tree (AST). The AST is a tree representation of the command that captures its structure and meaning.

For example, the command ls -l | grep cpp would be parsed into an AST that looks something like this:

    Pipe
   /    \
Command  Command
  |        |
ls -l    grep cpp

The Dax parser, implemented in parser.cpp, is a recursive descent parser. It has functions for parsing simple commands, pipes, and lists of commands. The parse function returns a std::unique_ptr<ASTNode>, which is the root of the AST.

After the AST has been built, the shell can execute the command by traversing the tree. The execute method is called on the root of the AST, which then recursively calls the execute method on its children.

// CommandNode::execute in parser.cpp
pid_t pid = fork();
if (pid == 0) {
    // Child process
    execvp(c_args[0], c_args.data());
    perror("execvp");
    exit(1);
} else if (pid > 0) {
    // Parent process
    int status;
    waitpid(pid, &status, 0);
}

In addition to the core features we've discussed, the Dax shell also implements a number of other features, including: