用lex分析C源码中数据结构关系拓扑图

程序=数据结构+算法。最近在看ovs源码时，被其中c源码里面数据结构之间复杂的关系搞的晕头转向，所以强烈想自己写个工具来解析代码内数据结构之间的拓扑。

本来想找个现成工具来的，一直没有找到好用的工具，于是产生自己来写的想法。本文记录下该想法实现的思路及详细过程。

步骤如下：

1）用lex解析出C源码里面的struct体到文件，包括用lex去掉注释并匹配struct结构体的过程。

2）利用python将1）中的到的struct体进行关系处理，并描述成graphviz dot格式文本。

3）利用graphviz 将dot格式进行绘图，得到可视化的结构体关系图。

下面逐步介绍：

1） lex 解析c里面的结构体


我之前虽然看过编译原理，但是对lex yacc基本都没用过。写这个东西，无非就是将C代码里面的结构体全部过滤出来，之后将结构体图关系绘制出来。所以上来就面临lex的用法。在网上找了一些lex的资料，发现都是实验用的，几乎都是解析一个小功能，没有能够一次解析多个功能的，所以都无法直接用。
关于lex还是找官网直接的资料比较好，我基本全部看了一遍，见官方的介绍http://dinosaur.compilertools.net/#lex。


我的用法也比较简单，只需要一次能够解析2个功能1）去掉源码中的所有注释 2）解析出C代码中的结构体。这中间经历了比较多的曲折，别小看这两个小功能，关于lex的正则表达式可是看了不少贴才写出。贴出代码，再废话。
由于lex不能用注释，我试过// /**/在规则中都会导致一定问题，所以代码里面先没写注释。

cat source.txt
%{
#include <stdio.h>
extern char* yytext;
extern FILE *yyin;
extern FILE *yyout;
%}


comment_t (\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+\/)|(\/\/.*)
string_t [a-zA-Z0-9_\-]+


