Awk里的域赋值操作和部分源码解析（$1=$1,$0=$0,FS,OFS)

前言：

cu上出了个shell题：

http://bbs.chinaunix.net/thread-2319120-1-1.html

第八题：GNU awk的$1=$1到底有什么作用？$0=$0呢？

这题问得相当的细致。可能很多人已经常用这二个赋值语句，却半知半解。以下分二部分对这个题目进行分析

建议没心情，没耐心，没兴趣的人，只需要了解下第一部分，看第二部分就表看了，很罗嗦的。

第一部分：能过man上边的解析，回签这二个赋值语句的功能

第二部分：awk部分源码解析（结点树简介，及域模块)

通过分析awk域模块源码 ，了解awk的内部处理机制

参考程序及源码版本：gawk-3.1.5

=========================第一部分================================================

第一部分：GNU awk的$1=$1到底有什么作用？$0=$0呢？

首先了解一下一些知识，先翻一下man awk里的这段话：

assigning to anon-existent field (e.g., $(NF+2) = 5) increases the value of NF,

对不存在的域赋值，会增加NF值

creates any intervening fields with the nullstring as their value,

中间域默认为NULL字符串

and causes the value of $0 to be recomputed, with the fields being separated by thevalue of OFS.

$0会被根据OFS值重新计算，

References to negative numbered fields cause a fatal error.

引用负的域索引是无效的，并且会导致错误

Decrementing NF causes the valuesof fields past the new value to be lost,

减少NF值时，索引大于NF的域将会丢失

and the value of $0 to be recomputed, with the fields being separatedby the value of OFS.

同时$0也会被根据OFS值重新计算，

Assigning a value to an existing field causes the whole record to be rebuilt when $0 is referenced.

对当前存在的域值进行赋值，会使记录在$0被引用时重构

Similarly,assigning a value to $0 causes the record to be resplit, creating new values for the fields.

对$0赋值，也会使记录重新重分割，对域重新赋值

这里涉及到二种记录操作

1：记录分割，记录按FS值分割成域，赋给每个域值

2：记录重构，根据域值和OFS重构域。重构之后: $0=$1OFS$2OFS……

另外补充一点额外的知识：

$0与$1,$2….是分开存放的，$0保存的是记录初始的整串值（包括刚读进来时候的分隔符），而$1,2...保存的是分割后的域值，

awk内部函数机制基本上保证了二者的同步，一般不会出现什么错误。

尽管如此，分开存储的记录和域还是不可必免会存在一些应用问题，下边举二个例子说明：

例子一：当我们想通过更改OFS，变更域之间的输出分隔符时，此时$0由于保存的是原来的串，输出并不是按$1OFS$2进行输出：

[root@rac_2~]#echo"aaabbb"|awk'{OFS="#";print$0;}'
aaabbb

[root@rac_2 ~]# echo "aaa bbb"|awk '{OFS="#";print $0;}'        
aaa bbb

此时的办法采用可以列举的办法：

[root@rac_2~]#echo"aaabbb"|awk'{OFS="#";print$1,$2;}'
aaa#bbb

[root@rac_2 ~]# echo "aaa bbb"|awk '{OFS="#";print $1,$2;}'  
aaa#bbb

但是当域值很多时（或不固定时），再用列举的话可能要借用NF，写一个循环

例子二：当我们想通过更改FS，变更域之间的分隔符时，此时$0由于保存的是原来的串，$1并没有重新分隔

[root@rac_2~]#echo"aa#ab#bb"|awk'{FS="#";print$1}'
aa#a

[root@rac_2 ~]# echo "aa#a b#bb"|awk '{FS="#";print $1}'     
aa#a

$1=$1的解析：

命令分解：

1：赋值操作的顺序是从右到左，先通过右操作数引用了$1,取得当前$1的值，

2：再通过赋值操作将值赋给左边的$1

步骤解析：

步骤1没什么特别的，若当前NF=0，这里的$1只会得到空值（NULL string)

