www.infradead.org Git - users/hch/configfs.git/blob

1 #!/usr/bin/perl -w

6 # Licensed under the terms of the GNU GPL License version 2

7

8 use strict;

9 use POSIX;

10

11 my $P = $0;

12 $P =~ s@.*/@@g;

13

14 my $V = '0.32';

15

16 use Getopt::Long qw(:config no_auto_abbrev);

17

18 my $quiet = 0;

19 my $tree = 1;

20 my $chk_signoff = 1;

21 my $chk_patch = 1;

22 my $tst_only;

23 my $emacs = 0;

24 my $terse = 0;

25 my $file = 0;

26 my $check = 0;

27 my $summary = 1;

28 my $mailback = 0;

29 my $summary_file = 0;

30 my $show_types = 0;

31 my $fix = 0;

32 my $fix_inplace = 0;

33 my $root;

34 my %debug;

35 my %camelcase = ();

36 my %use_type = ();

37 my @use = ();

38 my %ignore_type = ();

39 my @ignore = ();

40 my $help = 0;

41 my $configuration_file = ".checkpatch.conf";

42 my $max_line_length = 80;

43 my $ignore_perl_version = 0;

44 my $minimum_perl_version = 5.10.0;

45

46 sub help {

47 my ($exitcode) = @_;

48

49 print << "EOM";

50 Usage: $P [OPTION]... [FILE]...

51 Version: $V

52

53 Options:

54 -q, --quiet quiet

55 --no-tree run without a kernel tree

56 --no-signoff do not check for 'Signed-off-by' line

57 --patch treat FILE as patchfile (default)

58 --emacs emacs compile window format

59 --terse one line per report

60 -f, --file treat FILE as regular source file

61 --subjective, --strict enable more subjective tests

62 --types TYPE(,TYPE2...) show only these comma separated message types

63 --ignore TYPE(,TYPE2...) ignore various comma separated message types

64 --max-line-length=n set the maximum line length, if exceeded, warn

65 --show-types show the message "types" in the output

66 --root=PATH PATH to the kernel tree root

67 --no-summary suppress the per-file summary

68 --mailback only produce a report in case of warnings/errors

69 --summary-file include the filename in summary

70 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of

71 'values', 'possible', 'type', and 'attr' (default

72 is all off)

73 --test-only=WORD report only warnings/errors containing WORD

74 literally

75 --fix EXPERIMENTAL - may create horrible results

76 If correctable single-line errors exist, create

77 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"

78 with potential errors corrected to the preferred

79 checkpatch style

80 --fix-inplace EXPERIMENTAL - may create horrible results

81 Is the same as --fix, but overwrites the input

82 file. It's your fault if there's no backup or git

83 --ignore-perl-version override checking of perl version. expect

84 runtime errors.

85 -h, --help, --version display this help and exit

86

87 When FILE is - read standard input.

88 EOM

89

90 exit($exitcode);

91 }

92

93 my $conf = which_conf($configuration_file);

94 if (-f $conf) {

95 my @conf_args;

96 open(my $conffile, '<', "$conf")

97 or warn "$P: Can't find a readable $configuration_file file $!\n";

98

99 while (<$conffile>) {

100 my $line = $_;

101

102 $line =~ s/\s*\n?$//g;

103 $line =~ s/^\s*//g;

104 $line =~ s/\s+/ /g;

105

106 next if ($line =~ m/^\s*#/);

107 next if ($line =~ m/^\s*$/);

108

109 my @words = split(" ", $line);

110 foreach my $word (@words) {

111 last if ($word =~ m/^#/);

112 push (@conf_args, $word);

113 }

114 }

115 close($conffile);

116 unshift(@ARGV, @conf_args) if @conf_args;

117 }

118

119 GetOptions(

120 'q|quiet+' => \$quiet,

121 'tree!' => \$tree,

122 'signoff!' => \$chk_signoff,

123 'patch!' => \$chk_patch,

124 'emacs!' => \$emacs,

125 'terse!' => \$terse,

126 'f|file!' => \$file,

127 'subjective!' => \$check,

128 'strict!' => \$check,

129 'ignore=s' => \@ignore,

130 'types=s' => \@use,

131 'show-types!' => \$show_types,

132 'max-line-length=i' => \$max_line_length,

133 'root=s' => \$root,

134 'summary!' => \$summary,

135 'mailback!' => \$mailback,

136 'summary-file!' => \$summary_file,

137 'fix!' => \$fix,

138 'fix-inplace!' => \$fix_inplace,

139 'ignore-perl-version!' => \$ignore_perl_version,

140 'debug=s' => \%debug,

141 'test-only=s' => \$tst_only,

142 'h|help' => \$help,

143 'version' => \$help

144 ) or help(1);

145

146 help(0) if ($help);

147

148 $fix = 1 if ($fix_inplace);

149

150 my $exit = 0;

151

152 if ($^V && $^V lt $minimum_perl_version) {

153 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;

154 if (!$ignore_perl_version) {

155 exit(1);

156 }

157 }

158

159 if ($#ARGV < 0) {

160 print "$P: no input files\n";

161 exit(1);

162 }

163

164 sub hash_save_array_words {

165 my ($hashRef, $arrayRef) = @_;

166

167 my @array = split(/,/, join(',', @$arrayRef));

168 foreach my $word (@array) {

169 $word =~ s/\s*\n?$//g;

170 $word =~ s/^\s*//g;

171 $word =~ s/\s+/ /g;

172 $word =~ tr/[a-z]/[A-Z]/;

173

174 next if ($word =~ m/^\s*#/);

175 next if ($word =~ m/^\s*$/);

176

177 $hashRef->{$word}++;

178 }

179 }

180

181 sub hash_show_words {

182 my ($hashRef, $prefix) = @_;

183

184 if ($quiet == 0 && keys %$hashRef) {

185 print "NOTE: $prefix message types:";

186 foreach my $word (sort keys %$hashRef) {

187 print " $word";

188 }

189 print "\n\n";

190 }

191 }

192

193 hash_save_array_words(\%ignore_type, \@ignore);

194 hash_save_array_words(\%use_type, \@use);

195

196 my $dbg_values = 0;

197 my $dbg_possible = 0;

198 my $dbg_type = 0;

199 my $dbg_attr = 0;

200 for my $key (keys %debug) {

201 ## no critic

202 eval "\${dbg_$key} = '$debug{$key}';";

203 die "$@" if ($@);

204 }

205

206 my $rpt_cleaners = 0;

207

208 if ($terse) {

209 $emacs = 1;

210 $quiet++;

211 }

212

213 if ($tree) {

214 if (defined $root) {

215 if (!top_of_kernel_tree($root)) {

216 die "$P: $root: --root does not point at a valid tree\n";

217 }

218 } else {

219 if (top_of_kernel_tree('.')) {

220 $root = '.';

221 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&

222 top_of_kernel_tree($1)) {

223 $root = $1;

224 }

225 }

226

227 if (!defined $root) {

228 print "Must be run from the top-level dir. of a kernel tree\n";

229 exit(2);

230 }

231 }

232

233 my $emitted_corrupt = 0;

234

235 our $Ident = qr{

236 [A-Za-z_][A-Za-z\d_]*

237 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*

238 }x;

239 our $Storage = qr{extern|static|asmlinkage};

240 our $Sparse = qr{

241 __user|

242 __kernel|

243 __force|

244 __iomem|

245 __must_check|

246 __init_refok|

247 __kprobes|

248 __ref|

249 __rcu

250 }x;

251 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};

252 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};

253 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};

254 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};

255 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};

256

257 # Notes to $Attribute:

258 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check

259 our $Attribute = qr{

260 const|

261 __percpu|

262 __nocast|

263 __safe|

264 __bitwise__|

265 __packed__|

266 __packed2__|

267 __naked|

268 __maybe_unused|

269 __always_unused|

270 __noreturn|

271 __used|

272 __cold|

273 __noclone|

274 __deprecated|

275 __read_mostly|

276 __kprobes|

277 $InitAttribute|

278 ____cacheline_aligned|

279 ____cacheline_aligned_in_smp|

280 ____cacheline_internodealigned_in_smp|

281 __weak

282 }x;

283 our $Modifier;

284 our $Inline = qr{inline|__always_inline|noinline};

285 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};

286 our $Lval = qr{$Ident(?:$Member)*};

287

288 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};

289 our $Binary = qr{(?i)0b[01]+$Int_type?};

290 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};

291 our $Int = qr{[0-9]+$Int_type?};

292 our $Octal = qr{0[0-7]+$Int_type?};

293 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};

294 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};

295 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};

296 our $Float = qr{$Float_hex|$Float_dec|$Float_int};

297 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};

298 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};

299 our $Compare = qr{<=|>=|==|!=|<|>};

300 our $Arithmetic = qr{\+|-|\*|\/|%};

301 our $Operators = qr{

302 <=|>=|==|!=|

303 =>|->|<<|>>|<|>|!|~|

304 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic

305 }x;

306

307 our $NonptrType;

308 our $NonptrTypeWithAttr;

309 our $Type;

310 our $Declare;

311

312 our $NON_ASCII_UTF8 = qr{

313 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte

314 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs

315 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte

316 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates

317 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3

318 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15

319 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16

320 }x;

321

322 our $UTF8 = qr{

323 [\x09\x0A\x0D\x20-\x7E] # ASCII

324 | $NON_ASCII_UTF8

325 }x;

326

327 our $typeTypedefs = qr{(?x:

328 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|

329 atomic_t

330 )};

331

332 our $logFunctions = qr{(?x:

333 printk(?:_ratelimited|_once|)|

334 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|

335 WARN(?:_RATELIMIT|_ONCE|)|

336 panic|

337 MODULE_[A-Z_]+|

338 seq_vprintf|seq_printf|seq_puts

339 )};

340

341 our $signature_tags = qr{(?xi:

342 Signed-off-by:|

343 Acked-by:|

344 Tested-by:|

345 Reviewed-by:|

346 Reported-by:|

347 Suggested-by:|

348 To:|

349 Cc:

350 )};

351

352 our @typeList = (

353 qr{void},

354 qr{(?:unsigned\s+)?char},

355 qr{(?:unsigned\s+)?short},

356 qr{(?:unsigned\s+)?int},

357 qr{(?:unsigned\s+)?long},

358 qr{(?:unsigned\s+)?long\s+int},

359 qr{(?:unsigned\s+)?long\s+long},

360 qr{(?:unsigned\s+)?long\s+long\s+int},

361 qr{unsigned},

362 qr{float},

363 qr{double},

364 qr{bool},

365 qr{struct\s+$Ident},

366 qr{union\s+$Ident},

367 qr{enum\s+$Ident},

368 qr{${Ident}_t},

369 qr{${Ident}_handler},

370 qr{${Ident}_handler_fn},

371 );

372 our @typeListWithAttr = (

373 @typeList,

374 qr{struct\s+$InitAttribute\s+$Ident},

375 qr{union\s+$InitAttribute\s+$Ident},

376 );

377

378 our @modifierList = (

379 qr{fastcall},

380 );

381

382 our @mode_permission_funcs = (

383 ["module_param", 3],

384 ["module_param_(?:array|named|string)", 4],

385 ["module_param_array_named", 5],

386 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],

387 ["proc_create(?:_data|)", 2],

388 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],

389 );

390

391 our $allowed_asm_includes = qr{(?x:

392 irq|

393 memory

394 )};

395 # memory.h: ARM has a custom one

396

397 sub build_types {

398 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)";

399 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)";

400 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";

401 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};

402 $NonptrType = qr{

403 (?:$Modifier\s+|const\s+)*

404 (?:

405 (?:typeof|__typeof__)\s*$[^$]*\)|

406 (?:$typeTypedefs\b)|

407 (?:${all}\b)

408 )

409 (?:\s+$Modifier|\s+const)*

410 }x;

411 $NonptrTypeWithAttr = qr{

412 (?:$Modifier\s+|const\s+)*

413 (?:

414 (?:typeof|__typeof__)\s*$[^$]*\)|

415 (?:$typeTypedefs\b)|

416 (?:${allWithAttr}\b)

417 )

418 (?:\s+$Modifier|\s+const)*

419 }x;

420 $Type = qr{

421 $NonptrType

422 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*|\[\])+|(?:\s*\[\s*\])+)?

423 (?:\s+$Inline|\s+$Modifier)*

424 }x;

425 $Declare = qr{(?:$Storage\s+)?$Type};

426 }

427 build_types();

428

429 our $Typecast = qr{\s*($\s*$NonptrType\s*$){0,1}\s*};

430

431 # Using $balanced_parens, $LvalOrFunc, or $FuncArg

432 # requires at least perl version v5.10.0

433 # Any use must be runtime checked with $^V

434

435 our $balanced_parens = qr/($(?:[^\($]++|(?-1))*\))/;

436 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};

437 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};

438

439 sub deparenthesize {

440 my ($string) = @_;

441 return "" if (!defined($string));

442 $string =~ s@^\s*\(\s*@@g;

443 $string =~ s@\s*\)\s*$@@g;

444 $string =~ s@\s+@ @g;

445 return $string;

446 }

447

