Chinaunix首页 | 论坛 | 博客

菜鸟先飞

首页　| 　博文目录　| 　关于我

luoyan_xy

  • 博客访问： 381316
  • 博文数量： 73
  • 博客积分： 3574
  • 博客等级： 中校
  • 技术积分： 1503
  • 用 户 组： 普通用户
  • 注册时间： 2010-03-26 11:17
文章分类

全部博文（73）

文章存档

2012年（14）

2011年（15）

2010年（44）

我的朋友
最近访客
推荐博文
相关博文
python自动生成结构体打印函数

分类： Python/Ruby

2012-09-11 23:15:20

    原始需求是在调试代码的过程中，经常需要插入一些printk或printf调试语句，而如果被调试的对象是一个结构体，并且结构体所包含的变量还比较多的时候，手写打印结构体内变量的函数就成了一个琐碎而又无聊的工作。

    那么，有没有什么办法能够自动生成这些打印函数，在需要的时候直接编译，而不需要手动去一行行的敲代码呢。
    当然，这个问题绝对不是我第一次遇到，网上查了一下，有不少人在问同样的问题，而在开源界也有一个实现此功能的开源软件，它的原理是利用gcc -g编译生成的二进制代码中已经存在打印每个结构体变量的函数，通过某种方法把这些code码直接抠出来使用。
    
    这个方法当然比较高明了，恰巧最近在学习python的正则表达式，便想着能不能通过正则表达式去解析代码，生成一个.h或者.c文件，文件中包含针对每个结构体的打印函数，下面就可以直接在需要的位置添加这些函数，重新编译时把生成的文件编译进工程就可以了。
    针对这个需求，有了以下的代码：

