| #!/usr/bin/env python |
| # |
| # Copyright 2008 Google Inc. All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """Generate Google Mock classes from base classes. |
| |
| This program will read in a C++ source file and output the Google Mock |
| classes for the specified classes. If no class is specified, all |
| classes in the source file are emitted. |
| |
| Usage: |
| gmock_class.py header-file.h [ClassName]... |
| |
| Output is sent to stdout. |
| """ |
| |
| __author__ = 'nnorwitz@google.com (Neal Norwitz)' |
| |
| |
| import os |
| import re |
| import sys |
| |
| from cpp import ast |
| from cpp import utils |
| |
| # Preserve compatibility with Python 2.3. |
| try: |
| _dummy = set |
| except NameError: |
| import sets |
| set = sets.Set |
| |
| _VERSION = (1, 0, 1) # The version of this script. |
| # How many spaces to indent. Can set me with the INDENT environment variable. |
| _INDENT = 2 |
| |
| |
| def _GenerateMethods(output_lines, source, class_node): |
| function_type = (ast.FUNCTION_VIRTUAL | ast.FUNCTION_PURE_VIRTUAL | |
| ast.FUNCTION_OVERRIDE) |
| ctor_or_dtor = ast.FUNCTION_CTOR | ast.FUNCTION_DTOR |
| indent = ' ' * _INDENT |
| |
| for node in class_node.body: |
| # We only care about virtual functions. |
| if (isinstance(node, ast.Function) and |
| node.modifiers & function_type and |
| not node.modifiers & ctor_or_dtor): |
| # Pick out all the elements we need from the original function. |
| const = '' |
| if node.modifiers & ast.FUNCTION_CONST: |
| const = 'CONST_' |
| return_type = 'void' |
| if node.return_type: |
| # Add modifiers like 'const'. |
| modifiers = '' |
| if node.return_type.modifiers: |
| modifiers = ' '.join(node.return_type.modifiers) + ' ' |
| return_type = modifiers + node.return_type.name |
| template_args = [arg.name for arg in node.return_type.templated_types] |
| if template_args: |
| return_type += '<' + ', '.join(template_args) + '>' |
| if len(template_args) > 1: |
| for line in [ |
| '// The following line won\'t really compile, as the return', |
| '// type has multiple template arguments. To fix it, use a', |
| '// typedef for the return type.']: |
| output_lines.append(indent + line) |
| if node.return_type.pointer: |
| return_type += '*' |
| if node.return_type.reference: |
| return_type += '&' |
| num_parameters = len(node.parameters) |
| if len(node.parameters) == 1: |
| first_param = node.parameters[0] |
| if source[first_param.start:first_param.end].strip() == 'void': |
| # We must treat T(void) as a function with no parameters. |
| num_parameters = 0 |
| tmpl = '' |
| if class_node.templated_types: |
| tmpl = '_T' |
| mock_method_macro = 'MOCK_%sMETHOD%d%s' % (const, num_parameters, tmpl) |
| |
| args = '' |
| if node.parameters: |
| # Due to the parser limitations, it is impossible to keep comments |
| # while stripping the default parameters. When defaults are |
| # present, we choose to strip them and comments (and produce |
| # compilable code). |
| # TODO(nnorwitz@google.com): Investigate whether it is possible to |
| # preserve parameter name when reconstructing parameter text from |
| # the AST. |
| if len([param for param in node.parameters if param.default]) > 0: |
| args = ', '.join(param.type.name for param in node.parameters) |
| else: |
| # Get the full text of the parameters from the start |
| # of the first parameter to the end of the last parameter. |
| start = node.parameters[0].start |
| end = node.parameters[-1].end |
| # Remove // comments. |
| args_strings = re.sub(r'//.*', '', source[start:end]) |
| # Condense multiple spaces and eliminate newlines putting the |
| # parameters together on a single line. Ensure there is a |
| # space in an argument which is split by a newline without |
| # intervening whitespace, e.g.: int\nBar |
| args = re.sub(' +', ' ', args_strings.replace('\n', ' ')) |
| |
| # Create the mock method definition. |
| output_lines.extend(['%s%s(%s,' % (indent, mock_method_macro, node.name), |
| '%s%s(%s));' % (indent*3, return_type, args)]) |
| |
| |
| def _GenerateMocks(filename, source, ast_list, desired_class_names): |
| processed_class_names = set() |
| lines = [] |
| for node in ast_list: |
| if (isinstance(node, ast.Class) and node.body and |
| # desired_class_names being None means that all classes are selected. |
| (not desired_class_names or node.name in desired_class_names)): |
| class_name = node.name |
| parent_name = class_name |
| processed_class_names.add(class_name) |
| class_node = node |
| # Add namespace before the class. |
| if class_node.namespace: |
| lines.extend(['namespace %s {' % n for n in class_node.namespace]) # } |
| lines.append('') |
| |
| # Add template args for templated classes. |
| if class_node.templated_types: |
| # TODO(paulchang): The AST doesn't preserve template argument order, |
| # so we have to make up names here. |
| # TODO(paulchang): Handle non-type template arguments (e.g. |
| # template<typename T, int N>). |
| template_arg_count = len(class_node.templated_types.keys()) |
| template_args = ['T%d' % n for n in range(template_arg_count)] |
| template_decls = ['typename ' + arg for arg in template_args] |
| lines.append('template <' + ', '.join(template_decls) + '>') |
| parent_name += '<' + ', '.join(template_args) + '>' |
| |
| # Add the class prolog. |
| lines.append('class Mock%s : public %s {' # } |
| % (class_name, parent_name)) |
| lines.append('%spublic:' % (' ' * (_INDENT // 2))) |
| |
| # Add all the methods. |
| _GenerateMethods(lines, source, class_node) |
| |
| # Close the class. |
| if lines: |
| # If there are no virtual methods, no need for a public label. |
| if len(lines) == 2: |
| del lines[-1] |
| |
| # Only close the class if there really is a class. |
| lines.append('};') |
| lines.append('') # Add an extra newline. |
| |
| # Close the namespace. |
| if class_node.namespace: |
| for i in range(len(class_node.namespace)-1, -1, -1): |
| lines.append('} // namespace %s' % class_node.namespace[i]) |
| lines.append('') # Add an extra newline. |
| |
| if desired_class_names: |
| missing_class_name_list = list(desired_class_names - processed_class_names) |
| if missing_class_name_list: |
| missing_class_name_list.sort() |
| sys.stderr.write('Class(es) not found in %s: %s\n' % |
| (filename, ', '.join(missing_class_name_list))) |
| elif not processed_class_names: |
| sys.stderr.write('No class found in %s\n' % filename) |
| |
| return lines |
| |
| |
| def main(argv=sys.argv): |
| if len(argv) < 2: |
| sys.stderr.write('Google Mock Class Generator v%s\n\n' % |
| '.'.join(map(str, _VERSION))) |
| sys.stderr.write(__doc__) |
| return 1 |
| |
| global _INDENT |
| try: |
| _INDENT = int(os.environ['INDENT']) |
| except KeyError: |
| pass |
| except: |
| sys.stderr.write('Unable to use indent of %s\n' % os.environ.get('INDENT')) |
| |
| filename = argv[1] |
| desired_class_names = None # None means all classes in the source file. |
| if len(argv) >= 3: |
| desired_class_names = set(argv[2:]) |
| source = utils.ReadFile(filename) |
| if source is None: |
| return 1 |
| |
| builder = ast.BuilderFromSource(source, filename) |
| try: |
| entire_ast = filter(None, builder.Generate()) |
| except KeyboardInterrupt: |
| return |
| except: |
| # An error message was already printed since we couldn't parse. |
| sys.exit(1) |
| else: |
| lines = _GenerateMocks(filename, source, entire_ast, desired_class_names) |
| sys.stdout.write('\n'.join(lines)) |
| |
| |
| if __name__ == '__main__': |
| main(sys.argv) |
