Subversion Repositories s80186

#!/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)