Doug / smarc-fsl-linux-kernel

1

#!/usr/bin/perl -w

1

#!/usr/bin/perl -w

2

3

4

5

6

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

6

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

7

8

use strict;

8

use strict;

9

10

my $P = $0;

10

my $P = $0;

11

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

11

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

12

13

my $V = '0.30';

13

my $V = '0.30';

14

15

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

15

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

16

17

my $quiet = 0;

17

my $quiet = 0;

18

my $tree = 1;

18

my $tree = 1;

19

my $chk_signoff = 1;

19

my $chk_signoff = 1;

20

my $chk_patch = 1;

20

my $chk_patch = 1;

21

my $tst_only;

21

my $tst_only;

22

my $emacs = 0;

22

my $emacs = 0;

23

my $terse = 0;

23

my $terse = 0;

24

my $file = 0;

24

my $file = 0;

25

my $check = 0;

25

my $check = 0;

26

my $summary = 1;

26

my $summary = 1;

27

my $mailback = 0;

27

my $mailback = 0;

28

my $summary_file = 0;

28

my $summary_file = 0;

29

my $root;

29

my $root;

30

my %debug;

30

my %debug;

31

my $help = 0;

31

my $help = 0;

32

33

sub help {

33

sub help {

34

my ($exitcode) = @_;

34

my ($exitcode) = @_;

35

36

print << "EOM";

36

print << "EOM";

37

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

37

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

38

Version: $V

38

Version: $V

39

40

Options:

40

Options:

41

-q, --quiet quiet

41

-q, --quiet quiet

42

--no-tree run without a kernel tree

42

--no-tree run without a kernel tree

43

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

43

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

44

--patch treat FILE as patchfile (default)

44

--patch treat FILE as patchfile (default)

45

--emacs emacs compile window format

45

--emacs emacs compile window format

46

--terse one line per report

46

--terse one line per report

47

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

47

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

48

--subjective, --strict enable more subjective tests

48

--subjective, --strict enable more subjective tests

49

--root=PATH PATH to the kernel tree root

49

--root=PATH PATH to the kernel tree root

50

--no-summary suppress the per-file summary

50

--no-summary suppress the per-file summary

51

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

51

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

52

--summary-file include the filename in summary

52

--summary-file include the filename in summary

53

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

53

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

54

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

54

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

55

is all off)

55

is all off)

56

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

56

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

57

literally

57

literally

58

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

58

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

59

60

When FILE is - read standard input.

60

When FILE is - read standard input.

61

EOM

61

EOM

62

63

exit($exitcode);

63

exit($exitcode);

64

}

64

}

65

66

GetOptions(

66

GetOptions(

67

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

67

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

68

'tree!' => \$tree,

68

'tree!' => \$tree,

69

'signoff!' => \$chk_signoff,

69

'signoff!' => \$chk_signoff,

70

'patch!' => \$chk_patch,

70

'patch!' => \$chk_patch,

71

'emacs!' => \$emacs,

71

'emacs!' => \$emacs,

72

'terse!' => \$terse,

72

'terse!' => \$terse,

73

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

73

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

74

'subjective!' => \$check,

74

'subjective!' => \$check,

75

'strict!' => \$check,

75

'strict!' => \$check,

76

'root=s' => \$root,

76

'root=s' => \$root,

77

'summary!' => \$summary,

77

'summary!' => \$summary,

78

'mailback!' => \$mailback,

78

'mailback!' => \$mailback,

79

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

79

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

80

81

'debug=s' => \%debug,

81

'debug=s' => \%debug,

82

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

82

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

83

'h|help' => \$help,

83

'h|help' => \$help,

84

'version' => \$help

84

'version' => \$help

85

) or help(1);

85

) or help(1);

86

87

help(0) if ($help);

87

help(0) if ($help);

88

89

my $exit = 0;

89

my $exit = 0;

90

91

if ($#ARGV < 0) {

91

if ($#ARGV < 0) {

92

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

92

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

93

exit(1);

93

exit(1);

94

}

94

}

95

96

my $dbg_values = 0;

96

my $dbg_values = 0;

97

my $dbg_possible = 0;

97

my $dbg_possible = 0;

98

my $dbg_type = 0;

98

my $dbg_type = 0;

99

my $dbg_attr = 0;

99

my $dbg_attr = 0;

100

for my $key (keys %debug) {

100

for my $key (keys %debug) {

101

## no critic

101

## no critic

102

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

102

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

103

die "$@" if ($@);

103

die "$@" if ($@);

104

}

104

}

105

106

my $rpt_cleaners = 0;

106

my $rpt_cleaners = 0;

107

108

if ($terse) {

108

if ($terse) {

109

$emacs = 1;

109

$emacs = 1;

110

$quiet++;

110

$quiet++;

111

}

111

}

112

113

if ($tree) {

113

if ($tree) {

114

if (defined $root) {

114

if (defined $root) {

115

if (!top_of_kernel_tree($root)) {

115

if (!top_of_kernel_tree($root)) {

116

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

116

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

117

}

117

}

118

} else {

118

} else {

119

if (top_of_kernel_tree('.')) {

119

if (top_of_kernel_tree('.')) {

120

$root = '.';

120

$root = '.';

121

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

121

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

122

top_of_kernel_tree($1)) {

122

top_of_kernel_tree($1)) {

123

$root = $1;

123

$root = $1;

124

}

124

}

125

}

125

}

126

127

if (!defined $root) {

127

if (!defined $root) {

128

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

128

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

129

exit(2);

129

exit(2);

130

}

130

}

131

}

131

}

132

133

my $emitted_corrupt = 0;

133

my $emitted_corrupt = 0;

134

135

our $Ident = qr{

135

our $Ident = qr{

136

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

136

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

137

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

137

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

138

}x;

138

}x;

139

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

139

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

140

our $Sparse = qr{

140

our $Sparse = qr{

141

__user|

141

__user|

142

__kernel|

142

__kernel|

143

__force|

143

__force|

144

__iomem|

144

__iomem|

145

__must_check|

145

__must_check|

146

__init_refok|

146

__init_refok|

147

__kprobes|

147

__kprobes|

148

__ref

148

__ref

149

}x;

149

}x;

150

151

# Notes to $Attribute:

151

# Notes to $Attribute:

152

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

152

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

153

our $Attribute = qr{

153

our $Attribute = qr{

154

const|

154

const|

155

__read_mostly|

155

__read_mostly|

156

__kprobes|

156

__kprobes|

157

__(?:mem|cpu|dev|)(?:initdata|initconst|init\b)|

157

__(?:mem|cpu|dev|)(?:initdata|initconst|init\b)|

158

____cacheline_aligned|

158

____cacheline_aligned|

159

____cacheline_aligned_in_smp|

159

____cacheline_aligned_in_smp|

160

____cacheline_internodealigned_in_smp|

160

____cacheline_internodealigned_in_smp|

161

__weak

161

__weak

162

}x;

162

}x;

163

our $Modifier;

163

our $Modifier;

164

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

164

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

165

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

165

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

166

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

166

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

167

168

our $Constant = qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*};

168

our $Constant = qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*};

169

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

169

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

170

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

170

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

171

our $Operators = qr{

171

our $Operators = qr{

172

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

172

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

173

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

173

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

174

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

174

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

175

}x;

175

}x;

176

177

our $NonptrType;

177

our $NonptrType;

178

our $Type;

178

our $Type;

179

our $Declare;

179

our $Declare;

180

181

our $UTF8 = qr {

181

our $UTF8 = qr {

182

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

182

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

183

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

183

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

184

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

184

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

185

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

185

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

186

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

186

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

187

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

187

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

188

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

188

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

189

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

189

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

190

}x;

190

}x;

191

192

our $typeTypedefs = qr{(?x:

192

our $typeTypedefs = qr{(?x:

193

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

193

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

194

atomic_t

194

atomic_t

195

)};

195

)};

196

197

our $logFunctions = qr{(?x:

197

our $logFunctions = qr{(?x:

198

printk|

198

printk|

199

199

200

200

201

WARN|

201

WARN|

202

panic

202

panic

203

)};

203

)};

204

205

our @typeList = (

205

our @typeList = (

206

qr{void},

206

qr{void},

207

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

207

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

208

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

208

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

209

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

209

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

210

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

210

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

211

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

211

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

212

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

212

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

213

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

213

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

214

qr{unsigned},

214

qr{unsigned},

215

qr{float},

215

qr{float},

216

qr{double},

216

qr{double},

217

qr{bool},

217

qr{bool},

218

qr{struct\s+$Ident},

218

qr{struct\s+$Ident},

219

qr{union\s+$Ident},

219

qr{union\s+$Ident},

220

qr{enum\s+$Ident},

220

qr{enum\s+$Ident},

221

qr{${Ident}_t},

221

qr{${Ident}_t},

222

qr{${Ident}_handler},

222

qr{${Ident}_handler},

223

qr{${Ident}_handler_fn},

223

qr{${Ident}_handler_fn},

224

);

224

);

225

our @modifierList = (

225

our @modifierList = (

226

qr{fastcall},

226

qr{fastcall},

227

);

227

);

228

229

our $allowed_asm_includes = qr{(?x:

229

our $allowed_asm_includes = qr{(?x:

230

irq|

230

irq|

231

memory

231

memory

232

)};

232

)};

233

# memory.h: ARM has a custom one

233

# memory.h: ARM has a custom one

234

235

sub build_types {

235

sub build_types {

236

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

236

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

237

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

237

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

238

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

238

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

239

$NonptrType = qr{

239

$NonptrType = qr{

240

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

240

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

241

(?:

241

(?:

242

(?:typeof|__typeof__)\s*$\s*\**\s*$Ident\s*$|

242

(?:typeof|__typeof__)\s*$\s*\**\s*$Ident\s*$|

243

(?:$typeTypedefs\b)|

243

(?:$typeTypedefs\b)|

244

(?:${all}\b)

244

(?:${all}\b)

245

)

245

)

246

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

246

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

247

}x;

247

}x;

248

$Type = qr{

248

$Type = qr{

249

$NonptrType

249

$NonptrType

250

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

250

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

251

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

251

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

252

}x;

252

}x;

253

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

253

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

254

}

254

}

255

build_types();

255

build_types();

256

257

$chk_signoff = 0 if ($file);

257

$chk_signoff = 0 if ($file);

258

259

my @dep_includes = ();

259

my @dep_includes = ();

260

my @dep_functions = ();

260

my @dep_functions = ();

261

my $removal = "Documentation/feature-removal-schedule.txt";

261

my $removal = "Documentation/feature-removal-schedule.txt";

262

if ($tree && -f "$root/$removal") {

262

if ($tree && -f "$root/$removal") {

263

open(my $REMOVE, '<', "$root/$removal") ||

263

open(my $REMOVE, '<', "$root/$removal") ||

264

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

264

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

265

while (<$REMOVE>) {

265

while (<$REMOVE>) {

266

if (/^Check:\s+(.*\S)/) {

266

if (/^Check:\s+(.*\S)/) {

267

for my $entry (split(/[, ]+/, $1)) {

267

for my $entry (split(/[, ]+/, $1)) {

268

if ($entry =~ m@include/(.*)@) {

268

if ($entry =~ m@include/(.*)@) {

269

push(@dep_includes, $1);

269

push(@dep_includes, $1);

270

271

} elsif ($entry !~ m@/@) {

271

} elsif ($entry !~ m@/@) {

272

push(@dep_functions, $entry);

272

push(@dep_functions, $entry);

273

}

273

}

274

}

274

}

275

}

275

}

276

}

276

}

277

close($REMOVE);

277

close($REMOVE);

278

}

278

}

279

280

my @rawlines = ();

280

my @rawlines = ();

281

my @lines = ();

281

my @lines = ();

282

my $vname;

282

my $vname;

283

for my $filename (@ARGV) {

283

for my $filename (@ARGV) {

284

my $FILE;

284

my $FILE;

285

if ($file) {

285

if ($file) {

286

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

286

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

287

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

287

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

288

} elsif ($filename eq '-') {

288

} elsif ($filename eq '-') {

289

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

289

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

290

} else {

290

} else {

291

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

291

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

292

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

292

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

293

}

293

}

294

if ($filename eq '-') {

294

if ($filename eq '-') {

295

$vname = 'Your patch';

295

$vname = 'Your patch';

296

} else {

296

} else {

297

$vname = $filename;

297

$vname = $filename;

298

}

298

}

299

while (<$FILE>) {

299

while (<$FILE>) {

300

chomp;

300

chomp;

301

push(@rawlines, $_);

301

push(@rawlines, $_);

302

}

302

}

303

close($FILE);

303

close($FILE);

304

if (!process($filename)) {

304

if (!process($filename)) {

305

$exit = 1;

305

$exit = 1;

306

}

306

}

307

@rawlines = ();

307

@rawlines = ();

308

@lines = ();

308

@lines = ();

309

}

309

}

310

311

exit($exit);

311

exit($exit);

312

313

sub top_of_kernel_tree {

313

sub top_of_kernel_tree {

314

my ($root) = @_;

314

my ($root) = @_;

315

316

my @tree_check = (

316

my @tree_check = (

317

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

317

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

318

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

318

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

319

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

319

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

320

);

320

);

321

322

foreach my $check (@tree_check) {

322

foreach my $check (@tree_check) {

323

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

323

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

324

return 0;

324

return 0;

325

}

325

}

326

}

326

}

327

return 1;

327

return 1;

328

}

328

}

329

330

sub expand_tabs {

330

sub expand_tabs {

331

my ($str) = @_;

331

my ($str) = @_;

332

333

my $res = '';

333

my $res = '';

334

my $n = 0;

334

my $n = 0;

335

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

335

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

336

if ($c eq "\t") {

336

if ($c eq "\t") {

337

$res .= ' ';

337

$res .= ' ';

338

$n++;

338

$n++;

339

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

339

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

340

$res .= ' ';

340

$res .= ' ';

341

}

341

}

342

next;

342

next;

343

}

343

}

344

$res .= $c;

344

$res .= $c;

345

$n++;

345

$n++;

346

}

346

}

347

348

return $res;

348

return $res;

349

}

349

}

350

sub copy_spacing {

350

sub copy_spacing {

351

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

351

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

352

return $res;

352

return $res;

353

}

353

}

354

355

sub line_stats {

355

sub line_stats {

356

my ($line) = @_;

356

my ($line) = @_;

357

358

# Drop the diff line leader and expand tabs

358

# Drop the diff line leader and expand tabs

359

$line =~ s/^.//;

359

$line =~ s/^.//;

360

$line = expand_tabs($line);

360

$line = expand_tabs($line);

361

362

# Pick the indent from the front of the line.

362

# Pick the indent from the front of the line.

363

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

363

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

364

365

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

365

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

366

}

366

}

367

368

my $sanitise_quote = '';

368

my $sanitise_quote = '';

369

370

sub sanitise_line_reset {

370

sub sanitise_line_reset {

371

my ($in_comment) = @_;

371

my ($in_comment) = @_;

372

373

if ($in_comment) {

373

if ($in_comment) {

374

$sanitise_quote = '*/';

374

$sanitise_quote = '*/';

375

} else {

375

} else {

376

$sanitise_quote = '';

376

$sanitise_quote = '';

377

}

377

}

378

}

378

}

379

sub sanitise_line {

379

sub sanitise_line {

380

my ($line) = @_;

380

my ($line) = @_;

381

382

my $res = '';

382

my $res = '';

383

my $l = '';

383

my $l = '';

384

385

my $qlen = 0;

385

my $qlen = 0;

386

my $off = 0;

386

my $off = 0;

387

my $c;

387

my $c;

388

389

# Always copy over the diff marker.

389

# Always copy over the diff marker.

390

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

390

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

391

392

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

392

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

393

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

393

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

394

395

# Comments we are wacking completly including the begin

395

# Comments we are wacking completly including the begin

396

# and end, all to $;.

396

# and end, all to $;.

397

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

397

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

398

$sanitise_quote = '*/';

398

$sanitise_quote = '*/';

399

400

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

400

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

401

$off++;

401

$off++;

402

next;

402

next;

403

}

403

}

404

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

404

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

405

$sanitise_quote = '';

405

$sanitise_quote = '';

406

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

406

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

407

$off++;

407

$off++;

408

next;

408

next;

409

}

409

}

410

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

410

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

411

$sanitise_quote = '//';

411

$sanitise_quote = '//';

412

413

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

413

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

414

$off++;

414

$off++;

415

next;

415

next;

416

}

416

}

417

418

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

418

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

419

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

419

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

420

$c eq "\\") {

420

$c eq "\\") {

421

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

421

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

422

$off++;

422

$off++;

423

next;

423

next;

424

}

424

}

425

# Regular quotes.

425

# Regular quotes.

426

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

426

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

427

if ($sanitise_quote eq '') {

427

if ($sanitise_quote eq '') {

428

$sanitise_quote = $c;

428

$sanitise_quote = $c;

429

430

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

430

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

431

next;

431

next;

432

} elsif ($sanitise_quote eq $c) {

432

} elsif ($sanitise_quote eq $c) {

433

$sanitise_quote = '';

433

$sanitise_quote = '';

434

}

434

}

435

}

435

}

436

437

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

437

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

438

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

438

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

439

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

439

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

440

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

440

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

441

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

441

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

442

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

442

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

443

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

443

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

444

} else {

444

} else {

445

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

445

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

446

}

446

}

447

}

447

}

448

449

if ($sanitise_quote eq '//') {

449

if ($sanitise_quote eq '//') {

450

$sanitise_quote = '';

450

$sanitise_quote = '';

451

}

451

}

452

453

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

453

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

454

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

454

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

455

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

455

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

456

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

456

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

457

458

# The whole of a #error is a string.

458

# The whole of a #error is a string.

459

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

459

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

460

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

460

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

461

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

461

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

462

}

462

}

463

464

return $res;

464

return $res;

465

}

465

}

466

467

sub ctx_statement_block {

467

sub ctx_statement_block {

468

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

468

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

469

my $line = $linenr - 1;

469

my $line = $linenr - 1;

470

my $blk = '';

470

my $blk = '';

471

my $soff = $off;

471

my $soff = $off;

472

my $coff = $off - 1;

472

my $coff = $off - 1;

473

my $coff_set = 0;

473

my $coff_set = 0;

474

475

my $loff = 0;

475

my $loff = 0;

476

477

my $type = '';

477

my $type = '';

478

my $level = 0;

478

my $level = 0;

479

my @stack = ();

479

my @stack = ();

480

my $p;

480

my $p;

481

my $c;

481

my $c;

482

my $len = 0;

482

my $len = 0;

483

484

my $remainder;

484

my $remainder;

485

while (1) {

485

while (1) {

486

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

486

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

487

488

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

488

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

489

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

489

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

490

# context.

490

# context.

491

if ($off >= $len) {

491

if ($off >= $len) {

492

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

492

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

493

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

493

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

494

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

494

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

495

$remain--;

495

$remain--;

496

$loff = $len;

496

$loff = $len;

497

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

497

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

498

$len = length($blk);

498

$len = length($blk);

499

$line++;

499

$line++;

500

last;

500

last;

501

}

501

}

502

# Bail if there is no further context.

502

# Bail if there is no further context.

503

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

503

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

504

if ($off >= $len) {

504

if ($off >= $len) {

505

last;

505

last;

506

}

506

}

507

}

507

}

508

$p = $c;

508

$p = $c;

509

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

509

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

510

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

510

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

511

512

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

512

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

513

514

# Handle nested #if/#else.

514

# Handle nested #if/#else.

515

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

515

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

516

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

516

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

517

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

517

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

518

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

518

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

519

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

519

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

520

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

520

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

521

}

521

}

522

523

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

523

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

524

# outermost level.

524

# outermost level.

525

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

525

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

526

last;

526

last;

527

}

527

}

528

529

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

529

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

530

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

530

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

531

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

531

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

532

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

532

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

533

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

533

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

534

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

534

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

535

$coff_set = 1;

535

$coff_set = 1;

536

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

536

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

537

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

537

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

538

}

538

}

539

540

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

540

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

541

$level++;

541

$level++;

542

$type = '(';

542

$type = '(';

543

}

543

}

544

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

544

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

545

$level--;

545

$level--;

546

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

546

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

547

548

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

548

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

549

$coff = $off;

549

$coff = $off;

550

$coff_set = 1;

550

$coff_set = 1;

551

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

551

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

552

}

552

}

553

}

553

}

554

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

554

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

555

$level++;

555

$level++;

556

$type = '{';

556

$type = '{';

557

}

557

}

558

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

558

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

559

$level--;

559

$level--;

560

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

560

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

561

562

if ($level == 0) {

562

if ($level == 0) {

563

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

563

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

564

$off++;

564

$off++;

565

}

565

}

566

last;

566

last;

567

}

567

}

568

}

568

}

569

$off++;

569

$off++;

570

}

570

}

571

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

571

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

572

if ($off == $len) {

572

if ($off == $len) {

573

$loff = $len + 1;

573

$loff = $len + 1;

574

$line++;

574

$line++;

575

$remain--;

575

$remain--;

576

}

576

}

577

578

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

578

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

579

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

579

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

580

581

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

581

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

582

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

582

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

583

584

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

584

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

585

586

return ($statement, $condition,

586

return ($statement, $condition,

587

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

587

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

588

}

588

}

589

590

sub statement_lines {

590

sub statement_lines {

591

my ($stmt) = @_;

591

my ($stmt) = @_;

592

593

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

593

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

594

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

594

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

595

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

595

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

596

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

596

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

597

598

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

598

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

599

600

return $#stmt_lines + 2;

600

return $#stmt_lines + 2;

601

}

601

}

602

603

sub statement_rawlines {

603

sub statement_rawlines {

604

my ($stmt) = @_;

604

my ($stmt) = @_;

605

606

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

606

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

607

608

return $#stmt_lines + 2;

608

return $#stmt_lines + 2;

609

}

609

}

610

611

sub statement_block_size {

611

sub statement_block_size {

612

my ($stmt) = @_;

612

my ($stmt) = @_;

613

614

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

614

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

615

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

615

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

616

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

616

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

617

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

617

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

618

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

618

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

619

620

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

620

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

621

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

621

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

622

623

my $stmt_lines = $#stmt_lines + 2;

623

my $stmt_lines = $#stmt_lines + 2;

624

my $stmt_statements = $#stmt_statements + 1;

624

my $stmt_statements = $#stmt_statements + 1;

625

626

if ($stmt_lines > $stmt_statements) {

626

if ($stmt_lines > $stmt_statements) {

627

return $stmt_lines;

627

return $stmt_lines;

628

} else {

628

} else {

629

return $stmt_statements;

629

return $stmt_statements;

630

}

630

}

631

}

631

}

632

633

sub ctx_statement_full {

633

sub ctx_statement_full {

634

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

634

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

635

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

635

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

636

637

my (@chunks);

637

my (@chunks);

638

639

# Grab the first conditional/block pair.

639

# Grab the first conditional/block pair.

640

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

640

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

641

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

641

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

642

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

642

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

643

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

643

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

644

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

644

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

645

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

645

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

646

}

646

}

647

648

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

648

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

649

# could continue the statement.

649

# could continue the statement.

650

for (;;) {

650

for (;;) {

651

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

651

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

652

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

652

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

653

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

653

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

654

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

654

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

655

#print "C: push\n";

655

#print "C: push\n";

656

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

656

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

657

}

657

}

658

659

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

659

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

660

}

660

}

661

662

sub ctx_block_get {

662

sub ctx_block_get {

663

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

663

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

664

my $line;

664

my $line;

665

my $start = $linenr - 1;

665

my $start = $linenr - 1;

666

my $blk = '';

666

my $blk = '';

667

my @o;

667

my @o;

668

my @c;

668

my @c;

669

my @res = ();

669

my @res = ();

670

671

my $level = 0;

671

my $level = 0;

672

my @stack = ($level);

672

my @stack = ($level);

673

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

673

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

674

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

674

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

675

$remain--;

675

$remain--;

676

677

$blk .= $rawlines[$line];

677

$blk .= $rawlines[$line];

678

679

# Handle nested #if/#else.

679

# Handle nested #if/#else.

680

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

680

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

681

push(@stack, $level);

681

push(@stack, $level);

682

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

682

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

683

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

683

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

684

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

684

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

685

$level = pop(@stack);

685

$level = pop(@stack);

686

}

686

}

687

688

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

688

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

689

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

689

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

690

if ($off > 0) {

690

if ($off > 0) {

691

$off--;

691

$off--;

692

next;

692

next;

693

}

693

}

694

695

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

695

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

696

$level--;

696

$level--;

697

last if ($level == 0);

697

last if ($level == 0);

698

} elsif ($c eq $open) {

698

} elsif ($c eq $open) {

699

$level++;

699

$level++;

700

}

700

}

701

}

701

}

702

703

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

703

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

704

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

704

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

705

}

705

}

706

707

last if ($level == 0);

707

last if ($level == 0);

708

}

708

}

709

710

return ($level, @res);

710

return ($level, @res);

711

}

711

}

712

sub ctx_block_outer {

712

sub ctx_block_outer {

713

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

713

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

714

715

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

715

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

716

return @r;

716

return @r;

717

}

717

}

718

sub ctx_block {

718

sub ctx_block {

719

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

719

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

720

721

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

721

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

722

return @r;

722

return @r;

723

}

723

}

724

sub ctx_statement {

724

sub ctx_statement {

725

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

725

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

726

727

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

727

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

728

return @r;

728

return @r;

729

}

729

}

730

sub ctx_block_level {

730

sub ctx_block_level {

731

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

731

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

732

733

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

733

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

734

}

734

}

735

sub ctx_statement_level {

735

sub ctx_statement_level {

736

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

736

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

737

738

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

738

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

739

}

739

}

740

741

sub ctx_locate_comment {

741

sub ctx_locate_comment {

742

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

742

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

743

744

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

744

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

745

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

745

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

746

return $current_comment if (defined $current_comment);

746

return $current_comment if (defined $current_comment);

747

748

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

748

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

749

# comment.

749

# comment.

750

my $in_comment = 0;

750

my $in_comment = 0;

751

$current_comment = '';

751

$current_comment = '';

752

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

752

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

753

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

753

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

754

#warn " $line\n";

754

#warn " $line\n";

755

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

755

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

756

$in_comment = 1;

756

$in_comment = 1;

757

}

757

}

758

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

758

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

759

$in_comment = 1;

759

$in_comment = 1;

760

}

760

}

761

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

761

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

762

$current_comment = '';

762

$current_comment = '';

763

}

763

}

764

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

764

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

765

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

765

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

766

$in_comment = 0;

766

$in_comment = 0;

767

}

767

}

768

}

768

}

769

770

chomp($current_comment);

770

chomp($current_comment);

771

return($current_comment);

771

return($current_comment);

772

}

772

}

773

sub ctx_has_comment {

773

sub ctx_has_comment {

774

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

774

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

775

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

775

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

776

777

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

777

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

778

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

778

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

779

780

return ($cmt ne '');

780

return ($cmt ne '');

781

}

781

}

782

783

sub raw_line {

783

sub raw_line {

784

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

784

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

785

786

my $offset = $linenr - 1;

786

my $offset = $linenr - 1;

787

$cnt++;

787

$cnt++;

788

789

my $line;

789

my $line;

790

while ($cnt) {

790

while ($cnt) {

791

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

791

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

792

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

792

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

793

$cnt--;

793

$cnt--;

794

}

794

}

795

796

return $line;

796

return $line;

797

}

797

}

798

799

sub cat_vet {

799

sub cat_vet {

800

my ($vet) = @_;

800

my ($vet) = @_;

801

my ($res, $coded);

801

my ($res, $coded);

802

803

$res = '';

803

$res = '';

804

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

804

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

805

$res .= $1;

805

$res .= $1;

806

if ($2 ne '') {

806

if ($2 ne '') {

807

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

807

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

808

$res .= $coded;

808

$res .= $coded;

809

}

809

}

810

}

810

}

811

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

811

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

812

813

return $res;

813

return $res;

814

}

814

}

815

816

my $av_preprocessor = 0;

816

my $av_preprocessor = 0;

817

my $av_pending;

817

my $av_pending;

818

my @av_paren_type;

818

my @av_paren_type;

819

my $av_pend_colon;

819

my $av_pend_colon;

820

821

sub annotate_reset {

821

sub annotate_reset {

822

$av_preprocessor = 0;

822

$av_preprocessor = 0;

823

$av_pending = '_';

823

$av_pending = '_';

824

@av_paren_type = ('E');

824

@av_paren_type = ('E');

825

$av_pend_colon = 'O';

825

$av_pend_colon = 'O';

826

}

826

}

827

828

