~drizzle-trunk/drizzle/development

if filename.endswith("config.h") or filename.endswith("global.h") or filename.endswith("server_includes.h") or filename.endswith("_priv.h") or not filename.endswith(".h"):

2118

return

2119

2120

fileinfo = FileInfo(filename)

2121

2122

line = clean_lines.lines[linenum]

2123

2124

match = _RE_PATTERN_INCLUDE.search(line)

2125

if match:

2126

include = match.group(2)

2127

if Match(r'(config|global|server_includes|_priv)\.h$', include):

2128

error(filename, linenum, 'build/include_config', 4,

2129

'Do not include config.h or files that include config.h in .h files')

2130

2131

def CheckIncludeLine(filename, clean_lines, linenum, include_state, error):

2132

"""Check rules that are applicable to #include lines.

2133

2134

Strings on #include lines are NOT removed from elided line, to make

2135

certain tasks easier. However, to prevent false positives, checks

2136

applicable to #include lines in CheckLanguage must be put here.

2137

2138

Args:

2139

filename: The name of the current file.

2140

clean_lines: A CleansedLines instance containing the file.

2141

linenum: The number of the line to check.

2142

include_state: An _IncludeState instance in which the headers are inserted.

2143

error: The function to call with any errors found.

2144

"""

2145

fileinfo = FileInfo(filename)

2146

2147

line = clean_lines.lines[linenum]

2148

2149

# "include" should use the new style "foo/bar.h" instead of just "bar.h"

2150

if _RE_PATTERN_INCLUDE_NEW_STYLE.search(line):

2151

error(filename, linenum, 'build/include', 4,

2152

'Include the directory when naming .h files')

2153

2154

# we shouldn't include a file more than once. actually, there are a

2155

# handful of instances where doing so is okay, but in general it's

2156

# not.

2157

match = _RE_PATTERN_INCLUDE.search(line)

2158

if match:

2159

include = match.group(2)

2160

is_system = (match.group(1) == '<')

2161

if include in include_state:

2162

error(filename, linenum, 'build/include', 4,

2163

'"%s" already included at %s:%s' %

2164

(include, filename, include_state[include]))

2165

else:

2166

include_state[include] = linenum

2167

2168

# We want to ensure that headers appear in the right order:

2169

# 1) for foo.cc, foo.h (preferred location)

2170

# 2) c system files

2171

# 3) cpp system files

2172

# 4) for foo.cc, foo.h (deprecated location)

2173

# 5) other google headers

2174

2175

# We classify each include statement as one of those 5 types

2176

# using a number of techniques. The include_state object keeps

2177

# track of the highest type seen, and complains if we see a

2178

# lower type after that.

2179

error_message = include_state.CheckNextIncludeOrder(

2180

_ClassifyInclude(fileinfo, include, is_system))

2181

if error_message:

2182

error(filename, linenum, 'build/include_order', 4,

2183

'%s. Should be: %s.h, c system, c++ system, other.' %

2184

(error_message, fileinfo.BaseName()))

2185

2186

# Look for any of the stream classes that are part of standard C++.

2187

match = _RE_PATTERN_INCLUDE.match(line)

2188

if match:

2189

include = match.group(2)

2190

if Match(r'(f|ind|io|i|o|parse|pf|stdio|str|)?stream$', include):

2191

# Many unit tests use cout, so we exempt them.

2192

if not _IsTestFilename(filename):

2193

error(filename, linenum, 'readability/streams', 3,

2194

'Streams are highly discouraged.')

2195

2196

def CheckLanguage(filename, clean_lines, linenum, file_extension, include_state,

2197

error):

2198

"""Checks rules from the 'C++ language rules' section of cppguide.html.

2199

2200

Some of these rules are hard to test (function overloading, using

2201

uint32 inappropriately), but we do the best we can.

2202

2203

Args:

2204

filename: The name of the current file.

2205

clean_lines: A CleansedLines instance containing the file.

2206

linenum: The number of the line to check.

2207

file_extension: The extension (without the dot) of the filename.

2208

include_state: An _IncludeState instance in which the headers are inserted.

2209

error: The function to call with any errors found.

2210

"""

2211

# If the line is empty or consists of entirely a comment, no need to

2212

# check it.

2213

line = clean_lines.elided[linenum]

2214

if not line:

2215

return

2216

2217

