#!/usr/bin/python

# -*- coding: utf-8 -*-

#

# Copyright (C) 2009 Google Inc. All rights reserved.

# Copyright (C) 2009 Torch Mobile Inc.

# Copyright (C) 2009 Apple Inc. All rights reserved.

# Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org)

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions are

# met:

#

#    * Redistributions of source code must retain the above copyright

# notice, this list of conditions and the following disclaimer.

#    * Redistributions in binary form must reproduce the above

# copyright notice, this list of conditions and the following disclaimer

# in the documentation and/or other materials provided with the

# distribution.

#    * Neither the name of Google Inc. nor the names of its

# contributors may be used to endorse or promote products derived from

# this software without specific prior written permission.

#

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# This is the modified version of Google's cpplint. The original code is

# http://google-styleguide.googlecode.com/svn/trunk/cpplint/cpplint.py

"""Support for check-webkit-style."""

import codecs

import math  # for log

import os

import os.path

import re

import sre_compile

import string

import sys

import unicodedata

# Headers that we consider STL headers.

_STL_HEADERS = frozenset([

    'algobase.h', 'algorithm', 'alloc.h', 'bitset', 'deque', 'exception',

    'function.h', 'functional', 'hash_map', 'hash_map.h', 'hash_set',

    'hash_set.h', 'iterator', 'list', 'list.h', 'map', 'memory', 'pair.h',

    'pthread_alloc', 'queue', 'set', 'set.h', 'sstream', 'stack',

    'stl_alloc.h', 'stl_relops.h', 'type_traits.h',

    'utility', 'vector', 'vector.h',

    ])

# Non-STL C++ system headers.

_CPP_HEADERS = frozenset([

    'algo.h', 'builtinbuf.h', 'bvector.h', 'cassert', 'cctype',

    'cerrno', 'cfloat', 'ciso646', 'climits', 'clocale', 'cmath',

    'complex', 'complex.h', 'csetjmp', 'csignal', 'cstdarg', 'cstddef',

    'cstdio', 'cstdlib', 'cstring', 'ctime', 'cwchar', 'cwctype',

    'defalloc.h', 'deque.h', 'editbuf.h', 'exception', 'fstream',

    'fstream.h', 'hashtable.h', 'heap.h', 'indstream.h', 'iomanip',

    'iomanip.h', 'ios', 'iosfwd', 'iostream', 'iostream.h', 'istream.h',

    'iterator.h', 'limits', 'map.h', 'multimap.h', 'multiset.h',

    'numeric', 'ostream.h', 'parsestream.h', 'pfstream.h', 'PlotFile.h',

    'procbuf.h', 'pthread_alloc.h', 'rope', 'rope.h', 'ropeimpl.h',

    'SFile.h', 'slist', 'slist.h', 'stack.h', 'stdexcept',

    'stdiostream.h', 'streambuf.h', 'stream.h', 'strfile.h', 'string',

    'strstream', 'strstream.h', 'tempbuf.h', 'tree.h', 'typeinfo', 'valarray',

    ])

# Assertion macros.  These are defined in base/logging.h and

# testing/base/gunit.h.  Note that the _M versions need to come first

# for substring matching to work.

_CHECK_MACROS = [

    'DCHECK', 'CHECK',

    'EXPECT_TRUE_M', 'EXPECT_TRUE',

    'ASSERT_TRUE_M', 'ASSERT_TRUE',

    'EXPECT_FALSE_M', 'EXPECT_FALSE',

    'ASSERT_FALSE_M', 'ASSERT_FALSE',

    ]

# Replacement macros for CHECK/DCHECK/EXPECT_TRUE/EXPECT_FALSE

_CHECK_REPLACEMENT = dict([(m, {}) for m in _CHECK_MACROS])

for op, replacement in [('==', 'EQ'), ('!=', 'NE'),

                        ('>=', 'GE'), ('>', 'GT'),

                        ('<=', 'LE'), ('<', 'LT')]:

    _CHECK_REPLACEMENT['DCHECK'][op] = 'DCHECK_%s' % replacement

    _CHECK_REPLACEMENT['CHECK'][op] = 'CHECK_%s' % replacement

    _CHECK_REPLACEMENT['EXPECT_TRUE'][op] = 'EXPECT_%s' % replacement

    _CHECK_REPLACEMENT['ASSERT_TRUE'][op] = 'ASSERT_%s' % replacement

    _CHECK_REPLACEMENT['EXPECT_TRUE_M'][op] = 'EXPECT_%s_M' % replacement

    _CHECK_REPLACEMENT['ASSERT_TRUE_M'][op] = 'ASSERT_%s_M' % replacement

