git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob

1 #!/usr/bin/perl -w

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

8 use strict;

9 use POSIX;

 my $P = $0;

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

 my $V = '0.32';

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

 my $quiet = 0;

 my $tree = 1;

 my $chk_signoff = 1;

 my $chk_patch = 1;

22 my $tst_only;

 my $emacs = 0;

 my $terse = 0;

 my $file = 0;

 my $check = 0;

 my $summary = 1;

 my $mailback = 0;

 my $summary_file = 0;

 my $show_types = 0;

 my $fix = 0;

 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 = ();

 my $help = 0;

 my $configuration_file = ".checkpatch.conf";

 my $max_line_length = 80;

 my $ignore_perl_version = 0;

 my $minimum_perl_version = 5.10.0;

46 sub help {

         my ($exitcode) = @_;

49 print << "EOM";

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

51 Version: $V

53 Options:

54 -q, --quiet quiet

55 --no-tree run without a kernel tree

   --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

   --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

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

                              '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.

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

87 When FILE is - read standard input.

88 EOM

90 exit($exitcode);

91 }

 my $conf = which_conf($configuration_file);

94 if (-f $conf) {

95 my @conf_args;

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

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

99 while (<$conffile>) {

                 my $line = $_;

101

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

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

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

105

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

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

108

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

                 foreach my $word (@words) {

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

112 push (@conf_args, $word);

113 }

114 }

115 close($conffile);

         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

 ) or help(1);

145

 help(0) if ($help);

147

 $fix = 1 if ($fix_inplace);

149

 my $exit = 0;

151

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

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

154 if (!$ignore_perl_version) {

155 exit(1);

156 }

157 }

158

 if ($#ARGV < 0) {

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

161 exit(1);

162 }

163

164 sub hash_save_array_words {

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

166

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

         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

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

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

176

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

178 }

179 }

180

181 sub hash_show_words {

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

183

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

                 print "NOTE: $prefix message types:";

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

                         print " $word";

188 }

                 print "\n\n";

190 }

191 }

192

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

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

195

 my $dbg_values = 0;

 my $dbg_possible = 0;

 my $dbg_type = 0;

 my $dbg_attr = 0;

 for my $key (keys %debug) {

201 ## no critic

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

         die "$@" if ($@);

204 }

205

 my $rpt_cleaners = 0;

207

208 if ($terse) {

209 $emacs = 1;

210 $quiet++;

211 }

212

213 if ($tree) {

         if (defined $root) {

                 if (!top_of_kernel_tree($root)) {

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

217 }

218 } else {

                 if (top_of_kernel_tree('.')) {

220 $root = '.';

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

222 top_of_kernel_tree($1)) {

223 $root = $1;

224 }

225 }

226

         if (!defined $root) {

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

229 exit(2);

230 }

231 }

232

 my $emitted_corrupt = 0;

234

235 our $Ident = qr{

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

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

238 }x;

 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;

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

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

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

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

 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;

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

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

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

287

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

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

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

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

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

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

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

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

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

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

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

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

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

301 our $Operators = qr{

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

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

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

305 }x;

306

307 our $NonptrType;

308 our $NonptrTypeWithAttr;

309 our $Type;

310 our $Declare;

311

312 our $NON_ASCII_UTF8 = qr{

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

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

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

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

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

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

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

320 }x;

321

322 our $UTF8 = qr{

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

324 | $NON_ASCII_UTF8

325 }x;

326

 our $typeTypedefs = qr{(?x:

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

329 atomic_t

330 )};

331

 our $logFunctions = qr{(?x:

333 printk(?:_ratelimited|_once|)|

         (?:[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

 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 = (

         ["module_param", 3],

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

         ["module_param_array_named", 5],

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

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

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

389 );

390

 our $allowed_asm_includes = qr{(?x:

392 irq|

393 memory

394 )};

395 # memory.h: ARM has a custom one

396

397 sub build_types {

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

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

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

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

402 $NonptrType = qr{

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

404 (?:

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

406 (?:$typeTypedefs\b)|

                                 (?:${all}\b)

408 )

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

410 }x;

411 $NonptrTypeWithAttr = qr{

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

413 (?:

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

415 (?:$typeTypedefs\b)|

                                 (?:${allWithAttr}\b)

417 )

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

419 }x;

420 $Type = qr{

421 $NonptrType

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

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

424 }x;

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

426 }

427 build_types();

428

 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

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

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

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

438

439 sub deparenthesize {

         my ($string) = @_;

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

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

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

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

445 return $string;

446 }

447

448 sub seed_camelcase_file {

         my ($file) = @_;

450

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

452

453 local $/;

454

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

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

         my $text = <$include_file>;

458 close($include_file);

459

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

461

         foreach my $line (@lines) {

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

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

                         $camelcase{$1} = 1;

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

                         $camelcase{$1} = 1;

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

                         $camelcase{$1} = 1;

470 }

471 }

472 }

473

 my $camelcase_seeded = 0;

475 sub seed_camelcase_includes {

476 return if ($camelcase_seeded);

477

478 my $files;

         my $camelcase_cache = "";

480 my @include_files = ();

481

482 $camelcase_seeded = 1;

483

484 if (-e ".git") {

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

486 chomp $git_last_include_commit;

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

488 } else {

                 my $last_mod_date = 0;

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

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

                 foreach my $file (@include_files) {

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

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

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

496 }

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

498 }

499

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

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

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

503 while (<$camelcase_file>) {

504 chomp;

                         $camelcase{$_} = 1;

506 }

507 close($camelcase_file);

508

509 return;

510 }

511

512 if (-e ".git") {

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

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

515 }

516

         foreach my $file (@include_files) {

518 seed_camelcase_file($file);

519 }

520

         if ($camelcase_cache ne "") {

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

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

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

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

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

527 }

528 close($camelcase_file);

529 }

530 }

531

 $chk_signoff = 0 if ($file);

533

534 my @rawlines = ();

535 my @lines = ();

536 my @fixed = ();

537 my $vname;

 for my $filename (@ARGV) {

539 my $FILE;

540 if ($file) {

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

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

         } elsif ($filename eq '-') {

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

545 } else {

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

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

548 }

         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);

         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 {

         my ($root) = @_;

571

572 my @tree_check = (

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

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

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

576 );

577

         foreach my $check (@tree_check) {

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

580 return 0;

581 }

582 }

583 return 1;

584 }

585

586 sub parse_email {

         my ($formatted_email) = @_;

588

         my $name = "";

         my $address = "";

         my $comment = "";

592

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

594 $name = $1;

595 $address = $2;

                 $comment = $3 if defined $3;

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

598 $address = $1;

                 $comment = $2 if defined $2;

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

601 $address = $1;

                 $comment = $2 if defined $2;

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

604 $name = $formatted_email;

                 $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

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

614 $name = "";

615 $address = "";

616 $comment = "";

617 }

618 }

619

         $name = trim($name);

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

         $address = trim($address);

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

624

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

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

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

628 }

629

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

631 }

632

633 sub format_email {

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

635

636 my $formatted_email;

637

         $name = trim($name);

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

         $address = trim($address);

641

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

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

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

645 }

646

         if ("$name" eq "") {

                 $formatted_email = "$address";

649 } else {

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

651 }

652

653 return $formatted_email;

654 }

655

656 sub which_conf {

         my ($conf) = @_;

658

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

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

                         return "$path/$conf";

662 }

663 }

664

665 return "";

666 }

667

668 sub expand_tabs {

         my ($str) = @_;

670

         my $res = '';

         my $n = 0;

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

                 if ($c eq "\t") {

675 $res .= ' ';

676 $n++;

                         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 {

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

690 return $res;

691 }

692

693 sub line_stats {

         my ($line) = @_;

695

696 # Drop the diff line leader and expand tabs

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

         $line = expand_tabs($line);

699

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

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

702

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

704 }

705

 my $sanitise_quote = '';

707

708 sub sanitise_line_reset {

         my ($in_comment) = @_;

710

711 if ($in_comment) {

712 $sanitise_quote = '*/';

713 } else {

714 $sanitise_quote = '';

715 }

716 }

717 sub sanitise_line {

         my ($line) = @_;

719

         my $res = '';

         my $l = '';

722

         my $qlen = 0;

         my $off = 0;

725 my $c;

726

727 # Always copy over the diff marker.

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

729

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

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

732

733 # Comments we are wacking completly including the begin

734 # and end, all to $;.

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

736 $sanitise_quote = '*/';

737

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

739 $off++;

740 next;

741 }

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

743 $sanitise_quote = '';

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

745 $off++;

746 next;

747 }

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

749 $sanitise_quote = '//';

750

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

752 $off++;

753 next;

754 }

755

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

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

                     $c eq "\\") {

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

760 $off++;

761 next;

762 }

763 # Regular quotes.

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

                         if ($sanitise_quote eq '') {

766 $sanitise_quote = $c;

767

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

769 next;

                         } elsif ($sanitise_quote eq $c) {

771 $sanitise_quote = '';

772 }

773 }

774

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

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

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

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

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

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

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

782 } else {

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

784 }

785 }

786

         if ($sanitise_quote eq '//') {

788 $sanitise_quote = '';

789 }

790

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

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

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

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

795

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

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

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

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

800 }

801

802 return $res;

803 }

804

805 sub get_quoted_string {

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

807

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

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

810 }

811

812 sub ctx_statement_block {

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

         my $line = $linenr - 1;

         my $blk = '';

         my $soff = $off;

         my $coff = $off - 1;

         my $coff_set = 0;

819

         my $loff = 0;

821

         my $type = '';

         my $level = 0;

824 my @stack = ();

825 my $p;

826 my $c;

         my $len = 0;

828

829 my $remainder;

830 while (1) {

                 @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.

                 if ($off >= $len) {

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

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

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

840 $remain--;

841 $loff = $len;

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

                                 $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";

                         if ($off >= $len) {

850 last;

851 }

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

853 $level++;

854 $type = '#';

855 }

856 }

857 $p = $c;

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

                 $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.

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

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

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

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

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

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

870 }

871

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

873 # outermost level.

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

875 last;

876 }

877

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

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

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

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

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

                         $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

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

890 $level++;

891 $type = '(';

892 }

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

894 $level--;

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

896

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

898 $coff = $off;

899 $coff_set = 1;

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

901 }

902 }

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

904 $level++;

905 $type = '{';

906 }

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

908 $level--;

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

910

                         if ($level == 0) {

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

913 $off++;

914 }

915 last;

916 }

917 }

918 # Preprocessor commands end at the newline unless escaped.

                 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.

         if ($off == $len) {

                 $loff = $len + 1;

930 $line++;

931 $remain--;

932 }