match = _RE_PATTERN_INCLUDE.search(line)

2218

if match:

2219

CheckIncludeLine(filename, clean_lines, linenum, include_state, error)

2220

CheckGlobalInclude(filename, clean_lines, linenum, include_state, error)

2221

return

2222

2223

# Create an extended_line, which is the concatenation of the current and

2224

# next lines, for more effective checking of code that may span more than one

2225

# line.

2226

if linenum + 1 < clean_lines.NumLines():

2227

extended_line = line + clean_lines.elided[linenum + 1]

2228

else:

2229

extended_line = line

2230

2231

# Make Windows paths like Unix.

2232

fullname = os.path.abspath(filename).replace('\\', '/')

2233

2234

# TODO(unknown): figure out if they're using default arguments in fn proto.

2235

2236

# Check to see if they're using an conversion function cast.

2237

# I just try to capture the most common basic types, though there are more.

2238

# Parameterless conversion functions, such as bool(), are allowed as they are

2239

# probably a member operator declaration or default constructor.

2240

match = Search(

2241

2242

if match:

2243

# gMock methods are defined using some variant of MOCK_METHODx(name, type)

2244

# where type may be float(), int(string), etc. Without context they are

2245

# virtually indistinguishable from int(x) casts.

2246

if not Match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(', line):

2247

error(filename, linenum, 'readability/casting', 4,

2248

'Using deprecated casting style. '

2249

'Use static_cast<%s>(...) instead' %

2250

match.group(1))

2251

2252

CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum],

2253

'static_cast',

2254

2255

error)

2256

# This doesn't catch all cases. Consider (const char * const)"hello".

2257

CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum],

2258

'reinterpret_cast', r'$(\w+\s?\*+\s?)$', error)

2259

2260

# In addition, we look for people taking the address of a cast. This

2261

# is dangerous -- casts can assign to temporaries, so the pointer doesn't

2262

# point where you think.

2263

if Search(

2264

r'(&$[^)]+$[\w(])|(&(static|dynamic|reinterpret)_cast\b)', line):

2265

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

2266

('Are you taking an address of a cast? '

2267

'This is dangerous: could be a temp var. '

2268

'Take the address before doing the cast, rather than after'))

2269

2270

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

2271

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

2272

# globals with constructors are initialized before the first access.

2273

match = Match(

2274

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

2275

line)

2276

# Make sure it's not a function.

2277

# Function template specialization looks like: "string foo<Type>(...".

2278

# Class template definitions look like: "string Foo<Type>::Method(...".

2279

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

2280

match.group(3)):

2281

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

2282

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

2283

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

2284

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

2285

2286

# Check that we're not using RTTI outside of testing code.

2287

if Search(r'\bdynamic_cast<', line) and not _IsTestFilename(filename):

2288

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

2289

'Do not use dynamic_cast<>. If you need to cast within a class '

2290

"hierarchy, use static_cast<> to upcast. Google doesn't support "

2291

'RTTI.')

2292

2293

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

2294

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

2295

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

2296

2297

if file_extension == 'h':

2298

# TODO(unknown): check that 1-arg constructors are explicit.

2299

# How to tell it's a constructor?

2300

# (handled in CheckForNonStandardConstructs for now)

2301

# TODO(unknown): check that classes have DISALLOW_EVIL_CONSTRUCTORS

2302

# (level 1 error)

2303

pass

2304

2305

# Check if people are using the verboten C basic types. The only exception

2306

# we regularly allow is "unsigned short port" for port.

2307

if Search(r'\bshort port\b', line):

2308

if not Search(r'\bunsigned short port\b', line):

2309

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

2310

'Use "unsigned short" for ports, not "short"')

2311

else:

2312

match = Search(r'\b(short|long(?! +double)|long long)\b', line)

2313

if match:

2314

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

2315

'Use int16/int64/etc, rather than the C type %s' % match.group(1))

2316

2317

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

2318

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

2319

if match:

2320

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

2321

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

2322

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

2323

2324

# Check if some verboten C functions are being used.

2325

if Search(r'\bsprintf\b', line):

2326

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

2327

'Never use sprintf. Use snprintf instead.')

2328

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

2329

if match:

2330

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

2331

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

2332

2333

if Search(r'\bsscanf\b', line):

2334

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

2335

'sscanf can be ok, but is slow and can overflow buffers.')

2336

2337