for op, inv_replacement in [('==', 'NE'), ('!=', 'EQ'),

                            ('>=', 'LT'), ('>', 'LE'),

                            ('<=', 'GT'), ('<', 'GE')]:

    _CHECK_REPLACEMENT['EXPECT_FALSE'][op] = 'EXPECT_%s' % inv_replacement

    _CHECK_REPLACEMENT['ASSERT_FALSE'][op] = 'ASSERT_%s' % inv_replacement

    _CHECK_REPLACEMENT['EXPECT_FALSE_M'][op] = 'EXPECT_%s_M' % inv_replacement

    _CHECK_REPLACEMENT['ASSERT_FALSE_M'][op] = 'ASSERT_%s_M' % inv_replacement

# These constants define types of headers for use with

# _IncludeState.check_next_include_order().

_CONFIG_HEADER = 0

_PRIMARY_HEADER = 1

_OTHER_HEADER = 2

_MOC_HEADER = 3

# The regexp compilation caching is inlined in all regexp functions for

# performance reasons; factoring it out into a separate function turns out

# to be noticeably expensive.

_regexp_compile_cache = {}

def match(pattern, s):

    """Matches the string with the pattern, caching the compiled regexp."""

    if not pattern in _regexp_compile_cache:

        _regexp_compile_cache[pattern] = sre_compile.compile(pattern)

    return _regexp_compile_cache[pattern].match(s)

def search(pattern, s):

    """Searches the string for the pattern, caching the compiled regexp."""

    if not pattern in _regexp_compile_cache:

        _regexp_compile_cache[pattern] = sre_compile.compile(pattern)

    return _regexp_compile_cache[pattern].search(s)

def sub(pattern, replacement, s):

    """Substitutes occurrences of a pattern, caching the compiled regexp."""

    if not pattern in _regexp_compile_cache:

        _regexp_compile_cache[pattern] = sre_compile.compile(pattern)

    return _regexp_compile_cache[pattern].sub(replacement, s)

def subn(pattern, replacement, s):

    """Substitutes occurrences of a pattern, caching the compiled regexp."""

    if not pattern in _regexp_compile_cache:

        _regexp_compile_cache[pattern] = sre_compile.compile(pattern)

    return _regexp_compile_cache[pattern].subn(replacement, s)

def up_to_unmatched_closing_paren(s):

    """Splits a string into two parts up to first unmatched ')'.

    Args:

      s: a string which is a substring of line after '('

      (e.g., "a == (b + c))").

    Returns:

      A pair of strings (prefix before first unmatched ')',

      remainder of s after first unmatched ')'), e.g.,

      up_to_unmatched_closing_paren("a == (b + c)) { ")

      returns "a == (b + c)", " {".

      Returns None, None if there is no unmatched ')'

    """

    i = 1

    for pos, c in enumerate(s):

      if c == '(':

        i += 1

      elif c == ')':

        i -= 1

        if i == 0:

          return s[:pos], s[pos + 1:]

    return None, None

class _IncludeState(dict):

    """Tracks line numbers for includes, and the order in which includes appear.

    As a dict, an _IncludeState object serves as a mapping between include

    filename and line number on which that file was included.

    Call check_next_include_order() once for each header in the file, passing

    in the type constants defined above. Calls in an illegal order will

    raise an _IncludeError with an appropriate error message.

    """

    # self._section will move monotonically through this set. If it ever

    # needs to move backwards, check_next_include_order will raise an error.

    _INITIAL_SECTION = 0

    _CONFIG_SECTION = 1

    _PRIMARY_SECTION = 2

    _OTHER_SECTION = 3

    _TYPE_NAMES = {

        _CONFIG_HEADER: 'WebCore config.h',

        _PRIMARY_HEADER: 'header this file implements',

        _OTHER_HEADER: 'other header',

        _MOC_HEADER: 'moc file',

        }

    _SECTION_NAMES = {

        _INITIAL_SECTION: "... nothing.",

        _CONFIG_SECTION: "WebCore config.h.",

        _PRIMARY_SECTION: 'a header this file implements.',

        _OTHER_SECTION: 'other header.',

        }

    def __init__(self):

        dict.__init__(self)

        self._section = self._INITIAL_SECTION

        self._visited_primary_section = False

        self.header_types = dict();

    def visited_primary_section(self):

        return self._visited_primary_section

    def check_next_include_order(self, header_type, file_is_header):

        """Returns a non-empty error message if the next header is out of order.

        This function also updates the internal state to be ready to check

        the next include.

        Args:

          header_type: One of the _XXX_HEADER constants defined above.

          file_is_header: Whether the file that owns this _IncludeState is itself a header

        Returns:

          The empty string if the header is in the right order, or an

          error message describing what's wrong.

        """

        if header_type == _CONFIG_HEADER and file_is_header:

            return 'Header file should not contain WebCore config.h.'

        if header_type == _PRIMARY_HEADER and file_is_header:

            return 'Header file should not contain itself.'

        if header_type == _MOC_HEADER:

            return ''

        error_message = ''

        if self._section != self._OTHER_SECTION:

            before_error_message = ('Found %s before %s' %

                                    (self._TYPE_NAMES[header_type],

                                     self._SECTION_NAMES[self._section + 1]))

        after_error_message = ('Found %s after %s' %

                                (self._TYPE_NAMES[header_type],

                                 self._SECTION_NAMES[self._section]))

        if header_type == _CONFIG_HEADER:

            if self._section >= self._CONFIG_SECTION:

                error_message = after_error_message

            self._section = self._CONFIG_SECTION

        elif header_type == _PRIMARY_HEADER:

            if self._section >= self._PRIMARY_SECTION:

                error_message = after_error_message

            elif self._section < self._CONFIG_SECTION:

                error_message = before_error_message

            self._section = self._PRIMARY_SECTION

            self._visited_primary_section = True

        else:

            assert header_type == _OTHER_HEADER

            if not file_is_header and self._section < self._PRIMARY_SECTION:

                error_message = before_error_message

            self._section = self._OTHER_SECTION

        return error_message