string_head struct[ \t]+.{string_t}[ \t]*[\n]?\{
string_element {string_t}[ \t]+[^;{]+[ \t]*\;


%s STRUCT COMMENT TAG


%%
<STRUCT>struct[ \t]+.{string_t}[ \t]*[\n]?\{([^}]|[\r\n])*\}\; {fprintf(yyout,"%s\n",yytext);}
<COMMENT>{comment_t} ;
<COMMENT>. fprintf(yyout,"%s",yytext) ;
<COMMENT>\n fprintf(yyout,"\n") ;
<STRUCT>.  ;
<STRUCT>\n ;
<TAG>{string_head} fprintf(yyout,"TTT_HEAD:%s\n",yytext);
<TAG>{string_element} fprintf(yyout,"TTT_ELE:%s\n",yytext);
<TAG>. fprintf(yyout,"%s",yytext);
<TAG>\n  fprintf(yyout,"\n");
%%


#include <sys/types.h>
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>


int yywrap(){
    return 1;
}
 
int main(int argc, char *argv[])
{
int step = 0;
char file_dir[1024]={0};
char file_no_comment[1024]={0};
char file_struct[1024]={0};
char file_result[1024]={0};


int size = 1023;


if (argc != 2){
    printf("please give src file path\n");
    return 0;
}


getcwd(file_dir,size); 


strcat(file_no_comment, argv[1]);
strcat(file_no_comment, "-1.txt");


strcat(file_struct, argv[1]);
strcat(file_struct,"-2.txt");


strcat(file_result, argv[1]);
strcat(file_result,"-struct-result.txt");


printf("out file is %s\n", file_result);


yyin=fopen(argv[1],"r");
if (!yyin)
{
    printf("error file %s\n",argv[1]);
    return 0;
}
yyout=fopen(file_no_comment, "w+");
if (!yyout)
{
    printf("error out file\n");
    return 0;
}


BEGIN COMMENT;
yylex();
fclose(yyin);
fclose(yyout);


yyin=fopen(file_no_comment,"r");
if (!yyin)
{
    printf("error file %s\n",file_no_comment);
    return 0;
}
yyout=fopen(file_struct, "w+");
if (!yyout)
{
    printf("error out file\n");
    return 0;
}
BEGIN STRUCT;
yylex();
fclose(yyin);
fclose(yyout);
remove(file_no_comment);


yyin=fopen(file_struct,"r");
if (!yyin)
{
    printf("error file %s\n",file_no_comment);
    return 0;
}   
yyout=fopen(file_result, "w+");
if (!yyout)
{
    printf("error out file\n");
    return 0;
}   
BEGIN TAG;
yylex();
fclose(yyin);
fclose(yyout);
remove(file_struct);

return 0;
}

上面这个代码的功能，是对输入的源码，执行去除所有注释的功能；再将源码中的结构体输出到后缀为-struct-result.txt的文件中。说下一具体思路：


第一遍，只开启BEGIN COMMENT;的规则，这样将输的源码，全部去除注释后，写入到后缀为-1.txt的文件中。
第二遍，只开启BEGIN STRUCT的规则，修改yyin yyout，将第一次的输出-1txt文件作为输入，识别出所有的struct ，写入到-2.txt的文件中。

第三遍，只开启BEGIN TAG的规则, 修改yyin yyout，将第二次的输入-2.txt文件作用输入，将 struct 头与struct中的元素，加上TTT_HEAD/TTT_ELE的标示，最后输出到-struct-result-txt文件中。因为后面我需要用PYTHON来解析结构体，解析处理时不方便识别struct的名称与里面的结构体，所以这个第三边也是必须的。

初写lex时，由于网上都是写基础资料，都是针对一个小功能进行解析，所以不知道怎么在一个lex脚本里面完成多个功能，故当时写了三个lex程序去做上面三个事情。后面突然看到BEGIN XXX这个用法后，逆向思维了下，觉得靠谱，果然写出来了。这个lex的例子比较少，大部分资料都是介绍怎么用正则表达式，感觉目前是牛人不屑于写一般的例子，而初学者只能写简单例子，所以几乎很少看到能用的中等例子。个人的这个例子，可以在一个lex中处理三个小功能。可能有人会说，你搞复杂了，没必要分三次来解析。其实我想目前我还不是非常精通lex框架处理流程，所以只能分三次解析。因为如果不分三次解析的话，lex的一些特点，比如匹配最长的字串，可能会在二次处理注释与结构体时有一些遗漏或互相干扰。所以干脆来个分三次处理，免得干扰。

所有代码在linux下完成，执行如下构建：
lex example
gcc lex.yy.c -o parse -ll 
这样就得出了可以去除注释，并且识别struct的parse程序。这个parse file_name 已经可将file_name中的结构体解析到file_name-struct-result.txt中了。


说一下里面的表达式，


comment_t (\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+\/)|(\/\/.*) 这个我认为是核心，基本上我花了半天多功夫才找到这个去除C注释的表达式。在一个国人写的帖子里面，而且他引用了一个老外的例子，对所有注释格式进行了说明，解释了为什么这个又长又丑陋的表达式是必须的。老外的帖子我暂时不记得了，感兴趣的“必应”下（顺便吐槽下百度搜索，收学术资料基本收不到）。

string_t [a-zA-Z0-9_\-]+

struct[ \t]+.{string_t}[ \t]*[\n]?\{([^}]|[\r\n])*\}\; 是用来识别C结构体的表达式。注意这里\r\n可能又一些遗留，在linux下是没问题的，在windows下，可能对有\n的地方必须有\r，我没有试过windows。


为了让多个表达式直接不互相影响，（前面说了，lex有个最长匹配等混淆），所有我使用了BEGIN 开关，做了三次处理，每次只处理一个类型，防止多个类型直接互相影响。我觉得每次只处理一个类型是比较好的，这样就不会因为lex自身的规则等互相干扰。


基本上，这样后，通过执行 ./parse file_path 就可以再 file_path-struct-result.txt 中得到struct的结构体了。后面我们需要用python对结构体进行二次分析。



2）用python 来解析结构体文件。


