[关闭]
@cloverwang 2016-05-18T04:03:03.000000Z 字数 7407 阅读 2042

为C函数自动添加跟踪语句

Python 正则表达式

声明

本文将借助正则表达式，采用Python2.7编写脚本，自动对C代码工程中的函数添加调试跟踪语句。
正则表达式的基础知识可参考《Python正则表达式指南》一文，本文将不再赘述。

一. 问题提出

作者复杂的模块包含数十万行C代码，调用关系复杂。若能对关键函数添加调试跟踪语句，运行时输出当前文件名、函数名、行号等信息，会有助于维护者和新手更好地掌握模块流程。

考虑到代码规模，手工添加跟踪语句不太现实。因此，作者决定编写脚本自动实现这一功能。为保证不影响代码行号信息，跟踪语句与函数左花括号{位于同一行。

二. 代码实现

2.1 函数匹配测试

匹配C函数时，主要依赖函数头的定义模式，即返回类型、函数名、参数列表及相邻的左花括号{。注意，返回类型和参数列表可以为空，{可能与函数头同行或位于其后某行。

函数头模式的组合较为复杂。为正确匹配C函数，首先列举疑似函数头的典型语句，作为测试用例：

  1. funcList = [
  2.     ' static unsigned int test(int a, int b) { ',
  3.     'INT32U* test (int *a, char b[]/*names*/) ', ' void test()',
  4.     '#define MACRO(m) {m=5;}',
  5.     'while(bFlag) {',  ' else if(a!=1||!b)',
  6.     'if(IsTimeOut()){', ' else if(bFlag)',
  7.     'static void test(void);'
  8. ]

然后，构造恰当的正则表达式，以匹配funcList中的C函数：

  1. import sys, os, re
  2. def ParseFuncHeader():
  3.     regPattern = re.compile(r'''(?P<Ret>[\w\s]+[\w*]+)          #return type
  4.                                 \s+(?P<Func>\w+)                #function name
  5.                                 \s*\((?P<Args>[,/*[\].\s\w]*)\) #args
  6.                                 \s*({?)\s*$''', re.X)
  8.     for i in range(0, len(funcList)):
  9.         regMatch = regPattern.match(funcList[i])
  10.         if regMatch != None:
  11.            print '[%d] %s' %(i, regMatch.groups())
  12.            print '     %s' %regMatch.groupdict()

为简化正则表达式，未区分函数返回类型的限定符(如const, static等)和关键字(如int, INT32U等)。若有需要，可在初步匹配后进一步细化子串的匹配。注意，args项也可使用排除字符集，如排除各种运算符[^<>&|=)]。但C语言运算符繁多，故此处选择匹配函数参数中的合法字符，即逗号、注释符、指针运算符、数组括号、空白和单词字符等。

执行ParseFuncHeader()函数后，运行结果如下：

  1. [0] (' static unsigned int', 'test', 'int a, int b', '{')
  2.      {'Args': 'int a, int b', 'Ret': ' static unsigned int', 'Func': 'test'}
  3. [1] ('INT32U*', 'test', 'int *a, char b[]/*names*/', '')
  4.      {'Args': 'int *a, char b[]/*names*/', 'Ret': 'INT32U*', 'Func': 'test'}
  5. [2] (' void', 'test', '', '')
  6.      {'Args': '', 'Ret': ' void', 'Func': 'test'}
  7. [7] (' else', 'if', 'bFlag', '')
  8.      {'Args': 'bFlag', 'Ret': ' else', 'Func': 'if'}

可见，除正确识别合法的函数头外，还误将else if(bFlag)识别为函数头。要排除这种组合，可修改上述正则表达式，或在匹配后检查Func分组是否包含if子串。

2.2 插入跟踪语句

构造出匹配C函数头的正则表达式后，稍加修改即可用于实际工程中函数的匹配。

由于工程中C函数众多，尤其是短小的函数常被频繁调用，因此需控制待处理的函数体规模。亦即，仅对超过特定行数的函数插入跟踪语句。这就要求统计函数行数，思路是从函数头开始，向下查找函数体末尾的}。具体实现如下：

  1. #查找复合语句的一对花括号{}，返回右花括号所在行号
  2. def FindCurlyBracePair(lineList, startLineNo):
  3.     leftBraceNum = 0
  4.     rightBraceNum = 0
  5.     #若未找到对应的花括号，则将起始行的下行作为结束行
  6.     endLineNo = startLineNo + 1
  8.     for i in range(startLineNo, len(lineList)):
  9.         #若找到{，计数
  10.         if lineList[i].find('{') != -1:
  11.             leftBraceNum += 1
  12.         #若找到}，计数。}可能与{位于同一行
  13.         if lineList[i].find('}') != -1:
  14.             rightBraceNum += 1
  15.         #若左右花括号数目相等且不为0，则表明最外层花括号匹配
  16.         if (leftBraceNum == rightBraceNum) and (leftBraceNum != 0):
  17.             endLineNo = i
  18.             break
  20.     return endLineNo

接下来是本文的重头戏，即匹配当前文件中满足行数条件的函数，并为其插入跟踪语句。代码如下：

  1. FUNC_MIN_LINE = 10
  3. totalFileNum = 0; totalFuncNum = 0; procFileNum = 0; procFuncNum = 0;
  4. def AddFuncTrace(dir, file):
  5.     global totalFileNum, totalFuncNum, procFileNum, procFuncNum
  6.     totalFileNum += 1
  8.     filePath = os.path.join(dir, file)
  10.     #识别C文件
  11.     fileExt = os.path.splitext(filePath)
  12.     if fileExt[1] != '.c':
  13.         return
  15.     try:
  16.         fileObj = open(filePath, 'r')
  17.     except IOError:
  18.         print 'Cannot open file (%s) for reading!', filePath
  19.     else:
  20.         lineList = fileObj.readlines()
  22.     procFileNum += 1
  23.     #识别C函数
  24.     lineNo = 0
  25.     while lineNo < len(lineList):
  26.         #若为注释行或不含{，则跳过该行
  27.         if re.match('^.*/(?:/|\*)+.*?(?:/\*)*\s*$', lineList[lineNo]) != None \
  28.             or re.search('{', lineList[lineNo]) == None:
  29.             lineNo = lineNo + 1; continue
  31.         funcStartLine = lineNo
  32.         #默认左圆括号与函数头位于同一行
  33.         while re.search('\(', lineList[funcStartLine]) == None:
  34.             funcStartLine = funcStartLine - 1
  35.             if funcStartLine < 0:
  36.                 lineNo = lineNo + 1; break
  38.         regMatch = re.match(r'''^\s*(\w+\s*[\w*]+)    #return type
  39.                                 \s+(\w+)              #function name
  40.                                 \s*\([,/*[\].\s\w]*   #patial args
  41.                                 \)?[^;]*$''', lineList[funcStartLine], re.X)
  43.         if regMatch == None \
  44.             or 'if' in regMatch.group(2): #排除"else if(bFlag)"之类的伪函数头
  45.             #print 'False[%s(%d)]%s' %(file, funcStartLine+1, lineList[funcStartLine]) #funcStartLine从0开始，加1为真实行号
  46.             lineNo = lineNo + 1; continue
  48.         totalFuncNum += 1
  49.         #print '+[%d] %s' %(funcStartLine+1, lineList[funcStartLine])
  50.         funcName = regMatch.group(2)
  51.         #跳过短于FUNC_MIN_LINE行的函数
  52.         funcEndLine = FindCurlyBracePair(lineList, funcStartLine)
  53.         #print 'func:%s, linenum: %d' %(funcName, funcEndLine - funcStartLine)
  54.         if (funcEndLine - funcStartLine) < FUNC_MIN_LINE:
  55.             lineNo = funcEndLine + 1; continue
  57.         #花括号{与函数头在同一行时，{后通常无语句。否则其后可能有语句
  58.         regMatch = re.match('^(.*){(.*)$', lineList[lineNo])
  59.         lineList[lineNo] = '%s{printf("%s() at %s, %s.\\n"); %s\n' \
  60.                             %(regMatch.group(1), funcName, file, lineNo+1, regMatch.group(2))
  61.         print '-[%d] %s' %(lineNo+1, lineList[lineNo]) ###
  62.         procFuncNum += 1
  63.         lineNo = funcEndLine + 1
  65.     #return
  66.     try:
  67.         fileObj = open(filePath, 'w')
  68.     except IOError:
  69.         print 'Cannot open file (%s) for writing!', filePath
  70.     else:
  71.         fileObj.writelines(lineList)
  72.         fileObj.close()

因为实际工程中函数头模式更加复杂，AddFuncTrace()内匹配函数时所用的正则表达式与ParseFuncHeader()略有不同。正确识别函数头并添加根据语句后，会直接跳至函数体外继续向下处理。但未识别出函数头时，正则表达式可能会错误匹配函数体内"else if(bFlag)"之类的语句，因此需要防护这种情况。

注意，目前添加的跟踪语句形如printf("func() at file.c, line.\n")。读者可根据需要自行定制跟踪语句，如添加打印开关。

因为源代码文件可能以嵌套目录组织，还需遍历目录以访问所有文件：

  1. def ValidateDir(dirPath):
  2.     #判断路径是否存在(不区分大小写)
  3.     if os.path.exists(dirPath) == False:
  4.         print dirPath + ' is non-existent!'
  5.         return ''
  7.     #判断路径是否为目录(不区分大小写)
  8.     if os.path.isdir(dirPath) == False:
  9.         print dirPath + ' is not a directory!'
  10.         return ''
  11.     return dirPath
  13. def WalkDir(dirPath):
  14.     dirPath = ValidateDir(dirPath)
  15.     if not dirPath:
  16.         return
  18.     #遍历路径下的文件及子目录
  19.     for root, dirs, files in os.walk(dirPath):
  20.         for file in files:
  21.             #处理文件
  22.             AddFuncTrace(root, file)
  24.     print '############## %d/%d functions in %d/%d files processed##############' \
  25.           %(procFuncNum, totalFuncNum, procFileNum, totalFileNum)

最后，添加可有可无的命令行及帮助信息：

  1. usage = '''Usage:
  2.   AddFuncTrace(.py) [options] [minFunc] [codePath]
  3.   This program adds trace code to functions in source code.
  4.   Options include:
  5.       --version : show the version number
  6.       --help    : show this help
  7.   Default minFunc is 10, specifying that only functions with
  8.   more than 10 lines will be processed.
  9.   Default codePath is the current working directory.'''
  11. if __name__ == '__main__':
  12.     if len(sys.argv) == 1: #脚本名
  13.         WalkDir(os.getcwd())
  14.         sys.exit()
  15.     if sys.argv[1].startswith('--'):
  16.         option = sys.argv[1][2:]
  17.         if option == 'version':
  18.             print 'Version 1.0 by xywang'
  19.         elif option == 'help':
  20.             print usage
  21.         else:
  22.             print 'Unknown Option.'
  23.         sys.exit()
  25.     if len(sys.argv) >= 3:
  26.         FUNC_MIN_LINE = int(sys.argv[1])
  27.         WalkDir(os.path.abspath(sys.argv[2]))
  28.         sys.exit()
  29.     if len(sys.argv) >= 2:
  30.         FUNC_MIN_LINE = int(sys.argv[1])
  31.         WalkDir(os.getcwd())
  32.         sys.exit()

上述命令行参数解析比较简陋，也可参考《Python实现Linux命令xxd -i功能》一文中的optionparser解析模块。

三. 效果验证

为验证上节的代码实现，建立test调试目录。该目录下包含test.c及两个文本文件。其中，test.c内容如下：

  1. #include <stdio.h>
  2. /* {{{ Local definitions/variables */
  4. unsigned int test0(int a, int b){
  5.     int a0; int b0;}
  7.  unsigned int test1 (int a, int b) {
  8.     int a1; int b1;
  9.     a1 = 1;
  10.     b1 = 2;}
  12.   int test2 (int a, int b)
  13. {
  14.     int a2; int b2;
  15.     a2 = 1;
  16.     b2 = 2;
  17. }
  20. /* {{{ test3 */
  21. int test3(int a,
  22.           int b)
  23. {   int a3 = 1; int b3 = 2;
  24.     if(a3)
  25.     {
  26.         a3 = 0;
  27.     }
  28.     else if(b3) {
  29.         b3 = 0;
  30.     }
  31. }
  32. /* }}} */
  34. static void test4(A *aaa,
  35.        B bbb,
  36.        C ccc[]
  37.        ) {
  38.     int a4; int b4;
  39. }
  41. static void test5(void);
  42. struct T5 {
  43.   int t5;
  44. };

考虑到上述函数较短，故指定函数最短行数为1，运行AddFuncTrace.py：

  1. E:\PyTest>python AddFuncTrace.py 1 test
  2. -[4] unsigned int test0(int a, int b){printf("test0() at test.c, 4.\n");
  4. -[7]  unsigned int test1 (int a, int b) {printf("test1() at test.c, 7.\n"
  6. -[13] {printf("test2() at test.c, 13.\n");
  8. -[23] {printf("test3() at test.c, 23.\n");    int a3 = 1; int b3 = 2;
  10. -[37]        ) {printf("test4() at test.c, 37.\n");
  12. ############## 5/5 functions in 1/3 files processed##############

查看test.c文件内容如下：

  1. #include <stdio.h>
  2. /* {{{ Local definitions/variables */
  4. unsigned int test0(int a, int b){printf("test0() at test.c, 4.\n"); 
  5.     int a0; int b0;}
  7.  unsigned int test1 (int a, int b) {printf("test1() at test.c, 7.\n"); 
  8.     int a1; int b1;
  9.     a1 = 1;
  10.     b1 = 2;}
  12.   int test2 (int a, int b)
  13. {printf("test2() at test.c, 13.\n"); 
  14.     int a2; int b2;
  15.     a2 = 1;
  16.     b2 = 2;
  17. }
  20. /* {{{ test3 */
  21. int test3(int a,
  22.           int b)
  23. {printf("test3() at test.c, 23.\n");    int a3 = 1; int b3 = 2;
  24.     if(a3)
  25.     {
  26.         a3 = 0;
  27.     }
  28.     else if(b3) {
  29.         b3 = 0;
  30.     }
  31. }
  32. /* }}} */
  34. static void test4(A *aaa,
  35.        B bbb,
  36.        C ccc[]
  37.        ) {printf("test4() at test.c, 37.\n"); 
  38.     int a4; int b4;
  39. }
  41. static void test5(void);
  42. struct T5 {
  43.   int t5;
  44. };

可见，跟踪语句的插入完全符合期望。

接着，在实际工程中运行python AddFuncTrace.py 50，截取部分运行输出如下：

  1. -[1619] {printf("bcmGetQuietCrossTalk() at bcm_api.c, 1619.\n"); 
  3. -[1244] {printf("afeAddressExist() at bcm_hmiLineMsg.c, 1244.\n"); 
  5. -[1300] {printf("afeAddressMask() at bcm_hmiLineMsg.c, 1300.\n"); 
  7. -[479] uint32 stpApiCall(uint8 *payload, uint32 payloadSize, uint32 *size) {printf("stpApiCall() at bcm_stpApi.c, 479.\n"); 
  9. ############## 291/1387 functions in 99/102 files processed##############

查看处理后的C函数，插入效果也符合期望。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注