# Check for suspicious usage of "if" like

2338

# } if (a == b) {

2339

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

2340

error(filename, linenum, 'readability/braces', 4,

2341

'Did you mean "else if"? If not, start a new line for "if".')

2342

2343

# Check for potential format string bugs like printf(foo).

2344

# We constrain the pattern not to pick things like DocidForPrintf(foo).

2345

# Not perfect but it can catch printf(foo.c_str()) and printf(foo->c_str())

2346

match = re.search(r'\b((?:string)?printf)\s*$([\w.\->()]+)$', line, re.I)

2347

if match:

2348

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

2349

'Potential format string bug. Do %s("%%s", %s) instead.'

2350

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

2351

2352

# Check for potential memset bugs like memset(buf, sizeof(buf), 0).

2353

match = Search(r'memset\s*$([^,]*),\s*([^,]*),\s*0\s*$', line)

2354

if match and not Match(r"^''|-?[0-9]+|0x[0-9A-Fa-f]$", match.group(2)):

2355

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

2356

'Did you mean "memset(%s, 0, %s)"?'

2357

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

2358

2359

if Search(r'\busing namespace\b', line) and filename.endswith(".h"):

2360

error(filename, linenum, 'build/namespaces', 5,

2361

'Do not use namespace using-directives in headers. ')

2362

2363

# Detect variable-length arrays.

2364

match = Match(r'\s*(.+::)?(\w+) [a-z]\w*\[(.+)];', line)

2365

if (match and match.group(2) != 'return' and match.group(2) != 'delete' and

2366

match.group(3).find(']') == -1):

2367

# Split the size using space and arithmetic operators as delimiters.

2368

# If any of the resulting tokens are not compile time constants then

2369

# report the error.

2370

tokens = re.split(r'\s|\+|\-|\*|\/|<<|>>]', match.group(3))

2371

is_const = True

2372

skip_next = False

2373

for tok in tokens:

2374

if skip_next:

2375

skip_next = False

2376

continue

2377

2378

if Search(r'sizeof$.+$', tok): continue

2379

if Search(r'arraysize$\w+$', tok): continue

2380

2381

tok = tok.lstrip('(')

2382

tok = tok.rstrip(')')

2383

if not tok: continue

2384

if Match(r'\d+', tok): continue

2385

if Match(r'0[xX][0-9a-fA-F]+', tok): continue

2386

if Match(r'k[A-Z0-9]\w*', tok): continue

2387

if Match(r'(.+::)?k[A-Z0-9]\w*', tok): continue

2388

if Match(r'(.+::)?[A-Z][A-Z0-9_]*', tok): continue

2389

# A catch all for tricky sizeof cases, including 'sizeof expression',

2390

# 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)'

2391

# requires skipping the next token becasue we split on ' ' and '*'.

2392

if tok.startswith('sizeof'):

2393

skip_next = True

2394

continue

2395

is_const = False

2396

break

2397

if not is_const:

2398

error(filename, linenum, 'runtime/arrays', 1,

2399

'Do not use variable-length arrays. Use an appropriately named '

2400

"('k' followed by CamelCase) compile-time constant for the size.")

2401

2402

# If DISALLOW_EVIL_CONSTRUCTORS, DISALLOW_COPY_AND_ASSIGN, or

2403

# DISALLOW_IMPLICIT_CONSTRUCTORS is present, then it should be the last thing

2404

# in the class declaration.

2405

match = Match(

2406

(r'\s*'

2407

r'(DISALLOW_(EVIL_CONSTRUCTORS|COPY_AND_ASSIGN|IMPLICIT_CONSTRUCTORS))'

2408

r'$.*$;$'),

2409

line)

2410

if match and linenum + 1 < clean_lines.NumLines():

2411

next_line = clean_lines.elided[linenum + 1]

2412

if not Search(r'^\s*};', next_line):

2413

error(filename, linenum, 'readability/constructors', 3,

2414

match.group(1) + ' should be the last thing in the class')

2415

2416

# Check for use of unnamed namespaces in header files. Registration

2417

# macros are typically OK, so we allow use of "namespace {" on lines

2418

# that end with backslashes.

2419

if (file_extension == 'h'

2420

and Search(r'\bnamespace\s*{', line)

2421

and line[-1] != '\\'):

2422

