unix解释器原理 .

 

转自: http://www.cnblogs.com/hbt19860104/archive/2008/07/24/1250898.html

 

引言
使用Shell进行工作的人们对Unix/Linux下的Shell编程都很熟悉，在所有的Shell编程的书中都会提到#!/bin/bash,而这里到底包含了些什么？对操作系统而言，这一行字符串意味着什么？你可能会说，不就是会让 /bin/bash程序来解释这个脚本程序吗？当然你是对的，看看我们的标题，这里我们谈谈解释器，让我们一起来看看脚本文件里的第一句到底对系统而言意味着什么。但有一点我们可先明确一下，所谓解释器就是指#!行后面的可执行的程序。

一、我们从exec族函数谈起
如果你从不写C程序，可能需要对本节的内容看得更为仔细并且试验一下。

 

代码:

[cpp] view plaincopyprint?

1. #include <unistd.h>   
2. extern char **environ;  
3. int execl(const char *path, const char *arg, ...);  
4. int execlp(const char *file, const char *arg, ...);  
5. int execle(const  char  *path,  const  char  *arg  , ..., char * const envp[]);  
6. int execv(const char *path, char *const argv[]);  
7. int execvp(const char *file, char *const argv[]);  
8. int execve(const char *pathname, char *const argv[], char *const envp []);  

#include <unistd.h>extern char **environ;int execl(const char *path, const char *arg, ...);int execlp(const char *file, const char *arg, ...);int execle(const char *path, const char *arg , ..., char * const envp[]);int execv(const char *path, char *const argv[]);int execvp(const char *file, char *const argv[]);int execve(const char *pathname, char *const argv[], char *const envp []); 

 

exec 族函数一共有上面所列的5个(seawolf1979注：其实应该是6个，还包括execve，见上方红色标出部分)，作用都是一样：执行一段新的代码。区别只是向函数传递的参数方式不同而已，我在这里讲讲execl函数：第一个参数 path是指向设置了执行位文件的路径，后面的可变参数列表分别指向了传递给此执行文件的参数列表(包括了参数0,即是执行文件的名称)。最后一个参数为 (char *) 0，表示参数列表结束。

对于解释器，exec族函数是这样做的(以execl为例)，如果path是指向了一个脚本，脚本的第一行以#!开头，则这样调用：
以#!后面的字符串为命令，后面加上execl参数列表中指定的参数列表，这样形成了新的程序执行。
下面我们以例子来验证这个结果：

下面这个C程序的作用是回射所有命令行参数。

 

代码:

[cpp] view plaincopyprint?

1. /* Program source : showargs.c * 
2. * Program name   : showargs   */  
3. #include <unistd.h>   
4. int  
5. main(int argc, char *argv[])  
6. {  
7.    int i;  
8.    for(i = 0; i < argc; i++)  
9.    {  
10.        printf("arg[%d]: %s/n", i, argv[i]);  
11.    }  
12.    return 0;  
13. }  

/* Program source : showargs.c ** Program name : showargs */#include <unistd.h>intmain(int argc, char *argv[]){ int i; for(i = 0; i < argc; i++) { printf("arg[%d]: %s/n", i, argv[i]); } return 0;} 

 

 

编译：gcc -o showargs showargs.c
执行：

 

代码:

[cpp] view plaincopyprint?

1. $ pwd  
2. /home/kiron  
3. $ ./showargs arg1 arg2  
4. arg[0]: ./showargs  
5. arg[1]: arg1  
6. arg[2]: arg2  

$ pwd/home/kiron$ ./showargs arg1 arg2arg[0]: ./showargsarg[1]: arg1arg[2]: arg2 

 

我们在同一个目录下再写一个脚本：

 

代码:

[cpp] view plaincopyprint?

1. #!/home/kiron/showargs addargs  

#!/home/kiron/showargs addargs 

 

 

我没有打错，是的，这个脚本就只有一行，这个脚本我们命名为testexec，加上执行位后，执行情况如下：

 

代码:

[cpp] view plaincopyprint?

1. $ ./testexec  
2. arg[0]: /home/kiron/showargs  
3. arg[1]: addargs  
4. arg[2]: ./testexec  

$ ./testexecarg[0]: /home/kiron/showargsarg[1]: addargsarg[2]: ./testexec 

 

 

怎么会这样？我猜会有人对第2个参数./testexec不理解，暂且卖个关子，再引出一个C程序：

代码:

[cpp] view plaincopyprint?

1. /* Program source : mytest.c * 
2. * Program name   : mytest   */  
3. #include <stdio.h>   
4. int  
5. main(void)  
6. {  
7.    execl("/home/kiron/testexec", "testexec", "arg1", "arg2", (char *) 0);  
8.    return 0;  
9. }  

/* Program source : mytest.c ** Program name : mytest */#include <stdio.h>intmain(void){ execl("/home/kiron/testexec", "testexec", "arg1", "arg2", (char *) 0); return 0;} 

 

 

编译：gcc -o mytest mytest.c
执行：

代码:

[cpp] view plaincopyprint?

1. $ ./mytest  
2. arg[0]: /home/kiron/showargs  
3. arg[1]: addargs  
4. arg[2]: /home/kiron/testexec  
5. arg[3]: arg1  
6. arg[4]: arg2  

$ ./mytestarg[0]: /home/kiron/showargsarg[1]: addargsarg[2]: /home/kiron/testexecarg[3]: arg1arg[4]: arg2 

 

 

