请教python分析groovy代码文件的写法

GhostFromHeaven

回复 1# abcfy2
那个文件讲的太复杂，没看懂，我写了一个简单的，处理一个文件，加个循环就可以处理多个文件了。

我做了一些假设，如果对你的情况不适合，可以增加些复杂的条件。

1. #-*- coding:utf-8 -*-=
   
2. import re
   
3. import string
   
4. pattern_func_def = re.compile('''\s*def\s+.*?\s+\{\s*''')
   
5. pattern_save = re.compile('''\.save\s*\(.*?\)''')
   
6. pattern_left_brace = re.compile('''.*?\{.*?''')
   
7. pattern_right_brace = re.compile('''.*?\}.*?''')
   
8. 
   
9. STATE_UNDEFINED = -1
   
10. STATE_OPEN = 0
    
11. STATE_CLOSED = 1
    
12. 
    
13. brace_count = 0
    
14. got_function_definition = False
    
15. state = STATE_UNDEFINED #-1:Undefined, 0:Open, 1:Closed
    
16. got_full_function = False
    
17. save_count_in_1_function = 0
    
18. 
    
19. if __name__ == "__main__":
    
20.     filename = "to_parse.groovy"
    
21.     line_index = 0
    
22.     with open(filename, "r") as fin:
    
23.         for line in fin:
    
24.             line = line.strip('\n')
    
25.             line_index += 1
    
26.             # 假设  def xxx = {在同一行
    
27.             if state != STATE_OPEN  and pattern_func_def.search(line):
    
28.                 state = STATE_OPEN
    
29.                
    
30.             # 假设每行最多一个{
    
31.             if state == STATE_OPEN and pattern_left_brace.search(line):
    
32.                 brace_count -= 1
    
33.             
    
34.             # 假设每行最多一个}
    
35.             if state == STATE_OPEN and pattern_right_brace.search(line):
    
36.                 brace_count += 1
    
37.             
    
38.             # 假设每行最多一个.save()
    
39.             if state == STATE_OPEN and pattern_save.search(line):
    
40.                 save_count_in_1_function += 1
    
41.                 # 如果有多个save，则打印出来
    
42.                 if save_count_in_1_function > 1:
    
43.                     print "%04d:%s" %(line_index, line)
    
44.             
    
45.             # 函数定义结束
    
46.             if brace_count == 0:
    
47.                 state = STATE_CLOSED
    
48.                 save_count_in_1_function = 0
    

复制代码

样例文件

1. 1
   
2. 2
   
3. def fuction = {
   
4.     dosomething
   
5.     something.save(xyz)
   
6.     something.save(123)
   
7. }abc
   
8. 3
   
9. 4
   
10. 
    
11. def fuction = {
    
12.     dosomething
    
13.     something.save(abc)
    
14.     something.save(def)
    
15. }abc
    

复制代码

   

GhostFromHeaven

回复 4# abcfy2


    要想解决嵌套的问题也很简单

1. #-*- coding:utf-8 -*-=
   
2. import re
   
3. import string
   
4. pattern_func_def = re.compile('''\s*def\s+.*?\s+\{\s*''')
   
5. pattern_save = re.compile('''\.save\s*\(.*?\)''')
   
6. pattern_left_brace = re.compile('''.*?\{.*?''')
   
7. pattern_right_brace = re.compile('''.*?\}.*?''')
   
8. 
   
9. STATE_UNDEFINED = -1
   
10. STATE_OPEN = 0
    
11. STATE_CLOSED = 1
    
12. state = STATE_UNDEFINED #-1:Undefined, 0:Open, 1:Closed
    
13. 
    
14. def parse_groovy(fin, state, brace_count, line_index):
    
15.     is_inner_function = False
    
16.     if brace_count == -1 and state == STATE_OPEN:
    
17.         is_inner_function = True
    
18.     save_count_in_1_function = 0
    
19.     while True:
    
20.         line = fin.readline()
    
