Shell处理命令的内部机制 和eval

看图说文！
命令行处理解释了Shell如何处理一个命令的内部机制：
Shell从标准输入或脚本读取的每一行称为管道线（pipeline），每一行包含一个或多个命令，这些命令用管道符隔开，Shell对每一个读取的管道线都按照下面的步骤处理：

1、将命令分割成令牌（token），令牌之间以元字符分隔。Shell的元字符集合是固定不变的，包括空格、Tab键、换行字符、分号（;）、小括号、输入重定向符（<）、输出重定向符（>）、管道符（|）和 &符号，令牌可以是单词（word）、关键字，也可以是I/O重定向器和分号。（这段话很重要！）

2、检查命令行的第一个令牌是否为不带(引号或反斜杠)的关键字，如果此令牌是开放关键字，开放关键字指if、while、for或其他控制结构中的开始符号，Shell就认为此命令是复合命令，并为该复合命令进行内部设置，读取下一条命令，再次启动进程。如果此令牌不是复合命令的开始符号，如该令牌是then、else、do、fi、done等符号，这说明该令牌不应该处在命令行的首位，因此，Shell提示语法错误信息。

3、检查命令行的第一个令牌是否为某命令别名，这需要将此令牌与别名（alia）列表逐个比较，如果匹配，说明该令牌是别名，则将该令牌替换掉，返回步骤1，否则进入步骤4。这种机制允许别名递归，也允许定义关键字别名，比如可以用下面命令定义while关键字的别名when： alias when=while 。

4、执行大括号展开，比如h{a,i}t展开为hat或hit。
5、将单词开头处的波浪号 ~ 替换成用户的根目录$HOME。
6、将任何开头为$符号的表达式，执行变量替换。
7、将反引号内的表达式或子shell ‘()’，则执行命令替换。
8、将$((string))的表达式进行算术运算。

9、从变量、命令和算术替换的结果中取出命令行，再次进行单词切分，与步骤1不同的是，此时不再用元字符分隔单词，而是使用$IFS分隔单词。 缺省的IFS变量包含有：SPACE , TAB 和换行符号。
echo ~+/${f}[12]$y $(echo cmd subst )$(( 3 + 2 ))
和
echo ~+/${f}[12]$y $(echo cmd subst )$(( 3 + 2 )) # cmd 和subst之间添加了多个空格
的结果是一样的！

11、将第一个单词作为命令，它可以是函数、内建命令和可执行文件。
shell把處理的結果中用到的注释删除，並且按照下面的顺序实行命令的检查：
A. 内建的命令
B. shell函数（由用户自己定义的）
C. 可执行的脚本文件（需要寻找文件和PATH路径）

12、在完成I/O重定向与其他类似事项后，执行命令。

---

案例解释一：

$ echo ~/i* $PWD `echo Yahoo Hadop` $((21*20)) > output

1、
Shell首先将命令行分割成令牌，分割成的令牌如下，我们在命令行下方用数字标出各个令牌：
$ echo ~/i* $PWD `echo Yahoo Hadop` $((21*20))
|-1-||–2—-| |–3–| |——-4———-| |—–5——|
需要注意的是，重定向>output虽已被识别，但是它不是令牌，Shell将在后面对I/O重定向进行处理。

2、检查第一个单词echo否为关键字，显然echo不是开放关键字，所以命令行继续下面的判断。
3、检查第一个单词echo是否为别名，echo不是别名，命令行继续往下处理。
4、扫描命令行是否需要大括号展开，这条命令没有大括号，命令行继续往下处理。
5、
扫描命令行是否需要波浪号展开，命令行中存在波浪号，令牌2将被修改，命令行变为如下形式：

$ echo /root/i* $PWD `echo Yahoo Hadop` $((21*20))
 |--1-||--2---||-3--||-------4--------||-----5---|

6、
扫描命令行中是否存在变量，若存在变量，则进行变量替换，该命令行中存在环境变量PWD，因此，令牌3将被修改，命令行变为如下形式：

$ echo /root/i* /root `echo Yahoo Hadop` $((21*20))
  |--1-||--2--||--3-||---------4-------||-----5---|

7、
扫描命令行中是否存在反引号，若存在则进行命令替换，该命令行存在命令替换，因此，令牌4将被修改，命令行变为如下形式：

          $ echo /root/i* /root Yahoo Hadop $((21*20))
          |--1--||---2--||--3--||----4----||----5----|

8、
执行命令行中的算术替换，令牌5将被修改，命令行变为如下形式：

         $ echo /root/i* /root Yahoo Hadop 420
           |--1-||--2--||--3--||-----4---||-5-|

9、
Shell将对前面所有展开所产生的结果进行再次扫描，依据$IFS变量值对结果进行单词分割，形成如下形式的新命令行：

         $ echo /root/i* /root Yahoo Hadop 420
          |--1-||---2---||-3-||--4-||--5--||-6-|
         # 由于$IFS是空格，因此，命令行被分割为6个令牌，**Yahoo Hadop被分成两个令牌**。

10、扫描命令行中的通配符，并展开，该命令行中存在通配符*，展开后，命令行变为如下形式：

$ echo /root/indirect.sh /root/install.log /root/install.log.syslog /root Yahoo Hadop 420
|--1--||-------2------||-------3---------||---------4------------||--5--||--6-||-7--||-8-|
i*展开为当前目录下所有以i开头的文件，目录下有三个i开头的文件：indirect.sh、install.log和install.log.syslog。
因此，**令牌2又被分为令牌2,3和4**。

11、此时，Shell已经准备执行命令了，它寻找echo，echo是内建命令。
12、Shell执行echo命令，此时执行>output的I/O重定向，再调用echo命令，显示最后参数。