这里说点后话，我最终发现利用我的解析来分析ovs代码时，得到了一个很大的关系图，大的无法想象，有近1000个struct。打开一开，乱的很，基本没法看了，因为有太多结构体图了，一度到了900个结构体之多，而且每个结构体直接用线连起来，实在是没法看。而且我发现，绝大部分都是一个孤立的结构体，即这个结构体就它自己，没有与其他结构体有连接关系，这类就不是我们想要的结果。所以果断忽略孤岛结构体，不绘制这不部分。不说了，上python代码。

cat parse-struct.py 
#!/usr/bin/env python


import os
import sys
import string
import getopt
import copy


parse_tool = '/home/data_struct_show/parse'  #this is lex tools path, please modify in you os


FILE_TYPE=['.c', '.h']
RESULT_STRUCT=[]
count = 0
frame_height = 30
frame_weight = 300
frame_space = 100




def file_type_ok(fileName):
    global FILE_TYPE
    for x in FILE_TYPE:
        if fileName.endswith(x):
            return True
    return False


def do_parse(fileName):
    if 'struct-result.txt' in fileName:
        return


    if file_type_ok(fileName):
        cmd = '%s %s' %(parse_tool, fileName)
        os.system(cmd)
 


def filter_struct_name(name):
    str_head=name
    str_head=str_head.replace('{', '')
    str_head=str_head.replace('\t', ' ')
    str_head=str_head.strip()
    return str_head


def filter_struct_ele(name):
    str_ele=name
    str_ele=str_ele.replace('{', '')
    str_ele=str_ele.replace('\t', ' ')
    str_ele=str_ele.strip()
    return str_ele




def judge_element_is_fun(name):
    if '(' in name and ')' in name:
        return True
    return False


def judge_element_is_strut(name):
    if ('struct ' in name) and not ('(' in name and ')' in name):
        return True


    return False


def get_struct_element_name(name):
    str = name
    keys =['struct ', 'const ', ]
    for x in keys:
        str = str.replace(x,'')
    str = str.strip()
    if str.find(' ')!=-1 and str[:str.index(' ')]:
        str = str[:str.index(' ')]
    elif str.find('\t')!=-1 and str[:str.index('\t')]:
        str = str[:str.index('\t')]
    else:
        return None
    return str


def get_struct_name(data):
    ret = {}
    index = 0
    for m in data:
        name = m[0]
        name = name.replace('struct ', '')
        name = name.strip()
        if name in ret:
            pass
        else:
            ret[name]=[index]
            index +=1
        for n in m[1:]:
            if 'struct ' in n:
                #n = n.replace('struct ', '')
                n = n.replace(';','')
                n = n.strip()
                ret[name].append(n)
    return ret


def get_struct(fileName):
    global RESULT_STRUCT
    #print fileName
    if 'struct-result.txt' in fileName:
        handle = open(fileName)
        lines = handle.readlines()
        handle.close()
        os.remove(fileName)
        one_struct=[]
        for line in lines:
            if 'TTT_HEAD:' in line:
                if len(one_struct) != 0:
                    RESULT_STRUCT.append(one_struct)
                    one_struct = []
                str_head = line[line.index('TTT_HEAD:')+len('TTT_HEAD:'):-1]
                str_head = filter_struct_name(str_head)
                one_struct.append(str_head)    
            elif 'TTT_ELE:' in line:
                str_ele = line[line.index('TTT_ELE:')+len('TTT_ELE:'):-1]
                str_ele = filter_struct_ele(str_ele)
                one_struct.append(str_ele)
            else:
                continue


def walk_dir(dirName, do_work):
    global count;


    if(not os.path.isdir(dirName)):
        #print dirName
        count +=1
        do_work(dirName)
        return 


    files = os.listdir(dirName)
    
    for oneFile in files:
        temp = os.path.join(dirName, oneFile)
        if(os.path.isdir(temp)):
            walk_dir(temp, do_work)
        else:
           #print(temp)
           count += 1
           do_work(temp)
      
            