步骤2分二种情况

1：若当前NF=0，即上边引文中提到的assigning to a non-existent field，

此时，NF由0变1，

2：若NF>1，则NF不变

接下来是关健做用：由于步骤2触发了域赋值操作，产生了连带的动作：在下一次引用$0时，会对$0进行重新构。（根据OFS）

归纳作用：

下次引用$0时，对$0进行按引用时的OFS进行重构（$1OFS$2OFS……）

应用：

例子一：变更输出分隔符，可以这样：

[root@rac_2~]#echo"aaabbb"|awk'{OFS="#";$1=$1;print$0;}'
aaa#bbb

[root@rac_2 ~]# echo "aaa bbb"|awk '{OFS="#";$1=$1;print $0;}'
aaa#bbb

再来是$0=$0的解析

命令分解：

1：赋值操作的顺序是从右到左，先通过右操作数引用了$0,取得当前$0的值

2：再通过赋值操作将值赋给左边的$0

步骤分析：

步骤1：这里引用了$0进行取值，由于上边提到的设定，要注意是否有重构问题

步骤2：这里是赋值引用，对$0的赋值引用，会涉及到根据当前的FS对域的重分割

归纳作用：根据右操作数$0取出的值（可能是重构的），赋给$0,并根据FS重新分隔

应用：

例子二：变更输入分隔符，对当前记录进行重解析：

[root@rac_2~]#echo"aa#ab#bb"|awk'{FS="#";$0=$0;print$1}'
aa#a

[root@rac_2 ~]# echo "aa#a b#bb"|awk '{FS="#";$0=$0;print $1}'
aa#a

综合应用$1=$1,$0=$0

这里涉及到了FS跟OFS同时变更时，要注意分析，区别应用：

例子三：替换原来的分隔符（假如为A）为新的串（B），最后按分隔符（C）输出第三域

[root@rac_2~]#echo"1CA2CA3CA"|awk'BEGIN{FS="A"}{FS="C";OFS="B";$1=$1;$0=$0;print$3}'
B3

[root@rac_2 ~]# echo "1CA2CA3CA"|awk 'BEGIN{FS="A"}{FS="C";OFS="B";$1=$1;$0=$0;print $3}'
B3

这里如果少了$1=$1的话，则$0在引用时无法根据新的OFS值重构，没有做替换，仍按原先的串按新FS解析，得到原先的第三域值

[root@rac_2~]#echo"1CA2CA3CA"|awk'BEGIN{FS="A"}{FS="C";OFS="B";$0=$0;print$3}'
A3

[root@rac_2 ~]# echo "1CA2CA3CA"|awk 'BEGIN{FS="A"}{FS="C";OFS="B";$0=$0;print $3}' 
A3

这里如果少了$0=$0的话，$0以原先的值"1CA2CA3CA"在读入时按"A"分隔，$3不变

[root@rac_2~]#echo"1CA2CA3CA"|awk'BEGIN{FS="A"}{FS="C";OFS="B";$1=$1;print$3}'
3C

[root@rac_2 ~]# echo "1CA2CA3CA"|awk 'BEGIN{FS="A"}{FS="C";OFS="B";$1=$1;print $3}'
3C

这个结果与下边等同：

[root@rac_2~]#echo"1CA2CA3CA"|awk'BEGIN{FS="A"}{FS="C";OFS="B";print$3}'
3C

[root@rac_2 ~]# echo "1CA2CA3CA"|awk 'BEGIN{FS="A"}{FS="C";OFS="B";print $3}'           
3C

=====================================================================================================

二：awk部分源码解析（结点树简介，及域模块)

看man还是有些不够清晰的，或多或少会留下点疑问，应该会有人考虑到$0在分割之后存放成各个域，既然可以通过各个域拼接起来，为什么还要保存一份原先的串的样本？

比如怎么证明$0是独立于$1,$2,$3的存储存在？这样做又出于什么考虑？