仔细观察上面的三个例子，答案开始浮出水面了。正如在开始时讲到的，exec族函数的处理是把#!后面的字符串为命令，后面加上execl参数列表中指定的参数列表，这样形成了新的程序执行。分析一下mytest.c源程序，execl把命令的结果是这样执行的/home/kiron/testexec的内容是#!/home/kiron/showargs addargs，则#!后面的字符串"/home/kiron/showargs addargs"加上命令参数列表："/home/kiron/testexec arg1 arg2"就形成了新的程序行：/home/kiron/showargs addargs /home/kiron/testexec arg1 arg2。对于testexec脚本，我们在shell中调用它时，shell调用了fork,exec,wait来执行它，也就是和程序 mytest.c一样用了exec函数，首先，exec函数对#!行分析后得出此脚本的解释器为/home/kiron/showargs，然后就形成了把命令行处理成了：“/home/kiron/showargs addargs ./testexec”。

注意：#!行中的解释器的路径必须是全路径，exec函数并不对其特殊处理，比如用PATH变量来搜索它的真实路径，所以路径是由程序员来保证正确的。

二、我的脚本第一句必须得是#!/bin/bash吗？
当然不必了，通过上面的解释，其实第一句的#!是对脚本的解释器程序路径，脚本的内容是由解释器解释的，我们可以用各种各样的解释器来写对应的脚本，比如说 /bin/csh脚本，/bin/perl脚本，/bin/awk脚本，/bin/sed脚本，甚至/bin/echo等等。那我们真的能写一个 /bin/echo的脚本文件吗？我们来试试，下面是一个例子：

 

代码:

[cpp] view plaincopyprint?

1. #!/bin/echo -e  

#!/bin/echo -e 

 

 

我把这只有一行的程序(实际上它也只能是一行，echo程序并不是被设计成像awk那样的编程语言，能写成源程序文件)命名为myecho，加上权限后执行它：

代码:

[cpp] view plaincopyprint?

1. $ ./myecho "hi/a"  
2. ./myecho hi  

$ ./myecho "hi/a"./myecho hi 

 

 

如果你的echo支持-e选项并且你工作的环境还算安静，你在得到上面的结果的时候也应该听到清脆的终端响铃。但这种程序是毫无作用的。

三、我能利用解释器来做什么？
但是上面的echo脚本实际应用时并没有什么作用，我们可以得出一个小小的实验结果，并不是所有的可执行二进制文件都可以用来写解释器脚本。那我编写解释器的脚本有什么用？如果你有一个可编程的解释器，那你或许能编写该解释器的程序来简化你工作。比如说常用到的解释器如awk,perl,bash等等。但是正如我们上面总结的实验结果，很不幸地，并不是全部的可编程程序都是有用的解释器，exec脚本时，能从第一行得到脚本的解释器，然后用exec去解释脚本(可能是选项去控制，如#!/bin/awk -f)，也包括了形如#!/PATH/的第一行，如果该解释器对这行不能忽略的话，就会出错，另外解释器也必须要对余下的程序语句能解释(这句好像是废话，但想象一下，上面myecho程序加一些"hello world"的行来，会有效吗？下面的mysed程序中的s/UNIX/unix/p也是一样的道理)。像awk,perl,bash等程序对#开头的行当成注释行处理，就能写成有用的脚本。
再看下面的mysed程序，

代码:

[cpp] view plaincopyprint?

1. #!/bin/sed -f   
2. s/UNIX/unix/p  

#!/bin/sed -fs/UNIX/unix/p 

 

 

执行./mysed时出错了。因为被解释成了"/bin/sed -f ./mysed"，其中-f选项是表示以文件里的内容作为sed的命令输入,但sed的命令输入不能对"#!/bin/sed -f"解释，那么程序出错了。
所以，有用的解释器应该是类似bash,perl,awk的程序，并且能对一些规定的语句有解释功能的。下面给出一个awk程序写的统计文件行数和单词数的脚本程序myawk。

代码:

[cpp] view plaincopyprint?

1. #!/usr/bin/awk -f   
2. BEGIN {  
3.    sum = 0;  
4. }  
5. {sum += NF;}  
6. END {  
7.    printf("file /"%s/" have %d line, %d words./n", FILENAME, NR, sum);  
8. }  

#!/usr/bin/awk -fBEGIN { sum = 0;}{sum += NF;}END { printf("file /"%s/" have %d line, %d words./n", FILENAME, NR, sum);} 

 

 

设置执行位之后，执行如下：

代码:

[cpp] view plaincopyprint?

1. $ echo -e "hi/nhello world">test.txt  
2. $ ./myawk test.txt  
3. file "test.txt" have 2 line, 3 words  

$ echo -e "hi/nhello world">test.txt$ ./myawk test.txtfile "test.txt" have 2 line, 3 words 

 

 

这里执行./myawk被执行成“/usr/bin/awk -f ./myawk test.txt”，因为awk的命令中，以#开头的行被认为是注释行而忽略，awk忽略了第一行"#!/usr/bin/awk -f"，正确的以非#开头行当成模式和命令的输入并能对其解释，所以这个程序是正确的，能被顺利地执行。

OK，关于Linux系统的解释器的介绍就说到这了，希望大家能对解释器的原理有更多的认识，而不是给我越说越糊涂^_^。

参考文献：W.Richard Stevens著 Advanced Programming in the UNIX Environment