def draw_graph(data):
    fobj = open('./graph', 'w+')
    str_head = 'digraph G { \n \
node [shape=record,height=.1]; \n'
    fobj.write(str_head)


       #fobj.write(str)


    str_ship=''
    str_filter=set()
    for x in data:
        index = 1
        for y in data[x][1:]:
            if judge_element_is_strut(y):
                ele_struct_name = get_struct_element_name(y)
                if ele_struct_name is not None and ele_struct_name in data:
                    if '*' not in y:
                        str='node%d: f%d->"node%d":f%d[dir=none color="red"];\n' %(data[x][0],index,data[ele_struct_name][0],0)
                    else:
                        str='node%d: f%d->"node%d":f%d;\n' %(data[x][0],index,data[ele_struct_name][0],0)
                    str_filter.add(data[x][0])
                    str_filter.add(data[ele_struct_name][0])
                    str_ship +=str
            index +=1
      
    print '--list',str_filter          
    str_node=''
    for x in data:
        if data[x][0] not in str_filter:
            continue
        str='node%d[label ="{<f0>%s' %(data[x][0], x)
        index = 1
        for y in data[x][1:]:
            if not judge_element_is_fun(y):
                str+='|<f%d>%s' %(index,y)
            index +=1
        str +='}"];\n'
        str_node+=str;


    fobj.write(str_node)
    fobj.write(str_ship)
            
    fobj.write('}\n')
    fobj.close()
              

    
def main():
    try:
        opts, args = getopt.getopt(sys.argv[1:], "d:", ["dir="])
    except:
        print("para error" + ' ' + str(sys.argv[1:]))
        sys.exit(1)


    dirPath = []


    for opt, arg in opts:
        if opt in ('-d', '--dir'):
            dirPath = arg.split(':')
            continue
        else:
            print('para error')
            sys.exit(1)


    for dir in dirPath:
        walk_dir(dir, do_parse)
        walk_dir(dir, get_struct)


    print 'total file is %d' %count


    struct_dit = get_struct_name(RESULT_STRUCT)
	
    draw_graph(struct_dit)


    os.system('dot -Tpng graph -o graph.png')
    #draw_pic(RESULT_STRUCT)


if __name__ == '__main__':
    main()

parse-struct.py -d xxxx_dir1_path:xxxx_dir1_path 

多个目录之间用：分隔开，没有就只写一个目录，这个脚本会将目录下面所以C代码中所有struct全部绘制处理，最后的关系图是graph.png。

这里需要在Linux 上yum install graphviz 来安装graphviz工具，其实就是最后调用的那个命令是graphviz提供的。

这个代码，可能写的比较戳，但基本没有啥费力气的。做了如下功能：


1）读取目录，遍历目录，对目录里面的所有文件调用前面的parsy 工具，得到-struct-result.txt的文件。
2）将所有-struct-result.txt里面的结构体，读取出来。然后根据一个结构体，是否里面嵌套了其他结构体，去判断这二者结构体是否有关系。对有关系的结果体，全部都标示出来。
3）利用graphviz的dot语言，对2中所有有关系的结构体，写出符合dot描述的graph文件，最后直接用dot -Tpng graph -o graph.png命令绘制出来。
里面对结构体里面的函数进行了截断出来，或者干脆不显示结果体里面的函数。所有嵌套的结构体，用红色的线画出，对于指针个数的结构体，用箭头前画出。


代码里面有一个draw_pic，这个函数没用。我开始是准备自己来画图的，利用pil。但是后面再网上看另一个开源的graphviz工具，这个dot语音真是太牛逼了，只需要安装一定的格式去描述结构体，他自己都会讲关系图给我画出来。所以我再一次站在了巨人的肩膀上，直接用了这个画图工具。有关graphviz的资料，还是看官网：
http://www.graphviz.org/Documentation.php 这个工具真是太强大了。

来看看几个最终效果图：

最后来一个巨无霸，本来1000多个结构体的，去掉孤岛结构体后，勉强还可以看：）貌似超过2M了，算了。

后话：lex yacc 这两个东西，以前只知道有，没想到功能真是太强大了。现在真的是有这个感觉，学习编程到一个阶段后，发现所有的语言，无论是过程式、面向对象式、函数式等这些，掌握它们都已经不是问题，甚至觉得学习语言本身太浅，反而应该回归到了编译原理上面，可以武断的说，编译原理才是真正的语言之语言。