class _FunctionState(object):

    """Tracks current function name and the number of lines in its body.

    Attributes:

      min_confidence: The minimum confidence level to use while checking style.

    """

    _NORMAL_TRIGGER = 250  # for --v=0, 500 for --v=1, etc.

    _TEST_TRIGGER = 400    # about 50% more than _NORMAL_TRIGGER.

    def __init__(self, min_confidence):

        self.min_confidence = min_confidence

        self.current_function = ''

        self.in_a_function = False

        self.lines_in_function = 0

    def begin(self, function_name):

        """Start analyzing function body.

        Args:

            function_name: The name of the function being tracked.

        """

        self.in_a_function = True

        self.lines_in_function = 0

        self.current_function = function_name

    def count(self):

        """Count line in current function body."""

        if self.in_a_function:

            self.lines_in_function += 1

    def check(self, error, line_number):

        """Report if too many lines in function body.

        Args:

          error: The function to call with any errors found.

          line_number: The number of the line to check.

        """

        if match(r'T(EST|est)', self.current_function):

            base_trigger = self._TEST_TRIGGER

        else:

            base_trigger = self._NORMAL_TRIGGER

        trigger = base_trigger * 2 ** self.min_confidence

        if self.lines_in_function > trigger:

            error_level = int(math.log(self.lines_in_function / base_trigger, 2))

            # 50 => 0, 100 => 1, 200 => 2, 400 => 3, 800 => 4, 1600 => 5, ...

            if error_level > 5:

                error_level = 5

            error(line_number, 'readability/fn_size', error_level,

                  'Small and focused functions are preferred:'

                  ' %s has %d non-comment lines'

                  ' (error triggered by exceeding %d lines).'  % (

                      self.current_function, self.lines_in_function, trigger))

    def end(self):

        """Stop analizing function body."""

        self.in_a_function = False

class _IncludeError(Exception):

    """Indicates a problem with the include order in a file."""

    pass

def is_c_or_objective_c(file_extension):

   """Return whether the file extension corresponds to C or Objective-C.

   Args:

     file_extension: The file extension without the leading dot.

   """

   return file_extension in ['c', 'm']

class FileInfo:

    """Provides utility functions for filenames.

    FileInfo provides easy access to the components of a file's path

    relative to the project root.

    """

    def __init__(self, filename):

        self._filename = filename

    def full_name(self):

        """Make Windows paths like Unix."""

        return os.path.abspath(self._filename).replace('\\', '/')

    def repository_name(self):

        """Full name after removing the local path to the repository.

        If we have a real absolute path name here we can try to do something smart:

        detecting the root of the checkout and truncating /path/to/checkout from

        the name so that we get header guards that don't include things like

        "C:\Documents and Settings\..." or "/home/username/..." in them and thus

        people on different computers who have checked the source out to different

        locations won't see bogus errors.

        """

        fullname = self.full_name()

        if os.path.exists(fullname):

            project_dir = os.path.dirname(fullname)

            if os.path.exists(os.path.join(project_dir, ".svn")):

                # If there's a .svn file in the current directory, we

                # recursively look up the directory tree for the top

                # of the SVN checkout

                root_dir = project_dir

                one_up_dir = os.path.dirname(root_dir)

                while os.path.exists(os.path.join(one_up_dir, ".svn")):

                    root_dir = os.path.dirname(root_dir)

                    one_up_dir = os.path.dirname(one_up_dir)

                prefix = os.path.commonprefix([root_dir, project_dir])

                return fullname[len(prefix) + 1:]

            # Not SVN? Try to find a git top level directory by

            # searching up from the current path.

            root_dir = os.path.dirname(fullname)

            while (root_dir != os.path.dirname(root_dir)

                   and not os.path.exists(os.path.join(root_dir, ".git"))):

                root_dir = os.path.dirname(root_dir)

                if os.path.exists(os.path.join(root_dir, ".git")):

                    prefix = os.path.commonprefix([root_dir, project_dir])

                    return fullname[len(prefix) + 1:]

        # Don't know what to do; header guard warnings may be wrong...

        return fullname

    def split(self):

        """Splits the file into the directory, basename, and extension.

        For 'chrome/browser/browser.cpp', Split() would

        return ('chrome/browser', 'browser', '.cpp')

        Returns:

          A tuple of (directory, basename, extension).

        """

        googlename = self.repository_name()

        project, rest = os.path.split(googlename)

        return (project,) + os.path.splitext(rest)

    def base_name(self):

        """File base name - text after the final slash, before the final period."""

        return self.split()[1]

    def extension(self):

        """File extension - text following the final period."""

        return self.split()[2]

    def no_extension(self):

        """File has no source file extension."""

        return '/'.join(self.split()[0:2])

    def is_source(self):

        """File has a source file extension."""

        return self.extension()[1:] in ('c', 'cc', 'cpp', 'cxx')