error(filename, linenum, 'build/namespaces', 4,

2423

'Do not use unnamed namespaces in header files. See '

2424

'http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces'

2425

' for more information.')

2426

2427

2428

def CheckCStyleCast(filename, linenum, line, raw_line, cast_type, pattern,

2429

error):

2430

"""Checks for a C-style cast by looking for the pattern.

2431

2432

This also handles sizeof(type) warnings, due to similarity of content.

2433

2434

Args:

2435

filename: The name of the current file.

2436

linenum: The number of the line to check.

2437

line: The line of code to check.

2438

raw_line: The raw line of code to check, with comments.

2439

cast_type: The string for the C++ cast to recommend. This is either

2440

reinterpret_cast or static_cast, depending.

2441

pattern: The regular expression used to find C-style casts.

2442

error: The function to call with any errors found.

2443

"""

2444

match = Search(pattern, line)

2445

if not match:

2446

return

2447

2448

# e.g., sizeof(int)

2449

sizeof_match = Match(r'.*sizeof\s*$', line[0:match.start(1) - 1])

2450

if sizeof_match:

2451

error(filename, linenum, 'runtime/sizeof', 1,

2452

'Using sizeof(type). Use sizeof(varname) instead if possible')

2453

return

2454

2455

remainder = line[match.end(0):]

2456

2457

# The close paren is for function pointers as arguments to a function.

2458

# eg, void foo(void (*bar)(int));

2459

# The semicolon check is a more basic function check; also possibly a

2460

# function pointer typedef.

2461

# eg, void foo(int); or void foo(int) const;

2462

# The equals check is for function pointer assignment.

2463

# eg, void *(*foo)(int) = ...

2464

2465

# Right now, this will only catch cases where there's a single argument, and

2466

# it's unnamed. It should probably be expanded to check for multiple

2467

# arguments with some unnamed.

2468

function_match = Match(r'\s*(\)|=|(const)?\s*(;|\{|throw))', remainder)

2469

if function_match:

2470

if (not function_match.group(3) or

2471

function_match.group(3) == ';' or

2472

raw_line.find('/*') < 0):

2473

error(filename, linenum, 'readability/function', 3,

2474

'All parameters should be named in a function')

2475

return

2476

2477

# At this point, all that should be left is actual casts.

2478

error(filename, linenum, 'readability/casting', 4,

2479

'Using C-style cast. Use %s<%s>(...) instead' %

2480

(cast_type, match.group(1)))

2481

2482

2483

_HEADERS_CONTAINING_TEMPLATES = (

2484

('<deque>', ('deque',)),

2485

('<functional>', ('unary_function', 'binary_function',

2486

'plus', 'minus', 'multiplies', 'divides', 'modulus',

2487

'negate',

2488

'equal_to', 'not_equal_to', 'greater', 'less',

2489

'greater_equal', 'less_equal',

2490

'logical_and', 'logical_or', 'logical_not',

2491

'unary_negate', 'not1', 'binary_negate', 'not2',

2492

'bind1st', 'bind2nd',

2493

'pointer_to_unary_function',

2494

'pointer_to_binary_function',

2495

'ptr_fun',

2496

'mem_fun_t', 'mem_fun', 'mem_fun1_t', 'mem_fun1_ref_t',

2497

'mem_fun_ref_t',

2498

'const_mem_fun_t', 'const_mem_fun1_t',

2499

'const_mem_fun_ref_t', 'const_mem_fun1_ref_t',

2500

'mem_fun_ref',

2501

)),

2502

('<limits>', ('numeric_limits',)),

2503

('<list>', ('list',)),

2504

('<map>', ('map', 'multimap',)),

2505

('<memory>', ('allocator',)),

2506

('<queue>', ('queue', 'priority_queue',)),

2507

('<set>', ('set', 'multiset',)),

2508

('<stack>', ('stack',)),

2509

('<string>', ('char_traits', 'basic_string',)),

2510

('<utility>', ('pair',)),

2511

('<vector>', ('vector',)),

2512

2513

# gcc extensions.

2514

# Note: std::hash is their hash, ::hash is our hash

2515

('<hash_map>', ('hash_map', 'hash_multimap',)),

2516

('<hash_set>', ('hash_set', 'hash_multiset',)),

2517

('<slist>', ('slist',)),

2518

)

2519

2520