点击(此处)折叠或打开

  1. #!/usr/bin/env python
  2. #-*-coding:UTF-8 -*-

  4. import re
  5. import os
  6. import sys
  7. import getopt


  10. print_symbol = {} #保存打印符号信息

  12. print_func = {} #保存每一个结构体对应的打印函数

  14. define_store = [] #保存分解出的所有typedef定义
  15. struct_store = [] #保存分解出的所有struct结构列表
  16.     
  17. #默认写入文件为temp.c
  18. target_file = './temp.c'


  21. m = re.compile(r'struct\s*\w[\w_]*?\s*?{.*?}',re.S) #匹配struct(不支持嵌套)
  22. n = re.compile(r'typedef.*?(?=;)') #匹配typedef定义
  23. m1 = re.compile(r'/\*.*?\*/',re.S) #匹配/*...*/的注释
  24. n1 = re.compile(r'//.*(?=\n)') #匹配//..的注释
  25. m2 = re.compile(r'#if\s*?0.*?#endif',re.S) #匹配#if 0的注释(不支持嵌套)


  28. #设置打印符号的默认配置
  29. def set_default_conf():
  30.     #后期可考虑默认打印符号的自动化生成，如生成组合，确定打印类型等
  31.     print_symbol['int'] = '%d'
  32.     print_symbol['unsigned int'] = '%u'
  33.     print_symbol['long'] = '%l'
  34.     print_symbol['unsigned long'] = '%lu'
  35.     
  36.     print_symbol['short'] = '%d'
  37.     print_symbol['unsigned short'] = '%u'
  38.     
  39.     print_symbol['char'] = '%c'
  40.     print_symbol['unsigned char'] = '%u'

  42.     print_symbol['float'] = '%f'
  43.     print_symbol['double'] = '%f'

  45.     print_symbol['void *'] = '%p'
  46.     print_symbol['int *'] = '%p'
  47.     print_symbol['char *'] = '%p'


  50. #处理单个define
  51. def collect_each_define(define_item):
  52.     define_store.append(define_item)


  55. #处理单个struct
  56. def collect_each_struct(struct_item):
  57.     #删除注释应放到最前面，防止解析到已经注释到的结构体    
  58.     #删除注释
  59.     #struct_item = m1.sub('',struct_item)
  60.     #struct_item = n1.sub('',struct_item)
  61.     
  62.     struct_store.append(struct_item)


  65. #处理数组赋值
  66. def process_array(head,fp,line):
  67.     #print 'array\t' + line
  68.     #指针数组
  69.     if '*' in line:
  70.         flag_match = re.compile(r'\*+')
  71.         flag = ''.join(flag_match.findall(line))
  72.         style = flag_match.split(line)[0]
  73.         name_value = flag_match.split(line)[-1]
  74.         array_match1 = re.compile(r'\w\w*?(?=\[)')
  75.         array_match2 = re.compile(r'(?<=\[)\d+(?=\])')
  76.         name = array_match1.findall(line.split()[-1].strip())
  77.         value = array_match2.findall(line.split()[-1].strip())
  78.         name = ''.join(name).strip()
  79.         value = ''.join(value).strip()

  81.         style += flag
  82.     #普通数组
  83.     else:
  84.         style = (' '.join(line.split()[:-1])).strip()
  85.         #print style
  86.         #print line.split()[-1].strip()
  87.         array_match1 = re.compile(r'\w\w*?(?=\[)')
  88.         array_match2 = re.compile(r'(?<=\[)\d+(?=\])')
  89.         name = array_match1.findall(line.split()[-1].strip())
  90.         value = array_match2.findall(line.split()[-1].strip())
  91.         name = ''.join(name).strip()
  92.         value = ''.join(value).strip()

  94.     #style为类型，name为变量名，value为数组大小
  95.     if style in print_symbol.keys():
  96.         if '%' in print_symbol[style]:
  97.             fp.write('\n')    
  98.             fp.write('''\tfor(i = 0 ; i < %s; i++)\n''' %value)
  99.             fp.write('''\t{\n''')
  100.             fp.write('''\t\tprintf("%s.%s <==> %s\\n",item.%s);\n''' %(head,name,print_symbol[style],name))
  101.             fp.write('''\t}\n''')
  102.     #不在打印符号表内的指针统一按照%p打印
  103.     elif '*' in style:
  104.         fp.write('\n')    
  105.         fp.write('''\tfor(i = 0 ; i < %s; i++)\n''' %value)
  106.         fp.write('''\t{\n''')
  107.         fp.write('''\t\tprintf("%s.%s <==> %%p\\n",item.%s);\n''' %(head,name,name))
  108.         #print ('''\t\tprintf("%s.%s <==> %%p\\n",item.%s);\n''' %(head,name,print_symbol[style],name))
  109.         fp.write('''\t}\n''')



  113. #处理位域赋值
  114. def process_bit(head,fp,line):
  115.     #print 'bit\t' + line
  116.     bit_match = re.compile(r'\w+:\d+')
  117.     style_match = re.compile(r'\w+')

  119.     bit_list = bit_match.findall(line)
  120.     style = ''.join(style_match.findall(bit_match.sub('',line)))

  122.     if style in print_symbol.keys():
  123.         if '%' in print_symbol[style]:
  124.             for it in bit_list:
  125.                 its = str(it)
  126.                 fp.write('''\tprintf("%s.%s <==> %s\\n",item.%s);\n''' %(head,its[:its.index(':')],print_symbol[style],its[:its.index(':')]))
  127.     else:
  128.             fp.write('''printf("sizeof(%s.%s) %%d\n",sizeof(%s.%s));\n''' %(head,name,head,name))



  132. #处理指针赋值
  133. def process_pointer(head,fp,line):
  134.     #print 'pointer\t' + line
  135.     #数组处理优先级更高，确保在这个地方已经不存在指针数组
  136.     if '*' in line:
  137.         #print line        
  138.         flag_match = re.compile(r'\*+')
  139.         flag = ''.join(flag_match.findall(line))
  140.         style = flag_match.split(line)[0]
  141.         name = flag_match.split(line)[-1]

  143.         style += flag
  144.     
  145.         if style in print_symbol.keys():
  146.             if '%' in print_symbol[style]:
  147.                 fp.write('''\tprintf("%s.%s <==> %s\\n",item.%s);\n''' %(head,name,print_symbol[style],name))
  148.         else:
  149.             fp.write('''\tprintf("%s.%s <==>%%p\\n",item.%s);\n''' %(head,name,name))


  152. #处理标准赋值
  153. def process_normal(head,fp,line):
  154.     #print 'normal\t' + line
  155.     style = (' '.join(line.split()[:-1])).strip()
  156.     name = line.split()[-1].strip()
  157.     if style in print_symbol.keys():
  158.         #如果已经存在%*的打印格式
  159.         if '%' in print_symbol[style]:
  160.             fp.write('''\tprintf("%s.%s <==> %s\\n",item.%s);\n''' %(head,name,print_symbol[style],name))
  161.             #pass
  162.     #这种情形应该为结构体中包含别的结构体变量
  163.     else:
  164.         #先规避，打印结构体大小，后续可直接嵌套打印函数
  165.         fp.write('''\tprintf("sizeof(%s.%s) %%d\\n",sizeof(%s.%s));\n''' %(head,name,head,name))
  166.         #pass



  170. #解析struct中每一个定义语句
  171. def process_line(head,fp,line):

  173.     #判断是否为位域定义(假定位域的定义中包含,)
  174.     if ',' in line:
  175.         process_bit(head,fp,line)
  176.     #判断是否为数组(数组的定义为包含一对中括号[]),对于指针数组优先为数组
  177.     elif '[' in line and ']' in line:
  178.         process_array(head,fp,line)
  179.     #判断指针
  180.     elif '*' in line:
  181.         process_pointer(head,fp,line)
  182.     #正常赋值(还有没有其他情况？)
  183.     else:
  184.         process_normal(head,fp,line)

  186. #解析define
  187. def reslove_each_define():
  188.     for item in define_store:
  189.         temp_match = re.compile('typedef')
  190.         item = temp_match.sub('',item)

  192.         #这块解析的好烂啊，复杂点的都解析不出来
  193.         #怎么解析指针类赋值,尤其函数指针???
  194.         temp_list = item.split(' ')
  195.         s = (' '.join(temp_list[:-1])).strip()

  197.         if s in print_symbol.keys():
  198.                 print_symbol[temp_list[-1]] = print_symbol[s]
  199.         else:
  200.             #先保存define定义，在生成打印时再查找确认一次
  201.             print_symbol[temp_list[-1]] = s


  204. #解析struct
  205. def reslove_each_struct():
  206.     for item in struct_store:
  207.         #获取struct的名字
  208.         name_match = re.compile(r'(?<=struct)\s*\w\w*(?=\s*?{)')
  209.         name = name_match.findall(item)
  210.         name = (''.join(name)).strip()
  211.         #假设{}之间的为正文
  212.         index1 = item.find('{')
  213.         if index1 == -1:
  214.             print 'reslove failed for the error farmat struct'
  215.             return
  216.         index2 = item.find('}')
  217.         if index2 == -1:
  218.             print 'reslove failed for the error farmat struct'
  219.             return
  220.         
  221.         fp = open(target_file,'a+')
  222.         fp.write('\n')
  223.         fp.write('void print_%s(%s item)\n'%(name,name))
  224.         fp.write('{\n')
  225.         fp.write('\tint i = 0; \n')
  226.         #print ('void print_%s(struct %s item)\n'%(name,name))
  227.         
  228.         date = item[index1 +1 : index2]

  230.         item_match = re.compile(r'\w.*?(?=;)',re.S)
  231.         for line in item_match.findall(date):
  232.             process_line(name,fp,line)

  234.         fp.write('}\n')
  235.         fp.close()

  237. #完成对单个文件的解析
  238. def handle_file(test_file):
  239.     fp = open(test_file,'r')
  240.     context = fp.readlines()
  241.     context = ''.join(context)

  243.     context = m2.sub('',context)
  244.     context = m1.sub('',context)
  245.     context = n1.sub('',context)

  247.     file_define = []
  248.     file_struct = []
  249.     for i in n.findall(context):
  250.         collect_each_define(i)

  252.     for j in m.findall(context):
  253.         collect_each_struct(j)

  255. '''
  256. def write_to_file(target):
  257.     pass
  258. '''

  260. def print_help_info():
  261.     '''print function help information'''
  262.     print 'Usage: python get_struct.py [-f file -d directory -o target_file -h --help]'
  263.     print '-f 待解析的源文件'
  264.     print '-d 待解析的目录，将解析目录下所有的.c以及.h'
  265.     print '-o 打印函数保留文件，默认保留在当前目录下的temp.c文件中'
  266.     print '-h/--help 打印帮助信息'


  269. if __name__ == '__main__':
  270.     if(len(sys.argv) <= 1):
  271.             print 'input the error args format'

  273.     try:
  274.         opts,args = getopt.getopt(sys.argv[1:],'f:d:ho:',['help'])
  275.     except getopt.GetoptError,err:
  276.         print str(err)
  277.         sys.exit(-1)
  278.     
  279.     reslove_file = 0
  280.     reslove_dir = 0
  281.     
  282.     for k,v in opts:
  283.         if k == '-f':
  284.             reslove_file = v
  285.             print reslove_file
  286.         elif k == '-d':
  287.             reslove_dir = v
  288.             print reslove_dir
  289.         elif k == '-o':
  290.             target_file = v
  291.             print target_file
  292.         elif k in ('-h','--help'):
  293.             print_help_info()
  294.             sys.exit()
  295.         else:
  296.             print 'Error,unhandled option'
  297.             sys.exit(-1)
  298.     
  299.     set_default_conf()

  301.     if(reslove_file):
  302.         handle_file(reslove_file)
  303.     if(reslove_dir):
  304.         #文件夹支持
  305.         pass

  307.     #print print_symbol
  308.     #解析define以及struct
  309.     reslove_each_define()
  310.     reslove_each_struct()

  312.     #将解析结果写入文件
  313.     #write_to_file(reslove_file)
 
     代码中注释自认为还是比较详细的，代码也不长，看懂应该没什么问题。
     一共300行左右的代码，花了自己两个晚上看电影的时间，不过如果用C实现，用字符串去解析，那这个工程的复杂性还会增加，由此可见，python在效率（编码 + 调试 + 运行）上还是有一定的优势。

     当然了，代码中也存在不少的问题，而且有一些严重的硬伤，究其愿意还在于用正则的语义去完成词法分析、语法分析的逻辑，还是稍有差别的。
     如果有机会，以后会慢慢完善它；如果谁有一些好的建议，也可以交流~
     
阅读(6307) | 评论(0) | 转发(0) |
0

上一篇：创建python的C扩展

下一篇：Linux内核kprobe机制实现浅析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6