21.         if not line:
    
22.             return line_index
    
23.         line = line.strip('\n')
    
24.         line_index += 1
    
25.         #print "%d:%s" %(line_index, line)
    
26.         # 假设  def xxx = {在同一行
    
27.         if pattern_func_def.search(line):
    
28.             if state == STATE_OPEN:
    
29.                line_index = parse_groovy(fin, state, -1, line_index)
    
30.             state = STATE_OPEN
    
31.             
    
32.         # 假设每行最多一个{
    
33.         if state == STATE_OPEN and pattern_left_brace.search(line):
    
34.             brace_count -= 1
    
35.         
    
36.         # 假设每行最多一个}
    
37.         if state == STATE_OPEN and pattern_right_brace.search(line):
    
38.             brace_count += 1
    
39.         
    
40.         # 假设每行最多一个.save()
    
41.         if state == STATE_OPEN and pattern_save.search(line):
    
42.             save_count_in_1_function += 1
    
43.             # 如果有多个save，则打印出来
    
44.             if save_count_in_1_function > 1:
    
45.                 print "%04d:%s" %(line_index, line)
    
46.         
    
47.         # 函数定义结束
    
48.         if state == STATE_OPEN and brace_count == 0:
    
49.             state = STATE_CLOSED
    
50.             save_count_in_1_function = 0
    
51.             if is_inner_function:
    
52.                 return line_index
    
53.             
    
54. if __name__ == "__main__":
    
55.     filename = "to_parse.groovy"
    
56.     line_index = 0
    
57.     with open(filename, "r") as fin:
    
58.         parse_groovy(fin, state, 0, 0)
    

复制代码

1. 1
   
2. 2
   
3. def fuction = {
   
4.     dosomething
   
5.     something.save(xyz)
   
6.     something.save(123)
   
7.     def fuction1 = {
   
8.         dosomething
   
9.         something.save(abc1)
   
10.         something.save(def2)
    
11.         def fuction2 = {
    
12.             dosomething
    
13.             something.save(abc1)
    
14.             something.save(def2)
    
15.         }
    
16.         something.save(def2)
    
17.     }
    
18.     def fuction4 = {
    
19.         dosomething
    
20.         something.save(abc1)
    
21.         something.save(def2)
    
22.     }
    
23.     something.save(defx)
    
24. }abc
    
25. 3
    
26. 4
    
27. 
    
28. def fuction = {
    
29.     dosomething
    
30.     something.save(abc)
    
31.     something.save(def)
    
32. }abc
    
33. 
    
34. 
    
35. 
    

复制代码

样例文件内容

GhostFromHeaven

回复 7# abcfy2

这里匹配不到是因为直接用的save，不是xx.save

修改一个正则表达式即可：pattern_save = re.compile('''[\.\s]+save\s*\(.*?\)''')
   

GhostFromHeaven

回复 9# abcfy2

如果方便的话，可以把你的需求文档或说明发给我（GhostFromHeaven@163.com），好一次做对，在论坛里交流比较慢。

   

GhostFromHeaven

回复 9# abcfy2

switch不同case里的save不会被重复计数，但会把switch各分支中最多的save数加到函数里面。

打印格式为：文件名:行号:内容

可以处理多个文件。

1. #-*- coding:utf-8 -*-
   
2. import os
   
3. import re
   
4. import string
   
5. 
   
6. pattern_func_def = re.compile('''(?<!\S)def\s+.*?\s+\{\s*''')
   
7. pattern_save = re.compile('''\.save\s*\(.*?\)''')
   
8. 
   
9. pattern_switch = re.compile('''(?<!\S)switch\s*\(.*?\)\s*{''')
   
10. pattern_case = re.compile('''(?<!\S)(case\s+\S+)|(default)\s*:''')
    
11. pattern_break = re.compile('''(?<!\S)break(?!\S)''')
    
12. 
    
13. pattern_left_brace = re.compile('''.*?\{.*?''')
    