933

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

         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,

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

944 }

945

946 sub statement_lines {

         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

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

955

         return $#stmt_lines + 2;

957 }

958

959 sub statement_rawlines {

         my ($stmt) = @_;

961

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

963

         return $#stmt_lines + 2;

965 }

966

967 sub statement_block_size {

         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

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

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

978

         my $stmt_lines = $#stmt_lines + 2;

         my $stmt_statements = $#stmt_statements + 1;

981

         if ($stmt_lines > $stmt_statements) {

983 return $stmt_lines;

984 } else {

985 return $stmt_statements;

986 }

987 }

988

989 sub ctx_statement_full {

         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";

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

         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";

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

1011 #print "C: push\n";

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

1013 }

1014

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

1016 }

1017

1018 sub ctx_block_get {

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

1020 my $line;

         my $start = $linenr - 1;

         my $blk = '';

1023 my @o;

1024 my @c;

1025 my @res = ();

1026

         my $level = 0;

         my @stack = ($level);

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

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

1031 $remain--;

1032

                 $blk .= $rawlines[$line];

1034

1035 # Handle nested #if/#else.

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

1037 push(@stack, $level);

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

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

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

                         $level = pop(@stack);

1042 }

1043

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

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

                         if ($off > 0) {

1047 $off--;

1048 next;

1049 }

1050

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

1052 $level--;

                                 last if ($level == 0);

                         } elsif ($c eq $open) {

1055 $level++;

1056 }

1057 }

1058

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

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

1061 }

1062

                 last if ($level == 0);

1064 }

1065

1066 return ($level, @res);

1067 }

1068 sub ctx_block_outer {

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

1070

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

1072 return @r;

1073 }

1074 sub ctx_block {

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

1076

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

1078 return @r;

1079 }

1080 sub ctx_statement {

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

1082

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

1084 return @r;

1085 }

1086 sub ctx_block_level {

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

1088

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

1090 }

1091 sub ctx_statement_level {

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

1093

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

1095 }

1096

1097 sub ctx_locate_comment {

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

1099

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

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

         return $current_comment if (defined $current_comment);

1103

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

1105 # comment.

         my $in_comment = 0;

1107 $current_comment = '';

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

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

1110 #warn " $line\n";

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

1112 $in_comment = 1;

1113 }

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

1115 $in_comment = 1;

1116 }

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

1118 $current_comment = '';

1119 }

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

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

1122 $in_comment = 0;

1123 }

1124 }

1125

1126 chomp($current_comment);

1127 return($current_comment);

1128 }

1129 sub ctx_has_comment {

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

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

1132

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

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

1135

         return ($cmt ne '');

1137 }

1138

1139 sub raw_line {

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

1141

         my $offset = $linenr - 1;

1143 $cnt++;

1144

1145 my $line;

1146 while ($cnt) {

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

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

1149 $cnt--;

1150 }

1151

1152 return $line;

1153 }

1154

1155 sub cat_vet {

         my ($vet) = @_;

1157 my ($res, $coded);

1158

1159 $res = '';

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

1161 $res .= $1;

                 if ($2 ne '') {

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

1164 $res .= $coded;

1165 }

1166 }

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

1168

1169 return $res;

1170 }

1171

 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 {

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

1186

1187 my $res;

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

         my $cur = $stream;

1190

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

1192

         while (length($cur)) {

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

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

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

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

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

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

                                 $type = pop(@av_paren_type);

1201 $av_preprocessor = 0;

1202 }

1203

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

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

1206 push(@av_paren_type, $type);

1207 $type = 'c';

1208

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

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

1211 $type = 'T';

1212

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

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

1215 $type = 'T';

1216

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

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

1219 $av_preprocessor = 1;

1220 push(@av_paren_type, $type);

                         if ($2 ne '') {

1222 $av_pending = 'N';

1223 }

1224 $type = 'E';

1225

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

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

1228 $av_preprocessor = 1;

1229 push(@av_paren_type, $type);

1230

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

                         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

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

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

1241 $av_preprocessor = 1;

1242

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

1244

1245 $type = 'E';

1246

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

                         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

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

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

1260

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

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

1263 $av_pending = $type;

1264 $type = 'N';

1265

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

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

                         if (defined $2) {

1269 $av_pending = 'V';

1270 }

1271 $type = 'N';

1272

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

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

1275 $av_pending = 'E';

1276 $type = 'N';

1277

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

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

1280 $av_pend_colon = 'C';

1281 $type = 'N';

1282

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

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

1285 $type = 'N';

1286

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

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

1289 push(@av_paren_type, $av_pending);

1290 $av_pending = '_';

1291 $type = 'N';

1292

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

                         my $new_type = pop(@av_paren_type);

                         if ($new_type ne '_') {

1296 $type = $new_type;

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

                                                         if ($dbg_values > 1);

1299 } else {

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

1301 }

1302

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

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

1305 $type = 'V';

1306 $av_pending = 'V';

1307

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

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

1310 $av_pend_colon = 'B';

                         } elsif ($type eq 'E') {

1312 $av_pend_colon = 'L';

1313 }

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

1315 $type = 'V';

1316

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

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

1319 $type = 'V';

1320

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

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

1323 $type = 'N';

1324

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

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

1327 $type = 'E';

1328 $av_pend_colon = 'O';

1329

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

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

1332 $type = 'C';

1333

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

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

1336 $type = 'N';

1337

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

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

1340

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

                         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

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

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

1351 $type = 'N';

1352

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

1354 my $variant;

1355

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

                         if ($type eq 'V') {

1358 $variant = 'B';

1359 } else {

1360 $variant = 'U';

1361 }

1362

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

1364 $type = 'N';

1365

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

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

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

1369 $type = 'N';

1370 }

1371

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

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

1374 }

                 if (defined $1) {

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

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

1378 }

1379 }

1380

1381 return ($res, $var);

1382 }

1383

1384 sub possible {

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

         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|$)|

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

1404 )}x;

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

         if ($possible !~ $notPermitted) {

1407 # Check for modifiers.

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

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

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

1411

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

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

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

                                 if ($modifier !~ $notPermitted) {

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

1417 push(@modifierList, $modifier);

1418 }

1419 }

1420

1421 } else {

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

1423 push(@typeList, $possible);

1424 }

1425 build_types();

1426 } else {

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

1428 }

1429 }

1430

 my $prefix = '';

1432

1433 sub show_type {

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

1435

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

1437 }

1438

1439 sub report {

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

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

1442 return 0;

1443 }

1444 my $line;

1445 if ($show_types) {

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

1447 } else {

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

1449 }

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

1451

         push(our @report, $line);

1453

1454 return 1;

1455 }

1456 sub report_dump {

1457 our @report;

1458 }

1459

1460 sub ERROR {

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

                 our $clean = 0;

1463 our $cnt_error++;

1464 return 1;

1465 }

1466 return 0;

1467 }

1468 sub WARN {

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

                 our $clean = 0;

1471 our $cnt_warn++;

1472 return 1;

1473 }

1474 return 0;

1475 }

1476 sub CHK {

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

                 our $clean = 0;

1479 our $cnt_chk++;

1480 return 1;

1481 }

1482 return 0;

1483 }

1484

1485 sub check_absolute_file {

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

         my $file = $absolute;

1488

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

1490

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

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

                 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.

         my $prefix = $absolute;

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

1505

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

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

1508 WARN("USE_RELATIVE_PATH",

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

1510 }

1511 }

1512

1513 sub trim {

         my ($string) = @_;

1515

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

1517

1518 return $string;

1519 }

1520

1521 sub ltrim {

         my ($string) = @_;

1523

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

1525

1526 return $string;

1527 }

1528

1529 sub rtrim {

         my ($string) = @_;

1531

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

1533

1534 return $string;

1535 }

1536

1537 sub string_find_replace {

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

1539

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

1541

1542 return $string;

1543 }

1544

1545 sub tabify {

         my ($leading) = @_;

1547

         my $source_indent = 8;

         my $max_spaces_before_tab = $source_indent - 1;

         my $spaces_to_tab = " " x $source_indent;

1551

1552 #convert leading spaces to tabs

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

1554 #Remove spaces before a tab

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

1556

         return "$leading";

1558 }

1559

1560 sub pos_last_openparen {

         my ($line) = @_;

1562

         my $pos = 0;

1564

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

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

1567

         my $last_openparen = 0;

1569

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

1571 return -1;

1572 }

1573

         my $len = length($line);

1575

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

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

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

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

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

1581 $last_openparen = $pos;

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

1583 last;

1584 }

1585 }

1586

         return $last_openparen + 1;

1588 }

1589

1590 sub process {

         my $filename = shift;

1592

         my $linenr=0;

         my $prevline="";

         my $prevrawline="";

         my $stashline="";

         my $stashrawline="";

1598

1599 my $length;

1600 my $indent;

         my $previndent=0;

         my $stashindent=0;

1603

         our $clean = 1;

         my $signoff = 0;

         my $is_patch = 0;

1607

         my $in_header_lines = 1;

         my $in_commit_log = 0;          #Scanning lines before patch

1610

         my $non_utf8_charset = 0;

1612

1613 our @report = ();

         our $cnt_lines = 0;

         our $cnt_error = 0;

         our $cnt_warn = 0;

         our $cnt_chk = 0;

1618

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

         my $realfile = '';

         my $realline = 0;

         my $realcnt = 0;

         my $here = '';

         my $in_comment = 0;

         my $comment_edge = 0;

         my $first_line = 0;

         my $p1_prefix = '';

1628

         my $prev_values = 'E';

1630

1631 # suppression flags

1632 my %suppress_ifbraces;

1633 my %suppress_whiletrailers;

1634 my %suppress_export;

         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 = ();

         my $setup_docs = 0;

1644

         my $camelcase_file_seeded = 0;

1646

1647 sanitise_line_reset();

1648 my $line;

         foreach my $rawline (@rawlines) {

1650 $linenr++;

1651 $line = $rawline;

1652

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

1654

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

1656 $setup_docs = 0;

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

1658 $setup_docs = 1;

1659 }

1660 #next;

1661 }

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

                         $realline=$1-1;

                         if (defined $2) {

1665 $realcnt=$3+1;

1666 } else {

                                 $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;

                         my $cnt = $realcnt;

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

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

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

1680 $cnt--;

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

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

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

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

                                         ($edge) = $1;

1686 last;

1687 }

1688 }

                         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.

                         if (!defined $edge &&

                             $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

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

1706 # Standardise the strings and chars within the input to

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

                         $line = sanitise_line($rawline);

1709 }

