cpp.py 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301
  1. #
  2. # Metrix++, Copyright 2009-2013, Metrix++ Project
  3. # Link: http://metrixplusplus.sourceforge.net
  4. #
  5. # This file is a part of Metrix++ Tool.
  6. #
  7. # Metrix++ is free software: you can redistribute it and/or modify
  8. # it under the terms of the GNU General Public License as published by
  9. # the Free Software Foundation, version 3 of the License.
  10. #
  11. # Metrix++ is distributed in the hope that it will be useful,
  12. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. # GNU General Public License for more details.
  15. #
  16. # You should have received a copy of the GNU General Public License
  17. # along with Metrix++. If not, see <http://www.gnu.org/licenses/>.
  18. #
  19. import re
  20. import binascii
  21. import logging
  22. import core.api
  23. class Plugin(core.api.Plugin, core.api.Parent, core.api.IParser, core.api.IConfigurable, core.api.ICode):
  24. def declare_configuration(self, parser):
  25. parser.add_option("--std.code.cpp.files", default="*.c,*.h,*.cpp,*.hpp,*.cc,*.hh,*.cxx,*.hxx",
  26. help="Enumerates filename extensions to match C/C++ files [default: %default]")
  27. def configure(self, options):
  28. self.files = options.__dict__['std.code.cpp.files'].split(',')
  29. self.files.sort() # sorted list goes to properties
  30. def initialize(self):
  31. self.get_plugin_loader().register_parser(self.files, self)
  32. # trigger version property set
  33. core.api.Plugin.initialize(self)
  34. db_loader = self.get_plugin_loader().get_database_loader()
  35. prev_ext = db_loader.set_property(self.get_name() + ":files", ','.join(self.files))
  36. if prev_ext != ','.join(self.files):
  37. self.is_updated = True
  38. def process(self, parent, data, is_updated):
  39. is_updated = is_updated or self.is_updated
  40. count_mismatched_brackets = 0
  41. if is_updated == True:
  42. count_mismatched_brackets = CppCodeParser().run(data)
  43. self.notify_children(data, is_updated)
  44. return count_mismatched_brackets
  45. class CppCodeParser(object):
  46. regex_cpp = re.compile(r'''
  47. /([\\](?:\n|\r|\r\n))*/(?=\n|\r|\r\n) # Match C++ style comments (empty comment line)
  48. | /([\\](?:\n|\r|\r\n))*/.*?[^\\](?=\n|\r|\r\n) # Match C++ style comments
  49. # NOTE: end of line is NOT consumed
  50. # NOTE: ([\\](?:\n|\r|\r\n))* for new line separators,
  51. # Need to support new line separators in expense of efficiency?
  52. | /([\\](?:\n|\r|\r\n))*\*.*?\*([\\](?:\n|\r|\r\n))*/ # Match C style comments
  53. | \'(?:\\.|[^\\\'])*\' # Match quoted strings
  54. | "(?:\\.|[^\\"])*" # Match double quoted strings
  55. | (((?<=\n|\r)|^)[ \t]*[#].*?[^\\](?=\n|\r|\r\n)) # Match preprocessor
  56. # NOTE: end of line is NOT consumed
  57. # NOTE: beginning of line is NOT consumed
  58. | (?P<fn_name>
  59. (operator( # Match C++ operator ...
  60. (\s+[_a-zA-Z][_a-zA-Z0-9]*(\s*\[\s*\])?) # - cast, new and delete operators
  61. | (\s*\[\s*\]) # - operator []
  62. | (\s*\(\s*\)) # - operator ()
  63. | (\s*[+-\\*/=<>!%&^|~,?.]{1,3}) # - other operators (from 1 to 3 symbols)
  64. ))
  65. | ([~]?[_a-zA-Z][_a-zA-Z0-9]*) # ... or function or constructor
  66. )\s*[(] # LIMITATION: if there are comments after function name
  67. # and before '(', it is not detected
  68. # LIMITATION: if there are comments within operator definition,
  69. # if may be not detected
  70. | ((?P<block_type>class|struct|namespace) # Match C++ class or struct
  71. (?P<block_name>((\s+[a-zA-Z_][a-zA-Z0-9_]*)|(?=\s*[{])))) # noname is supported, symbol '{' is not consumed
  72. # LIMITATION: if there are comments between keyword and name,
  73. # it is not detected
  74. | [<>{};:] # Match block start/end, brackets and statement separator
  75. | ((?:\n|\r|\r\n)\s*(?:\n|\r|\r\n)) # Match double empty line
  76. ''',
  77. re.DOTALL | re.MULTILINE | re.VERBOSE
  78. )
  79. regex_ln = re.compile(r'(\n)|(\r)|(\r\n)')
  80. def run(self, data):
  81. self.__init__() # Go to initial state if it is called twice
  82. return self.parse(data)
  83. def finalize_block(self, text, block, block_end):
  84. space_match = re.match('^\s*', text[block['start']:block_end], re.MULTILINE)
  85. block['start'] += space_match.end() # trim spaces at the beginning
  86. block['end'] = block_end
  87. start_pos = block['start']
  88. crc32 = 0
  89. for child in block['children']:
  90. # exclude children
  91. crc32 = binascii.crc32(text[start_pos:child['start']], crc32)
  92. start_pos = child['end']
  93. block['checksum'] = binascii.crc32(text[start_pos:block['end']], crc32) & 0xffffffff # to match python 3
  94. def add_lines_data(self, text, blocks):
  95. def add_lines_data_rec(self, text, blocks):
  96. for each in blocks:
  97. # add line begin
  98. self.total_current += len(self.regex_ln.findall(text, self.total_last_pos, each['start']))
  99. each['line_begin'] = self.total_current
  100. self.total_last_pos = each['start']
  101. # process enclosed
  102. add_lines_data_rec(self, text, each['children'])
  103. # add line end
  104. self.total_current += len(self.regex_ln.findall(text, self.total_last_pos, each['end']))
  105. each['line_end'] = self.total_current
  106. self.total_last_pos = each['end']
  107. self.total_last_pos = 0
  108. self.total_current = 1
  109. add_lines_data_rec(self, text, blocks)
  110. def add_regions(self, data, blocks):
  111. # Note: data.add_region() internals depend on special ordering of regions
  112. # in order to identify enclosed regions efficiently
  113. def add_regions_rec(self, data, blocks):
  114. def get_type_id(data, named_type):
  115. if named_type == "function":
  116. return data.get_region_types().FUNCTION
  117. elif named_type == "class":
  118. return data.get_region_types().CLASS
  119. elif named_type == "struct":
  120. return data.get_region_types().STRUCT
  121. elif named_type == "namespace":
  122. return data.get_region_types().NAMESPACE
  123. elif named_type == "__global__":
  124. return data.get_region_types().GLOBAL
  125. else:
  126. assert(False)
  127. for each in blocks:
  128. data.add_region(each['name'], each['start'], each['end'],
  129. each['line_begin'], each['line_end'], each['cursor'],
  130. get_type_id(data, each['type']), each['checksum'])
  131. add_regions_rec(self, data, each['children'])
  132. add_regions_rec(self, data, blocks)
  133. def parse(self, data):
  134. def reset_next_block(start):
  135. return {'name':'', 'start':start, 'cursor':0, 'type':'', 'confirmed':False}
  136. count_mismatched_brackets = 0
  137. text = data.get_content()
  138. indent_current = 0;
  139. blocks = [{'name':'__global__', 'start':0, 'cursor':0, 'type':'__global__', 'indent_start':indent_current, 'children':[]}]
  140. curblk = 0
  141. next_block = reset_next_block(0)
  142. cursor_last_pos = 0
  143. cursor_current = 1
  144. for m in re.finditer(self.regex_cpp, text):
  145. # Comment
  146. if text[m.start()] == '/':
  147. data.add_marker(m.start(), m.end(), data.get_marker_types().COMMENT)
  148. if text[m.start():m.end()].startswith("//\n"):
  149. print text[m.start():m.end()]
  150. # String
  151. elif text[m.start()] == '"' or text[m.start()] == '\'':
  152. data.add_marker(m.start() + 1, m.end() - 1, data.get_marker_types().STRING)
  153. # Preprocessor (including internal comments)
  154. elif text[m.start()] == ' ' or text[m.start()] == '\t' or text[m.start()] == '#':
  155. data.add_marker(m.start(), m.end(), data.get_marker_types().PREPROCESSOR)
  156. # Statement end
  157. elif text[m.start()] == ';':
  158. # Reset next block name and start
  159. next_block['name'] = ""
  160. next_block['start'] = m.end() # potential region start
  161. # Template argument closing bracket
  162. elif text[m.start()] == '>':
  163. # Reset next block name and start (in order to skip class names in templates), if has not been confirmed before
  164. if next_block['confirmed'] == False and (next_block['type'] == 'class' or next_block['type'] == 'struct'):
  165. next_block['name'] = ""
  166. next_block['start'] = m.end() # potential region start
  167. # Template argument opening bracket or after class inheritance specification
  168. elif text[m.start()] == ':' or text[m.start()] == '<':
  169. # .. if goes after calss definition
  170. if next_block['type'] == 'class' or next_block['type'] == 'struct':
  171. next_block['confirmed'] = True
  172. # Double end line
  173. elif text[m.start()] == '\n' or text[m.start()] == '\r':
  174. # Reset next block start, if has not been named yet
  175. if next_block['name'] == "":
  176. next_block['start'] = m.end() # potential region start
  177. # Block start...
  178. elif text[m.start()] == '{':
  179. # shift indent right
  180. indent_current += 1
  181. # ... if name detected previously
  182. if next_block['name'] != '': # - Start of enclosed block
  183. blocks.append({'name':next_block['name'],
  184. 'start':next_block['start'],
  185. 'cursor':next_block['cursor'],
  186. 'type':next_block['type'],
  187. 'indent_start':indent_current,
  188. 'children':[]})
  189. next_block = reset_next_block(m.end())
  190. curblk += 1
  191. # ... reset next block start, otherwise
  192. else: # - unknown type of block start
  193. next_block['start'] = m.end() # potential region start
  194. # Block end...
  195. elif text[m.start()] == '}':
  196. # ... if indent level matches the start
  197. if blocks[curblk]['indent_start'] == indent_current:
  198. next_block = reset_next_block(m.end())
  199. if curblk == 0:
  200. logging.warning("Non-matching closing bracket '}' detected: " + data.get_path() + ":" +
  201. str(cursor_current + len(self.regex_ln.findall(text, cursor_last_pos, m.start()))))
  202. count_mismatched_brackets += 1
  203. continue
  204. self.finalize_block(text, blocks[curblk], m.end())
  205. assert(blocks[curblk]['type'] != '__global__')
  206. curblk -= 1
  207. assert(curblk >= 0)
  208. blocks[curblk]['children'].append(blocks.pop())
  209. # shift indent left
  210. indent_current -= 1
  211. if indent_current < 0:
  212. logging.warning("Non-matching closing bracket '}' detected")
  213. count_mismatched_brackets += 1
  214. indent_current = 0
  215. # Potential namespace, struct, class
  216. elif text[m.start():m.end()].startswith(('class','struct','namespace')) == True \
  217. and m.group('fn_name') == None: # function name can start with keyword, for example class_id_type()
  218. if next_block['name'] == "":
  219. # - 'name'
  220. next_block['name'] = m.group('block_name').strip()
  221. if next_block['name'] == "":
  222. next_block['name'] = '__noname__'
  223. # - 'cursor'
  224. cursor_current += len(self.regex_ln.findall(text, cursor_last_pos, m.start('block_name')))
  225. cursor_last_pos = m.start('block_name')
  226. next_block['cursor'] = cursor_current
  227. # - 'type'
  228. next_block['type'] = m.group('block_type').strip()
  229. # - 'start' detected earlier
  230. # Potential function name detected...
  231. else:
  232. # ... if outside of a function (do not detect enclosed functions, unless classes are matched)
  233. if blocks[curblk]['type'] != 'function' and (next_block['name'] == "" or next_block['type'] != 'function'):
  234. # - 'name'
  235. next_block['name'] = m.group('fn_name').strip()
  236. # - 'cursor'
  237. cursor_current += len(self.regex_ln.findall(text, cursor_last_pos, m.start('fn_name')))
  238. cursor_last_pos = m.start('fn_name')
  239. # NOTE: cursor could be collected together with line_begin, line_end,
  240. # but we keep it here separately for easier debugging of file parsing problems
  241. next_block['cursor'] = cursor_current
  242. # - 'type'
  243. next_block['type'] = 'function'
  244. # - 'start' detected earlier
  245. while indent_current > 0:
  246. # log all
  247. logging.warning("Non-matching opening bracket '{' detected")
  248. count_mismatched_brackets += 1
  249. indent_current -= 1
  250. for (ind, each) in enumerate(blocks):
  251. each = each # used
  252. block = blocks[len(blocks) - 1 - ind]
  253. self.finalize_block(text, block, len(text))
  254. self.add_lines_data(text, blocks)
  255. self.add_regions(data, blocks)
  256. return count_mismatched_brackets