sub annotate_values {

828

sub annotate_values {

829

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

829

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

830

831

my $res;

831

my $res;

832

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

832

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

833

my $cur = $stream;

833

my $cur = $stream;

834

835

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

835

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

836

837

while (length($cur)) {

837

while (length($cur)) {

838

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

838

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

839

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

839

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

840

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

840

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

841

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

841

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

842

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

842

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

843

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

843

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

844

$type = pop(@av_paren_type);

844

$type = pop(@av_paren_type);

845

$av_preprocessor = 0;

845

$av_preprocessor = 0;

846

}

846

}

847

848

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

848

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

849

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

849

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

850

push(@av_paren_type, $type);

850

push(@av_paren_type, $type);

851

$type = 'C';

851

$type = 'C';

852

853

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

853

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

854

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

854

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

855

$type = 'T';

855

$type = 'T';

856

857

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

857

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

858

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

858

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

859

$type = 'T';

859

$type = 'T';

860

861

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

861

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

862

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

862

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

863

$av_preprocessor = 1;

863

$av_preprocessor = 1;

864

push(@av_paren_type, $type);

864

push(@av_paren_type, $type);

865

if ($2 ne '') {

865

if ($2 ne '') {

866

$av_pending = 'N';

866

$av_pending = 'N';

867

}

867

}

868

$type = 'E';

868

$type = 'E';

869

870

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

870

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

871

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

871

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

872

$av_preprocessor = 1;

872

$av_preprocessor = 1;

873

push(@av_paren_type, $type);

873

push(@av_paren_type, $type);

874

875

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

875

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

876

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

876

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

877

$av_preprocessor = 1;

877

$av_preprocessor = 1;

878

879

push(@av_paren_type, $type);

879

push(@av_paren_type, $type);

880

push(@av_paren_type, $type);

880

push(@av_paren_type, $type);

881

$type = 'E';

881

$type = 'E';

882

883

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

883

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

884

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

884

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

885

$av_preprocessor = 1;

885

$av_preprocessor = 1;

886

887

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

887

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

888

889

$type = 'E';

889

$type = 'E';

890

891

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

891

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

892

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

892

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

893

894

$av_preprocessor = 1;

894

$av_preprocessor = 1;

895

896

# Assume all arms of the conditional end as this

896

# Assume all arms of the conditional end as this

897

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

897

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

898

pop(@av_paren_type);

898

pop(@av_paren_type);

899

push(@av_paren_type, $type);

899

push(@av_paren_type, $type);

900

$type = 'E';

900

$type = 'E';

901

902

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

902

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

903

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

903

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

904

905

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

905

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

906

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

906

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

907

$av_pending = $type;

907

$av_pending = $type;

908

$type = 'N';

908

$type = 'N';

909

910

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

910

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

911

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

911

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

912

if (defined $2) {

912

if (defined $2) {

913

$av_pending = 'V';

913

$av_pending = 'V';

914

}

914

}

915

$type = 'N';

915

$type = 'N';

916

917

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

917

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

918

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

918

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

919

$av_pending = 'E';

919

$av_pending = 'E';

920

$type = 'N';

920

$type = 'N';

921

922

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

922

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

923

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

923

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

924

$av_pend_colon = 'C';

924

$av_pend_colon = 'C';

925

$type = 'N';

925

$type = 'N';

926

927

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

927

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

928

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

928

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

929

$type = 'N';

929

$type = 'N';

930

931

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

931

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

932

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

932

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

933

push(@av_paren_type, $av_pending);

933

push(@av_paren_type, $av_pending);

934

$av_pending = '_';

934

$av_pending = '_';

935

$type = 'N';

935

$type = 'N';

936

937

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

937

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

938

my $new_type = pop(@av_paren_type);

938

my $new_type = pop(@av_paren_type);

939

if ($new_type ne '_') {

939

if ($new_type ne '_') {

940

$type = $new_type;

940

$type = $new_type;

941

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

941

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

942

if ($dbg_values > 1);

942

if ($dbg_values > 1);

943

} else {

943

} else {

944

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

944

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

945

}

945

}

946

947

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

947

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

948

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

948

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

949

$type = 'V';

949

$type = 'V';

950

$av_pending = 'V';

950

$av_pending = 'V';

951

952

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

952

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

953

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

953

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

954

$av_pend_colon = 'B';

954

$av_pend_colon = 'B';

955

} elsif ($type eq 'E') {

955

} elsif ($type eq 'E') {

956

$av_pend_colon = 'L';

956

$av_pend_colon = 'L';

957

}

957

}

958

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

958

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

959

$type = 'V';

959

$type = 'V';

960

961

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

961

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

962

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

962

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

963

$type = 'V';

963

$type = 'V';

964

965

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

965

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

966

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

966

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

967

$type = 'N';

967

$type = 'N';

968

969

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

969

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

970

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

970

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

971

$type = 'E';

971

$type = 'E';

972

$av_pend_colon = 'O';

972

$av_pend_colon = 'O';

973

974

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

974

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

975

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

975

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

976

$type = 'C';

976

$type = 'C';

977

978

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

978

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

979

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

979

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

980

$type = 'N';

980

$type = 'N';

981

982

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

982

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

983

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

983

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

984

985

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

985

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

986

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

986

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

987

$type = 'E';

987

$type = 'E';

988

} else {

988

} else {

989

$type = 'N';

989

$type = 'N';

990

}

990

}

991

$av_pend_colon = 'O';

991

$av_pend_colon = 'O';

992

993

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

993

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

994

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

994

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

995

$type = 'N';

995

$type = 'N';

996

997

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

997

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

998

my $variant;

998

my $variant;

999

1000

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

1000

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

1001

if ($type eq 'V') {

1001

if ($type eq 'V') {

1002

$variant = 'B';

1002

$variant = 'B';

1003

} else {

1003

} else {

1004

$variant = 'U';

1004

$variant = 'U';

1005

}

1005

}

1006

1007

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

1007

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

1008

$type = 'N';

1008

$type = 'N';

1009

1010

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

1010

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

1011

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

1011

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

1012

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

1012

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

1013

$type = 'N';

1013

$type = 'N';

1014

}

1014

}

1015

1016

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

1016

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

1017

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

1017

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

1018

}

1018

}

1019

if (defined $1) {

1019

if (defined $1) {

1020

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

1020

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

1021

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

1021

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

1022

}

1022

}

1023

}

1023

}

1024

1025

return ($res, $var);

1025

return ($res, $var);

1026

}

1026

}

1027

1028

sub possible {

1028

sub possible {

1029

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

1029

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

1030

my $notPermitted = qr{(?:

1030

my $notPermitted = qr{(?:

1031

^(?:

1031

^(?:

1032

$Modifier|

1032

$Modifier|

1033

$Storage|

1033

$Storage|

1034

$Type|

1034

$Type|

1035

DEFINE_\S+

1035

DEFINE_\S+

1036

)$|

1036

)$|

1037

^(?:

1037

^(?:

1038

goto|

1038

goto|

1039

return|

1039

return|

1040

case|

1040

case|

1041

else|

1041

else|

1042

asm|__asm__|

1042

asm|__asm__|

1043

do

1043

do

1044

)(?:\s|$)|

1044

)(?:\s|$)|

1045

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

1045

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

1046

)}x;

1046

)}x;

1047

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

1047

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

1048

if ($possible !~ $notPermitted) {

1048

if ($possible !~ $notPermitted) {

1049

# Check for modifiers.

1049

# Check for modifiers.

1050

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

1050

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

1051

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

1051

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

1052

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

1052

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

1053

1054

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

1054

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

1055

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

1055

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

1056

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

1056

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

1057

if ($modifier !~ $notPermitted) {

1057

if ($modifier !~ $notPermitted) {

1058

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

1058

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

1059

push(@modifierList, $modifier);

1059

push(@modifierList, $modifier);

1060

}

1060

}

1061

}

1061

}

1062

1063

} else {

1063

} else {

1064

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

1064

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

1065

push(@typeList, $possible);

1065

push(@typeList, $possible);

1066

}

1066

}

1067

build_types();

1067

build_types();

1068

} else {

1068

} else {

1069

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

1069

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

1070

}

1070

}

1071

}

1071

}

1072

1073

my $prefix = '';

1073

my $prefix = '';

1074

1075

sub report {

1075

sub report {

1076

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

1076

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

1077

return 0;

1077

return 0;

1078

}

1078

}

1079

my $line = $prefix . $_[0];

1079

my $line = $prefix . $_[0];

1080

1081

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

1081

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

1082

1083

push(our @report, $line);

1083

push(our @report, $line);

1084

1085

return 1;

1085

return 1;

1086

}

1086

}

1087

sub report_dump {

1087

sub report_dump {

1088

our @report;

1088

our @report;

1089

}

1089

}

1090

sub ERROR {

1090

sub ERROR {

1091

if (report("ERROR: $_[0]\n")) {

1091

if (report("ERROR: $_[0]\n")) {

1092

our $clean = 0;

1092

our $clean = 0;

1093

our $cnt_error++;

1093

our $cnt_error++;

1094

}

1094

}

1095

}

1095

}

1096

sub WARN {

1096

sub WARN {

1097

if (report("WARNING: $_[0]\n")) {

1097

if (report("WARNING: $_[0]\n")) {

1098

our $clean = 0;

1098

our $clean = 0;

1099

our $cnt_warn++;

1099

our $cnt_warn++;

1100

}

1100

}

1101

}

1101

}

1102

sub CHK {

1102

sub CHK {

1103

if ($check && report("CHECK: $_[0]\n")) {

1103

if ($check && report("CHECK: $_[0]\n")) {

1104

our $clean = 0;

1104

our $clean = 0;

1105

our $cnt_chk++;

1105

our $cnt_chk++;

1106

}

1106

}

1107

}

1107

}

1108

1109

sub check_absolute_file {

1109

sub check_absolute_file {

1110

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

1110

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

1111

my $file = $absolute;

1111

my $file = $absolute;

1112

1113

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

1113

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

1114

1115

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

1115

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

1116

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

1116

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

1117

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

1117

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

1118

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

1118

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

1119

last;

1119

last;

1120

}

1120

}

1121

}

1121

}

1122

if (! -f _) {

1122

if (! -f _) {

1123

return 0;

1123

return 0;

1124

}

1124

}

1125

1126

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

1126

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

1127

my $prefix = $absolute;

1127

my $prefix = $absolute;

1128

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

1128

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

1129

1130

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

1130

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

1131

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

1131

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

1132

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

1132

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

1133

}

1133

}

1134

}

1134

}

1135

1136

sub process {

1136

sub process {

1137

my $filename = shift;

1137

my $filename = shift;

1138

1139

my $linenr=0;

1139

my $linenr=0;

1140

my $prevline="";

1140

my $prevline="";

1141

my $prevrawline="";

1141

my $prevrawline="";

1142

my $stashline="";

1142

my $stashline="";

1143

my $stashrawline="";

1143

my $stashrawline="";

1144

1145

my $length;

1145

my $length;

1146

my $indent;

1146

my $indent;

1147

my $previndent=0;

1147

my $previndent=0;

1148

my $stashindent=0;

1148

my $stashindent=0;

1149

1150

our $clean = 1;

1150

our $clean = 1;

1151

my $signoff = 0;

1151

my $signoff = 0;

1152

my $is_patch = 0;

1152

my $is_patch = 0;

1153

1154

our @report = ();

1154

our @report = ();

1155

our $cnt_lines = 0;

1155

our $cnt_lines = 0;

1156

our $cnt_error = 0;

1156

our $cnt_error = 0;

1157

our $cnt_warn = 0;

1157

our $cnt_warn = 0;

1158

our $cnt_chk = 0;

1158

our $cnt_chk = 0;

1159

1160

# Trace the real file/line as we go.

1160

# Trace the real file/line as we go.

1161

my $realfile = '';

1161

my $realfile = '';

1162

my $realline = 0;

1162

my $realline = 0;

1163

my $realcnt = 0;

1163

my $realcnt = 0;

1164

my $here = '';

1164

my $here = '';

1165

my $in_comment = 0;

1165

my $in_comment = 0;

1166

my $comment_edge = 0;

1166

my $comment_edge = 0;

1167

my $first_line = 0;

1167

my $first_line = 0;

1168

my $p1_prefix = '';

1168

my $p1_prefix = '';

1169

1170

my $prev_values = 'E';

1170

my $prev_values = 'E';

1171

1172

# suppression flags

1172

# suppression flags

1173

my %suppress_ifbraces;

1173

my %suppress_ifbraces;

1174

my %suppress_whiletrailers;

1174

my %suppress_whiletrailers;

1175

my %suppress_export;

1175

my %suppress_export;

1176

1177

# Pre-scan the patch sanitizing the lines.

1177

# Pre-scan the patch sanitizing the lines.

1178

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

1178

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

1179

#

1179

#

1180

my @setup_docs = ();

1180

my @setup_docs = ();

1181

my $setup_docs = 0;

1181

my $setup_docs = 0;

1182

1183

sanitise_line_reset();

1183

sanitise_line_reset();

1184

my $line;

1184

my $line;

1185

foreach my $rawline (@rawlines) {

1185

foreach my $rawline (@rawlines) {

1186

$linenr++;

1186

$linenr++;

1187

$line = $rawline;

1187

$line = $rawline;

1188

1189

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

1189

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

1190

$setup_docs = 0;

1190

$setup_docs = 0;

1191

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

1191

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

1192

$setup_docs = 1;

1192

$setup_docs = 1;

1193

}

1193

}

1194

#next;

1194

#next;

1195

}

1195

}

1196

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

1196

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

1197

$realline=$1-1;

1197

$realline=$1-1;

1198

if (defined $2) {

1198

if (defined $2) {

1199

$realcnt=$3+1;

1199

$realcnt=$3+1;

1200

} else {

1200

} else {

1201

$realcnt=1+1;

1201

$realcnt=1+1;

1202

}

1202

}

1203

$in_comment = 0;

1203

$in_comment = 0;

1204

1205

# Guestimate if this is a continuing comment. Run

1205

# Guestimate if this is a continuing comment. Run

1206

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

1206

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

1207

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

1207

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

1208

# at context start.

1208

# at context start.

1209

my $edge;

1209

my $edge;

1210

my $cnt = $realcnt;

1210

my $cnt = $realcnt;

1211

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

1211

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

1212

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

1212

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

1213

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

1213

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

1214

$cnt--;

1214

$cnt--;

1215

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

1215

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

1216

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

1216

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

1217

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

1217

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

1218

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

1218

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

1219

($edge) = $1;

1219

($edge) = $1;

1220

last;

1220

last;

1221

}

1221

}

1222

}

1222

}

1223

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

1223

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

1224

$in_comment = 1;

1224

$in_comment = 1;

1225

}

1225

}

1226

1227

# Guestimate if this is a continuing comment. If this

1227

# Guestimate if this is a continuing comment. If this

1228

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

1228

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

1229

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

1229

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

1230

if (!defined $edge &&

1230

if (!defined $edge &&

1231

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

1231

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

1232

{

1232

{

1233

$in_comment = 1;

1233

$in_comment = 1;

1234

}

1234

}

1235

1236

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

1236

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

1237

sanitise_line_reset($in_comment);

1237

sanitise_line_reset($in_comment);

1238

1239

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

1239

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

1240

# Standardise the strings and chars within the input to

1240

# Standardise the strings and chars within the input to

1241

# simplify matching -- only bother with positive lines.

1241

# simplify matching -- only bother with positive lines.

1242

$line = sanitise_line($rawline);

1242

$line = sanitise_line($rawline);

1243

}

1243

}

1244

push(@lines, $line);

1244

push(@lines, $line);

1245

1246

if ($realcnt > 1) {

1246

if ($realcnt > 1) {

1247

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

1247

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

1248

} else {

1248

} else {

1249

$realcnt = 0;

1249

$realcnt = 0;

1250

}

1250

}

1251

1252

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

1252

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

1253

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

1253

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

1254

1255

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

1255

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

1256

push(@setup_docs, $line);

1256

push(@setup_docs, $line);

1257

}

1257

}

1258

}

1258

}

1259

1260

$prefix = '';

1260

$prefix = '';

1261

1262

$realcnt = 0;

1262

$realcnt = 0;

1263

$linenr = 0;

1263

$linenr = 0;

1264

foreach my $line (@lines) {

1264

foreach my $line (@lines) {

1265

$linenr++;

1265

$linenr++;

1266

1267

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

1267

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

1268

1269

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

1269

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

1270

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

1270

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

1271

$is_patch = 1;

1271

$is_patch = 1;

1272

$first_line = $linenr + 1;

1272

$first_line = $linenr + 1;

1273

$realline=$1-1;

1273

$realline=$1-1;

1274

if (defined $2) {

1274

if (defined $2) {

1275

$realcnt=$3+1;

1275

$realcnt=$3+1;

1276

} else {

1276

} else {

1277

$realcnt=1+1;

1277

$realcnt=1+1;

1278

}

1278

}

1279

annotate_reset();

1279

annotate_reset();

1280

$prev_values = 'E';

1280

$prev_values = 'E';

1281

1282

%suppress_ifbraces = ();

1282

%suppress_ifbraces = ();

1283

%suppress_whiletrailers = ();

1283

%suppress_whiletrailers = ();

1284

%suppress_export = ();

1284

%suppress_export = ();

1285

next;

1285

next;

1286

1287

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

1287

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

1288

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

1288

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

1289

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

1289

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

1290

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

1290

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

1291

$realline++;

1291

$realline++;

1292

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

1292

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

1293

1294

# Measure the line length and indent.

1294

# Measure the line length and indent.

1295

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

1295

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

1296

1297

# Track the previous line.

1297

# Track the previous line.

1298

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

1298

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

1299

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

1299

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

1300

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

1300

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

1301

1302

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

1302

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

1303

1304

} elsif ($realcnt == 1) {

1304

} elsif ($realcnt == 1) {

1305

$realcnt--;

1305

$realcnt--;

1306

}

1306

}

1307

1308

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

1308

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

1309

1310

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

1310

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

1311

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

1311

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

1312

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

1312

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

1313

1314

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

1314

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

1315

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

1315

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

1316

1317

# extract the filename as it passes

1317

# extract the filename as it passes

1318

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

1318

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

1319

$realfile = $1;

1319

$realfile = $1;

1320

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

1320

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

1321

1322

$p1_prefix = $1;

1322

$p1_prefix = $1;

1323

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

1323

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

1324

-e "$root/$p1_prefix") {

1324

-e "$root/$p1_prefix") {

1325

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

1325

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

1326

}

1326

}

1327

1328

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

1328

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

1329

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

1329

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

1330

}

1330

}

1331

next;

1331

next;

1332

}

1332

}

1333

1334

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

1334

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

1335

1336

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

1336

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

1337

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

1337

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

1338

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

1338

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

1339

1340

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

1340

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

1341

1342

#check the patch for a signoff:

1342

#check the patch for a signoff:

1343

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

1343

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

1344

# This is a signoff, if ugly, so do not double report.

1344

# This is a signoff, if ugly, so do not double report.

1345

$signoff++;

1345

$signoff++;

1346

if (!($line =~ /^\s*Signed-off-by:/)) {

1346

if (!($line =~ /^\s*Signed-off-by:/)) {

1347

WARN("Signed-off-by: is the preferred form\n" .

1347

WARN("Signed-off-by: is the preferred form\n" .

1348

$herecurr);

1348

$herecurr);

1349

}

1349

}

1350

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

1350

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

1351

WARN("space required after Signed-off-by:\n" .

1351

WARN("space required after Signed-off-by:\n" .

1352

$herecurr);

1352

$herecurr);

1353

}

1353

}

1354

}

1354

}

1355

1356

# Check for wrappage within a valid hunk of the file

1356

# Check for wrappage within a valid hunk of the file

1357

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

1357

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

1358

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

1358

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

1359

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

1359

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

1360

}

1360

}

1361

1362

# Check for absolute kernel paths.

1362

# Check for absolute kernel paths.

1363

if ($tree) {

1363

if ($tree) {

1364

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

1364

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

1365

my $file = $1;

1365

my $file = $1;

1366

1367

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

1367

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

1368

check_absolute_file($1, $herecurr)) {

1368

check_absolute_file($1, $herecurr)) {

1369

#

1369

#

1370

} else {

1370

} else {

1371

check_absolute_file($file, $herecurr);

1371

check_absolute_file($file, $herecurr);

1372

}

1372

}

1373

}

1373

}

1374

}

1374

}

1375

1376

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

1376

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

1377

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

1377

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

1378

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

1378

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

1379

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

1379

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

1380

1381

my $blank = copy_spacing($rawline);

1381

my $blank = copy_spacing($rawline);

1382

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

1382

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

1383

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

1383

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

1384

1385

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

1385

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

1386

}

1386

}

1387

1388

# ignore non-hunk lines and lines being removed

1388

# ignore non-hunk lines and lines being removed

1389

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

1389

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

1390

1391

#trailing whitespace

1391

#trailing whitespace

1392

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

1392

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

1393

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

1393

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

1394

ERROR("DOS line endings\n" . $herevet);

1394

ERROR("DOS line endings\n" . $herevet);

1395

1396

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

1396

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

1397

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

1397

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

1398

ERROR("trailing whitespace\n" . $herevet);

1398

ERROR("trailing whitespace\n" . $herevet);

1399

$rpt_cleaners = 1;

1399

$rpt_cleaners = 1;

1400

}

1400

}

1401

1402

# check for Kconfig help text having a real description

1402

# check for Kconfig help text having a real description

1403

if ($realfile =~ /Kconfig/ &&

1403

if ($realfile =~ /Kconfig/ &&

1404

$line =~ /\+?\s*(---)?help(---)?$/) {

1404

$line =~ /\+?\s*(---)?help(---)?$/) {

1405

my $length = 0;

1405

my $length = 0;

1406

for (my $l = $linenr; defined($lines[$l]); $l++) {

1406

for (my $l = $linenr; defined($lines[$l]); $l++) {

1407

my $f = $lines[$l];

1407

my $f = $lines[$l];

1408

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

1408

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

1409

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

1409

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

1410

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

1410

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

1411

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

1411

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

1412

$length++;

1412

$length++;

1413

}

1413

}

1414

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

1414

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

1415

}

1415

}

1416

1417

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

1417

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

1418

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

1418

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

1419

1420

#80 column limit

1420

#80 column limit

1421

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

1421

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

1422

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

1422

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

1423

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

1423

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

1424

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

1424

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

1425

$length > 80)

1425

$length > 80)

1426

{

1426

{

1427

WARN("line over 80 characters\n" . $herecurr);

1427

WARN("line over 80 characters\n" . $herecurr);

1428

}

1428

}

1429

1430

# check for spaces before a quoted newline

1430

# check for spaces before a quoted newline

1431

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

1431

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

1432

WARN("unnecessary whitespace before a quoted newline\n" . $herecurr);

1432

WARN("unnecessary whitespace before a quoted newline\n" . $herecurr);

1433

}

1433

}

1434

1435

# check for adding lines without a newline.

1435

# check for adding lines without a newline.

1436

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

1436

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

1437

WARN("adding a line without newline at end of file\n" . $herecurr);

1437

WARN("adding a line without newline at end of file\n" . $herecurr);

1438

}

1438

}

1439

1440

# Blackfin: use hi/lo macros

1440

# Blackfin: use hi/lo macros

1441

if ($realfile =~ m@arch/blackfin/.*\.S$@) {

1441

if ($realfile =~ m@arch/blackfin/.*\.S$@) {

1442

if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {

1442

if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {

1443

my $herevet = "$here\n" . cat_vet($line) . "\n";

1443

my $herevet = "$here\n" . cat_vet($line) . "\n";

1444

ERROR("use the LO() macro, not (... & 0xFFFF)\n" . $herevet);

1444

ERROR("use the LO() macro, not (... & 0xFFFF)\n" . $herevet);

1445

}

1445

}

1446

if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {

1446

if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {

1447

my $herevet = "$here\n" . cat_vet($line) . "\n";

1447

my $herevet = "$here\n" . cat_vet($line) . "\n";

1448

ERROR("use the HI() macro, not (... >> 16)\n" . $herevet);

1448

ERROR("use the HI() macro, not (... >> 16)\n" . $herevet);

1449

}

1449

}

1450

}

1450

}

1451

1452

# check we are in a valid source file C or perl if not then ignore this hunk

1452

# check we are in a valid source file C or perl if not then ignore this hunk

1453

next if ($realfile !~ /\.(h|c|pl)$/);

1453

next if ($realfile !~ /\.(h|c|pl)$/);

1454

1455

# at the beginning of a line any tabs must come first and anything

1455

# at the beginning of a line any tabs must come first and anything

1456

# more than 8 must use tabs.

1456

# more than 8 must use tabs.

1457

if ($rawline =~ /^\+\s* \t\s*\S/ ||

1457

if ($rawline =~ /^\+\s* \t\s*\S/ ||

1458

$rawline =~ /^\+\s* \s*/) {

1458

$rawline =~ /^\+\s* \s*/) {

1459

my $herevet = "$here\n" . cat_vet($rawline) . "\n";

1459

my $herevet = "$here\n" . cat_vet($rawline) . "\n";

1460

ERROR("code indent should use tabs where possible\n" . $herevet);

1460

ERROR("code indent should use tabs where possible\n" . $herevet);

1461

$rpt_cleaners = 1;

1461

$rpt_cleaners = 1;

1462

}

1462

}

1463

1464

# check for space before tabs.

1464

# check for space before tabs.

1465

if ($rawline =~ /^\+/ && $rawline =~ / \t/) {

1465

if ($rawline =~ /^\+/ && $rawline =~ / \t/) {

1466

my $herevet = "$here\n" . cat_vet($rawline) . "\n";

1466

my $herevet = "$here\n" . cat_vet($rawline) . "\n";

1467

WARN("please, no space before tabs\n" . $herevet);

1467

WARN("please, no space before tabs\n" . $herevet);

1468

}

1468

}

1469

1470

# check for spaces at the beginning of a line.

1470

# check for spaces at the beginning of a line.

1471

# Exceptions:

1471

# Exceptions:

1472

# 1) within comments

1472

# 1) within comments

1473

# 2) indented preprocessor commands

1473

# 2) indented preprocessor commands

1474

# 3) hanging labels

1474

# 3) hanging labels

1475

if ($rawline =~ /^\+ / && $line !~ /\+ *(?:$;|#|$Ident:)/) {

1475

if ($rawline =~ /^\+ / && $line !~ /\+ *(?:$;|#|$Ident:)/) {

1476

my $herevet = "$here\n" . cat_vet($rawline) . "\n";

1476

my $herevet = "$here\n" . cat_vet($rawline) . "\n";

1477

WARN("please, no spaces at the start of a line\n" . $herevet);

1477

WARN("please, no spaces at the start of a line\n" . $herevet);

1478

}

1478

}

1479

1480

# check we are in a valid C source file if not then ignore this hunk

1480

# check we are in a valid C source file if not then ignore this hunk

1481

next if ($realfile !~ /\.(h|c)$/);

1481

next if ($realfile !~ /\.(h|c)$/);

1482

1483

# check for RCS/CVS revision markers

1483

# check for RCS/CVS revision markers

1484

if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {

1484

if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {

1485

WARN("CVS style keyword markers, these will _not_ be updated\n". $herecurr);

1485

WARN("CVS style keyword markers, these will _not_ be updated\n". $herecurr);

1486

}

1486

}

1487

1488

# Blackfin: don't use __builtin_bfin_[cs]sync

1488

# Blackfin: don't use __builtin_bfin_[cs]sync

1489

if ($line =~ /__builtin_bfin_csync/) {

1489

if ($line =~ /__builtin_bfin_csync/) {

1490

my $herevet = "$here\n" . cat_vet($line) . "\n";

1490

my $herevet = "$here\n" . cat_vet($line) . "\n";

1491

ERROR("use the CSYNC() macro in asm/blackfin.h\n" . $herevet);

1491

ERROR("use the CSYNC() macro in asm/blackfin.h\n" . $herevet);

1492

}

1492

}

1493

if ($line =~ /__builtin_bfin_ssync/) {

1493

if ($line =~ /__builtin_bfin_ssync/) {

1494

my $herevet = "$here\n" . cat_vet($line) . "\n";

1494

my $herevet = "$here\n" . cat_vet($line) . "\n";

1495

ERROR("use the SSYNC() macro in asm/blackfin.h\n" . $herevet);

1495

ERROR("use the SSYNC() macro in asm/blackfin.h\n" . $herevet);

1496

}

1496

}

1497

1498

# Check for potential 'bare' types

1498

# Check for potential 'bare' types

1499

my ($stat, $cond, $line_nr_next, $remain_next, $off_next,

1499

my ($stat, $cond, $line_nr_next, $remain_next, $off_next,

1500

$realline_next);

1500

$realline_next);

1501

if ($realcnt && $line =~ /.\s*\S/) {

1501

if ($realcnt && $line =~ /.\s*\S/) {

1502

($stat, $cond, $line_nr_next, $remain_next, $off_next) =

1502

($stat, $cond, $line_nr_next, $remain_next, $off_next) =

1503

ctx_statement_block($linenr, $realcnt, 0);

1503

ctx_statement_block($linenr, $realcnt, 0);

1504

$stat =~ s/\n./\n /g;

1504

$stat =~ s/\n./\n /g;

1505

$cond =~ s/\n./\n /g;

1505

$cond =~ s/\n./\n /g;

1506

1507

# Find the real next line.

1507

# Find the real next line.

1508

$realline_next = $line_nr_next;

1508

$realline_next = $line_nr_next;

1509

if (defined $realline_next &&

1509

if (defined $realline_next &&

1510

(!defined $lines[$realline_next - 1] ||

1510

(!defined $lines[$realline_next - 1] ||

1511

substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {

1511

substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {

1512

$realline_next++;

1512

$realline_next++;

1513

}

1513

}

1514

1515

my $s = $stat;

1515

my $s = $stat;

1516

$s =~ s/{.*$//s;

1516

$s =~ s/{.*$//s;

1517

1518

# Ignore goto labels.

1518

# Ignore goto labels.

1519

if ($s =~ /$Ident:\*$/s) {

1519

if ($s =~ /$Ident:\*$/s) {

1520

1521

# Ignore functions being called

1521

# Ignore functions being called

1522

} elsif ($s =~ /^.\s*$Ident\s*\(/s) {

1522

} elsif ($s =~ /^.\s*$Ident\s*\(/s) {

1523

1524

} elsif ($s =~ /^.\s*else\b/s) {

1524

} elsif ($s =~ /^.\s*else\b/s) {

1525

1526

# declarations always start with types

1526

# declarations always start with types

1527

} 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) {

1527

} 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) {

1528

my $type = $1;

1528

my $type = $1;

1529

$type =~ s/\s+/ /g;

1529

$type =~ s/\s+/ /g;

1530

possible($type, "A:" . $s);

1530

possible($type, "A:" . $s);

1531

1532

# definitions in global scope can only start with types

1532

# definitions in global scope can only start with types

1533

} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {

1533

} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {

1534

possible($1, "B:" . $s);

1534

possible($1, "B:" . $s);

1535

}

1535

}

1536

1537

# any (foo ... *) is a pointer cast, and foo is a type

1537

# any (foo ... *) is a pointer cast, and foo is a type

1538

while ($s =~ /$($Ident)(?:\s+$Sparse)*[\s\*]+\s*$/sg) {

1538

while ($s =~ /$($Ident)(?:\s+$Sparse)*[\s\*]+\s*$/sg) {

1539

possible($1, "C:" . $s);

1539

possible($1, "C:" . $s);

1540

}

1540

}

1541

1542

# Check for any sort of function declaration.

1542

# Check for any sort of function declaration.

1543

# int foo(something bar, other baz);

1543

# int foo(something bar, other baz);

1544

# void (*store_gdt)(x86_descr_ptr *);

1544

# void (*store_gdt)(x86_descr_ptr *);

1545

if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|$\*\s*$Ident$)\s*)\(/s) {

1545

if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|$\*\s*$Ident$)\s*)\(/s) {

1546

my ($name_len) = length($1);

1546

my ($name_len) = length($1);

1547

1548

my $ctx = $s;

1548

my $ctx = $s;

1549

substr($ctx, 0, $name_len + 1, '');

1549

substr($ctx, 0, $name_len + 1, '');

1550

$ctx =~ s/\)[^\)]*$//;

1550

$ctx =~ s/\)[^\)]*$//;

1551

1552

for my $arg (split(/\s*,\s*/, $ctx)) {

1552

for my $arg (split(/\s*,\s*/, $ctx)) {

1553

if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {

1553

if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {

1554

1555

possible($1, "D:" . $s);

1555

possible($1, "D:" . $s);

1556

}

1556

}

1557

}

1557

}

1558

}

1558

}

1559

1560

}

1560

}