1710 push(@lines, $line);

1711

                 if ($realcnt > 1) {

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

1714 } else {

1715 $realcnt = 0;

1716 }

1717

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

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

1720

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

1722 push(@setup_docs, $line);

1723 }

1724 }

1725

1726 $prefix = '';

1727

1728 $realcnt = 0;

1729 $linenr = 0;

         foreach my $line (@lines) {

1731 $linenr++;

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

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

1734

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

1736

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

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

1739 $is_patch = 1;

                         $first_line = $linenr + 1;

                         $realline=$1-1;

                         if (defined $2) {

1743 $realcnt=$3+1;

1744 } else {

                                 $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.

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

1760 $realline++;

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

1762

1763 # Measure the line length and indent.

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

1765

1766 # Track the previous line.

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

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

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

1770

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

1772

                 } elsif ($realcnt == 1) {

1774 $realcnt--;

1775 }

1776

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

1778

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

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

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

1782

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

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

1785

1786 # extract the filename as it passes

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

1788 $realfile = $1;

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

1790 $in_commit_log = 0;

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

1792 $realfile = $1;

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

1794 $in_commit_log = 0;

1795

1796 $p1_prefix = $1;

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

                             -e "$root/$p1_prefix") {

1799 WARN("PATCH_PREFIX",

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

1801 }

1802

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

1804 ERROR("MODIFIED_INCLUDE_ASM",

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

1806 }

1807 next;

1808 }

1809

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

1811

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

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

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

1815

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

1817

1818 # Check for incorrect file permissions

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

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

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

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

1823 ERROR("EXECUTE_PERMISSIONS",

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

1825 }

1826 }

1827