_HEADERS_ACCEPTED_BUT_NOT_PROMOTED = {

2521

# We can trust with reasonable confidence that map gives us pair<>, too.

2522

'pair<>': ('map', 'multimap', 'hash_map', 'hash_multimap')

2523

}

2524

2525

_RE_PATTERN_STRING = re.compile(r'\bstring\b')

2526

2527

_re_pattern_algorithm_header = []

2528

for _template in ('copy', 'max', 'min', 'min_element', 'sort', 'swap',

2529

'transform'):

2530

# Match max<type>(..., ...), max(..., ...), but not foo->max, foo.max or

2531

# type::max().

2532

_re_pattern_algorithm_header.append(

2533

(re.compile(r'[^>.]\b' + _template + r'(<.*?>)?$[^$]'),

2534

_template,

2535

'<algorithm>'))

2536

2537

_re_pattern_templates = []

2538

for _header, _templates in _HEADERS_CONTAINING_TEMPLATES:

2539

for _template in _templates:

2540

_re_pattern_templates.append(

2541

(re.compile(r'(\<|\b)' + _template + r'\s*\<'),

2542

_template + '<>',

2543

_header))

2544

2545

2546

def FilesBelongToSameModule(filename_cc, filename_h):

2547

"""Check if these two filenames belong to the same module.

2548

2549

The concept of a 'module' here is a as follows:

2550

foo.h, foo-inl.h, foo.cc, foo_test.cc and foo_unittest.cc belong to the

2551

same 'module' if they are in the same directory.

2552

some/path/public/xyzzy and some/path/internal/xyzzy are also considered

2553

to belong to the same module here.

2554

2555

If the filename_cc contains a longer path than the filename_h, for example,

2556

'/absolute/path/to/base/sysinfo.cc', and this file would include

2557

'base/sysinfo.h', this function also produces the prefix needed to open the

2558

header. This is used by the caller of this function to more robustly open the

2559

header file. We don't have access to the real include paths in this context,

2560

so we need this guesswork here.

2561

2562

Known bugs: tools/base/bar.cc and base/bar.h belong to the same module

2563

according to this implementation. Because of this, this function gives

2564

some false positives. This should be sufficiently rare in practice.

2565

2566

Args:

2567

filename_cc: is the path for the .cc file

2568

filename_h: is the path for the header path

2569

2570

Returns:

2571

Tuple with a bool and a string:

2572

bool: True if filename_cc and filename_h belong to the same module.

2573

string: the additional prefix needed to open the header file.

2574

"""

2575

2576

if not filename_cc.endswith('.cc'):

2577

return (False, '')

2578

filename_cc = filename_cc[:-len('.cc')]

2579

if filename_cc.endswith('_unittest'):

2580

filename_cc = filename_cc[:-len('_unittest')]

2581

elif filename_cc.endswith('_test'):

2582

filename_cc = filename_cc[:-len('_test')]

2583

filename_cc = filename_cc.replace('/public/', '/')

2584

filename_cc = filename_cc.replace('/internal/', '/')

2585

2586

if not filename_h.endswith('.h'):

2587

return (False, '')

2588

filename_h = filename_h[:-len('.h')]

2589

if filename_h.endswith('-inl'):

2590

filename_h = filename_h[:-len('-inl')]

2591

filename_h = filename_h.replace('/public/', '/')

2592

filename_h = filename_h.replace('/internal/', '/')

2593

2594

files_belong_to_same_module = filename_cc.endswith(filename_h)

2595

common_path = ''

2596

if files_belong_to_same_module:

2597

common_path = filename_cc[:-len(filename_h)]

2598

return files_belong_to_same_module, common_path

2599

2600

2601

def UpdateIncludeState(filename, include_state, io=codecs):

2602

"""Fill up the include_state with new includes found from the file.

2603

2604

Args:

2605

filename: the name of the header to read.

2606

include_state: an _IncludeState instance in which the headers are inserted.

2607

io: The io factory to use to read the file. Provided for testability.

2608

2609

Returns:

2610

True if a header was succesfully added. False otherwise.

2611

"""

2612

headerfile = None

2613

try:

2614

headerfile = io.open(filename, 'r', 'utf8', 'replace')

2615

except IOError:

2616

return False

2617

_cpplint_state.seen_file(filename)

2618

linenum = 0

2619

for line in headerfile:

2620

linenum += 1

2621

clean_line = CleanseComments(line)

2622