1561

1562

#

1562

#

1563

# Checks which may be anchored in the context.

1563

# Checks which may be anchored in the context.

1564

#

1564

#

1565

1566

# Check for switch () and associated case and default

1566

# Check for switch () and associated case and default

1567

# statements should be at the same indent.

1567

# statements should be at the same indent.

1568

if ($line=~/\bswitch\s*$.*$/) {

1568

if ($line=~/\bswitch\s*$.*$/) {

1569

my $err = '';

1569

my $err = '';

1570

my $sep = '';

1570

my $sep = '';

1571

my @ctx = ctx_block_outer($linenr, $realcnt);

1571

my @ctx = ctx_block_outer($linenr, $realcnt);

1572

shift(@ctx);

1572

shift(@ctx);

1573

for my $ctx (@ctx) {

1573

for my $ctx (@ctx) {

1574

my ($clen, $cindent) = line_stats($ctx);

1574

my ($clen, $cindent) = line_stats($ctx);

1575

if ($ctx =~ /^\+\s*(case\s+|default:)/ &&

1575

if ($ctx =~ /^\+\s*(case\s+|default:)/ &&

1576

$indent != $cindent) {

1576

$indent != $cindent) {

1577

$err .= "$sep$ctx\n";

1577

$err .= "$sep$ctx\n";

1578

$sep = '';

1578

$sep = '';

1579

} else {

1579

} else {

1580

$sep = "[...]\n";

1580

$sep = "[...]\n";

1581

}

1581

}

1582

}

1582

}

1583

if ($err ne '') {

1583

if ($err ne '') {

1584

ERROR("switch and case should be at the same indent\n$hereline$err");

1584

ERROR("switch and case should be at the same indent\n$hereline$err");

1585

}

1585

}

1586

}

1586

}

1587

1588

# if/while/etc brace do not go on next line, unless defining a do while loop,

1588

# if/while/etc brace do not go on next line, unless defining a do while loop,

1589

# or if that brace on the next line is for something else

1589

# or if that brace on the next line is for something else

1590

if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {

1590

if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {

1591

my $pre_ctx = "$1$2";

1591

my $pre_ctx = "$1$2";

1592

1593

my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);

1593

my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);

1594

my $ctx_cnt = $realcnt - $#ctx - 1;

1594

my $ctx_cnt = $realcnt - $#ctx - 1;

1595

my $ctx = join("\n", @ctx);

1595

my $ctx = join("\n", @ctx);

1596

1597

my $ctx_ln = $linenr;

1597

my $ctx_ln = $linenr;

1598

my $ctx_skip = $realcnt;

1598

my $ctx_skip = $realcnt;

1599

1600

while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&

1600

while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&

1601

defined $lines[$ctx_ln - 1] &&

1601

defined $lines[$ctx_ln - 1] &&

1602

$lines[$ctx_ln - 1] =~ /^-/)) {

1602

$lines[$ctx_ln - 1] =~ /^-/)) {

1603

##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";

1603

##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";

1604

$ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);

1604

$ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);

1605

$ctx_ln++;

1605

$ctx_ln++;

1606

}

1606

}

1607

1608

#print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";

1608

#print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";

1609

#print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";

1609

#print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";

1610

1611

if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {

1611

if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {

1612

ERROR("that open brace { should be on the previous line\n" .

1612

ERROR("that open brace { should be on the previous line\n" .

1613

"$here\n$ctx\n$lines[$ctx_ln - 1]\n");

1613

"$here\n$ctx\n$lines[$ctx_ln - 1]\n");

1614

}

1614

}

1615

if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&

1615

if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&

1616

$ctx =~ /\)\s*\;\s*$/ &&

1616

$ctx =~ /\)\s*\;\s*$/ &&

1617

defined $lines[$ctx_ln - 1])

1617

defined $lines[$ctx_ln - 1])

1618

{

1618

{

1619

my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);

1619

my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);

1620

if ($nindent > $indent) {

1620

if ($nindent > $indent) {

1621

WARN("trailing semicolon indicates no statements, indent implies otherwise\n" .

1621

WARN("trailing semicolon indicates no statements, indent implies otherwise\n" .

1622

"$here\n$ctx\n$lines[$ctx_ln - 1]\n");

1622

"$here\n$ctx\n$lines[$ctx_ln - 1]\n");

1623

}

1623

}

1624

}

1624

}

1625

}

1625

}

1626

1627

# Check relative indent for conditionals and blocks.

1627

# Check relative indent for conditionals and blocks.

1628