1828 # Check the patch for a signoff:

                 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) {

                         my $space_before = $1;

                         my $sign_off = $2;

                         my $space_after = $3;

                         my $email = $4;

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

1842

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

1844 WARN("BAD_SIGN_OFF",

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

1846 }

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

                                 if (WARN("BAD_SIGN_OFF",

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

1850 $fix) {

                                         $fixed[$linenr - 1] =

                                             "$ucfirst_sign_off $email";

1853 }

1854 }

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

                                 if (WARN("BAD_SIGN_OFF",

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

1858 $fix) {

                                         $fixed[$linenr - 1] =

                                             "$ucfirst_sign_off $email";

1861 }

1862

1863 }

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

                                 if (WARN("BAD_SIGN_OFF",

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

1867 $fix) {

                                         $fixed[$linenr - 1] =

                                             "$ucfirst_sign_off $email";

1870 }

1871 }

1872

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

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

                         if ($suggested_email eq "") {

1876 ERROR("BAD_SIGN_OFF",

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

1878 } else {

                                 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

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

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

                                     "$suggested_email$comment" ne $email) {

1887 WARN("BAD_SIGN_OFF",

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

1889 }

1890 }

1891

1892 # Check for duplicate signatures

                         my $sig_nospace = $line;

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

                         $sig_nospace = lc($sig_nospace);

                         if (defined $signatures{$sig_nospace}) {

1897 WARN("BAD_SIGN_OFF",

                                      "Duplicate signature\n" . $herecurr);

1899 } else {

                                 $signatures{$sig_nospace} = 1;

1901 }

1902 }

1903

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

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

1906 ERROR("CORRUPTED_PATCH",

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

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

1909 }

1910

1911 # Check for absolute kernel paths.

1912 if ($tree) {

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

                                 my $file = $1;

1915

                                 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

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

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

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

1929

                         my $blank = copy_spacing($rawline);

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

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

1933

1934 CHK("INVALID_UTF8",

                             "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)

                 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

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

1955 $rawline =~ /$NON_ASCII_UTF8/) {

1956 WARN("UTF8_BEFORE_PATCH",

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

1958 }

1959

1960 # ignore non-hunk lines and lines being removed

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

1962

1963 #trailing whitespace

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

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

                         if (ERROR("DOS_LINE_ENDINGS",

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

1968 $fix) {

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

1970 }

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

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

                         if (ERROR("TRAILING_WHITESPACE",

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

1975 $fix) {

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

1977 }

1978

1979 $rpt_cleaners = 1;

1980 }

1981

1982 # Check for FSF mailing addresses.

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

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

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

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

                         my $msg_type = \&ERROR;

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

                         &{$msg_type}("FSF_MAILING_ADDRESS",

                                      "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.

                 if ($realfile =~ /Kconfig/ &&

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

                         my $length = 0;

                         my $cnt = $realcnt;

                         my $ln = $linenr + 1;

2001 my $f;

                         my $is_start = 0;

                         my $is_end = 0;

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

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

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

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

2008

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

2010

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

2012 $is_start = 1;

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

2014 $length = -1;

2015 }

2016

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

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

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

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

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

2022 $is_end = 1;

2023 last;

2024 }

2025 $length++;

2026 }

2027 WARN("CONFIG_DESCRIPTION",

                              "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.

                 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

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

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

                         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",

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

2051 }

2052

2053 # check for DT compatible documentation

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

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

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

2057

                         foreach my $compat (@compats) {

                                 my $compat2 = $compat;

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

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

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

2063 if ( $? >> 8 ) {

2064 WARN("UNDOCUMENTED_DT_STRING",

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

2066 }

2067

                                 my $vendor = $compat;

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

2070 next if (! -f $vendor_path);

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

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

                                 if ( $? >> 8 ) {

2074 WARN("UNDOCUMENTED_DT_STRING",

                                              "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

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

2082

2083 #line length limit

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

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

                     !($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",

                              "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

                 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",

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

2103 }

2104

2105 # check for spaces before a quoted newline

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

                         if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",

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

2109 $fix) {

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

2111 }

2112

2113 }

2114

2115 # check for adding lines without a newline.

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

2117 WARN("MISSING_EOF_NEWLINE",

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

2119 }

2120

2121 # Blackfin: use hi/lo macros

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

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

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

2125 ERROR("LO_MACRO",

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

2127 }

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

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

2130 ERROR("HI_MACRO",

                                       "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

                 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.

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

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

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

2143 $rpt_cleaners = 1;

                         if (ERROR("CODE_INDENT",

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

2146 $fix) {

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

2148 }

2149 }

2150

2151 # check for space before tabs.

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

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

                         if (WARN("SPACE_BEFORE_TAB",

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

2156 $fix) {

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

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

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

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

2161 }

2162 }

2163

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

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

2166 CHK("LOGICAL_CONTINUATIONS",

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

2168 }

2169

2170 # check multi-line statement indentation matches previous line

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

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

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

                         my $oldindent = $1;

                         my $rest = $2;

2176

                         my $pos = pos_last_openparen($rest);

                         if ($pos >= 0) {

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

                                 my $newindent = $2;

2181

                                 my $goodtabindent = $oldindent .

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

                                         " "  x ($pos % 8);

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

2186

                                 if ($newindent ne $goodtabindent &&

2188 $newindent ne $goodspaceindent) {

2189

                                         if (CHK("PARENTHESIS_ALIGNMENT",

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

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

                                                 $fixed[$linenr - 1] =~

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

2195 }

2196 }

2197 }

2198 }

2199

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

                         if (CHK("SPACING",

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

2203 $fix) {

                                 $fixed[$linenr - 1] =~

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

2206 }

2207 }

2208

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

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

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

2212 WARN("NETWORKING_BLOCK_COMMENT_STYLE",

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

2214 }

2215

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

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

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

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

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

2221 WARN("NETWORKING_BLOCK_COMMENT_STYLE",

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

2223 }

2224

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

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

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

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

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

2230 WARN("NETWORKING_BLOCK_COMMENT_STYLE",

                              "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

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

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

                         if (WARN("LEADING_SPACE",

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

2243 $fix) {

                                 $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

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

2250

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

                 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

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

2259 WARN("CVS_KEYWORD",

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

2261 }

2262

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

                 if ($line =~ /__builtin_bfin_csync/) {

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

2266 ERROR("CSYNC",

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

2268 }

                 if ($line =~ /__builtin_bfin_ssync/) {

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

2271 ERROR("SSYNC",

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

2273 }

2274

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

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

2277 WARN("HOTPLUG_SECTION",

                              "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";

                 if ($linenr >= $suppress_statement &&

                     $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.

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

                         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;

                         if (defined $realline_next &&

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

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

2307 $realline_next++;

2308 }

2309

                         my $s = $stat;

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

2312

2313 # Ignore goto labels.

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

2315

2316 # Ignore functions being called

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

2318

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

2320

2321 # declarations always start with types

                         } 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) {

                                 my $type = $1;

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

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

2326

2327 # definitions in global scope can only start with types

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

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

2330 }

2331

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

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

                                 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 *);

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

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

2342

                                 my $ctx = $s;

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

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

2346

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

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

2349

                                                 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.

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

                         my $err = '';

                         my $sep = '';

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

2367 shift(@ctx);

                         for my $ctx (@ctx) {

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

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

2371 $indent != $cindent) {

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

2373 $sep = '';

2374 } else {

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

2376 }

2377 }

                         if ($err ne '') {

2379 ERROR("SWITCH_CASE_INDENT_LEVEL",

                                       "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

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

                         my $pre_ctx = "$1$2";

2388

                         my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);

2390

                         if ($line =~ /^\+\t{6,}/) {

2392 WARN("DEEP_INDENTATION",

                                      "Too many leading tabs - consider code refactoring\n" . $herecurr);

2394 }

2395

                         my $ctx_cnt = $realcnt - $#ctx - 1;

                         my $ctx = join("\n", @ctx);

2398

                         my $ctx_ln = $linenr;

                         my $ctx_skip = $realcnt;

2401

                         while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&

                                         defined $lines[$ctx_ln - 1] &&

                                         $lines[$ctx_ln - 1] =~ /^-/)) {

2405 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";

                                 $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

                         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" .

                                         "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");

2417 }

                         if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&

2419 $ctx =~ /\)\s*\;\s*$/ &&

                             defined $lines[$ctx_ln - 1])

2421 {

                                 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);

                                 if ($nindent > $indent) {

2424 WARN("TRAILING_SEMICOLON",

2425 "trailing semicolon indicates no statements, indent implies otherwise\n" .

                                                 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");

2427 }

2428 }

2429 }

2430

2431 # Check relative indent for conditionals and blocks.

                 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)

                                         if (!defined $stat);

                         my ($s, $c) = ($stat, $cond);

2437

                         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.

                         my @newlines = ($c =~ /\n/gs);

                         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 (...) {

                         my $continuation = 0;

                         my $check = 0;

2456 $s =~ s/^.*\bdo\b//;

2457 $s =~ s/^\s*{//;

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

2459 $continuation = 1;

2460 }

                         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.

                         if (($prevline =~ /^.\s*#\s*define\s/ ||

                             $prevline =~ /\\\s*$/) && $continuation == 0) {

2470 $check = 0;

2471 }

2472

                         my $cond_ptr = -1;

2474 $continuation = 0;

                         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.

                                 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*:/) {

                                         $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;

                                         if ($s =~ s/^.*?\n//) {

2494 $cond_lines++;

2495 }

2496 }

2497 }

2498

                         my (undef, $sindent) = line_stats("+" . $s);

                         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.

                         if (!defined($stat_real) ||

                             $stat !~ /^\+/ && $stat_real !~ /^\+/) {

2506 $check = 0;

2507 }

                         if (defined($stat_real) && $cond_lines > 1) {

                                 $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

                         if ($check && (($sindent % 8) != 0 ||

                             ($sindent <= $indent && $s ne ''))) {

2516 WARN("SUSPECT_CODE_INDENT",

                                      "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.

                 my $opline = $line; $opline =~ s/^./ /;

2523 my ($curr_values, $curr_vars) =

                                 annotate_values($opline . "\n", $prev_values);

                 $curr_values = $prev_values . $curr_values;

2526 if ($dbg_values) {

                         my $outline = $opline; $outline =~ s/\t/ /g;

                         print "$linenr > .$outline\n";

                         print "$linenr > $curr_values\n";

                         print "$linenr >  $curr_vars\n";

2531 }

                 $prev_values = substr($curr_values, -1);

2533

2534 #ignore lines not being added

                 next if ($line =~ /^[^\+]/);

2536

2537 # TEST: allow direct testing of the type matcher.

2538 if ($dbg_type) {

                         if ($line =~ /^.\s*$Declare\s*$/) {

2540 ERROR("TEST_TYPE",

                                       "TEST: is type\n" . $herecurr);

                         } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {

2543 ERROR("TEST_NOT_TYPE",

                                       "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) {

                         if ($line =~ /^.\s*$Modifier\s*$/) {

2551 ERROR("TEST_ATTR",

                                       "TEST: is attr\n" . $herecurr);

                         } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {

2554 ERROR("TEST_NOT_ATTR",

                                       "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

                 if ($line =~ /^.\s*{/ &&

2562 $prevline =~ /(?:^|[^=])=\s*$/) {

2563 ERROR("OPEN_BRACE",

                               "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)

                 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {

                         my $path = $1;

                         if ($path =~ m{//}) {

2575 ERROR("MALFORMED_INCLUDE",

                                       "malformed #include filename\n" . $herecurr);

2577 }

                         if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {

2579 ERROR("UAPI_INCLUDE",

                                       "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);

2581 }

2582 }

2583

2584 # no C99 // comments

                 if ($line =~ m{//}) {

                         if (ERROR("C99_COMMENTS",

                                   "do not use C99 // comments\n" . $herecurr) &&

2588 $fix) {

                                 my $line = $fixed[$linenr - 1];

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

                                         my $comment = trim($1);

                                         $fixed[$linenr - 1] =~ s@\/\/(.*)$@/\* $comment \*/@;

2593 }

2594 }

2595 }

2596 # Remove C99 comments.

                 $line =~ s@//.*@@;

                 $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";

                 if (defined $realline_next &&

                     exists $lines[$realline_next - 1] &&

                     !defined $suppress_export{$realline_next} &&

                     ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||

                      $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);

                         my $name = $1;

                         if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&

2614 $name =~ /^${Ident}_$2/) {

2615 #print "FOO C name<$name>\n";

                                 $suppress_export{$realline_next} = 1;

2617

                         } elsif ($stat !~ /(?:

2619 \n.}\s*$|

                                 ^.DEFINE_$Ident\(\Q$name\E\)|

                                 ^.DECLARE_$Ident\(\Q$name\E\)|

2622 ^.LIST_HEAD$\Q$name\E$|

                                 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|

                                 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()

2625 )/x) {

2626 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";

                                 $suppress_export{$realline_next} = 2;

2628 } else {

                                 $suppress_export{$realline_next} = 1;

2630 }

2631 }

                 if (!defined $suppress_export{$linenr} &&

2633 $prevline =~ /^.\s*$/ &&

                     ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||

2635 $line =~ /EXPORT_UNUSED_SYMBOL.*$(.*)$/)) {

2636 #print "FOO B <$lines[$linenr - 1]>\n";

                         $suppress_export{$linenr} = 2;

2638 }

                 if (defined $suppress_export{$linenr} &&

                     $suppress_export{$linenr} == 2) {

2641 WARN("EXPORT_SYMBOL",

                              "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);

2643 }

2644

2645 # check for global initialisers.

                 if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {

                         if (ERROR("GLOBAL_INITIALISERS",

2648 "do not initialise globals to 0 or NULL\n" .

2649 $herecurr) &&

2650 $fix) {

                                 $fixed[$linenr - 1] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;

2652 }

2653 }

2654 # check for static initialisers.

                 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {

                         if (ERROR("INITIALISED_STATIC",

2657 "do not initialise statics to 0 or NULL\n" .

2658 $herecurr) &&

2659 $fix) {

                                 $fixed[$linenr - 1] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;

2661 }

2662 }

2663

2664 # check for static const char * arrays.

                 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.

                 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()"

                 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {

                         if (ERROR("FUNCTION_WITHOUT_ARGS",

                                   "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&

2682 $fix) {

                                 $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

                 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {

                         if (WARN("DEFINE_PCI_DEVICE_TABLE",

                                  "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&

2691 $fix) {

                                 $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.

                 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",

                              "do not add new typedefs\n" . $herecurr);

2705 }

2706

2707 # * goes on variable not on type

2708 # (char*[ const])

                 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {

2710 #print "AA<$1>\n";

                         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.

                         while ($to =~ s/\*\s+\*/\*\*/) {

2719 }

2720

2721 ## print "1: from<$from> to<$to> ident<$ident>\n";

                         if ($from ne $to) {

                                 if (ERROR("POINTER_LOCATION",

                                           "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&

2725 $fix) {

                                         my $sub_from = $ident;

                                         my $sub_to = $ident;

2728 $sub_to =~ s/\Q$from\E/$to/;

                                         $fixed[$linenr - 1] =~

2730 s@\Q$sub_from\E@$sub_to@;

2731 }

2732 }

2733 }

                 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {

2735 #print "BB<$1>\n";

                         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.

                         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";

                         if ($from ne $to && $ident !~ /^$Modifier$/) {

                                 if (ERROR("POINTER_LOCATION",

                                           "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&

2752 $fix) {

2753

                                         my $sub_from = $match;

                                         my $sub_to = $match;

2756 $sub_to =~ s/\Q$from\E/$to/;

                                         $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

                 if ($line =~ /\bLINUX_VERSION_CODE\b/) {

2771 WARN("LINUX_VERSION_CODE",

                              "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

                 if ($line =~ /\bprintk_ratelimit\s*\(/) {

2777 WARN("PRINTK_RATELIMITED",

 "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.

                 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {

                         my $ok = 0;

                         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

                                 if ($lines[$ln - 1] =~ m{\bprintk\(}) {

                                         if ($rawlines[$ln - 1] !~ m{\\n"}) {

2794 $ok = 1;

2795 }

2796 last;

2797 }

2798 }

                         if ($ok == 0) {

2800 WARN("PRINTK_WITHOUT_KERN_LEVEL",

                                      "printk() should include KERN_ facility level\n" . $herecurr);

2802 }

2803 }

2804

                 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {

                         my $orig = $1;

                         my $level = lc($orig);

                         $level = "warn" if ($level eq "warning");

                         my $level2 = $level;

                         $level2 = "dbg" if ($level eq "debug");

2811 WARN("PREFER_PR_LEVEL",

                              "Prefer netdev_$level2(netdev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);

2813 }

2814

                 if ($line =~ /\bpr_warning\s*\(/) {

                         if (WARN("PREFER_PR_LEVEL",

                                  "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&

2818 $fix) {

                                 $fixed[$linenr - 1] =~

2820 s/\bpr_warning\b/pr_warn/;

2821 }

2822 }

2823

                 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {

                         my $orig = $1;

                         my $level = lc($orig);

                         $level = "warn" if ($level eq "warning");

                         $level = "dbg" if ($level eq "debug");

2829 WARN("PREFER_DEV_LEVEL",

                              "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

                 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and

                     !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {

2837 ERROR("OPEN_BRACE",

                               "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.

                 if ($line =~ /^.\s*{/ &&

2843 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {

2844 ERROR("OPEN_BRACE",

                               "open brace '{' following $1 go on the same line\n" . $hereprev);

2846 }

2847

2848 # missing space after union, struct or enum definition

                 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {

                         if (WARN("SPACING",

                                  "missing space after $1 definition\n" . $herecurr) &&

2852 $fix) {

                                 $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...)"

                 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {

                         my $declare = $1;

                         my $pre_pointer_space = $2;

                         my $post_pointer_space = $3;

                         my $funcname = $4;

                         my $post_funcname_space = $5;

                         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.

                         my $post_declare_space = "";

                         if ($declare =~ /(\s+)$/) {

2874 $post_declare_space = $1;

                                 $declare = rtrim($declare);

2876 }

                         if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {

2878 WARN("SPACING",

                                      "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...)"

                         if (defined $pre_pointer_space &&

2896 $pre_pointer_space =~ /^\s/) {

2897 WARN("SPACING",

                                      "Unnecessary space after function pointer open parenthesis\n" . $herecurr);

2899 }

2900

2901 # unnecessary space "type (* funcptr)(args...)"

                         if (defined $post_pointer_space &&

2903 $post_pointer_space =~ /^\s/) {

2904 WARN("SPACING",

                                      "Unnecessary space before function pointer name\n" . $herecurr);

2906 }

2907

2908 # unnecessary space "type (*funcptr )(args...)"

                         if (defined $post_funcname_space &&

2910 $post_funcname_space =~ /^\s/) {

2911 WARN("SPACING",

                                      "Unnecessary space after function pointer name\n" . $herecurr);

2913 }

2914

2915 # unnecessary space "type (*funcptr) (args...)"

                         if (defined $pre_args_space &&

2917 $pre_args_space =~ /^\s/) {

2918 WARN("SPACING",

                                      "Unnecessary space before function pointer arguments\n" . $herecurr);

2920 }

2921

                         if (show_type("SPACING") && $fix) {

                                 $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 }

                 while ($line =~ /(.*?\s)\[/g) {

                         my ($where, $prefix) = ($-[1], $1);

                         if ($prefix !~ /$Type\s+$/ &&

                             ($where != 0 || $prefix !~ /^.\s+$/) &&

2936 $prefix !~ /[{,]\s+$/) {

                                 if (ERROR("BRACKET_SPACE",

                                           "space prohibited before open square bracket '['\n" . $herecurr) &&

2939 $fix) {

                                     $fixed[$linenr - 1] =~

2941 s/^(\+.*?)\s+\[/$1\[/;

2942 }

2943 }

2944 }

2945

2946 # check for spaces between functions and their parentheses.

                 while ($line =~ /($Ident)\s+\(/g) {

                         my $name = $1;

                         my $ctx_before = substr($line, 0, $-[1]);

                         my $ctx = "$ctx_before$name";

2951

2952 # Ignore those directives where spaces _are_ permitted.

                         if ($name =~ /^(?:

                                 if|for|while|switch|return|case|

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.

                         } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {

2963

2964 # cpp #elif statement condition may start with a (

                         } 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.

                         } elsif ($ctx =~ /$Type$/) {

2970

2971 } else {

                                 if (WARN("SPACING",

                                          "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&

2974 $fix) {

                                         $fixed[$linenr - 1] =~

2976 s/\b$name\s+\(/$name\(/;

2977 }

2978 }

2979 }

2980

2981 # Check operator spacing.

                 if (!($line=~/\#\s*include/)) {

                         my $fixed_line = "";

                         my $line_fixed = 0;

2985

2986 my $ops = qr{

2987 <<=|>>=|<=|>=|==|!=|

                                 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|

2989 =>|->|<<|>>|<|>|=|!|~|

                                 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|

2991 \?:|\?|:

2992 }x;

                         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 = ();

                         my $off = 0;

3002

                         foreach my $el (@elements) {

                                 push(@fix_elements, substr($rawline, $off, length($el)));

                                 $off += length($el);

3006 }

3007

3008 $off = 0;

3009

                         my $blank = copy_spacing($opline);

                         my $last_after = -1;

3012

                         for (my $n = 0; $n < $#elements; $n += 2) {

3014

                                 my $good = $fix_elements[$n] . $fix_elements[$n + 1];

3016

3017 ## print("n: <$n> good: <$good>\n");

3018

                                 $off += length($elements[$n]);

3020

3021 # Pick up the preceding and succeeding characters.

                                 my $ca = substr($opline, 0, $off);

                                 my $cc = '';

                                 if (length($opline) >= ($off + length($elements[$n + 1]))) {

                                         $cc = substr($opline, $off + length($elements[$n + 1]));

3026 }

                                 my $cb = "$ca$;$cc";

3028

                                 my $a = '';

                                 $a = 'V' if ($elements[$n] ne '');

                                 $a = 'W' if ($elements[$n] =~ /\s$/);

                                 $a = 'C' if ($elements[$n] =~ /$;$/);

                                 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);

                                 $a = 'O' if ($elements[$n] eq '');

                                 $a = 'E' if ($ca =~ /^\s*$/);

3036

                                 my $op = $elements[$n + 1];

3038

                                 my $c = '';

                                 if (defined $elements[$n + 2]) {

                                         $c = 'V' if ($elements[$n + 2] ne '');

                                         $c = 'W' if ($elements[$n + 2] =~ /^\s/);

                                         $c = 'C' if ($elements[$n + 2] =~ /^$;/);

                                         $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);

                                         $c = 'O' if ($elements[$n + 2] eq '');

                                         $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);

3047 } else {

3048 $c = 'E';

3049 }

3050

                                 my $ctx = "${a}x${c}";

3052

                                 my $at = "(ctx:$ctx)";

3054

                                 my $ptr = substr($blank, 0, $off) . "^";

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

3057

3058 # Pull out the value of this operator.

                                 my $op_type = substr($curr_values, $off + 1, 1);

3060

3061 # Get the full operator variant.

                                 my $opv = $op . substr($curr_vars, $off, 1);

3063

3064 # Ignore operators passed as parameters.

                                 if ($op_type ne 'V' &&

                                     $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

                                 } elsif ($op eq ';') {

                                         if ($ctx !~ /.x[WEBC]/ &&

                                             $cc !~ /^\\/ && $cc !~ /^;/) {

                                                 if (ERROR("SPACING",

                                                           "space required after that '$op' $at\n" . $hereptr)) {

                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";

3078 $line_fixed = 1;

3079 }

3080 }

3081

3082 # // is a comment

                                 } elsif ($op eq '//') {

3084

3085 # No spaces for:

3086 # ->

3087 # : when part of a bitfield

                                 } elsif ($op eq '->' || $opv eq ':B') {

                                         if ($ctx =~ /Wx.|.xW/) {

                                                 if (ERROR("SPACING",

                                                           "spaces prohibited around that '$op' $at\n" . $hereptr)) {

                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);

                                                         if (defined $fix_elements[$n + 2]) {

                                                                 $fix_elements[$n + 2] =~ s/^\s+//;

3095 }

3096 $line_fixed = 1;

3097 }

3098 }

3099

3100 # , must have a space on the right.

                                 } elsif ($op eq ',') {

                                         if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {

                                                 if (ERROR("SPACING",

                                                           "space required after that '$op' $at\n" . $hereptr)) {

                                                         $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.

                                 } 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

                                 } elsif ($op eq '!' || $op eq '~' ||

                                          $opv eq '*U' || $opv eq '-U' ||

                                          $opv eq '&U' || $opv eq '&&U') {

                                         if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {

                                                 if (ERROR("SPACING",

                                                           "space required before that '$op' $at\n" . $hereptr)) {

                                                         if ($n != $last_after + 2) {

                                                                 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);

3126 $line_fixed = 1;

3127 }

3128 }

3129 }

                                         if ($op eq '*' && $cc =~/\s*$Modifier\b/) {

3131 # A unary '*' may be const

3132

                                         } elsif ($ctx =~ /.xW/) {

                                                 if (ERROR("SPACING",

                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {

                                                         $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);

                                                         if (defined $fix_elements[$n + 2]) {

                                                                 $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.

                                 } elsif ($op eq '++' or $op eq '--') {

                                         if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {

                                                 if (ERROR("SPACING",

                                                           "space required one side of that '$op' $at\n" . $hereptr)) {

                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";

3150 $line_fixed = 1;

3151 }

3152 }

                                         if ($ctx =~ /Wx[BE]/ ||

                                             ($ctx =~ /Wx./ && $cc =~ /^;/)) {

                                                 if (ERROR("SPACING",

                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {

                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);

3158 $line_fixed = 1;

3159 }

3160 }

                                         if ($ctx =~ /ExW/) {

                                                 if (ERROR("SPACING",

                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {

                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);

                                                         if (defined $fix_elements[$n + 2]) {

                                                                 $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

                                 } elsif ($op eq '<<' or $op eq '>>' or

                                          $op eq '&' or $op eq '^' or $op eq '|' or

                                          $op eq '+' or $op eq '-' or

                                          $op eq '*' or $op eq '/' or

3177 $op eq '%')

3178 {

                                         if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {

                                                 if (ERROR("SPACING",

                                                           "need consistent spacing around '$op' $at\n" . $hereptr)) {

                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";

                                                         if (defined $fix_elements[$n + 2]) {

                                                                 $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.

                                 } elsif ($opv eq ':C' || $opv eq ':L') {

                                         if ($ctx =~ /Wx./) {

                                                 if (ERROR("SPACING",

                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {

                                                         $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.

                                 } elsif ($ctx !~ /[EWC]x[CWE]/) {

                                         my $ok = 0;

3204

3205 # Ignore email addresses <foo@bar>

                                         if (($op eq '<' &&

3207 $cc =~ /^\S+\@\S+>/) ||

                                             ($op eq '>' &&

3209 $ca =~ /<\S+\@\S+$/))

3210 {

3211 $ok = 1;

3212 }

3213

3214 # messages are ERROR, but ?: are CHK

                                         if ($ok == 0) {

                                                 my $msg_type = \&ERROR;

                                                 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);

3218

                                                 if (&{$msg_type}("SPACING",

                                                                  "spaces required around that '$op' $at\n" . $hereptr)) {

                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";

                                                         if (defined $fix_elements[$n + 2]) {

                                                                 $fix_elements[$n + 2] =~ s/^\s+//;

3224 }

3225 $line_fixed = 1;

3226 }

3227 }

3228 }

                                 $off += length($elements[$n + 1]);

3230

3231 ## print("n: <$n> GOOD: <$good>\n");

3232

                                 $fixed_line = $fixed_line . $good;

3234 }

3235

                         if (($#elements % 2) == 0) {

                                 $fixed_line = $fixed_line . $fix_elements[$#elements];

3238 }

3239

                         if ($fix && $line_fixed && $fixed_line ne $fixed[$linenr - 1]) {

                                 $fixed[$linenr - 1] = $fixed_line;

3242 }

3243

3244

3245 }

3246

3247 # check for whitespace before a non-naked semicolon

                 if ($line =~ /^\+.*\S\s+;\s*$/) {

                         if (WARN("SPACING",

                                  "space prohibited before semicolon\n" . $herecurr) &&

3251 $fix) {

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

3253 s/^(\+.*\S)\s+;/$1;/;

3254 }

3255 }

3256

3257 # check for multiple assignments

                 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {

3259 CHK("MULTIPLE_ASSIGNMENTS",

                             "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

                 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||

3281 $line =~ /do{/) {

                         if (ERROR("SPACING",

                                   "space required before the open brace '{'\n" . $herecurr) &&

3284 $fix) {

                                 $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

                 if ($line =~ /}(?!(?:,|;|\)))\S/) {

                         if (ERROR("SPACING",

                                   "space required after that close brace '}'\n" . $herecurr) &&

3302 $fix) {

                                 $fixed[$linenr - 1] =~

3304 s/}((?!(?:,|;|\)))\S)/} $1/;

3305 }

3306 }

3307

3308 # check spacing on square brackets

                 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {

                         if (ERROR("SPACING",

                                   "space prohibited after that open square bracket '['\n" . $herecurr) &&

3312 $fix) {

                                 $fixed[$linenr - 1] =~

3314 s/\[\s+/\[/;

3315 }

3316 }

                 if ($line =~ /\s\]/) {

                         if (ERROR("SPACING",

                                   "space prohibited before that close square bracket ']'\n" . $herecurr) &&

3320 $fix) {

                                 $fixed[$linenr - 1] =~

3322 s/\s+\]/\]/;

3323 }

3324 }

3325

3326 # check spacing on parentheses

                 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&

3328 $line !~ /for\s*\(\s+;/) {

                         if (ERROR("SPACING",

                                   "space prohibited after that open parenthesis '('\n" . $herecurr) &&

3331 $fix) {

                                 $fixed[$linenr - 1] =~

3333 s/\(\s+/\(/;

3334 }

3335 }

                 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&

3337 $line !~ /for\s*$.*;\s+$/ &&

3338 $line !~ /:\s+\)/) {

                         if (ERROR("SPACING",

                                   "space prohibited before that close parenthesis ')'\n" . $herecurr) &&

3341 $fix) {

                                 $fixed[$linenr - 1] =~

3343 s/\s+\)/\)/;

3344 }

3345 }

3346

3347 #goto labels aren't indented, allow a single space however

                 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and

                    !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {

                         if (WARN("INDENTED_LABEL",

                                  "labels should not be indented\n" . $herecurr) &&

3352 $fix) {

                                 $fixed[$linenr - 1] =~

3354 s/^(.)\s+/$1/;

3355 }

3356 }

3357

3358 # Return is not a function.

                 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {

                         my $spacing = $1;

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

3362 $stat =~ /^.\s*return\s*$balanced_parens\s*;\s*$/) {

3363 ERROR("RETURN_PARENTHESES",

                                       "return is not a function, parentheses are not required\n" . $herecurr);

3365

                         } elsif ($spacing !~ /\s+/) {

3367 ERROR("SPACING",

                                       "space required before the open parenthesis '('\n" . $herecurr);

3369 }

3370 }

3371

3372 # if statements using unnecessary parentheses - ie: if ((foo == bar))

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

3374 $line =~ /\bif\s*((?:\(\s*){2,})/) {

                         my $openparens = $1;

                         my $count = $openparens =~ tr@\(@\(@;

                         my $msg = "";

                         if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {

                                 my $comp = $4;  #Not $1 because of $LvalOrFunc

                                 $msg = " - maybe == should be = ?" if ($comp eq "==");

3381 WARN("UNNECESSARY_PARENTHESES",

                                      "Unnecessary parentheses$msg\n" . $herecurr);

3383 }

3384 }

3385

3386 # Return of what appears to be an errno should normally be -'ve

                 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {

                         my $name = $1;

                         if ($name ne 'EOF' && $name ne 'ERROR') {

3390 WARN("USE_NEGATIVE_ERRNO",

                                      "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

                 if ($line =~ /\b(if|while|for|switch)\(/) {

                         if (ERROR("SPACING",

                                   "space required before the open parenthesis '('\n" . $herecurr) &&

3399 $fix) {

                                 $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.

                 if ($line =~ /do\s*(?!{)/) {

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

3409 ctx_statement_block($linenr, $realcnt, 0)

                                         if (!defined $stat);

                         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

                         if ($stat_next =~ /^\s*while\b/) {

3417 # If the statement carries leading newlines,

3418 # then count those as offsets.

3419 my ($whitespace) =

                                         ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);

3421 my $offset =

                                         statement_rawlines($whitespace) - 1;

3423

3424 $suppress_whiletrailers{$line_nr_next +

3425 $offset} = 1;

3426 }

3427 }

                 if (!defined $suppress_whiletrailers{$linenr} &&

                     defined($stat) && defined($cond) &&

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

                         my ($s, $c) = ($stat, $cond);

3432

                         if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {

3434 ERROR("ASSIGN_IN_IF",

                                       "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.

                         substr($s, 0, length($c), '');

3441 $s =~ s/\n.*//g;

                         $s =~ s/$;//g;  # Remove any comments

                         if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&

3444 $c !~ /}\s*while\s*/)

3445 {

3446 # Find out how long the conditional actually is.

                                 my @newlines = ($c =~ /\n/gs);

                                 my $cond_lines = 1 + $#newlines;

                                 my $stat_real = '';

3450

                                 $stat_real = raw_line($linenr, $cond_lines)

                                                         . "\n" if ($cond_lines);

                                 if (defined($stat_real) && $cond_lines > 1) {

                                         $stat_real = "[...]\n$stat_real";

3455 }

3456

3457 ERROR("TRAILING_STATEMENTS",

                                       "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 (?:

                                 (?:\[|\(|\&\&|\|\|)

                                 \s*0[xX][0-9]+\s*

                                 (?:\&\&|\|\|)

3468 |

                                 (?:\&\&|\|\|)

                                 \s*0[xX][0-9]+\s*

                                 (?:\&\&|\|\||\)|\])

3472 )/x)

3473 {

3474 WARN("HEXADECIMAL_BOOLEAN_TEST",

                              "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);

3476 }

3477

3478 # if and else should not have general statements after it

                 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {

                         my $s = $1;

                         $s =~ s/$;//g;  # Remove any comments

                         if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {

3483 ERROR("TRAILING_STATEMENTS",

                                       "trailing statements should be on next line\n" . $herecurr);

3485 }

3486 }

3487 # if should not continue a brace

                 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

                 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&

3495 $line !~ /\G(?:

                         (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|

3497 \s*return\s+

3498 )/xg)

3499 {

3500 ERROR("TRAILING_STATEMENTS",

                               "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.

                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and

3507 $previndent == $indent) {

3508 ERROR("ELSE_AFTER_BRACE",

                               "else should follow close brace '}'\n" . $hereprev);

3510 }

3511

                 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and

3513 $previndent == $indent) {

                         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.

                         substr($s, 0, length($c), '');

3519 $s =~ s/\n.*//g;

3520

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

3522 ERROR("WHILE_AFTER_BRACE",

                                       "while should follow close brace '}'\n" . $hereprev);

3524 }

3525 }

3526

3527 #Specific variable tests

                 while ($line =~ m{($Constant|$Lval)}g) {

                         my $var = $1;

3530

3531 #gcc binary extension

                         if ($var =~ /^$Binary$/) {

                                 if (WARN("GCC_BINARY_CONSTANT",

                                          "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&

3535 $fix) {

                                         my $hexval = sprintf("0x%x", oct($var));

                                         $fixed[$linenr - 1] =~

3538 s/\b$var\b/$hexval/;

3539 }

3540 }

3541

3542 #CamelCase

                         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_]+)?$/) {

                                 while ($var =~ m{($Ident)}g) {

                                         my $word = $1;

                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);

3552 if ($check) {

3553 seed_camelcase_includes();

                                                 if (!$file && !$camelcase_file_seeded) {

3555 seed_camelcase_file($realfile);

3556 $camelcase_file_seeded = 1;

3557 }

3558 }

                                         if (!defined $camelcase{$word}) {

                                                 $camelcase{$word} = 1;

3561 CHK("CAMELCASE",

                                                     "Avoid CamelCase: <$word>\n" . $herecurr);

3563 }

3564 }

3565 }

3566 }

3567

3568 #no spaces allowed after \ in define

                 if ($line =~ /\#\s*define.*\\\s+$/) {

                         if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",

                                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&

3572 $fix) {

                                 $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)

                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {

                         my $file = "$1.h";

                         my $checkfile = "include/linux/$file";

                         if (-f "$root/$checkfile" &&

3582 $realfile ne $checkfile &&

3583 $1 !~ /$allowed_asm_includes/)

3584 {

                                 if ($realfile =~ m{^arch/}) {

3586 CHK("ARCH_INCLUDE_LINUX",

                                             "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);

3588 } else {

3589 WARN("INCLUDE_LINUX",

                                              "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

                 if ($realfile !~ m@/vmlinux.lds.h$@ &&

3599 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {

                         my $ln = $linenr;

                         my $cnt = $realcnt;

3602 my ($off, $dstat, $dcond, $rest);

                         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

                         while ($dstat =~ s/\([^\(\)]*\)/1/ ||

3618 $dstat =~ s/\{[^\{\}]*\}/1/ ||

3619 $dstat =~ s/\[[^\[\]]*\]/1/)

3620 {

3621 }

3622

3623 # Flatten any obvious string concatentation.

                         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*|

                                 ^\"|\"$

3640 }x;

3641 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";

                         if ($dstat ne '' &&

                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),

                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();

                             $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&          # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz

                             $dstat !~ /^'X'$/ &&                                        # character constants

3647 $dstat !~ /$exceptions/ &&

                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =

                             $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo

                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)

                             $dstat !~ /^for\s*$Constant$/ &&                            # for (...)

                             $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()

                             $dstat !~ /^do\s*{/ &&                                      # do {...

                             $dstat !~ /^\({/ &&                                         # ({...

3655 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)

3656 {

3657 $ctx =~ s/\n*$//;

                                 my $herectx = $here . "\n";

                                 my $cnt = statement_rawlines($ctx);

3660

                                 for (my $n = 0; $n < $cnt; $n++) {

                                         $herectx .= raw_line($linenr, $n) . "\n";

3663 }

3664

                                 if ($dstat =~ /;/) {

3666 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",

                                               "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");

3668 } else {

3669 ERROR("COMPLEX_MACRO",

                                               "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 {

                         if ($prevline !~ /^..*\\$/ &&

                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor

                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm

3680 $line =~ /^\+.*\\$/) {

3681 WARN("LINE_CONTINUATIONS",

                                      "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

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

                     $realfile !~ m@/vmlinux.lds.h$@ &&

3691 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {

                         my $ln = $linenr;

                         my $cnt = $realcnt;

3694 my ($off, $dstat, $dcond, $rest);

                         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

                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {

                                 my $stmts = $2;

                                 my $semis = $3;

3705

3706 $ctx =~ s/\n*$//;

                                 my $cnt = statement_rawlines($ctx);

                                 my $herectx = $here . "\n";

3709

                                 for (my $n = 0; $n < $cnt; $n++) {

                                         $herectx .= raw_line($linenr, $n) . "\n";

3712 }

3713

                                 if (($stmts =~ tr/;/;/) == 1 &&

3715 $stmts !~ /^\s*(if|while|for|switch)\b/) {

3716 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",

                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");

3718 }

                                 if (defined $semis && $semis ne "") {

3720 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",

                                              "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(...)

                 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {

3732 WARN("MISSING_VMLINUX_SYMBOL",

                              "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);

3734 }

3735

3736 # check for redundant bracing round if etc

                 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";

                         if ($#chunks > 0 && $level == 0) {

3743 my @allowed = ();

                                 my $allow = 0;

                                 my $seen = 0;

                                 my $herectx = $here . "\n";

                                 my $ln = $linenr - 1;

                                 for my $chunk (@chunks) {

                                         my ($cond, $block) = @{$chunk};

3750

3751 # If the condition carries leading newlines, then count those as offsets.

                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);

                                         my $offset = statement_rawlines($whitespace) - 1;

3754

                                         $allowed[$allow] = 0;

3756 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";

3757

3758 # We have looked at and allowed this specific line.

                                         $suppress_ifbraces{$ln + $offset} = 1;

3760

                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";

                                         $ln += statement_rawlines($block) - 1;

3763

                                         substr($block, 0, length($cond), '');

3765

                                         $seen++ if ($block =~ /^\s*{/);

3767

3768 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";

                                         if (statement_lines($cond) > 1) {

3770 #print "APW: ALLOWED: cond<$cond>\n";

                                                 $allowed[$allow] = 1;

3772 }

                                         if ($block =~/\b(?:if|for|while)\b/) {

3774 #print "APW: ALLOWED: block<$block>\n";

                                                 $allowed[$allow] = 1;

3776 }

                                         if (statement_block_size($block) > 1) {

3778 #print "APW: ALLOWED: lines block<$block>\n";

                                                 $allowed[$allow] = 1;

3780 }

3781 $allow++;

3782 }

3783 if ($seen) {

                                         my $sum_allowed = 0;

3785 foreach (@allowed) {

3786 $sum_allowed += $_;

3787 }

                                         if ($sum_allowed == 0) {

3789 WARN("BRACES",

                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);

                                         } elsif ($sum_allowed != $allow &&

3792 $seen != $allow) {

3793 CHK("BRACES",

                                                     "braces {} should be used on all arms of this statement\n" . $herectx);

3795 }

3796 }

3797 }

3798 }

                 if (!defined $suppress_ifbraces{$linenr - 1} &&

3800 $line =~ /\b(if|while|for|else)\b/) {

                         my $allowed = 0;

3802

3803 # Check the pre-context.

                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {

3805 #print "APW: ALLOWED: pre<$1>\n";

3806 $allowed = 1;

3807 }

3808

3809 my ($level, $endln, @chunks) =

                                 ctx_statement_full($linenr, $realcnt, $-[0]);

3811

3812 # Check the condition.

                         my ($cond, $block) = @{$chunks[0]};

3814 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";

                         if (defined $cond) {

                                 substr($block, 0, length($cond), '');

3817 }

                         if (statement_lines($cond) > 1) {

3819 #print "APW: ALLOWED: cond<$cond>\n";

3820 $allowed = 1;

3821 }

                         if ($block =~/\b(?:if|for|while)\b/) {

3823 #print "APW: ALLOWED: block<$block>\n";

3824 $allowed = 1;

3825 }

                         if (statement_block_size($block) > 1) {

3827 #print "APW: ALLOWED: lines block<$block>\n";

3828 $allowed = 1;

3829 }

3830 # Check the post-context.

                         if (defined $chunks[1]) {

                                 my ($cond, $block) = @{$chunks[1]};

                                 if (defined $cond) {

                                         substr($block, 0, length($cond), '');

3835 }

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

3837 #print "APW: ALLOWED: chunk-1 block<$block>\n";

3838 $allowed = 1;

3839 }

3840 }

                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {

                                 my $herectx = $here . "\n";

                                 my $cnt = statement_rawlines($block);

3844

                                 for (my $n = 0; $n < $cnt; $n++) {

                                         $herectx .= raw_line($linenr, $n) . "\n";

3847 }

3848

3849 WARN("BRACES",

                                      "braces {} are not necessary for single statement blocks\n" . $herectx);

3851 }

3852 }

3853

3854 # check for unnecessary blank lines around braces

                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {

3856 CHK("BRACES",

                             "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);

3858 }

                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {

3860 CHK("BRACES",

                             "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);

3862 }

3863

3864 # no volatiles please

                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};

                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {

3867 WARN("VOLATILE",

                              "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);

3869 }

3870

3871 # warn about #if 0

                 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

                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {

                         my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';

                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {

3882 WARN('NEEDLESS_IF',

                                      "$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)

                 if ($line =~ /(\b$InitAttribute\b)/) {

                         my $attr = $1;

                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {

                                 my $ptr = $1;

                                 my $var = $2;

                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&

3894 ERROR("MISPLACED_INIT",

                                             "$attr should be placed after $var\n" . $herecurr)) ||

                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&

3897 WARN("MISPLACED_INIT",

                                            "$attr should be placed after $var\n" . $herecurr))) &&

3899 $fix) {

                                         $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

                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {

                         my $attr = $1;

3908 $attr =~ /($InitAttributePrefix)(.*)/;

                         my $attr_prefix = $1;

                         my $attr_type = $2;

                         if (ERROR("INIT_ATTRIBUTE",

                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&

3913 $fix) {

                                 $fixed[$linenr - 1] =~

3915 s/$InitAttributeData/${attr_prefix}initconst/;

3916 }

3917 }

3918

3919 # check for $InitAttributeConst (ie: __initconst) without const

                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {

                         my $attr = $1;

                         if (ERROR("INIT_ATTRIBUTE",

                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&

3924 $fix) {

                                 my $lead = $fixed[$linenr - 1] =~

3926 /(^\+\s*(?:static\s+))/;

                                 $lead = rtrim($1);

                                 $lead = "$lead " if ($lead !~ /^\+$/);

3929 $lead = "${lead}const ";

                                 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;

3931 }

3932 }

3933

3934 # don't use __constant_<foo> functions outside of include/uapi/

                 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*\(/) {

                         my $constant_func = $1;

                         my $func = $constant_func;

3939 $func =~ s/^__constant_//;

                         if (WARN("CONSTANT_CONVERSION",

                                  "$constant_func should be $func\n" . $herecurr) &&

3942 $fix) {

                                 $fixed[$linenr - 1] =~ s/\b$constant_func\b/$func/g;

3944 }

3945 }

3946

3947 # prefer usleep_range over udelay

                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {

                         my $delay = $1;

3950 # ignore udelay's < 10, however

                         if (! ($delay < 10) ) {

3952 CHK("USLEEP_RANGE",

                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);

3954 }

                         if ($delay > 2000) {

3956 WARN("LONG_UDELAY",

                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);

3958 }

3959 }

3960

3961 # warn about unexpectedly long msleep's

                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {

                         if ($1 < 20) {

3964 WARN("MSLEEP",

                                      "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

                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {

3971 WARN("JIFFIES_COMPARISON",

                              "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()

                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {

3977 WARN("JIFFIES_COMPARISON",

                              "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

                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {

                         if (ERROR("SPACING",

                                   "exactly one space required after that #$1\n" . $herecurr) &&

3992 $fix) {

                                 $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.

                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||

4001 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {

                         my $which = $1;

                         if (!ctx_has_comment($first_line, $linenr)) {

4004 CHK("UNCOMMENTED_DEFINITION",

                                     "$1 definition without comment\n" . $herecurr);

4006 }

4007 }

4008 # check for memory barriers without a comment.

                 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {

                         if (!ctx_has_comment($first_line, $linenr)) {

4011 WARN("MEMORY_BARRIER",

                                      "memory barrier without comment\n" . $herecurr);

4013 }

4014 }

4015 # check of hardware specific defines

                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {

4017 CHK("ARCH_DEFINES",

                             "architecture specific defines should be avoided\n" .  $herecurr);

4019 }

4020

4021 # Check that the storage class is at the beginning of a declaration

                 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {

4023 WARN("STORAGE_CLASS",

                              "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.

                 if ($line =~ /\b$Type\s+$Inline\b/ ||

4030 $line =~ /\b$Inline\s+$Storage\b/) {

4031 ERROR("INLINE_LOCATION",

                               "inline keyword should sit between storage class and type\n" . $herecurr);

4033 }

4034

4035 # Check for __inline__ and __inline, prefer inline

                 if ($realfile !~ m@\binclude/uapi/@ &&

4037 $line =~ /\b(__inline__|__inline)\b/) {

                         if (WARN("INLINE",

                                  "plain inline is preferred over $1\n" . $herecurr) &&

4040 $fix) {

                                 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/;

4042

4043 }

4044 }

4045

4046 # Check for __attribute__ packed, prefer __packed

                 if ($realfile !~ m@\binclude/uapi/@ &&

4048 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {

4049 WARN("PREFER_PACKED",

                              "__packed is preferred over __attribute__((packed))\n" . $herecurr);

4051 }

4052

4053 # Check for __attribute__ aligned, prefer __aligned

                 if ($realfile !~ m@\binclude/uapi/@ &&

4055 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {

4056 WARN("PREFER_ALIGNED",

                              "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);

4058 }

4059

4060 # Check for __attribute__ format(printf, prefer __printf

                 if ($realfile !~ m@\binclude/uapi/@ &&

4062 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {

                         if (WARN("PREFER_PRINTF",

                                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&

4065 $fix) {

                                 $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

                 if ($realfile !~ m@\binclude/uapi/@ &&

4073 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {

                         if (WARN("PREFER_SCANF",

                                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&

4076 $fix) {

                                 $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(&)

                 if ($line =~ /\bsizeof\s*\(\s*\&/) {

4083 WARN("SIZEOF_ADDRESS",

                              "sizeof(& should be avoided\n" . $herecurr);

4085 }

4086

4087 # check for sizeof without parenthesis

                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {

                         if (WARN("SIZEOF_PARENTHESIS",

                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&

4091 $fix) {

                                 $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 "

                 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {

4098 WARN("LINE_CONTINUATIONS",

                              "Avoid line continuations in quoted strings\n" . $herecurr);

4100 }

4101

4102 # check for struct spinlock declarations

                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {

4104 WARN("USE_SPINLOCK_T",

                              "struct spinlock should be spinlock_t\n" . $herecurr);

4106 }

4107

4108 # check for seq_printf uses that could be seq_puts

                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {

                         my $fmt = get_quoted_string($line, $rawline);

                         if ($fmt ne "" && $fmt !~ /[^\\]\%/) {

                                 if (WARN("PREFER_SEQ_PUTS",

                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&

4114 $fix) {

                                         $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/;

4116 }

4117 }

4118 }

4119

4120 # Check for misused memsets

                 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

                         my $ms_addr = $2;

                         my $ms_val = $7;

                         my $ms_size = $12;

4128

                         if ($ms_size =~ /^(0x|)0$/i) {

4130 ERROR("MEMSET",

                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");

                         } elsif ($ms_size =~ /^(0x|)1$/i) {

4133 WARN("MEMSET",

                                      "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)

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

4140 $line =~ /^\+(?:.*?)\bmemcpy\s*$\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*$/s) {

                         if (WARN("PREFER_ETHER_ADDR_COPY",

                                  "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&

4143 $fix) {

                                 $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

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

4150 defined $stat &&

4151 $stat =~ /^\+(?:.*?)\b(min|max)\s*$\s*$FuncArg\s*,\s*$FuncArg\s*$/) {

                         if (defined $2 || defined $7) {

                                 my $call = $1;

                                 my $cast1 = deparenthesize($2);

                                 my $arg1 = $3;

                                 my $cast2 = deparenthesize($7);

                                 my $arg2 = $8;

4158 my $cast;

4159

                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {

                                         $cast = "$cast1 or $cast2";

                                 } elsif ($cast1 ne "") {

4163 $cast = $cast1;

4164 } else {

4165 $cast = $cast2;

4166 }

4167 WARN("MINMAX",

                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");

4169 }

4170 }

4171

4172 # check usleep_range arguments

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

4174 defined $stat &&

4175 $stat =~ /^\+(?:.*?)\busleep_range\s*$\s*($FuncArg)\s*,\s*($FuncArg)\s*$/) {

                         my $min = $1;

                         my $max = $7;

                         if ($min eq $max) {

4179 WARN("USLEEP_RANGE",

                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");

                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&

4182 $min > $max) {

4183 WARN("USLEEP_RANGE",

                                      "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

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

4190 defined $stat &&

4191 $stat =~ /\bsscanf\b/ &&

                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&

4193 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&

4194 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {

                         my $lc = $stat =~ tr@\n@@;

                         $lc = $lc + $linenr;

                         my $stat_real = raw_line($linenr, 0);

                         for (my $count = $linenr + 1; $count <= $lc; $count++) {

                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);

4200 }

4201 WARN("NAKED_SSCANF",

                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");

4203 }

4204

4205 # check for new externs in .h files.

                 if ($realfile =~ /\.h$/ &&

4207 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {

                         if (CHK("AVOID_EXTERNS",

                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&

4210 $fix) {

                                 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;

4212 }

4213 }

4214

4215 # check for new externs in .c files.

                 if ($realfile =~ /\.c$/ && defined $stat &&

4217 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)

4218 {

                         my $function_name = $1;

                         my $paren_space = $2;

4221

                         my $s = $stat;

                         if (defined $cond) {

                                 substr($s, 0, length($cond), '');

4225 }

                         if ($s =~ /^\s*;/ &&

4227 $function_name ne 'uninitialized_var')

4228 {

4229 WARN("AVOID_EXTERNS",

                                      "externs should be avoided in .c files\n" .  $herecurr);

4231 }

4232

                         if ($paren_space =~ /\n/) {

4234 WARN("FUNCTION_ARGUMENTS",

                                      "arguments for function declarations should follow identifier\n" . $herecurr);

4236 }

4237

                 } elsif ($realfile =~ /\.c$/ && defined $stat &&

4239 $stat =~ /^.\s*extern\s+/)

4240 {

4241 WARN("AVOID_EXTERNS",

                              "externs should be avoided in .c files\n" .  $herecurr);

4243 }

4244

4245 # checks for new __setup's

                 if ($rawline =~ /\b__setup\("([^"]*)"/) {

                         my $name = $1;

4248

                         if (!grep(/$name/, @setup_docs)) {

4250 CHK("UNDOCUMENTED_SETUP",

                                     "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);

4252 }

4253 }

4254

4255 # check for pointless casting of kmalloc return

                 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {

4257 WARN("UNNECESSARY_CASTS",

                              "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), ...)

                 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",

                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);

4267 }

4268

4269 # check for krealloc arg reuse

                 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",

                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);

4274 }

4275

4276 # check for alloc argument mismatch

                 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {

4278 WARN("ALLOC_ARRAY_ARGS",

                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);

4280 }

4281

4282 # check for GFP_NOWAIT use

                 if ($line =~ /\b__GFP_NOFAIL\b/) {

4284 WARN("__GFP_NOFAIL",

                              "Use of __GFP_NOFAIL is deprecated, no new users should be added\n" . $herecurr);

4286 }

4287

4288 # check for multiple semicolons

                 if ($line =~ /;\s*;\s*$/) {

                         if (WARN("ONE_SEMICOLON",

                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&

4292 $fix) {

                                 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g;

4294 }

4295 }

4296

4297 # check for case / default statements not preceeded by break/fallthrough/switch

                 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {

                         my $has_break = 0;

                         my $has_statement = 0;

                         my $count = 0;

                         my $prevline = $linenr;

                         while ($prevline > 1 && $count < 3 && !$has_break) {

4304 $prevline--;

                                 my $rline = $rawlines[$prevline - 1];

                                 my $fline = $lines[$prevline - 1];

                                 last if ($fline =~ /^\@\@/);

                                 next if ($fline =~ /^\-/);

                                 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);

                                 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);

                                 next if ($fline =~ /^.[\s$;]*$/);

4312 $has_statement = 1;

4313 $count++;

                                 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);

4315 }

                         if (!$has_break && $has_statement) {

4317 WARN("MISSING_BREAK",

                                      "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;

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

4324 defined $stat &&

4325 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {

                         my $ctx = '';

                         my $herectx = $here . "\n";

                         my $cnt = statement_rawlines($stat);

                         for (my $n = 0; $n < $cnt; $n++) {

                                 $herectx .= raw_line($linenr, $n) . "\n";

4331 }

4332 WARN("DEFAULT_NO_BREAK",

                              "switch default: should use break\n" . $herectx);

4334 }

4335

4336 # check for gcc specific __FUNCTION__

                 if ($line =~ /\b__FUNCTION__\b/) {

                         if (WARN("USE_FUNC",

                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&

4340 $fix) {

                                 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g;

4342 }

4343 }

4344

4345 # check for use of yield()

                 if ($line =~ /\byield\s*\(\s*\)/) {

4347 WARN("YIELD",

                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);

4349 }

4350

4351 # check for comparisons against true and false

                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {

                         my $lead = $1;

                         my $arg = $2;

                         my $test = $3;

                         my $otype = $4;

                         my $trail = $5;

                         my $op = "!";

4359

                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);

4361

                         my $type = lc($otype);

                         if ($type =~ /^(?:true|false)$/) {

                                 if (("$test" eq "==" && "$type" eq "true") ||

                                     ("$test" eq "!=" && "$type" eq "false")) {

4366 $op = "";

4367 }

4368

4369 CHK("BOOL_COMPARISON",

                                     "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

                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {

4380 WARN("CONSIDER_COMPLETION",

                              "consider using a completion\n" . $herecurr);

4382 }

4383

4384 # recommend kstrto* over simple_strto* and strict_strto*

                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {

4386 WARN("CONSIDER_KSTRTO",

                              "$1 is obsolete, use k$3 instead\n" . $herecurr);

4388 }

4389

4390 # check for __initcall(), use device_initcall() explicitly please

                 if ($line =~ /^.\s*__initcall\s*\(/) {

4392 WARN("USE_DEVICE_INITCALL",

                              "please use device_initcall() instead of __initcall()\n" . $herecurr);

4394 }

4395

4396 # check for various ops structs, ensure they are const.

                 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;

                 if ($line !~ /\bconst\b/ &&

4435 $line =~ /\bstruct\s+($struct_ops)\b/) {

4436 WARN("CONST_STRUCT",

                              "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

                 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",

                              "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.

                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {

4456 ERROR("DEFINE_ARCH_HAS",

                               "#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;

                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {

                         $string = substr($rawline, $-[1], $+[1] - $-[1]);

4464 $string =~ s/%%/__/g;

                         if ($string =~ /(?<!%)%L[udi]/) {

4466 WARN("PRINTF_L",

                                      "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);

4468 last;

4469 }

4470 }

4471

4472 # whine mightly about in_atomic

                 if ($line =~ /\bin_atomic\s*\(/) {

                         if ($realfile =~ m@^drivers/@) {

4475 ERROR("IN_ATOMIC",

                                       "do not use in_atomic in drivers\n" . $herecurr);

                         } elsif ($realfile !~ m@^kernel/@) {

4478 WARN("IN_ATOMIC",

                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);

4480 }

4481 }

4482

4483 # check for lockdep_set_novalidate_class

                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||

4485 $line =~ /__lockdep_no_validate__\s*\)/ ) {

                         if ($realfile !~ m@^kernel/lockdep@ &&

4487 $realfile !~ m@^include/linux/lockdep@ &&

4488 $realfile !~ m@^drivers/base/core@) {

4489 ERROR("LOCKDEP",

                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);

4491 }

4492 }

4493

                 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||

4495 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {

4496 WARN("EXPORTED_WORLD_WRITABLE",

                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);

4498 }

4499

                 foreach my $entry (@mode_permission_funcs) {

                         my $func = $entry->[0];

                         my $arg_pos = $entry->[1];

4503

                         my $skip_args = "";

                         if ($arg_pos > 1) {

4506 $arg_pos--;

                                 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";

4508 }

                         my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";

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

4511 $line =~ /$test/) {

                                 my $val = $1;

                                 $val = $6 if ($skip_args ne "");

4514

                                 if ($val =~ /^$Int$/ && $val !~ /^$Octal$/) {

4516 ERROR("NON_OCTAL_PERMISSIONS",

                                               "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.

         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.

         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.

         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 }

         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();

         if ($summary && !($clean == 1 && $quiet == 1)) {

                 print "$filename " if ($summary_file);

                 print "total: $cnt_error errors, $cnt_warn warnings, " .

                         (($check)? "$cnt_chk checks, " : "") .

                         "$cnt_lines lines checked\n";

                 print "\n" if ($quiet == 0);

4557 }

4558

         if ($quiet == 0) {

4560

                 if ($^V lt 5.10.0) {

                         print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");

                         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) {

                         print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";

                         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

         if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {

                 my $newfile = $filename;

                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);

                 my $linecount = 0;

4582 my $f;

4583

                 open($f, '>', $newfile)

                     or die "$P: Can't open $newfile for write\n";

                 foreach my $fixed_line (@fixed) {

4587 $linecount++;

4588 if ($file) {

                                 if ($linecount > 3) {

4590 $fixed_line =~ s/^\+//;

                                         print $f $fixed_line. "\n";

4592 }

4593 } else {

                                 print $f $fixed_line . "\n";

4595 }

4596 }

4597 close($f);

4598

4599 if (!$quiet) {

4600 print << "EOM";

 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

         if ($clean == 1 && $quiet == 0) {

                 print "$vname has no obvious style problems and is ready for submission.\n"

4615 }

         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 }