# Matches standard C++ escape esequences per 2.13.2.3 of the C++ standard.

_RE_PATTERN_CLEANSE_LINE_ESCAPES = re.compile(

    r'\\([abfnrtv?"\\\']|\d+|x[0-9a-fA-F]+)')

# Matches strings.  Escape codes should already be removed by ESCAPES.

_RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES = re.compile(r'"[^"]*"')

# Matches characters.  Escape codes should already be removed by ESCAPES.

_RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES = re.compile(r"'.'")

# Matches multi-line C++ comments.

# This RE is a little bit more complicated than one might expect, because we

# have to take care of space removals tools so we can handle comments inside

# statements better.

# The current rule is: We only clear spaces from both sides when we're at the

# end of the line. Otherwise, we try to remove spaces from the right side,

# if this doesn't work we try on left side but only if there's a non-character

# on the right.

_RE_PATTERN_CLEANSE_LINE_C_COMMENTS = re.compile(

    r"""(\s*/\*.*\*/\s*$|

            /\*.*\*/\s+|

         \s+/\*.*\*/(?=\W)|

            /\*.*\*/)""", re.VERBOSE)

def is_cpp_string(line):

    """Does line terminate so, that the next symbol is in string constant.

    This function does not consider single-line nor multi-line comments.

    Args:

      line: is a partial line of code starting from the 0..n.

    Returns:

      True, if next character appended to 'line' is inside a

      string constant.

    """

    line = line.replace(r'\\', 'XX')  # after this, \\" does not match to \"

    return ((line.count('"') - line.count(r'\"') - line.count("'\"'")) & 1) == 1

def find_next_multi_line_comment_start(lines, line_index):

    """Find the beginning marker for a multiline comment."""

    while line_index < len(lines):

        if lines[line_index].strip().startswith('/*'):

            # Only return this marker if the comment goes beyond this line

            if lines[line_index].strip().find('*/', 2) < 0:

                return line_index

        line_index += 1

    return len(lines)

def find_next_multi_line_comment_end(lines, line_index):

    """We are inside a comment, find the end marker."""

    while line_index < len(lines):

        if lines[line_index].strip().endswith('*/'):

            return line_index

        line_index += 1

    return len(lines)

def remove_multi_line_comments_from_range(lines, begin, end):

    """Clears a range of lines for multi-line comments."""

    # Having // dummy comments makes the lines non-empty, so we will not get

    # unnecessary blank line warnings later in the code.

    for i in range(begin, end):

        lines[i] = '// dummy'

def remove_multi_line_comments(lines, error):

    """Removes multiline (c-style) comments from lines."""

    line_index = 0

    while line_index < len(lines):

        line_index_begin = find_next_multi_line_comment_start(lines, line_index)

        if line_index_begin >= len(lines):

            return

        line_index_end = find_next_multi_line_comment_end(lines, line_index_begin)

        if line_index_end >= len(lines):

            error(line_index_begin + 1, 'readability/multiline_comment', 5,

                  'Could not find end of multi-line comment')

            return

        remove_multi_line_comments_from_range(lines, line_index_begin, line_index_end + 1)

        line_index = line_index_end + 1

def cleanse_comments(line):

    """Removes //-comments and single-line C-style /* */ comments.

    Args:

      line: A line of C++ source.

    Returns:

      The line with single-line comments removed.

    """

    comment_position = line.find('//')

    if comment_position != -1 and not is_cpp_string(line[:comment_position]):

        line = line[:comment_position]

    # get rid of /* ... */