checkpatch: fix path of documentation

[fw/openocd] / tools / scripts / checkpatch.pl

diff --git a/tools/scripts/checkpatch.pl b/tools/scripts/checkpatch.pl
index 9ef94ff43d1b1b3fb987ecde2a219d80e619c3d0..10b0b8c257697a36d562e78cc2225b49db7c2f2e 100755 (executable)
--- a/tools/scripts/checkpatch.pl
+++ b/tools/scripts/checkpatch.pl
@@ -78,7 +78,12 @@ my $codespell = 0;
 my $codespellfile = "/usr/share/codespell/dictionary.txt";
 my $user_codespellfile = "";
 my $conststructsfile = "$D/const_structs.checkpatch";
+if (!$OpenOCD) {
 my $docsfile = "$D/../Documentation/dev-tools/checkpatch.rst";
+} # !$OpenOCD
+# OpenOCD Specific: Begin
+my $docsfile = "$D/../../doc/checkpatch.rst";
+# OpenOCD Specific: End
 my $typedefsfile;
 my $color = "auto";
 my $allow_c99_comments = 1; # Can be overridden by --ignore C99_COMMENT_TOLERANCE
@@ -988,6 +993,32 @@ sub read_words {
        return 0;
 }
 
+# OpenOCD specific: Begin: Load list of allowed CamelCase symbols
+if (show_type("CAMELCASE")) {
+       my $allowed_camelcase_file = "$root/tools/scripts/camelcase.txt";
+       if (open(my $words, '<', $allowed_camelcase_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("$allowed_camelcase_file: '$line' invalid - ignored\n");
+                               next;
+                       }
+
+                       $camelcase{$line} = 1;
+               }
+               close($allowed_camelcase_file);
+       } else {
+               warn "No camelcase symbols to ignore - file '$allowed_camelcase_file': $!\n";
+       }
+}
+# OpenOCD specific: End
+
 my $const_structs;
 if (show_type("CONST_STRUCT")) {
        read_words(\$const_structs, $conststructsfile)
@@ -1104,6 +1135,7 @@ sub seed_camelcase_file {
        my @lines = split('\n', $text);
 
        foreach my $line (@lines) {
+               if (!$OpenOCD) {
                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;
@@ -1112,6 +1144,17 @@ sub seed_camelcase_file {
                } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
                        $camelcase{$1} = 1;
                }
+               } # !$OpenOCD
+               # OpenOCD Specific: Begin: extend to camel[0-9_]*CASE
+               next if ($line !~ /(?:[A-Z][0-9_]*[a-z]|[a-z][0-9_]*[A-Z])/);
+               if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][0-9_]*[a-z]|[a-z][0-9_]*[A-Z])\w*)/) {
+                       $camelcase{$1} = 1;
+               } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][0-9_]*[a-z]|[a-z][0-9_]*[A-Z])\w*)\s*[\(\[,;]/) {
+                       $camelcase{$1} = 1;
+               } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][0-9_]*[a-z]|[a-z][0-9_]*[A-Z])\w*)\s*[;\{]/) {
+                       $camelcase{$1} = 1;
+               }
+               # OpenOCD Specific: End
        }
 }
 
@@ -1132,10 +1175,12 @@ sub is_maintained_obsolete {
 sub is_SPDX_License_valid {
        my ($license) = @_;
 
-       return 1 if (!$tree || which("python3") eq "" || !(-x "$root/scripts/spdxcheck.py") || !(-e "$gitroot"));
+       # OpenOCD specific: Begin: replace s"scripts"tools/scripts"
+       return 1 if (!$tree || which("python3") eq "" || !(-x "$root/tools/scripts/spdxcheck.py") || !(-e "$gitroot"));
 
        my $root_path = abs_path($root);
-       my $status = `cd "$root_path"; echo "$license" | scripts/spdxcheck.py -`;
+       my $status = `cd "$root_path"; echo "$license" | tools/scripts/spdxcheck.py -`;
+       # OpenOCD specific: End
        return 0 if ($status ne "");
        return 1;
 }
@@ -3009,6 +3054,13 @@ sub process {
                        }
                }
 
+# OpenOCD specific: Begin: Extend list of checkpatch tests to ignore
+               if ($in_commit_log && $line =~ /^\s*Checkpatch-ignore:\s*(.*)/) {
+                       my @array = split(/[\s,]+/, $1);
+                       hash_save_array_words(\%ignore_type, \@array);
+               }
+# OpenOCD specific: End
+
 # Check for patch separator
                if ($line =~ /^---$/) {
                        $has_patch_separator = 1;
@@ -3669,6 +3721,10 @@ sub process {
                                        $comment = '#';
                                } elsif ($realfile =~ /\.rst$/) {
                                        $comment = '..';
+                               # OpenOCD specific: Begin
+                               } elsif ($realfile =~ /\.(am|cfg|tcl)$/) {
+                                       $comment = '#';
+                               # OpenOCD specific: End
                                }
 
 # check SPDX comment style for .[chsS] files
@@ -4232,7 +4288,9 @@ sub process {
 
                        my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
 
-                       if ($line =~ /^\+\t{6,}/) {
+                       # OpenOCD specific: Begin: replace s/6/10/
+                       if ($line =~ /^\+\t{10,}/) {
+                       # OpenOCD specific: End
                                WARN("DEEP_INDENTATION",
                                     "Too many leading tabs - consider code refactoring\n" . $herecurr);
                        }
@@ -5757,6 +5815,7 @@ sub process {
                        my $var = $1;
 
 #CamelCase
+                       if (!$OpenOCD) {
                        if ($var !~ /^$Constant$/ &&
                            $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
 #Ignore some autogenerated defines and enum values
@@ -5768,9 +5827,24 @@ sub process {
                            $var !~ /^(?:[a-z0-9_]*|[A-Z0-9_]*)?_?[a-z][A-Z](?:_[a-z0-9_]+|_[A-Z0-9_]+)?$/ &&
 #Ignore some three character SI units explicitly, like MiB and KHz
                            $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
+                       }
+                       } # !$OpenOCD
+                       # OpenOCD Specific: Begin: remove Linux exceptions, extend to camel[0-9_]*CASE
+                       if ($var !~ /^$Constant$/ &&
+                           $var =~ /[A-Z][0-9_]*[a-z]|[a-z][0-9_]*[A-Z]/) {
+                       # OpenOCD Specific: End
                                while ($var =~ m{\b($Ident)}g) {
                                        my $word = $1;
+                                       if (!$OpenOCD) {
                                        next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
+                                       } # !$OpenOCD
+                                       # OpenOCD Specific: Begin: extend to camel[0-9_]*CASE
+                                       next if ($word !~ /[A-Z][0-9_]*[a-z]|[a-z][0-9_]*[A-Z]/);
+                                       # OpenOCD Specific: End
+                                       if (!$OpenOCD) {
+                                       # This will not work for OpenOCD jenkins because it runs
+                                       # checkpatch from a tree already patched. Any new camelcase
+                                       # in include file will be ignored as it was pre-existing.
                                        if ($check) {
                                                seed_camelcase_includes();
                                                if (!$file && !$camelcase_file_seeded) {
@@ -5778,6 +5852,7 @@ sub process {
                                                        $camelcase_file_seeded = 1;
                                                }
                                        }
+                                       } # !$OpenOCD
                                        if (!defined $camelcase{$word}) {
                                                $camelcase{$word} = 1;
                                                CHK("CAMELCASE",