Quelle checkpatch.pl Sprache: Shell

#!/usr/bin/env perl
# SPDX-License-Identifier: GPL-2.0
#
# (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-2010 Andy Whitcroft <apw@canonical.com>
# (c) 2010-2018 Joe Perches <joe@perches.com>

use strict;
use warnings;
use POSIX;
use File::Basename;
use Cwd 'abs_path';
use Term::ANSIColor qw(:constants);
use Encode qw(decode encode);

my $P = $0;
my $D = dirname(abs_path($P));

my $V = '0.32';

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

my $quiet = 0;
my $verbose = 0;
my %verbose_messages = ();
my %verbose_emitted = ();
my $tree = 1;
my $chk_signoff = 1;
my $chk_fixes_tag = 1;
my $chk_patch = 1;
my $tst_only;
my $emacs = 0;
my $terse = 0;
my $showfile = 0;
my $file = 0;
my $git = 0;
my %git_commits = ();
my $check = 0;
my $check_orig = 0;
my $summary = 1;
my $mailback = 0;
my $summary_file = 0;
my $show_types = 0;
my $list_types = 0;
my $fix = 0;
my $fix_inplace = 0;
my $root;
my $gitroot = $ENV{'GIT_DIR'};
$gitroot = ".git" if !defined($gitroot);
my %debug;
my %camelcase = ();
my %use_type = ();
my @use = ();
my %ignore_type = ();
my @ignore = ();
my $help = 0;
my $configuration_file = ".checkpatch.conf";
my $max_line_length = 100;
my $ignore_perl_version = 0;
my $minimum_perl_version = 5.10.0;
my $min_conf_desc_length = 4;
my $spelling_file = "$D/spelling.txt";
my $codespell = 0;
my $codespellfile = "/usr/share/codespell/dictionary.txt";
my $user_codespellfile = "";
my $conststructsfile = "$D/const_structs.checkpatch";
my $docsfile = "$D/../Documentation/dev-tools/checkpatch.rst";
my $typedefsfile;
my $color = "auto";
my $allow_c99_comments = 1; # Can be overridden by --ignore C99_COMMENT_TOLERANCE
# git output parsing needs US English output, so first set backtick child process LANGUAGE
my $git_command ='export LANGUAGE=en_US.UTF-8; git';
my $tabsize = 8;
my ${CONFIG_} = "CONFIG_";

my %maybe_linker_symbol; # for externs in c exceptions, when seen in *vmlinux.lds.h

sub help {
my ($exitcode) = @_;

print << "EOM";
Usage: $P [OPTION]... [FILE]...
Version: $V

Options:
  -q, --quiet                quiet
  -v, --verbose              verbose mode
  --no-tree                  run without a kernel tree
  --no-signoff               do not check for 'Signed-off-by' line
  --no-fixes-tag             do not check for 'Fixes:' tag
  --patch                    treat FILE as patchfile (default)
  --emacs                    emacs compile window format
  --terse                    one line per report
  --showfile                 emit diffed file position, not input file position
  -g, --git                  treat FILE as a single commit or git revision range
                             single git commit with:
                               <rev>
                               <rev>^
                               <rev>~n
                             multiple git commits with:
                               <rev1>..<rev2>
                               <rev1>...<rev2>
                               <rev>-<count>
                             git merges are ignored
  -f, --file                 treat FILE as regular source file
  --subjective, --strict     enable more subjective tests
  --list-types               list the possible message types
  --types TYPE(,TYPE2...)    show only these comma separated message types
  --ignore TYPE(,TYPE2...)   ignore various comma separated message types
  --show-types               show the specific message type in the output
  --max-line-length=n        set the maximum line length, (default $max_line_length)
                             if exceeded, warn on patches
                             requires --strict for use with --file
  --min-conf-desc-length=n   set the minimum description length for config symbols
                             in lines, if shorter, warn (default $min_conf_desc_length)
  --tab-size=n               set the number of spaces for tab (default $tabsize)
  --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
  --fix                      EXPERIMENTAL - may create horrible results
                             If correctable single-line errors exist, create
                             ".EXPERIMENTAL-checkpatch-fixes"
                             with potential errors corrected to the preferred
                             checkpatch style
  --fix-inplace              EXPERIMENTAL - may create horrible results
                             Is the same as --fix, but overwrites the input
                             file.  It's your fault if there's no backup or git
  --ignore-perl-version      override checking of perl version.  expect
                             runtime errors.
  --codespell                Use the codespell dictionary for spelling/typos
                             (default:$codespellfile)
  --codespellfile            Use this codespell dictionary
  --typedefsfile             Read additional types from this file
  --color[=WHEN]             Use colors 'always', 'never', or only when output
                             is a terminal ('auto'). Default is 'auto'.
  --kconfig-prefix=WORD      use WORD as a prefix for Kconfig symbols (default
                             ${CONFIG_})
  -h, --help, --version      display this help and exit

When FILE is - read standard input.
EOM

exit($exitcode);
}

my $DO_WHILE_0_ADVICE = q{
   do {} while (0) advice is over-stated in a few situations:

   The more obvious case is macros, like MODULE_PARM_DESC, invoked at
   file-scope, where C disallows code (it must be in functions).  See
   $exceptions if you have one to add by name.

   More troublesome is declarative macros used at top of new scope,
   like DECLARE_PER_CPU.  These might just compile with a do-while-0
   wrapper, but would be incorrect.  Most of these are handled by
   detecting struct,union,etc declaration primitives in $exceptions.

   Theres also macros called inside an if (block), which "return" an
   expression.  These cannot do-while, and need a ({}) wrapper.

   Enjoy this qualification while we work to improve our heuristics.
};

sub uniq {
my %seen;
return grep { !$seen{$_}++ } @_;
}

