使用 Python 创建你自己的 Shell:Part II
===========================================

在[part 1][1]，我们已经创建了一个主要的 shell 循环、切分了的命令输入，以及通过 fork 和 exec 执行命令。在这部分，我们将会解决剩下的问题。首先，`cd test_dir2` 命令无法修改我们的当前目录。其次，我们仍无法优雅地从 shell 中退出。

### 步骤 4：内置命令

“cd test_dir2 无法修改我们的当前目录” 这句话是对的，但在某种意义上也是错的。在执行完该命令之后，我们仍然处在同一目录，从这个意义上讲，它是对的。然而，目录实际上已经被修改，只不过它是在子进程中被修改。

还记得我们 fork 了一个子进程，然后执行命令，执行命令的过程没有发生在父进程上。结果是我们只是改变了子进程的当前目录，而不是父进程的目录。

然后子进程退出，且父进程在原封不动的目录下继续运行。

因此，这类与 shell 自己相关的命令必须是内置命令。它必须在 shell 进程中执行而没有分叉（forking）。

#### cd

让我们从 cd 命令开始。

我们首先创建一个内置目录。每一个内置命令都会被放进这个目录中。

```shell
yosh_project
|-- yosh
   |-- builtins
   |   |-- __init__.py
   |   |-- cd.py
   |-- __init__.py
   |-- shell.py
```

在 cd.py，我们通过使用系统调用 os.chdir 实现自己的 cd 命令。

```python
import os
from yosh.constants import *


def cd(args):
    os.chdir(args[0])

    return SHELL_STATUS_RUN
```

注意，我们会从内置函数返回 shell 的运行状态。所以，为了能够在项目中继续使用常量，我们将它们移至 yosh/constants.py。

```shell
yosh_project
|-- yosh
   |-- builtins
   |   |-- __init__.py
   |   |-- cd.py
   |-- __init__.py
   |-- constants.py
   |-- shell.py
```

在 constants.py，我们将状态常量放在这里。

```python
SHELL_STATUS_STOP = 0
SHELL_STATUS_RUN = 1
```

现在，我们的内置 cd 已经准备好了。让我们修改 shell.py 来处理这些内置函数。

```python
...
# Import constants
from yosh.constants import *

# Hash map to store built-in function name and reference as key and value
built_in_cmds = {}


def tokenize(string):
    return shlex.split(string)


def execute(cmd_tokens):
    # Extract command name and arguments from tokens
    cmd_name = cmd_tokens[0]
    cmd_args = cmd_tokens[1:]

    # If the command is a built-in command, invoke its function with arguments
    if cmd_name in built_in_cmds:
        return built_in_cmds[cmd_name](cmd_args)

    ...
```

我们使用一个 python 字典变量 built_in_cmds 作为哈希映射（a hash map），以存储我们的内置函数。我们在 execute 函数中提取命令的名字和参数。如果该命令在我们的哈希映射中，则调用对应的内置函数。

（提示：built_in_cmds[cmd_name] 返回能直接使用参数调用的函数引用的。) 

我们差不多准备好使用内置的 cd 函数了。最后一步是将 cd 函数添加到 built_in_cmds 映射中。

```
...
# Import all built-in function references
from yosh.builtins import *

...

# Register a built-in function to built-in command hash map
def register_command(name, func):
    built_in_cmds[name] = func


# Register all built-in commands here
def init():
    register_command("cd", cd)


def main():
    # Init shell before starting the main loop
    init()
    shell_loop()
```

我们定义 register_command 函数以添加一个内置函数到我们内置的命令哈希映射。 
We define register_command function for adding a built-in function to our built-in commmand hash map. Then, we define init function and register the built-in cd function there.

Notice the line register_command("cd", cd). The first argument is a command name. The second argument is a reference to a function. In order to let cd, in the second argument, refer to the cd function reference in yosh/builtins/cd.py, we have to put the following line in yosh/builtins/__init__.py.

```
from yosh.builtins.cd import *
```
Therefore, in yosh/shell.py, when we import * from yosh.builtins, we get cd function reference that is already imported by yosh.builtins.

We’ve done preparing our code. Let’s try by running our shell as a module python -m yosh.shell at the same level as the yosh directory.

Now, our cd command should change our shell directory correctly while non-built-in commands still work too. Cool.

#### exit

Here comes the last piece: to exit gracefully.

We need a function that changes the shell status to be SHELL_STATUS_STOP. So, the shell loop will naturally break and the shell program will end and exit.

As same as cd, if we fork and exec exit in a child process, the parent process will still remain inact. Therefore, the exit function is needed to be a shell built-in function.

Let’s start by creating a new file called exit.py in the builtins folder.

```
yosh_project
|-- yosh
   |-- builtins
   |   |-- __init__.py
   |   |-- cd.py
   |   |-- exit.py
   |-- __init__.py
   |-- constants.py
   |-- shell.py
```

The exit.py defines the exit function that just returns the status to break the main loop.

```
from yosh.constants import *


def exit(args):
    return SHELL_STATUS_STOP
```

Then, we import the exit function reference in `yosh/builtins/__init__.py`.

```
from yosh.builtins.cd import *
from yosh.builtins.exit import *
```

Finally, in shell.py, we register the exit command in `init()` function.


```
...

# Register all built-in commands here
def init():
    register_command("cd", cd)
    register_command("exit", exit)

...
```

That’s all!

Try running python -m yosh.shell. Now you can enter exit to quit the program gracefully.

### Final Thought

I hope you enjoy creating yosh (your own shell) like I do. However, my version of yosh is still in an early stage. I don’t handle several corner cases that can corrupt the shell. There are a lot of built-in commands that I don’t cover. Some non-built-in commands can also be implemented as built-in commands to improve performance (avoid new process creation time). And, a ton of features are not yet implemented (see Common features and Differing features).

I’ve provided the source code at github.com/supasate/yosh. Feel free to fork and play around.

Now, it’s your turn to make it real Your Own SHell.

Happy Coding!

--------------------------------------------------------------------------------

via: https://hackercollider.com/articles/2016/07/06/create-your-own-shell-in-python-part-2/

作者：[Supasate Choochaisri][a]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

[a]: https://disqus.com/by/supasate_choochaisri/
[1]: https://hackercollider.com/articles/2016/07/05/create-your-own-shell-in-python-part-1/
[2]: http://tldp.org/LDP/Bash-Beginners-Guide/html/x7243.html
[3]: http://www.tldp.org/LDP/intro-linux/html/x12249.html
[4]: https://github.com/supasate/yosh