if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {

1628

if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {

1629

my ($s, $c) = ($stat, $cond);

1629

my ($s, $c) = ($stat, $cond);

1630

1631

substr($s, 0, length($c), '');

1631

substr($s, 0, length($c), '');

1632

1633

# Make sure we remove the line prefixes as we have

1633

# Make sure we remove the line prefixes as we have

1634

# none on the first line, and are going to readd them

1634

# none on the first line, and are going to readd them

1635

# where necessary.

1635

# where necessary.

1636

$s =~ s/\n./\n/gs;

1636

$s =~ s/\n./\n/gs;

1637

1638

# Find out how long the conditional actually is.

1638

# Find out how long the conditional actually is.

1639

my @newlines = ($c =~ /\n/gs);

1639

my @newlines = ($c =~ /\n/gs);

1640

my $cond_lines = 1 + $#newlines;

1640

my $cond_lines = 1 + $#newlines;

1641

1642

# We want to check the first line inside the block

1642

# We want to check the first line inside the block

1643

# starting at the end of the conditional, so remove:

1643

# starting at the end of the conditional, so remove:

1644

# 1) any blank line termination

1644

# 1) any blank line termination

1645

# 2) any opening brace { on end of the line

1645

# 2) any opening brace { on end of the line

1646

# 3) any do (...) {

1646

# 3) any do (...) {

1647

my $continuation = 0;

1647

my $continuation = 0;

1648

my $check = 0;

1648

my $check = 0;

1649

$s =~ s/^.*\bdo\b//;

1649

$s =~ s/^.*\bdo\b//;

1650

$s =~ s/^\s*{//;

1650

$s =~ s/^\s*{//;

1651

if ($s =~ s/^\s*\\//) {

1651

if ($s =~ s/^\s*\\//) {

1652

$continuation = 1;

1652

$continuation = 1;

1653

}

1653

}

1654

if ($s =~ s/^\s*?\n//) {

1654

if ($s =~ s/^\s*?\n//) {

1655

$check = 1;

1655

$check = 1;

1656

$cond_lines++;

1656

$cond_lines++;

1657

}

1657

}

1658

1659

# Also ignore a loop construct at the end of a

1659

# Also ignore a loop construct at the end of a

1660

# preprocessor statement.

1660

# preprocessor statement.

1661

if (($prevline =~ /^.\s*#\s*define\s/ ||

1661

if (($prevline =~ /^.\s*#\s*define\s/ ||

1662

$prevline =~ /\\\s*$/) && $continuation == 0) {

1662

$prevline =~ /\\\s*$/) && $continuation == 0) {

1663

$check = 0;

1663

$check = 0;

1664

}

1664

}

1665

1666

my $cond_ptr = -1;

1666

my $cond_ptr = -1;

1667

$continuation = 0;

1667

$continuation = 0;

1668

while ($cond_ptr != $cond_lines) {

1668

while ($cond_ptr != $cond_lines) {

1669

$cond_ptr = $cond_lines;

1669

$cond_ptr = $cond_lines;

1670

1671

# If we see an #else/#elif then the code

1671

# If we see an #else/#elif then the code

1672

# is not linear.

1672

# is not linear.

1673

if ($s =~ /^\s*\#\s*(?:else|elif)/) {

1673

if ($s =~ /^\s*\#\s*(?:else|elif)/) {

1674

$check = 0;

1674

$check = 0;

1675

}

1675

}

1676

1677

# Ignore:

1677

# Ignore:

1678

# 1) blank lines, they should be at 0,

1678

# 1) blank lines, they should be at 0,

1679

# 2) preprocessor lines, and

1679

# 2) preprocessor lines, and

1680

# 3) labels.

1680

# 3) labels.

1681

if ($continuation ||

1681

if ($continuation ||

1682

$s =~ /^\s*?\n/ ||

1682

$s =~ /^\s*?\n/ ||

1683

$s =~ /^\s*#\s*?/ ||

1683

$s =~ /^\s*#\s*?/ ||

1684

$s =~ /^\s*$Ident\s*:/) {

1684

$s =~ /^\s*$Ident\s*:/) {

1685

$continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;

1685

$continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;

1686

if ($s =~ s/^.*?\n//) {

1686

if ($s =~ s/^.*?\n//) {

1687

$cond_lines++;

1687

$cond_lines++;

1688

}

1688

}

1689

}

1689

}

1690

}

1690

}

1691

1692

my (undef, $sindent) = line_stats("+" . $s);

1692

my (undef, $sindent) = line_stats("+" . $s);

1693

my $stat_real = raw_line($linenr, $cond_lines);

1693

my $stat_real = raw_line($linenr, $cond_lines);

1694

1695

# Check if either of these lines are modified, else

1695

# Check if either of these lines are modified, else

1696

# this is not this patch's fault.

1696

# this is not this patch's fault.

1697

if (!defined($stat_real) ||

1697

if (!defined($stat_real) ||

1698

$stat !~ /^\+/ && $stat_real !~ /^\+/) {

1698

$stat !~ /^\+/ && $stat_real !~ /^\+/) {

1699

$check = 0;

1699

$check = 0;

1700

}

1700

}

1701

if (defined($stat_real) && $cond_lines > 1) {

1701

if (defined($stat_real) && $cond_lines > 1) {

1702

$stat_real = "[...]\n$stat_real";

1702

$stat_real = "[...]\n$stat_real";

1703

}

1703

}

1704

1705

#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";

1705

#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";

1706

1707

if ($check && (($sindent % 8) != 0 ||

1707

if ($check && (($sindent % 8) != 0 ||

1708

($sindent <= $indent && $s ne ''))) {

1708

($sindent <= $indent && $s ne ''))) {

1709

WARN("suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");

1709

WARN("suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");

1710

}

1710

}

1711

}

1711

}

1712

1713

# Track the 'values' across context and added lines.

1713

# Track the 'values' across context and added lines.

1714

my $opline = $line; $opline =~ s/^./ /;

1714

my $opline = $line; $opline =~ s/^./ /;

1715

my ($curr_values, $curr_vars) =

1715

my ($curr_values, $curr_vars) =

1716

annotate_values($opline . "\n", $prev_values);

1716

annotate_values($opline . "\n", $prev_values);

1717

$curr_values = $prev_values . $curr_values;

1717

$curr_values = $prev_values . $curr_values;

1718

if ($dbg_values) {

1718

if ($dbg_values) {

1719

my $outline = $opline; $outline =~ s/\t/ /g;

1719

my $outline = $opline; $outline =~ s/\t/ /g;

1720

print "$linenr > .$outline\n";

1720

print "$linenr > .$outline\n";

1721

print "$linenr > $curr_values\n";

1721

print "$linenr > $curr_values\n";

1722

print "$linenr > $curr_vars\n";

1722

print "$linenr > $curr_vars\n";

1723

}

1723

}

1724

$prev_values = substr($curr_values, -1);

1724

$prev_values = substr($curr_values, -1);

1725

1726

#ignore lines not being added

1726

#ignore lines not being added

1727

if ($line=~/^[^\+]/) {next;}

1727

if ($line=~/^[^\+]/) {next;}

1728

1729

# TEST: allow direct testing of the type matcher.

1729

# TEST: allow direct testing of the type matcher.

1730

if ($dbg_type) {

1730

if ($dbg_type) {

1731

if ($line =~ /^.\s*$Declare\s*$/) {

1731

if ($line =~ /^.\s*$Declare\s*$/) {

1732

ERROR("TEST: is type\n" . $herecurr);

1732

ERROR("TEST: is type\n" . $herecurr);

1733

} elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {

1733

} elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {

1734

ERROR("TEST: is not type ($1 is)\n". $herecurr);

1734

ERROR("TEST: is not type ($1 is)\n". $herecurr);

1735

}

1735

}

1736

next;

1736

next;

1737

}

1737

}

1738

# TEST: allow direct testing of the attribute matcher.

1738

# TEST: allow direct testing of the attribute matcher.

1739

if ($dbg_attr) {

1739

if ($dbg_attr) {

1740

if ($line =~ /^.\s*$Modifier\s*$/) {

1740

if ($line =~ /^.\s*$Modifier\s*$/) {

1741

ERROR("TEST: is attr\n" . $herecurr);

1741

ERROR("TEST: is attr\n" . $herecurr);

1742

} elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {

1742

} elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {

1743

ERROR("TEST: is not attr ($1 is)\n". $herecurr);

1743

ERROR("TEST: is not attr ($1 is)\n". $herecurr);

1744

}

1744

}

1745

next;

1745

next;

1746

}

1746

}

1747

1748

# check for initialisation to aggregates open brace on the next line

1748

# check for initialisation to aggregates open brace on the next line

1749

if ($line =~ /^.\s*{/ &&

1749

if ($line =~ /^.\s*{/ &&

1750

$prevline =~ /(?:^|[^=])=\s*$/) {

1750

$prevline =~ /(?:^|[^=])=\s*$/) {

1751

ERROR("that open brace { should be on the previous line\n" . $hereprev);

1751

ERROR("that open brace { should be on the previous line\n" . $hereprev);

1752

}

1752

}

1753

1754

#

1754

#

1755

# Checks which are anchored on the added line.

1755

# Checks which are anchored on the added line.

1756

#

1756

#

1757

1758

# check for malformed paths in #include statements (uses RAW line)

1758

# check for malformed paths in #include statements (uses RAW line)

1759

if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {

1759

if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {

1760

my $path = $1;

1760

my $path = $1;

1761

if ($path =~ m{//}) {

1761

if ($path =~ m{//}) {

1762

ERROR("malformed #include filename\n" .

1762

ERROR("malformed #include filename\n" .

1763

$herecurr);

1763

$herecurr);

1764

}

1764

}

1765

}

1765

}

1766

1767

# no C99 // comments

1767

# no C99 // comments

1768

if ($line =~ m{//}) {

1768

if ($line =~ m{//}) {

1769

ERROR("do not use C99 // comments\n" . $herecurr);

1769

ERROR("do not use C99 // comments\n" . $herecurr);

1770

}

1770

}

1771

# Remove C99 comments.

1771

# Remove C99 comments.

1772

$line =~ s@//.*@@;

1772

$line =~ s@//.*@@;

1773

$opline =~ s@//.*@@;

1773

$opline =~ s@//.*@@;

1774

1775

# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider

1775

# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider

1776

# the whole statement.

1776

# the whole statement.

1777

#print "APW <$lines[$realline_next - 1]>\n";

1777

#print "APW <$lines[$realline_next - 1]>\n";

1778

if (defined $realline_next &&

1778

if (defined $realline_next &&

1779

exists $lines[$realline_next - 1] &&

1779

exists $lines[$realline_next - 1] &&

1780

!defined $suppress_export{$realline_next} &&

1780

!defined $suppress_export{$realline_next} &&

1781

($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*$(.*)$/ ||

1781

($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*$(.*)$/ ||

1782

$lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*$(.*)$/)) {

1782

$lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*$(.*)$/)) {

1783

my $name = $1;

1783

my $name = $1;

1784

if ($stat !~ /(?:

1784

if ($stat !~ /(?:

1785

\n.}\s*$|

1785

\n.}\s*$|

1786

^.DEFINE_$Ident$\Q$name\E$|

1786

^.DEFINE_$Ident$\Q$name\E$|

1787

^.DECLARE_$Ident$\Q$name\E$|

1787

^.DECLARE_$Ident$\Q$name\E$|

1788

^.LIST_HEAD$\Q$name\E$|

1788

^.LIST_HEAD$\Q$name\E$|

1789

^.(?:$Storage\s+)?$Type\s*$\s*\*\s*\Q$name\E\s*$\s*\(|

1789

^.(?:$Storage\s+)?$Type\s*$\s*\*\s*\Q$name\E\s*$\s*\(|

1790

\b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()

1790

\b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()

1791

)/x) {

1791

)/x) {

1792

#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";

1792

#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";

1793

$suppress_export{$realline_next} = 2;

1793

$suppress_export{$realline_next} = 2;

1794

} else {

1794

} else {

1795

$suppress_export{$realline_next} = 1;

1795

$suppress_export{$realline_next} = 1;

1796

}

1796

}

1797

}

1797

}

1798

if (!defined $suppress_export{$linenr} &&

1798

if (!defined $suppress_export{$linenr} &&

1799

$prevline =~ /^.\s*$/ &&

1799

$prevline =~ /^.\s*$/ &&

1800

($line =~ /EXPORT_SYMBOL.*$(.*)$/ ||

1800

($line =~ /EXPORT_SYMBOL.*$(.*)$/ ||

1801

$line =~ /EXPORT_UNUSED_SYMBOL.*$(.*)$/)) {

1801

$line =~ /EXPORT_UNUSED_SYMBOL.*$(.*)$/)) {

1802

#print "FOO B <$lines[$linenr - 1]>\n";

1802

#print "FOO B <$lines[$linenr - 1]>\n";

1803

$suppress_export{$linenr} = 2;

1803

$suppress_export{$linenr} = 2;

1804

}

1804

}

1805

if (defined $suppress_export{$linenr} &&

1805

if (defined $suppress_export{$linenr} &&

1806

$suppress_export{$linenr} == 2) {

1806

$suppress_export{$linenr} == 2) {

1807

WARN("EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);

1807

WARN("EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);

1808

}

1808

}

1809

1810

# check for global initialisers.

1810

# check for global initialisers.

1811

if ($line =~ /^.$Type\s*$Ident\s*(?:\s+$Modifier)*\s*=\s*(0|NULL|false)\s*;/) {

1811

if ($line =~ /^.$Type\s*$Ident\s*(?:\s+$Modifier)*\s*=\s*(0|NULL|false)\s*;/) {

1812

ERROR("do not initialise globals to 0 or NULL\n" .

1812

ERROR("do not initialise globals to 0 or NULL\n" .

1813

$herecurr);

1813

$herecurr);

1814

}

1814

}

1815

# check for static initialisers.

1815

# check for static initialisers.

1816

if ($line =~ /\bstatic\s.*=\s*(0|NULL|false)\s*;/) {

1816

if ($line =~ /\bstatic\s.*=\s*(0|NULL|false)\s*;/) {

1817

ERROR("do not initialise statics to 0 or NULL\n" .

1817

ERROR("do not initialise statics to 0 or NULL\n" .

1818

$herecurr);

1818

$herecurr);

1819

}

1819

}

1820

1821

# check for new typedefs, only function parameters and sparse annotations

1821

# check for new typedefs, only function parameters and sparse annotations

1822

# make sense.

1822

# make sense.

1823

if ($line =~ /\btypedef\s/ &&

1823

if ($line =~ /\btypedef\s/ &&

1824

$line !~ /\btypedef\s+$Type\s*$\s*\*?$Ident\s*$\s*\(/ &&

1824

$line !~ /\btypedef\s+$Type\s*$\s*\*?$Ident\s*$\s*\(/ &&

1825

$line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&

1825

$line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&

1826

$line !~ /\b$typeTypedefs\b/ &&

1826

$line !~ /\b$typeTypedefs\b/ &&

1827

$line !~ /\b__bitwise(?:__|)\b/) {

1827

$line !~ /\b__bitwise(?:__|)\b/) {

1828

WARN("do not add new typedefs\n" . $herecurr);

1828

WARN("do not add new typedefs\n" . $herecurr);

1829

}

1829

}

1830

1831

# * goes on variable not on type

1831

# * goes on variable not on type

1832

# (char*[ const])

1832

# (char*[ const])

1833

if ($line =~ m{$$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)$}) {

1833

if ($line =~ m{$$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)$}) {

1834

my ($from, $to) = ($1, $1);

1834

my ($from, $to) = ($1, $1);

1835

1836

# Should start with a space.

1836

# Should start with a space.

1837

$to =~ s/^(\S)/ $1/;

1837

$to =~ s/^(\S)/ $1/;

1838

# Should not end with a space.

1838

# Should not end with a space.

1839

$to =~ s/\s+$//;

1839

$to =~ s/\s+$//;

1840

# '*'s should not have spaces between.

1840

# '*'s should not have spaces between.

1841

while ($to =~ s/\*\s+\*/\*\*/) {

1841

while ($to =~ s/\*\s+\*/\*\*/) {

1842

}

1842

}

1843

1844

#print "from<$from> to<$to>\n";

1844

#print "from<$from> to<$to>\n";

1845

if ($from ne $to) {

1845

if ($from ne $to) {

1846

ERROR("\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr);

1846

ERROR("\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr);

1847

}

1847

}

1848

} elsif ($line =~ m{\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident)}) {

1848

} elsif ($line =~ m{\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident)}) {

1849

my ($from, $to, $ident) = ($1, $1, $2);

1849

my ($from, $to, $ident) = ($1, $1, $2);

1850

1851

# Should start with a space.

1851

# Should start with a space.

1852

$to =~ s/^(\S)/ $1/;

1852

$to =~ s/^(\S)/ $1/;

1853

# Should not end with a space.

1853

# Should not end with a space.

1854

$to =~ s/\s+$//;

1854

$to =~ s/\s+$//;

1855

# '*'s should not have spaces between.

1855

# '*'s should not have spaces between.

1856

while ($to =~ s/\*\s+\*/\*\*/) {

1856

while ($to =~ s/\*\s+\*/\*\*/) {

1857

}

1857

}

1858

# Modifiers should have spaces.

1858

# Modifiers should have spaces.

1859

$to =~ s/(\b$Modifier$)/$1 /;

1859

$to =~ s/(\b$Modifier$)/$1 /;

1860

1861

#print "from<$from> to<$to> ident<$ident>\n";

1861

#print "from<$from> to<$to> ident<$ident>\n";

1862

if ($from ne $to && $ident !~ /^$Modifier$/) {

1862

if ($from ne $to && $ident !~ /^$Modifier$/) {

1863

ERROR("\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr);

1863

ERROR("\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr);

1864

}

1864

}

1865

}

1865

}

1866

1867

# # no BUG() or BUG_ON()

1867

# # no BUG() or BUG_ON()

1868

# if ($line =~ /\b(BUG|BUG_ON)\b/) {

1868

# if ($line =~ /\b(BUG|BUG_ON)\b/) {

1869

# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";

1869

# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";

1870

# print "$herecurr";

1870

# print "$herecurr";

1871

# $clean = 0;

1871

# $clean = 0;

1872

# }

1872

# }

1873

1874

if ($line =~ /\bLINUX_VERSION_CODE\b/) {

1874

if ($line =~ /\bLINUX_VERSION_CODE\b/) {

1875

WARN("LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);

1875

WARN("LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);

1876

}

1876

}

1877

1878

# printk should use KERN_* levels. Note that follow on printk's on the

1878

# printk should use KERN_* levels. Note that follow on printk's on the

1879

# same line do not need a level, so we use the current block context

1879

# same line do not need a level, so we use the current block context

1880

# to try and find and validate the current printk. In summary the current

1880

# to try and find and validate the current printk. In summary the current

1881

# printk includes all preceeding printk's which have no newline on the end.

1881

# printk includes all preceeding printk's which have no newline on the end.

1882

# we assume the first bad printk is the one to report.

1882

# we assume the first bad printk is the one to report.

1883

if ($line =~ /\bprintk\((?!KERN_)\s*"/) {

1883

if ($line =~ /\bprintk\((?!KERN_)\s*"/) {

1884

my $ok = 0;

1884

my $ok = 0;

1885

for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {

1885

for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {

1886

#print "CHECK<$lines[$ln - 1]\n";

1886

#print "CHECK<$lines[$ln - 1]\n";

1887

# we have a preceeding printk if it ends

1887

# we have a preceeding printk if it ends

1888

# with "\n" ignore it, else it is to blame

1888

# with "\n" ignore it, else it is to blame

1889

if ($lines[$ln - 1] =~ m{\bprintk\(}) {

1889

if ($lines[$ln - 1] =~ m{\bprintk\(}) {

1890

if ($rawlines[$ln - 1] !~ m{\\n"}) {

1890

if ($rawlines[$ln - 1] !~ m{\\n"}) {

1891

$ok = 1;

1891

$ok = 1;

1892

}

1892

}

1893

last;

1893

last;

1894

}

1894

}

1895

}

1895

}

1896

if ($ok == 0) {

1896

if ($ok == 0) {

1897

WARN("printk() should include KERN_ facility level\n" . $herecurr);

1897

WARN("printk() should include KERN_ facility level\n" . $herecurr);

1898

}

1898

}

1899

}

1899

}

1900

1901

# function brace can't be on same line, except for #defines of do while,

1901

# function brace can't be on same line, except for #defines of do while,

1902

# or if closed on same line

1902

# or if closed on same line

1903

if (($line=~/$Type\s*$Ident$.*$.*\s{/) and

1903

if (($line=~/$Type\s*$Ident$.*$.*\s{/) and

1904

!($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {

1904

!($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {

1905

ERROR("open brace '{' following function declarations go on the next line\n" . $herecurr);

1905

ERROR("open brace '{' following function declarations go on the next line\n" . $herecurr);

1906

}

1906

}

1907

1908

# open braces for enum, union and struct go on the same line.

1908

# open braces for enum, union and struct go on the same line.

1909

if ($line =~ /^.\s*{/ &&

1909

if ($line =~ /^.\s*{/ &&

1910

$prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {

1910

$prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {

1911

ERROR("open brace '{' following $1 go on the same line\n" . $hereprev);

1911

ERROR("open brace '{' following $1 go on the same line\n" . $hereprev);

1912

}

1912

}

1913

1914

# check for spacing round square brackets; allowed:

1914

# check for spacing round square brackets; allowed:

1915

# 1. with a type on the left -- int [] a;

1915

# 1. with a type on the left -- int [] a;

1916

# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,

1916

# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,

1917

# 3. inside a curly brace -- = { [0...10] = 5 }

1917

# 3. inside a curly brace -- = { [0...10] = 5 }

1918

while ($line =~ /(.*?\s)\[/g) {

1918

while ($line =~ /(.*?\s)\[/g) {

1919

my ($where, $prefix) = ($-[1], $1);

1919

my ($where, $prefix) = ($-[1], $1);

1920

if ($prefix !~ /$Type\s+$/ &&

1920

if ($prefix !~ /$Type\s+$/ &&

1921

($where != 0 || $prefix !~ /^.\s+$/) &&

1921

($where != 0 || $prefix !~ /^.\s+$/) &&

1922

$prefix !~ /{\s+$/) {

1922

$prefix !~ /{\s+$/) {

1923

ERROR("space prohibited before open square bracket '['\n" . $herecurr);

1923

ERROR("space prohibited before open square bracket '['\n" . $herecurr);

1924

}

1924

}

1925

}

1925

}

1926

1927

# check for spaces between functions and their parentheses.

1927

# check for spaces between functions and their parentheses.

1928

while ($line =~ /($Ident)\s+\(/g) {

1928

while ($line =~ /($Ident)\s+\(/g) {

1929

my $name = $1;

1929

my $name = $1;

1930

my $ctx_before = substr($line, 0, $-[1]);

1930

my $ctx_before = substr($line, 0, $-[1]);

1931

my $ctx = "$ctx_before$name";

1931

my $ctx = "$ctx_before$name";

1932

1933

# Ignore those directives where spaces _are_ permitted.

1933

# Ignore those directives where spaces _are_ permitted.

1934

if ($name =~ /^(?:

1934

if ($name =~ /^(?:

1935

1935

1936

volatile|__volatile__|

1936

volatile|__volatile__|

1937

__attribute__|format|__extension__|

1937

__attribute__|format|__extension__|

1938

asm|__asm__)$/x)

1938

asm|__asm__)$/x)

1939

{

1939

{

1940

1941

# cpp #define statements have non-optional spaces, ie

1941

# cpp #define statements have non-optional spaces, ie

1942

# if there is a space between the name and the open

1942

# if there is a space between the name and the open

1943

# parenthesis it is simply not a parameter group.

1943

# parenthesis it is simply not a parameter group.

1944

} elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {

1944

} elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {

1945

1946

# cpp #elif statement condition may start with a (

1946

# cpp #elif statement condition may start with a (

1947

} elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {

1947

} elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {

1948

1949

# If this whole things ends with a type its most

1949

# If this whole things ends with a type its most

1950

# likely a typedef for a function.

1950

# likely a typedef for a function.

1951

} elsif ($ctx =~ /$Type$/) {

1951

} elsif ($ctx =~ /$Type$/) {

1952

1953

} else {

1953

} else {

1954

WARN("space prohibited between function name and open parenthesis '('\n" . $herecurr);

1954

WARN("space prohibited between function name and open parenthesis '('\n" . $herecurr);

1955

}

1955

}

1956

}

1956

}

1957

# Check operator spacing.

1957

# Check operator spacing.

1958

if (!($line=~/\#\s*include/)) {

1958

if (!($line=~/\#\s*include/)) {

1959

my $ops = qr{

1959

my $ops = qr{

1960

<<=|>>=|<=|>=|==|!=|

1960

<<=|>>=|<=|>=|==|!=|

1961

\+=|-=|\*=|\/=|%=|\^=|\|=|&=|

1961

\+=|-=|\*=|\/=|%=|\^=|\|=|&=|

1962

=>|->|<<|>>|<|>|=|!|~|

1962

=>|->|<<|>>|<|>|=|!|~|

1963

&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|

1963

&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|

1964

\?|:

1964

\?|:

1965

}x;

1965

}x;

1966

my @elements = split(/($ops|;)/, $opline);

1966

my @elements = split(/($ops|;)/, $opline);

1967

my $off = 0;

1967

my $off = 0;

1968

1969

my $blank = copy_spacing($opline);

1969

my $blank = copy_spacing($opline);

1970

1971

for (my $n = 0; $n < $#elements; $n += 2) {

1971

for (my $n = 0; $n < $#elements; $n += 2) {

1972

$off += length($elements[$n]);

1972

$off += length($elements[$n]);

1973

1974

# Pick up the preceeding and succeeding characters.

1974

# Pick up the preceeding and succeeding characters.

1975

my $ca = substr($opline, 0, $off);

1975

my $ca = substr($opline, 0, $off);

1976

my $cc = '';

1976

my $cc = '';

1977

if (length($opline) >= ($off + length($elements[$n + 1]))) {

1977

if (length($opline) >= ($off + length($elements[$n + 1]))) {

1978

$cc = substr($opline, $off + length($elements[$n + 1]));

1978

$cc = substr($opline, $off + length($elements[$n + 1]));

1979

}

1979

}

1980

my $cb = "$ca$;$cc";

1980

my $cb = "$ca$;$cc";

1981

1982

my $a = '';

1982

my $a = '';

1983

$a = 'V' if ($elements[$n] ne '');

1983

$a = 'V' if ($elements[$n] ne '');

1984

$a = 'W' if ($elements[$n] =~ /\s$/);

1984

$a = 'W' if ($elements[$n] =~ /\s$/);

1985

$a = 'C' if ($elements[$n] =~ /$;$/);

1985

$a = 'C' if ($elements[$n] =~ /$;$/);

1986

$a = 'B' if ($elements[$n] =~ /(\[|\()$/);

1986

$a = 'B' if ($elements[$n] =~ /(\[|\()$/);

1987

$a = 'O' if ($elements[$n] eq '');

1987

$a = 'O' if ($elements[$n] eq '');

1988

$a = 'E' if ($ca =~ /^\s*$/);

1988

$a = 'E' if ($ca =~ /^\s*$/);

1989

1990

my $op = $elements[$n + 1];

1990

my $op = $elements[$n + 1];

1991

1992

my $c = '';

1992

my $c = '';

1993

if (defined $elements[$n + 2]) {

1993

if (defined $elements[$n + 2]) {

1994

$c = 'V' if ($elements[$n + 2] ne '');

1994

$c = 'V' if ($elements[$n + 2] ne '');

1995

$c = 'W' if ($elements[$n + 2] =~ /^\s/);

1995

$c = 'W' if ($elements[$n + 2] =~ /^\s/);

1996

$c = 'C' if ($elements[$n + 2] =~ /^$;/);

1996

$c = 'C' if ($elements[$n + 2] =~ /^$;/);

1997

$c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);

1997

$c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);

1998

$c = 'O' if ($elements[$n + 2] eq '');

1998

$c = 'O' if ($elements[$n + 2] eq '');

1999

$c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);

1999

$c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);

2000

} else {

2000

} else {

2001

$c = 'E';

2001

$c = 'E';

2002

}

2002

}

2003

2004

my $ctx = "${a}x${c}";

2004

my $ctx = "${a}x${c}";

2005

2006

my $at = "(ctx:$ctx)";

2006

my $at = "(ctx:$ctx)";

2007

2008

my $ptr = substr($blank, 0, $off) . "^";

2008

my $ptr = substr($blank, 0, $off) . "^";

2009

my $hereptr = "$hereline$ptr\n";

2009

my $hereptr = "$hereline$ptr\n";

2010

2011

# Pull out the value of this operator.

2011

# Pull out the value of this operator.

2012

my $op_type = substr($curr_values, $off + 1, 1);

2012

my $op_type = substr($curr_values, $off + 1, 1);

2013

2014

# Get the full operator variant.

2014

# Get the full operator variant.

2015

my $opv = $op . substr($curr_vars, $off, 1);

2015

my $opv = $op . substr($curr_vars, $off, 1);

2016

2017

# Ignore operators passed as parameters.

2017

# Ignore operators passed as parameters.

2018

if ($op_type ne 'V' &&

2018

if ($op_type ne 'V' &&

2019

$ca =~ /\s$/ && $cc =~ /^\s*,/) {

2019

$ca =~ /\s$/ && $cc =~ /^\s*,/) {

2020

2021

# # Ignore comments

2021

# # Ignore comments

2022

# } elsif ($op =~ /^$;+$/) {

2022

# } elsif ($op =~ /^$;+$/) {

2023

2024

# ; should have either the end of line or a space or \ after it

2024

# ; should have either the end of line or a space or \ after it

2025

} elsif ($op eq ';') {

2025

} elsif ($op eq ';') {

2026

if ($ctx !~ /.x[WEBC]/ &&

2026

if ($ctx !~ /.x[WEBC]/ &&

2027

$cc !~ /^\\/ && $cc !~ /^;/) {

2027

$cc !~ /^\\/ && $cc !~ /^;/) {

2028

ERROR("space required after that '$op' $at\n" . $hereptr);

2028

ERROR("space required after that '$op' $at\n" . $hereptr);

2029

}

2029

}

2030

2031

# // is a comment

2031

# // is a comment

2032

} elsif ($op eq '//') {

2032

} elsif ($op eq '//') {

2033

2034

# No spaces for:

2034

# No spaces for:

2035

# ->

2035

# ->

2036

# : when part of a bitfield

2036

# : when part of a bitfield

2037

} elsif ($op eq '->' || $opv eq ':B') {

2037

} elsif ($op eq '->' || $opv eq ':B') {

2038

if ($ctx =~ /Wx.|.xW/) {

2038

if ($ctx =~ /Wx.|.xW/) {

2039

ERROR("spaces prohibited around that '$op' $at\n" . $hereptr);

2039

ERROR("spaces prohibited around that '$op' $at\n" . $hereptr);

2040

}

2040

}

2041

2042

# , must have a space on the right.

2042

# , must have a space on the right.

2043

} elsif ($op eq ',') {

2043

} elsif ($op eq ',') {

2044

if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {

2044

if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {

2045

ERROR("space required after that '$op' $at\n" . $hereptr);

2045

ERROR("space required after that '$op' $at\n" . $hereptr);

2046

}

2046

}

2047

2048

# '*' as part of a type definition -- reported already.

2048

# '*' as part of a type definition -- reported already.

2049

} elsif ($opv eq '*_') {

2049

} elsif ($opv eq '*_') {

2050

#warn "'*' is part of type\n";

2050

#warn "'*' is part of type\n";

2051

2052

# unary operators should have a space before and

2052

# unary operators should have a space before and

2053

# none after. May be left adjacent to another

2053

# none after. May be left adjacent to another

2054

# unary operator, or a cast

2054

# unary operator, or a cast

2055

} elsif ($op eq '!' || $op eq '~' ||

2055

} elsif ($op eq '!' || $op eq '~' ||

2056

$opv eq '*U' || $opv eq '-U' ||

2056

$opv eq '*U' || $opv eq '-U' ||

2057

$opv eq '&U' || $opv eq '&&U') {

2057

$opv eq '&U' || $opv eq '&&U') {

2058

if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {

2058

if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {

2059

ERROR("space required before that '$op' $at\n" . $hereptr);

2059

ERROR("space required before that '$op' $at\n" . $hereptr);

2060

}

2060

}

2061

if ($op eq '*' && $cc =~/\s*$Modifier\b/) {

2061

if ($op eq '*' && $cc =~/\s*$Modifier\b/) {

2062

# A unary '*' may be const

2062

# A unary '*' may be const

2063

2064

} elsif ($ctx =~ /.xW/) {

2064

} elsif ($ctx =~ /.xW/) {

2065

ERROR("space prohibited after that '$op' $at\n" . $hereptr);

2065

ERROR("space prohibited after that '$op' $at\n" . $hereptr);

2066

}

2066

}

2067

2068

# unary ++ and unary -- are allowed no space on one side.

2068

# unary ++ and unary -- are allowed no space on one side.

2069

} elsif ($op eq '++' or $op eq '--') {

2069

} elsif ($op eq '++' or $op eq '--') {

2070

if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {

2070

if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {

2071

ERROR("space required one side of that '$op' $at\n" . $hereptr);

2071

ERROR("space required one side of that '$op' $at\n" . $hereptr);

2072

}

2072

}

2073

if ($ctx =~ /Wx[BE]/ ||

2073

if ($ctx =~ /Wx[BE]/ ||

2074

($ctx =~ /Wx./ && $cc =~ /^;/)) {

2074

($ctx =~ /Wx./ && $cc =~ /^;/)) {

2075

ERROR("space prohibited before that '$op' $at\n" . $hereptr);

2075

ERROR("space prohibited before that '$op' $at\n" . $hereptr);

2076

}

2076

}

2077

if ($ctx =~ /ExW/) {

2077

if ($ctx =~ /ExW/) {

2078

ERROR("space prohibited after that '$op' $at\n" . $hereptr);

2078

ERROR("space prohibited after that '$op' $at\n" . $hereptr);

2079

}

2079

}

2080

2081

2082

# << and >> may either have or not have spaces both sides

2082

# << and >> may either have or not have spaces both sides

2083

} elsif ($op eq '<<' or $op eq '>>' or

2083

} elsif ($op eq '<<' or $op eq '>>' or

2084

$op eq '&' or $op eq '^' or $op eq '|' or

2084

$op eq '&' or $op eq '^' or $op eq '|' or

2085

$op eq '+' or $op eq '-' or

2085

$op eq '+' or $op eq '-' or

2086

$op eq '*' or $op eq '/' or

2086

$op eq '*' or $op eq '/' or

2087

$op eq '%')

2087

$op eq '%')

2088

{

2088

{

2089

if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {

2089

if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {

2090

ERROR("need consistent spacing around '$op' $at\n" .

2090

ERROR("need consistent spacing around '$op' $at\n" .

2091

$hereptr);

2091

$hereptr);

2092

}

2092

}

2093

2094

# A colon needs no spaces before when it is

2094

# A colon needs no spaces before when it is

2095

# terminating a case value or a label.

2095

# terminating a case value or a label.

2096

} elsif ($opv eq ':C' || $opv eq ':L') {

2096

} elsif ($opv eq ':C' || $opv eq ':L') {

2097

if ($ctx =~ /Wx./) {

2097

if ($ctx =~ /Wx./) {

2098

ERROR("space prohibited before that '$op' $at\n" . $hereptr);

2098

ERROR("space prohibited before that '$op' $at\n" . $hereptr);

2099

}

2099

}

2100

2101

# All the others need spaces both sides.

2101

# All the others need spaces both sides.

2102

} elsif ($ctx !~ /[EWC]x[CWE]/) {

2102

} elsif ($ctx !~ /[EWC]x[CWE]/) {

2103

my $ok = 0;

2103

my $ok = 0;

2104

2105

# Ignore email addresses <foo@bar>

2105

# Ignore email addresses <foo@bar>

2106

if (($op eq '<' &&

2106

if (($op eq '<' &&

2107

$cc =~ /^\S+\@\S+>/) ||

2107

$cc =~ /^\S+\@\S+>/) ||

2108

($op eq '>' &&

2108

($op eq '>' &&

2109

$ca =~ /<\S+\@\S+$/))

2109

$ca =~ /<\S+\@\S+$/))

2110

{

2110

{

2111

$ok = 1;

2111

$ok = 1;

2112

}

2112

}

2113

2114

# Ignore ?:

2114

# Ignore ?:

2115

if (($opv eq ':O' && $ca =~ /\?$/) ||

2115

if (($opv eq ':O' && $ca =~ /\?$/) ||

2116

($op eq '?' && $cc =~ /^:/)) {

2116

($op eq '?' && $cc =~ /^:/)) {

2117

$ok = 1;

2117

$ok = 1;

2118

}

2118

}

2119

2120

if ($ok == 0) {

2120

if ($ok == 0) {

2121

ERROR("spaces required around that '$op' $at\n" . $hereptr);

2121

ERROR("spaces required around that '$op' $at\n" . $hereptr);

2122

}

2122

}

2123

}

2123

}

2124

$off += length($elements[$n + 1]);

2124

$off += length($elements[$n + 1]);

2125

}

2125

}

2126

}

2126

}

2127

2128

# check for multiple assignments

2128

# check for multiple assignments

2129

if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {

2129

if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {

2130

CHK("multiple assignments should be avoided\n" . $herecurr);

2130

CHK("multiple assignments should be avoided\n" . $herecurr);

2131

}

2131

}

2132

2133

## # check for multiple declarations, allowing for a function declaration

2133

## # check for multiple declarations, allowing for a function declaration

2134

## # continuation.

2134

## # continuation.

2135

## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&

2135

## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&

2136

## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {

2136

## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {

2137

##

2137

##

2138

## # Remove any bracketed sections to ensure we do not

2138

## # Remove any bracketed sections to ensure we do not

2139

## # falsly report the parameters of functions.

2139

## # falsly report the parameters of functions.

2140

## my $ln = $line;

2140

## my $ln = $line;

2141

## while ($ln =~ s/$[^\($]*\)//g) {

2141

## while ($ln =~ s/$[^\($]*\)//g) {

2142

## }

2142

## }

2143

## if ($ln =~ /,/) {

2143

## if ($ln =~ /,/) {

2144

## WARN("declaring multiple variables together should be avoided\n" . $herecurr);

2144

## WARN("declaring multiple variables together should be avoided\n" . $herecurr);

2145

## }

2145

## }

2146

## }

2146

## }

2147

2148

#need space before brace following if, while, etc

2148

#need space before brace following if, while, etc

2149

if (($line =~ /$.*${/ && $line !~ /$$Type${/) ||

2149

if (($line =~ /$.*${/ && $line !~ /$$Type${/) ||

2150

$line =~ /do{/) {

2150

$line =~ /do{/) {

2151

ERROR("space required before the open brace '{'\n" . $herecurr);

2151

ERROR("space required before the open brace '{'\n" . $herecurr);

2152

}

2152

}

2153

2154

# closing brace should have a space following it when it has anything

2154

# closing brace should have a space following it when it has anything

2155

# on the line

2155

# on the line

2156

if ($line =~ /}(?!(?:,|;|\)))\S/) {

2156

if ($line =~ /}(?!(?:,|;|\)))\S/) {

2157

ERROR("space required after that close brace '}'\n" . $herecurr);

2157

ERROR("space required after that close brace '}'\n" . $herecurr);

2158

}

2158

}

2159

2160

# check spacing on square brackets

2160

# check spacing on square brackets

2161

if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {

2161

if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {

2162

ERROR("space prohibited after that open square bracket '['\n" . $herecurr);

2162

ERROR("space prohibited after that open square bracket '['\n" . $herecurr);

2163

}

2163

}

2164

if ($line =~ /\s\]/) {

2164

if ($line =~ /\s\]/) {

2165

ERROR("space prohibited before that close square bracket ']'\n" . $herecurr);

2165

ERROR("space prohibited before that close square bracket ']'\n" . $herecurr);

2166

}

2166

}

2167

2168

# check spacing on parentheses

2168

# check spacing on parentheses

2169

if ($line =~ /$\s/ && $line !~ /\(\s*(?:\$?$/ &&

2169

if ($line =~ /$\s/ && $line !~ /\(\s*(?:\$?$/ &&

2170

$line !~ /for\s*\(\s+;/) {

2170

$line !~ /for\s*\(\s+;/) {

2171

ERROR("space prohibited after that open parenthesis '('\n" . $herecurr);

2171

ERROR("space prohibited after that open parenthesis '('\n" . $herecurr);

2172

}

2172

}

2173

if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&

2173

if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&

2174

$line !~ /for\s*$.*;\s+$/ &&

2174

$line !~ /for\s*$.*;\s+$/ &&

2175

$line !~ /:\s+\)/) {

2175

$line !~ /:\s+\)/) {

2176

ERROR("space prohibited before that close parenthesis ')'\n" . $herecurr);

2176

ERROR("space prohibited before that close parenthesis ')'\n" . $herecurr);

2177

}

2177

}

2178

2179

#goto labels aren't indented, allow a single space however

2179

#goto labels aren't indented, allow a single space however

2180

if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and

2180

if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and

2181

!($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {

2181

!($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {

2182

WARN("labels should not be indented\n" . $herecurr);

2182

WARN("labels should not be indented\n" . $herecurr);

2183

}

2183

}

2184

2185

# Return is not a function.

2185

# Return is not a function.

2186

if (defined($stat) && $stat =~ /^.\s*return(\s*)(\(.*);/s) {

2186

if (defined($stat) && $stat =~ /^.\s*return(\s*)(\(.*);/s) {

2187

my $spacing = $1;

2187

my $spacing = $1;

2188

my $value = $2;

2188

my $value = $2;

2189

2190

# Flatten any parentheses

2190

# Flatten any parentheses

2191

$value =~ s/\(/ \(/g;

2191

$value =~ s/\(/ \(/g;

2192

$value =~ s/\)/\) /g;

2192

$value =~ s/\)/\) /g;

2193

while ($value =~ s/\[[^\{\}]*\]/1/ ||

2193

while ($value =~ s/\[[^\{\}]*\]/1/ ||

2194

$value !~ /(?:$Ident|-?$Constant)\s*

2194

$value !~ /(?:$Ident|-?$Constant)\s*

2195

$Compare\s*

2195

$Compare\s*

2196

(?:$Ident|-?$Constant)/x &&

2196

(?:$Ident|-?$Constant)/x &&

2197

$value =~ s/$[^\($]*\)/1/) {

2197

$value =~ s/$[^\($]*\)/1/) {

2198

}

2198

}

2199

#print "value<$value>\n";

2199

#print "value<$value>\n";

2200

if ($value =~ /^\s*(?:$Ident|-?$Constant)\s*$/) {

2200

if ($value =~ /^\s*(?:$Ident|-?$Constant)\s*$/) {

2201

ERROR("return is not a function, parentheses are not required\n" . $herecurr);

2201

ERROR("return is not a function, parentheses are not required\n" . $herecurr);

2202

2203

} elsif ($spacing !~ /\s+/) {

2203

} elsif ($spacing !~ /\s+/) {

2204

ERROR("space required before the open parenthesis '('\n" . $herecurr);

2204

ERROR("space required before the open parenthesis '('\n" . $herecurr);

2205

}

2205

}

2206

}

2206

}

2207

# Return of what appears to be an errno should normally be -'ve

2208

if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {

2209

my $name = $1;

2210

if ($name ne 'EOF' && $name ne 'ERROR') {

2211

WARN("return of an errno should typically be -ve (return -$1)\n" . $herecurr);

2212

}

2213

}

2207

2214

2208

# Need a space before open parenthesis after if, while etc

2215

# Need a space before open parenthesis after if, while etc

2209

if ($line=~/\b(if|while|for|switch)\(/) {

2216

if ($line=~/\b(if|while|for|switch)\(/) {

2210

ERROR("space required before the open parenthesis '('\n" . $herecurr);

2217

ERROR("space required before the open parenthesis '('\n" . $herecurr);

2211

}

2218

}

2212

2219

2213

# Check for illegal assignment in if conditional -- and check for trailing

2220

# Check for illegal assignment in if conditional -- and check for trailing

2214

# statements after the conditional.

2221

# statements after the conditional.

2215

if ($line =~ /do\s*(?!{)/) {

2222

if ($line =~ /do\s*(?!{)/) {

2216

my ($stat_next) = ctx_statement_block($line_nr_next,

2223

my ($stat_next) = ctx_statement_block($line_nr_next,

2217

$remain_next, $off_next);

2224

$remain_next, $off_next);

2218

$stat_next =~ s/\n./\n /g;

2225

$stat_next =~ s/\n./\n /g;

2219

##print "stat<$stat> stat_next<$stat_next>\n";

2226

##print "stat<$stat> stat_next<$stat_next>\n";

2220

2227

2221

if ($stat_next =~ /^\s*while\b/) {

2228

if ($stat_next =~ /^\s*while\b/) {

2222

# If the statement carries leading newlines,

2229

# If the statement carries leading newlines,

2223

# then count those as offsets.

2230

# then count those as offsets.

2224

my ($whitespace) =

2231

my ($whitespace) =

2225

($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);

2232

($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);

2226

my $offset =

2233

my $offset =

2227

statement_rawlines($whitespace) - 1;

2234

statement_rawlines($whitespace) - 1;

2228

2235

2229

$suppress_whiletrailers{$line_nr_next +

2236

$suppress_whiletrailers{$line_nr_next +

2230

$offset} = 1;

2237

$offset} = 1;

2231

}

2238

}

2232

}

2239

}

2233

if (!defined $suppress_whiletrailers{$linenr} &&

2240

if (!defined $suppress_whiletrailers{$linenr} &&

2234

$line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {

2241

$line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {

2235

my ($s, $c) = ($stat, $cond);

2242

my ($s, $c) = ($stat, $cond);

2236

2243

2237

if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {

2244

if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {

2238

ERROR("do not use assignment in if condition\n" . $herecurr);

2245

ERROR("do not use assignment in if condition\n" . $herecurr);

2239

}

2246

}

2240

2247

2241

# Find out what is on the end of the line after the

2248

# Find out what is on the end of the line after the

2242

# conditional.

2249

# conditional.

2243

substr($s, 0, length($c), '');

2250

substr($s, 0, length($c), '');

2244

$s =~ s/\n.*//g;

2251

$s =~ s/\n.*//g;

2245

$s =~ s/$;//g; # Remove any comments

2252

$s =~ s/$;//g; # Remove any comments

2246

if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&

2253

if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&

2247

$c !~ /}\s*while\s*/)

2254

$c !~ /}\s*while\s*/)

2248

{

2255

{

2249

# Find out how long the conditional actually is.

2256

# Find out how long the conditional actually is.

2250

my @newlines = ($c =~ /\n/gs);

2257

my @newlines = ($c =~ /\n/gs);

2251

my $cond_lines = 1 + $#newlines;

2258

my $cond_lines = 1 + $#newlines;

2252

my $stat_real = '';

2259

my $stat_real = '';

2253

2260

2254

$stat_real = raw_line($linenr, $cond_lines)

2261

$stat_real = raw_line($linenr, $cond_lines)

2255

. "\n" if ($cond_lines);

2262

. "\n" if ($cond_lines);

2256

if (defined($stat_real) && $cond_lines > 1) {

2263

if (defined($stat_real) && $cond_lines > 1) {

2257

$stat_real = "[...]\n$stat_real";

2264

$stat_real = "[...]\n$stat_real";

2258

}

2265

}

2259

2266

2260

ERROR("trailing statements should be on next line\n" . $herecurr . $stat_real);

2267

ERROR("trailing statements should be on next line\n" . $herecurr . $stat_real);

2261

}

2268

}

2262

}

2269

}

2263

2270

2264

# Check for bitwise tests written as boolean

2271

# Check for bitwise tests written as boolean

2265

if ($line =~ /

2272

if ($line =~ /

2266

(?:

2273

(?:

2267

(?:\[|\(|\&\&|\|\|)

2274

(?:\[|\(|\&\&|\|\|)

2268

\s*0[xX][0-9]+\s*

2275

\s*0[xX][0-9]+\s*

2269

(?:\&\&|\|\|)

2276

(?:\&\&|\|\|)

2270

|

2277

|

2271

(?:\&\&|\|\|)

2278

(?:\&\&|\|\|)

2272

\s*0[xX][0-9]+\s*

2279

\s*0[xX][0-9]+\s*

2273

(?:\&\&|\|\||\)|\])

2280

(?:\&\&|\|\||\)|\])

2274

)/x)

2281

)/x)

2275

{

2282

{

2276

WARN("boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);

2283

WARN("boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);

2277

}

2284

}

2278

2285

2279

# if and else should not have general statements after it

2286

# if and else should not have general statements after it

2280

if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {

2287

if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {

2281

my $s = $1;

2288

my $s = $1;

2282

$s =~ s/$;//g; # Remove any comments

2289

$s =~ s/$;//g; # Remove any comments

2283

if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {

2290

if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {

2284

ERROR("trailing statements should be on next line\n" . $herecurr);

2291

ERROR("trailing statements should be on next line\n" . $herecurr);

2285

}

2292

}

2286

}

2293

}

2287

# if should not continue a brace

2294

# if should not continue a brace

2288

if ($line =~ /}\s*if\b/) {

2295

if ($line =~ /}\s*if\b/) {

2289

ERROR("trailing statements should be on next line\n" .

2296

ERROR("trailing statements should be on next line\n" .

2290

$herecurr);

2297

$herecurr);

2291

}

2298

}

2292

# case and default should not have general statements after them

2299

# case and default should not have general statements after them

2293

if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&

2300

if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&

2294

$line !~ /\G(?:

2301

$line !~ /\G(?:

2295

(?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|

2302

(?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|

2296

\s*return\s+

2303

\s*return\s+

2297

)/xg)

2304

)/xg)

2298

{

2305

{

2299

ERROR("trailing statements should be on next line\n" . $herecurr);

2306

ERROR("trailing statements should be on next line\n" . $herecurr);

2300

}

2307

}

2301

2308

2302

# Check for }<nl>else {, these must be at the same

2309

# Check for }<nl>else {, these must be at the same

2303

# indent level to be relevant to each other.

2310

# indent level to be relevant to each other.

2304

if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and

2311

if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and

2305

$previndent == $indent) {

2312

$previndent == $indent) {

2306

ERROR("else should follow close brace '}'\n" . $hereprev);

2313

ERROR("else should follow close brace '}'\n" . $hereprev);

2307

}

2314

}

2308

2315

2309

if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and

2316

if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and

2310

$previndent == $indent) {

2317

$previndent == $indent) {

2311

my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);

2318

my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);

2312

2319

2313

# Find out what is on the end of the line after the

2320

# Find out what is on the end of the line after the

2314

# conditional.

2321

# conditional.

2315

substr($s, 0, length($c), '');

2322

substr($s, 0, length($c), '');

2316

$s =~ s/\n.*//g;

2323

$s =~ s/\n.*//g;

2317

2324

2318

if ($s =~ /^\s*;/) {

2325

if ($s =~ /^\s*;/) {

2319

ERROR("while should follow close brace '}'\n" . $hereprev);

2326

ERROR("while should follow close brace '}'\n" . $hereprev);

2320

}

2327

}

2321

}

2328

}

2322

2329

2323

#studly caps, commented out until figure out how to distinguish between use of existing and adding new

2330

#studly caps, commented out until figure out how to distinguish between use of existing and adding new

2324

# if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {

2331

# if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {

2325

# print "No studly caps, use _\n";

2332

# print "No studly caps, use _\n";

2326

# print "$herecurr";

2333

# print "$herecurr";

2327

# $clean = 0;

2334

# $clean = 0;

2328

# }

2335

# }

2329

2336

2330

#no spaces allowed after \ in define

2337

#no spaces allowed after \ in define

2331

if ($line=~/\#\s*define.*\\\s$/) {

2338

if ($line=~/\#\s*define.*\\\s$/) {

2332

WARN("Whitepspace after \\ makes next lines useless\n" . $herecurr);

2339

WARN("Whitepspace after \\ makes next lines useless\n" . $herecurr);

2333

}

2340

}

2334

2341

2335

#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)

2342

#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)

2336

if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {

2343

if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {

2337

my $file = "$1.h";

2344

my $file = "$1.h";

2338

my $checkfile = "include/linux/$file";

2345

my $checkfile = "include/linux/$file";

2339

if (-f "$root/$checkfile" &&

2346

if (-f "$root/$checkfile" &&

2340

$realfile ne $checkfile &&

2347

$realfile ne $checkfile &&

2341

$1 !~ /$allowed_asm_includes/)

2348

$1 !~ /$allowed_asm_includes/)

2342

{

2349

{

2343

if ($realfile =~ m{^arch/}) {

2350

if ($realfile =~ m{^arch/}) {

2344

CHK("Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);

2351

CHK("Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);

2345

} else {

2352

} else {

2346

WARN("Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);

2353

WARN("Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);

2347

}

2354

}

2348

}

2355

}

2349

}

2356

}

2350

2357

2351

# multi-statement macros should be enclosed in a do while loop, grab the

2358

# multi-statement macros should be enclosed in a do while loop, grab the

2352

# first statement and ensure its the whole macro if its not enclosed

2359

# first statement and ensure its the whole macro if its not enclosed

2353

# in a known good container

2360

# in a known good container

2354

if ($realfile !~ m@/vmlinux.lds.h$@ &&

2361

if ($realfile !~ m@/vmlinux.lds.h$@ &&

2355

$line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {

2362

$line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {

2356

my $ln = $linenr;

2363

my $ln = $linenr;

2357

my $cnt = $realcnt;

2364

my $cnt = $realcnt;

2358

my ($off, $dstat, $dcond, $rest);

2365

my ($off, $dstat, $dcond, $rest);

2359

my $ctx = '';

2366

my $ctx = '';

2360

2367

2361

my $args = defined($1);

2368

my $args = defined($1);

2362

2369

2363

# Find the end of the macro and limit our statement

2370

# Find the end of the macro and limit our statement

2364

# search to that.

2371

# search to that.

2365

while ($cnt > 0 && defined $lines[$ln - 1] &&

2372

while ($cnt > 0 && defined $lines[$ln - 1] &&

2366

$lines[$ln - 1] =~ /^(?:-|..*\\$)/)

2373

$lines[$ln - 1] =~ /^(?:-|..*\\$)/)

2367

{

2374

{

2368

$ctx .= $rawlines[$ln - 1] . "\n";

2375

$ctx .= $rawlines[$ln - 1] . "\n";

2369

$cnt-- if ($lines[$ln - 1] !~ /^-/);

2376

$cnt-- if ($lines[$ln - 1] !~ /^-/);

2370

$ln++;

2377

$ln++;

2371

}

2378

}

2372

$ctx .= $rawlines[$ln - 1];

2379

$ctx .= $rawlines[$ln - 1];

2373

2380

2374

($dstat, $dcond, $ln, $cnt, $off) =

2381

($dstat, $dcond, $ln, $cnt, $off) =

2375

ctx_statement_block($linenr, $ln - $linenr + 1, 0);

2382

ctx_statement_block($linenr, $ln - $linenr + 1, 0);

2376

#print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";

2383

#print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";

2377

#print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";

2384

#print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";

2378

2385

2379

# Extract the remainder of the define (if any) and

2386

# Extract the remainder of the define (if any) and

2380

# rip off surrounding spaces, and trailing \'s.

2387

# rip off surrounding spaces, and trailing \'s.

2381

$rest = '';

2388

$rest = '';

2382

while ($off != 0 || ($cnt > 0 && $rest =~ /\\\s*$/)) {

2389

while ($off != 0 || ($cnt > 0 && $rest =~ /\\\s*$/)) {

2383

#print "ADDING cnt<$cnt> $off <" . substr($lines[$ln - 1], $off) . "> rest<$rest>\n";

2390

#print "ADDING cnt<$cnt> $off <" . substr($lines[$ln - 1], $off) . "> rest<$rest>\n";

2384

if ($off != 0 || $lines[$ln - 1] !~ /^-/) {

2391

if ($off != 0 || $lines[$ln - 1] !~ /^-/) {

2385

$rest .= substr($lines[$ln - 1], $off) . "\n";

2392

$rest .= substr($lines[$ln - 1], $off) . "\n";

2386

$cnt--;

2393

$cnt--;

2387

}

2394

}

2388

$ln++;

2395

$ln++;

2389

$off = 0;

2396

$off = 0;

2390

}

2397

}

2391

$rest =~ s/\\\n.//g;

2398

$rest =~ s/\\\n.//g;

2392

$rest =~ s/^\s*//s;

2399

$rest =~ s/^\s*//s;

2393

$rest =~ s/\s*$//s;

2400

$rest =~ s/\s*$//s;

2394

2401

2395

# Clean up the original statement.

2402

# Clean up the original statement.

2396

if ($args) {

2403

if ($args) {

2397

substr($dstat, 0, length($dcond), '');

2404

substr($dstat, 0, length($dcond), '');

2398

} else {

2405

} else {

2399

$dstat =~ s/^.\s*\#\s*define\s+$Ident\s*//;

2406

$dstat =~ s/^.\s*\#\s*define\s+$Ident\s*//;

2400

}

2407

}

2401

$dstat =~ s/$;//g;

2408

$dstat =~ s/$;//g;

2402

$dstat =~ s/\\\n.//g;

2409

$dstat =~ s/\\\n.//g;

2403

$dstat =~ s/^\s*//s;

2410

$dstat =~ s/^\s*//s;

2404

$dstat =~ s/\s*$//s;

2411

$dstat =~ s/\s*$//s;

2405

2412

2406

# Flatten any parentheses and braces

2413

# Flatten any parentheses and braces

2407

while ($dstat =~ s/$[^\($]*\)/1/ ||

2414

while ($dstat =~ s/$[^\($]*\)/1/ ||

2408

$dstat =~ s/\{[^\{\}]*\}/1/ ||

2415

$dstat =~ s/\{[^\{\}]*\}/1/ ||

2409

$dstat =~ s/\[[^\{\}]*\]/1/)

2416

$dstat =~ s/\[[^\{\}]*\]/1/)

2410

{

2417

{

2411

}

2418

}

2412

2419

2413

my $exceptions = qr{

2420

my $exceptions = qr{

2414

$Declare|

2421

$Declare|

2415

module_param_named|

2422

module_param_named|

2416

MODULE_PARAM_DESC|

2423

MODULE_PARAM_DESC|

2417

DECLARE_PER_CPU|

2424

DECLARE_PER_CPU|

2418

DEFINE_PER_CPU|

2425

DEFINE_PER_CPU|

2419

__typeof__\(|

2426

__typeof__\(|

2420

union|

2427

union|

2421

struct|

2428

struct|

2422

\.$Ident\s*=\s*|

2429

\.$Ident\s*=\s*|

2423

^\"|\"$

2430

^\"|\"$

2424

}x;

2431

}x;

2425

#print "REST<$rest> dstat<$dstat>\n";

2432

#print "REST<$rest> dstat<$dstat>\n";

2426

if ($rest ne '') {

2433

if ($rest ne '') {

2427

if ($rest !~ /while\s*\(/ &&

2434

if ($rest !~ /while\s*\(/ &&

2428

$dstat !~ /$exceptions/)

2435

$dstat !~ /$exceptions/)

2429

{

2436

{

2430

ERROR("Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");

2437

ERROR("Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");

2431

}

2438

}

2432

2439

2433

} elsif ($ctx !~ /;/) {

2440

} elsif ($ctx !~ /;/) {

2434

if ($dstat ne '' &&

2441

if ($dstat ne '' &&

2435

$dstat !~ /^(?:$Ident|-?$Constant)$/ &&

2442

$dstat !~ /^(?:$Ident|-?$Constant)$/ &&

2436

$dstat !~ /$exceptions/ &&

2443

$dstat !~ /$exceptions/ &&

2437

$dstat !~ /^\.$Ident\s*=/ &&

2444

$dstat !~ /^\.$Ident\s*=/ &&

2438

$dstat =~ /$Operators/)

2445

$dstat =~ /$Operators/)

2439

{

2446

{

2440

ERROR("Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");

2447

ERROR("Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");

2441

}

2448

}

2442

}

2449

}

2443

}

2450

}

2444

2451

2445

# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...

2452

# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...

2446

# all assignments may have only one of the following with an assignment:

2453

# all assignments may have only one of the following with an assignment:

2447

# .

2454

# .

2448

# ALIGN(...)

2455

# ALIGN(...)

2449

# VMLINUX_SYMBOL(...)

2456

# VMLINUX_SYMBOL(...)

2450

if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {

2457

if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {

2451

WARN("vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);

2458

WARN("vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);

2452

}

2459

}

2453

2460

2454

# check for redundant bracing round if etc

2461

# check for redundant bracing round if etc

2455

if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {

2462

if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {

2456

my ($level, $endln, @chunks) =

2463

my ($level, $endln, @chunks) =

2457

ctx_statement_full($linenr, $realcnt, 1);

2464

ctx_statement_full($linenr, $realcnt, 1);

2458

#print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";

2465

#print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";

2459

#print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";

2466

#print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";

2460

if ($#chunks > 0 && $level == 0) {

2467

if ($#chunks > 0 && $level == 0) {

2461

my $allowed = 0;

2468

my $allowed = 0;

2462

my $seen = 0;

2469

my $seen = 0;

2463

my $herectx = $here . "\n";

2470

my $herectx = $here . "\n";

2464

my $ln = $linenr - 1;

2471

my $ln = $linenr - 1;

2465

for my $chunk (@chunks) {

2472

for my $chunk (@chunks) {

2466

my ($cond, $block) = @{$chunk};

2473

my ($cond, $block) = @{$chunk};

2467

2474

2468

# If the condition carries leading newlines, then count those as offsets.

2475

# If the condition carries leading newlines, then count those as offsets.

2469

my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);

2476

my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);

2470

my $offset = statement_rawlines($whitespace) - 1;

2477

my $offset = statement_rawlines($whitespace) - 1;

2471

2478

2472

#print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";

2479

#print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";

2473

2480

2474

# We have looked at and allowed this specific line.

2481

# We have looked at and allowed this specific line.

2475

$suppress_ifbraces{$ln + $offset} = 1;

2482

$suppress_ifbraces{$ln + $offset} = 1;

2476

2483

2477

$herectx .= "$rawlines[$ln + $offset]\n[...]\n";

2484

$herectx .= "$rawlines[$ln + $offset]\n[...]\n";

2478

$ln += statement_rawlines($block) - 1;

2485

$ln += statement_rawlines($block) - 1;

2479

2486

2480

substr($block, 0, length($cond), '');

2487

substr($block, 0, length($cond), '');

2481

2488

2482

$seen++ if ($block =~ /^\s*{/);

2489

$seen++ if ($block =~ /^\s*{/);

2483

2490

2484

#print "cond<$cond> block<$block> allowed<$allowed>\n";

2491

#print "cond<$cond> block<$block> allowed<$allowed>\n";

2485

if (statement_lines($cond) > 1) {

2492

if (statement_lines($cond) > 1) {

2486

#print "APW: ALLOWED: cond<$cond>\n";

2493

#print "APW: ALLOWED: cond<$cond>\n";

2487

$allowed = 1;

2494

$allowed = 1;

2488

}

2495

}

2489

if ($block =~/\b(?:if|for|while)\b/) {

2496

if ($block =~/\b(?:if|for|while)\b/) {

2490

#print "APW: ALLOWED: block<$block>\n";

2497

#print "APW: ALLOWED: block<$block>\n";

2491

$allowed = 1;

2498

$allowed = 1;

2492

}

2499

}

2493

if (statement_block_size($block) > 1) {

2500

if (statement_block_size($block) > 1) {

2494

#print "APW: ALLOWED: lines block<$block>\n";

2501

#print "APW: ALLOWED: lines block<$block>\n";

2495

$allowed = 1;

2502

$allowed = 1;

2496

}

2503

}

2497

}

2504

}

2498

if ($seen && !$allowed) {

2505

if ($seen && !$allowed) {

2499

WARN("braces {} are not necessary for any arm of this statement\n" . $herectx);

2506

WARN("braces {} are not necessary for any arm of this statement\n" . $herectx);

2500

}

2507

}

2501

}

2508

}

2502

}

2509

}

2503

if (!defined $suppress_ifbraces{$linenr - 1} &&

2510

if (!defined $suppress_ifbraces{$linenr - 1} &&

2504

$line =~ /\b(if|while|for|else)\b/) {

2511

$line =~ /\b(if|while|for|else)\b/) {

2505

my $allowed = 0;

2512

my $allowed = 0;

2506

2513

2507

# Check the pre-context.

2514

# Check the pre-context.

2508

if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {

2515

if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {

2509

#print "APW: ALLOWED: pre<$1>\n";

2516

#print "APW: ALLOWED: pre<$1>\n";

2510

$allowed = 1;

2517

$allowed = 1;

2511

}

2518

}

2512

2519

2513

my ($level, $endln, @chunks) =

2520

my ($level, $endln, @chunks) =

2514

ctx_statement_full($linenr, $realcnt, $-[0]);

2521

ctx_statement_full($linenr, $realcnt, $-[0]);

2515

2522

2516

# Check the condition.

2523

# Check the condition.

2517

my ($cond, $block) = @{$chunks[0]};

2524

my ($cond, $block) = @{$chunks[0]};

2518

#print "CHECKING<$linenr> cond<$cond> block<$block>\n";

2525

#print "CHECKING<$linenr> cond<$cond> block<$block>\n";

2519

if (defined $cond) {

2526

if (defined $cond) {

2520

substr($block, 0, length($cond), '');

2527

substr($block, 0, length($cond), '');

2521

}

2528

}

2522

if (statement_lines($cond) > 1) {

2529

if (statement_lines($cond) > 1) {

2523

#print "APW: ALLOWED: cond<$cond>\n";

2530

#print "APW: ALLOWED: cond<$cond>\n";

2524

$allowed = 1;

2531

$allowed = 1;

2525

}

2532

}

2526

if ($block =~/\b(?:if|for|while)\b/) {

2533

if ($block =~/\b(?:if|for|while)\b/) {

2527

#print "APW: ALLOWED: block<$block>\n";

2534

#print "APW: ALLOWED: block<$block>\n";

2528

$allowed = 1;

2535

$allowed = 1;

2529

}

2536

}

2530

if (statement_block_size($block) > 1) {

2537

if (statement_block_size($block) > 1) {

2531

#print "APW: ALLOWED: lines block<$block>\n";

2538

#print "APW: ALLOWED: lines block<$block>\n";

2532

$allowed = 1;

2539

$allowed = 1;

2533

}

2540

}

2534

# Check the post-context.

2541

# Check the post-context.

2535

if (defined $chunks[1]) {

2542

if (defined $chunks[1]) {

2536

my ($cond, $block) = @{$chunks[1]};

2543

my ($cond, $block) = @{$chunks[1]};

2537

if (defined $cond) {

2544

if (defined $cond) {

2538

substr($block, 0, length($cond), '');

2545

substr($block, 0, length($cond), '');

2539

}

2546

}

2540

if ($block =~ /^\s*\{/) {

2547

if ($block =~ /^\s*\{/) {

2541

#print "APW: ALLOWED: chunk-1 block<$block>\n";

2548

#print "APW: ALLOWED: chunk-1 block<$block>\n";

2542

$allowed = 1;

2549

$allowed = 1;

2543

}

2550

}

2544

}

2551

}

2545

if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {

2552

if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {

2546

my $herectx = $here . "\n";;

2553

my $herectx = $here . "\n";;

2547

my $cnt = statement_rawlines($block);

2554

my $cnt = statement_rawlines($block);

2548

2555

2549

for (my $n = 0; $n < $cnt; $n++) {

2556

for (my $n = 0; $n < $cnt; $n++) {

2550

$herectx .= raw_line($linenr, $n) . "\n";;

2557

$herectx .= raw_line($linenr, $n) . "\n";;

2551

}

2558

}

2552

2559

2553

WARN("braces {} are not necessary for single statement blocks\n" . $herectx);

2560

WARN("braces {} are not necessary for single statement blocks\n" . $herectx);

2554

}

2561

}

2555

}

2562

}

2556

2563

2557

# don't include deprecated include files (uses RAW line)

2564

# don't include deprecated include files (uses RAW line)

2558

for my $inc (@dep_includes) {

2565

for my $inc (@dep_includes) {

2559

if ($rawline =~ m@^.\s*\#\s*include\s*\<$inc>@) {

2566

if ($rawline =~ m@^.\s*\#\s*include\s*\<$inc>@) {

2560

ERROR("Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr);

2567

ERROR("Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr);

2561

}

2568

}

2562

}

2569

}

2563

2570

2564

# don't use deprecated functions

2571

# don't use deprecated functions

2565

for my $func (@dep_functions) {

2572

for my $func (@dep_functions) {

2566

if ($line =~ /\b$func\b/) {

2573

if ($line =~ /\b$func\b/) {

2567

ERROR("Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr);

2574

ERROR("Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr);

2568

}

2575

}

2569

}

2576

}

2570

2577

2571

# no volatiles please

2578

# no volatiles please

2572

my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};

2579

my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};

2573

if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {

2580

if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {

2574

WARN("Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);

2581

WARN("Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);

2575

}

2582

}

2576

2583

2577

# SPIN_LOCK_UNLOCKED & RW_LOCK_UNLOCKED are deprecated

2584

# SPIN_LOCK_UNLOCKED & RW_LOCK_UNLOCKED are deprecated

2578

if ($line =~ /\b(SPIN_LOCK_UNLOCKED|RW_LOCK_UNLOCKED)/) {

2585

if ($line =~ /\b(SPIN_LOCK_UNLOCKED|RW_LOCK_UNLOCKED)/) {

2579

ERROR("Use of $1 is deprecated: see Documentation/spinlocks.txt\n" . $herecurr);

2586

ERROR("Use of $1 is deprecated: see Documentation/spinlocks.txt\n" . $herecurr);

2580

}

2587

}

2581

2588

2582

# warn about #if 0

2589

# warn about #if 0

2583

if ($line =~ /^.\s*\#\s*if\s+0\b/) {

2590

if ($line =~ /^.\s*\#\s*if\s+0\b/) {

2584

CHK("if this code is redundant consider removing it\n" .

2591

CHK("if this code is redundant consider removing it\n" .

2585

$herecurr);

2592

$herecurr);

2586

}

2593

}

2587

2594

2588

# check for needless kfree() checks

2595

# check for needless kfree() checks

2589

if ($prevline =~ /\bif\s*$([^$]*)\)/) {

2596

if ($prevline =~ /\bif\s*$([^$]*)\)/) {

2590

my $expr = $1;

2597

my $expr = $1;

2591

if ($line =~ /\bkfree$\Q$expr\E$;/) {

2598

if ($line =~ /\bkfree$\Q$expr\E$;/) {

2592

WARN("kfree(NULL) is safe this check is probably not required\n" . $hereprev);

2599

WARN("kfree(NULL) is safe this check is probably not required\n" . $hereprev);

2593

}

2600

}

2594

}

2601

}

2595

# check for needless usb_free_urb() checks

2602

# check for needless usb_free_urb() checks

2596

if ($prevline =~ /\bif\s*$([^$]*)\)/) {

2603

if ($prevline =~ /\bif\s*$([^$]*)\)/) {

2597

my $expr = $1;

2604

my $expr = $1;

2598

if ($line =~ /\busb_free_urb$\Q$expr\E$;/) {

2605

if ($line =~ /\busb_free_urb$\Q$expr\E$;/) {

2599

WARN("usb_free_urb(NULL) is safe this check is probably not required\n" . $hereprev);

2606

WARN("usb_free_urb(NULL) is safe this check is probably not required\n" . $hereprev);

2600

}

2607

}

2601

}

2608

}

2602

2609

2603

# prefer usleep_range over udelay

2610

# prefer usleep_range over udelay

2604

if ($line =~ /\budelay\s*$\s*(\w+)\s*$/) {

2611

if ($line =~ /\budelay\s*$\s*(\w+)\s*$/) {

2605

# ignore udelay's < 10, however

2612

# ignore udelay's < 10, however

2606

if (! (($1 =~ /(\d+)/) && ($1 < 10)) ) {

2613

if (! (($1 =~ /(\d+)/) && ($1 < 10)) ) {

2607

CHK("usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $line);

2614

CHK("usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $line);

2608

}

2615

}

2609

}

2616

}

2610

2617

2611

# warn about unexpectedly long msleep's

2618

# warn about unexpectedly long msleep's

2612

if ($line =~ /\bmsleep\s*$(\d+)$;/) {

2619

if ($line =~ /\bmsleep\s*$(\d+)$;/) {

2613

if ($1 < 20) {

2620

if ($1 < 20) {

2614

WARN("msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);

2621

WARN("msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);

2615

}

2622

}

2616

}

2623

}

2617

2624

2618

# warn about #ifdefs in C files

2625

# warn about #ifdefs in C files

2619

# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {

2626

# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {

2620

# print "#ifdef in C files should be avoided\n";

2627

# print "#ifdef in C files should be avoided\n";

2621

# print "$herecurr";

2628

# print "$herecurr";

2622

# $clean = 0;

2629

# $clean = 0;

2623

# }

2630

# }

2624

2631

2625

# warn about spacing in #ifdefs

2632

# warn about spacing in #ifdefs

2626

if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {

2633

if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {

2627

ERROR("exactly one space required after that #$1\n" . $herecurr);

2634

ERROR("exactly one space required after that #$1\n" . $herecurr);

2628

}

2635

}

2629

2636

2630

# check for spinlock_t definitions without a comment.

2637

# check for spinlock_t definitions without a comment.

2631

if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||

2638

if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||

2632

$line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {

2639

$line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {

2633

my $which = $1;

2640

my $which = $1;

2634

if (!ctx_has_comment($first_line, $linenr)) {

2641

if (!ctx_has_comment($first_line, $linenr)) {

2635

CHK("$1 definition without comment\n" . $herecurr);

2642

CHK("$1 definition without comment\n" . $herecurr);

2636

}

2643

}

2637

}

2644

}

2638

# check for memory barriers without a comment.

2645

# check for memory barriers without a comment.

2639

if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {

2646

if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {

2640

if (!ctx_has_comment($first_line, $linenr)) {

2647

if (!ctx_has_comment($first_line, $linenr)) {

2641

CHK("memory barrier without comment\n" . $herecurr);

2648

CHK("memory barrier without comment\n" . $herecurr);

2642

}

2649

}

2643

}

2650

}

2644

# check of hardware specific defines

2651

# check of hardware specific defines

2645

if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {

2652

if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {

2646

CHK("architecture specific defines should be avoided\n" . $herecurr);

2653

CHK("architecture specific defines should be avoided\n" . $herecurr);

2647

}

2654

}

2648

2655

2649

# Check that the storage class is at the beginning of a declaration

2656

# Check that the storage class is at the beginning of a declaration

2650

if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {

2657

if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {

2651

WARN("storage class should be at the beginning of the declaration\n" . $herecurr)

2658

WARN("storage class should be at the beginning of the declaration\n" . $herecurr)

2652

}

2659

}

2653

2660

2654

# check the location of the inline attribute, that it is between

2661

# check the location of the inline attribute, that it is between

2655

# storage class and type.

2662

# storage class and type.

2656

if ($line =~ /\b$Type\s+$Inline\b/ ||

2663

if ($line =~ /\b$Type\s+$Inline\b/ ||

2657

$line =~ /\b$Inline\s+$Storage\b/) {

2664

$line =~ /\b$Inline\s+$Storage\b/) {

2658

ERROR("inline keyword should sit between storage class and type\n" . $herecurr);

2665

ERROR("inline keyword should sit between storage class and type\n" . $herecurr);

2659

}

2666

}

2660

2667

2661

# Check for __inline__ and __inline, prefer inline

2668

# Check for __inline__ and __inline, prefer inline

2662

if ($line =~ /\b(__inline__|__inline)\b/) {

2669

if ($line =~ /\b(__inline__|__inline)\b/) {

2663

WARN("plain inline is preferred over $1\n" . $herecurr);

2670

WARN("plain inline is preferred over $1\n" . $herecurr);

2664

}

2671

}

2665

2672

2666

# check for sizeof(&)

2673

# check for sizeof(&)

2667

if ($line =~ /\bsizeof\s*\(\s*\&/) {

2674

if ($line =~ /\bsizeof\s*\(\s*\&/) {

2668

WARN("sizeof(& should be avoided\n" . $herecurr);

2675

WARN("sizeof(& should be avoided\n" . $herecurr);

2669

}

2676

}

2670

2677

2671

# check for new externs in .c files.

2678

# check for new externs in .c files.

2672

if ($realfile =~ /\.c$/ && defined $stat &&

2679

if ($realfile =~ /\.c$/ && defined $stat &&

2673

$stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)

2680

$stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)

2674

{

2681

{

2675

my $function_name = $1;

2682

my $function_name = $1;

2676

my $paren_space = $2;

2683

my $paren_space = $2;

2677

2684

2678

my $s = $stat;

2685

my $s = $stat;

2679

if (defined $cond) {

2686

if (defined $cond) {

2680

substr($s, 0, length($cond), '');

2687

substr($s, 0, length($cond), '');

2681

}

2688

}

2682

if ($s =~ /^\s*;/ &&

2689

if ($s =~ /^\s*;/ &&

2683

$function_name ne 'uninitialized_var')

2690

$function_name ne 'uninitialized_var')

2684

{

2691

{

2685

WARN("externs should be avoided in .c files\n" . $herecurr);

2692

WARN("externs should be avoided in .c files\n" . $herecurr);

2686

}

2693

}

2687

2694

2688

if ($paren_space =~ /\n/) {

2695

if ($paren_space =~ /\n/) {

2689

WARN("arguments for function declarations should follow identifier\n" . $herecurr);

2696

WARN("arguments for function declarations should follow identifier\n" . $herecurr);

2690

}

2697

}

2691

2698

2692

} elsif ($realfile =~ /\.c$/ && defined $stat &&

2699

} elsif ($realfile =~ /\.c$/ && defined $stat &&

2693

$stat =~ /^.\s*extern\s+/)

2700

$stat =~ /^.\s*extern\s+/)

2694

{

2701

{

2695

WARN("externs should be avoided in .c files\n" . $herecurr);

2702

WARN("externs should be avoided in .c files\n" . $herecurr);

2696

}

2703

}

2697

2704

2698

# checks for new __setup's

2705

# checks for new __setup's

2699

if ($rawline =~ /\b__setup\("([^"]*)"/) {

2706

if ($rawline =~ /\b__setup\("([^"]*)"/) {

2700

my $name = $1;

2707

my $name = $1;

2701

2708

2702

if (!grep(/$name/, @setup_docs)) {

2709

if (!grep(/$name/, @setup_docs)) {

2703

CHK("__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);

2710

CHK("__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);

2704

}

2711

}

2705

}

2712

}

2706

2713

2707

# check for pointless casting of kmalloc return

2714

# check for pointless casting of kmalloc return

2708

if ($line =~ /\*\s*\)\s*k[czm]alloc\b/) {

2715

if ($line =~ /\*\s*\)\s*k[czm]alloc\b/) {

2709

WARN("unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);

2716

WARN("unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);

2710

}

2717

}

2711

2718

2712

# check for gcc specific __FUNCTION__

2719

# check for gcc specific __FUNCTION__

2713

if ($line =~ /__FUNCTION__/) {

2720

if ($line =~ /__FUNCTION__/) {

2714

WARN("__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr);

2721

WARN("__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr);

2715

}

2722

}

2716

2723

2717

# check for semaphores used as mutexes

2724

# check for semaphores used as mutexes

2718

if ($line =~ /^.\s*(DECLARE_MUTEX|init_MUTEX)\s*\(/) {

2725

if ($line =~ /^.\s*(DECLARE_MUTEX|init_MUTEX)\s*\(/) {

2719

WARN("mutexes are preferred for single holder semaphores\n" . $herecurr);

2726

WARN("mutexes are preferred for single holder semaphores\n" . $herecurr);

2720

}

2727

}

2721

# check for semaphores used as mutexes

2728

# check for semaphores used as mutexes

2722

if ($line =~ /^.\s*init_MUTEX_LOCKED\s*\(/) {

2729

if ($line =~ /^.\s*init_MUTEX_LOCKED\s*\(/) {

2723

WARN("consider using a completion\n" . $herecurr);

2730

WARN("consider using a completion\n" . $herecurr);

2724

2731

2725

}

2732

}

2726

# recommend strict_strto* over simple_strto*

2733

# recommend strict_strto* over simple_strto*

2727

if ($line =~ /\bsimple_(strto.*?)\s*\(/) {

2734

if ($line =~ /\bsimple_(strto.*?)\s*\(/) {

2728

WARN("consider using strict_$1 in preference to simple_$1\n" . $herecurr);

2735

WARN("consider using strict_$1 in preference to simple_$1\n" . $herecurr);

2729

}

2736

}

2730

# check for __initcall(), use device_initcall() explicitly please

2737

# check for __initcall(), use device_initcall() explicitly please

2731

if ($line =~ /^.\s*__initcall\s*\(/) {

2738

if ($line =~ /^.\s*__initcall\s*\(/) {

2732

WARN("please use device_initcall() instead of __initcall()\n" . $herecurr);

2739

WARN("please use device_initcall() instead of __initcall()\n" . $herecurr);

2733

}

2740

}

2734

# check for various ops structs, ensure they are const.

2741

# check for various ops structs, ensure they are const.

2735

my $struct_ops = qr{acpi_dock_ops|

2742

my $struct_ops = qr{acpi_dock_ops|

2736

address_space_operations|

2743

address_space_operations|

2737

backlight_ops|

2744

backlight_ops|

2738

block_device_operations|

2745

block_device_operations|

2739

dentry_operations|

2746

dentry_operations|

2740

dev_pm_ops|

2747

dev_pm_ops|

2741

dma_map_ops|

2748

dma_map_ops|

2742

extent_io_ops|

2749

extent_io_ops|

2743

file_lock_operations|

2750

file_lock_operations|

2744

file_operations|

2751

file_operations|

2745

hv_ops|

2752

hv_ops|

2746

ide_dma_ops|

2753

ide_dma_ops|

2747

intel_dvo_dev_ops|

2754

intel_dvo_dev_ops|

2748

item_operations|

2755

item_operations|

2749

iwl_ops|

2756

iwl_ops|

2750

kgdb_arch|

2757

kgdb_arch|

2751

kgdb_io|

2758

kgdb_io|

2752

kset_uevent_ops|

2759

kset_uevent_ops|

2753

lock_manager_operations|

2760

lock_manager_operations|

2754

microcode_ops|

2761

microcode_ops|

2755

mtrr_ops|

2762

mtrr_ops|

2756

neigh_ops|

2763

neigh_ops|

2757

nlmsvc_binding|

2764

nlmsvc_binding|

2758

pci_raw_ops|

2765

pci_raw_ops|

2759

pipe_buf_operations|

2766

pipe_buf_operations|

2760

platform_hibernation_ops|

2767

platform_hibernation_ops|

2761

platform_suspend_ops|

2768

platform_suspend_ops|

2762

proto_ops|

2769

proto_ops|

2763

rpc_pipe_ops|

2770

rpc_pipe_ops|

2764

seq_operations|

2771

seq_operations|

2765

snd_ac97_build_ops|

2772

snd_ac97_build_ops|

2766

soc_pcmcia_socket_ops|

2773

soc_pcmcia_socket_ops|

2767

stacktrace_ops|

2774

stacktrace_ops|

2768

sysfs_ops|

2775

sysfs_ops|

2769

tty_operations|

2776

tty_operations|

2770

usb_mon_operations|

2777

usb_mon_operations|

2771

wd_ops}x;

2778

wd_ops}x;

2772

if ($line !~ /\bconst\b/ &&

2779

if ($line !~ /\bconst\b/ &&

2773

$line =~ /\bstruct\s+($struct_ops)\b/) {

2780

$line =~ /\bstruct\s+($struct_ops)\b/) {

2774

WARN("struct $1 should normally be const\n" .

2781

WARN("struct $1 should normally be const\n" .

2775

$herecurr);

2782

$herecurr);

2776

}

2783

}

2777

2784

2778

# use of NR_CPUS is usually wrong

2785

# use of NR_CPUS is usually wrong

2779

# ignore definitions of NR_CPUS and usage to define arrays as likely right

2786

# ignore definitions of NR_CPUS and usage to define arrays as likely right

2780

if ($line =~ /\bNR_CPUS\b/ &&

2787

if ($line =~ /\bNR_CPUS\b/ &&

2781

$line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&

2788

$line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&

2782

$line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&

2789

$line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&

2783

$line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&

2790

$line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&

2784

$line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&

2791

$line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&

2785

$line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)

2792

$line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)

2786

{

2793

{

2787

WARN("usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);

2794

WARN("usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);

2788

}

2795

}

2789

2796

2790

# check for %L{u,d,i} in strings

2797

# check for %L{u,d,i} in strings

2791

my $string;

2798

my $string;

2792

while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {

2799

while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {

2793

$string = substr($rawline, $-[1], $+[1] - $-[1]);

2800

$string = substr($rawline, $-[1], $+[1] - $-[1]);

2794

$string =~ s/%%/__/g;

2801

$string =~ s/%%/__/g;

2795

if ($string =~ /(?<!%)%L[udi]/) {

2802

if ($string =~ /(?<!%)%L[udi]/) {

2796

WARN("\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);

2803

WARN("\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);

2797

last;

2804

last;

2798

}

2805

}

2799

}

2806

}

2800

2807

2801

# whine mightly about in_atomic

2808

# whine mightly about in_atomic

2802

if ($line =~ /\bin_atomic\s*\(/) {

2809

if ($line =~ /\bin_atomic\s*\(/) {

2803

if ($realfile =~ m@^drivers/@) {

2810

if ($realfile =~ m@^drivers/@) {

2804

ERROR("do not use in_atomic in drivers\n" . $herecurr);

2811

ERROR("do not use in_atomic in drivers\n" . $herecurr);

2805

} elsif ($realfile !~ m@^kernel/@) {

2812

} elsif ($realfile !~ m@^kernel/@) {

2806

WARN("use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);

2813

WARN("use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);

2807

}

2814

}

2808

}

2815

}

2809

2816

2810

# check for lockdep_set_novalidate_class

2817

# check for lockdep_set_novalidate_class

2811

if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||

2818

if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||

2812

$line =~ /__lockdep_no_validate__\s*\)/ ) {

2819

$line =~ /__lockdep_no_validate__\s*\)/ ) {

2813

if ($realfile !~ m@^kernel/lockdep@ &&

2820

if ($realfile !~ m@^kernel/lockdep@ &&

2814

$realfile !~ m@^include/linux/lockdep@ &&

2821

$realfile !~ m@^include/linux/lockdep@ &&

2815

$realfile !~ m@^drivers/base/core@) {

2822

$realfile !~ m@^drivers/base/core@) {

2816

ERROR("lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);

2823

ERROR("lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);

2817

}

2824

}

2818

}

2825

}

2819

}

2826

}

2820

2827

2821

# If we have no input at all, then there is nothing to report on

2828

# If we have no input at all, then there is nothing to report on

2822

# so just keep quiet.

2829

# so just keep quiet.

2823

if ($#rawlines == -1) {

2830

if ($#rawlines == -1) {

2824

exit(0);

2831

exit(0);

2825

}

2832

}

2826

2833

2827

# In mailback mode only produce a report in the negative, for

2834

# In mailback mode only produce a report in the negative, for

2828

# things that appear to be patches.

2835

# things that appear to be patches.

2829

if ($mailback && ($clean == 1 || !$is_patch)) {

2836

if ($mailback && ($clean == 1 || !$is_patch)) {

2830

exit(0);

2837

exit(0);

2831

}

2838

}

2832

2839

2833

# This is not a patch, and we are are in 'no-patch' mode so

2840

# This is not a patch, and we are are in 'no-patch' mode so

2834

# just keep quiet.

2841

# just keep quiet.

2835

if (!$chk_patch && !$is_patch) {

2842

if (!$chk_patch && !$is_patch) {

2836

exit(0);

2843

exit(0);

2837

}

2844

}

2838

2845

2839

if (!$is_patch) {

2846

if (!$is_patch) {

2840

ERROR("Does not appear to be a unified-diff format patch\n");

2847

ERROR("Does not appear to be a unified-diff format patch\n");

2841

}

2848

}

2842

if ($is_patch && $chk_signoff && $signoff == 0) {

2849

if ($is_patch && $chk_signoff && $signoff == 0) {

2843

ERROR("Missing Signed-off-by: line(s)\n");

2850

ERROR("Missing Signed-off-by: line(s)\n");

2844

}

2851

}

2845

2852

2846

print report_dump();

2853

print report_dump();

2847

if ($summary && !($clean == 1 && $quiet == 1)) {

2854

if ($summary && !($clean == 1 && $quiet == 1)) {

2848

print "$filename " if ($summary_file);

2855

print "$filename " if ($summary_file);

2849

print "total: $cnt_error errors, $cnt_warn warnings, " .

2856

print "total: $cnt_error errors, $cnt_warn warnings, " .

2850

(($check)? "$cnt_chk checks, " : "") .

2857

(($check)? "$cnt_chk checks, " : "") .

2851

"$cnt_lines lines checked\n";

2858

"$cnt_lines lines checked\n";

2852

print "\n" if ($quiet == 0);

2859

print "\n" if ($quiet == 0);

2853

}

2860

}

2854

2861

2855

if ($quiet == 0) {

2862

if ($quiet == 0) {

2856

# If there were whitespace errors which cleanpatch can fix

2863

# If there were whitespace errors which cleanpatch can fix

2857

# then suggest that.

2864

# then suggest that.

2858

if ($rpt_cleaners) {

2865

if ($rpt_cleaners) {

2859

print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";

2866

print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";

2860

print " scripts/cleanfile\n\n";

2867

print " scripts/cleanfile\n\n";

2861

}

2868

}

2862

}

2869

}

2863

2870

2864

if ($clean == 1 && $quiet == 0) {

2871

if ($clean == 1 && $quiet == 0) {

2865

print "$vname has no obvious style problems and is ready for submission.\n"

2872

print "$vname has no obvious style problems and is ready for submission.\n"

2866

}

2873

}

2867

if ($clean == 0 && $quiet == 0) {

2874

if ($clean == 0 && $quiet == 0) {

2868

print "$vname has style problems, please review. If any of these errors\n";

2875

print "$vname has style problems, please review. If any of these errors\n";

2869

print "are false positives report them to the maintainer, see\n";

2876

print "are false positives report them to the maintainer, see\n";

2870

print "CHECKPATCH in MAINTAINERS.\n";

2877

print "CHECKPATCH in MAINTAINERS.\n";

2871

}

2878

}

2872

2879

2873

return $clean;

2880

return $clean;

2874

}

2881

}

2875

2882

GITLAB

checkpatch: returning errno typically should be negative

 #!/usr/bin/perl -w
 # (c) 2001, Dave Jones. (the file handling bit)
 # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
 # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
 # (c) 2008,2009, Andy Whitcroft <apw@canonical.com>
 # Licensed under the terms of the GNU GPL License version 2
 use strict;
 my $P = $0;
 $P =~ s@.*/@@g;
 my $V = '0.30';
 use Getopt::Long qw(:config no_auto_abbrev);
 my $quiet = 0;
 my $tree = 1;
 my $chk_signoff = 1;
 my $chk_patch = 1;
 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 $root;
 my %debug;
 my $help = 0;
 sub help {
 	my ($exitcode) = @_;
 	print << "EOM";
 Usage: $P [OPTION]... [FILE]...
 Version: $V
 Options:
   -q, --quiet                quiet
   --no-tree                  run without a kernel tree
   --no-signoff               do not check for 'Signed-off-by' line
   --patch                    treat FILE as patchfile (default)
   --emacs                    emacs compile window format
   --terse                    one line per report
   -f, --file                 treat FILE as regular source file
   --subjective, --strict     enable more subjective tests
   --root=PATH                PATH to the kernel tree root
   --no-summary               suppress the per-file summary
   --mailback                 only produce a report in case of warnings/errors
   --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
                              is all off)
   --test-only=WORD           report only warnings/errors containing WORD
                              literally
   -h, --help, --version      display this help and exit
 When FILE is - read standard input.
 EOM
 	exit($exitcode);
 }
 GetOptions(
 	'q|quiet+'	=> \$quiet,
 	'tree!'		=> \$tree,
 	'signoff!'	=> \$chk_signoff,
 	'patch!'	=> \$chk_patch,
 	'emacs!'	=> \$emacs,
 	'terse!'	=> \$terse,
 	'f|file!'	=> \$file,
 	'subjective!'	=> \$check,
 	'strict!'	=> \$check,
 	'root=s'	=> \$root,
 	'summary!'	=> \$summary,
 	'mailback!'	=> \$mailback,
 	'summary-file!'	=> \$summary_file,
 	'debug=s'	=> \%debug,
 	'test-only=s'	=> \$tst_only,
 	'h|help'	=> \$help,
 	'version'	=> \$help
 ) or help(1);
 help(0) if ($help);
 my $exit = 0;
 if ($#ARGV < 0) {
 	print "$P: no input files\n";
 	exit(1);
 }
 my $dbg_values = 0;
 my $dbg_possible = 0;
 my $dbg_type = 0;
 my $dbg_attr = 0;
 for my $key (keys %debug) {
 	## no critic
 	eval "\${dbg_$key} = '$debug{$key}';";
 	die "$@" if ($@);
 }
 my $rpt_cleaners = 0;
 if ($terse) {
 	$emacs = 1;
 	$quiet++;
 }
 if ($tree) {
 	if (defined $root) {
 		if (!top_of_kernel_tree($root)) {
 			die "$P: $root: --root does not point at a valid tree\n";
 		}
 	} else {
 		if (top_of_kernel_tree('.')) {
 			$root = '.';
 		} elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
 						top_of_kernel_tree($1)) {
 			$root = $1;
 		}
 	}
 	if (!defined $root) {
 		print "Must be run from the top-level dir. of a kernel tree\n";
 		exit(2);
 	}
 }
 my $emitted_corrupt = 0;
 our $Ident	= qr{
 			[A-Za-z_][A-Za-z\d_]*
 			(?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
 		}x;
 our $Storage	= qr{extern|static|asmlinkage};
 our $Sparse	= qr{
 			__user|
 			__kernel|
 			__force|
 			__iomem|
 			__must_check|
 			__init_refok|
 			__kprobes|
 			__ref
 		}x;
 # Notes to $Attribute:
 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
 our $Attribute	= qr{
 			const|
 			__read_mostly|
 			__kprobes|
 			__(?:mem|cpu|dev|)(?:initdata|initconst|init\b)|
 			____cacheline_aligned|
 			____cacheline_aligned_in_smp|
 			____cacheline_internodealigned_in_smp|
 			__weak
 		  }x;
 our $Modifier;
 our $Inline	= qr{inline|__always_inline|noinline};
 our $Member	= qr{->$Ident|\.$Ident|\[[^]]*\]};
 our $Lval	= qr{$Ident(?:$Member)*};
 our $Constant	= qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*};
 our $Assignment	= qr{(?:\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=)};
 our $Compare    = qr{<=|>=|==|!=|<|>};
 our $Operators	= qr{
 			<=|>=|==|!=|
 			=>|->|<<|>>|<|>|!|~|
 			&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
 		  }x;
 our $NonptrType;
 our $Type;
 our $Declare;
 our $UTF8	= qr {
 	[\x09\x0A\x0D\x20-\x7E]              # ASCII
 	| [\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
 }x;
 our $typeTypedefs = qr{(?x:
 	(?:__)?(?:u|s|be|le)(?:8|16|32|64)|
 	atomic_t
 )};
 our $logFunctions = qr{(?x:
 	printk|
 	pr_(debug|dbg|vdbg|devel|info|warning|err|notice|alert|crit|emerg|cont)|
 	(dev|netdev|netif)_(printk|dbg|vdbg|info|warn|err|notice|alert|crit|emerg|WARN)|
 	WARN|
 	panic
 )};
 our @typeList = (
 	qr{void},
 	qr{(?:unsigned\s+)?char},
 	qr{(?:unsigned\s+)?short},
 	qr{(?:unsigned\s+)?int},
 	qr{(?:unsigned\s+)?long},
 	qr{(?:unsigned\s+)?long\s+int},
 	qr{(?:unsigned\s+)?long\s+long},
 	qr{(?:unsigned\s+)?long\s+long\s+int},
 	qr{unsigned},
 	qr{float},
 	qr{double},
 	qr{bool},
 	qr{struct\s+$Ident},
 	qr{union\s+$Ident},
 	qr{enum\s+$Ident},
 	qr{${Ident}_t},
 	qr{${Ident}_handler},
 	qr{${Ident}_handler_fn},
 );
 our @modifierList = (
 	qr{fastcall},
 );
 our $allowed_asm_includes = qr{(?x:
 	irq|
 	memory
 )};
 # memory.h: ARM has a custom one
 sub build_types {
 	my $mods = "(?x:  \n" . join("|\n  ", @modifierList) . "\n)";
 	my $all = "(?x:  \n" . join("|\n  ", @typeList) . "\n)";
 	$Modifier	= qr{(?:$Attribute|$Sparse|$mods)};
 	$NonptrType	= qr{
 			(?:$Modifier\s+|const\s+)*
 			(?:
 				(?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)|
 				(?:$typeTypedefs\b)|
 				(?:${all}\b)
 			)
 			(?:\s+$Modifier|\s+const)*
 		  }x;
 	$Type	= qr{
 			$NonptrType
 			(?:[\s\*]+\s*const|[\s\*]+|(?:\s*\[\s*\])+)?
 			(?:\s+$Inline|\s+$Modifier)*
 		  }x;
 	$Declare	= qr{(?:$Storage\s+)?$Type};
 }
 build_types();
 $chk_signoff = 0 if ($file);
 my @dep_includes = ();
 my @dep_functions = ();
 my $removal = "Documentation/feature-removal-schedule.txt";
 if ($tree && -f "$root/$removal") {
 	open(my $REMOVE, '<', "$root/$removal") ||
 				die "$P: $removal: open failed - $!\n";
 	while (<$REMOVE>) {
 		if (/^Check:\s+(.*\S)/) {
 			for my $entry (split(/[, ]+/, $1)) {
 				if ($entry =~ m@include/(.*)@) {
 					push(@dep_includes, $1);
 				} elsif ($entry !~ m@/@) {
 					push(@dep_functions, $entry);
 				}
 			}
 		}
 	}
 	close($REMOVE);
 }
 my @rawlines = ();
 my @lines = ();
 my $vname;
 for my $filename (@ARGV) {
 	my $FILE;
 	if ($file) {
 		open($FILE, '-|', "diff -u /dev/null $filename") ||
 			die "$P: $filename: diff failed - $!\n";
 	} elsif ($filename eq '-') {
 		open($FILE, '<&STDIN');
 	} else {
 		open($FILE, '<', "$filename") ||
 			die "$P: $filename: open failed - $!\n";
 	}
 	if ($filename eq '-') {
 		$vname = 'Your patch';
 	} else {
 		$vname = $filename;
 	}
 	while (<$FILE>) {
 		chomp;
 		push(@rawlines, $_);
 	}
 	close($FILE);
 	if (!process($filename)) {
 		$exit = 1;
 	}
 	@rawlines = ();
 	@lines = ();
 }
 exit($exit);
 sub top_of_kernel_tree {
 	my ($root) = @_;
 	my @tree_check = (
 		"COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
 		"README", "Documentation", "arch", "include", "drivers",
 		"fs", "init", "ipc", "kernel", "lib", "scripts",
 	);
 	foreach my $check (@tree_check) {
 		if (! -e $root . '/' . $check) {
 			return 0;
 		}
 	}
 	return 1;
 }
 sub expand_tabs {
 	my ($str) = @_;
 	my $res = '';
 	my $n = 0;
 	for my $c (split(//, $str)) {
 		if ($c eq "\t") {
 			$res .= ' ';
 			$n++;
 			for (; ($n % 8) != 0; $n++) {
 				$res .= ' ';
 			}
 			next;
 		}
 		$res .= $c;
 		$n++;
 	}
 	return $res;
 }
 sub copy_spacing {
 	(my $res = shift) =~ tr/\t/ /c;
 	return $res;
 }
 sub line_stats {
 	my ($line) = @_;
 	# Drop the diff line leader and expand tabs
 	$line =~ s/^.//;
 	$line = expand_tabs($line);
 	# Pick the indent from the front of the line.
 	my ($white) = ($line =~ /^(\s*)/);
 	return (length($line), length($white));
 }
 my $sanitise_quote = '';
 sub sanitise_line_reset {
 	my ($in_comment) = @_;
 	if ($in_comment) {
 		$sanitise_quote = '*/';
 	} else {
 		$sanitise_quote = '';
 	}
 }
 sub sanitise_line {
 	my ($line) = @_;
 	my $res = '';
 	my $l = '';
 	my $qlen = 0;
 	my $off = 0;
 	my $c;
 	# Always copy over the diff marker.
 	$res = substr($line, 0, 1);
 	for ($off = 1; $off < length($line); $off++) {
 		$c = substr($line, $off, 1);
 		# Comments we are wacking completly including the begin
 		# and end, all to $;.
 		if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
 			$sanitise_quote = '*/';
 			substr($res, $off, 2, "$;$;");
 			$off++;
 			next;
 		}
 		if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
 			$sanitise_quote = '';
 			substr($res, $off, 2, "$;$;");
 			$off++;
 			next;
 		}
 		if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
 			$sanitise_quote = '//';
 			substr($res, $off, 2, $sanitise_quote);
 			$off++;
 			next;
 		}
 		# A \ in a string means ignore the next character.
 		if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
 		    $c eq "\\") {
 			substr($res, $off, 2, 'XX');
 			$off++;
 			next;
 		}
 		# Regular quotes.
 		if ($c eq "'" || $c eq '"') {
 			if ($sanitise_quote eq '') {
 				$sanitise_quote = $c;
 				substr($res, $off, 1, $c);
 				next;
 			} elsif ($sanitise_quote eq $c) {
 				$sanitise_quote = '';
 			}
 		}
 		#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');
 		} else {
 			substr($res, $off, 1, $c);
 		}
 	}
 	if ($sanitise_quote eq '//') {
 		$sanitise_quote = '';
 	}
 	# 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>@;
 	# 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@;
 	}
 	return $res;
 }
 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;
 	my $loff = 0;
 	my $type = '';
 	my $level = 0;
 	my @stack = ();
 	my $p;
 	my $c;
 	my $len = 0;
 	my $remainder;
 	while (1) {
 		@stack = (['', 0]) if ($#stack == -1);
 		#warn "CSB: blk<$blk> remain<$remain>\n";
 		# If we are about to drop off the end, pull in more
 		# context.
 		if ($off >= $len) {
 			for (; $remain > 0; $line++) {
 				last if (!defined $lines[$line]);
 				next if ($lines[$line] =~ /^-/);
 				$remain--;
 				$loff = $len;
 				$blk .= $lines[$line] . "\n";
 				$len = length($blk);
 				$line++;
 				last;
 			}
 			# Bail if there is no further context.
 			#warn "CSB: blk<$blk> off<$off> len<$len>\n";
 			if ($off >= $len) {
 				last;
 			}
 		}
 		$p = $c;
 		$c = substr($blk, $off, 1);
 		$remainder = substr($blk, $off);
 		#warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
 		# 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)};
 		}
 		# Statement ends at the ';' or a close '}' at the
 		# outermost level.
 		if ($level == 0 && $c eq ';') {
 			last;
 		}
 		# An else is really a conditional as long as its not else if
 		if ($level == 0 && $coff_set == 0 &&
 				(!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
 				$remainder =~ /^(else)(?:\s|{)/ &&
 				$remainder !~ /^else\s+if\b/) {
 			$coff = $off + length($1) - 1;
 			$coff_set = 1;
 			#warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
 			#warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
 		}
 		if (($type eq '' || $type eq '(') && $c eq '(') {
 			$level++;
 			$type = '(';
 		}
 		if ($type eq '(' && $c eq ')') {
 			$level--;
 			$type = ($level != 0)? '(' : '';
 			if ($level == 0 && $coff < $soff) {
 				$coff = $off;
 				$coff_set = 1;
 				#warn "CSB: mark coff<$coff>\n";
 			}
 		}
 		if (($type eq '' || $type eq '{') && $c eq '{') {
 			$level++;
 			$type = '{';
 		}
 		if ($type eq '{' && $c eq '}') {
 			$level--;
 			$type = ($level != 0)? '{' : '';
 			if ($level == 0) {
 				if (substr($blk, $off + 1, 1) eq ';') {
 					$off++;
 				}
 				last;
 			}
 		}
 		$off++;
 	}
 	# We are truly at the end, so shuffle to the next line.
 	if ($off == $len) {
 		$loff = $len + 1;
 		$line++;
 		$remain--;
 	}
 	my $statement = substr($blk, $soff, $off - $soff + 1);
 	my $condition = substr($blk, $soff, $coff - $soff + 1);
 	#warn "STATEMENT<$statement>\n";
 	#warn "CONDITION<$condition>\n";
 	#print "coff<$coff> soff<$off> loff<$loff>\n";
 	return ($statement, $condition,
 			$line, $remain + 1, $off - $loff + 1, $level);
 }
 sub statement_lines {
 	my ($stmt) = @_;
 	# Strip the diff line prefixes and rip blank lines at start and end.
 	$stmt =~ s/(^|\n)./$1/g;
 	$stmt =~ s/^\s*//;
 	$stmt =~ s/\s*$//;
 	my @stmt_lines = ($stmt =~ /\n/g);
 	return $#stmt_lines + 2;
 }
 sub statement_rawlines {
 	my ($stmt) = @_;
 	my @stmt_lines = ($stmt =~ /\n/g);
 	return $#stmt_lines + 2;
 }
 sub statement_block_size {
 	my ($stmt) = @_;
 	$stmt =~ s/(^|\n)./$1/g;
 	$stmt =~ s/^\s*{//;
 	$stmt =~ s/}\s*$//;
 	$stmt =~ s/^\s*//;
 	$stmt =~ s/\s*$//;
 	my @stmt_lines = ($stmt =~ /\n/g);
 	my @stmt_statements = ($stmt =~ /;/g);
 	my $stmt_lines = $#stmt_lines + 2;
 	my $stmt_statements = $#stmt_statements + 1;
 	if ($stmt_lines > $stmt_statements) {
 		return $stmt_lines;
 	} else {
 		return $stmt_statements;
 	}
 }
 sub ctx_statement_full {
 	my ($linenr, $remain, $off) = @_;
 	my ($statement, $condition, $level);
 	my (@chunks);
 	# Grab the first conditional/block pair.
 	($statement, $condition, $linenr, $remain, $off, $level) =
 				ctx_statement_block($linenr, $remain, $off);
 	#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)) {
 		return ($level, $linenr, @chunks);
 	}
 	# Pull in the following conditional/block pairs and see if they
 	# could continue the statement.
 	for (;;) {
 		($statement, $condition, $linenr, $remain, $off, $level) =
 				ctx_statement_block($linenr, $remain, $off);
 		#print "C: c<$condition> s<$statement> remain<$remain>\n";
 		last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
 		#print "C: push\n";
 		push(@chunks, [ $condition, $statement ]);
 	}
 	return ($level, $linenr, @chunks);
 }
 sub ctx_block_get {
 	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
 	my $line;
 	my $start = $linenr - 1;
 	my $blk = '';
 	my @o;
 	my @c;
 	my @res = ();
 	my $level = 0;
 	my @stack = ($level);
 	for ($line = $start; $remain > 0; $line++) {
 		next if ($rawlines[$line] =~ /^-/);
 		$remain--;
 		$blk .= $rawlines[$line];
 		# Handle nested #if/#else.
 		if ($rawlines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
 			push(@stack, $level);
 		} elsif ($rawlines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
 			$level = $stack[$#stack - 1];
 		} elsif ($rawlines[$line] =~ /^.\s*#\s*endif\b/) {
 			$level = pop(@stack);
 		}
 		foreach my $c (split(//, $rawlines[$line])) {
 			##print "C<$c>L<$level><$open$close>O<$off>\n";
 			if ($off > 0) {
 				$off--;
 				next;
 			}
 			if ($c eq $close && $level > 0) {
 				$level--;
 				last if ($level == 0);
 			} elsif ($c eq $open) {
 				$level++;
 			}
 		}
 		if (!$outer || $level <= 1) {
 			push(@res, $rawlines[$line]);
 		}
 		last if ($level == 0);
 	}
 	return ($level, @res);
 }
 sub ctx_block_outer {
 	my ($linenr, $remain) = @_;
 	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
 	return @r;
 }
 sub ctx_block {
 	my ($linenr, $remain) = @_;
 	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
 	return @r;
 }
 sub ctx_statement {
 	my ($linenr, $remain, $off) = @_;
 	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
 	return @r;
 }
 sub ctx_block_level {
 	my ($linenr, $remain) = @_;
 	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
 }
 sub ctx_statement_level {
 	my ($linenr, $remain, $off) = @_;
 	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
 }
 sub ctx_locate_comment {
 	my ($first_line, $end_line) = @_;
 	# 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);
 	# Look through the context and try and figure out if there is a
 	# comment.
 	my $in_comment = 0;
 	$current_comment = '';
 	for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
 		my $line = $rawlines[$linenr - 1];
 		#warn "           $line\n";
 		if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
 			$in_comment = 1;
 		}
 		if ($line =~ m@/\*@) {
 			$in_comment = 1;
 		}
 		if (!$in_comment && $current_comment ne '') {
 			$current_comment = '';
 		}
 		$current_comment .= $line . "\n" if ($in_comment);
 		if ($line =~ m@\*/@) {
 			$in_comment = 0;
 		}
 	}
 	chomp($current_comment);
 	return($current_comment);
 }
 sub ctx_has_comment {
 	my ($first_line, $end_line) = @_;
 	my $cmt = ctx_locate_comment($first_line, $end_line);
 	##print "LINE: $rawlines[$end_line - 1 ]\n";
 	##print "CMMT: $cmt\n";
 	return ($cmt ne '');
 }
 sub raw_line {
 	my ($linenr, $cnt) = @_;
 	my $offset = $linenr - 1;
 	$cnt++;
 	my $line;
 	while ($cnt) {
 		$line = $rawlines[$offset++];
 		next if (defined($line) && $line =~ /^-/);
 		$cnt--;
 	}
 	return $line;
 }
 sub cat_vet {
 	my ($vet) = @_;
 	my ($res, $coded);
 	$res = '';
 	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
 		$res .= $1;
 		if ($2 ne '') {
 			$coded = sprintf("^%c", unpack('C', $2) + 64);
 			$res .= $coded;
 		}
 	}
 	$res =~ s/$/\$/;
 	return $res;
 }
 my $av_preprocessor = 0;
 my $av_pending;
 my @av_paren_type;
 my $av_pend_colon;
 sub annotate_reset {
 	$av_preprocessor = 0;
 	$av_pending = '_';
 	@av_paren_type = ('E');
 	$av_pend_colon = 'O';
 }
 sub annotate_values {
 	my ($stream, $type) = @_;
 	my $res;
 	my $var = '_' x length($stream);
 	my $cur = $stream;
 	print "$stream\n" if ($dbg_values > 1);
 	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);
 				$av_preprocessor = 0;
 			}
 		} elsif ($cur =~ /^(\(\s*$Type\s*)\)/) {
 			print "CAST($1)\n" if ($dbg_values > 1);
 			push(@av_paren_type, $type);
 			$type = 'C';
 		} elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
 			print "DECLARE($1)\n" if ($dbg_values > 1);
 			$type = 'T';
 		} elsif ($cur =~ /^($Modifier)\s*/) {
 			print "MODIFIER($1)\n" if ($dbg_values > 1);
 			$type = 'T';
 		} elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
 			print "DEFINE($1,$2)\n" if ($dbg_values > 1);
 			$av_preprocessor = 1;
 			push(@av_paren_type, $type);
 			if ($2 ne '') {
 				$av_pending = 'N';
 			}
 			$type = 'E';
 		} elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
 			print "UNDEF($1)\n" if ($dbg_values > 1);
 			$av_preprocessor = 1;
 			push(@av_paren_type, $type);
 		} elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
 			print "PRE_START($1)\n" if ($dbg_values > 1);
 			$av_preprocessor = 1;
 			push(@av_paren_type, $type);
 			push(@av_paren_type, $type);
 			$type = 'E';
 		} elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
 			print "PRE_RESTART($1)\n" if ($dbg_values > 1);
 			$av_preprocessor = 1;
 			push(@av_paren_type, $av_paren_type[$#av_paren_type]);
 			$type = 'E';
 		} elsif ($cur =~ /^(\#\s*(?:endif))/o) {
 			print "PRE_END($1)\n" if ($dbg_values > 1);
 			$av_preprocessor = 1;
 			# Assume all arms of the conditional end as this
 			# one does, and continue as if the #endif was not here.
 			pop(@av_paren_type);
 			push(@av_paren_type, $type);
 			$type = 'E';
 		} elsif ($cur =~ /^(\\\n)/o) {
 			print "PRECONT($1)\n" if ($dbg_values > 1);
 		} elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
 			print "ATTR($1)\n" if ($dbg_values > 1);
 			$av_pending = $type;
 			$type = 'N';
 		} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
 			print "SIZEOF($1)\n" if ($dbg_values > 1);
 			if (defined $2) {
 				$av_pending = 'V';
 			}
 			$type = 'N';
 		} elsif ($cur =~ /^(if|while|for)\b/o) {
 			print "COND($1)\n" if ($dbg_values > 1);
 			$av_pending = 'E';
 			$type = 'N';
 		} elsif ($cur =~/^(case)/o) {
 			print "CASE($1)\n" if ($dbg_values > 1);
 			$av_pend_colon = 'C';
 			$type = 'N';
 		} elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
 			print "KEYWORD($1)\n" if ($dbg_values > 1);
 			$type = 'N';
 		} elsif ($cur =~ /^(\()/o) {
 			print "PAREN('$1')\n" if ($dbg_values > 1);
 			push(@av_paren_type, $av_pending);
 			$av_pending = '_';
 			$type = 'N';
 		} elsif ($cur =~ /^(\))/o) {
 			my $new_type = pop(@av_paren_type);
 			if ($new_type ne '_') {
 				$type = $new_type;
 				print "PAREN('$1') -> $type\n"
 							if ($dbg_values > 1);
 			} else {
 				print "PAREN('$1')\n" if ($dbg_values > 1);
 			}
 		} elsif ($cur =~ /^($Ident)\s*\(/o) {
 			print "FUNC($1)\n" if ($dbg_values > 1);
 			$type = 'V';
 			$av_pending = 'V';
 		} elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
 			if (defined $2 && $type eq 'C' || $type eq 'T') {
 				$av_pend_colon = 'B';
 			} elsif ($type eq 'E') {
 				$av_pend_colon = 'L';
 			}
 			print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
 			$type = 'V';
 		} elsif ($cur =~ /^($Ident|$Constant)/o) {
 			print "IDENT($1)\n" if ($dbg_values > 1);
 			$type = 'V';
 		} elsif ($cur =~ /^($Assignment)/o) {
 			print "ASSIGN($1)\n" if ($dbg_values > 1);
 			$type = 'N';
 		} elsif ($cur =~/^(;|{|})/) {
 			print "END($1)\n" if ($dbg_values > 1);
 			$type = 'E';
 			$av_pend_colon = 'O';
 		} elsif ($cur =~/^(,)/) {
 			print "COMMA($1)\n" if ($dbg_values > 1);
 			$type = 'C';
 		} elsif ($cur =~ /^(\?)/o) {
 			print "QUESTION($1)\n" if ($dbg_values > 1);
 			$type = 'N';
 		} elsif ($cur =~ /^(:)/o) {
 			print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
 			substr($var, length($res), 1, $av_pend_colon);
 			if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
 				$type = 'E';
 			} else {
 				$type = 'N';
 			}
 			$av_pend_colon = 'O';
 		} elsif ($cur =~ /^(\[)/o) {
 			print "CLOSE($1)\n" if ($dbg_values > 1);
 			$type = 'N';
 		} elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
 			my $variant;
 			print "OPV($1)\n" if ($dbg_values > 1);
 			if ($type eq 'V') {
 				$variant = 'B';
 			} else {
 				$variant = 'U';
 			}
 			substr($var, length($res), 1, $variant);
 			$type = 'N';
 		} elsif ($cur =~ /^($Operators)/o) {
 			print "OP($1)\n" if ($dbg_values > 1);
 			if ($1 ne '++' && $1 ne '--') {
 				$type = 'N';
 			}
 		} elsif ($cur =~ /(^.)/o) {
 			print "C($1)\n" if ($dbg_values > 1);
 		}
 		if (defined $1) {
 			$cur = substr($cur, length($1));
 			$res .= $type x length($1);
 		}
 	}
 	return ($res, $var);
 }
 sub possible {
 	my ($possible, $line) = @_;
 	my $notPermitted = qr{(?:
 		^(?:
 			$Modifier|
 			$Storage|
 			$Type|
 			DEFINE_\S+
 		)$|
 		^(?:
 			goto|
 			return|
 			case|
 			else|
 			asm|__asm__|
 			do
 		)(?:\s|$)|
 		^(?:typedef|struct|enum)\b
 	    )}x;
 	warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
 	if ($possible !~ $notPermitted) {
 		# Check for modifiers.
 		$possible =~ s/\s*$Storage\s*//g;
 		$possible =~ s/\s*$Sparse\s*//g;
 		if ($possible =~ /^\s*$/) {
 		} elsif ($possible =~ /\s/) {
 			$possible =~ s/\s*$Type\s*//g;
 			for my $modifier (split(' ', $possible)) {
 				if ($modifier !~ $notPermitted) {
 					warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
 					push(@modifierList, $modifier);
 				}
 			}
 		} else {
 			warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
 			push(@typeList, $possible);
 		}
 		build_types();
 	} else {
 		warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
 	}
 }
 my $prefix = '';
 sub report {
 	if (defined $tst_only && $_[0] !~ /\Q$tst_only\E/) {
 		return 0;
 	}
 	my $line = $prefix . $_[0];
 	$line = (split('\n', $line))[0] . "\n" if ($terse);
 	push(our @report, $line);
 	return 1;
 }
 sub report_dump {
 	our @report;
 }
 sub ERROR {
 	if (report("ERROR: $_[0]\n")) {
 		our $clean = 0;
 		our $cnt_error++;
 	}
 }
 sub WARN {
 	if (report("WARNING: $_[0]\n")) {
 		our $clean = 0;
 		our $cnt_warn++;
 	}
 }
 sub CHK {
 	if ($check && report("CHECK: $_[0]\n")) {
 		our $clean = 0;
 		our $cnt_chk++;
 	}
 }
 sub check_absolute_file {
 	my ($absolute, $herecurr) = @_;
 	my $file = $absolute;
 	##print "absolute<$absolute>\n";
 	# See if any suffix of this path is a path within the tree.
 	while ($file =~ s@^[^/]*/@@) {
 		if (-f "$root/$file") {
 			##print "file<$file>\n";
 			last;
 		}
 	}
 	if (! -f _)  {
 		return 0;
 	}
 	# It is, so see if the prefix is acceptable.
 	my $prefix = $absolute;
 	substr($prefix, -length($file)) = '';
 	##print "prefix<$prefix>\n";
 	if ($prefix ne ".../") {
 		WARN("use relative pathname instead of absolute in changelog text\n" . $herecurr);
 	}
 }
 sub process {
 	my $filename = shift;
 	my $linenr=0;
 	my $prevline="";
 	my $prevrawline="";
 	my $stashline="";
 	my $stashrawline="";
 	my $length;
 	my $indent;
 	my $previndent=0;
 	my $stashindent=0;
 	our $clean = 1;
 	my $signoff = 0;
 	my $is_patch = 0;
 	our @report = ();
 	our $cnt_lines = 0;
 	our $cnt_error = 0;
 	our $cnt_warn = 0;
 	our $cnt_chk = 0;
 	# 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 = '';
 	my $prev_values = 'E';
 	# suppression flags
 	my %suppress_ifbraces;
 	my %suppress_whiletrailers;
 	my %suppress_export;
 	# Pre-scan the patch sanitizing the lines.
 	# Pre-scan the patch looking for any __setup documentation.
 	#
 	my @setup_docs = ();
 	my $setup_docs = 0;
 	sanitise_line_reset();
 	my $line;
 	foreach my $rawline (@rawlines) {
 		$linenr++;
 		$line = $rawline;
 		if ($rawline=~/^\+\+\+\s+(\S+)/) {
 			$setup_docs = 0;
 			if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
 				$setup_docs = 1;
 			}
 			#next;
 		}
 		if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
 			$realline=$1-1;
 			if (defined $2) {
 				$realcnt=$3+1;
 			} else {
 				$realcnt=1+1;
 			}
 			$in_comment = 0;
 			# Guestimate if this is a continuing comment.  Run
 			# the context looking for a comment "edge".  If this
 			# edge is a close comment then we must be in a comment
 			# at context start.
 			my $edge;
 			my $cnt = $realcnt;
 			for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
 				next if (defined $rawlines[$ln - 1] &&
 					 $rawlines[$ln - 1] =~ /^-/);
 				$cnt--;
 				#print "RAW<$rawlines[$ln - 1]>\n";
 				last if (!defined $rawlines[$ln - 1]);
 				if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
 				    $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
 					($edge) = $1;
 					last;
 				}
 			}
 			if (defined $edge && $edge eq '*/') {
 				$in_comment = 1;
 			}
 			# Guestimate if this is a continuing comment.  If this
 			# is the start of a diff block and this line starts
 			# ' *' then it is very likely a comment.
 			if (!defined $edge &&
 			    $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
 			{
 				$in_comment = 1;
 			}
 			##print "COMMENT:$in_comment edge<$edge> $rawline\n";
 			sanitise_line_reset($in_comment);
 		} elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
 			# Standardise the strings and chars within the input to
 			# simplify matching -- only bother with positive lines.
 			$line = sanitise_line($rawline);
 		}
 		push(@lines, $line);
 		if ($realcnt > 1) {
 			$realcnt-- if ($line =~ /^(?:\+| |$)/);
 		} else {
 			$realcnt = 0;
 		}
 		#print "==>$rawline\n";
 		#print "-->$line\n";
 		if ($setup_docs && $line =~ /^\+/) {
 			push(@setup_docs, $line);
 		}
 	}
 	$prefix = '';
 	$realcnt = 0;
 	$linenr = 0;
 	foreach my $line (@lines) {
 		$linenr++;
 		my $rawline = $rawlines[$linenr - 1];
 #extract the line range in the file after the patch is applied
 		if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
 			$is_patch = 1;
 			$first_line = $linenr + 1;
 			$realline=$1-1;
 			if (defined $2) {
 				$realcnt=$3+1;
 			} else {
 				$realcnt=1+1;
 			}
 			annotate_reset();
 			$prev_values = 'E';
 			%suppress_ifbraces = ();
 			%suppress_whiletrailers = ();
 			%suppress_export = ();
 			next;
 # track the line number as we move through the hunk, note that
 # new versions of GNU diff omit the leading space on completely
 # blank context lines so we need to count that too.
 		} elsif ($line =~ /^( |\+|$)/) {
 			$realline++;
 			$realcnt-- if ($realcnt != 0);
 			# Measure the line length and indent.
 			($length, $indent) = line_stats($rawline);
 			# Track the previous line.
 			($prevline, $stashline) = ($stashline, $line);
 			($previndent, $stashindent) = ($stashindent, $indent);
 			($prevrawline, $stashrawline) = ($stashrawline, $rawline);
 			#warn "line<$line>\n";
 		} elsif ($realcnt == 1) {
 			$realcnt--;
 		}
 		my $hunk_line = ($realcnt != 0);
 #make up the handle for any error we report on this line
 		$prefix = "$filename:$realline: " if ($emacs && $file);
 		$prefix = "$filename:$linenr: " if ($emacs && !$file);
 		$here = "#$linenr: " if (!$file);
 		$here = "#$realline: " if ($file);
 		# extract the filename as it passes
 		if ($line=~/^\+\+\+\s+(\S+)/) {
 			$realfile = $1;
 			$realfile =~ s@^([^/]*)/@@;
 			$p1_prefix = $1;
 			if (!$file && $tree && $p1_prefix ne '' &&
 			    -e "$root/$p1_prefix") {
 				WARN("patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
 			}
 			if ($realfile =~ m@^include/asm/@) {
 				ERROR("do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
 			}
 			next;
 		}
 		$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
 		my $hereline = "$here\n$rawline\n";
 		my $herecurr = "$here\n$rawline\n";
 		my $hereprev = "$here\n$prevrawline\n$rawline\n";
 		$cnt_lines++ if ($realcnt != 0);
 #check the patch for a signoff:
 		if ($line =~ /^\s*signed-off-by:/i) {
 			# This is a signoff, if ugly, so do not double report.
 			$signoff++;
 			if (!($line =~ /^\s*Signed-off-by:/)) {
 				WARN("Signed-off-by: is the preferred form\n" .
 					$herecurr);
 			}
 			if ($line =~ /^\s*signed-off-by:\S/i) {
 				WARN("space required after Signed-off-by:\n" .
 					$herecurr);
 			}
 		}
 # Check for wrappage within a valid hunk of the file
 		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
 			ERROR("patch seems to be corrupt (line wrapped?)\n" .
 				$herecurr) if (!$emitted_corrupt++);
 		}
 # Check for absolute kernel paths.
 		if ($tree) {
 			while ($line =~ m{(?:^|\s)(/\S*)}g) {
 				my $file = $1;
 				if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
 				    check_absolute_file($1, $herecurr)) {
 					#
 				} else {
 					check_absolute_file($file, $herecurr);
 				}
 			}
 		}
 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
 		if (($realfile =~ /^$/ || $line =~ /^\+/) &&
 		    $rawline !~ m/^$UTF8*$/) {
 			my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
 			my $blank = copy_spacing($rawline);
 			my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
 			my $hereptr = "$hereline$ptr\n";
 			ERROR("Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
 		}
 # ignore non-hunk lines and lines being removed
 		next if (!$hunk_line || $line =~ /^-/);
 #trailing whitespace
 		if ($line =~ /^\+.*\015/) {
 			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
 			ERROR("DOS line endings\n" . $herevet);
 		} elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
 			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
 			ERROR("trailing whitespace\n" . $herevet);
 			$rpt_cleaners = 1;
 		}
 # check for Kconfig help text having a real description
 		if ($realfile =~ /Kconfig/ &&
 		    $line =~ /\+?\s*(---)?help(---)?$/) {
 			my $length = 0;
 			for (my $l = $linenr; defined($lines[$l]); $l++) {
 				my $f = $lines[$l];
 				$f =~ s/#.*//;
 				$f =~ s/^\s+//;
 				next if ($f =~ /^$/);
 				last if ($f =~ /^\s*config\s/);
 				$length++;
 			}
 			WARN("please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($length < 4);
 		}
 # check we are in a valid source file if not then ignore this hunk
 		next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
 #80 column limit
 		if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
 		    $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
 		    !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:,|\)\s*;)\s*$/ ||
 		    $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
 		    $length > 80)
 		{
 			WARN("line over 80 characters\n" . $herecurr);
 		}
 # check for spaces before a quoted newline
 		if ($rawline =~ /^.*\".*\s\\n/) {
 			WARN("unnecessary whitespace before a quoted newline\n" . $herecurr);
 		}
 # check for adding lines without a newline.
 		if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
 			WARN("adding a line without newline at end of file\n" . $herecurr);
 		}
 # 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";
 				ERROR("use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
 			}
 			if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
 				my $herevet = "$here\n" . cat_vet($line) . "\n";
 				ERROR("use the HI() macro, not (... >> 16)\n" . $herevet);
 			}
 		}
 # check we are in a valid source file C or perl if not then ignore this hunk
 		next if ($realfile !~ /\.(h|c|pl)$/);
 # at the beginning of a line any tabs must come first and anything
 # more than 8 must use tabs.
 		if ($rawline =~ /^\+\s* \t\s*\S/ ||
 		    $rawline =~ /^\+\s*        \s*/) {
 			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
 			ERROR("code indent should use tabs where possible\n" . $herevet);
 			$rpt_cleaners = 1;
 		}
 # check for space before tabs.
 		if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
 			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
 			WARN("please, no space before tabs\n" . $herevet);
 		}
 # check for spaces at the beginning of a line.
 # Exceptions:
 #  1) within comments
 #  2) indented preprocessor commands
 #  3) hanging labels
 		if ($rawline =~ /^\+ / && $line !~ /\+ *(?:$;|#|$Ident:)/)  {
 			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
 			WARN("please, no spaces at the start of a line\n" . $herevet);
 		}
 # check we are in a valid C source file if not then ignore this hunk
 		next if ($realfile !~ /\.(h|c)$/);
 # check for RCS/CVS revision markers
 		if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
 			WARN("CVS style keyword markers, these will _not_ be updated\n". $herecurr);
 		}
 # Blackfin: don't use __builtin_bfin_[cs]sync
 		if ($line =~ /__builtin_bfin_csync/) {
 			my $herevet = "$here\n" . cat_vet($line) . "\n";
 			ERROR("use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
 		}
 		if ($line =~ /__builtin_bfin_ssync/) {
 			my $herevet = "$here\n" . cat_vet($line) . "\n";
 			ERROR("use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
 		}
 # Check for potential 'bare' types
 		my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
 		    $realline_next);
 		if ($realcnt && $line =~ /.\s*\S/) {
 			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
 				ctx_statement_block($linenr, $realcnt, 0);
 			$stat =~ s/\n./\n /g;
 			$cond =~ s/\n./\n /g;
 			# Find the real next line.
 			$realline_next = $line_nr_next;
 			if (defined $realline_next &&
 			    (!defined $lines[$realline_next - 1] ||
 			     substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
 				$realline_next++;
 			}
 			my $s = $stat;
 			$s =~ s/{.*$//s;
 			# Ignore goto labels.
 			if ($s =~ /$Ident:\*$/s) {
 			# Ignore functions being called
 			} elsif ($s =~ /^.\s*$Ident\s*\(/s) {
 			} elsif ($s =~ /^.\s*else\b/s) {
 			# 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;
 				$type =~ s/\s+/ /g;
 				possible($type, "A:" . $s);
 			# 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);
 			}
 			# any (foo ... *) is a pointer cast, and foo is a type
 			while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
 				possible($1, "C:" . $s);
 			}
 			# Check for any sort of function declaration.
 			# int foo(something bar, other baz);
 			# 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);
 				my $ctx = $s;
 				substr($ctx, 0, $name_len + 1, '');
 				$ctx =~ s/\)[^\)]*$//;
 				for my $arg (split(/\s*,\s*/, $ctx)) {
 					if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
 						possible($1, "D:" . $s);
 					}
 				}
 			}
 		}
 #
 # Checks which may be anchored in the context.
 #
 # Check for switch () and associated case and default
 # statements should be at the same indent.
 		if ($line=~/\bswitch\s*\(.*\)/) {
 			my $err = '';
 			my $sep = '';
 			my @ctx = ctx_block_outer($linenr, $realcnt);
 			shift(@ctx);
 			for my $ctx (@ctx) {
 				my ($clen, $cindent) = line_stats($ctx);
 				if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
 							$indent != $cindent) {
 					$err .= "$sep$ctx\n";
 					$sep = '';
 				} else {
 					$sep = "[...]\n";
 				}
 			}
 			if ($err ne '') {
 				ERROR("switch and case should be at the same indent\n$hereline$err");
 			}
 		}
 # if/while/etc brace do not go on next line, unless defining a do while loop,
 # 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";
 			my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
 			my $ctx_cnt = $realcnt - $#ctx - 1;
 			my $ctx = join("\n", @ctx);
 			my $ctx_ln = $linenr;
 			my $ctx_skip = $realcnt;
 			while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
 					defined $lines[$ctx_ln - 1] &&
 					$lines[$ctx_ln - 1] =~ /^-/)) {
 				##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
 				$ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
 				$ctx_ln++;
 			}
 			#print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
 			#print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
 			if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
 				ERROR("that open brace { should be on the previous line\n" .
 					"$here\n$ctx\n$lines[$ctx_ln - 1]\n");
 			}
 			if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
 			    $ctx =~ /\)\s*\;\s*$/ &&
 			    defined $lines[$ctx_ln - 1])
 			{
 				my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
 				if ($nindent > $indent) {
 					WARN("trailing semicolon indicates no statements, indent implies otherwise\n" .
 						"$here\n$ctx\n$lines[$ctx_ln - 1]\n");
 				}
 			}
 		}
 # Check relative indent for conditionals and blocks.
 		if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
 			my ($s, $c) = ($stat, $cond);
 			substr($s, 0, length($c), '');
 			# Make sure we remove the line prefixes as we have
 			# none on the first line, and are going to readd them
 			# where necessary.
 			$s =~ s/\n./\n/gs;
 			# Find out how long the conditional actually is.
 			my @newlines = ($c =~ /\n/gs);
 			my $cond_lines = 1 + $#newlines;
 			# We want to check the first line inside the block
 			# starting at the end of the conditional, so remove:
 			#  1) any blank line termination
 			#  2) any opening brace { on end of the line
 			#  3) any do (...) {
 			my $continuation = 0;
 			my $check = 0;
 			$s =~ s/^.*\bdo\b//;
 			$s =~ s/^\s*{//;
 			if ($s =~ s/^\s*\\//) {
 				$continuation = 1;
 			}
 			if ($s =~ s/^\s*?\n//) {
 				$check = 1;
 				$cond_lines++;
 			}
 			# Also ignore a loop construct at the end of a
 			# preprocessor statement.
 			if (($prevline =~ /^.\s*#\s*define\s/ ||
 			    $prevline =~ /\\\s*$/) && $continuation == 0) {
 				$check = 0;
 			}
 			my $cond_ptr = -1;
 			$continuation = 0;
 			while ($cond_ptr != $cond_lines) {
 				$cond_ptr = $cond_lines;
 				# If we see an #else/#elif then the code
 				# is not linear.
 				if ($s =~ /^\s*\#\s*(?:else|elif)/) {
 					$check = 0;
 				}
 				# Ignore:
 				#  1) blank lines, they should be at 0,
 				#  2) preprocessor lines, and
 				#  3) labels.
 				if ($continuation ||
 				    $s =~ /^\s*?\n/ ||
 				    $s =~ /^\s*#\s*?/ ||
 				    $s =~ /^\s*$Ident\s*:/) {
 					$continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
 					if ($s =~ s/^.*?\n//) {
 						$cond_lines++;
 					}
 				}
 			}
 			my (undef, $sindent) = line_stats("+" . $s);
 			my $stat_real = raw_line($linenr, $cond_lines);
 			# Check if either of these lines are modified, else
 			# this is not this patch's fault.
 			if (!defined($stat_real) ||
 			    $stat !~ /^\+/ && $stat_real !~ /^\+/) {
 				$check = 0;
 			}
 			if (defined($stat_real) && $cond_lines > 1) {
 				$stat_real = "[...]\n$stat_real";
 			}
 			#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";
 			if ($check && (($sindent % 8) != 0 ||
 			    ($sindent <= $indent && $s ne ''))) {
 				WARN("suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
 			}
 		}
 		# Track the 'values' across context and added lines.
 		my $opline = $line; $opline =~ s/^./ /;
 		my ($curr_values, $curr_vars) =
 				annotate_values($opline . "\n", $prev_values);
 		$curr_values = $prev_values . $curr_values;
 		if ($dbg_values) {
 			my $outline = $opline; $outline =~ s/\t/ /g;
 			print "$linenr > .$outline\n";
 			print "$linenr > $curr_values\n";
 			print "$linenr >  $curr_vars\n";
 		}
 		$prev_values = substr($curr_values, -1);
 #ignore lines not being added
 		if ($line=~/^[^\+]/) {next;}
 # TEST: allow direct testing of the type matcher.
 		if ($dbg_type) {
 			if ($line =~ /^.\s*$Declare\s*$/) {
 				ERROR("TEST: is type\n" . $herecurr);
 			} elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
 				ERROR("TEST: is not type ($1 is)\n". $herecurr);
 			}
 			next;
 		}
 # TEST: allow direct testing of the attribute matcher.
 		if ($dbg_attr) {
 			if ($line =~ /^.\s*$Modifier\s*$/) {
 				ERROR("TEST: is attr\n" . $herecurr);
 			} elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
 				ERROR("TEST: is not attr ($1 is)\n". $herecurr);
 			}
 			next;
 		}
 # check for initialisation to aggregates open brace on the next line
 		if ($line =~ /^.\s*{/ &&
 		    $prevline =~ /(?:^|[^=])=\s*$/) {
 			ERROR("that open brace { should be on the previous line\n" . $hereprev);
 		}
 #
 # Checks which are anchored on the added line.
 #
 # check for malformed paths in #include statements (uses RAW line)
 		if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
 			my $path = $1;
 			if ($path =~ m{//}) {
 				ERROR("malformed #include filename\n" .
 					$herecurr);
 			}
 		}
 # no C99 // comments
 		if ($line =~ m{//}) {
 			ERROR("do not use C99 // comments\n" . $herecurr);
 		}
 		# Remove C99 comments.
 		$line =~ s@//.*@@;
 		$opline =~ s@//.*@@;
 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
 # the whole statement.
 #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.*\((.*)\)/)) {
 			my $name = $1;
 			if ($stat !~ /(?:
 				\n.}\s*$|
 				^.DEFINE_$Ident\(\Q$name\E\)|
 				^.DECLARE_$Ident\(\Q$name\E\)|
 				^.LIST_HEAD\(\Q$name\E\)|
 				^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
 				\b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
 			    )/x) {
 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
 				$suppress_export{$realline_next} = 2;
 			} else {
 				$suppress_export{$realline_next} = 1;
 			}
 		}
 		if (!defined $suppress_export{$linenr} &&
 		    $prevline =~ /^.\s*$/ &&
 		    ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
 		     $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
 #print "FOO B <$lines[$linenr - 1]>\n";
 			$suppress_export{$linenr} = 2;
 		}
 		if (defined $suppress_export{$linenr} &&
 		    $suppress_export{$linenr} == 2) {
 			WARN("EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
 		}
 # check for global initialisers.
 		if ($line =~ /^.$Type\s*$Ident\s*(?:\s+$Modifier)*\s*=\s*(0|NULL|false)\s*;/) {
 			ERROR("do not initialise globals to 0 or NULL\n" .
 				$herecurr);
 		}
 # check for static initialisers.
 		if ($line =~ /\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
 			ERROR("do not initialise statics to 0 or NULL\n" .
 				$herecurr);
 		}
 # check for new typedefs, only function parameters and sparse annotations
 # make sense.
 		if ($line =~ /\btypedef\s/ &&
 		    $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
 		    $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
 		    $line !~ /\b$typeTypedefs\b/ &&
 		    $line !~ /\b__bitwise(?:__|)\b/) {
 			WARN("do not add new typedefs\n" . $herecurr);
 		}
 # * goes on variable not on type
 		# (char*[ const])
 		if ($line =~ m{\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\)}) {
 			my ($from, $to) = ($1, $1);
 			# Should start with a space.
 			$to =~ s/^(\S)/ $1/;
 			# Should not end with a space.
 			$to =~ s/\s+$//;
 			# '*'s should not have spaces between.
 			while ($to =~ s/\*\s+\*/\*\*/) {
 			}
 			#print "from<$from> to<$to>\n";
 			if ($from ne $to) {
 				ERROR("\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr);
 			}
 		} elsif ($line =~ m{\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident)}) {
 			my ($from, $to, $ident) = ($1, $1, $2);
 			# Should start with a space.
 			$to =~ s/^(\S)/ $1/;
 			# Should not end with a space.
 			$to =~ s/\s+$//;
 			# '*'s should not have spaces between.
 			while ($to =~ s/\*\s+\*/\*\*/) {
 			}
 			# Modifiers should have spaces.
 			$to =~ s/(\b$Modifier$)/$1 /;
 			#print "from<$from> to<$to> ident<$ident>\n";
 			if ($from ne $to && $ident !~ /^$Modifier$/) {
 				ERROR("\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr);
 			}
 		}
 # # no BUG() or BUG_ON()
 # 		if ($line =~ /\b(BUG|BUG_ON)\b/) {
 # 			print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
 # 			print "$herecurr";
 # 			$clean = 0;
 # 		}
 		if ($line =~ /\bLINUX_VERSION_CODE\b/) {
 			WARN("LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
 		}
 # printk should use KERN_* levels.  Note that follow on printk's on the
 # same line do not need a level, so we use the current block context
 # to try and find and validate the current printk.  In summary the current
 # printk includes all preceeding printk's which have no newline on the end.
 # 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--) {
 				#print "CHECK<$lines[$ln - 1]\n";
 				# we have a preceeding printk if it ends
 				# with "\n" ignore it, else it is to blame
 				if ($lines[$ln - 1] =~ m{\bprintk\(}) {
 					if ($rawlines[$ln - 1] !~ m{\\n"}) {
 						$ok = 1;
 					}
 					last;
 				}
 			}
 			if ($ok == 0) {
 				WARN("printk() should include KERN_ facility level\n" . $herecurr);
 			}
 		}
 # function brace can't be on same line, except for #defines of do while,
 # or if closed on same line
 		if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
 		    !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
 			ERROR("open brace '{' following function declarations go on the next line\n" . $herecurr);
 		}
 # open braces for enum, union and struct go on the same line.
 		if ($line =~ /^.\s*{/ &&
 		    $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
 			ERROR("open brace '{' following $1 go on the same line\n" . $hereprev);
 		}
 # check for spacing round square brackets; allowed:
 #  1. with a type on the left -- int [] a;
 #  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
 #  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+$/) &&
 			    $prefix !~ /{\s+$/) {
 				ERROR("space prohibited before open square bracket '['\n" . $herecurr);
 			}
 		}
 # 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";
 			# Ignore those directives where spaces _are_ permitted.
 			if ($name =~ /^(?:
 				if|for|while|switch|return|case|
 				volatile|__volatile__|
 				__attribute__|format|__extension__|
 				asm|__asm__)$/x)
 			{
 			# cpp #define statements have non-optional spaces, ie
 			# if there is a space between the name and the open
 			# parenthesis it is simply not a parameter group.
 			} elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
 			# cpp #elif statement condition may start with a (
 			} elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
 			# If this whole things ends with a type its most
 			# likely a typedef for a function.
 			} elsif ($ctx =~ /$Type$/) {
 			} else {
 				WARN("space prohibited between function name and open parenthesis '('\n" . $herecurr);
 			}
 		}
 # Check operator spacing.
 		if (!($line=~/\#\s*include/)) {
 			my $ops = qr{
 				<<=|>>=|<=|>=|==|!=|
 				\+=|-=|\*=|\/=|%=|\^=|\|=|&=|
 				=>|->|<<|>>|<|>|=|!|~|
 				&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
 				\?|:
 			}x;
 			my @elements = split(/($ops|;)/, $opline);
 			my $off = 0;
 			my $blank = copy_spacing($opline);
 			for (my $n = 0; $n < $#elements; $n += 2) {
 				$off += length($elements[$n]);
 				# Pick up the preceeding 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]));
 				}
 				my $cb = "$ca$;$cc";
 				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*$/);
 				my $op = $elements[$n + 1];
 				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*\\$/);
 				} else {
 					$c = 'E';
 				}
 				my $ctx = "${a}x${c}";
 				my $at = "(ctx:$ctx)";
 				my $ptr = substr($blank, 0, $off) . "^";
 				my $hereptr = "$hereline$ptr\n";
 				# Pull out the value of this operator.
 				my $op_type = substr($curr_values, $off + 1, 1);
 				# Get the full operator variant.
 				my $opv = $op . substr($curr_vars, $off, 1);
 				# Ignore operators passed as parameters.
 				if ($op_type ne 'V' &&
 				    $ca =~ /\s$/ && $cc =~ /^\s*,/) {
 #				# Ignore comments
 #				} elsif ($op =~ /^$;+$/) {
 				# ; should have either the end of line or a space or \ after it
 				} elsif ($op eq ';') {
 					if ($ctx !~ /.x[WEBC]/ &&
 					    $cc !~ /^\\/ && $cc !~ /^;/) {
 						ERROR("space required after that '$op' $at\n" . $hereptr);
 					}
 				# // is a comment
 				} elsif ($op eq '//') {
 				# No spaces for:
 				#   ->
 				#   :   when part of a bitfield
 				} elsif ($op eq '->' || $opv eq ':B') {
 					if ($ctx =~ /Wx.|.xW/) {
 						ERROR("spaces prohibited around that '$op' $at\n" . $hereptr);
 					}
 				# , must have a space on the right.
 				} elsif ($op eq ',') {
 					if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
 						ERROR("space required after that '$op' $at\n" . $hereptr);
 					}
 				# '*' as part of a type definition -- reported already.
 				} elsif ($opv eq '*_') {
 					#warn "'*' is part of type\n";
 				# unary operators should have a space before and
 				# none after.  May be left adjacent to another
 				# 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 !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
 						ERROR("space required before that '$op' $at\n" . $hereptr);
 					}
 					if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
 						# A unary '*' may be const
 					} elsif ($ctx =~ /.xW/) {
 						ERROR("space prohibited after that '$op' $at\n" . $hereptr);
 					}
 				# 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]/) {
 						ERROR("space required one side of that '$op' $at\n" . $hereptr);
 					}
 					if ($ctx =~ /Wx[BE]/ ||
 					    ($ctx =~ /Wx./ && $cc =~ /^;/)) {
 						ERROR("space prohibited before that '$op' $at\n" . $hereptr);
 					}
 					if ($ctx =~ /ExW/) {
 						ERROR("space prohibited after that '$op' $at\n" . $hereptr);
 					}
 				# << 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
 					 $op eq '%')
 				{
 					if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
 						ERROR("need consistent spacing around '$op' $at\n" .
 							$hereptr);
 					}
 				# A colon needs no spaces before when it is
 				# terminating a case value or a label.
 				} elsif ($opv eq ':C' || $opv eq ':L') {
 					if ($ctx =~ /Wx./) {
 						ERROR("space prohibited before that '$op' $at\n" . $hereptr);
 					}
 				# All the others need spaces both sides.
 				} elsif ($ctx !~ /[EWC]x[CWE]/) {
 					my $ok = 0;
 					# Ignore email addresses <foo@bar>
 					if (($op eq '<' &&
 					     $cc =~ /^\S+\@\S+>/) ||
 					    ($op eq '>' &&
 					     $ca =~ /<\S+\@\S+$/))
 					{
 					    	$ok = 1;
 					}
 					# Ignore ?:
 					if (($opv eq ':O' && $ca =~ /\?$/) ||
 					    ($op eq '?' && $cc =~ /^:/)) {
 					    	$ok = 1;
 					}
 					if ($ok == 0) {
 						ERROR("spaces required around that '$op' $at\n" . $hereptr);
 					}
 				}
 				$off += length($elements[$n + 1]);
 			}
 		}
 # check for multiple assignments
 		if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
 			CHK("multiple assignments should be avoided\n" . $herecurr);
 		}
 ## # check for multiple declarations, allowing for a function declaration
 ## # continuation.
 ## 		if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
 ## 		    $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
 ##
 ## 			# Remove any bracketed sections to ensure we do not
 ## 			# falsly report the parameters of functions.
 ## 			my $ln = $line;
 ## 			while ($ln =~ s/\([^\(\)]*\)//g) {
 ## 			}
 ## 			if ($ln =~ /,/) {
 ## 				WARN("declaring multiple variables together should be avoided\n" . $herecurr);
 ## 			}
 ## 		}
 #need space before brace following if, while, etc
 		if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
 		    $line =~ /do{/) {
 			ERROR("space required before the open brace '{'\n" . $herecurr);
 		}
 # closing brace should have a space following it when it has anything
 # on the line
 		if ($line =~ /}(?!(?:,|;|\)))\S/) {
 			ERROR("space required after that close brace '}'\n" . $herecurr);
 		}
 # check spacing on square brackets
 		if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
 			ERROR("space prohibited after that open square bracket '['\n" . $herecurr);
 		}
 		if ($line =~ /\s\]/) {
 			ERROR("space prohibited before that close square bracket ']'\n" . $herecurr);
 		}
 # check spacing on parentheses
 		if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
 		    $line !~ /for\s*\(\s+;/) {
 			ERROR("space prohibited after that open parenthesis '('\n" . $herecurr);
 		}
 		if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
 		    $line !~ /for\s*\(.*;\s+\)/ &&
 		    $line !~ /:\s+\)/) {
 			ERROR("space prohibited before that close parenthesis ')'\n" . $herecurr);
 		}
 #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:/)) {
 			WARN("labels should not be indented\n" . $herecurr);
 		}
 # Return is not a function.
 		if (defined($stat) && $stat =~ /^.\s*return(\s*)(\(.*);/s) {
 			my $spacing = $1;
 			my $value = $2;
 			# Flatten any parentheses
 			$value =~ s/\(/ \(/g;
 			$value =~ s/\)/\) /g;
 			while ($value =~ s/\[[^\{\}]*\]/1/ ||
 			       $value !~ /(?:$Ident|-?$Constant)\s*
 					     $Compare\s*
 					     (?:$Ident|-?$Constant)/x &&
 			       $value =~ s/\([^\(\)]*\)/1/) {
 			}
 #print "value<$value>\n";
 			if ($value =~ /^\s*(?:$Ident|-?$Constant)\s*$/) {
 				ERROR("return is not a function, parentheses are not required\n" . $herecurr);
 			} elsif ($spacing !~ /\s+/) {
 				ERROR("space required before the open parenthesis '('\n" . $herecurr);
 			}
 		}
+# 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') {
+				WARN("return of an errno should typically be -ve (return -$1)\n" . $herecurr);
+			}
+		}
 # Need a space before open parenthesis after if, while etc
 		if ($line=~/\b(if|while|for|switch)\(/) {
 			ERROR("space required before the open parenthesis '('\n" . $herecurr);
 		}
 # Check for illegal assignment in if conditional -- and check for trailing
 # statements after the conditional.
 		if ($line =~ /do\s*(?!{)/) {
 			my ($stat_next) = ctx_statement_block($line_nr_next,
 						$remain_next, $off_next);
 			$stat_next =~ s/\n./\n /g;
 			##print "stat<$stat> stat_next<$stat_next>\n";
 			if ($stat_next =~ /^\s*while\b/) {
 				# If the statement carries leading newlines,
 				# then count those as offsets.
 				my ($whitespace) =
 					($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
 				my $offset =
 					statement_rawlines($whitespace) - 1;
 				$suppress_whiletrailers{$line_nr_next +
 								$offset} = 1;
 			}
 		}
 		if (!defined $suppress_whiletrailers{$linenr} &&
 		    $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
 			my ($s, $c) = ($stat, $cond);
 			if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
 				ERROR("do not use assignment in if condition\n" . $herecurr);
 			}
 			# Find out what is on the end of the line after the
 			# conditional.
 			substr($s, 0, length($c), '');
 			$s =~ s/\n.*//g;
 			$s =~ s/$;//g; 	# Remove any comments
 			if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
 			    $c !~ /}\s*while\s*/)
 			{
 				# Find out how long the conditional actually is.
 				my @newlines = ($c =~ /\n/gs);
 				my $cond_lines = 1 + $#newlines;
 				my $stat_real = '';
 				$stat_real = raw_line($linenr, $cond_lines)
 							. "\n" if ($cond_lines);
 				if (defined($stat_real) && $cond_lines > 1) {
 					$stat_real = "[...]\n$stat_real";
 				}
 				ERROR("trailing statements should be on next line\n" . $herecurr . $stat_real);
 			}
 		}
 # Check for bitwise tests written as boolean
 		if ($line =~ /
 			(?:
 				(?:\[|\(|\&\&|\|\|)
 				\s*0[xX][0-9]+\s*
 				(?:\&\&|\|\|)
 			|
 				(?:\&\&|\|\|)
 				\s*0[xX][0-9]+\s*
 				(?:\&\&|\|\||\)|\])
 			)/x)
 		{
 			WARN("boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
 		}
 # 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*$)/) {
 				ERROR("trailing statements should be on next line\n" . $herecurr);
 			}
 		}
 # if should not continue a brace
 		if ($line =~ /}\s*if\b/) {
 			ERROR("trailing statements should be on next line\n" .
 				$herecurr);
 		}
 # case and default should not have general statements after them
 		if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
 		    $line !~ /\G(?:
 			(?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
 			\s*return\s+
 		    )/xg)
 		{
 			ERROR("trailing statements should be on next line\n" . $herecurr);
 		}
 		# Check for }<nl>else {, these must be at the same
 		# indent level to be relevant to each other.
 		if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
 						$previndent == $indent) {
 			ERROR("else should follow close brace '}'\n" . $hereprev);
 		}
 		if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
 						$previndent == $indent) {
 			my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
 			# Find out what is on the end of the line after the
 			# conditional.
 			substr($s, 0, length($c), '');
 			$s =~ s/\n.*//g;
 			if ($s =~ /^\s*;/) {
 				ERROR("while should follow close brace '}'\n" . $hereprev);
 			}
 		}
 #studly caps, commented out until figure out how to distinguish between use of existing and adding new
 #		if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
 #		    print "No studly caps, use _\n";
 #		    print "$herecurr";
 #		    $clean = 0;
 #		}
 #no spaces allowed after \ in define
 		if ($line=~/\#\s*define.*\\\s$/) {
 			WARN("Whitepspace after \\ makes next lines useless\n" . $herecurr);
 		}
 #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" &&
 			    $realfile ne $checkfile &&
 			    $1 !~ /$allowed_asm_includes/)
 			{
 				if ($realfile =~ m{^arch/}) {
 					CHK("Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
 				} else {
 					WARN("Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
 				}
 			}
 		}
 # multi-statement macros should be enclosed in a do while loop, grab the
 # first statement and ensure its the whole macro if its not enclosed
 # in a known good container
 		if ($realfile !~ m@/vmlinux.lds.h$@ &&
 		    $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
 			my $ln = $linenr;
 			my $cnt = $realcnt;
 			my ($off, $dstat, $dcond, $rest);
 			my $ctx = '';
 			my $args = defined($1);
 			# Find the end of the macro and limit our statement
 			# search to that.
 			while ($cnt > 0 && defined $lines[$ln - 1] &&
 				$lines[$ln - 1] =~ /^(?:-|..*\\$)/)
 			{
 				$ctx .= $rawlines[$ln - 1] . "\n";
 				$cnt-- if ($lines[$ln - 1] !~ /^-/);
 				$ln++;
 			}
 			$ctx .= $rawlines[$ln - 1];
 			($dstat, $dcond, $ln, $cnt, $off) =
 				ctx_statement_block($linenr, $ln - $linenr + 1, 0);
 			#print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
 			#print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
 			# Extract the remainder of the define (if any) and
 			# rip off surrounding spaces, and trailing \'s.
 			$rest = '';
 			while ($off != 0 || ($cnt > 0 && $rest =~ /\\\s*$/)) {
 				#print "ADDING cnt<$cnt> $off <" . substr($lines[$ln - 1], $off) . "> rest<$rest>\n";
 				if ($off != 0 || $lines[$ln - 1] !~ /^-/) {
 					$rest .= substr($lines[$ln - 1], $off) . "\n";
 					$cnt--;
 				}
 				$ln++;
 				$off = 0;
 			}
 			$rest =~ s/\\\n.//g;
 			$rest =~ s/^\s*//s;
 			$rest =~ s/\s*$//s;
 			# Clean up the original statement.
 			if ($args) {
 				substr($dstat, 0, length($dcond), '');
 			} else {
 				$dstat =~ s/^.\s*\#\s*define\s+$Ident\s*//;
 			}
 			$dstat =~ s/$;//g;
 			$dstat =~ s/\\\n.//g;
 			$dstat =~ s/^\s*//s;
 			$dstat =~ s/\s*$//s;
 			# Flatten any parentheses and braces
 			while ($dstat =~ s/\([^\(\)]*\)/1/ ||
 			       $dstat =~ s/\{[^\{\}]*\}/1/ ||
 			       $dstat =~ s/\[[^\{\}]*\]/1/)
 			{
 			}
 			my $exceptions = qr{
 				$Declare|
 				module_param_named|
 				MODULE_PARAM_DESC|
 				DECLARE_PER_CPU|
 				DEFINE_PER_CPU|
 				__typeof__\(|
 				union|
 				struct|
 				\.$Ident\s*=\s*|
 				^\"|\"$
 			}x;
 			#print "REST<$rest> dstat<$dstat>\n";
 			if ($rest ne '') {
 				if ($rest !~ /while\s*\(/ &&
 				    $dstat !~ /$exceptions/)
 				{
 					ERROR("Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
 				}
 			} elsif ($ctx !~ /;/) {
 				if ($dstat ne '' &&
 				    $dstat !~ /^(?:$Ident|-?$Constant)$/ &&
 				    $dstat !~ /$exceptions/ &&
 				    $dstat !~ /^\.$Ident\s*=/ &&
 				    $dstat =~ /$Operators/)
 				{
 					ERROR("Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");
 				}
 			}
 		}
 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
 # all assignments may have only one of the following with an assignment:
 #	.
 #	ALIGN(...)
 #	VMLINUX_SYMBOL(...)
 		if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
 			WARN("vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
 		}
 # check for redundant bracing round if etc
 		if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
 			my ($level, $endln, @chunks) =
 				ctx_statement_full($linenr, $realcnt, 1);
 			#print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
 			#print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
 			if ($#chunks > 0 && $level == 0) {
 				my $allowed = 0;
 				my $seen = 0;
 				my $herectx = $here . "\n";
 				my $ln = $linenr - 1;
 				for my $chunk (@chunks) {
 					my ($cond, $block) = @{$chunk};
 					# If the condition carries leading newlines, then count those as offsets.
 					my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
 					my $offset = statement_rawlines($whitespace) - 1;
 					#print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
 					# We have looked at and allowed this specific line.
 					$suppress_ifbraces{$ln + $offset} = 1;
 					$herectx .= "$rawlines[$ln + $offset]\n[...]\n";
 					$ln += statement_rawlines($block) - 1;
 					substr($block, 0, length($cond), '');
 					$seen++ if ($block =~ /^\s*{/);
 					#print "cond<$cond> block<$block> allowed<$allowed>\n";
 					if (statement_lines($cond) > 1) {
 						#print "APW: ALLOWED: cond<$cond>\n";
 						$allowed = 1;
 					}
 					if ($block =~/\b(?:if|for|while)\b/) {
 						#print "APW: ALLOWED: block<$block>\n";
 						$allowed = 1;
 					}
 					if (statement_block_size($block) > 1) {
 						#print "APW: ALLOWED: lines block<$block>\n";
 						$allowed = 1;
 					}
 				}
 				if ($seen && !$allowed) {
 					WARN("braces {} are not necessary for any arm of this statement\n" . $herectx);
 				}
 			}
 		}
 		if (!defined $suppress_ifbraces{$linenr - 1} &&
 					$line =~ /\b(if|while|for|else)\b/) {
 			my $allowed = 0;
 			# Check the pre-context.
 			if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
 				#print "APW: ALLOWED: pre<$1>\n";
 				$allowed = 1;
 			}
 			my ($level, $endln, @chunks) =
 				ctx_statement_full($linenr, $realcnt, $-[0]);
 			# Check the condition.
 			my ($cond, $block) = @{$chunks[0]};
 			#print "CHECKING<$linenr> cond<$cond> block<$block>\n";
 			if (defined $cond) {
 				substr($block, 0, length($cond), '');
 			}
 			if (statement_lines($cond) > 1) {
 				#print "APW: ALLOWED: cond<$cond>\n";
 				$allowed = 1;
 			}
 			if ($block =~/\b(?:if|for|while)\b/) {
 				#print "APW: ALLOWED: block<$block>\n";
 				$allowed = 1;
 			}
 			if (statement_block_size($block) > 1) {
 				#print "APW: ALLOWED: lines block<$block>\n";
 				$allowed = 1;
 			}
 			# Check the post-context.
 			if (defined $chunks[1]) {
 				my ($cond, $block) = @{$chunks[1]};
 				if (defined $cond) {
 					substr($block, 0, length($cond), '');
 				}
 				if ($block =~ /^\s*\{/) {
 					#print "APW: ALLOWED: chunk-1 block<$block>\n";
 					$allowed = 1;
 				}
 			}
 			if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
 				my $herectx = $here . "\n";;
 				my $cnt = statement_rawlines($block);
 				for (my $n = 0; $n < $cnt; $n++) {
 					$herectx .= raw_line($linenr, $n) . "\n";;
 				}
 				WARN("braces {} are not necessary for single statement blocks\n" . $herectx);
 			}
 		}
 # don't include deprecated include files (uses RAW line)
 		for my $inc (@dep_includes) {
 			if ($rawline =~ m@^.\s*\#\s*include\s*\<$inc>@) {
 				ERROR("Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr);
 			}
 		}
 # don't use deprecated functions
 		for my $func (@dep_functions) {
 			if ($line =~ /\b$func\b/) {
 				ERROR("Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr);
 			}
 		}
 # no volatiles please
 		my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
 		if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
 			WARN("Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
 		}
 # SPIN_LOCK_UNLOCKED & RW_LOCK_UNLOCKED are deprecated
 		if ($line =~ /\b(SPIN_LOCK_UNLOCKED|RW_LOCK_UNLOCKED)/) {
 			ERROR("Use of $1 is deprecated: see Documentation/spinlocks.txt\n" . $herecurr);
 		}
 # warn about #if 0
 		if ($line =~ /^.\s*\#\s*if\s+0\b/) {
 			CHK("if this code is redundant consider removing it\n" .
 				$herecurr);
 		}
 # check for needless kfree() checks
 		if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
 			my $expr = $1;
 			if ($line =~ /\bkfree\(\Q$expr\E\);/) {
 				WARN("kfree(NULL) is safe this check is probably not required\n" . $hereprev);
 			}
 		}
 # check for needless usb_free_urb() checks
 		if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
 			my $expr = $1;
 			if ($line =~ /\busb_free_urb\(\Q$expr\E\);/) {
 				WARN("usb_free_urb(NULL) is safe this check is probably not required\n" . $hereprev);
 			}
 		}
 # prefer usleep_range over udelay
 		if ($line =~ /\budelay\s*\(\s*(\w+)\s*\)/) {
 			# ignore udelay's < 10, however
 			if (! (($1 =~ /(\d+)/) && ($1 < 10)) ) {
 				CHK("usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $line);
 			}
 		}
 # warn about unexpectedly long msleep's
 		if ($line =~ /\bmsleep\s*\((\d+)\);/) {
 			if ($1 < 20) {
 				WARN("msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);
 			}
 		}
 # warn about #ifdefs in C files
 #		if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
 #			print "#ifdef in C files should be avoided\n";
 #			print "$herecurr";
 #			$clean = 0;
 #		}
 # warn about spacing in #ifdefs
 		if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
 			ERROR("exactly one space required after that #$1\n" . $herecurr);
 		}
 # check for spinlock_t definitions without a comment.
 		if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
 		    $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
 			my $which = $1;
 			if (!ctx_has_comment($first_line, $linenr)) {
 				CHK("$1 definition without comment\n" . $herecurr);
 			}
 		}
 # 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)) {
 				CHK("memory barrier without comment\n" . $herecurr);
 			}
 		}
 # check of hardware specific defines
 		if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
 			CHK("architecture specific defines should be avoided\n" .  $herecurr);
 		}
 # Check that the storage class is at the beginning of a declaration
 		if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
 			WARN("storage class should be at the beginning of the declaration\n" . $herecurr)
 		}
 # check the location of the inline attribute, that it is between
 # storage class and type.
 		if ($line =~ /\b$Type\s+$Inline\b/ ||
 		    $line =~ /\b$Inline\s+$Storage\b/) {
 			ERROR("inline keyword should sit between storage class and type\n" . $herecurr);
 		}
 # Check for __inline__ and __inline, prefer inline
 		if ($line =~ /\b(__inline__|__inline)\b/) {
 			WARN("plain inline is preferred over $1\n" . $herecurr);
 		}
 # check for sizeof(&)
 		if ($line =~ /\bsizeof\s*\(\s*\&/) {
 			WARN("sizeof(& should be avoided\n" . $herecurr);
 		}
 # check for new externs in .c files.
 		if ($realfile =~ /\.c$/ && defined $stat &&
 		    $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
 		{
 			my $function_name = $1;
 			my $paren_space = $2;
 			my $s = $stat;
 			if (defined $cond) {
 				substr($s, 0, length($cond), '');
 			}
 			if ($s =~ /^\s*;/ &&
 			    $function_name ne 'uninitialized_var')
 			{
 				WARN("externs should be avoided in .c files\n" .  $herecurr);
 			}
 			if ($paren_space =~ /\n/) {
 				WARN("arguments for function declarations should follow identifier\n" . $herecurr);
 			}
 		} elsif ($realfile =~ /\.c$/ && defined $stat &&
 		    $stat =~ /^.\s*extern\s+/)
 		{
 			WARN("externs should be avoided in .c files\n" .  $herecurr);
 		}
 # checks for new __setup's
 		if ($rawline =~ /\b__setup\("([^"]*)"/) {
 			my $name = $1;
 			if (!grep(/$name/, @setup_docs)) {
 				CHK("__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
 			}
 		}
 # check for pointless casting of kmalloc return
 		if ($line =~ /\*\s*\)\s*k[czm]alloc\b/) {
 			WARN("unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
 		}
 # check for gcc specific __FUNCTION__
 		if ($line =~ /__FUNCTION__/) {
 			WARN("__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr);
 		}
 # check for semaphores used as mutexes
 		if ($line =~ /^.\s*(DECLARE_MUTEX|init_MUTEX)\s*\(/) {
 			WARN("mutexes are preferred for single holder semaphores\n" . $herecurr);
 		}
 # check for semaphores used as mutexes
 		if ($line =~ /^.\s*init_MUTEX_LOCKED\s*\(/) {
 			WARN("consider using a completion\n" . $herecurr);
 		}
 # recommend strict_strto* over simple_strto*
 		if ($line =~ /\bsimple_(strto.*?)\s*\(/) {
 			WARN("consider using strict_$1 in preference to simple_$1\n" . $herecurr);
 		}
 # check for __initcall(), use device_initcall() explicitly please
 		if ($line =~ /^.\s*__initcall\s*\(/) {
 			WARN("please use device_initcall() instead of __initcall()\n" . $herecurr);
 		}
 # check for various ops structs, ensure they are const.
 		my $struct_ops = qr{acpi_dock_ops|
 				address_space_operations|
 				backlight_ops|
 				block_device_operations|
 				dentry_operations|
 				dev_pm_ops|
 				dma_map_ops|
 				extent_io_ops|
 				file_lock_operations|
 				file_operations|
 				hv_ops|
 				ide_dma_ops|
 				intel_dvo_dev_ops|
 				item_operations|
 				iwl_ops|
 				kgdb_arch|
 				kgdb_io|
 				kset_uevent_ops|
 				lock_manager_operations|
 				microcode_ops|
 				mtrr_ops|
 				neigh_ops|
 				nlmsvc_binding|
 				pci_raw_ops|
 				pipe_buf_operations|
 				platform_hibernation_ops|
 				platform_suspend_ops|
 				proto_ops|
 				rpc_pipe_ops|
 				seq_operations|
 				snd_ac97_build_ops|
 				soc_pcmcia_socket_ops|
 				stacktrace_ops|
 				sysfs_ops|
 				tty_operations|
 				usb_mon_operations|
 				wd_ops}x;
 		if ($line !~ /\bconst\b/ &&
 		    $line =~ /\bstruct\s+($struct_ops)\b/) {
 			WARN("struct $1 should normally be const\n" .
 				$herecurr);
 		}
 # use of NR_CPUS is usually wrong
 # ignore definitions of NR_CPUS and usage to define arrays as likely right
 		if ($line =~ /\bNR_CPUS\b/ &&
 		    $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
 		    $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
 		    $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
 		    $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
 		    $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
 		{
 			WARN("usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
 		}
 # check for %L{u,d,i} in strings
 		my $string;
 		while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
 			$string = substr($rawline, $-[1], $+[1] - $-[1]);
 			$string =~ s/%%/__/g;
 			if ($string =~ /(?<!%)%L[udi]/) {
 				WARN("\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
 				last;
 			}
 		}
 # whine mightly about in_atomic
 		if ($line =~ /\bin_atomic\s*\(/) {
 			if ($realfile =~ m@^drivers/@) {
 				ERROR("do not use in_atomic in drivers\n" . $herecurr);
 			} elsif ($realfile !~ m@^kernel/@) {
 				WARN("use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
 			}
 		}
 # check for lockdep_set_novalidate_class
 		if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
 		    $line =~ /__lockdep_no_validate__\s*\)/ ) {
 			if ($realfile !~ m@^kernel/lockdep@ &&
 			    $realfile !~ m@^include/linux/lockdep@ &&
 			    $realfile !~ m@^drivers/base/core@) {
 				ERROR("lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
 			}
 		}
 	}
 	# If we have no input at all, then there is nothing to report on
 	# so just keep quiet.
 	if ($#rawlines == -1) {
 		exit(0);
 	}
 	# In mailback mode only produce a report in the negative, for
 	# things that appear to be patches.
 	if ($mailback && ($clean == 1 || !$is_patch)) {
 		exit(0);
 	}
 	# This is not a patch, and we are are in 'no-patch' mode so
 	# just keep quiet.
 	if (!$chk_patch && !$is_patch) {
 		exit(0);
 	}
 	if (!$is_patch) {
 		ERROR("Does not appear to be a unified-diff format patch\n");
 	}
 	if ($is_patch && $chk_signoff && $signoff == 0) {
 		ERROR("Missing Signed-off-by: line(s)\n");
 	}
 	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);
 	}
 	if ($quiet == 0) {
 		# If there were whitespace errors which cleanpatch can fix
 		# then suggest that.
 		if ($rpt_cleaners) {
 			print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
 			print "      scripts/cleanfile\n\n";
 		}
 	}
 	if ($clean == 1 && $quiet == 0) {
 		print "$vname has no obvious style problems and is ready for submission.\n"
 	}
 	if ($clean == 0 && $quiet == 0) {
 		print "$vname has style problems, please review.  If any of these errors\n";
 		print "are false positives report them to the maintainer, see\n";
 		print "CHECKPATCH in MAINTAINERS.\n";
 	}
 	return $clean;
 }