14. pattern_right_brace = re.compile('''.*?\}.*?''')
    
15. 
    
16. class GroovyParser(object):
    
17.     def __init__(self):
    
18.         self.current_file_name = ""
    
19.         self.current_file_handler = None
    
20.         self.current_line = ""
    
21.         self.current_line_index = 0
    
22.         
    
23.     def _get_line(self):
    
24.         for self.current_line in open(self.current_file_name, "r"):
    
25.             self.current_line_index += 1
    
26.             self.current_line = self.current_line.strip('\n')
    
27.             yield "%s" % self.current_line
    
28.    
    
29.     def print_line(self):
    
30.         print "%10s:%04d:%s" % (os.path.basename(self.current_file_name),
    
31.                                 self.current_line_index,
    
32.                                 self.current_line)
    
33.    
    
34.     # 处理{}
    
35.     def _handle_brace(self, line):
    
36.         # 假设每行最多一个{
    
37.         _brace_count = 0
    
38.         if pattern_left_brace.search(line):
    
39.             _brace_count -= 1
    
40. 
    
41.         # 假设每行最多一个}
    
42.         if pattern_right_brace.search(line):
    
43.             _brace_count += 1
    
44.         return _brace_count
    
45.    
    
46.     # 处理xx.save(yy)
    
47.     def _handle_save(self, line, save_count):
    
48.         _save_count_in_1_function = save_count
    
49.         # 假设每行最多一个.save()
    
50.         if pattern_save.search(line):
    
51.             _save_count_in_1_function += 1
    
52.             # 如果有多个save，则打印出来
    
53.             if _save_count_in_1_function > 1:
    
54.                 self.print_line()
    
55.             return 1
    
56.         return 0
    
57.         
    
58.     def parse_func_def(self):
    
59.         _brace_count = -1
    
60.         _save_count_in_1_function = 0
    
61.         for line in self.line_reader:
    
62.             #line = self.get_line()
    
63.             if not line:
    
64.                 break
    
65. 
    
66.             # function
    
67.             if pattern_func_def.search(line):
    
68.                 self.parse_func_def()
    
69.             
    
70.             # switch
    
71.             if pattern_switch.search(line):
    
72.                _save_count_in_1_function = self.parse_switch_def(_save_count_in_1_function)
    
73.             
    
74.             # {}
    
75.             _brace_count += self._handle_brace(line)
    
76.             
    
77.             # xx.save(yy)
    
78.             _save_count_in_1_function += self._handle_save(line, _save_count_in_1_function)
    
79.             
    
80.             # 函数定义结束
    
81.             if _brace_count == 0:
    
82.                 return
    
83. 
    
84.     def parse_switch_def(self, save_count):
    
85.         _brace_count = -1
    
86.         _save_count_in_1_function = save_count
    
87.         _max_save_count = save_count
    
88.         _all_save_count = save_count
    
89.         for line in self.line_reader:
    
90.             if not line:
    
91.                 break
    
92.             # switch
    
93.             if pattern_switch.search(line):
    
94.                 _all_save_count = self.parse_switch_def(_save_count_in_1_function)
    
95.             
    
96.             if pattern_case.search(line):
    
97.                 _get_brace_count, _all_save_count = self.parse_case_def(_save_count_in_1_function)
    
98.                 _brace_count += _get_brace_count
    
99.             
    
100.             if _max_save_count < _all_save_count:
     
101.                _max_save_count = _all_save_count
     
102.             
     
103.             # {}
     
104.             _brace_count += self._handle_brace(line)
     
105.             
     
106.             # xx.save(yy)
     
107.             #_save_count_in_1_function += self._handle_save(line, _save_count_in_1_function)
     
108.             # 定义结束
     
109.             if _brace_count == 0:
     
110.                 break
     
111.         return _max_save_count
     
112.    
     
113.     def parse_case_def(self, save_count):
     
114.         _brace_count = 0
     