match = _RE_PATTERN_INCLUDE.search(clean_line)

2623

if match:

2624

include = match.group(2)

2625

# The value formatting is cute, but not really used right now.

2626

# What matters here is that the key is in include_state.

2627

include_state.setdefault(include, '%s:%d' % (filename, linenum))

2628

return True

2629

2630

2631

def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error,

2632

io=codecs):

2633

"""Reports for missing stl includes.

2634

2635

This function will output warnings to make sure you are including the headers

2636

necessary for the stl containers and functions that you use. We only give one

2637

reason to include a header. For example, if you use both equal_to<> and

2638

less<> in a .h file, only one (the latter in the file) of these will be

2639

reported as a reason to include the <functional>.

2640

2641

Args:

2642

filename: The name of the current file.

2643

clean_lines: A CleansedLines instance containing the file.

2644

include_state: An _IncludeState instance.

2645

error: The function to call with any errors found.

2646

io: The IO factory to use to read the header file. Provided for unittest

2647

injection.

2648

"""

2649

required = {} # A map of header name to linenumber and the template entity.

2650

# Example of required: { '<functional>': (1219, 'less<>') }

2651

2652

for linenum in xrange(clean_lines.NumLines()):

2653

line = clean_lines.elided[linenum]

2654

if not line or line[0] == '#':

2655

continue

2656

2657

# String is special -- it is a non-templatized type in STL.

2658

if _RE_PATTERN_STRING.search(line):

2659

required['<string>'] = (linenum, 'string')

2660

2661

for pattern, template, header in _re_pattern_algorithm_header:

2662

if pattern.search(line):

2663

required[header] = (linenum, template)

2664

2665

# The following function is just a speed up, no semantics are changed.

2666

if not '<' in line: # Reduces the cpu time usage by skipping lines.

2667

continue

2668

2669

for pattern, template, header in _re_pattern_templates:

2670

if pattern.search(line):

2671

required[header] = (linenum, template)

2672

2673

# The policy is that if you #include something in foo.h you don't need to

2674

# include it again in foo.cc. Here, we will look at possible includes.

2675

# Let's copy the include_state so it is only messed up within this function.

2676

include_state = include_state.copy()

2677

2678

# Did we find the header for this file (if any) and succesfully load it?

2679

header_found = False

2680

2681

# Use the absolute path so that matching works properly.

2682

abs_filename = os.path.abspath(filename)

2683

2684

# For Emacs's flymake.

2685

# If cpplint is invoked from Emacs's flymake, a temporary file is generated

2686

# by flymake and that file name might end with '_flymake.cc'. In that case,

2687

# restore original file name here so that the corresponding header file can be

2688

# found.

2689

# e.g. If the file name is 'foo_flymake.cc', we should search for 'foo.h'

2690

# instead of 'foo_flymake.h'

2691

emacs_flymake_suffix = '_flymake.cc'

2692

if abs_filename.endswith(emacs_flymake_suffix):

2693

abs_filename = abs_filename[:-len(emacs_flymake_suffix)] + '.cc'

2694

2695

# include_state is modified during iteration, so we iterate over a copy of

2696

# the keys.

2697

for header in include_state.keys(): #NOLINT

2698

(same_module, common_path) = FilesBelongToSameModule(abs_filename, header)

2699

fullpath = common_path + header

2700

if same_module and UpdateIncludeState(fullpath, include_state, io):

2701

header_found = True

2702

2703

# If we can't find the header file for a .cc, assume it's because we don't

2704

# know where to look. In that case we'll give up as we're not sure they

2705

# didn't include it in the .h file.

2706

# TODO(unknown): Do a better job of finding .h files so we are confident that

2707

# not having the .h file means there isn't one.

2708

if filename.endswith('.cc') and not header_found:

2709

return

2710

2711

# All the lines have been processed, report the errors found.

2712

for required_header_unstripped in required:

2713

template = required[required_header_unstripped][1]

2714

if template in _HEADERS_ACCEPTED_BUT_NOT_PROMOTED:

2715

headers = _HEADERS_ACCEPTED_BUT_NOT_PROMOTED[template]

2716

if [True for header in headers if header in include_state]:

2717

continue

2718

if required_header_unstripped.strip('<>"') not in include_state:

2719

error(filename, required[required_header_unstripped][0],

2720

'build/include_what_you_use', 4,

2721

'Add #include ' + required_header_unstripped + ' for ' + template)