再比如为什么在$1=$1后不是立即重构$0,而是在引用的时候才重构。

再比如对$0进行赋值后，是直接触发分割的，还是在引用域前才进行分隔。

没什么什么比查源码更能回答这些问题的了

通过查看awk的源码中的awk.h头文件可以了解到awk的源码的核心数据结构：结点（typedef struct NODE)和结点树，awk代码里的各种元素都是以树和结点这种结构存在的，变量如FS/$0/$0是结点，操作符如“=赋值符等”也是结点，内置函数（builtin)也是结点，哈希数组也是结点。

awk是以节点（node 结构)树的形式保存各种变量和操作的，比如各变量，各{}操作块都是树的节点。awk通过调用awkgram.c的yylex+yyparse二个函数，解析awk程序，并形成各种树，比较典型的，如主体程序有三颗数：

/*AblockofAWKcodetoberunbeforerunningtheprogram*/
NODE*begin_block=NULL;
/*Theparsetreeisstoredhere.*/
NODE*expression_value;
/*AblockofAWKcodetoberunafterthelastinputfile*/
NODE*end_block=NULL;

/* A block of AWK code to be run before running the program */
NODE *begin_block = NULL;
/* The parse tree is stored here.  */
NODE *expression_value;
/* A block of AWK code to be run after the last input file */
NODE *end_block = NULL;

程序块在解析形成树之后，由函数 执行Intinterpret(register NODE *volatile tree)

begin模块跟end模块都执行一次

if(begin_block!=NULL){
in_begin_rule=TRUE;
(void)interpret(begin_block);
}
if(end_block!=NULL){
in_end_rule=TRUE;
(void)interpret(end_block);
}

        if (begin_block != NULL) {
                in_begin_rule = TRUE;
                (void) interpret(begin_block);
        }
        if (end_block != NULL) {
                in_end_rule = TRUE;
                (void) interpret(end_block);
        }

而中间模块：expression_value 是在do_input里，一次读一一条记录执行一次的

for(;;){
rval2=rval3=-1;/*fordebugging*/
rval2=interpret(expression_value);
if(rval2!=0)
rval3=inrec(iop);
if(rval2==0||rval3!=0)
break;
}

                        for (;;) {                                                                               
                                rval2 = rval3 = -1;     /* for debugging */                                      
                                rval2 = interpret(expression_value);                                             
                                if (rval2 != 0)                                                                  
                                        rval3 = inrec(iop);                                                      
                                if (rval2 == 0 || rval3 != 0)                                                    
                                        break;                                                                   
                        } 

然后回到正题：域模块源码：field.c，通过分析模块的数据结构和函数来了解模块设计，包括分隔符设计，记录分割，记录设置，域设置等

首先是数据结构：

NODE**fields_arr;/*arrayofpointerstothefieldnodes*/

NODE **fields_arr;              /* array of pointers to the field nodes */

fields_arr数组保存了所有域节点，$1,2...分别对应一样的下标fields_arr[1,2…]：

C的数组索引是从0开始的，这里也不例外，

fields_arr[0]是用于保存完整记录的节点，保存记录值，即$0

然后是函数，我们关注函数的功能和调用。

NF相关函数：

NF（域数值）赋值函数：

voidset_NF()

void set_NF()

直接更改NF值，域数组随NF长短做伸缩

最后一句话:field0_valid = FALSE;涉及到记录重构，见rebuild_record()

记录层面的函数：赋值，重构，域分割等

记录重置函数：

voidreset_record()

void reset_record()

重置记录，清除fields_arr，NF= -1,视情况保存当前FS

当对$0赋值时即是调用此函数

记录赋值函数：

voidset_record(constchar*buf,intcnt)

void  set_record(const char *buf, int cnt)

此函数调用：reset_record,重置数组，将buf数组里的内容保存到fields_arr[0] 里边去

注意：此时并未进行分割。注释里是这么写的：

* setup $0, but defer parsing rest of line until reference is made to $(>0)