115.         _save_count_in_1_function = save_count
     
116.         for line in self.line_reader:
     
117.             if not line:
     
118.                 break
     
119.             
     
120.             # xx.save(yy)
     
121.             _save_count_in_1_function += self._handle_save(line, _save_count_in_1_function)
     
122.             
     
123.             # break
     
124.             if pattern_break.search(line):
     
125.                 break
     
126. 
     
127.             # {}
     
128.             _brace_count = self._handle_brace(line)
     
129.             if _brace_count == -1:
     
130.                 break
     
131.         return (_brace_count, _save_count_in_1_function)
     
132. 
     
133.     def parse(self, file_list):
     
134.         for self.current_file_name in file_list:
     
135.             self.line_reader = self._get_line()
     
136.             self.current_line_index = 0
     
137.             for line in self.line_reader:
     
138.                 if not line:
     
139.                     break
     
140.                 if pattern_func_def.search(line):
     
141.                     self.parse_func_def()
     
142.         
     
143. if __name__ == "__main__":
     
144.     file_list = [r'C:\Users\fgl\Desktop\test\to_parse_2.groovy']#, 'to_parse_1.groovy']
     
145.     gp = GroovyParser()
     
146.     gp.parse(file_list)
     
147. 
     
148.         
     
149.         
     

复制代码

to_parse_2.zip (534 Bytes, 下载次数: 1)

2013-05-24 22:45 上传

点击文件名下载附件

   

GhostFromHeaven

回复 12# abcfy2
1、switch的问题已经解决了，昨天就猜到if应该也要处理。你可以用最新的脚本试试。

2、你的意思是如果是if(xx.save && yy.save())这样的save都不算进去吗？

3、if (xx) {
          xx.save(yyy)
   } else {
         zzz.save(aaa)
   }

这样的怎么计算？
   

GhostFromHeaven

回复 14# abcfy2
1、已经可以判断一行有多个save，多个{}

2、if的问题的解决了。
    思路是如果找到save(m个)就判断是否是if语句，如果是if语句就搜索.save()(n个)，如果m>n就找到新的需要计数的save，否则不算。

1. def fuction4 = {
   
2.     dosomething
   
3.     something.save(abc1).save(dxy)
   
4.     something.save(def2)
   
5.     if (xx.save() && yy.save())
   
6.     {
   
7.         xxa.save()
   
8.     }
   
9.    
   
10.     if(xx.save() && yy.save())
    
11.     {
    
12.         xxa.save()
    
13.     }
    
14.    
    
15.     if(xx.save(xx) && yy.save())
    
16.     {
    
17.         xxa.save()
    
18.     }
    
19.    
    
20.     if(xx.save(xx) && yy.save(yy))
    
21.     {
    
22.         xxa.save()
    
23.     }
    
24. }
    

复制代码

parse_groovy.zip (22.12 KB, 下载次数: 4)

2013-05-26 17:29 上传

点击文件名下载附件

   

GhostFromHeaven

回复 17# abcfy2

1、函数定义的模式匹配要修改一下，\s+要求函数名和{直接必须有空白字符，改成：
pattern_func_def = re.compile('''(?<!\S)def\s+.*?\s*\{\s*''')
或
pattern_func_def = re.compile('''(?<!\S)def\s+.*?\{\s*''')


2、还有下面这样的语句都删掉：

                if not line:
                    break

GhostFromHeaven

回复 19# abcfy2

我试了下，没有扫出来。你再确认下。
   

GhostFromHeaven

回复 21# abcfy2

1、
pattern_save = re.compile('''\.save\s*\(.*?\)|\.delete\s*\(.*?\)''')  #同时筛选save方法和delete方法

这句有问题，这样的话save和delete的数量就加在一起了。

前面有：rod.delete()，这个计算变为1了，后面的save自然就变为2，就会筛选出来。所以不能加delete。

2、
要想处理用同样的办法处理delete可以再增加处理函数。