448 sub seed_camelcase_file {

449 my ($file) = @_;

450

451 return if (!(-f $file));

452

453 local $/;

454

455 open(my $include_file, '<', "$file")

456 or warn "$P: Can't read '$file' $!\n";

457 my $text = <$include_file>;

458 close($include_file);

459

460 my @lines = split('\n', $text);

461

462 foreach my $line (@lines) {

463 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);

464 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {

465 $camelcase{$1} = 1;

466 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {

467 $camelcase{$1} = 1;

468 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {

469 $camelcase{$1} = 1;

470 }

471 }

472 }

473

474 my $camelcase_seeded = 0;

475 sub seed_camelcase_includes {

476 return if ($camelcase_seeded);

477

478 my $files;

479 my $camelcase_cache = "";

480 my @include_files = ();

481

482 $camelcase_seeded = 1;

483

484 if (-e ".git") {

485 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;

486 chomp $git_last_include_commit;

487 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";

488 } else {

489 my $last_mod_date = 0;

490 $files = `find $root/include -name "*.h"`;

491 @include_files = split('\n', $files);

492 foreach my $file (@include_files) {

493 my $date = POSIX::strftime("%Y%m%d%H%M",

494 localtime((stat $file)[9]));

495 $last_mod_date = $date if ($last_mod_date < $date);

496 }

497 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";

498 }

499

500 if ($camelcase_cache ne "" && -f $camelcase_cache) {

501 open(my $camelcase_file, '<', "$camelcase_cache")

502 or warn "$P: Can't read '$camelcase_cache' $!\n";

503 while (<$camelcase_file>) {

504 chomp;

505 $camelcase{$_} = 1;

506 }

507 close($camelcase_file);

508

509 return;

510 }

511

512 if (-e ".git") {

513 $files = `git ls-files "include/*.h"`;

514 @include_files = split('\n', $files);

515 }

516

517 foreach my $file (@include_files) {

518 seed_camelcase_file($file);

519 }

520

521 if ($camelcase_cache ne "") {

522 unlink glob ".checkpatch-camelcase.*";

523 open(my $camelcase_file, '>', "$camelcase_cache")

524 or warn "$P: Can't write '$camelcase_cache' $!\n";

525 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {

526 print $camelcase_file ("$_\n");

527 }

528 close($camelcase_file);

529 }

530 }

531

532 $chk_signoff = 0 if ($file);

533

534 my @rawlines = ();

535 my @lines = ();

536 my @fixed = ();

537 my $vname;

538 for my $filename (@ARGV) {

539 my $FILE;

540 if ($file) {

541 open($FILE, '-|', "diff -u /dev/null $filename") ||

542 die "$P: $filename: diff failed - $!\n";

543 } elsif ($filename eq '-') {

544 open($FILE, '<&STDIN');

545 } else {

546 open($FILE, '<', "$filename") ||

547 die "$P: $filename: open failed - $!\n";

548 }

549 if ($filename eq '-') {

550 $vname = 'Your patch';

551 } else {

552 $vname = $filename;

553 }

554 while (<$FILE>) {

555 chomp;

556 push(@rawlines, $_);

557 }

558 close($FILE);

559 if (!process($filename)) {

560 $exit = 1;

561 }

562 @rawlines = ();

563 @lines = ();

564 @fixed = ();

565 }

566

567 exit($exit);

568

569 sub top_of_kernel_tree {

570 my ($root) = @_;

571

572 my @tree_check = (

573 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",

574 "README", "Documentation", "arch", "include", "drivers",

575 "fs", "init", "ipc", "kernel", "lib", "scripts",

576 );

577

578 foreach my $check (@tree_check) {

579 if (! -e $root . '/' . $check) {

580 return 0;

581 }

582 }

583 return 1;

584 }

585

586 sub parse_email {

587 my ($formatted_email) = @_;

588

589 my $name = "";

590 my $address = "";

591 my $comment = "";

592

593 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {

594 $name = $1;

595 $address = $2;

596 $comment = $3 if defined $3;

597 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {

598 $address = $1;

599 $comment = $2 if defined $2;

600 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {

601 $address = $1;

602 $comment = $2 if defined $2;

603 $formatted_email =~ s/$address.*$//;

604 $name = $formatted_email;

605 $name = trim($name);

606 $name =~ s/^\"|\"$//g;

607 # If there's a name left after stripping spaces and

608 # leading quotes, and the address doesn't have both

609 # leading and trailing angle brackets, the address

610 # is invalid. ie:

611 # "joe smith joe@smith.com" bad

612 # "joe smith <joe@smith.com" bad

613 if ($name ne "" && $address !~ /^<[^>]+>$/) {

614 $name = "";

615 $address = "";

616 $comment = "";

617 }

618 }

619

620 $name = trim($name);

621 $name =~ s/^\"|\"$//g;

622 $address = trim($address);

623 $address =~ s/^\<|\>$//g;

624

625 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars

626 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes

627 $name = "\"$name\"";

628 }

629

630 return ($name, $address, $comment);

631 }

632

633 sub format_email {

634 my ($name, $address) = @_;

635

636 my $formatted_email;

637

638 $name = trim($name);

639 $name =~ s/^\"|\"$//g;

640 $address = trim($address);

641

642 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars

643 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes

644 $name = "\"$name\"";

645 }

646

647 if ("$name" eq "") {

648 $formatted_email = "$address";

649 } else {

650 $formatted_email = "$name <$address>";

651 }

652

653 return $formatted_email;

654 }

655

656 sub which_conf {

657 my ($conf) = @_;

658

659 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {

660 if (-e "$path/$conf") {

661 return "$path/$conf";

662 }

663 }

664

665 return "";

666 }

667

668 sub expand_tabs {

669 my ($str) = @_;

670

671 my $res = '';

672 my $n = 0;

673 for my $c (split(//, $str)) {

674 if ($c eq "\t") {

675 $res .= ' ';

676 $n++;

677 for (; ($n % 8) != 0; $n++) {

678 $res .= ' ';

679 }

680 next;

681 }

682 $res .= $c;

683 $n++;

684 }

685

686 return $res;

687 }

688 sub copy_spacing {

689 (my $res = shift) =~ tr/\t/ /c;

690 return $res;

691 }

692

693 sub line_stats {

694 my ($line) = @_;

695

696 # Drop the diff line leader and expand tabs

697 $line =~ s/^.//;

698 $line = expand_tabs($line);

699

700 # Pick the indent from the front of the line.

701 my ($white) = ($line =~ /^(\s*)/);

702

703 return (length($line), length($white));

704 }

705

706 my $sanitise_quote = '';

707

708 sub sanitise_line_reset {

709 my ($in_comment) = @_;

710

711 if ($in_comment) {

712 $sanitise_quote = '*/';

713 } else {

714 $sanitise_quote = '';

715 }

716 }

717 sub sanitise_line {

718 my ($line) = @_;

719

720 my $res = '';

721 my $l = '';

722

723 my $qlen = 0;

724 my $off = 0;

725 my $c;

726

727 # Always copy over the diff marker.

728 $res = substr($line, 0, 1);

729

730 for ($off = 1; $off < length($line); $off++) {

731 $c = substr($line, $off, 1);

732

733 # Comments we are wacking completly including the begin

734 # and end, all to $;.

735 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {

736 $sanitise_quote = '*/';

737

738 substr($res, $off, 2, "$;$;");

739 $off++;

740 next;

741 }

742 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {

743 $sanitise_quote = '';

744 substr($res, $off, 2, "$;$;");

745 $off++;

746 next;

747 }

748 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {

749 $sanitise_quote = '//';

750

751 substr($res, $off, 2, $sanitise_quote);

752 $off++;

753 next;

754 }

755

756 # A \ in a string means ignore the next character.

757 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&

758 $c eq "\\") {

759 substr($res, $off, 2, 'XX');

760 $off++;

761 next;

762 }

763 # Regular quotes.

764 if ($c eq "'" || $c eq '"') {

765 if ($sanitise_quote eq '') {

766 $sanitise_quote = $c;

767

768 substr($res, $off, 1, $c);

769 next;

770 } elsif ($sanitise_quote eq $c) {

771 $sanitise_quote = '';

772 }

773 }

774

775 #print "c<$c> SQ<$sanitise_quote>\n";

776 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {

777 substr($res, $off, 1, $;);

778 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {

779 substr($res, $off, 1, $;);

780 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {

781 substr($res, $off, 1, 'X');

782 } else {

783 substr($res, $off, 1, $c);

784 }

785 }

786

787 if ($sanitise_quote eq '//') {

788 $sanitise_quote = '';

789 }

790

791 # The pathname on a #include may be surrounded by '<' and '>'.

792 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {

793 my $clean = 'X' x length($1);

794 $res =~ s@\<.*\>@<$clean>@;

795

796 # The whole of a #error is a string.

797 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {

798 my $clean = 'X' x length($1);

799 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;

800 }

801

802 return $res;

803 }

804

805 sub get_quoted_string {

806 my ($line, $rawline) = @_;

807

808 return "" if ($line !~ m/(\"[X]+\")/g);

809 return substr($rawline, $-[0], $+[0] - $-[0]);

810 }

811

812 sub ctx_statement_block {

813 my ($linenr, $remain, $off) = @_;

814 my $line = $linenr - 1;

815 my $blk = '';

816 my $soff = $off;

817 my $coff = $off - 1;

818 my $coff_set = 0;

819

820 my $loff = 0;

821

822 my $type = '';

823 my $level = 0;

824 my @stack = ();

825 my $p;

826 my $c;

827 my $len = 0;

828

829 my $remainder;

830 while (1) {

831 @stack = (['', 0]) if ($#stack == -1);

832

833 #warn "CSB: blk<$blk> remain<$remain>\n";

834 # If we are about to drop off the end, pull in more

835 # context.

836 if ($off >= $len) {

837 for (; $remain > 0; $line++) {

838 last if (!defined $lines[$line]);

839 next if ($lines[$line] =~ /^-/);

840 $remain--;

841 $loff = $len;

842 $blk .= $lines[$line] . "\n";

843 $len = length($blk);

844 $line++;

845 last;

846 }

847 # Bail if there is no further context.

848 #warn "CSB: blk<$blk> off<$off> len<$len>\n";

849 if ($off >= $len) {

850 last;

851 }

852 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {

853 $level++;

854 $type = '#';

855 }

856 }

857 $p = $c;

858 $c = substr($blk, $off, 1);

859 $remainder = substr($blk, $off);

860

861 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";

862

863 # Handle nested #if/#else.

864 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {

865 push(@stack, [ $type, $level ]);

866 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {

867 ($type, $level) = @{$stack[$#stack - 1]};

868 } elsif ($remainder =~ /^#\s*endif\b/) {

869 ($type, $level) = @{pop(@stack)};

870 }

871

872 # Statement ends at the ';' or a close '}' at the

873 # outermost level.

874 if ($level == 0 && $c eq ';') {

875 last;

876 }

877

878 # An else is really a conditional as long as its not else if

879 if ($level == 0 && $coff_set == 0 &&

880 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&

881 $remainder =~ /^(else)(?:\s|{)/ &&

882 $remainder !~ /^else\s+if\b/) {

883 $coff = $off + length($1) - 1;

884 $coff_set = 1;

885 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";

886 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";

887 }

888

889 if (($type eq '' || $type eq '(') && $c eq '(') {

890 $level++;

891 $type = '(';

892 }

893 if ($type eq '(' && $c eq ')') {

894 $level--;

895 $type = ($level != 0)? '(' : '';

896

897 if ($level == 0 && $coff < $soff) {

898 $coff = $off;

899 $coff_set = 1;

900 #warn "CSB: mark coff<$coff>\n";

901 }

902 }

903 if (($type eq '' || $type eq '{') && $c eq '{') {

904 $level++;

905 $type = '{';

906 }

907 if ($type eq '{' && $c eq '}') {

908 $level--;

909 $type = ($level != 0)? '{' : '';

910

911 if ($level == 0) {

912 if (substr($blk, $off + 1, 1) eq ';') {

913 $off++;

914 }

915 last;

916 }

917 }

918 # Preprocessor commands end at the newline unless escaped.

919 if ($type eq '#' && $c eq "\n" && $p ne "\\") {

920 $level--;

921 $type = '';

922 $off++;

923 last;

924 }

925 $off++;

926 }

927 # We are truly at the end, so shuffle to the next line.

928 if ($off == $len) {

929 $loff = $len + 1;

930 $line++;

931 $remain--;

932 }

933

934 my $statement = substr($blk, $soff, $off - $soff + 1);

935 my $condition = substr($blk, $soff, $coff - $soff + 1);

936

937 #warn "STATEMENT<$statement>\n";

938 #warn "CONDITION<$condition>\n";

939

940 #print "coff<$coff> soff<$off> loff<$loff>\n";

941

942 return ($statement, $condition,

943 $line, $remain + 1, $off - $loff + 1, $level);

944 }

945

946 sub statement_lines {

947 my ($stmt) = @_;

948

949 # Strip the diff line prefixes and rip blank lines at start and end.

950 $stmt =~ s/(^|\n)./$1/g;

951 $stmt =~ s/^\s*//;

952 $stmt =~ s/\s*$//;

953

954 my @stmt_lines = ($stmt =~ /\n/g);

955

956 return $#stmt_lines + 2;

957 }

958

959 sub statement_rawlines {

960 my ($stmt) = @_;

961

962 my @stmt_lines = ($stmt =~ /\n/g);

963

964 return $#stmt_lines + 2;

965 }

966

967 sub statement_block_size {

968 my ($stmt) = @_;

969

970 $stmt =~ s/(^|\n)./$1/g;

971 $stmt =~ s/^\s*{//;

972 $stmt =~ s/}\s*$//;

973 $stmt =~ s/^\s*//;

974 $stmt =~ s/\s*$//;

975

976 my @stmt_lines = ($stmt =~ /\n/g);

977 my @stmt_statements = ($stmt =~ /;/g);

978

979 my $stmt_lines = $#stmt_lines + 2;

980 my $stmt_statements = $#stmt_statements + 1;

981

982 if ($stmt_lines > $stmt_statements) {

983 return $stmt_lines;

984 } else {

985 return $stmt_statements;

986 }

987 }

988

989 sub ctx_statement_full {

990 my ($linenr, $remain, $off) = @_;

991 my ($statement, $condition, $level);

992

993 my (@chunks);

994

995 # Grab the first conditional/block pair.

996 ($statement, $condition, $linenr, $remain, $off, $level) =

997 ctx_statement_block($linenr, $remain, $off);

998 #print "F: c<$condition> s<$statement> remain<$remain>\n";

999 push(@chunks, [ $condition, $statement ]);

1000 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {

1001 return ($level, $linenr, @chunks);

1002 }

1003

1004 # Pull in the following conditional/block pairs and see if they

1005 # could continue the statement.

1006 for (;;) {

1007 ($statement, $condition, $linenr, $remain, $off, $level) =

1008 ctx_statement_block($linenr, $remain, $off);

1009 #print "C: c<$condition> s<$statement> remain<$remain>\n";

1010 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));

1011 #print "C: push\n";

1012 push(@chunks, [ $condition, $statement ]);

1013 }

1014

1015 return ($level, $linenr, @chunks);

1016 }

1017

1018 sub ctx_block_get {

1019 my ($linenr, $remain, $outer, $open, $close, $off) = @_;

1020 my $line;

1021 my $start = $linenr - 1;

1022 my $blk = '';

1023 my @o;

1024 my @c;

1025 my @res = ();

1026

1027 my $level = 0;

1028 my @stack = ($level);

1029 for ($line = $start; $remain > 0; $line++) {

1030 next if ($rawlines[$line] =~ /^-/);

1031 $remain--;

1032

1033 $blk .= $rawlines[$line];

1034

1035 # Handle nested #if/#else.

1036 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {

1037 push(@stack, $level);

1038 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {

1039 $level = $stack[$#stack - 1];

1040 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {

1041 $level = pop(@stack);

1042 }

1043

1044 foreach my $c (split(//, $lines[$line])) {

1045 ##print "C<$c>L<$level><$open$close>O<$off>\n";

1046 if ($off > 0) {

1047 $off--;

1048 next;

1049 }

1050

1051 if ($c eq $close && $level > 0) {

1052 $level--;

1053 last if ($level == 0);

1054 } elsif ($c eq $open) {

1055 $level++;

1056 }

1057 }

1058

1059 if (!$outer || $level <= 1) {

1060 push(@res, $rawlines[$line]);

1061 }

1062

1063 last if ($level == 0);

1064 }

1065

1066 return ($level, @res);

1067 }

1068 sub ctx_block_outer {

1069 my ($linenr, $remain) = @_;

1070

1071 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);

1072 return @r;

1073 }

1074 sub ctx_block {

1075 my ($linenr, $remain) = @_;

1076

1077 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);

1078 return @r;

1079 }

1080 sub ctx_statement {

1081 my ($linenr, $remain, $off) = @_;

1082

1083 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);

1084 return @r;

1085 }

1086 sub ctx_block_level {

1087 my ($linenr, $remain) = @_;

1088

1089 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);

1090 }

1091 sub ctx_statement_level {

1092 my ($linenr, $remain, $off) = @_;

1093

1094 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);

1095 }

1096

1097 sub ctx_locate_comment {

1098 my ($first_line, $end_line) = @_;

1099

1100 # Catch a comment on the end of the line itself.

1101 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);

1102 return $current_comment if (defined $current_comment);

1103

1104 # Look through the context and try and figure out if there is a

1105 # comment.

1106 my $in_comment = 0;

1107 $current_comment = '';

1108 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {

1109 my $line = $rawlines[$linenr - 1];

1110 #warn " $line\n";

1111 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {

1112 $in_comment = 1;

1113 }

1114 if ($line =~ m@/\*@) {

1115 $in_comment = 1;

1116 }

1117 if (!$in_comment && $current_comment ne '') {

1118 $current_comment = '';

1119 }

1120 $current_comment .= $line . "\n" if ($in_comment);

1121 if ($line =~ m@\*/@) {

1122 $in_comment = 0;

1123 }

1124 }

1125

1126 chomp($current_comment);

1127 return($current_comment);

1128 }

1129 sub ctx_has_comment {

1130 my ($first_line, $end_line) = @_;

1131 my $cmt = ctx_locate_comment($first_line, $end_line);

1132

1133 ##print "LINE: $rawlines[$end_line - 1 ]\n";

1134 ##print "CMMT: $cmt\n";

1135

1136 return ($cmt ne '');

1137 }

1138

1139 sub raw_line {

1140 my ($linenr, $cnt) = @_;

1141

1142 my $offset = $linenr - 1;

1143 $cnt++;

1144

1145 my $line;

1146 while ($cnt) {

1147 $line = $rawlines[$offset++];

1148 next if (defined($line) && $line =~ /^-/);

1149 $cnt--;

1150 }

1151

1152 return $line;

1153 }

1154

1155 sub cat_vet {

1156 my ($vet) = @_;

1157 my ($res, $coded);

1158

1159 $res = '';

1160 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {

1161 $res .= $1;

1162 if ($2 ne '') {

1163 $coded = sprintf("^%c", unpack('C', $2) + 64);

1164 $res .= $coded;

1165 }

1166 }

1167 $res =~ s/$/\$/;

1168

1169 return $res;

1170 }

1171

1172 my $av_preprocessor = 0;

1173 my $av_pending;

1174 my @av_paren_type;

1175 my $av_pend_colon;

1176

1177 sub annotate_reset {

1178 $av_preprocessor = 0;

1179 $av_pending = '_';

1180 @av_paren_type = ('E');

1181 $av_pend_colon = 'O';

1182 }

1183

1184 sub annotate_values {

1185 my ($stream, $type) = @_;

1186

1187 my $res;

1188 my $var = '_' x length($stream);

1189 my $cur = $stream;

1190

1191 print "$stream\n" if ($dbg_values > 1);

1192

1193 while (length($cur)) {

1194 @av_paren_type = ('E') if ($#av_paren_type < 0);

1195 print " <" . join('', @av_paren_type) .

1196 "> <$type> <$av_pending>" if ($dbg_values > 1);

1197 if ($cur =~ /^(\s+)/o) {

1198 print "WS($1)\n" if ($dbg_values > 1);

1199 if ($1 =~ /\n/ && $av_preprocessor) {

1200 $type = pop(@av_paren_type);

1201 $av_preprocessor = 0;

1202 }

1203

1204 } elsif ($cur =~ /^($\s*$Type\s*)$/ && $av_pending eq '_') {

1205 print "CAST($1)\n" if ($dbg_values > 1);

1206 push(@av_paren_type, $type);

1207 $type = 'c';

1208

1209 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {

1210 print "DECLARE($1)\n" if ($dbg_values > 1);

1211 $type = 'T';

1212

1213 } elsif ($cur =~ /^($Modifier)\s*/) {

1214 print "MODIFIER($1)\n" if ($dbg_values > 1);

1215 $type = 'T';

1216

1217 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {

1218 print "DEFINE($1,$2)\n" if ($dbg_values > 1);

1219 $av_preprocessor = 1;

1220 push(@av_paren_type, $type);

1221 if ($2 ne '') {

1222 $av_pending = 'N';

1223 }

1224 $type = 'E';

1225

1226 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {

1227 print "UNDEF($1)\n" if ($dbg_values > 1);

1228 $av_preprocessor = 1;

1229 push(@av_paren_type, $type);

1230

1231 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {

1232 print "PRE_START($1)\n" if ($dbg_values > 1);

1233 $av_preprocessor = 1;

1234

1235 push(@av_paren_type, $type);

1236 push(@av_paren_type, $type);

1237 $type = 'E';

1238

1239 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {

1240 print "PRE_RESTART($1)\n" if ($dbg_values > 1);

1241 $av_preprocessor = 1;

1242

1243 push(@av_paren_type, $av_paren_type[$#av_paren_type]);

1244

1245 $type = 'E';

1246

1247 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {

1248 print "PRE_END($1)\n" if ($dbg_values > 1);

1249

1250 $av_preprocessor = 1;

1251

1252 # Assume all arms of the conditional end as this

1253 # one does, and continue as if the #endif was not here.

1254 pop(@av_paren_type);

1255 push(@av_paren_type, $type);

1256 $type = 'E';

1257

1258 } elsif ($cur =~ /^(\\\n)/o) {

1259 print "PRECONT($1)\n" if ($dbg_values > 1);

1260

1261 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {

1262 print "ATTR($1)\n" if ($dbg_values > 1);

1263 $av_pending = $type;

1264 $type = 'N';

1265

1266 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {

1267 print "SIZEOF($1)\n" if ($dbg_values > 1);

1268 if (defined $2) {

1269 $av_pending = 'V';

1270 }

1271 $type = 'N';

1272

1273 } elsif ($cur =~ /^(if|while|for)\b/o) {

1274 print "COND($1)\n" if ($dbg_values > 1);

1275 $av_pending = 'E';

1276 $type = 'N';

1277

1278 } elsif ($cur =~/^(case)/o) {

1279 print "CASE($1)\n" if ($dbg_values > 1);

1280 $av_pend_colon = 'C';

1281 $type = 'N';

1282

1283 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {

1284 print "KEYWORD($1)\n" if ($dbg_values > 1);

1285 $type = 'N';

1286

1287 } elsif ($cur =~ /^(\()/o) {

1288 print "PAREN('$1')\n" if ($dbg_values > 1);

1289 push(@av_paren_type, $av_pending);

1290 $av_pending = '_';

1291 $type = 'N';

1292

1293 } elsif ($cur =~ /^(\))/o) {

1294 my $new_type = pop(@av_paren_type);

1295 if ($new_type ne '_') {

1296 $type = $new_type;

1297 print "PAREN('$1') -> $type\n"

1298 if ($dbg_values > 1);

1299 } else {

1300 print "PAREN('$1')\n" if ($dbg_values > 1);

1301 }

1302

1303 } elsif ($cur =~ /^($Ident)\s*\(/o) {

1304 print "FUNC($1)\n" if ($dbg_values > 1);

1305 $type = 'V';

1306 $av_pending = 'V';

1307

1308 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {

1309 if (defined $2 && $type eq 'C' || $type eq 'T') {

1310 $av_pend_colon = 'B';

1311 } elsif ($type eq 'E') {

1312 $av_pend_colon = 'L';

1313 }

1314 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);

1315 $type = 'V';

1316

1317 } elsif ($cur =~ /^($Ident|$Constant)/o) {

1318 print "IDENT($1)\n" if ($dbg_values > 1);

1319 $type = 'V';

1320

1321 } elsif ($cur =~ /^($Assignment)/o) {

1322 print "ASSIGN($1)\n" if ($dbg_values > 1);

1323 $type = 'N';

1324

1325 } elsif ($cur =~/^(;|{|})/) {

1326 print "END($1)\n" if ($dbg_values > 1);

1327 $type = 'E';

1328 $av_pend_colon = 'O';

1329

1330 } elsif ($cur =~/^(,)/) {

1331 print "COMMA($1)\n" if ($dbg_values > 1);

1332 $type = 'C';

1333

1334 } elsif ($cur =~ /^(\?)/o) {

1335 print "QUESTION($1)\n" if ($dbg_values > 1);

1336 $type = 'N';

1337

1338 } elsif ($cur =~ /^(:)/o) {

1339 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);

1340

1341 substr($var, length($res), 1, $av_pend_colon);

1342 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {

1343 $type = 'E';

1344 } else {

1345 $type = 'N';

1346 }

1347 $av_pend_colon = 'O';

1348

1349 } elsif ($cur =~ /^(\[)/o) {

1350 print "CLOSE($1)\n" if ($dbg_values > 1);

1351 $type = 'N';

1352

1353 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {

1354 my $variant;

1355

1356 print "OPV($1)\n" if ($dbg_values > 1);

1357 if ($type eq 'V') {

1358 $variant = 'B';

1359 } else {

1360 $variant = 'U';

1361 }

1362

1363 substr($var, length($res), 1, $variant);

1364 $type = 'N';

1365

1366 } elsif ($cur =~ /^($Operators)/o) {

1367 print "OP($1)\n" if ($dbg_values > 1);

1368 if ($1 ne '++' && $1 ne '--') {

1369 $type = 'N';

1370 }

1371

1372 } elsif ($cur =~ /(^.)/o) {

1373 print "C($1)\n" if ($dbg_values > 1);

1374 }

1375 if (defined $1) {

1376 $cur = substr($cur, length($1));

1377 $res .= $type x length($1);

1378 }

1379 }

1380

1381 return ($res, $var);

1382 }

1383

1384 sub possible {

1385 my ($possible, $line) = @_;

1386 my $notPermitted = qr{(?:

1387 ^(?:

1388 $Modifier|

1389 $Storage|

1390 $Type|

1391 DEFINE_\S+

1392 )$|

1393 ^(?:

1394 goto|

1395 return|

1396 case|

1397 else|

1398 asm|__asm__|

1399 do|

1400 \#|

1401 \#\#|

1402 )(?:\s|$)|

1403 ^(?:typedef|struct|enum)\b

1404 )}x;

1405 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);

1406 if ($possible !~ $notPermitted) {

1407 # Check for modifiers.

1408 $possible =~ s/\s*$Storage\s*//g;

1409 $possible =~ s/\s*$Sparse\s*//g;

1410 if ($possible =~ /^\s*$/) {

1411

1412 } elsif ($possible =~ /\s/) {

1413 $possible =~ s/\s*$Type\s*//g;

1414 for my $modifier (split(' ', $possible)) {

1415 if ($modifier !~ $notPermitted) {

1416 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);

1417 push(@modifierList, $modifier);

1418 }

1419 }

1420

1421 } else {

1422 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);

1423 push(@typeList, $possible);

1424 }

1425 build_types();

1426 } else {

1427 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);

1428 }

1429 }

1430

1431 my $prefix = '';

1432

1433 sub show_type {

1434 return defined $use_type{$_[0]} if (scalar keys %use_type > 0);

1435

1436 return !defined $ignore_type{$_[0]};

1437 }

1438

1439 sub report {

1440 if (!show_type($_[1]) ||

1441 (defined $tst_only && $_[2] !~ /\Q$tst_only\E/)) {

1442 return 0;

1443 }

1444 my $line;

1445 if ($show_types) {

1446 $line = "$prefix$_[0]:$_[1]: $_[2]\n";

1447 } else {

1448 $line = "$prefix$_[0]: $_[2]\n";

1449 }

1450 $line = (split('\n', $line))[0] . "\n" if ($terse);

1451

1452 push(our @report, $line);

1453

1454 return 1;

1455 }

1456 sub report_dump {

1457 our @report;

1458 }

1459

1460 sub ERROR {

1461 if (report("ERROR", $_[0], $_[1])) {

1462 our $clean = 0;

1463 our $cnt_error++;

1464 return 1;

1465 }

1466 return 0;

1467 }

1468 sub WARN {

1469 if (report("WARNING", $_[0], $_[1])) {

1470 our $clean = 0;

1471 our $cnt_warn++;

1472 return 1;

1473 }

1474 return 0;

1475 }

1476 sub CHK {

1477 if ($check && report("CHECK", $_[0], $_[1])) {

1478 our $clean = 0;

1479 our $cnt_chk++;

1480 return 1;

1481 }

1482 return 0;

1483 }

1484

1485 sub check_absolute_file {

1486 my ($absolute, $herecurr) = @_;

1487 my $file = $absolute;

1488

1489 ##print "absolute<$absolute>\n";

1490

1491 # See if any suffix of this path is a path within the tree.

1492 while ($file =~ s@^[^/]*/@@) {

1493 if (-f "$root/$file") {

1494 ##print "file<$file>\n";

1495 last;

1496 }

1497 }

1498 if (! -f _) {

1499 return 0;

1500 }

1501

1502 # It is, so see if the prefix is acceptable.

1503 my $prefix = $absolute;

1504 substr($prefix, -length($file)) = '';

1505

1506 ##print "prefix<$prefix>\n";

1507 if ($prefix ne ".../") {

1508 WARN("USE_RELATIVE_PATH",

1509 "use relative pathname instead of absolute in changelog text\n" . $herecurr);

1510 }

1511 }

1512

1513 sub trim {

1514 my ($string) = @_;

1515

1516 $string =~ s/^\s+|\s+$//g;

1517

1518 return $string;

1519 }

1520

1521 sub ltrim {

1522 my ($string) = @_;

1523

1524 $string =~ s/^\s+//;

1525

1526 return $string;

1527 }

1528

1529 sub rtrim {

1530 my ($string) = @_;

1531

1532 $string =~ s/\s+$//;

1533

1534 return $string;

1535 }

1536

1537 sub string_find_replace {

1538 my ($string, $find, $replace) = @_;

1539

1540 $string =~ s/$find/$replace/g;

1541

1542 return $string;

1543 }

1544

1545 sub tabify {

1546 my ($leading) = @_;

1547

1548 my $source_indent = 8;

1549 my $max_spaces_before_tab = $source_indent - 1;

1550 my $spaces_to_tab = " " x $source_indent;

1551

1552 #convert leading spaces to tabs

1553 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;

1554 #Remove spaces before a tab

1555 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;

1556

1557 return "$leading";

1558 }

1559

1560 sub pos_last_openparen {

1561 my ($line) = @_;

1562

1563 my $pos = 0;

1564

1565 my $opens = $line =~ tr/\(/\(/;

1566 my $closes = $line =~ tr/\)/\)/;

1567

1568 my $last_openparen = 0;

1569

1570 if (($opens == 0) || ($closes >= $opens)) {

1571 return -1;

1572 }

1573

1574 my $len = length($line);

1575

1576 for ($pos = 0; $pos < $len; $pos++) {

1577 my $string = substr($line, $pos);

1578 if ($string =~ /^($FuncArg|$balanced_parens)/) {

1579 $pos += length($1) - 1;

1580 } elsif (substr($line, $pos, 1) eq '(') {

1581 $last_openparen = $pos;

1582 } elsif (index($string, '(') == -1) {

1583 last;

1584 }

1585 }

1586

1587 return $last_openparen + 1;

1588 }

1589

1590 sub process {

1591 my $filename = shift;

1592

1593 my $linenr=0;

1594 my $prevline="";

1595 my $prevrawline="";

1596 my $stashline="";

1597 my $stashrawline="";

1598

1599 my $length;

1600 my $indent;

1601 my $previndent=0;

1602 my $stashindent=0;

1603

1604 our $clean = 1;

1605 my $signoff = 0;

1606 my $is_patch = 0;

1607

1608 my $in_header_lines = 1;

1609 my $in_commit_log = 0; #Scanning lines before patch

1610

1611 my $non_utf8_charset = 0;

1612

1613 our @report = ();

1614 our $cnt_lines = 0;

1615 our $cnt_error = 0;

1616 our $cnt_warn = 0;

1617 our $cnt_chk = 0;

1618

1619 # Trace the real file/line as we go.

1620 my $realfile = '';

1621 my $realline = 0;

1622 my $realcnt = 0;

1623 my $here = '';

1624 my $in_comment = 0;

1625 my $comment_edge = 0;

1626 my $first_line = 0;

1627 my $p1_prefix = '';

1628

1629 my $prev_values = 'E';

1630

1631 # suppression flags

1632 my %suppress_ifbraces;

1633 my %suppress_whiletrailers;

1634 my %suppress_export;

1635 my $suppress_statement = 0;

1636

1637 my %signatures = ();

1638

1639 # Pre-scan the patch sanitizing the lines.

1640 # Pre-scan the patch looking for any __setup documentation.

1641 #

1642 my @setup_docs = ();

1643 my $setup_docs = 0;

1644

1645 my $camelcase_file_seeded = 0;

1646

1647 sanitise_line_reset();

1648 my $line;

1649 foreach my $rawline (@rawlines) {

1650 $linenr++;

1651 $line = $rawline;

1652

1653 push(@fixed, $rawline) if ($fix);

1654

1655 if ($rawline=~/^\+\+\+\s+(\S+)/) {

1656 $setup_docs = 0;

1657 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {

1658 $setup_docs = 1;

1659 }

1660 #next;

1661 }

1662 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {

1663 $realline=$1-1;

1664 if (defined $2) {

1665 $realcnt=$3+1;

1666 } else {

1667 $realcnt=1+1;

1668 }

1669 $in_comment = 0;

1670

1671 # Guestimate if this is a continuing comment. Run

1672 # the context looking for a comment "edge". If this

1673 # edge is a close comment then we must be in a comment

1674 # at context start.

1675 my $edge;

1676 my $cnt = $realcnt;

1677 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {

1678 next if (defined $rawlines[$ln - 1] &&

1679 $rawlines[$ln - 1] =~ /^-/);

1680 $cnt--;

1681 #print "RAW<$rawlines[$ln - 1]>\n";

1682 last if (!defined $rawlines[$ln - 1]);

1683 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&

1684 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {

1685 ($edge) = $1;

1686 last;

1687 }

1688 }

1689 if (defined $edge && $edge eq '*/') {

1690 $in_comment = 1;

1691 }

1692

1693 # Guestimate if this is a continuing comment. If this

1694 # is the start of a diff block and this line starts

1695 # ' *' then it is very likely a comment.

1696 if (!defined $edge &&

1697 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)

1698 {

1699 $in_comment = 1;

1700 }

1701

1702 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";

1703 sanitise_line_reset($in_comment);

1704

1705 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {

1706 # Standardise the strings and chars within the input to

1707 # simplify matching -- only bother with positive lines.

1708 $line = sanitise_line($rawline);

1709 }

1710 push(@lines, $line);

1711

1712 if ($realcnt > 1) {

1713 $realcnt-- if ($line =~ /^(?:\+| |$)/);

1714 } else {

1715 $realcnt = 0;

1716 }

1717

1718 #print "==>$rawline\n";

1719 #print "-->$line\n";

1720

1721 if ($setup_docs && $line =~ /^\+/) {

1722 push(@setup_docs, $line);

1723 }

1724 }

1725

1726 $prefix = '';

1727

1728 $realcnt = 0;

1729 $linenr = 0;

1730 foreach my $line (@lines) {

1731 $linenr++;

1732 my $sline = $line; #copy of $line

1733 $sline =~ s/$;/ /g; #with comments as spaces

1734

1735 my $rawline = $rawlines[$linenr - 1];

1736

1737 #extract the line range in the file after the patch is applied

1738 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {

1739 $is_patch = 1;

1740 $first_line = $linenr + 1;

1741 $realline=$1-1;

1742 if (defined $2) {

1743 $realcnt=$3+1;

1744 } else {

1745 $realcnt=1+1;

1746 }

1747 annotate_reset();

1748 $prev_values = 'E';

1749

1750 %suppress_ifbraces = ();

1751 %suppress_whiletrailers = ();

1752 %suppress_export = ();

1753 $suppress_statement = 0;

1754 next;

1755

1756 # track the line number as we move through the hunk, note that

1757 # new versions of GNU diff omit the leading space on completely

1758 # blank context lines so we need to count that too.

1759 } elsif ($line =~ /^( |\+|$)/) {

1760 $realline++;

1761 $realcnt-- if ($realcnt != 0);

1762

1763 # Measure the line length and indent.

1764 ($length, $indent) = line_stats($rawline);

1765

1766 # Track the previous line.

1767 ($prevline, $stashline) = ($stashline, $line);

1768 ($previndent, $stashindent) = ($stashindent, $indent);

1769 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);

1770

1771 #warn "line<$line>\n";

1772

1773 } elsif ($realcnt == 1) {

1774 $realcnt--;

1775 }

1776

1777 my $hunk_line = ($realcnt != 0);

1778

1779 #make up the handle for any error we report on this line

1780 $prefix = "$filename:$realline: " if ($emacs && $file);

1781 $prefix = "$filename:$linenr: " if ($emacs && !$file);

1782

1783 $here = "#$linenr: " if (!$file);

1784 $here = "#$realline: " if ($file);

1785

1786 # extract the filename as it passes

1787 if ($line =~ /^diff --git.*?(\S+)$/) {

1788 $realfile = $1;

1789 $realfile =~ s@^([^/]*)/@@ if (!$file);

1790 $in_commit_log = 0;

1791 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {

1792 $realfile = $1;

1793 $realfile =~ s@^([^/]*)/@@ if (!$file);

1794 $in_commit_log = 0;

1795

1796 $p1_prefix = $1;

1797 if (!$file && $tree && $p1_prefix ne '' &&

1798 -e "$root/$p1_prefix") {

1799 WARN("PATCH_PREFIX",

1800 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");

1801 }

1802

1803 if ($realfile =~ m@^include/asm/@) {

1804 ERROR("MODIFIED_INCLUDE_ASM",

1805 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");

1806 }

1807 next;

1808 }

1809

1810 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);

1811

1812 my $hereline = "$here\n$rawline\n";

1813 my $herecurr = "$here\n$rawline\n";

1814 my $hereprev = "$here\n$prevrawline\n$rawline\n";

1815

1816 $cnt_lines++ if ($realcnt != 0);

1817

1818 # Check for incorrect file permissions

1819 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {

1820 my $permhere = $here . "FILE: $realfile\n";

1821 if ($realfile !~ m@scripts/@ &&

1822 $realfile !~ /\.(py|pl|awk|sh)$/) {

1823 ERROR("EXECUTE_PERMISSIONS",

1824 "do not set execute permissions for source files\n" . $permhere);

1825 }

1826 }

1827

1828 # Check the patch for a signoff:

1829 if ($line =~ /^\s*signed-off-by:/i) {

1830 $signoff++;

1831 $in_commit_log = 0;

1832 }

1833

1834 # Check signature styles

1835 if (!$in_header_lines &&

1836 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {

1837 my $space_before = $1;

1838 my $sign_off = $2;

1839 my $space_after = $3;

1840 my $email = $4;

1841 my $ucfirst_sign_off = ucfirst(lc($sign_off));

1842

1843 if ($sign_off !~ /$signature_tags/) {

1844 WARN("BAD_SIGN_OFF",

1845 "Non-standard signature: $sign_off\n" . $herecurr);

1846 }

1847 if (defined $space_before && $space_before ne "") {

1848 if (WARN("BAD_SIGN_OFF",

1849 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&

1850 $fix) {

1851 $fixed[$linenr - 1] =

1852 "$ucfirst_sign_off $email";

1853 }

1854 }

1855 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {

1856 if (WARN("BAD_SIGN_OFF",

1857 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&

1858 $fix) {

1859 $fixed[$linenr - 1] =

1860 "$ucfirst_sign_off $email";

1861 }

1862

1863 }

1864 if (!defined $space_after || $space_after ne " ") {

1865 if (WARN("BAD_SIGN_OFF",

1866 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&

1867 $fix) {

1868 $fixed[$linenr - 1] =

1869 "$ucfirst_sign_off $email";

1870 }

1871 }

1872

1873 my ($email_name, $email_address, $comment) = parse_email($email);

1874 my $suggested_email = format_email(($email_name, $email_address));

1875 if ($suggested_email eq "") {

1876 ERROR("BAD_SIGN_OFF",

1877 "Unrecognized email address: '$email'\n" . $herecurr);

1878 } else {

1879 my $dequoted = $suggested_email;

1880 $dequoted =~ s/^"//;

1881 $dequoted =~ s/" </ </;

1882 # Don't force email to have quotes

1883 # Allow just an angle bracketed address

1884 if ("$dequoted$comment" ne $email &&

1885 "<$email_address>$comment" ne $email &&

1886 "$suggested_email$comment" ne $email) {

1887 WARN("BAD_SIGN_OFF",

1888 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);

1889 }

1890 }

1891

1892 # Check for duplicate signatures

1893 my $sig_nospace = $line;

1894 $sig_nospace =~ s/\s//g;

1895 $sig_nospace = lc($sig_nospace);

1896 if (defined $signatures{$sig_nospace}) {

1897 WARN("BAD_SIGN_OFF",

1898 "Duplicate signature\n" . $herecurr);

1899 } else {

1900 $signatures{$sig_nospace} = 1;

1901 }

1902 }

1903

1904 # Check for wrappage within a valid hunk of the file

1905 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {

1906 ERROR("CORRUPTED_PATCH",

1907 "patch seems to be corrupt (line wrapped?)\n" .

1908 $herecurr) if (!$emitted_corrupt++);

1909 }

1910

1911 # Check for absolute kernel paths.

1912 if ($tree) {

1913 while ($line =~ m{(?:^|\s)(/\S*)}g) {

1914 my $file = $1;

1915

1916 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&

1917 check_absolute_file($1, $herecurr)) {

1918 #

1919 } else {

1920 check_absolute_file($file, $herecurr);

1921 }

1922 }

1923 }

1924

1925 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php

1926 if (($realfile =~ /^$/ || $line =~ /^\+/) &&

1927 $rawline !~ m/^$UTF8*$/) {

1928 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);

1929

1930 my $blank = copy_spacing($rawline);

1931 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";

1932 my $hereptr = "$hereline$ptr\n";

1933

1934 CHK("INVALID_UTF8",

1935 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);

1936 }

1937

1938 # Check if it's the start of a commit log

1939 # (not a header line and we haven't seen the patch filename)

1940 if ($in_header_lines && $realfile =~ /^$/ &&

1941 $rawline !~ /^(commit\b|from\b|[\w-]+:).+$/i) {

1942 $in_header_lines = 0;

1943 $in_commit_log = 1;

1944 }

1945

1946 # Check if there is UTF-8 in a commit log when a mail header has explicitly

1947 # declined it, i.e defined some charset where it is missing.

1948 if ($in_header_lines &&

1949 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&

1950 $1 !~ /utf-8/i) {

1951 $non_utf8_charset = 1;

1952 }

1953

1954 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&

1955 $rawline =~ /$NON_ASCII_UTF8/) {

1956 WARN("UTF8_BEFORE_PATCH",

1957 "8-bit UTF-8 used in possible commit log\n" . $herecurr);

1958 }

1959

1960 # ignore non-hunk lines and lines being removed

1961 next if (!$hunk_line || $line =~ /^-/);

1962

1963 #trailing whitespace

1964 if ($line =~ /^\+.*\015/) {

1965 my $herevet = "$here\n" . cat_vet($rawline) . "\n";

1966 if (ERROR("DOS_LINE_ENDINGS",

1967 "DOS line endings\n" . $herevet) &&

1968 $fix) {

1969 $fixed[$linenr - 1] =~ s/[\s\015]+$//;

1970 }

1971 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {

1972 my $herevet = "$here\n" . cat_vet($rawline) . "\n";

1973 if (ERROR("TRAILING_WHITESPACE",

1974 "trailing whitespace\n" . $herevet) &&

1975 $fix) {

1976 $fixed[$linenr - 1] =~ s/\s+$//;

1977 }

1978

1979 $rpt_cleaners = 1;

1980 }

1981

1982 # Check for FSF mailing addresses.

1983 if ($rawline =~ /\bwrite to the Free/i ||

1984 $rawline =~ /\b59\s+Temple\s+Pl/i ||

1985 $rawline =~ /\b51\s+Franklin\s+St/i) {

1986 my $herevet = "$here\n" . cat_vet($rawline) . "\n";

1987 my $msg_type = \&ERROR;

1988 $msg_type = \&CHK if ($file);

1989 &{$msg_type}("FSF_MAILING_ADDRESS",

1990 "Do not include the paragraph about writing to the Free Software Foundation's mailing address from the sample GPL notice. The FSF has changed addresses in the past, and may do so again. Linux already includes a copy of the GPL.\n" . $herevet)

1991 }

1992

1993 # check for Kconfig help text having a real description

1994 # Only applies when adding the entry originally, after that we do not have

1995 # sufficient context to determine whether it is indeed long enough.

1996 if ($realfile =~ /Kconfig/ &&

1997 $line =~ /.\s*config\s+/) {

1998 my $length = 0;

1999 my $cnt = $realcnt;

2000 my $ln = $linenr + 1;

2001 my $f;

2002 my $is_start = 0;

2003 my $is_end = 0;

2004 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {

2005 $f = $lines[$ln - 1];

2006 $cnt-- if ($lines[$ln - 1] !~ /^-/);

2007 $is_end = $lines[$ln - 1] =~ /^\+/;

2008

2009 next if ($f =~ /^-/);

2010

2011 if ($lines[$ln - 1] =~ /.\s*(?:bool|tristate)\s*\"/) {

2012 $is_start = 1;

2013 } elsif ($lines[$ln - 1] =~ /.\s*(?:---)?help(?:---)?$/) {

2014 $length = -1;

2015 }

2016

2017 $f =~ s/^.//;

2018 $f =~ s/#.*//;

2019 $f =~ s/^\s+//;

2020 next if ($f =~ /^$/);

2021 if ($f =~ /^\s*config\s/) {

2022 $is_end = 1;

2023 last;

2024 }

2025 $length++;

2026 }

2027 WARN("CONFIG_DESCRIPTION",

2028 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);

2029 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";

2030 }

2031

2032 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.

2033 if ($realfile =~ /Kconfig/ &&

2034 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {

2035 WARN("CONFIG_EXPERIMENTAL",

2036 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");

2037 }

2038

2039 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&

2040 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {

2041 my $flag = $1;

2042 my $replacement = {

2043 'EXTRA_AFLAGS' => 'asflags-y',

2044 'EXTRA_CFLAGS' => 'ccflags-y',

2045 'EXTRA_CPPFLAGS' => 'cppflags-y',

2046 'EXTRA_LDFLAGS' => 'ldflags-y',

2047 };

2048

2049 WARN("DEPRECATED_VARIABLE",

2050 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});

2051 }

2052

2053 # check for DT compatible documentation

2054 if (defined $root && $realfile =~ /\.dts/ &&

2055 $rawline =~ /^\+\s*compatible\s*=/) {

2056 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;

2057

2058 foreach my $compat (@compats) {

2059 my $compat2 = $compat;

2060 my $dt_path = $root . "/Documentation/devicetree/bindings/";

2061 $compat2 =~ s/\,[a-z]*\-/\,<\.\*>\-/;

2062 `grep -Erq "$compat|$compat2" $dt_path`;

2063 if ( $? >> 8 ) {

2064 WARN("UNDOCUMENTED_DT_STRING",

2065 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);

2066 }

2067

2068 my $vendor = $compat;

2069 my $vendor_path = $dt_path . "vendor-prefixes.txt";

2070 next if (! -f $vendor_path);

2071 $vendor =~ s/^([a-zA-Z0-9]+)\,.*/$1/;

2072 `grep -Eq "$vendor" $vendor_path`;

2073 if ( $? >> 8 ) {

2074 WARN("UNDOCUMENTED_DT_STRING",

2075 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vendor_path\n" . $herecurr);

2076 }

2077 }

2078 }

2079

2080 # check we are in a valid source file if not then ignore this hunk

2081 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);

2082

2083 #line length limit

2084 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&

2085 $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&

2086 !($line =~ /^\+\s*$logFunctions\s*$\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|$\s*;)\s*$/ ||

2087 $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&

2088 $length > $max_line_length)

2089 {

2090 WARN("LONG_LINE",

2091 "line over $max_line_length characters\n" . $herecurr);

2092 }

2093

2094 # Check for user-visible strings broken across lines, which breaks the ability

2095 # to grep for the string. Make exceptions when the previous string ends in a

2096 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'

2097 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value

2098 if ($line =~ /^\+\s*"/ &&

2099 $prevline =~ /"\s*$/ &&

2100 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {

2101 WARN("SPLIT_STRING",

2102 "quoted string split across lines\n" . $hereprev);

2103 }

2104

2105 # check for spaces before a quoted newline

2106 if ($rawline =~ /^.*\".*\s\\n/) {

2107 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",

2108 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&

2109 $fix) {

2110 $fixed[$linenr - 1] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;

2111 }

2112

2113 }

2114

2115 # check for adding lines without a newline.

2116 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {

2117 WARN("MISSING_EOF_NEWLINE",

2118 "adding a line without newline at end of file\n" . $herecurr);

2119 }

2120

2121 # Blackfin: use hi/lo macros

2122 if ($realfile =~ m@arch/blackfin/.*\.S$@) {

2123 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {

2124 my $herevet = "$here\n" . cat_vet($line) . "\n";

2125 ERROR("LO_MACRO",

2126 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);

2127 }

2128 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {

2129 my $herevet = "$here\n" . cat_vet($line) . "\n";

2130 ERROR("HI_MACRO",

2131 "use the HI() macro, not (... >> 16)\n" . $herevet);

2132 }

2133 }

2134

2135 # check we are in a valid source file C or perl if not then ignore this hunk

2136 next if ($realfile !~ /\.(h|c|pl)$/);

2137

2138 # at the beginning of a line any tabs must come first and anything

2139 # more than 8 must use tabs.

2140 if ($rawline =~ /^\+\s* \t\s*\S/ ||

2141 $rawline =~ /^\+\s* \s*/) {

2142 my $herevet = "$here\n" . cat_vet($rawline) . "\n";

2143 $rpt_cleaners = 1;

2144 if (ERROR("CODE_INDENT",

2145 "code indent should use tabs where possible\n" . $herevet) &&

2146 $fix) {

2147 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;

2148 }

2149 }

2150

2151 # check for space before tabs.

2152 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {

2153 my $herevet = "$here\n" . cat_vet($rawline) . "\n";

2154 if (WARN("SPACE_BEFORE_TAB",

2155 "please, no space before tabs\n" . $herevet) &&

2156 $fix) {

2157 while ($fixed[$linenr - 1] =~

2158 s/(^\+.*) {8,8}+\t/$1\t\t/) {}

2159 while ($fixed[$linenr - 1] =~

2160 s/(^\+.*) +\t/$1\t/) {}

2161 }

2162 }

2163

2164 # check for && or || at the start of a line

2165 if ($rawline =~ /^\+\s*(&&|\|\|)/) {

2166 CHK("LOGICAL_CONTINUATIONS",

2167 "Logical continuations should be on the previous line\n" . $hereprev);

2168 }

2169

2170 # check multi-line statement indentation matches previous line

2171 if ($^V && $^V ge 5.10.0 &&

2172 $prevline =~ /^\+(\t*)(if \(|$Ident\().*(\&\&|\|\||,)\s*$/) {

2173 $prevline =~ /^\+(\t*)(.*)$/;

2174 my $oldindent = $1;

2175 my $rest = $2;

2176

2177 my $pos = pos_last_openparen($rest);

2178 if ($pos >= 0) {

2179 $line =~ /^(\+| )([ \t]*)/;

2180 my $newindent = $2;

2181

2182 my $goodtabindent = $oldindent .

2183 "\t" x ($pos / 8) .

2184 " " x ($pos % 8);

2185 my $goodspaceindent = $oldindent . " " x $pos;

2186

2187 if ($newindent ne $goodtabindent &&

2188 $newindent ne $goodspaceindent) {

2189

2190 if (CHK("PARENTHESIS_ALIGNMENT",

2191 "Alignment should match open parenthesis\n" . $hereprev) &&

2192 $fix && $line =~ /^\+/) {

2193 $fixed[$linenr - 1] =~

2194 s/^\+[ \t]*/\+$goodtabindent/;

2195 }

2196 }

2197 }

2198 }

2199

2200 if ($line =~ /^\+.*\*[ \t]*\)[ \t]+(?!$Assignment|$Arithmetic)/) {

2201 if (CHK("SPACING",

2202 "No space is necessary after a cast\n" . $hereprev) &&

2203 $fix) {

2204 $fixed[$linenr - 1] =~

2205 s/^(\+.*\*[ \t]*\))[ \t]+/$1/;

2206 }

2207 }

2208

2209 if ($realfile =~ m@^(drivers/net/|net/)@ &&

2210 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&

2211 $rawline =~ /^\+[ \t]*\*/) {

2212 WARN("NETWORKING_BLOCK_COMMENT_STYLE",

2213 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);

2214 }

2215

2216 if ($realfile =~ m@^(drivers/net/|net/)@ &&

2217 $prevrawline =~ /^\+[ \t]*\/\*/ && #starting /*

2218 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */

2219 $rawline =~ /^\+/ && #line is new

2220 $rawline !~ /^\+[ \t]*\*/) { #no leading *

2221 WARN("NETWORKING_BLOCK_COMMENT_STYLE",

2222 "networking block comments start with * on subsequent lines\n" . $hereprev);

2223 }

2224

2225 if ($realfile =~ m@^(drivers/net/|net/)@ &&

2226 $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */

2227 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/

2228 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/

2229 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */

2230 WARN("NETWORKING_BLOCK_COMMENT_STYLE",

2231 "networking block comments put the trailing */ on a separate line\n" . $herecurr);

2232 }

2233

2234 # check for spaces at the beginning of a line.

2235 # Exceptions:

2236 # 1) within comments

2237 # 2) indented preprocessor commands

2238 # 3) hanging labels

2239 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {

2240 my $herevet = "$here\n" . cat_vet($rawline) . "\n";

2241 if (WARN("LEADING_SPACE",

2242 "please, no spaces at the start of a line\n" . $herevet) &&

2243 $fix) {

2244 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;

2245 }

2246 }

2247

2248 # check we are in a valid C source file if not then ignore this hunk

2249 next if ($realfile !~ /\.(h|c)$/);

2250

2251 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).

2252 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {

2253 WARN("CONFIG_EXPERIMENTAL",

2254 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");

2255 }

2256

2257 # check for RCS/CVS revision markers

2258 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {

2259 WARN("CVS_KEYWORD",

2260 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);

2261 }

2262

2263 # Blackfin: don't use __builtin_bfin_[cs]sync

2264 if ($line =~ /__builtin_bfin_csync/) {

2265 my $herevet = "$here\n" . cat_vet($line) . "\n";

2266 ERROR("CSYNC",

2267 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);

2268 }

2269 if ($line =~ /__builtin_bfin_ssync/) {

2270 my $herevet = "$here\n" . cat_vet($line) . "\n";

2271 ERROR("SSYNC",

2272 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);

2273 }

2274

2275 # check for old HOTPLUG __dev<foo> section markings

2276 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {

2277 WARN("HOTPLUG_SECTION",

2278 "Using $1 is unnecessary\n" . $herecurr);

2279 }

2280

2281 # Check for potential 'bare' types

2282 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,

2283 $realline_next);

2284 #print "LINE<$line>\n";

2285 if ($linenr >= $suppress_statement &&

2286 $realcnt && $sline =~ /.\s*\S/) {

2287 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =

2288 ctx_statement_block($linenr, $realcnt, 0);

2289 $stat =~ s/\n./\n /g;

2290 $cond =~ s/\n./\n /g;

2291

2292 #print "linenr<$linenr> <$stat>\n";

2293 # If this statement has no statement boundaries within

2294 # it there is no point in retrying a statement scan

2295 # until we hit end of it.

2296 my $frag = $stat; $frag =~ s/;+\s*$//;

2297 if ($frag !~ /(?:{|;)/) {

2298 #print "skip<$line_nr_next>\n";

2299 $suppress_statement = $line_nr_next;

2300 }

2301

2302 # Find the real next line.

2303 $realline_next = $line_nr_next;

2304 if (defined $realline_next &&

2305 (!defined $lines[$realline_next - 1] ||

2306 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {

2307 $realline_next++;

2308 }

2309

2310 my $s = $stat;

2311 $s =~ s/{.*$//s;

2312

2313 # Ignore goto labels.

2314 if ($s =~ /$Ident:\*$/s) {

2315

2316 # Ignore functions being called

2317 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {

2318

2319 } elsif ($s =~ /^.\s*else\b/s) {

2320

2321 # declarations always start with types

2322 } elsif ($prev_values eq 'E' && $s =~ /^.\s*(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?((?:\s*$Ident)+?)\b(?:\s+$Sparse)?\s*\**\s*(?:$Ident|$\*[^$]*\))(?:\s*$Modifier)?\s*(?:;|=|,|\()/s) {

2323 my $type = $1;

2324 $type =~ s/\s+/ /g;

2325 possible($type, "A:" . $s);

2326

2327 # definitions in global scope can only start with types

2328 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {

2329 possible($1, "B:" . $s);

2330 }

2331

2332 # any (foo ... *) is a pointer cast, and foo is a type

2333 while ($s =~ /$($Ident)(?:\s+$Sparse)*[\s\*]+\s*$/sg) {

2334 possible($1, "C:" . $s);

2335 }

2336

2337 # Check for any sort of function declaration.

2338 # int foo(something bar, other baz);

2339 # void (*store_gdt)(x86_descr_ptr *);

2340 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|$\*\s*$Ident$)\s*)\(/s) {

2341 my ($name_len) = length($1);

2342

2343 my $ctx = $s;

2344 substr($ctx, 0, $name_len + 1, '');

2345 $ctx =~ s/\)[^\)]*$//;

2346

2347 for my $arg (split(/\s*,\s*/, $ctx)) {

2348 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {

2349

2350 possible($1, "D:" . $s);

2351 }

2352 }

2353 }

2354

2355 }

2356

2357 #

2358 # Checks which may be anchored in the context.

2359 #

2360

2361 # Check for switch () and associated case and default

2362 # statements should be at the same indent.

2363 if ($line=~/\bswitch\s*$.*$/) {

2364 my $err = '';

2365 my $sep = '';

2366 my @ctx = ctx_block_outer($linenr, $realcnt);

2367 shift(@ctx);

2368 for my $ctx (@ctx) {

2369 my ($clen, $cindent) = line_stats($ctx);

2370 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&

2371 $indent != $cindent) {

2372 $err .= "$sep$ctx\n";

2373 $sep = '';

2374 } else {

2375 $sep = "[...]\n";

2376 }

2377 }

2378 if ($err ne '') {

2379 ERROR("SWITCH_CASE_INDENT_LEVEL",

2380 "switch and case should be at the same indent\n$hereline$err");

2381 }

2382 }

2383

2384 # if/while/etc brace do not go on next line, unless defining a do while loop,

2385 # or if that brace on the next line is for something else

2386 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {

2387 my $pre_ctx = "$1$2";

2388

2389 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);

2390

2391 if ($line =~ /^\+\t{6,}/) {

2392 WARN("DEEP_INDENTATION",

2393 "Too many leading tabs - consider code refactoring\n" . $herecurr);

2394 }

2395

2396 my $ctx_cnt = $realcnt - $#ctx - 1;

2397 my $ctx = join("\n", @ctx);

2398

2399 my $ctx_ln = $linenr;

2400 my $ctx_skip = $realcnt;

2401

2402 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&

2403 defined $lines[$ctx_ln - 1] &&

2404 $lines[$ctx_ln - 1] =~ /^-/)) {

2405 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";

2406 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);

2407 $ctx_ln++;

2408 }

2409

2410 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";

2411 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";

2412

2413 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {

2414 ERROR("OPEN_BRACE",

2415 "that open brace { should be on the previous line\n" .

2416 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");

2417 }

2418 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&

2419 $ctx =~ /\)\s*\;\s*$/ &&

2420 defined $lines[$ctx_ln - 1])

2421 {

2422 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);

2423 if ($nindent > $indent) {

2424 WARN("TRAILING_SEMICOLON",

2425 "trailing semicolon indicates no statements, indent implies otherwise\n" .

2426 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");

2427 }

2428 }

2429 }

2430

2431 # Check relative indent for conditionals and blocks.

2432 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {

2433 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =

2434 ctx_statement_block($linenr, $realcnt, 0)

2435 if (!defined $stat);

2436 my ($s, $c) = ($stat, $cond);

2437

2438 substr($s, 0, length($c), '');

2439

2440 # Make sure we remove the line prefixes as we have

2441 # none on the first line, and are going to readd them

2442 # where necessary.

2443 $s =~ s/\n./\n/gs;

2444

2445 # Find out how long the conditional actually is.

2446 my @newlines = ($c =~ /\n/gs);

2447 my $cond_lines = 1 + $#newlines;

2448

2449 # We want to check the first line inside the block

2450 # starting at the end of the conditional, so remove:

2451 # 1) any blank line termination

2452 # 2) any opening brace { on end of the line

2453 # 3) any do (...) {

2454 my $continuation = 0;

2455 my $check = 0;

2456 $s =~ s/^.*\bdo\b//;

2457 $s =~ s/^\s*{//;

2458 if ($s =~ s/^\s*\\//) {

2459 $continuation = 1;

2460 }

2461 if ($s =~ s/^\s*?\n//) {

2462 $check = 1;

2463 $cond_lines++;

2464 }

2465

2466 # Also ignore a loop construct at the end of a

2467 # preprocessor statement.

2468 if (($prevline =~ /^.\s*#\s*define\s/ ||

2469 $prevline =~ /\\\s*$/) && $continuation == 0) {

2470 $check = 0;

2471 }

2472

2473 my $cond_ptr = -1;

2474 $continuation = 0;

2475 while ($cond_ptr != $cond_lines) {

2476 $cond_ptr = $cond_lines;

2477

2478 # If we see an #else/#elif then the code

2479 # is not linear.

2480 if ($s =~ /^\s*\#\s*(?:else|elif)/) {

2481 $check = 0;

2482 }

2483

2484 # Ignore:

2485 # 1) blank lines, they should be at 0,

2486 # 2) preprocessor lines, and

2487 # 3) labels.

2488 if ($continuation ||

2489 $s =~ /^\s*?\n/ ||

2490 $s =~ /^\s*#\s*?/ ||

2491 $s =~ /^\s*$Ident\s*:/) {

2492 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;

2493 if ($s =~ s/^.*?\n//) {

2494 $cond_lines++;

2495 }

2496 }

2497 }

2498

2499 my (undef, $sindent) = line_stats("+" . $s);

2500 my $stat_real = raw_line($linenr, $cond_lines);

2501

2502 # Check if either of these lines are modified, else

2503 # this is not this patch's fault.

2504 if (!defined($stat_real) ||

2505 $stat !~ /^\+/ && $stat_real !~ /^\+/) {

2506 $check = 0;

2507 }

2508 if (defined($stat_real) && $cond_lines > 1) {

2509 $stat_real = "[...]\n$stat_real";

2510 }

2511

2512 #print "line<$line> prevline<$prevline> indent<$indent> sindent<$sindent> check<$check> continuation<$continuation> s<$s> cond_lines<$cond_lines> stat_real<$stat_real> stat<$stat>\n";

2513

2514 if ($check && (($sindent % 8) != 0 ||

2515 ($sindent <= $indent && $s ne ''))) {

2516 WARN("SUSPECT_CODE_INDENT",

2517 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");

2518 }

2519 }

2520

2521 # Track the 'values' across context and added lines.

2522 my $opline = $line; $opline =~ s/^./ /;

2523 my ($curr_values, $curr_vars) =

2524 annotate_values($opline . "\n", $prev_values);

2525 $curr_values = $prev_values . $curr_values;

2526 if ($dbg_values) {

2527 my $outline = $opline; $outline =~ s/\t/ /g;

2528 print "$linenr > .$outline\n";

2529 print "$linenr > $curr_values\n";

2530 print "$linenr > $curr_vars\n";

2531 }

2532 $prev_values = substr($curr_values, -1);

2533

2534 #ignore lines not being added

2535 next if ($line =~ /^[^\+]/);

2536

2537 # TEST: allow direct testing of the type matcher.

2538 if ($dbg_type) {

2539 if ($line =~ /^.\s*$Declare\s*$/) {

2540 ERROR("TEST_TYPE",

2541 "TEST: is type\n" . $herecurr);

2542 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {

2543 ERROR("TEST_NOT_TYPE",

2544 "TEST: is not type ($1 is)\n". $herecurr);

2545 }

2546 next;

2547 }

2548 # TEST: allow direct testing of the attribute matcher.

2549 if ($dbg_attr) {

2550 if ($line =~ /^.\s*$Modifier\s*$/) {

2551 ERROR("TEST_ATTR",

2552 "TEST: is attr\n" . $herecurr);

2553 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {

2554 ERROR("TEST_NOT_ATTR",

2555 "TEST: is not attr ($1 is)\n". $herecurr);

2556 }

2557 next;

2558 }

2559

2560 # check for initialisation to aggregates open brace on the next line

2561 if ($line =~ /^.\s*{/ &&

2562 $prevline =~ /(?:^|[^=])=\s*$/) {

2563 ERROR("OPEN_BRACE",

2564 "that open brace { should be on the previous line\n" . $hereprev);

2565 }

2566

2567 #

2568 # Checks which are anchored on the added line.

2569 #

2570

2571 # check for malformed paths in #include statements (uses RAW line)

2572 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {

2573 my $path = $1;

2574 if ($path =~ m{//}) {

2575 ERROR("MALFORMED_INCLUDE",

2576 "malformed #include filename\n" . $herecurr);

2577 }

2578 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {

2579 ERROR("UAPI_INCLUDE",

2580 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);

2581 }

2582 }

2583

2584 # no C99 // comments

2585 if ($line =~ m{//}) {

2586 if (ERROR("C99_COMMENTS",

2587 "do not use C99 // comments\n" . $herecurr) &&

2588 $fix) {

2589 my $line = $fixed[$linenr - 1];

2590 if ($line =~ /\/\/(.*)$/) {

2591 my $comment = trim($1);

2592 $fixed[$linenr - 1] =~ s@\/\/(.*)$@/\* $comment \*/@;

2593 }

2594 }

2595 }

2596 # Remove C99 comments.

2597 $line =~ s@//.*@@;

2598 $opline =~ s@//.*@@;

2599

2600 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider

2601 # the whole statement.

2602 #print "APW <$lines[$realline_next - 1]>\n";

2603 if (defined $realline_next &&

2604 exists $lines[$realline_next - 1] &&

2605 !defined $suppress_export{$realline_next} &&

2606 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*$(.*)$/ ||

2607 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*$(.*)$/)) {

2608 # Handle definitions which produce identifiers with

2609 # a prefix:

2610 # XXX(foo);

2611 # EXPORT_SYMBOL(something_foo);

2612 my $name = $1;

2613 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&

2614 $name =~ /^${Ident}_$2/) {

2615 #print "FOO C name<$name>\n";

2616 $suppress_export{$realline_next} = 1;

2617

2618 } elsif ($stat !~ /(?:

2619 \n.}\s*$|

2620 ^.DEFINE_$Ident$\Q$name\E$|

2621 ^.DECLARE_$Ident$\Q$name\E$|

2622 ^.LIST_HEAD$\Q$name\E$|

2623 ^.(?:$Storage\s+)?$Type\s*$\s*\*\s*\Q$name\E\s*$\s*\(|

2624 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()

2625 )/x) {

2626 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";

2627 $suppress_export{$realline_next} = 2;

2628 } else {

2629 $suppress_export{$realline_next} = 1;

2630 }

2631 }

2632 if (!defined $suppress_export{$linenr} &&

2633 $prevline =~ /^.\s*$/ &&

2634 ($line =~ /EXPORT_SYMBOL.*$(.*)$/ ||

2635 $line =~ /EXPORT_UNUSED_SYMBOL.*$(.*)$/)) {

2636 #print "FOO B <$lines[$linenr - 1]>\n";

2637 $suppress_export{$linenr} = 2;

2638 }

2639 if (defined $suppress_export{$linenr} &&

2640 $suppress_export{$linenr} == 2) {

2641 WARN("EXPORT_SYMBOL",

2642 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);

2643 }

2644

2645 # check for global initialisers.

2646 if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {

2647 if (ERROR("GLOBAL_INITIALISERS",

2648 "do not initialise globals to 0 or NULL\n" .

2649 $herecurr) &&

2650 $fix) {

2651 $fixed[$linenr - 1] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;

2652 }

2653 }

2654 # check for static initialisers.

2655 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {

2656 if (ERROR("INITIALISED_STATIC",

2657 "do not initialise statics to 0 or NULL\n" .

2658 $herecurr) &&

2659 $fix) {

2660 $fixed[$linenr - 1] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;

2661 }

2662 }

2663

2664 # check for static const char * arrays.

2665 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {

2666 WARN("STATIC_CONST_CHAR_ARRAY",

2667 "static const char * array should probably be static const char * const\n" .

2668 $herecurr);

2669 }

2670

2671 # check for static char foo[] = "bar" declarations.

2672 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {

2673 WARN("STATIC_CONST_CHAR_ARRAY",

2674 "static char array declaration should probably be static const char\n" .

2675 $herecurr);

2676 }

2677

2678 # check for function declarations without arguments like "int foo()"

2679 if ($line =~ /(\b$Type\s+$Ident)\s*$\s*$/) {

2680 if (ERROR("FUNCTION_WITHOUT_ARGS",

2681 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&

2682 $fix) {

2683 $fixed[$linenr - 1] =~ s/(\b($Type)\s+($Ident))\s*$\s*$/$2 $3(void)/;

2684 }

2685 }

2686

2687 # check for uses of DEFINE_PCI_DEVICE_TABLE

2688 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*$\s*(\w+)\s*$\s*=/) {

2689 if (WARN("DEFINE_PCI_DEVICE_TABLE",

2690 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&

2691 $fix) {

2692 $fixed[$linenr - 1] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*$\s*(\w+)\s*$\s*=\s*/static const struct pci_device_id $1\[\] = /;

2693 }

2694 }

2695

2696 # check for new typedefs, only function parameters and sparse annotations

2697 # make sense.

2698 if ($line =~ /\btypedef\s/ &&

2699 $line !~ /\btypedef\s+$Type\s*$\s*\*?$Ident\s*$\s*\(/ &&

2700 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&

2701 $line !~ /\b$typeTypedefs\b/ &&

2702 $line !~ /\b__bitwise(?:__|)\b/) {

2703 WARN("NEW_TYPEDEFS",

2704 "do not add new typedefs\n" . $herecurr);

2705 }

2706

2707 # * goes on variable not on type

2708 # (char*[ const])

2709 while ($line =~ m{($$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)$)}g) {

2710 #print "AA<$1>\n";

2711 my ($ident, $from, $to) = ($1, $2, $2);

2712

2713 # Should start with a space.

2714 $to =~ s/^(\S)/ $1/;

2715 # Should not end with a space.

2716 $to =~ s/\s+$//;

2717 # '*'s should not have spaces between.

2718 while ($to =~ s/\*\s+\*/\*\*/) {

2719 }

2720

2721 ## print "1: from<$from> to<$to> ident<$ident>\n";

2722 if ($from ne $to) {

2723 if (ERROR("POINTER_LOCATION",

2724 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&

2725 $fix) {

2726 my $sub_from = $ident;

2727 my $sub_to = $ident;

2728 $sub_to =~ s/\Q$from\E/$to/;

2729 $fixed[$linenr - 1] =~

2730 s@\Q$sub_from\E@$sub_to@;

2731 }

2732 }

2733 }

2734 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {

2735 #print "BB<$1>\n";

2736 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);

2737

2738 # Should start with a space.

2739 $to =~ s/^(\S)/ $1/;

2740 # Should not end with a space.

2741 $to =~ s/\s+$//;

2742 # '*'s should not have spaces between.

2743 while ($to =~ s/\*\s+\*/\*\*/) {

2744 }

2745 # Modifiers should have spaces.

2746 $to =~ s/(\b$Modifier$)/$1 /;

2747

2748 ## print "2: from<$from> to<$to> ident<$ident>\n";

2749 if ($from ne $to && $ident !~ /^$Modifier$/) {

2750 if (ERROR("POINTER_LOCATION",

2751 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&

2752 $fix) {

2753

2754 my $sub_from = $match;

2755 my $sub_to = $match;

2756 $sub_to =~ s/\Q$from\E/$to/;

2757 $fixed[$linenr - 1] =~

2758 s@\Q$sub_from\E@$sub_to@;

2759 }

2760 }

2761 }

2762

2763 # # no BUG() or BUG_ON()

2764 # if ($line =~ /\b(BUG|BUG_ON)\b/) {

2765 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";

2766 # print "$herecurr";

2767 # $clean = 0;

2768 # }

2769

2770 if ($line =~ /\bLINUX_VERSION_CODE\b/) {

2771 WARN("LINUX_VERSION_CODE",

2772 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);

2773 }

2774

2775 # check for uses of printk_ratelimit

2776 if ($line =~ /\bprintk_ratelimit\s*\(/) {

2777 WARN("PRINTK_RATELIMITED",

2778 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);

2779 }

2780

2781 # printk should use KERN_* levels. Note that follow on printk's on the

2782 # same line do not need a level, so we use the current block context

2783 # to try and find and validate the current printk. In summary the current

2784 # printk includes all preceding printk's which have no newline on the end.

2785 # we assume the first bad printk is the one to report.

2786 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {

2787 my $ok = 0;

2788 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {

2789 #print "CHECK<$lines[$ln - 1]\n";

2790 # we have a preceding printk if it ends

2791 # with "\n" ignore it, else it is to blame

2792 if ($lines[$ln - 1] =~ m{\bprintk\(}) {

2793 if ($rawlines[$ln - 1] !~ m{\\n"}) {

2794 $ok = 1;

2795 }

2796 last;

2797 }

2798 }

2799 if ($ok == 0) {

2800 WARN("PRINTK_WITHOUT_KERN_LEVEL",

2801 "printk() should include KERN_ facility level\n" . $herecurr);

2802 }

2803 }

2804

2805 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {

2806 my $orig = $1;

2807 my $level = lc($orig);

2808 $level = "warn" if ($level eq "warning");

2809 my $level2 = $level;

2810 $level2 = "dbg" if ($level eq "debug");

2811 WARN("PREFER_PR_LEVEL",

2812 "Prefer netdev_$level2(netdev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);

2813 }

2814

2815 if ($line =~ /\bpr_warning\s*\(/) {

2816 if (WARN("PREFER_PR_LEVEL",

2817 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&

2818 $fix) {

2819 $fixed[$linenr - 1] =~

2820 s/\bpr_warning\b/pr_warn/;

2821 }

2822 }

2823

2824 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {

2825 my $orig = $1;

2826 my $level = lc($orig);

2827 $level = "warn" if ($level eq "warning");

2828 $level = "dbg" if ($level eq "debug");

2829 WARN("PREFER_DEV_LEVEL",

2830 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);

2831 }

2832

2833 # function brace can't be on same line, except for #defines of do while,

2834 # or if closed on same line

2835 if (($line=~/$Type\s*$Ident$.*$.*\s{/) and

2836 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {

2837 ERROR("OPEN_BRACE",

2838 "open brace '{' following function declarations go on the next line\n" . $herecurr);

2839 }

2840

2841 # open braces for enum, union and struct go on the same line.

2842 if ($line =~ /^.\s*{/ &&

2843 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {

2844 ERROR("OPEN_BRACE",

2845 "open brace '{' following $1 go on the same line\n" . $hereprev);

2846 }

2847

2848 # missing space after union, struct or enum definition

2849 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {

2850 if (WARN("SPACING",

2851 "missing space after $1 definition\n" . $herecurr) &&

2852 $fix) {

2853 $fixed[$linenr - 1] =~

2854 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;

2855 }

2856 }

2857

2858 # Function pointer declarations

2859 # check spacing between type, funcptr, and args

2860 # canonical declaration is "type (*funcptr)(args...)"

2861 if ($line =~ /^.\s*($Declare)$(\s*)\*(\s*)($Ident)(\s*)$(\s*)\(/) {

2862 my $declare = $1;

2863 my $pre_pointer_space = $2;

2864 my $post_pointer_space = $3;

2865 my $funcname = $4;

2866 my $post_funcname_space = $5;

2867 my $pre_args_space = $6;

2868

2869 # the $Declare variable will capture all spaces after the type

2870 # so check it for a missing trailing missing space but pointer return types

2871 # don't need a space so don't warn for those.

2872 my $post_declare_space = "";

2873 if ($declare =~ /(\s+)$/) {

2874 $post_declare_space = $1;

2875 $declare = rtrim($declare);

2876 }

2877 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {

2878 WARN("SPACING",

2879 "missing space after return type\n" . $herecurr);

2880 $post_declare_space = " ";

2881 }

2882

2883 # unnecessary space "type (*funcptr)(args...)"

2884 # This test is not currently implemented because these declarations are

2885 # equivalent to

2886 # int foo(int bar, ...)

2887 # and this is form shouldn't/doesn't generate a checkpatch warning.

2888 #

2889 # elsif ($declare =~ /\s{2,}$/) {

2890 # WARN("SPACING",

2891 # "Multiple spaces after return type\n" . $herecurr);

2892 # }

2893

2894 # unnecessary space "type ( *funcptr)(args...)"

2895 if (defined $pre_pointer_space &&

2896 $pre_pointer_space =~ /^\s/) {

2897 WARN("SPACING",

2898 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);

2899 }

2900

2901 # unnecessary space "type (* funcptr)(args...)"

2902 if (defined $post_pointer_space &&

2903 $post_pointer_space =~ /^\s/) {

2904 WARN("SPACING",

2905 "Unnecessary space before function pointer name\n" . $herecurr);

2906 }

2907

2908 # unnecessary space "type (*funcptr )(args...)"

2909 if (defined $post_funcname_space &&

2910 $post_funcname_space =~ /^\s/) {

2911 WARN("SPACING",

2912 "Unnecessary space after function pointer name\n" . $herecurr);

2913 }

2914

2915 # unnecessary space "type (*funcptr) (args...)"

2916 if (defined $pre_args_space &&

2917 $pre_args_space =~ /^\s/) {

2918 WARN("SPACING",

2919 "Unnecessary space before function pointer arguments\n" . $herecurr);

2920 }

2921

2922 if (show_type("SPACING") && $fix) {

2923 $fixed[$linenr - 1] =~

2924 s/^(.\s*)$Declare\s*$\s*\*\s*$Ident\s*$\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;

2925 }

2926 }

2927

2928 # check for spacing round square brackets; allowed:

2929 # 1. with a type on the left -- int [] a;

2930 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,

2931 # 3. inside a curly brace -- = { [0...10] = 5 }

2932 while ($line =~ /(.*?\s)\[/g) {

2933 my ($where, $prefix) = ($-[1], $1);

2934 if ($prefix !~ /$Type\s+$/ &&

2935 ($where != 0 || $prefix !~ /^.\s+$/) &&

2936 $prefix !~ /[{,]\s+$/) {

2937 if (ERROR("BRACKET_SPACE",

2938 "space prohibited before open square bracket '['\n" . $herecurr) &&

2939 $fix) {

2940 $fixed[$linenr - 1] =~

2941 s/^(\+.*?)\s+\[/$1\[/;

2942 }

2943 }

2944 }

2945

2946 # check for spaces between functions and their parentheses.

2947 while ($line =~ /($Ident)\s+\(/g) {

2948 my $name = $1;

2949 my $ctx_before = substr($line, 0, $-[1]);

2950 my $ctx = "$ctx_before$name";

2951

2952 # Ignore those directives where spaces _are_ permitted.

2953 if ($name =~ /^(?:

2955 volatile|__volatile__|

2956 __attribute__|format|__extension__|

2957 asm|__asm__)$/x)

2958 {

2959 # cpp #define statements have non-optional spaces, ie

2960 # if there is a space between the name and the open

2961 # parenthesis it is simply not a parameter group.

2962 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {

2963

2964 # cpp #elif statement condition may start with a (

2965 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {

2966

2967 # If this whole things ends with a type its most

2968 # likely a typedef for a function.

2969 } elsif ($ctx =~ /$Type$/) {

2970

2971 } else {

2972 if (WARN("SPACING",

2973 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&

2974 $fix) {

2975 $fixed[$linenr - 1] =~

2976 s/\b$name\s+\(/$name\(/;

2977 }

2978 }

2979 }

2980

2981 # Check operator spacing.

2982 if (!($line=~/\#\s*include/)) {

2983 my $fixed_line = "";

2984 my $line_fixed = 0;

2985

2986 my $ops = qr{

2987 <<=|>>=|<=|>=|==|!=|

2988 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|

2989 =>|->|<<|>>|<|>|=|!|~|

2990 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|

2991 \?:|\?|:

2992 }x;

2993 my @elements = split(/($ops|;)/, $opline);

2994

2995 ## print("element count: <" . $#elements . ">\n");

2996 ## foreach my $el (@elements) {

2997 ## print("el: <$el>\n");

2998 ## }

2999

3000 my @fix_elements = ();

3001 my $off = 0;

3002

3003 foreach my $el (@elements) {

3004 push(@fix_elements, substr($rawline, $off, length($el)));

3005 $off += length($el);

3006 }

3007

3008 $off = 0;

3009

3010 my $blank = copy_spacing($opline);

3011 my $last_after = -1;

3012

3013 for (my $n = 0; $n < $#elements; $n += 2) {

3014

3015 my $good = $fix_elements[$n] . $fix_elements[$n + 1];

3016

3017 ## print("n: <$n> good: <$good>\n");

3018

3019 $off += length($elements[$n]);

3020

3021 # Pick up the preceding and succeeding characters.

3022 my $ca = substr($opline, 0, $off);

3023 my $cc = '';

3024 if (length($opline) >= ($off + length($elements[$n + 1]))) {

3025 $cc = substr($opline, $off + length($elements[$n + 1]));

3026 }

3027 my $cb = "$ca$;$cc";

3028

3029 my $a = '';

3030 $a = 'V' if ($elements[$n] ne '');

3031 $a = 'W' if ($elements[$n] =~ /\s$/);

3032 $a = 'C' if ($elements[$n] =~ /$;$/);

3033 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);

3034 $a = 'O' if ($elements[$n] eq '');

3035 $a = 'E' if ($ca =~ /^\s*$/);

3036

3037 my $op = $elements[$n + 1];

3038

3039 my $c = '';

3040 if (defined $elements[$n + 2]) {

3041 $c = 'V' if ($elements[$n + 2] ne '');

3042 $c = 'W' if ($elements[$n + 2] =~ /^\s/);

3043 $c = 'C' if ($elements[$n + 2] =~ /^$;/);

3044 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);

3045 $c = 'O' if ($elements[$n + 2] eq '');

3046 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);

3047 } else {

3048 $c = 'E';

3049 }

3050

3051 my $ctx = "${a}x${c}";

3052

3053 my $at = "(ctx:$ctx)";

3054

3055 my $ptr = substr($blank, 0, $off) . "^";

3056 my $hereptr = "$hereline$ptr\n";

3057

3058 # Pull out the value of this operator.

3059 my $op_type = substr($curr_values, $off + 1, 1);

3060

3061 # Get the full operator variant.

3062 my $opv = $op . substr($curr_vars, $off, 1);

3063

3064 # Ignore operators passed as parameters.

3065 if ($op_type ne 'V' &&

3066 $ca =~ /\s$/ && $cc =~ /^\s*,/) {

3067

3068 # # Ignore comments

3069 # } elsif ($op =~ /^$;+$/) {

3070

3071 # ; should have either the end of line or a space or \ after it

3072 } elsif ($op eq ';') {

3073 if ($ctx !~ /.x[WEBC]/ &&

3074 $cc !~ /^\\/ && $cc !~ /^;/) {

3075 if (ERROR("SPACING",

3076 "space required after that '$op' $at\n" . $hereptr)) {

3077 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";

3078 $line_fixed = 1;

3079 }

3080 }

3081

3082 # // is a comment

3083 } elsif ($op eq '//') {

3084

3085 # No spaces for:

3086 # ->

3087 # : when part of a bitfield

3088 } elsif ($op eq '->' || $opv eq ':B') {

3089 if ($ctx =~ /Wx.|.xW/) {

3090 if (ERROR("SPACING",

3091 "spaces prohibited around that '$op' $at\n" . $hereptr)) {

3092 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);

3093 if (defined $fix_elements[$n + 2]) {

3094 $fix_elements[$n + 2] =~ s/^\s+//;

3095 }

3096 $line_fixed = 1;

3097 }

3098 }

3099

3100 # , must have a space on the right.

3101 } elsif ($op eq ',') {

3102 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {

3103 if (ERROR("SPACING",

3104 "space required after that '$op' $at\n" . $hereptr)) {

3105 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";

3106 $line_fixed = 1;

3107 $last_after = $n;

3108 }

3109 }

3110

3111 # '*' as part of a type definition -- reported already.

3112 } elsif ($opv eq '*_') {

3113 #warn "'*' is part of type\n";

3114

3115 # unary operators should have a space before and

3116 # none after. May be left adjacent to another

3117 # unary operator, or a cast

3118 } elsif ($op eq '!' || $op eq '~' ||

3119 $opv eq '*U' || $opv eq '-U' ||

3120 $opv eq '&U' || $opv eq '&&U') {

3121 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {

3122 if (ERROR("SPACING",

3123 "space required before that '$op' $at\n" . $hereptr)) {

3124 if ($n != $last_after + 2) {

3125 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);

3126 $line_fixed = 1;

3127 }

3128 }

3129 }

3130 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {

3131 # A unary '*' may be const

3132

3133 } elsif ($ctx =~ /.xW/) {

3134 if (ERROR("SPACING",

3135 "space prohibited after that '$op' $at\n" . $hereptr)) {

3136 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);

3137 if (defined $fix_elements[$n + 2]) {

3138 $fix_elements[$n + 2] =~ s/^\s+//;

3139 }

3140 $line_fixed = 1;

3141 }

3142 }

3143

3144 # unary ++ and unary -- are allowed no space on one side.

3145 } elsif ($op eq '++' or $op eq '--') {

3146 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {

3147 if (ERROR("SPACING",

3148 "space required one side of that '$op' $at\n" . $hereptr)) {

3149 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";

3150 $line_fixed = 1;

3151 }

3152 }

3153 if ($ctx =~ /Wx[BE]/ ||

3154 ($ctx =~ /Wx./ && $cc =~ /^;/)) {

3155 if (ERROR("SPACING",

3156 "space prohibited before that '$op' $at\n" . $hereptr)) {

3157 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);

3158 $line_fixed = 1;

3159 }

3160 }

3161 if ($ctx =~ /ExW/) {

3162 if (ERROR("SPACING",

3163 "space prohibited after that '$op' $at\n" . $hereptr)) {

3164 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);

3165 if (defined $fix_elements[$n + 2]) {

3166 $fix_elements[$n + 2] =~ s/^\s+//;

3167 }

3168 $line_fixed = 1;

3169 }

3170 }

3171

3172 # << and >> may either have or not have spaces both sides

3173 } elsif ($op eq '<<' or $op eq '>>' or

3174 $op eq '&' or $op eq '^' or $op eq '|' or

3175 $op eq '+' or $op eq '-' or

3176 $op eq '*' or $op eq '/' or

3177 $op eq '%')

3178 {

3179 if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {

3180 if (ERROR("SPACING",

3181 "need consistent spacing around '$op' $at\n" . $hereptr)) {

3182 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";

3183 if (defined $fix_elements[$n + 2]) {

3184 $fix_elements[$n + 2] =~ s/^\s+//;

3185 }

3186 $line_fixed = 1;

3187 }

3188 }

3189

3190 # A colon needs no spaces before when it is

3191 # terminating a case value or a label.

3192 } elsif ($opv eq ':C' || $opv eq ':L') {

3193 if ($ctx =~ /Wx./) {

3194 if (ERROR("SPACING",

3195 "space prohibited before that '$op' $at\n" . $hereptr)) {

3196 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);

3197 $line_fixed = 1;

3198 }

3199 }

3200

3201 # All the others need spaces both sides.

3202 } elsif ($ctx !~ /[EWC]x[CWE]/) {

3203 my $ok = 0;

3204

3205 # Ignore email addresses <foo@bar>

3206 if (($op eq '<' &&

3207 $cc =~ /^\S+\@\S+>/) ||

3208 ($op eq '>' &&

3209 $ca =~ /<\S+\@\S+$/))

3210 {

3211 $ok = 1;

3212 }

3213

3214 # messages are ERROR, but ?: are CHK

3215 if ($ok == 0) {

3216 my $msg_type = \&ERROR;

3217 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);

3218

3219 if (&{$msg_type}("SPACING",

3220 "spaces required around that '$op' $at\n" . $hereptr)) {

3221 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";

3222 if (defined $fix_elements[$n + 2]) {

3223 $fix_elements[$n + 2] =~ s/^\s+//;

3224 }

3225 $line_fixed = 1;

3226 }

3227 }

3228 }

3229 $off += length($elements[$n + 1]);

3230

3231 ## print("n: <$n> GOOD: <$good>\n");

3232

3233 $fixed_line = $fixed_line . $good;

3234 }

3235

3236 if (($#elements % 2) == 0) {

3237 $fixed_line = $fixed_line . $fix_elements[$#elements];

3238 }

3239

3240 if ($fix && $line_fixed && $fixed_line ne $fixed[$linenr - 1]) {

3241 $fixed[$linenr - 1] = $fixed_line;

3242 }

3243

3244

3245 }

3246

3247 # check for whitespace before a non-naked semicolon

3248 if ($line =~ /^\+.*\S\s+;\s*$/) {

3249 if (WARN("SPACING",

3250 "space prohibited before semicolon\n" . $herecurr) &&

3251 $fix) {

3252 1 while $fixed[$linenr - 1] =~

3253 s/^(\+.*\S)\s+;/$1;/;

3254 }

3255 }

3256

3257 # check for multiple assignments

3258 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {

3259 CHK("MULTIPLE_ASSIGNMENTS",

3260 "multiple assignments should be avoided\n" . $herecurr);

3261 }

3262

3263 ## # check for multiple declarations, allowing for a function declaration

3264 ## # continuation.

3265 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&

3266 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {

3267 ##

3268 ## # Remove any bracketed sections to ensure we do not

3269 ## # falsly report the parameters of functions.

3270 ## my $ln = $line;

3271 ## while ($ln =~ s/$[^\($]*\)//g) {

3272 ## }

3273 ## if ($ln =~ /,/) {

3274 ## WARN("MULTIPLE_DECLARATION",

3275 ## "declaring multiple variables together should be avoided\n" . $herecurr);

3276 ## }

3277 ## }

3278

3279 #need space before brace following if, while, etc

3280 if (($line =~ /$.*${/ && $line !~ /$$Type${/) ||

3281 $line =~ /do{/) {

3282 if (ERROR("SPACING",

3283 "space required before the open brace '{'\n" . $herecurr) &&

3284 $fix) {

3285 $fixed[$linenr - 1] =~ s/^(\+.*(?:do|\))){/$1 {/;

3286 }

3287 }

3288

3289 ## # check for blank lines before declarations

3290 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&

3291 ## $prevrawline =~ /^.\s*$/) {

3292 ## WARN("SPACING",

3293 ## "No blank lines before declarations\n" . $hereprev);

3294 ## }

3295 ##

3296

3297 # closing brace should have a space following it when it has anything

3298 # on the line

3299 if ($line =~ /}(?!(?:,|;|\)))\S/) {

3300 if (ERROR("SPACING",

3301 "space required after that close brace '}'\n" . $herecurr) &&

3302 $fix) {

3303 $fixed[$linenr - 1] =~

3304 s/}((?!(?:,|;|\)))\S)/} $1/;

3305 }

3306 }

3307

3308 # check spacing on square brackets

3309 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {

3310 if (ERROR("SPACING",

3311 "space prohibited after that open square bracket '['\n" . $herecurr) &&

3312 $fix) {

3313 $fixed[$linenr - 1] =~

3314 s/\[\s+/\[/;

3315 }

3316 }

3317 if ($line =~ /\s\]/) {

3318 if (ERROR("SPACING",

3319 "space prohibited before that close square bracket ']'\n" . $herecurr) &&

3320 $fix) {

3321 $fixed[$linenr - 1] =~

3322 s/\s+\]/\]/;

3323 }

3324 }

3325

3326 # check spacing on parentheses

3327 if ($line =~ /$\s/ && $line !~ /\(\s*(?:\$?$/ &&

3328 $line !~ /for\s*\(\s+;/) {

3329 if (ERROR("SPACING",

3330 "space prohibited after that open parenthesis '('\n" . $herecurr) &&

3331 $fix) {

3332 $fixed[$linenr - 1] =~

3333 s/\(\s+/\(/;

3334 }

3335 }

3336 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&

3337 $line !~ /for\s*$.*;\s+$/ &&

3338 $line !~ /:\s+\)/) {

3339 if (ERROR("SPACING",

3340 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&

3341 $fix) {

3342 $fixed[$linenr - 1] =~

3343 s/\s+\)/\)/;

3344 }

3345 }

3346

3347 #goto labels aren't indented, allow a single space however

3348 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and

3349 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {

3350 if (WARN("INDENTED_LABEL",

3351 "labels should not be indented\n" . $herecurr) &&

3352 $fix) {

3353 $fixed[$linenr - 1] =~

3354 s/^(.)\s+/$1/;

3355 }

3356 }

3357

3358 # Return is not a function.

3359 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {

3360 my $spacing = $1;

3361 if ($^V && $^V ge 5.10.0 &&

3362 $stat =~ /^.\s*return\s*$balanced_parens\s*;\s*$/) {

3363 ERROR("RETURN_PARENTHESES",

3364 "return is not a function, parentheses are not required\n" . $herecurr);

3365

3366 } elsif ($spacing !~ /\s+/) {

3367 ERROR("SPACING",

3368 "space required before the open parenthesis '('\n" . $herecurr);

3369 }

3370 }

3371

3372 # if statements using unnecessary parentheses - ie: if ((foo == bar))

3373 if ($^V && $^V ge 5.10.0 &&

3374 $line =~ /\bif\s*((?:\(\s*){2,})/) {

3375 my $openparens = $1;

3376 my $count = $openparens =~ tr@\(@\(@;

3377 my $msg = "";

3378 if ($line =~ /\bif\s*(?:$\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*$){$count,$count}/) {

3379 my $comp = $4; #Not $1 because of $LvalOrFunc

3380 $msg = " - maybe == should be = ?" if ($comp eq "==");

3381 WARN("UNNECESSARY_PARENTHESES",

3382 "Unnecessary parentheses$msg\n" . $herecurr);

3383 }

3384 }

3385

3386 # Return of what appears to be an errno should normally be -'ve

3387 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {

3388 my $name = $1;

3389 if ($name ne 'EOF' && $name ne 'ERROR') {

3390 WARN("USE_NEGATIVE_ERRNO",

3391 "return of an errno should typically be -ve (return -$1)\n" . $herecurr);

3392 }

3393 }

3394

3395 # Need a space before open parenthesis after if, while etc

3396 if ($line =~ /\b(if|while|for|switch)\(/) {

3397 if (ERROR("SPACING",

3398 "space required before the open parenthesis '('\n" . $herecurr) &&

3399 $fix) {

3400 $fixed[$linenr - 1] =~

3401 s/\b(if|while|for|switch)\(/$1 \(/;

3402 }

3403 }

3404

3405 # Check for illegal assignment in if conditional -- and check for trailing

3406 # statements after the conditional.

3407 if ($line =~ /do\s*(?!{)/) {

3408 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =

3409 ctx_statement_block($linenr, $realcnt, 0)

3410 if (!defined $stat);

3411 my ($stat_next) = ctx_statement_block($line_nr_next,

3412 $remain_next, $off_next);

3413 $stat_next =~ s/\n./\n /g;

3414 ##print "stat<$stat> stat_next<$stat_next>\n";

3415

3416 if ($stat_next =~ /^\s*while\b/) {

3417 # If the statement carries leading newlines,

3418 # then count those as offsets.

3419 my ($whitespace) =

3420 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);

3421 my $offset =

3422 statement_rawlines($whitespace) - 1;

3423

3424 $suppress_whiletrailers{$line_nr_next +

3425 $offset} = 1;

3426 }

3427 }

3428 if (!defined $suppress_whiletrailers{$linenr} &&

3429 defined($stat) && defined($cond) &&

3430 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {

3431 my ($s, $c) = ($stat, $cond);

3432

3433 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {

3434 ERROR("ASSIGN_IN_IF",

3435 "do not use assignment in if condition\n" . $herecurr);

3436 }

3437

3438 # Find out what is on the end of the line after the

3439 # conditional.

3440 substr($s, 0, length($c), '');

3441 $s =~ s/\n.*//g;

3442 $s =~ s/$;//g; # Remove any comments

3443 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&

3444 $c !~ /}\s*while\s*/)

3445 {

3446 # Find out how long the conditional actually is.

3447 my @newlines = ($c =~ /\n/gs);

3448 my $cond_lines = 1 + $#newlines;

3449 my $stat_real = '';

3450

3451 $stat_real = raw_line($linenr, $cond_lines)

3452 . "\n" if ($cond_lines);

3453 if (defined($stat_real) && $cond_lines > 1) {

3454 $stat_real = "[...]\n$stat_real";

3455 }

3456

3457 ERROR("TRAILING_STATEMENTS",

3458 "trailing statements should be on next line\n" . $herecurr . $stat_real);

3459 }

3460 }

3461

3462 # Check for bitwise tests written as boolean

3463 if ($line =~ /

3464 (?:

3465 (?:\[|\(|\&\&|\|\|)

3466 \s*0[xX][0-9]+\s*

3467 (?:\&\&|\|\|)

3468 |

3469 (?:\&\&|\|\|)

3470 \s*0[xX][0-9]+\s*

3471 (?:\&\&|\|\||\)|\])

3472 )/x)

3473 {

3474 WARN("HEXADECIMAL_BOOLEAN_TEST",

3475 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);

3476 }

3477

3478 # if and else should not have general statements after it

3479 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {

3480 my $s = $1;

3481 $s =~ s/$;//g; # Remove any comments

3482 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {

3483 ERROR("TRAILING_STATEMENTS",

3484 "trailing statements should be on next line\n" . $herecurr);

3485 }

3486 }

3487 # if should not continue a brace

3488 if ($line =~ /}\s*if\b/) {

3489 ERROR("TRAILING_STATEMENTS",

3490 "trailing statements should be on next line\n" .

3491 $herecurr);

3492 }

3493 # case and default should not have general statements after them

3494 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&

3495 $line !~ /\G(?:

3496 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|

3497 \s*return\s+

3498 )/xg)

3499 {

3500 ERROR("TRAILING_STATEMENTS",

3501 "trailing statements should be on next line\n" . $herecurr);

3502 }

3503

3504 # Check for }<nl>else {, these must be at the same

3505 # indent level to be relevant to each other.

3506 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and

3507 $previndent == $indent) {

3508 ERROR("ELSE_AFTER_BRACE",

3509 "else should follow close brace '}'\n" . $hereprev);

3510 }

3511

3512 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and

3513 $previndent == $indent) {

3514 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);

3515

3516 # Find out what is on the end of the line after the

3517 # conditional.

3518 substr($s, 0, length($c), '');

3519 $s =~ s/\n.*//g;

3520

3521 if ($s =~ /^\s*;/) {

3522 ERROR("WHILE_AFTER_BRACE",

3523 "while should follow close brace '}'\n" . $hereprev);

3524 }

3525 }

3526

3527 #Specific variable tests

3528 while ($line =~ m{($Constant|$Lval)}g) {

3529 my $var = $1;

3530

3531 #gcc binary extension

3532 if ($var =~ /^$Binary$/) {

3533 if (WARN("GCC_BINARY_CONSTANT",

3534 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&

3535 $fix) {

3536 my $hexval = sprintf("0x%x", oct($var));

3537 $fixed[$linenr - 1] =~

3538 s/\b$var\b/$hexval/;

3539 }

3540 }

3541

3542 #CamelCase

3543 if ($var !~ /^$Constant$/ &&

3544 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&

3545 #Ignore Page<foo> variants

3546 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&

3547 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)

3548 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {

3549 while ($var =~ m{($Ident)}g) {

3550 my $word = $1;

3551 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);

3552 if ($check) {

3553 seed_camelcase_includes();

3554 if (!$file && !$camelcase_file_seeded) {

3555 seed_camelcase_file($realfile);

3556 $camelcase_file_seeded = 1;

3557 }

3558 }

3559 if (!defined $camelcase{$word}) {

3560 $camelcase{$word} = 1;

3561 CHK("CAMELCASE",

3562 "Avoid CamelCase: <$word>\n" . $herecurr);

3563 }

3564 }

3565 }

3566 }

3567

3568 #no spaces allowed after \ in define

3569 if ($line =~ /\#\s*define.*\\\s+$/) {

3570 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",

3571 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&

3572 $fix) {

3573 $fixed[$linenr - 1] =~ s/\s+$//;

3574 }

3575 }

3576

3577 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)

3578 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {

3579 my $file = "$1.h";

3580 my $checkfile = "include/linux/$file";

3581 if (-f "$root/$checkfile" &&

3582 $realfile ne $checkfile &&

3583 $1 !~ /$allowed_asm_includes/)

3584 {

3585 if ($realfile =~ m{^arch/}) {

3586 CHK("ARCH_INCLUDE_LINUX",

3587 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);

3588 } else {

3589 WARN("INCLUDE_LINUX",

3590 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);

3591 }

3592 }

3593 }

3594

3595 # multi-statement macros should be enclosed in a do while loop, grab the

3596 # first statement and ensure its the whole macro if its not enclosed

3597 # in a known good container

3598 if ($realfile !~ m@/vmlinux.lds.h$@ &&

3599 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {

3600 my $ln = $linenr;

3601 my $cnt = $realcnt;

3602 my ($off, $dstat, $dcond, $rest);

3603 my $ctx = '';

3604 ($dstat, $dcond, $ln, $cnt, $off) =

3605 ctx_statement_block($linenr, $realcnt, 0);

3606 $ctx = $dstat;

3607 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";

3608 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";

3609

3610 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:$[^$]*\))?\s*//;

3611 $dstat =~ s/$;//g;

3612 $dstat =~ s/\\\n.//g;

3613 $dstat =~ s/^\s*//s;

3614 $dstat =~ s/\s*$//s;

3615

3616 # Flatten any parentheses and braces

3617 while ($dstat =~ s/$[^\($]*\)/1/ ||

3618 $dstat =~ s/\{[^\{\}]*\}/1/ ||

3619 $dstat =~ s/\[[^\[\]]*\]/1/)

3620 {

3621 }

3622

3623 # Flatten any obvious string concatentation.

3624 while ($dstat =~ s/("X*")\s*$Ident/$1/ ||

3625 $dstat =~ s/$Ident\s*("X*")/$1/)

3626 {

3627 }

3628

3629 my $exceptions = qr{

3630 $Declare|

3631 module_param_named|

3632 MODULE_PARM_DESC|

3633 DECLARE_PER_CPU|

3634 DEFINE_PER_CPU|

3635 __typeof__\(|

3636 union|

3637 struct|

3638 \.$Ident\s*=\s*|

3639 ^\"|\"$

3640 }x;

3641 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";

3642 if ($dstat ne '' &&

3643 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),

3644 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();

3645 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz

3646 $dstat !~ /^'X'$/ && # character constants

3647 $dstat !~ /$exceptions/ &&

3648 $dstat !~ /^\.$Ident\s*=/ && # .foo =

3649 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo

3650 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)

3651 $dstat !~ /^for\s*$Constant$/ && # for (...)

3652 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()

3653 $dstat !~ /^do\s*{/ && # do {...

3654 $dstat !~ /^\({/ && # ({...

3655 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)

3656 {

3657 $ctx =~ s/\n*$//;

3658 my $herectx = $here . "\n";

3659 my $cnt = statement_rawlines($ctx);

3660

3661 for (my $n = 0; $n < $cnt; $n++) {

3662 $herectx .= raw_line($linenr, $n) . "\n";

3663 }

3664

3665 if ($dstat =~ /;/) {

3666 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",

3667 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");

3668 } else {

3669 ERROR("COMPLEX_MACRO",

3670 "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");

3671 }

3672 }

3673

3674 # check for line continuations outside of #defines, preprocessor #, and asm

3675

3676 } else {

3677 if ($prevline !~ /^..*\\$/ &&

3678 $line !~ /^\+\s*\#.*\\$/ && # preprocessor

3679 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm

3680 $line =~ /^\+.*\\$/) {

3681 WARN("LINE_CONTINUATIONS",

3682 "Avoid unnecessary line continuations\n" . $herecurr);

3683 }

3684 }

3685

3686 # do {} while (0) macro tests:

3687 # single-statement macros do not need to be enclosed in do while (0) loop,

3688 # macro should not end with a semicolon

3689 if ($^V && $^V ge 5.10.0 &&

3690 $realfile !~ m@/vmlinux.lds.h$@ &&

3691 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {

3692 my $ln = $linenr;

3693 my $cnt = $realcnt;

3694 my ($off, $dstat, $dcond, $rest);

3695 my $ctx = '';

3696 ($dstat, $dcond, $ln, $cnt, $off) =

3697 ctx_statement_block($linenr, $realcnt, 0);

3698 $ctx = $dstat;

3699

3700 $dstat =~ s/\\\n.//g;

3701

3702 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*$\s*0\s*$\s*([;\s]*)\s*$/) {

3703 my $stmts = $2;

3704 my $semis = $3;

3705

3706 $ctx =~ s/\n*$//;

3707 my $cnt = statement_rawlines($ctx);

3708 my $herectx = $here . "\n";

3709

3710 for (my $n = 0; $n < $cnt; $n++) {

3711 $herectx .= raw_line($linenr, $n) . "\n";

3712 }

3713

3714 if (($stmts =~ tr/;/;/) == 1 &&

3715 $stmts !~ /^\s*(if|while|for|switch)\b/) {

3716 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",

3717 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");

3718 }

3719 if (defined $semis && $semis ne "") {

3720 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",

3721 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");

3722 }

3723 }

3724 }

3725

3726 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...

3727 # all assignments may have only one of the following with an assignment:

3728 # .

3729 # ALIGN(...)

3730 # VMLINUX_SYMBOL(...)

3731 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {

3732 WARN("MISSING_VMLINUX_SYMBOL",

3733 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);

3734 }

3735

3736 # check for redundant bracing round if etc

3737 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {

3738 my ($level, $endln, @chunks) =

3739 ctx_statement_full($linenr, $realcnt, 1);

3740 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";

3741 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";

3742 if ($#chunks > 0 && $level == 0) {

3743 my @allowed = ();

3744 my $allow = 0;

3745 my $seen = 0;

3746 my $herectx = $here . "\n";

3747 my $ln = $linenr - 1;

3748 for my $chunk (@chunks) {

3749 my ($cond, $block) = @{$chunk};

3750

3751 # If the condition carries leading newlines, then count those as offsets.

3752 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);

3753 my $offset = statement_rawlines($whitespace) - 1;

3754

3755 $allowed[$allow] = 0;

3756 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";

3757

3758 # We have looked at and allowed this specific line.

3759 $suppress_ifbraces{$ln + $offset} = 1;

3760

3761 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";

3762 $ln += statement_rawlines($block) - 1;

3763

3764 substr($block, 0, length($cond), '');

3765

3766 $seen++ if ($block =~ /^\s*{/);

3767

3768 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";

3769 if (statement_lines($cond) > 1) {

3770 #print "APW: ALLOWED: cond<$cond>\n";

3771 $allowed[$allow] = 1;

3772 }

3773 if ($block =~/\b(?:if|for|while)\b/) {

3774 #print "APW: ALLOWED: block<$block>\n";

3775 $allowed[$allow] = 1;

3776 }

3777 if (statement_block_size($block) > 1) {

3778 #print "APW: ALLOWED: lines block<$block>\n";

3779 $allowed[$allow] = 1;

3780 }

3781 $allow++;

3782 }

3783 if ($seen) {

3784 my $sum_allowed = 0;

3785 foreach (@allowed) {

3786 $sum_allowed += $_;

3787 }

3788 if ($sum_allowed == 0) {

3789 WARN("BRACES",

3790 "braces {} are not necessary for any arm of this statement\n" . $herectx);

3791 } elsif ($sum_allowed != $allow &&

3792 $seen != $allow) {

3793 CHK("BRACES",

3794 "braces {} should be used on all arms of this statement\n" . $herectx);

3795 }

3796 }

3797 }

3798 }

3799 if (!defined $suppress_ifbraces{$linenr - 1} &&

3800 $line =~ /\b(if|while|for|else)\b/) {

3801 my $allowed = 0;

3802

3803 # Check the pre-context.

3804 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {

3805 #print "APW: ALLOWED: pre<$1>\n";

3806 $allowed = 1;

3807 }

3808

3809 my ($level, $endln, @chunks) =

3810 ctx_statement_full($linenr, $realcnt, $-[0]);

3811

3812 # Check the condition.

3813 my ($cond, $block) = @{$chunks[0]};

3814 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";

3815 if (defined $cond) {

3816 substr($block, 0, length($cond), '');

3817 }

3818 if (statement_lines($cond) > 1) {

3819 #print "APW: ALLOWED: cond<$cond>\n";

3820 $allowed = 1;

3821 }

3822 if ($block =~/\b(?:if|for|while)\b/) {

3823 #print "APW: ALLOWED: block<$block>\n";

3824 $allowed = 1;

3825 }

3826 if (statement_block_size($block) > 1) {

3827 #print "APW: ALLOWED: lines block<$block>\n";

3828 $allowed = 1;

3829 }

3830 # Check the post-context.

3831 if (defined $chunks[1]) {

3832 my ($cond, $block) = @{$chunks[1]};

3833 if (defined $cond) {

3834 substr($block, 0, length($cond), '');

3835 }

3836 if ($block =~ /^\s*\{/) {

3837 #print "APW: ALLOWED: chunk-1 block<$block>\n";

3838 $allowed = 1;

3839 }

3840 }

3841 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {

3842 my $herectx = $here . "\n";

3843 my $cnt = statement_rawlines($block);

3844

3845 for (my $n = 0; $n < $cnt; $n++) {

3846 $herectx .= raw_line($linenr, $n) . "\n";

3847 }

3848

3849 WARN("BRACES",

3850 "braces {} are not necessary for single statement blocks\n" . $herectx);

3851 }

3852 }

3853

3854 # check for unnecessary blank lines around braces

3855 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {

3856 CHK("BRACES",

3857 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);

3858 }

3859 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {

3860 CHK("BRACES",

3861 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);

3862 }

3863

3864 # no volatiles please

3865 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};

3866 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {

3867 WARN("VOLATILE",

3868 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);

3869 }

3870

3871 # warn about #if 0

3872 if ($line =~ /^.\s*\#\s*if\s+0\b/) {

3873 CHK("REDUNDANT_CODE",

3874 "if this code is redundant consider removing it\n" .

3875 $herecurr);

3876 }

3877

3878 # check for needless "if (<foo>) fn(<foo>)" uses

3879 if ($prevline =~ /\bif\s*$\s*($Lval)\s*$/) {

3880 my $expr = '\s*$\s*' . quotemeta($1) . '\s*$\s*;';

3881 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {

3882 WARN('NEEDLESS_IF',

3883 "$1(NULL) is safe this check is probably not required\n" . $hereprev);

3884 }

3885 }

3886

3887 # check for bad placement of section $InitAttribute (e.g.: __initdata)

3888 if ($line =~ /(\b$InitAttribute\b)/) {

3889 my $attr = $1;

3890 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {

3891 my $ptr = $1;

3892 my $var = $2;

3893 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&

3894 ERROR("MISPLACED_INIT",

3895 "$attr should be placed after $var\n" . $herecurr)) ||

3896 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&

3897 WARN("MISPLACED_INIT",

3898 "$attr should be placed after $var\n" . $herecurr))) &&

3899 $fix) {

3900 $fixed[$linenr - 1] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;

3901 }

3902 }

3903 }

3904

3905 # check for $InitAttributeData (ie: __initdata) with const

3906 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {

3907 my $attr = $1;

3908 $attr =~ /($InitAttributePrefix)(.*)/;

3909 my $attr_prefix = $1;

3910 my $attr_type = $2;

3911 if (ERROR("INIT_ATTRIBUTE",

3912 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&

3913 $fix) {

3914 $fixed[$linenr - 1] =~

3915 s/$InitAttributeData/${attr_prefix}initconst/;

3916 }

3917 }

3918

3919 # check for $InitAttributeConst (ie: __initconst) without const

3920 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {

3921 my $attr = $1;

3922 if (ERROR("INIT_ATTRIBUTE",

3923 "Use of $attr requires a separate use of const\n" . $herecurr) &&

3924 $fix) {

3925 my $lead = $fixed[$linenr - 1] =~

3926 /(^\+\s*(?:static\s+))/;

3927 $lead = rtrim($1);

3928 $lead = "$lead " if ($lead !~ /^\+$/);

3929 $lead = "${lead}const ";

3930 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;

3931 }

3932 }

3933

3934 # don't use __constant_<foo> functions outside of include/uapi/

3935 if ($realfile !~ m@^include/uapi/@ &&

3936 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {

3937 my $constant_func = $1;

3938 my $func = $constant_func;

3939 $func =~ s/^__constant_//;

3940 if (WARN("CONSTANT_CONVERSION",

3941 "$constant_func should be $func\n" . $herecurr) &&

3942 $fix) {

3943 $fixed[$linenr - 1] =~ s/\b$constant_func\b/$func/g;

3944 }

3945 }

3946

3947 # prefer usleep_range over udelay

3948 if ($line =~ /\budelay\s*$\s*(\d+)\s*$/) {

3949 my $delay = $1;

3950 # ignore udelay's < 10, however

3951 if (! ($delay < 10) ) {

3952 CHK("USLEEP_RANGE",

3953 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);

3954 }

3955 if ($delay > 2000) {

3956 WARN("LONG_UDELAY",

3957 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);

3958 }

3959 }

3960

3961 # warn about unexpectedly long msleep's

3962 if ($line =~ /\bmsleep\s*$(\d+)$;/) {

3963 if ($1 < 20) {

3964 WARN("MSLEEP",

3965 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);

3966 }

3967 }

3968

3969 # check for comparisons of jiffies

3970 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {

3971 WARN("JIFFIES_COMPARISON",

3972 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);

3973 }

3974

3975 # check for comparisons of get_jiffies_64()

3976 if ($line =~ /\bget_jiffies_64\s*$\s*$\s*$Compare|$Compare\s*get_jiffies_64\s*$\s*$/) {

3977 WARN("JIFFIES_COMPARISON",

3978 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);

3979 }

3980

3981 # warn about #ifdefs in C files

3982 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {

3983 # print "#ifdef in C files should be avoided\n";

3984 # print "$herecurr";

3985 # $clean = 0;

3986 # }

3987

3988 # warn about spacing in #ifdefs

3989 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {

3990 if (ERROR("SPACING",

3991 "exactly one space required after that #$1\n" . $herecurr) &&

3992 $fix) {

3993 $fixed[$linenr - 1] =~

3994 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;

3995 }

3996

3997 }

3998

3999 # check for spinlock_t definitions without a comment.

4000 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||

4001 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {

4002 my $which = $1;

4003 if (!ctx_has_comment($first_line, $linenr)) {

4004 CHK("UNCOMMENTED_DEFINITION",

4005 "$1 definition without comment\n" . $herecurr);

4006 }

4007 }

4008 # check for memory barriers without a comment.

4009 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {

4010 if (!ctx_has_comment($first_line, $linenr)) {

4011 WARN("MEMORY_BARRIER",

4012 "memory barrier without comment\n" . $herecurr);

4013 }

4014 }

4015 # check of hardware specific defines

4016 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {

4017 CHK("ARCH_DEFINES",

4018 "architecture specific defines should be avoided\n" . $herecurr);

4019 }

4020

4021 # Check that the storage class is at the beginning of a declaration

4022 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {

4023 WARN("STORAGE_CLASS",

4024 "storage class should be at the beginning of the declaration\n" . $herecurr)

4025 }

4026

4027 # check the location of the inline attribute, that it is between

4028 # storage class and type.

4029 if ($line =~ /\b$Type\s+$Inline\b/ ||

4030 $line =~ /\b$Inline\s+$Storage\b/) {

4031 ERROR("INLINE_LOCATION",

4032 "inline keyword should sit between storage class and type\n" . $herecurr);

4033 }

4034

4035 # Check for __inline__ and __inline, prefer inline

4036 if ($realfile !~ m@\binclude/uapi/@ &&

4037 $line =~ /\b(__inline__|__inline)\b/) {

4038 if (WARN("INLINE",

4039 "plain inline is preferred over $1\n" . $herecurr) &&

4040 $fix) {

4041 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/;

4042

4043 }

4044 }

4045

4046 # Check for __attribute__ packed, prefer __packed

4047 if ($realfile !~ m@\binclude/uapi/@ &&

4048 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {

4049 WARN("PREFER_PACKED",

4050 "__packed is preferred over __attribute__((packed))\n" . $herecurr);

4051 }

4052

4053 # Check for __attribute__ aligned, prefer __aligned

4054 if ($realfile !~ m@\binclude/uapi/@ &&

4055 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {

4056 WARN("PREFER_ALIGNED",

4057 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);

4058 }

4059

4060 # Check for __attribute__ format(printf, prefer __printf

4061 if ($realfile !~ m@\binclude/uapi/@ &&

4062 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {

4063 if (WARN("PREFER_PRINTF",

4064 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&

4065 $fix) {

4066 $fixed[$linenr - 1] =~ s/\b__attribute__\s*$\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)$\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;

4067

4068 }

4069 }

4070

4071 # Check for __attribute__ format(scanf, prefer __scanf

4072 if ($realfile !~ m@\binclude/uapi/@ &&

4073 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {

4074 if (WARN("PREFER_SCANF",

4075 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&

4076 $fix) {

4077 $fixed[$linenr - 1] =~ s/\b__attribute__\s*$\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)$\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;

4078 }

4079 }

4080

4081 # check for sizeof(&)

4082 if ($line =~ /\bsizeof\s*\(\s*\&/) {

4083 WARN("SIZEOF_ADDRESS",

4084 "sizeof(& should be avoided\n" . $herecurr);

4085 }

4086

4087 # check for sizeof without parenthesis

4088 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {

4089 if (WARN("SIZEOF_PARENTHESIS",

4090 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&

4091 $fix) {

4092 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;

4093 }

4094 }

4095

4096 # check for line continuations in quoted strings with odd counts of "

4097 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {

4098 WARN("LINE_CONTINUATIONS",

4099 "Avoid line continuations in quoted strings\n" . $herecurr);

4100 }

4101

4102 # check for struct spinlock declarations

4103 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {

4104 WARN("USE_SPINLOCK_T",

4105 "struct spinlock should be spinlock_t\n" . $herecurr);

4106 }

4107

4108 # check for seq_printf uses that could be seq_puts

4109 if ($sline =~ /\bseq_printf\s*$.*"\s*$\s*;\s*$/) {

4110 my $fmt = get_quoted_string($line, $rawline);

4111 if ($fmt ne "" && $fmt !~ /[^\\]\%/) {

4112 if (WARN("PREFER_SEQ_PUTS",

4113 "Prefer seq_puts to seq_printf\n" . $herecurr) &&

4114 $fix) {

4115 $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/;

4116 }

4117 }

4118 }

4119

4120 # Check for misused memsets

4121 if ($^V && $^V ge 5.10.0 &&

4122 defined $stat &&

4123 $stat =~ /^\+(?:.*?)\bmemset\s*$\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*$/s) {

4124

4125 my $ms_addr = $2;

4126 my $ms_val = $7;

4127 my $ms_size = $12;

4128

4129 if ($ms_size =~ /^(0x|)0$/i) {

4130 ERROR("MEMSET",

4131 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");

4132 } elsif ($ms_size =~ /^(0x|)1$/i) {

4133 WARN("MEMSET",

4134 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");

4135 }

4136 }

4137

4138 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)

4139 if ($^V && $^V ge 5.10.0 &&

4140 $line =~ /^\+(?:.*?)\bmemcpy\s*$\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*$/s) {

4141 if (WARN("PREFER_ETHER_ADDR_COPY",

4142 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&

4143 $fix) {

4144 $fixed[$linenr - 1] =~ s/\bmemcpy\s*$\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*$/ether_addr_copy($2, $7)/;

4145 }

4146 }

4147

4148 # typecasts on min/max could be min_t/max_t

4149 if ($^V && $^V ge 5.10.0 &&

4150 defined $stat &&

4151 $stat =~ /^\+(?:.*?)\b(min|max)\s*$\s*$FuncArg\s*,\s*$FuncArg\s*$/) {

4152 if (defined $2 || defined $7) {

4153 my $call = $1;

4154 my $cast1 = deparenthesize($2);

4155 my $arg1 = $3;

4156 my $cast2 = deparenthesize($7);

4157 my $arg2 = $8;

4158 my $cast;

4159

4160 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {

4161 $cast = "$cast1 or $cast2";

4162 } elsif ($cast1 ne "") {

4163 $cast = $cast1;

4164 } else {

4165 $cast = $cast2;

4166 }

4167 WARN("MINMAX",

4168 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");

4169 }

4170 }

4171

4172 # check usleep_range arguments

4173 if ($^V && $^V ge 5.10.0 &&

4174 defined $stat &&

4175 $stat =~ /^\+(?:.*?)\busleep_range\s*$\s*($FuncArg)\s*,\s*($FuncArg)\s*$/) {

4176 my $min = $1;

4177 my $max = $7;

4178 if ($min eq $max) {

4179 WARN("USLEEP_RANGE",

4180 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");

4181 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&

4182 $min > $max) {

4183 WARN("USLEEP_RANGE",

4184 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");

4185 }

4186 }

4187

4188 # check for naked sscanf

4189 if ($^V && $^V ge 5.10.0 &&

4190 defined $stat &&

4191 $stat =~ /\bsscanf\b/ &&

4192 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&

4193 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&

4194 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {

4195 my $lc = $stat =~ tr@\n@@;

4196 $lc = $lc + $linenr;

4197 my $stat_real = raw_line($linenr, 0);

4198 for (my $count = $linenr + 1; $count <= $lc; $count++) {

4199 $stat_real = $stat_real . "\n" . raw_line($count, 0);

4200 }

4201 WARN("NAKED_SSCANF",

4202 "unchecked sscanf return value\n" . "$here\n$stat_real\n");

4203 }

4204

4205 # check for new externs in .h files.

4206 if ($realfile =~ /\.h$/ &&

4207 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {

4208 if (CHK("AVOID_EXTERNS",

4209 "extern prototypes should be avoided in .h files\n" . $herecurr) &&

4210 $fix) {

4211 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;

4212 }

4213 }

4214

4215 # check for new externs in .c files.

4216 if ($realfile =~ /\.c$/ && defined $stat &&

4217 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)

4218 {

4219 my $function_name = $1;

4220 my $paren_space = $2;

4221

4222 my $s = $stat;

4223 if (defined $cond) {

4224 substr($s, 0, length($cond), '');

4225 }

4226 if ($s =~ /^\s*;/ &&

4227 $function_name ne 'uninitialized_var')

4228 {

4229 WARN("AVOID_EXTERNS",

4230 "externs should be avoided in .c files\n" . $herecurr);

4231 }

4232

4233 if ($paren_space =~ /\n/) {

4234 WARN("FUNCTION_ARGUMENTS",

4235 "arguments for function declarations should follow identifier\n" . $herecurr);

4236 }

4237

4238 } elsif ($realfile =~ /\.c$/ && defined $stat &&

4239 $stat =~ /^.\s*extern\s+/)

4240 {

4241 WARN("AVOID_EXTERNS",

4242 "externs should be avoided in .c files\n" . $herecurr);

4243 }

4244

4245 # checks for new __setup's

4246 if ($rawline =~ /\b__setup\("([^"]*)"/) {

4247 my $name = $1;

4248

4249 if (!grep(/$name/, @setup_docs)) {

4250 CHK("UNDOCUMENTED_SETUP",

4251 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);

4252 }

4253 }

4254

4255 # check for pointless casting of kmalloc return

4256 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {

4257 WARN("UNNECESSARY_CASTS",

4258 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);

4259 }

4260

4261 # alloc style

4262 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)

4263 if ($^V && $^V ge 5.10.0 &&

4264 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*$\s*(sizeof\s*\(\s*struct\s+$Lval\s*$)/) {

4265 CHK("ALLOC_SIZEOF_STRUCT",

4266 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);

4267 }

4268

4269 # check for krealloc arg reuse

4270 if ($^V && $^V ge 5.10.0 &&

4271 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {

4272 WARN("KREALLOC_ARG_REUSE",

4273 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);

4274 }

4275

4276 # check for alloc argument mismatch

4277 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {

4278 WARN("ALLOC_ARRAY_ARGS",

4279 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);

4280 }

4281

4282 # check for GFP_NOWAIT use

4283 if ($line =~ /\b__GFP_NOFAIL\b/) {

4284 WARN("__GFP_NOFAIL",

4285 "Use of __GFP_NOFAIL is deprecated, no new users should be added\n" . $herecurr);

4286 }

4287

4288 # check for multiple semicolons

4289 if ($line =~ /;\s*;\s*$/) {

4290 if (WARN("ONE_SEMICOLON",

4291 "Statements terminations use 1 semicolon\n" . $herecurr) &&

4292 $fix) {

4293 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g;

4294 }

4295 }

4296

4297 # check for case / default statements not preceeded by break/fallthrough/switch

4298 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {

4299 my $has_break = 0;

4300 my $has_statement = 0;

4301 my $count = 0;

4302 my $prevline = $linenr;

4303 while ($prevline > 1 && $count < 3 && !$has_break) {

4304 $prevline--;

4305 my $rline = $rawlines[$prevline - 1];

4306 my $fline = $lines[$prevline - 1];

4307 last if ($fline =~ /^\@\@/);

4308 next if ($fline =~ /^\-/);

4309 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);

4310 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);

4311 next if ($fline =~ /^.[\s$;]*$/);

4312 $has_statement = 1;

4313 $count++;

4314 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);

4315 }

4316 if (!$has_break && $has_statement) {

4317 WARN("MISSING_BREAK",

4318 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);

4319 }

4320 }

4321

4322 # check for switch/default statements without a break;

4323 if ($^V && $^V ge 5.10.0 &&

4324 defined $stat &&

4325 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {

4326 my $ctx = '';

4327 my $herectx = $here . "\n";

4328 my $cnt = statement_rawlines($stat);

4329 for (my $n = 0; $n < $cnt; $n++) {

4330 $herectx .= raw_line($linenr, $n) . "\n";

4331 }

4332 WARN("DEFAULT_NO_BREAK",

4333 "switch default: should use break\n" . $herectx);

4334 }

4335

4336 # check for gcc specific __FUNCTION__

4337 if ($line =~ /\b__FUNCTION__\b/) {

4338 if (WARN("USE_FUNC",

4339 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&

4340 $fix) {

4341 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g;

4342 }

4343 }

4344

4345 # check for use of yield()

4346 if ($line =~ /\byield\s*$\s*$/) {

4347 WARN("YIELD",

4348 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);

4349 }

4350

4351 # check for comparisons against true and false

4352 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {

4353 my $lead = $1;

4354 my $arg = $2;

4355 my $test = $3;

4356 my $otype = $4;

4357 my $trail = $5;

4358 my $op = "!";

4359

4360 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);

4361

4362 my $type = lc($otype);

4363 if ($type =~ /^(?:true|false)$/) {

4364 if (("$test" eq "==" && "$type" eq "true") ||

4365 ("$test" eq "!=" && "$type" eq "false")) {

4366 $op = "";

4367 }

4368

4369 CHK("BOOL_COMPARISON",

4370 "Using comparison to $otype is error prone\n" . $herecurr);

4371

4372 ## maybe suggesting a correct construct would better

4373 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);

4374

4375 }

4376 }

4377

4378 # check for semaphores initialized locked

4379 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {

4380 WARN("CONSIDER_COMPLETION",

4381 "consider using a completion\n" . $herecurr);

4382 }

4383

4384 # recommend kstrto* over simple_strto* and strict_strto*

4385 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {

4386 WARN("CONSIDER_KSTRTO",

4387 "$1 is obsolete, use k$3 instead\n" . $herecurr);

4388 }

4389

4390 # check for __initcall(), use device_initcall() explicitly please

4391 if ($line =~ /^.\s*__initcall\s*\(/) {

4392 WARN("USE_DEVICE_INITCALL",

4393 "please use device_initcall() instead of __initcall()\n" . $herecurr);

4394 }

4395

4396 # check for various ops structs, ensure they are const.

4397 my $struct_ops = qr{acpi_dock_ops|

4398 address_space_operations|

4399 backlight_ops|

4400 block_device_operations|

4401 dentry_operations|

4402 dev_pm_ops|

4403 dma_map_ops|

4404 extent_io_ops|

4405 file_lock_operations|

4406 file_operations|

4407 hv_ops|

4408 ide_dma_ops|

4409 intel_dvo_dev_ops|

4410 item_operations|

4411 iwl_ops|

4412 kgdb_arch|

4413 kgdb_io|

4414 kset_uevent_ops|

4415 lock_manager_operations|

4416 microcode_ops|

4417 mtrr_ops|

4418 neigh_ops|

4419 nlmsvc_binding|

4420 pci_raw_ops|

4421 pipe_buf_operations|

4422 platform_hibernation_ops|

4423 platform_suspend_ops|

4424 proto_ops|

4425 rpc_pipe_ops|

4426 seq_operations|

4427 snd_ac97_build_ops|

4428 soc_pcmcia_socket_ops|

4429 stacktrace_ops|

4430 sysfs_ops|

4431 tty_operations|

4432 usb_mon_operations|

4433 wd_ops}x;

4434 if ($line !~ /\bconst\b/ &&

4435 $line =~ /\bstruct\s+($struct_ops)\b/) {

4436 WARN("CONST_STRUCT",

4437 "struct $1 should normally be const\n" .

4438 $herecurr);

4439 }

4440

4441 # use of NR_CPUS is usually wrong

4442 # ignore definitions of NR_CPUS and usage to define arrays as likely right

4443 if ($line =~ /\bNR_CPUS\b/ &&

4444 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&

4445 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&

4446 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&

4447 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&

4448 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)

4449 {

4450 WARN("NR_CPUS",

4451 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);

4452 }

4453

4454 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.

4455 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {

4456 ERROR("DEFINE_ARCH_HAS",

4457 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);

4458 }

4459

4460 # check for %L{u,d,i} in strings

4461 my $string;

4462 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {

4463 $string = substr($rawline, $-[1], $+[1] - $-[1]);

4464 $string =~ s/%%/__/g;

4465 if ($string =~ /(?<!%)%L[udi]/) {

4466 WARN("PRINTF_L",

4467 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);

4468 last;

4469 }

4470 }

4471

4472 # whine mightly about in_atomic

4473 if ($line =~ /\bin_atomic\s*\(/) {

4474 if ($realfile =~ m@^drivers/@) {

4475 ERROR("IN_ATOMIC",

4476 "do not use in_atomic in drivers\n" . $herecurr);

4477 } elsif ($realfile !~ m@^kernel/@) {

4478 WARN("IN_ATOMIC",

4479 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);

4480 }

4481 }

4482

4483 # check for lockdep_set_novalidate_class

4484 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||

4485 $line =~ /__lockdep_no_validate__\s*\)/ ) {

4486 if ($realfile !~ m@^kernel/lockdep@ &&

4487 $realfile !~ m@^include/linux/lockdep@ &&

4488 $realfile !~ m@^drivers/base/core@) {

4489 ERROR("LOCKDEP",

4490 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);

4491 }

4492 }

4493

4494 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||

4495 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {

4496 WARN("EXPORTED_WORLD_WRITABLE",

4497 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);

4498 }

4499

4500 foreach my $entry (@mode_permission_funcs) {

4501 my $func = $entry->[0];

4502 my $arg_pos = $entry->[1];

4503

4504 my $skip_args = "";

4505 if ($arg_pos > 1) {

4506 $arg_pos--;

4507 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";

4508 }

4509 my $test = "\\b$func\\s*\$${skip_args}([\\d]+)\\s*[,\$]";

4510 if ($^V && $^V ge 5.10.0 &&

4511 $line =~ /$test/) {

4512 my $val = $1;

4513 $val = $6 if ($skip_args ne "");

4514

4515 if ($val =~ /^$Int$/ && $val !~ /^$Octal$/) {

4516 ERROR("NON_OCTAL_PERMISSIONS",

4517 "Use octal not decimal permissions\n" . $herecurr);

4518 }

4519 }

4520 }

4521 }

4522

4523 # If we have no input at all, then there is nothing to report on

4524 # so just keep quiet.

4525 if ($#rawlines == -1) {

4526 exit(0);

4527 }

4528

4529 # In mailback mode only produce a report in the negative, for

4530 # things that appear to be patches.

4531 if ($mailback && ($clean == 1 || !$is_patch)) {

4532 exit(0);

4533 }

4534

4535 # This is not a patch, and we are are in 'no-patch' mode so

4536 # just keep quiet.

4537 if (!$chk_patch && !$is_patch) {

4538 exit(0);

4539 }

4540

4541 if (!$is_patch) {

4542 ERROR("NOT_UNIFIED_DIFF",

4543 "Does not appear to be a unified-diff format patch\n");

4544 }

4545 if ($is_patch && $chk_signoff && $signoff == 0) {

4546 ERROR("MISSING_SIGN_OFF",

4547 "Missing Signed-off-by: line(s)\n");

4548 }

4549

4550 print report_dump();

4551 if ($summary && !($clean == 1 && $quiet == 1)) {

4552 print "$filename " if ($summary_file);

4553 print "total: $cnt_error errors, $cnt_warn warnings, " .

4554 (($check)? "$cnt_chk checks, " : "") .

4555 "$cnt_lines lines checked\n";

4556 print "\n" if ($quiet == 0);

4557 }

4558

4559 if ($quiet == 0) {

4560

4561 if ($^V lt 5.10.0) {

4562 print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");

4563 print("An upgrade to at least perl v5.10.0 is suggested.\n\n");

4564 }

4565

4566 # If there were whitespace errors which cleanpatch can fix

4567 # then suggest that.

4568 if ($rpt_cleaners) {

4569 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";

4570 print " scripts/cleanfile\n\n";

4571 $rpt_cleaners = 0;

4572 }

4573 }

4574

4575 hash_show_words(\%use_type, "Used");

4576 hash_show_words(\%ignore_type, "Ignored");

4577

4578 if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {

4579 my $newfile = $filename;

4580 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);

4581 my $linecount = 0;

4582 my $f;

4583

4584 open($f, '>', $newfile)

4585 or die "$P: Can't open $newfile for write\n";

4586 foreach my $fixed_line (@fixed) {

4587 $linecount++;

4588 if ($file) {

4589 if ($linecount > 3) {

4590 $fixed_line =~ s/^\+//;

4591 print $f $fixed_line. "\n";

4592 }

4593 } else {

4594 print $f $fixed_line . "\n";

4595 }

4596 }

4597 close($f);

4598

4599 if (!$quiet) {

4600 print << "EOM";

4601 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'

4602

4603 Do _NOT_ trust the results written to this file.

4604 Do _NOT_ submit these changes without inspecting them for correctness.

4605

4606 This EXPERIMENTAL file is simply a convenience to help rewrite patches.

4607 No warranties, expressed or implied...

4608

4609 EOM

4610 }

4611 }

4612

4613 if ($clean == 1 && $quiet == 0) {

4614 print "$vname has no obvious style problems and is ready for submission.\n"

4615 }

4616 if ($clean == 0 && $quiet == 0) {

4617 print << "EOM";

4618 $vname has style problems, please review.

4619

4620 If any of these errors are false positives, please report

4621 them to the maintainer, see CHECKPATCH in MAINTAINERS.

4622 EOM

4623 }

4624

4625 return $clean;

4626 }