---

案例解释二：

mkdir /tmp/x   # 创建目录
cd /tmp/x      # 换到该目录
touch f1 f2    # 创建两个文件
f=f            # 初始化两个变量
y="a b"

# 分析命令：
echo ~+/${f}[12] $y $(echo cmd subst ) $(( 3 + 2 )) > out 

--输出结果：
root@37C:/tmp/x# cat out 
/tmp/x/f1 /tmp/x/f2 a b cmd subst 5

1.命令一开始会根据Shell语法而分割为token。
最重要的一点是：I/O重定向 >out 在这里是被识别的，并存储供稍后使用。
流程继续处理下面这行：

echo ~+/${f}[12] $y $(echo cmd subst) $((3 + 2))
| 1 ||-----2---||-3-||-------4-------||----5---|

2.检查第一个单词（echo）是否为关键字，例如 if 或 for …。
这里不是，所以命令行不变继续处理。

3.检查第一个单词（echo）是否为别名。
这里不是。所以命令行不变，继续处理。

4.扫描所有单词是否需要波浪号展开。
在本例中，~+ 为ksh93 与 bash 的扩展，等同于$PWD，也就是当前的目录。
token 2将被修改，处理如下：

echo /tmp/x/${f}[12] $y $(echo cmd subst) $((3 + 2))
| 1 ||------2 -----||3||------- 4--------||---5----|

5.下一步是变量展开。
这样会产生：

echo /tmp/x/f[12] a b $(echo cmd subst) $((3 + 2))
| 1 ||---- 2 ---||-3-||------ 4------||----5-----|

6.再来要处理的是命令替换。
注意，这里可用递归应用列表里的所有步骤！

echo /tmp/x/f[12] a b cmd subst $((3 + 2))
|-1-||-----2----||-3-||---4---||----5-----|

7.现在执行算数替换。
修改的是 token 5,结果：

echo /tmp/x/f[12] a b cmd subst 5
|-1-||----2-----||-3-||---4---||-5-|

8.前面所有的展开产生的结果，都将再一次被扫描，看看是否有 $IFS 字符。 如果有，则他们是作为分隔符（separator），产生额外的单词。 例如，变量$y 原来是由两个字符组成的一个单词，展开后为“a b”，在此阶段被切分为两个单词：a 与 b。
相同方式也应用于命令$（echo cmd subst）的结果上。
先前的 token 3 变成了 token 3 与token 4。
先前的 token 4则成了 token 5 与 token 6。
结果：

echo /tmp/x/f[12] a b cmd subst 5
|-1-||-----2-----|3|4|-5-||-6-|-7-|

9.最后的替换阶段是通配符展开。
token 2 变成了 token 2 与 token 3：

echo /tmp/x/f1 /tmp/x/f2 a b cmd subst 5
|-1-||-- 2 --||----3----|4|5|-6-||-7-||8|

10.这时，Shell已经准备好了要执行最后的命令了。
它会去寻找 echo。
正好 ksh93 与 bash 的 echo 都内建到Shell 中了。

11.Shell实际执行命令。
首先执行 > out 的 I/O重定向，再调用内部的 echo 版本，显示最后的参数。
最后的结果：

$cat out
/tmp/x/f1 /tmp/x/f2 a b cmd subst 5 

---

eval命令：

命令行处理流程图的左侧跳转箭头从执行命令步骤跳转到初始步骤，这正是eval命令的作用。
eval命令将其参数作为命令行，让Shell重新执行该命令行，eval的参数再次经过Shell命令行处理的12个步骤
eval在处理简单命令时，与直接执行该命令无甚区别。

演示了eval执行复杂命令：

#!/bin/bash
while read NAME VALUE
do
  eval "${NAME}=${VALUE}" #2.eval重新让其参数再解析一次，这次解析为了赋值语句。
  #${NAME}=${VALUE}  #1.整行会被作为一个命令解析，但是没有该命令存在，报错！
done <evalsource

#print evry variable:
echo "var1=$var1"
echo "var2=$var2" 
echo "var3=$var3" 
echo "var4=$var4" 
echo "var5=$var5"

# 文本的内容：
$ cat evalsource
var1 APPLE
var2 BAIDU
var3 CAMEL
var4 DOT
var5 EMUL  

# 结果输出：
root@37C:~# ./run.sh 
var1=APPLE
var2=BAIDU
var3=CAMEL
var4=DOT
var5=EMUL
root@37C:~# 

evalre.sh脚本关键语句 eval “${NAME}=${VALUE}”
第1轮结束后命令变为： var1=APPLE；再次将该命令提交到Shell，成功实现var1变量的赋值。
evalre.sh脚本还使用了代码块重定向，实现对evalsource文件的遍历。
也就是说，eval `“${NAME}=${VALUE}” 经过下一轮的语法解析，=被解释为元字符，是赋值的含义，而另外那个是单纯的字面含义’=’。

---

pipe变量赋为管道符：pipe='|'
ls $pipe wc -l发生错误：
第1步扫描没有发现有管道符，直到第6步变量替换之后命令行才变成 ls | wc -l，第9步根据$IFS变量将命令行重新分割成4个令牌，第11步将ls当作命令，后面的3个令牌|、wc和-l被解析为ls命令的参数和选项，由于该目录下没有|和wc等文件或目录：

$ ls $pipe wc -l
  ls: |: 没有那个文件或目录
  ls: wc: 没有那个文件或目录

因此，Shell**报语法错误。**
eval ls $pipe wc –l
正确执行：第1轮的结果，ls | wc -l命令行被重新提交到Shell 。