2722

2723

2724

def ProcessLine(filename, file_extension,

2725

clean_lines, line, include_state, function_state,

2726

class_state, error):

2727

"""Processes a single line in the file.

2728

2729

Args:

2730

filename: Filename of the file that is being processed.

2731

file_extension: The extension (dot not included) of the file.

2732

clean_lines: An array of strings, each representing a line of the file,

2733

with comments stripped.

2734

line: Number of line being processed.

2735

include_state: An _IncludeState instance in which the headers are inserted.

2736

function_state: A _FunctionState instance which counts function lines, etc.

2737

class_state: A _ClassState instance which maintains information about

2738

the current stack of nested class declarations being parsed.

2739

error: A callable to which errors are reported, which takes 4 arguments:

2740

filename, line number, error level, and message

2741

2742

"""

2743

raw_lines = clean_lines.raw_lines

2744

CheckForFunctionLengths(filename, clean_lines, line, function_state, error)

2745

if Search(r'\bNOLINT\b', raw_lines[line]): # ignore nolint lines

2746

return

2747

CheckForMultilineCommentsAndStrings(filename, clean_lines, line, error)

2748

CheckStyle(filename, clean_lines, line, file_extension, error)

2749

CheckLanguage(filename, clean_lines, line, file_extension, include_state,

2750

error)

2751

CheckForNonStandardConstructs(filename, clean_lines, line,

2752

class_state, error)

2753

CheckPosixThreading(filename, clean_lines, line, error)

2754

CheckInvalidIncrement(filename, clean_lines, line, error)

2755

2756

2757

def ProcessFileData(filename, file_extension, lines, error):

2758

"""Performs lint checks and reports any errors to the given error function.

2759

2760

Args:

2761

filename: Filename of the file that is being processed.

2762

file_extension: The extension (dot not included) of the file.

2763

lines: An array of strings, each representing a line of the file, with the

2764

last element being empty if the file is termined with a newline.

2765

error: A callable to which errors are reported, which takes 4 arguments:

2766

"""

2767

lines = (['// marker so line numbers and indices both start at 1'] + lines +

2768

['// marker so line numbers end in a known way'])

2769

2770

include_state = _IncludeState()

2771

function_state = _FunctionState()

2772

class_state = _ClassState()

2773

2774

CheckForCopyright(filename, lines, error)

2775

2776

if file_extension == 'h':

2777

CheckForHeaderGuard(filename, lines, error)

2778

2779

RemoveMultiLineComments(filename, lines, error)

2780

clean_lines = CleansedLines(lines)

2781

for line in xrange(clean_lines.NumLines()):

2782

ProcessLine(filename, file_extension, clean_lines, line,

2783

include_state, function_state, class_state, error)

2784

class_state.CheckFinished(filename, error)

2785

2786

CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error)

2787

2788

# We check here rather than inside ProcessLine so that we see raw

2789

# lines rather than "cleaned" lines.

2790

CheckForUnicodeReplacementCharacters(filename, lines, error)

2791

2792

CheckForNewlineAtEOF(filename, lines, error)

2793

2794

2795

def ProcessFile(filename, vlevel):

2796

"""Does google-lint on a single file.

2797

2798

Args:

2799

filename: The name of the file to parse.

2800

2801

vlevel: The level of errors to report. Every error of confidence

2802

>= verbose_level will be reported. 0 is a good default.

2803

"""

2804

2805

_SetVerboseLevel(vlevel)

2806

2807

try:

2808

# Support the UNIX convention of using "-" for stdin. Note that

2809

# we are not opening the file with universal newline support

2810

# (which codecs doesn't support anyway), so the resulting lines do

2811

# contain trailing '\r' characters if we are reading a file that

2812

# has CRLF endings.

2813

# If after the split a trailing '\r' is present, it is removed

2814

# below. If it is not expected to be present (i.e. os.linesep !=

2815

# '\r\n' as in Windows), a warning is issued below if this file

2816

# is processed.

2817

2818

if filename == '-':

2819

lines = codecs.StreamReaderWriter(sys.stdin,

2820

codecs.getreader('utf8'),

2821

codecs.getwriter('utf8'),

2822

'replace').read().split('\n')

2823

else:

2824

_cpplint_state.seen_file(filename)

2825