* or to NF. At that point, parse only as much as necessary.

虽然保存的记录值，但没有做域解析，直到域或NF引用才做解析

记录重构函数:

staticvoidrebuild_record()

static void  rebuild_record()

这个函数没有参数，这个函数的功能是把当前各域fields_arr[1,2….]数组拼接OFS，形成新的字符串更新到fields_arr[0]

并且这个函数只在get_field函数里，只有在field0_valid标志为fault时前提下，做$0引用时，才调用

记录分割函数：

NODE*do_split(NODE*tree)

NODE * do_split(NODE *tree)

根据设定的规则，解析域，包括定长解析，正则解析，字符串解析等。

（这么多的规则，是为了满足功能和效率需求。）

域层面的函数：

域赋值函数：

taticvoidset_field(longnum,char*str,longlen,NODE*dummyATTRIBUTE_UNUSED)

tatic void set_field(long num, char *str, long len, NODE *dummy ATTRIBUTE_UNUSED) 

通过对域节点操作fields_arr[num]，简单的赋域值，这函数由get_field调用

最关健的函数：

域引用函数：

NODE**get_field(registerlongrequested,Func_ptr*assign)

NODE ** get_field(register long requested, Func_ptr *assign)

requested是fields_arr的下标数值，下标为零是记录,即$0，下标大于零是域

这边称为引用函数，因为域引用，有可能是出现在赋值运算符的左边（LHS）或右边（LHS）

因为在词法解析过程中，$n是出现在赋值语句"="号左边还是右边都是一样的标记，并没有什么不同，

到语法解析的时候才能明白并且由assign指定，assign为空则是取值引用，非空则是赋值引用

这个函数分为以下四种情况：

1：$0取值引用，requested=0，assign = NULL

若 field0_valid = FALSE则调用 rebuild_record（重构fields_arr[0])，

返回fields_arr[0]

2：$n(n>=1)取值引用，requested!=0，assign = NULL

若未进行域解析，则调用域解析函数，

返回fields_arr[n]

3：$0赋值引用，requested=0，assign!= NULL

若 field0_valid = FALSE,同样调用rebuild_record重构记录，

记录赋值是在 set_record里完成的，返回fields_arr[0]

4：$n(n>=1)赋值引用：requested!=0，assign = NULL

设置 field0_valid = FALSE;

域赋值在set_field里完成的，返回fields_arr[n]

结论：

1：记录值（$0）与各域值（$1,2,….）是分离存放不同node结点里，前者存放在fields_arr[0]，后者存放在fields_arr[1,2...]

2：域赋值引用会引起记录重构和分割（不是同步的）

3：域取值引用会根据情况判断是否进行记录重构，或重新分割。

再看awk的一些更新记录关于get_field函数的说明：

Changesfrom2.12.27to2.12.28
Tunedget_field()--itwasunnecessarilyparsingthewholerecordonreference
to$0.
Changesfrom2.11.1to2.12
Fixedbuginget_field()wherebychangestoafieldwerenotalways
properlyreflectedin$0.
get_field()passesFS_regexp
tore_parse_field(),asdoesdo_split().
Changesfrom2.10betato2.11beta
Fixinget_field()forcasewhere$0ischangedandthen$(n)are
changedandthen$0isused.

Changes from 2.12.27 to 2.12.28           
Tuned get_field() -- it was unnecessarily parsing the whole record on reference
  to $0.
Changes from 2.11.1 to 2.12
Fixed bug in get_field() whereby changes to a field were not always
  properly reflected in $0.
 get_field() passes FS_regexp
  to re_parse_field(), as does do_split().
Changes from 2.10beta to 2.11beta
Fix in get_field() for case where $0 is changed and then $(n) are
changed and then $0 is used.

其实这部分机制也就是awk程序当前版本的一种设定。在版本变更中，有的做为bug,有的做为设定进行调整。

没必要再深究下去了，知道基本的作用就行了。