annoviko / pyclustering

          ' for more information.')

def CheckGlobalStatic(filename, clean_lines, linenum, error):

  """Check for unsafe global or static objects.

  Args:

    filename: The name of the current file.

    clean_lines: A CleansedLines instance containing the file.

    linenum: The number of the line to check.

    error: The function to call with any errors found.

  """

  line = clean_lines.elided[linenum]

  # Match two lines at a time to support multiline declarations

  if linenum + 1 < clean_lines.NumLines() and not Search(r'[;({]', line):

    line += clean_lines.elided[linenum + 1].strip()

  # Check for people declaring static/global STL strings at the top level.

  # This is dangerous because the C++ language does not guarantee that

  # globals with constructors are initialized before the first access.

  match = Match(

      r'((?:|static +)(?:|const +))string +([a-zA-Z0-9_:]+)\b(.*)',

      line)

  # Remove false positives:

  # - String pointers (as opposed to values).

  #    string *pointer

  #    const string *pointer

  #    string const *pointer

  #    string *const pointer

  #

  # - Functions and template specializations.

  #    string Function<Type>(...

  #    string Class<Type>::Method(...

  #

  # - Operators.  These are matched separately because operator names

  #   cross non-word boundaries, and trying to match both operators

  #   and functions at the same time would decrease accuracy of

  #   matching identifiers.

  #    string Class::operator*()

  if (match and

      not Search(r'\bstring\b(\s+const)?\s*\*\s*(const\s+)?\w', line) and

      not Search(r'\boperator\W', line) and

      not Match(r'\s*(<.*>)?(::[a-zA-Z0-9_]+)*\s*\(([^"]|$)', match.group(3))):

    error(filename, linenum, 'runtime/string', 4,

          'For a static/global string constant, use a C style string instead: '

          '"%schar %s[]".' %

          (match.group(1), match.group(2)))

  if Search(r'\b([A-Za-z0-9_]*_)\(\1\)', line):

    error(filename, linenum, 'runtime/init', 4,

          'You seem to be initializing a member variable with itself.')

def CheckPrintf(filename, clean_lines, linenum, error):

            "You don't need a ; after a }")

def CheckEmptyBlockBody(filename, clean_lines, linenum, error):

  """Look for empty loop/conditional body with only a single semicolon.

  Args:

    filename: The name of the current file.

    clean_lines: A CleansedLines instance containing the file.

    linenum: The number of the line to check.

    error: The function to call with any errors found.

  """

  # Search for loop keywords at the beginning of the line.  Because only

  # whitespaces are allowed before the keywords, this will also ignore most

  # do-while-loops, since those lines should start with closing brace.

  #

  # We also check "if" blocks here, since an empty conditional block

  # is likely an error.

  line = clean_lines.elided[linenum]

  matched = Match(r'\s*(for|while|if)\s*\(', line)

  if matched:

    # Find the end of the conditional expression

    (end_line, end_linenum, end_pos) = CloseExpression(

        clean_lines, linenum, line.find('('))

    # Output warning if what follows the condition expression is a semicolon.

    # No warning for all other cases, including whitespace or newline, since we

    # have a separate check for semicolons preceded by whitespace.

    if end_pos >= 0 and Match(r';', end_line[end_pos:]):

      if matched.group(1) == 'if':

        error(filename, end_linenum, 'whitespace/empty_conditional_body', 5,

              'Empty conditional bodies should use {}')

      else:

        error(filename, end_linenum, 'whitespace/empty_loop_body', 5,

              'Empty loop bodies should use {} or continue')

def FindCheckMacro(line):

          'You seem to be initializing a member variable with itself.')

def CheckPrintf(filename, clean_lines, linenum, error):

  """Check for printf related issues.

  Args:

    filename: The name of the current file.

    clean_lines: A CleansedLines instance containing the file.

    linenum: The number of the line to check.

    error: The function to call with any errors found.

  """

  line = clean_lines.elided[linenum]

  # When snprintf is used, the second argument shouldn't be a literal.

  match = Search(r'snprintf\s*\(([^,]*),\s*([0-9]*)\s*,', line)

  if match and match.group(2) != '0':

    # If 2nd arg is zero, snprintf is used to calculate size.

    error(filename, linenum, 'runtime/printf', 3,

          'If you can, use sizeof(%s) instead of %s as the 2nd arg '

          'to snprintf.' % (match.group(1), match.group(2)))

  # Check if some verboten C functions are being used.

  if Search(r'\bsprintf\s*\(', line):

    error(filename, linenum, 'runtime/printf', 5,

          'Never use sprintf. Use snprintf instead.')

  match = Search(r'\b(strcpy|strcat)\s*\(', line)

  if match:

    error(filename, linenum, 'runtime/printf', 4,

          'Almost always, snprintf is better than %s' % match.group(1))

def IsDerivedFunction(clean_lines, linenum):