lines = codecs.open(filename, 'r', 'utf8', 'replace').read().split('\n')

2826

2827

carriage_return_found = False

2828

# Remove trailing '\r'.

2829

for linenum in range(len(lines)):

2830

if lines[linenum].endswith('\r'):

2831

lines[linenum] = lines[linenum].rstrip('\r')

2832

carriage_return_found = True

2833

2834

except IOError:

2835

sys.stderr.write(

2836

"Skipping input '%s': Can't open for reading\n" % filename)

2837

return

2838

2839

# Note, if no dot is found, this will give the entire filename as the ext.

2840

file_extension = filename[filename.rfind('.') + 1:]

2841

2842

# When reading from stdin, the extension is unknown, so no cpplint tests

2843

# should rely on the extension.

2844

if (filename != '-' and file_extension != 'cc' and file_extension != 'h'

2845

and file_extension != 'cpp'):

2846

sys.stderr.write('Ignoring %s; not a .cc or .h file\n' % filename)

2847

else:

2848

ProcessFileData(filename, file_extension, lines, Error)

2849

if carriage_return_found and os.linesep != '\r\n':

2850

# Use 0 for linenum since outputing only one error for potentially

2851

# several lines.

2852

Error(filename, 0, 'whitespace/newline', 1,

2853

'One or more unexpected \\r (^M) found;'

2854

'better to use only a \\n')

2855

2856

sys.stderr.write('Done processing %s\n' % filename)

2857

2858

2859

def PrintUsage(message):

2860

"""Prints a brief usage string and exits, optionally with an error message.

2861

2862

Args:

2863

message: The optional error message.

2864

"""

2865

sys.stderr.write(_USAGE)

2866

if message:

2867

sys.exit('\nFATAL ERROR: ' + message)

2868

else:

2869

sys.exit(1)

2870

2871

2872

def PrintCategories():

2873

"""Prints a list of all the error-categories used by error messages.

2874

2875

These are the categories used to filter messages via --filter.

2876

"""

2877

sys.stderr.write(_ERROR_CATEGORIES)

2878

sys.exit(0)

2879

2880

2881

def ParseArguments(args):

2882

"""Parses the command line arguments.

2883

2884

This may set the output format and verbosity level as side-effects.

2885

2886

Args:

2887

args: The command line arguments:

2888

2889

Returns:

2890

The list of filenames to lint.

2891

"""

2892

try:

2893

(opts, filenames) = getopt.getopt(args, '',

2894

['help', 'output=', 'verbose=', 'deps=', 'filter='])

2895

except getopt.GetoptError:

2896

PrintUsage('Invalid arguments.')

2897

2898

verbosity = _VerboseLevel()

2899

output_format = _OutputFormat()

2900

filters = ''

2901

2902

for (opt, val) in opts:

2903

if opt == '--help':

2904

PrintUsage(None)

2905

elif opt == '--output':

2906

if not val in ('emacs', 'vs7'):

2907

PrintUsage('The only allowed output formats are emacs and vs7.')

2908

output_format = val

2909

elif opt == '--verbose':

2910

verbosity = int(val)

2911

elif opt == '--filter':

2912

filters = val

2913

if not filters:

2914

PrintCategories()

2915

elif opt == '--deps':

2916

_cpplint_state.depfilename = val

2917

2918

if not filenames:

2919

PrintUsage('No files were specified.')

2920

2921

_SetOutputFormat(output_format)

2922

_SetVerboseLevel(verbosity)

2923

_SetFilters(filters)

2924

2925

return filenames

2926

2927

2928

def main():

2929

filenames = ParseArguments(sys.argv[1:])

2930

2931

# Change stderr to write with replacement characters so we don't die

2932

# if we try to print something containing non-ASCII characters.

2933

sys.stderr = codecs.StreamReaderWriter(sys.stderr,

2934

codecs.getreader('utf8'),

2935

codecs.getwriter('utf8'),

2936

'replace')

2937

2938

_cpplint_state.ResetErrorCount()

2939

for filename in filenames:

2940

ProcessFile(filename, _cpplint_state.verbose_level)

2941

_cpplint_state.finished()

2942

sys.stderr.write('Total errors found: %d\n' % _cpplint_state.error_count)

2943

sys.exit(_cpplint_state.error_count > 0)

2944

2945

2946

if __name__ == '__main__':

2947

main()

Older »