sub list_types {
my ($exitcode) = @_;

my $count = 0;

local $/ = undef;

open(my $script, '<', abs_path($P)) or
     die "$P: Can't read '$P' $!\n";

my $text = <$script>;
close($script);

my %types = ();
# Also catch when type or level is passed through a variable
while ($text =~ /(?:(\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {
  if (defined($1)) {
   if (exists($types{$2})) {
    $types{$2} .= ",$1" if ($types{$2} ne $1);
   } else {
    $types{$2} = $1;
   }
  } else {
   $types{$2} = "UNDETERMINED";
  }
}

print("#\tMessage type\n\n");
if ($color) {
  print(" ( Color coding: ");
  print(RED . "ERROR" . RESET);
  print(" | ");
  print(YELLOW . "WARNING" . RESET);
  print(" | ");
  print(GREEN . "CHECK" . RESET);
  print(" | ");
  print("Multiple levels / Undetermined");
  print(" )\n\n");
}

foreach my $type (sort keys %types) {
  my $orig_type = $type;
  if ($color) {
   my $level = $types{$type};
   if ($level eq "ERROR") {
    $type = RED . $type . RESET;
   } elsif ($level eq "WARN") {
    $type = YELLOW . $type . RESET;
   } elsif ($level eq "CHK") {
    $type = GREEN . $type . RESET;
   }
  }
  print(++$count . "\t" . $type . "\n");
  if ($verbose && exists($verbose_messages{$orig_type})) {
   my $message = $verbose_messages{$orig_type};
   $message =~ s/\n/\n\t/g;
   print("\t" . $message . "\n\n");
  }
}

exit($exitcode);
}

my $conf = which_conf($configuration_file);
if (-f $conf) {
my @conf_args;
open(my $conffile, '<', "$conf")
     or warn "$P: Can't find a readable $configuration_file file $!\n";

while (<$conffile>) {
  my $line = $_;

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

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

  my @words = split(" ", $line);
  foreach my $word (@words) {
   last if ($word =~ m/^#/);
   push (@conf_args, $word);
  }
}
close($conffile);
unshift(@ARGV, @conf_args) if @conf_args;
}

sub load_docs {
open(my $docs, '<', "$docsfile")
     or warn "$P: Can't read the documentation file $docsfile $!\n";

my $type = '';
my $desc = '';
my $in_desc = 0;

while (<$docs>) {
  chomp;
  my $line = $_;
  $line =~ s/\s+$//;

  if ($line =~ /^\s*\*\*(.+)\*\*$/) {
   if ($desc ne '') {
    $verbose_messages{$type} = trim($desc);
   }
   $type = $1;
   $desc = '';
   $in_desc = 1;
  } elsif ($in_desc) {
   if ($line =~ /^(?:\s{4,}|$)/) {
    $line =~ s/^\s{4}//;
    $desc .= $line;
    $desc .= "\n";
   } else {
    $verbose_messages{$type} = trim($desc);
    $type = '';
    $desc = '';
    $in_desc = 0;
   }
  }
}

if ($desc ne '') {
  $verbose_messages{$type} = trim($desc);
}
close($docs);
}

# Perl's Getopt::Long allows options to take optional arguments after a space.
# Prevent --color by itself from consuming other arguments
foreach (@ARGV) {
if ($_ eq "--color" || $_ eq "-color") {
  $_ = "--color=$color";
}
}

GetOptions(
'q|quiet+' => \$quiet,
'v|verbose!' => \$verbose,
'tree!'  => \$tree,
'signoff!' => \$chk_signoff,
'fixes-tag!' => \$chk_fixes_tag,
'patch!' => \$chk_patch,
'emacs!' => \$emacs,
'terse!' => \$terse,
'showfile!' => \$showfile,
'f|file!' => \$file,
'g|git!' => \$git,
'subjective!' => \$check,
'strict!' => \$check,
'ignore=s' => \@ignore,
'types=s' => \@use,
'show-types!' => \$show_types,
'list-types!' => \$list_types,
'max-line-length=i' => \$max_line_length,
'min-conf-desc-length=i' => \$min_conf_desc_length,
'tab-size=i' => \$tabsize,
'root=s' => \$root,
'summary!' => \$summary,
'mailback!' => \$mailback,
'summary-file!' => \$summary_file,
'fix!'  => \$fix,
'fix-inplace!' => \$fix_inplace,
'ignore-perl-version!' => \$ignore_perl_version,
'debug=s' => \%debug,
'test-only=s' => \$tst_only,
'codespell!' => \$codespell,
'codespellfile=s' => \$user_codespellfile,
'typedefsfile=s' => \$typedefsfile,
'color=s' => \$color,
'no-color' => \$color, #keep old behaviors of -nocolor
'nocolor' => \$color, #keep old behaviors of -nocolor
'kconfig-prefix=s' => \${CONFIG_},
'h|help' => \$help,
'version' => \$help
) or $help = 2;

if ($user_codespellfile) {
# Use the user provided codespell file unconditionally
$codespellfile = $user_codespellfile;
} elsif (!(-f $codespellfile)) {
# If /usr/share/codespell/dictionary.txt is not present, try to find it
# under codespell's install directory: <codespell_root>/data/dictionary.txt
if (($codespell || $help) && which("python3") ne "") {
  my $python_codespell_dict = << "EOF";

import os.path as op
import codespell_lib
codespell_dir = op.dirname(codespell_lib.__file__)
codespell_file = op.join(codespell_dir, 'data', 'dictionary.txt')
print(codespell_file, end='')
EOF

  my $codespell_dict = `python3 -c "$python_codespell_dict" 2> /dev/null`;
  $codespellfile = $codespell_dict if (-f $codespell_dict);
}
}

# $help is 1 if either -h, --help or --version is passed as option - exitcode: 0
# $help is 2 if invalid option is passed - exitcode: 1
help($help - 1) if ($help);

die "$P: --git cannot be used with --file or --fix\n" if ($git && ($file || $fix));
die "$P: --verbose cannot be used with --terse\n" if ($verbose && $terse);

if ($color =~ /^[01]$/) {
$color = !$color;
} elsif ($color =~ /^always$/i) {
$color = 1;
} elsif ($color =~ /^never$/i) {
$color = 0;
} elsif ($color =~ /^auto$/i) {
$color = (-t STDOUT);
} else {
die "$P: Invalid color mode: $color\n";
}

load_docs() if ($verbose);
list_types(0) if ($list_types);

$fix = 1 if ($fix_inplace);
$check_orig = $check;

my $exit = 0;

my $perl_version_ok = 1;
if ($^V && $^V lt $minimum_perl_version) {
$perl_version_ok = 0;
printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
exit(1) if (!$ignore_perl_version);
}

#if no filenames are given, push '-' to read patch from stdin
if ($#ARGV < 0) {
push(@ARGV, '-');
}

# skip TAB size 1 to avoid additional checks on $tabsize - 1
die "$P: Invalid TAB size: $tabsize\n" if ($tabsize < 2);

sub hash_save_array_words {
my ($hashRef, $arrayRef) = @_;

my @array = split(/,/, join(',', @$arrayRef));
foreach my $word (@array) {
  $word =~ s/\s*\n?$//g;
  $word =~ s/^\s*//g;
  $word =~ s/\s+/ /g;
  $word =~ tr/[a-z]/[A-Z]/;

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

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

sub hash_show_words {
my ($hashRef, $prefix) = @_;

if (keys %$hashRef) {
  print "\nNOTE: $prefix message types:";
  foreach my $word (sort keys %$hashRef) {
   print " $word";
  }
  print "\n";
}
}

hash_save_array_words(\%ignore_type, \@ignore);
hash_save_array_words(\%use_type, \@use);

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|
   __kprobes|
   __ref|
   __refconst|
   __refdata|
   __rcu|
   __private
  }x;
our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};

# Notes to $Attribute:
# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
our $Attribute = qr{
   const|
   volatile|
   __percpu|
   __nocast|
   __safe|
   __bitwise|
   __packed__|
   __packed2__|
   __naked|
   __maybe_unused|
   __always_unused|
   __noreturn|
   __used|
   __cold|
   __pure|
   __noclone|
   __deprecated|
   __read_mostly|
   __ro_after_init|
   __kprobes|
   $InitAttribute|
   __aligned\s*$.*$|
   ____cacheline_aligned|
   ____cacheline_aligned_in_smp|
   ____cacheline_internodealigned_in_smp|
   __weak|
   __alloc_size\s*$\s*\d+\s*(?:,\s*\d+\s*)?$
    }x;
our $Modifier;
our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
our $Lval = qr{$Ident(?:$Member)*};

our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
our $Binary = qr{(?i)0b[01]+$Int_type?};
our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
our $Int = qr{[0-9]+$Int_type?};
our $Octal = qr{0[0-7]+$Int_type?};
our $String = qr{(?:\b[Lu])?"[X\t]*"};
our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
our $Float = qr{$Float_hex|$Float_dec|$Float_int};
our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
our $Compare    = qr{<=|>=|==|!=|<|(?<!-)>};
our $Arithmetic = qr{\+|-|\*|\/|%};
our $Operators = qr{
   <=|>=|==|!=|
   =>|->|<<|>>|<|>|!|~|
   &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
    }x;

our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;

our $BasicType;
our $NonptrType;
our $NonptrTypeMisordered;
our $NonptrTypeWithAttr;
our $Type;
our $TypeMisordered;
our $Declare;
our $DeclareMisordered;

our $NON_ASCII_UTF8 = qr{
[\xC2-\xDF][\x80-\xBF]               # non-overlong 2-byte
|  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
|  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
|  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
| [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
|  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
}x;

our $UTF8 = qr{
[\x09\x0A\x0D\x20-\x7E]              # ASCII
| $NON_ASCII_UTF8
}x;

our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
our $typeOtherOSTypedefs = qr{(?x:
u_(?:char|short|int|long) |          # bsd
u(?:nchar|short|int|long)            # sysv
)};
our $typeKernelTypedefs = qr{(?x:
(?:__)?(?:u|s|be|le)(?:8|16|32|64)|
atomic_t
)};
our $typeStdioTypedefs = qr{(?x:
FILE
)};
our $typeTypedefs = qr{(?x:
$typeC99Typedefs\b|
$typeOtherOSTypedefs\b|
$typeKernelTypedefs\b|
$typeStdioTypedefs\b
)};

our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};

our $logFunctions = qr{(?x:
printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
(?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
TP_printk|
WARN(?:_RATELIMIT|_ONCE|)|
panic|
MODULE_[A-Z_]+|
seq_vprintf|seq_printf|seq_puts
)};

our $allocFunctions = qr{(?x:
(?:(?:devm_)?
  (?:kv|k|v)[czm]alloc(?:_array)?(?:_node)? |
  kstrdup(?:_const)? |
  kmemdup(?:_nul)?) |
(?:\w+)?alloc_skb(?:_ip_align)? |
    # dev_alloc_skb/netdev_alloc_skb, et al
dma_alloc_coherent
)};

our $signature_tags = qr{(?xi:
Signed-off-by:|
Co-developed-by:|
Acked-by:|
Tested-by:|
Reviewed-by:|
Reported-by:|
Suggested-by:|
To:|
Cc:
)};

our @link_tags = qw(Link Closes);

#Create a search and print patterns for all these strings to be used directly below
our $link_tags_search = "";
our $link_tags_print = "";
foreach my $entry (@link_tags) {
if ($link_tags_search ne "") {
  $link_tags_search .= '|';
  $link_tags_print .= ' or ';
}
$entry .= ':';
$link_tags_search .= $entry;
$link_tags_print .= "'$entry'";
}
$link_tags_search = "(?:${link_tags_search})";

our $tracing_logging_tags = qr{(?xi:
[=-]*> |
<[=-]* |
\[ |
\] |
start |
called |
entered |
entry |
enter |
in |
inside |
here |
begin |
exit |
end |
done |
leave |
completed |
out |
return |
[\.\!:\s]*
)};

# Device ID types like found in include/linux/mod_devicetable.h.
our $dev_id_types = qr{\b[a-z]\w*_device_id\b};

sub edit_distance_min {
my (@arr) = @_;
my $len = scalar @arr;
if ((scalar @arr) < 1) {
  # if underflow, return
  return;
}
my $min = $arr[0];
for my $i (0 .. ($len-1)) {
  if ($arr[$i] < $min) {
   $min = $arr[$i];
  }
}
return $min;
}

sub get_edit_distance {
my ($str1, $str2) = @_;
$str1 = lc($str1);
$str2 = lc($str2);
$str1 =~ s/-//g;
$str2 =~ s/-//g;
my $len1 = length($str1);
my $len2 = length($str2);
# two dimensional array storing minimum edit distance
my @distance;
for my $i (0 .. $len1) {
  for my $j (0 .. $len2) {
   if ($i == 0) {
    $distance[$i][$j] = $j;
   } elsif ($j == 0) {
    $distance[$i][$j] = $i;
   } elsif (substr($str1, $i-1, 1) eq substr($str2, $j-1, 1)) {
    $distance[$i][$j] = $distance[$i - 1][$j - 1];
   } else {
    my $dist1 = $distance[$i][$j - 1]; #insert distance
    my $dist2 = $distance[$i - 1][$j]; # remove
    my $dist3 = $distance[$i - 1][$j - 1]; #replace
    $distance[$i][$j] = 1 + edit_distance_min($dist1, $dist2, $dist3);
   }
  }
}
return $distance[$len1][$len2];
}

sub find_standard_signature {
my ($sign_off) = @_;
my @standard_signature_tags = (
  'Signed-off-by:', 'Co-developed-by:', 'Acked-by:', 'Tested-by:',
  'Reviewed-by:', 'Reported-by:', 'Suggested-by:'
);
foreach my $signature (@standard_signature_tags) {
  return $signature if (get_edit_distance($sign_off, $signature) <= 2);
}

return "";
}

our $obsolete_archives = qr{(?xi:
\Qfreedesktop.org/archives/dri-devel\E |
\Qlists.infradead.org\E |
\Qlkml.org\E |
\Qmail-archive.com\E |
\Qmailman.alsa-project.org/pipermail\E |
\Qmarc.info\E |
\Qozlabs.org/pipermail\E |
\Qspinics.net\E
)};

our @typeListMisordered = (
qr{char\s+(?:un)?signed},
qr{int\s+(?:(?:un)?signed\s+)?short\s},
qr{int\s+short(?:\s+(?:un)?signed)},
qr{short\s+int(?:\s+(?:un)?signed)},
qr{(?:un)?signed\s+int\s+short},
qr{short\s+(?:un)?signed},
qr{long\s+int\s+(?:un)?signed},
qr{int\s+long\s+(?:un)?signed},
qr{long\s+(?:un)?signed\s+int},
qr{int\s+(?:un)?signed\s+long},
qr{int\s+(?:un)?signed},
qr{int\s+long\s+long\s+(?:un)?signed},
qr{long\s+long\s+int\s+(?:un)?signed},
qr{long\s+long\s+(?:un)?signed\s+int},
qr{long\s+long\s+(?:un)?signed},
qr{long\s+(?:un)?signed},
);

our @typeList = (
qr{void},
qr{(?:(?:un)?signed\s+)?char},
qr{(?:(?:un)?signed\s+)?short\s+int},
qr{(?:(?:un)?signed\s+)?short},
qr{(?:(?:un)?signed\s+)?int},
qr{(?:(?:un)?signed\s+)?long\s+int},
qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
qr{(?:(?:un)?signed\s+)?long\s+long},
qr{(?:(?:un)?signed\s+)?long},
qr{(?:un)?signed},
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},
@typeListMisordered,
);

our $C90_int_types = qr{(?x:
long\s+long\s+int\s+(?:un)?signed|
long\s+long\s+(?:un)?signed\s+int|
long\s+long\s+(?:un)?signed|
(?:(?:un)?signed\s+)?long\s+long\s+int|
(?:(?:un)?signed\s+)?long\s+long|
int\s+long\s+long\s+(?:un)?signed|
int\s+(?:(?:un)?signed\s+)?long\s+long|

long\s+int\s+(?:un)?signed|
long\s+(?:un)?signed\s+int|
long\s+(?:un)?signed|
(?:(?:un)?signed\s+)?long\s+int|
(?:(?:un)?signed\s+)?long|
int\s+long\s+(?:un)?signed|
int\s+(?:(?:un)?signed\s+)?long|

int\s+(?:un)?signed|
(?:(?:un)?signed\s+)?int
)};

our @typeListFile = ();
our @typeListWithAttr = (
@typeList,
qr{struct\s+$InitAttribute\s+$Ident},
qr{union\s+$InitAttribute\s+$Ident},
);

our @modifierList = (
qr{fastcall},
);
our @modifierListFile = ();

our @mode_permission_funcs = (
["module_param", 3],
["module_param_(?:array|named|string)", 4],
["module_param_array_named", 5],
["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
["proc_create(?:_data|)", 2],
["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
["IIO_DEV_ATTR_[A-Z_]+", 1],
["SENSOR_(?:DEVICE_|)ATTR_2", 2],
["SENSOR_TEMPLATE(?:_2|)", 3],
["__ATTR", 2],
);

my $word_pattern = '\b[A-Z]?[a-z]{2,}\b';

#Create a search pattern for all these functions to speed up a loop below
our $mode_perms_search = "";
foreach my $entry (@mode_permission_funcs) {
$mode_perms_search .= '|' if ($mode_perms_search ne "");
$mode_perms_search .= $entry->[0];
}
$mode_perms_search = "(?:${mode_perms_search})";

our %deprecated_apis = (
"kmap"     => "kmap_local_page",
"kunmap"    => "kunmap_local",
"kmap_atomic"    => "kmap_local_page",
"kunmap_atomic"    => "kunmap_local",
);

#Create a search pattern for all these strings to speed up a loop below
our $deprecated_apis_search = "";
foreach my $entry (keys %deprecated_apis) {
$deprecated_apis_search .= '|' if ($deprecated_apis_search ne "");
$deprecated_apis_search .= $entry;
}
$deprecated_apis_search = "(?:${deprecated_apis_search})";

our $mode_perms_world_writable = qr{
S_IWUGO  |
S_IWOTH  |
S_IRWXUGO |
S_IALLUGO |
0[0-7][0-7][2367]
}x;

our %mode_permission_string_types = (
"S_IRWXU" => 0700,
"S_IRUSR" => 0400,
"S_IWUSR" => 0200,
"S_IXUSR" => 0100,
"S_IRWXG" => 0070,
"S_IRGRP" => 0040,
"S_IWGRP" => 0020,
"S_IXGRP" => 0010,
"S_IRWXO" => 0007,
"S_IROTH" => 0004,
"S_IWOTH" => 0002,
"S_IXOTH" => 0001,
"S_IRWXUGO" => 0777,
"S_IRUGO" => 0444,
"S_IWUGO" => 0222,
"S_IXUGO" => 0111,
);

#Create a search pattern for all these strings to speed up a loop below
our $mode_perms_string_search = "";
foreach my $entry (keys %mode_permission_string_types) {
$mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
$mode_perms_string_search .= $entry;
}
our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
our $multi_mode_perms_string_search = qr{
${single_mode_perms_string_search}
(?:\s*\|\s*${single_mode_perms_string_search})*
}x;

sub perms_to_octal {
my ($string) = @_;

return trim($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);

my $val = "";
my $oval = "";
my $to = 0;
my $curpos = 0;
my $lastpos = 0;
while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
  $curpos = pos($string);
  my $match = $2;
  my $omatch = $1;
  last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
  $lastpos = $curpos;
  $to |= $mode_permission_string_types{$match};
  $val .= '\s*\|\s*' if ($val ne "");
  $val .= $match;
  $oval .= $omatch;
}
$oval =~ s/^\s*\|\s*//;
$oval =~ s/\s*\|\s*$//;
return sprintf("%04o", $to);
}

our $allowed_asm_includes = qr{(?x:
irq|
memory|
time|
reboot
)};
# memory.h: ARM has a custom one

# Load common spelling mistakes and build regular expression list.
my $misspellings;
my %spelling_fix;

if (open(my $spelling, '<', $spelling_file)) {
while (<$spelling>) {
  my $line = $_;

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

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

  my ($suspect, $fix) = split(/\|\|/, $line);

  $spelling_fix{$suspect} = $fix;
}
close($spelling);
} else {
warn "No typos will be found - file '$spelling_file': $!\n";
}

if ($codespell) {
if (open(my $spelling, '<', $codespellfile)) {
  while (<$spelling>) {
   my $line = $_;

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

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

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

   my ($suspect, $fix) = split(/->/, $line);

   $spelling_fix{$suspect} = $fix;
  }
  close($spelling);
} else {
  warn "No codespell typos will be found - file '$codespellfile': $!\n";
}
}

$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;

sub read_words {
my ($wordsRef, $file) = @_;

if (open(my $words, '<', $file)) {
  while (<$words>) {
   my $line = $_;

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

   next if ($line =~ m/^\s*#/);
   next if ($line =~ m/^\s*$/);
   if ($line =~ /\s/) {
    print("$file: '$line' invalid - ignored\n");
    next;
   }

   $$wordsRef .= '|' if (defined $$wordsRef);
   $$wordsRef .= $line;
  }
  close($file);
  return 1;
}

return 0;
}

my $const_structs;
if (show_type("CONST_STRUCT")) {
read_words(\$const_structs, $conststructsfile)
     or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
}

if (defined($typedefsfile)) {
my $typeOtherTypedefs;
read_words(\$typeOtherTypedefs, $typedefsfile)
     or warn "No additional types will be considered - file '$typedefsfile': $!\n";
$typeTypedefs .= '|' . $typeOtherTypedefs if (defined $typeOtherTypedefs);
}

sub build_types {
my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
$Modifier = qr{(?:$Attribute|$Sparse|$mods)};
$BasicType = qr{
    (?:$typeTypedefs\b)|
    (?:${all}\b)
  }x;
$NonptrType = qr{
   (?:$Modifier\s+|const\s+)*
   (?:
    (?:typeof|__typeof__)\s*$[^$]*\)|
    (?:$typeTypedefs\b)|
    (?:${all}\b)
   )
   (?:\s+$Modifier|\s+const)*
    }x;
$NonptrTypeMisordered = qr{
   (?:$Modifier\s+|const\s+)*
   (?:
    (?:${Misordered}\b)
   )
   (?:\s+$Modifier|\s+const)*
    }x;
$NonptrTypeWithAttr = qr{
   (?:$Modifier\s+|const\s+)*
   (?:
    (?:typeof|__typeof__)\s*$[^$]*\)|
    (?:$typeTypedefs\b)|
    (?:${allWithAttr}\b)
   )
   (?:\s+$Modifier|\s+const)*
    }x;
$Type = qr{
   $NonptrType
   (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
   (?:\s+$Inline|\s+$Modifier)*
    }x;
$TypeMisordered = qr{
   $NonptrTypeMisordered
   (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
   (?:\s+$Inline|\s+$Modifier)*
    }x;
$Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
$DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
}
build_types();

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

# Using $balanced_parens, $LvalOrFunc, or $FuncArg
# requires at least perl version v5.10.0
# Any use must be runtime checked with $^V

our $balanced_parens = qr/($(?:[^\($]++|(?-1))*\))/;
our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};

our $declaration_macros = qr{(?x:
(?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*$|
(?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
(?:SKCIPHER_REQUEST|SHASH_DESC|AHASH_REQUEST)_ON_STACK\s*\(|
(?:$Storage\s+)?(?:XA_STATE|XA_STATE_ORDER)\s*\(
)};

our %allow_repeated_words = (
add => '',
added => '',
bad => '',
be => '',
);

sub deparenthesize {
my ($string) = @_;
return "" if (!defined($string));

while ($string =~ /^\s*\(.*$\s*$/) {
  $string =~ s@^\s*$\s*@@;
  $string =~ s@\s*$\s*$@@;
}

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

return $string;
}

sub seed_camelcase_file {
my ($file) = @_;

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

local $/;

open(my $include_file, '<', "$file")
     or warn "$P: Can't read '$file' $!\n";
my $text = <$include_file>;
close($include_file);

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

foreach my $line (@lines) {
  next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
  if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
   $camelcase{$1} = 1;
  } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
   $camelcase{$1} = 1;
  } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
   $camelcase{$1} = 1;
  }
}
}

our %maintained_status = ();

sub is_maintained_obsolete {
my ($filename) = @_;

return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));

if (!exists($maintained_status{$filename})) {
  $maintained_status{$filename} = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
}

return $maintained_status{$filename} =~ /obsolete/i;
}

sub is_SPDX_License_valid {
my ($license) = @_;

return 1 if (!$tree || which("python3") eq "" || !(-x "$root/scripts/spdxcheck.py") || !(-e "$gitroot"));

my $root_path = abs_path($root);
my $status = `cd "$root_path"; echo "$license" | scripts/spdxcheck.py -`;
return 0 if ($status ne "");
return 1;
}

my $camelcase_seeded = 0;
sub seed_camelcase_includes {
return if ($camelcase_seeded);

my $files;
my $camelcase_cache = "";
my @include_files = ();

$camelcase_seeded = 1;

if (-e "$gitroot") {
  my $git_last_include_commit = `${git_command} log --no-merges --pretty=format:"%h%n" -1 -- include`;
  chomp $git_last_include_commit;
  $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
} else {
  my $last_mod_date = 0;
  $files = `find $root/include -name "*.h"`;
  @include_files = split('\n', $files);
  foreach my $file (@include_files) {
   my $date = POSIX::strftime("%Y%m%d%H%M",
         localtime((stat $file)[9]));
   $last_mod_date = $date if ($last_mod_date < $date);
  }
  $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
}

if ($camelcase_cache ne "" && -f $camelcase_cache) {
  open(my $camelcase_file, '<', "$camelcase_cache")
      or warn "$P: Can't read '$camelcase_cache' $!\n";
  while (<$camelcase_file>) {
   chomp;
   $camelcase{$_} = 1;
  }
  close($camelcase_file);

  return;
}

if (-e "$gitroot") {
  $files = `${git_command} ls-files "include/*.h"`;
  @include_files = split('\n', $files);
}

foreach my $file (@include_files) {
  seed_camelcase_file($file);
}

if ($camelcase_cache ne "") {
  unlink glob ".checkpatch-camelcase.*";
  open(my $camelcase_file, '>', "$camelcase_cache")
      or warn "$P: Can't write '$camelcase_cache' $!\n";
  foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
   print $camelcase_file ("$_\n");
  }
  close($camelcase_file);
}
}

sub git_is_single_file {
my ($filename) = @_;

return 0 if ((which("git") eq "") || !(-e "$gitroot"));

my $output = `${git_command} ls-files -- $filename 2>/dev/null`;
my $count = $output =~ tr/\n//;
return $count eq 1 && $output =~ m{^${filename}$};
}

sub git_commit_info {
my ($commit, $id, $desc) = @_;

return ($id, $desc) if ((which("git") eq "") || !(-e "$gitroot"));

my $output = `${git_command} log --no-color --format='%H %s' -1 $commit 2>&1`;
$output =~ s/^\s*//gm;
my @lines = split("\n", $output);

return ($id, $desc) if ($#lines < 0);

if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous/) {
# Maybe one day convert this block of bash into something that returns
# all matching commit ids, but it's very slow...
#
# echo "checking commits $1..."
# git rev-list --remotes | grep -i "^$1" |
# while read line ; do
#     git log --format='%H %s' -1 $line |
#     echo "commit $(cut -c 1-12,41-)"
# done
} elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./ ||
   $lines[0] =~ /^fatal: bad object $commit/) {
  $id = undef;
} else {
  $id = substr($lines[0], 0, 12);
  $desc = substr($lines[0], 41);
}

return ($id, $desc);
}

$chk_signoff = 0 if ($file);
$chk_fixes_tag = 0 if ($file);

my @rawlines = ();
my @lines = ();
my @fixed = ();
my @fixed_inserted = ();
my @fixed_deleted = ();
my $fixlinenr = -1;

# If input is git commits, extract all commits from the commit expressions.
# For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
die "$P: No git repository found\n" if ($git && !-e "$gitroot");

if ($git) {
my @commits = ();
foreach my $commit_expr (@ARGV) {
  my $git_range;
  if ($commit_expr =~ m/^(.*)-(\d+)$/) {
   $git_range = "-$2 $1";
  } elsif ($commit_expr =~ m/\.\./) {
   $git_range = "$commit_expr";
  } else {
   $git_range = "-1 $commit_expr";
  }
  my $lines = `${git_command} log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
  foreach my $line (split(/\n/, $lines)) {
   $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
   next if (!defined($1) || !defined($2));
   my $sha1 = $1;
   my $subject = $2;
   unshift(@commits, $sha1);
   $git_commits{$sha1} = $subject;
  }
}
die "$P: no git commits after extraction!\n" if (@commits == 0);
@ARGV = @commits;
}

my $vname;
$allow_c99_comments = !defined $ignore_type{"C99_COMMENT_TOLERANCE"};
for my $filename (@ARGV) {
my $FILE;
my $is_git_file = git_is_single_file($filename);
my $oldfile = $file;
$file = 1 if ($is_git_file);
if ($git) {
  open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
   die "$P: $filename: git format-patch failed - $!\n";
} elsif ($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';
} elsif ($git) {
  $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
} else {
  $vname = $filename;
}
while (<$FILE>) {
  chomp;
  push(@rawlines, $_);
  $vname = qq("$1") if ($filename eq '-' && $_ =~ m/^Subject:\s+(.+)/i);
}
close($FILE);

if ($#ARGV > 0 && $quiet == 0) {
  print '-' x length($vname) . "\n";
  print "$vname\n";
  print '-' x length($vname) . "\n";
}

if (!process($filename)) {
  $exit = 1;
}
@rawlines = ();
@lines = ();
@fixed = ();
@fixed_inserted = ();
@fixed_deleted = ();
$fixlinenr = -1;
@modifierListFile = ();
@typeListFile = ();
build_types();
$file = $oldfile if ($is_git_file);
}

if (!$quiet) {
hash_show_words(\%use_type, "Used");
hash_show_words(\%ignore_type, "Ignored");

if (!$perl_version_ok) {
  print << "EOM"

NOTE: perl $^V is not modern enough to detect all possible issues.
      An upgrade to at least perl $minimum_perl_version is suggested.
EOM
}
if ($exit) {
  print << "EOM"

NOTE: If any of the errors are false positives, please report
      them to the maintainer, see CHECKPATCH in MAINTAINERS.
EOM
}
}

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 parse_email {
my ($formatted_email) = @_;

my $name = "";
my $quoted = "";
my $name_comment = "";
my $address = "";
my $comment = "";

if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
  $name = $1;
  $address = $2;
  $comment = $3 if defined $3;
} elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
  $address = $1;
  $comment = $2 if defined $2;
} elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
  $address = $1;
  $comment = $2 if defined $2;
  $formatted_email =~ s/\Q$address\E.*$//;
  $name = $formatted_email;
  $name = trim($name);
  $name =~ s/^\"|\"$//g;
  # If there's a name left after stripping spaces and
  # leading quotes, and the address doesn't have both
  # leading and trailing angle brackets, the address
  # is invalid. ie:
  #   "joe smith joe@smith.com" bad
  #   "joe smith <joe@smith.com" bad
  if ($name ne "" && $address !~ /^<[^>]+>$/) {
   $name = "";
   $address = "";
   $comment = "";
  }
}

# Extract comments from names excluding quoted parts
# "John D. (Doe)" - Do not extract
if ($name =~ s/\"(.+)\"//) {
  $quoted = $1;
}
while ($name =~ s/\s*($balanced_parens)\s*/ /) {
  $name_comment .= trim($1);
}
$name =~ s/^[ \"]+|[ \"]+$//g;
$name = trim("$quoted $name");

$address = trim($address);
$address =~ s/^\<|\>$//g;
$comment = trim($comment);

if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
  $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
  $name = "\"$name\"";
}

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

sub format_email {
my ($name, $name_comment, $address, $comment) = @_;

my $formatted_email;

$name =~ s/^[ \"]+|[ \"]+$//g;
$address = trim($address);
$address =~ s/(?:\.|\,|\")+$//; ##trailing commas, dots or quotes

if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
  $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
  $name = "\"$name\"";
}

$name_comment = trim($name_comment);
$name_comment = " $name_comment" if ($name_comment ne "");
$comment = trim($comment);
$comment = " $comment" if ($comment ne "");

if ("$name" eq "") {
  $formatted_email = "$address";
} else {
  $formatted_email = "$name$name_comment <$address>";
}
$formatted_email .= "$comment";
return $formatted_email;
}

sub reformat_email {
my ($email) = @_;

my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
return format_email($email_name, $name_comment, $email_address, $comment);
}

sub same_email_addresses {
my ($email1, $email2) = @_;

my ($email1_name, $name1_comment, $email1_address, $comment1) = parse_email($email1);
my ($email2_name, $name2_comment, $email2_address, $comment2) = parse_email($email2);

return $email1_name eq $email2_name &&
        $email1_address eq $email2_address &&
        $name1_comment eq $name2_comment &&
        $comment1 eq $comment2;
}

sub which {
my ($bin) = @_;

foreach my $path (split(/:/, $ENV{PATH})) {
  if (-e "$path/$bin") {
   return "$path/$bin";
  }
}

return "";
}

sub which_conf {
my ($conf) = @_;

foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
  if (-e "$path/$conf") {
   return "$path/$conf";
  }
}

return "";
}

sub expand_tabs {
my ($str) = @_;

my $res = '';
my $n = 0;
for my $c (split(//, $str)) {
  if ($c eq "\t") {
   $res .= ' ';
   $n++;
   for (; ($n % $tabsize) != 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 whacking completely 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@;
}

if ($allow_c99_comments && $res =~ m@(//.*$)@) {
  my $match = $1;
  $res =~ s/\Q$match\E/"$;" x length($match)/e;
}

return $res;
}

sub get_quoted_string {
my ($line, $rawline) = @_;

return "" if (!defined($line) || !defined($rawline));
return "" if ($line !~ m/($String)/g);
return substr($rawline, $-[0], $+[0] - $-[0]);
}

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;
   }
   if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
    $level++;
    $type = '#';
   }
  }
  $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;
   }
  }
  # Preprocessor commands end at the newline unless escaped.
  if ($type eq '#' && $c eq "\n" && $p ne "\\") {
   $level--;
   $type = '';
   $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 ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
   push(@stack, $level);
  } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
   $level = $stack[$#stack - 1];
  } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
   $level = pop(@stack);
  }

  foreach my $c (split(//, $lines[$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) = @_;

# If c99 comment on the current line, or the line before or after
my ($current_comment) = ($rawlines[$end_line - 1] =~ m@^\+.*(//.*$)@);
return $current_comment if (defined $current_comment);
($current_comment) = ($rawlines[$end_line - 2] =~ m@^[\+ ].*(//.*$)@);
return $current_comment if (defined $current_comment);
($current_comment) = ($rawlines[$end_line] =~ m@^[\+ ].*(//.*$)@);
return $current_comment if (defined $current_comment);

# Catch a comment on the end of the line itself.
($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 get_stat_real {
my ($linenr, $lc) = @_;

my $stat_real = raw_line($linenr, 0);
for (my $count = $linenr + 1; $count <= $lc; $count++) {
  $stat_real = $stat_real . "\n" . raw_line($count, 0);
}

return $stat_real;
}

sub get_stat_here {
my ($linenr, $cnt, $here) = @_;

my $herectx = $here . "\n";
for (my $n = 0; $n < $cnt; $n++) {
  $herectx .= raw_line($linenr, $n) . "\n";
}

return $herectx;
}

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*)$/ && $av_pending eq '_') {
   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(@modifierListFile, $modifier);
    }
   }

  } else {
   warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
   push(@typeListFile, $possible);
  }
  build_types();
} else {
  warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
}
}

my $prefix = '';

sub show_type {
my ($type) = @_;

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

return defined $use_type{$type} if (scalar keys %use_type > 0);

return !defined $ignore_type{$type};
}

sub report {
my ($level, $type, $msg) = @_;

if (!show_type($type) ||
     (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
  return 0;
}
my $output = '';
if ($color) {
  if ($level eq 'ERROR') {
   $output .= RED;
  } elsif ($level eq 'WARNING') {
   $output .= YELLOW;
  } else {
   $output .= GREEN;
  }
}
$output .= $prefix . $level . ':';
if ($show_types) {
  $output .= BLUE if ($color);
  $output .= "$type:";
}
$output .= RESET if ($color);
$output .= ' ' . $msg . "\n";

if ($showfile) {
  my @lines = split("\n", $output, -1);
  splice(@lines, 1, 1);
  $output = join("\n", @lines);
}

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

if ($verbose && exists($verbose_messages{$type}) &&
     !exists($verbose_emitted{$type})) {
  $output .= $verbose_messages{$type} . "\n\n";
  $verbose_emitted{$type} = 1;
}

push(our @report, $output);

return 1;
}

sub report_dump {
our @report;
}

sub fixup_current_range {
my ($lineRef, $offset, $length) = @_;

if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
  my $o = $1;
  my $l = $2;
  my $no = $o + $offset;
  my $nl = $l + $length;
  $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
}
}

sub fix_inserted_deleted_lines {
my ($linesRef, $insertedRef, $deletedRef) = @_;

my $range_last_linenr = 0;
my $delta_offset = 0;

my $old_linenr = 0;
my $new_linenr = 0;

my $next_insert = 0;
my $next_delete = 0;

my @lines = ();

my $inserted = @{$insertedRef}[$next_insert++];
my $deleted = @{$deletedRef}[$next_delete++];

foreach my $old_line (@{$linesRef}) {
  my $save_line = 1;
  my $line = $old_line; #don't modify the array
  if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
   $delta_offset = 0;
  } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
   $range_last_linenr = $new_linenr;
   fixup_current_range(\$line, $delta_offset, 0);
  }

  while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
   $deleted = @{$deletedRef}[$next_delete++];
   $save_line = 0;
   fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
  }

  while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
   push(@lines, ${$inserted}{'LINE'});
   $inserted = @{$insertedRef}[$next_insert++];
   $new_linenr++;
   fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
  }

  if ($save_line) {
   push(@lines, $line);
   $new_linenr++;
  }

  $old_linenr++;
}

return @lines;
}

sub fix_insert_line {
my ($linenr, $line) = @_;

my $inserted = {
  LINENR => $linenr,
  LINE => $line,
};
push(@fixed_inserted, $inserted);
}

sub fix_delete_line {
my ($linenr, $line) = @_;

my $deleted = {
  LINENR => $linenr,
  LINE => $line,
};

push(@fixed_deleted, $deleted);
}

sub ERROR {
my ($type, $msg) = @_;

if (report("ERROR", $type, $msg)) {
  our $clean = 0;
  our $cnt_error++;
  return 1;
}
return 0;
}
sub WARN {
my ($type, $msg) = @_;

if (report("WARNING", $type, $msg)) {
  our $clean = 0;
  our $cnt_warn++;
  return 1;
}
return 0;
}
sub CHK {
my ($type, $msg) = @_;

if ($check && report("CHECK", $type, $msg)) {
  our $clean = 0;
  our $cnt_chk++;
  return 1;
}
return 0;
}

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_PATH",
       "use relative pathname instead of absolute in changelog text\n" . $herecurr);
}
}

sub trim {
my ($string) = @_;

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

return $string;
}

sub ltrim {
my ($string) = @_;

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

return $string;
}

sub rtrim {
my ($string) = @_;

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

return $string;
}

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

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

return $string;
}

sub tabify {
my ($leading) = @_;

my $source_indent = $tabsize;
my $max_spaces_before_tab = $source_indent - 1;
my $spaces_to_tab = " " x $source_indent;

#convert leading spaces to tabs
1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
#Remove spaces before a tab
1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;

return "$leading";
}

sub pos_last_openparen {
my ($line) = @_;

my $pos = 0;

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

my $last_openparen = 0;

if (($opens == 0) || ($closes >= $opens)) {
  return -1;
}

my $len = length($line);

for ($pos = 0; $pos < $len; $pos++) {
  my $string = substr($line, $pos);
  if ($string =~ /^($FuncArg|$balanced_parens)/) {
   $pos += length($1) - 1;
  } elsif (substr($line, $pos, 1) eq '(') {
   $last_openparen = $pos;
  } elsif (index($string, '(') == -1) {
   last;
  }
}

return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
}

sub get_raw_comment {
my ($line, $rawline) = @_;
my $comment = '';

for my $i (0 .. (length($line) - 1)) {
  if (substr($line, $i, 1) eq "$;") {
   $comment .= substr($rawline, $i, 1);
  }
}

return $comment;
}

sub exclude_global_initialisers {
my ($realfile) = @_;

# Do not check for BPF programs (tools/testing/selftests/bpf/progs/*.c, samples/bpf/*_kern.c, *.bpf.c).
return $realfile =~ m@^tools/testing/selftests/bpf/progs/.*\.c$@ ||
  $realfile =~ m@^samples/bpf/.*_kern\.c$@ ||
  $realfile =~ m@/bpf/.*\.bpf\.c$@;
}

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 $fixes_tag = 0;
my $is_revert = 0;
my $needs_fixes_tag = "";
my $author = '';
my $authorsignoff = 0;
my $author_sob = '';
my $is_patch = 0;
my $is_binding_patch = -1;
my $in_header_lines = $file ? 0 : 1;
my $in_commit_log = 0;  #Scanning lines before patch
my $has_patch_separator = 0; #Found a --- line
my $has_commit_log = 0;  #Encountered lines before patch
my $commit_log_lines = 0; #Number of commit log lines
my $commit_log_possible_stack_dump = 0;
my $commit_log_long_line = 0;
my $commit_log_has_diff = 0;
my $reported_maintainer_file = 0;
my $non_utf8_charset = 0;

my $last_git_commit_id_linenr = -1;

my $last_blank_line = 0;
my $last_coalesced_string_linenr = -1;

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 $context_function;  #undef'd unless there's a known function
my $in_comment = 0;
my $comment_edge = 0;
my $first_line = 0;
--> --------------------

--> maximum size reached

--> --------------------

quality83%

¤ Dauer der Verarbeitung: 0.34 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.