OpenPKG Specs: openpkg/lint-spec.pl@a2c6460cfb16 (annotated)

openpkg/lint-spec.pl@a2c6460cfb16 (annotated)

openpkg/lint-spec.pl

Mon, 28 Jan 2013 17:37:18 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Mon, 28 Jan 2013 17:37:18 +0100
changeset 758: a2c6460cfb16
permissions: -rw-r--r--

Correct socket error reporting improvement with IPv6 portable code,
after helpful recommendation by Saúl Ibarra Corretgé on OSips devlist.

 ##
 ##  lint-spec.pl -- OpenPKG *.spec File Checker
 ##  Copyright (c) 2000-2012 OpenPKG GmbH <http://openpkg.com/>
 ##
 ##  This software is property of the OpenPKG GmbH, DE MUC HRB 160208.
 ##  All rights reserved. Licenses which grant limited permission to use,
 ##  copy, modify and distribute this software are available from the
 ##  OpenPKG GmbH.
 ##
 ##  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 ##  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 ##  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 ##  IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
 ##  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 ##  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 ##  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 ##  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 ##  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 ##  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 ##  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 ##  SUCH DAMAGE.
 ##
 #   Perl run-time requirement
 require 5;
 BEGIN {
     eval "use Getopt::Long; use IO;";
     if ($@) {
         print STDERR
             "lint-spec: ERROR: This command requires a full-size Perl installation!\n" .
             "lint-spec: HINT:  Install OpenPKG \"perl\" package to use this command.\n";
         exit(1);
     }
 }
 #   OpenPKG instance prefix
 my $my_prefix = $ENV{'OPENPKG_PREFIX'};
 delete $ENV{'OPENPKG_PREFIX'};
 #   program information
 my $progname = "lint-spec";
 my $progvers = "1.0.0";
 #   parameters (defaults)
 my $version = 0;
 my $verbose = 0;
 my $help    = 0;
 my $check   = 'all';
 my $tmpdir  = ($ENV{TMPDIR} || $ENV{TEMPDIR} || "/tmp") . "/$progname";
 my $rpm     = "$my_prefix/bin/openpkg rpm";
 #   exception handling support
 $SIG{__DIE__} = sub {
     my ($err) = @_;
     $err =~ s|\s+at\s+.*||s if (not $verbose);
     print STDERR "$progname:ERROR: $err ". ($! ? "($!)" : "") . "\n";
     exit(1);
 };
 #   command line parsing
 Getopt::Long::Configure("bundling");
 my $result = GetOptions(
     'V|version'     => \$version,
     'v|verbose'     => \$verbose,
     'h|help'        => \$help,
     'c|check=s'     => \$check,
     't|tmpdir=s'    => \$tmpdir,
     'r|rpm=s'       => \$rpm,
 ) || die "option parsing failed";
 if ($help) {
     print "Usage: $progname [options] [SPECFILE ...]\n" .
           "Available options:\n" .
           " -v,--verbose       enable verbose run-time mode\n" .
           " -h,--help          print out this usage page\n" .
           " -c,--check=CHECKS  select checks to perform (default='all')\n" .
           " -r,--rpm=FILE      filesystem path to RPM program\n" .
           " -t,--tmpdir=PATH   filesystem path to temporary directory\n" .
           " -V,--version       print program version\n";
     exit(0);
 }
 if ($version) {
     print "OpenPKG $progname $progvers\n";
     exit(0);
 }
 #   verbose message printing
 sub msg_verbose {
     my ($msg) = @_;
     print STDERR "$msg\n" if ($verbose);
 }
 #   warning message printing
 sub msg_warning {
     my ($msg) = @_;
     print STDERR "$progname:WARNING: $msg\n";
 }
 #   error message printing
 sub msg_error {
     my ($msg) = @_;
     print STDERR "$progname:ERROR: $msg\n";
 }
 #   determine check list
 my @check_list = (qw(
     blank
     comment
     license
     header
     section
     preproc
     script
     global
     sources
     digest
 ));
 my @checks = ();
 if ($check eq 'all') {
     @checks = @check_list;
 }
 else {
     foreach my $c (split(/,/, $check)) {
         if (not grep($c, @check_list)) {
             die "invalid check \"$c\"";
         }
         push(@checks, $c);
     }
 }
 #   global return code
 $main::GRC = 0;
 #   iterate over all .spec files
 foreach my $filename (@ARGV) {
     my $io = new IO::File "<$filename"
         or die "unable to open file \"$filename\" for reading";
     my $spec; { local $/ = undef; $spec = <$io>; }
     $io->close;
     foreach my $check (@checks) {
         eval "\&check_$check(\$filename, \$spec);";
     }
 }
 #   die gracefully
 exit($main::GRC);
 ##  _________________________________________________________________
 ##
 ##  COMMON SUBROUTINES
 ##  _________________________________________________________________
 ##
 sub lines {
     my ($txt) = @_;
     my $l = 0;
     $txt =~ s|\n|$l++, ''|sge;
     return $l;
 }
 sub lint_message {
     my ($type, $file, $done, $this, $msg) = @_;
     if (defined($done) and defined($this)) {
         my $start = &lines($done) + 1;
         my $end = $start + &lines($this);
         my $pos = $start;
         $pos .= "-". $end if ($end > $start);
         printf("%s:%s: %s:%s: %s\n", $progname, $type, $file, $pos, $msg);
     }
     else {
         printf("%s:%s: %s: %s\n", $progname, $type, $file, $msg);
     }
 }
 sub lint_warning {
     my ($file, $done, $this, $msg) = @_;
     &lint_message("WARNING", $file, $done, $this, $msg);
     $main::GRC = 1 if ($main::GRC < 1);
 }
 sub lint_error {
     my ($file, $done, $this, $msg) = @_;
     &lint_message("ERROR", $file, $done, $this, $msg);
     $main::GRC = 2 if ($main::GRC < 2);
 }
 ##  _________________________________________________________________
 ##
 ##  CHECK "blank": whitespace and blank lines
 ##  _________________________________________________________________
 ##
 sub check_blank {
     my ($file, $spec) = @_;
     #   check for CR-LF combination
     my $done = ''; my $this = ''; my $todo = $spec;
     while ($todo =~ m/\r\n/s) {
         $done .= $`; $this = $&; $todo = $';
         &lint_warning($file, $done, $this, "carriage-return (CR, 0x0d) line-feed (NL, 0x0a) combination (expected just line-feed)");
         $done .= $this;
     }
     #   check for multiple blank lines
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/(\r?\n[ \t]*){3,}/s) {
         $done .= $`; $this = $&; $todo = $';
         &lint_warning($file, $done, $this, "multiple subsequent blank lines (expected single blank line)");
         $done .= $this;
     }
     #   check for trailing whitespaces
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/[ \t]+\r?\n/s) {
         $done .= $`; $this = $&; $todo = $';
         if ($done eq '' or $done =~ m|\n$|s) {
             &lint_warning($file, $done, $this, "whitespace on empty line (expected none)");
         }
         else {
             &lint_warning($file, $done, $this, "trailing whitespace (expected none)");
         }
         $done .= $this;
     }
     #   check for bogus line continuations
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/\\[ \t]*\r?\n(?=[ \t]*\r?\n)/s) {
         $done .= $`; $this = $&; $todo = $';
         &lint_warning($file, $done, $this, "bogus line continuation for following empty line (expect no line continuation)");
         $done .= $this;
     }
     #   check for leading whitespaces before line continuations
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/[ \t]{2,}\\[ \t]*\r?\n/s) {
         $done .= $`; $this = $&; $todo = $';
         &lint_warning($file, $done, $this, "multiple leading whitespace before line continuation (expected just a single space)");
         $done .= $this;
     }
     #   check for leading tabs
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/^ *\t+ *[^ \t]/m) {
         $done .= $`; $this = $&; $todo = $';
         &lint_warning($file, $done, $this, "leading tabs (expected spaces)");
         $done .= $this;
     }
     #   check for mandatory/wished trailing blank line
     if ($spec !~ m|\n\n$|) {
         &lint_warning($file, $spec, "", "mandatory/wished trailing blank line missing (expected one)");
     }
 }
 ##  _________________________________________________________________
 ##
 ##  CHECK "comment": sharp-comments
 ##  _________________________________________________________________
 ##
 sub check_comment {
     my ($file, $spec) = @_;
     #   check for comment indentation and contents
     my $done = ''; my $this = ''; my $todo = $spec;
     while ($todo =~ m/^([ \t]*)(#+)([ \t]*)(.*?)$/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($lead, $sharp, $pad, $text) = ($1, $2, $3, $4);
         if (length($lead) % 2 != 0) {
             &lint_warning($file, $done, $this, "incorrect comment indentation (expected a multiple of 2 spaces)");
         }
         if (length($lead) > 1 && length($sharp) > 1) {
             &lint_warning($file, $done, $this, "indented comment has introduced with multiple sharps (expected single sharp character)");
         }
         if (length($pad.$text) > 0 && length($sharp.$pad) % 4 != 0) {
             &lint_warning($file, $done, $this, "incorrect comment text padding (expected a multiple of 4 sharps or spaces)");
         }
         if (length($pad) == 0 && length($text) > 0) {
             &lint_warning($file, $done, $this, "missing leading space before comment text (expected padding spaces)");
         }
         if (length($pad) > 0 && length($text) == 0) {
             &lint_warning($file, $done, $this, "empty comment text (expected a reasonable text)");
         }
         $done .= $this;
     }
     #   check for comment contents only
     if ($file !~ m|openpkg\.spec$|) {
         $done = ''; $this = ''; $todo = $spec;
         while ($todo =~ m/\n\n[ \t]*#[ \t]+([^\n]+)(?!\n([ \t]*#))/s) {
             $done .= $`; $this = $&; $todo = $';
             my $text = $1;
             if (length($text) > 0 and $text =~ m|^[A-Z][^A-Z]|) {
                 &lint_warning($file, $done, $this, "comment text starts with upper-case letter (expected lower-case letter)");
             }
             $done .= $this;
         }
     }
 }
 ##  _________________________________________________________________
 ##
 ##  CHECK "license": license header
 ##  _________________________________________________________________
 ##
 sub check_license {
     my ($file, $spec) = @_;
     my $name = "[a-z][a-z0-9-]*";
     if ($file =~ m|^.*/([a-z][a-z0-9-]*)\.spec$|) {
         $name = $1;
     }
     elsif ($file =~ m|^([a-z][a-z0-9-]*)\.spec$|) {
         $name = $1;
     }
     my $re = "";
     $re .= "##\\n";
     $re .= "##  $name\\.spec -- OpenPKG RPM Package Specification\\n";
     $re .= "##  Copyright \\(c\\) 200[0-9]-2012 OpenPKG Foundation e\.V\. <http://openpkg\\.net/>\\n";
     $re .= "##\\n";
     $re .= "##  Permission to use, copy, modify, and distribute this software for\\n";
     $re .= "##  any purpose with or without fee is hereby granted, provided that\\n";
     $re .= "##  the above copyright notice and this permission notice appear in all\\n";
     $re .= "##  copies\\.\\n";
     $re .= "##\\n";
     $re .= "##  THIS SOFTWARE IS PROVIDED \\`\\`AS IS'' AND ANY EXPRESSED OR IMPLIED\\n";
     $re .= "##  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\\n";
     $re .= "##  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED\\.\\n";
     $re .= "##  IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR\\n";
     $re .= "##  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\\n";
     $re .= "##  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES \\(INCLUDING, BUT NOT\\n";
     $re .= "##  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF\\n";
     $re .= "##  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION\\) HOWEVER CAUSED AND\\n";
     $re .= "##  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\\n";
     $re .= "##  OR TORT \\(INCLUDING NEGLIGENCE OR OTHERWISE\\) ARISING IN ANY WAY OUT\\n";
     $re .= "##  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\\n";
     $re .= "##  SUCH DAMAGE\\.\\n";
     $re .= "##\\n";
     if ($name ne "openpkg" and $spec !~ m|^$re|os) {
         &lint_warning($file, "", "", "invalid license header");
     }
 }
 ##  _________________________________________________________________
 ##
 ##  CHECK "header": RPM headers
 ##  _________________________________________________________________
 ##
 sub check_header {
     my ($file, $spec) = @_;
     my @headers = (qw(
         m:Name:^[a-z][a-z0-9-]*$
         m:Summary:^[A-Z]\S*(\s+([A-Z]\S*|of|for|from|in|at|on|\(\S+\)))*
         m:URL:^((https?|ftp)://.+|-)$
         m:Vendor:.+
         m:Packager:^(OpenPKG\sFoundation\se\.V\.|OpenPKG\sGmbH)$
         m:Distribution:^(OpenPKG|OpenPKG\sCommunity|OpenPKG\sEnterprise)$
         m:Class:^(BOOT|CORE|BASE|PLUS|EVAL|JUNK|PRIV)$
         m:Group:^[A-Z][a-zA-Z0-9]+$
         m:License:.+
         m:Version:^[^-]+$
         m:Release:^(E?([1-9]\.)?20[0-9][0-9](0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[01])|E?[1-9]\.[0-9]\.\d+|%\{[^\}]+\})$
         o:Source\d+:^((https?|ftp)://.+|[^/]+)$
         o:Patch\d+:^((https?|ftp)://.+|[^/]+)$
         o:Prefix:^%{l_prefix}$
         o:BuildRoot:^%{l_buildroot}$
         m:BuildPreReq:^(((,\s+)?digest\\(sha1:\%\{(SOURCE|PATCH)\d+\}\\)\s+=\s+[0-9a-fA-F]+)+|(OpenPKG,\sopenpkg\s>=\s\S+)?((,\s)?([a-z][a-z0-9-]*(\:\:with_[a-z][a-z0-9_]+)?|[A-Z][A-Z0-9-]*)(\s(>=?|==?|<=?|!=)\s\S+)?)+)$
         m:PreReq:^(OpenPKG,\sopenpkg\s>=\s\S+)?((,\s)?([a-z][a-z0-9-]*(\:\:with_[a-z][a-z0-9_]+)?|[A-Z][A-Z0-9-]*)(\s(>=?|==?|<=?|!=)\s\S+)?)+$
         o:AutoReq:^no$
         o:AutoReqProv:^no$
         o:Provides:^((,\s)?([a-z][a-z0-9-]*(\:\:with_[a-z][a-z0-9_]+)?|[A-Z][A-Z0-9-]*)(\s==?\s\S+)?)+$
         o:Conflicts:^((,\s)?([a-z][a-z0-9-]*(\:\:with_[a-z][a-z0-9_]+)?|[A-Z][A-Z0-9-]*)(\s(>=?|==?|<=?|!=)\s\S+)?)+$
     ));
     my @headers_def = (qw(
         Summary:^Badly\sPackaged\sProgram$
         Vendor:^John\sDoe$
         Group:^Unknown$
         License:^DoePL$
     ));
     my @headers_mult = (qw(
         BuildPreReq PreReq Provides Conflicts
     ));
     my @seen = ();
     my %count = ();
     my $done = ''; my $this = ''; my $todo = $spec;
     while ($todo =~ m/^(\S+):([ \t]*)(.*?)$/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($header, $pad, $value) = ($1, $2, $3);
         #   check for layouting
         if (length($value) == 0) {
             &lint_error($file, $done, $this, "empty RPM header value");
         }
         if (length($header.":".$pad) != 14) {
             &lint_warning($file, $done, $this, "invalid RPM header name/value padding (expected value at column 15)");
         }
         #   check for valid header name and value
         if (not grep { $header =~ m|^$_$|s } map { m/^[^:]:([^:]+):/, $1 } @headers) {
             &lint_error($file, $done, $this, "invalid RPM header name \"$header\"");
         }
         else {
             my $hn = quotemeta((grep { $header =~ m|^$_$|s } map { m/^[^:]+:([^:]+):/, $1 } @headers)[0]);
             my $re = (map { m/^[^:]+:${hn}:(.+)$/s } @headers)[0];
             my $re_match = $re;
             $re_match =~ s|^\(|(?:|sg;
             $re_match =~ s|([^\\])\(|\1(?:|sg;
             if (    not ($file =~ m|openpkg\.spec$| and $header eq 'Provides' and $value eq '%{l_prefix}')
                 and $value !~ m|${re_match}|s) {
                 &lint_warning($file, $done, $this, "RPM header \"$header\": " .
                               "invalid value \"$value\" (expected to match \"$re\")");
             }
             my $re_def = (map { m/^${hn}:(.+)$/s } @headers_def)[0];
             if (defined($re_def)) {
                 my $re_def_match = $re_def;
                 $re_def_match =~ s|^\(|(?:|sg;
                 $re_def_match =~ s|([^\\])\(|\1(?:|sg;
                 if ($value =~ m|${re_def_match}|s) {
                     &lint_warning($file, $done, $this, "RPM header \"$header\": " .
                                   "default value \"$value\" (expected to match \"$re\", except for this)");
                 }
             }
             if ($header =~ m/^Vendor/ and $value =~ m/et\sal/ and $value !~ m/et\sal\./) {
                 &lint_warning($file, $done, $this, "RPM header \"$header\": " .
                               "has value \"$value\" (expected \"et al.\" with dot)");
             }
         }
         push(@seen, $header);
         $count{$header}++;
         $done .= $this;
     }
     #   check for existence of mandatory headers
     foreach my $header (@headers) {
         my ($type, $name, $regex) = split(/:/, $header, 3);
         if ($type eq 'm') {
             if ($file =~ m|openpkg\.spec$| and
                 ($name eq "BuildPreReq" or $name eq "PreReq")) {
                 #   the bootstrap package is an obvious exception
                 next;
             }
             if (not grep(/^$name$/, @seen)) {
                 &lint_warning($file, undef, undef, "mandatory RPM header \"$name\" not found");
             }
         }
     }
     #   check for multiple occurrence headers
     foreach my $seen (@seen) {
         if ($count{$seen} > 1 and not (grep { $_ eq $seen } @headers_mult)) {
             &lint_error($file, undef, undef, "RPM header \"$seen\" occurs multiple times (expected just once)");
         }
     }
 }
 ##  _________________________________________________________________
 ##
 ##  CHECK "section": RPM sections
 ##  _________________________________________________________________
 ##
 sub check_section {
     my ($file, $spec) = @_;
     my $require = qq{
         (%define,)*
         Name:,
         Summary:,
         URL:,
         Vendor:,
         Packager:,
         Distribution:,
         Class:,
         Group:,
         License:,
         Version:,
         Release:,
         (%option,)*
         (%define,|%undefine,)*
         (Source\\d+:,)*
         (Patch\\d+:,)*
         (%NoSource,)*
         (%NoPatch,)*
         (Prefix:,)?
         (BuildRoot:,)?
         ((BuildPreReq:,)
          |(PreReq:,))*
         (AutoReq:,)?
         (AutoReqProv:,)?
         (Provides:,)*
         (Conflicts:,)*
         %description,
         (%track,)?
         %prep,
         %build,
         %install,
         (%check,)?
         %files,
         %clean,
         (%pre,)?
         (%post,)?
         (%preun,)?
         (%postun,)?
         (%trigger,)?
         (%triggerin,)?
         (%triggerun,)?
         (%triggerpostun,)?
         (%verifyscript,)?
     };
     #   check for order of headers
     my $sections = "";
     my $done = ''; my $this = ''; my $todo = $spec;
     while ($todo =~ m/^(\S+:|%\S+).*$/m) {
         $done .= $`; $this = $&; $todo = $';
         my $section = $1;
         next if ($section =~ m/^%(if|else|endif)/);
         $sections .= "$section,";
         $done .= $this;
     }
     my $regex = $require;
     $regex =~ s|\s+||sg;
     if ($sections !~ m/^$regex$/s) {
         $regex =~ s|,| |sg;
         &lint_error($file, undef, undef, "invalid RPM section order: $sections (expected \"$regex\")");
     }
 }
 ##  _________________________________________________________________
 ##
 ##  CHECK "preproc": RPM macro pre-processor
 ##  _________________________________________________________________
 ##
 sub check_preproc {
     my ($file, $spec) = @_;
     my $done = ''; my $this = ''; my $todo = $spec;
     while ($todo =~ m/^(%(?:if|else|endif|define|undefine|option))(.*)$/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($cmd, $args) = ($1, $2);
         if ($cmd eq '%if') {
             #   FIXME: either try to really parse the boolean expression
             #   FIXME: or at least try to guess its correct syntax
         }
         elsif ($cmd eq '%else' or $cmd eq '%endif') {
             if (length($args) > 0) {
                 &lint_warning($file, $done, $this, "garbage after pre-processor directive " .
                               "\"$cmd\" (expected no arguments)");
             }
         }
         elsif ($cmd eq '%undefine') {
             if ($args =~ m|^\s+(\S+)\s*$|) {
                 my $var = $1;
                 if ($var !~ m/^(V|with)_[a-z][a-zA-Z0-9_]*$/) {
                     &lint_warning($file, $done, $this, "unusually named macro: \"$var\" " .
                                   "(expected \"(V|with)_[a-z][a-zA-Z0-9_]*\")");
                     next;
                 }
             }
             else {
                 &lint_error($file, $done, $this, "invalid number of arguments to pre-processor " .
                             "directive \"$cmd\" (expected exactly 1 argument)");
             }
         }
         elsif ($cmd eq '%define' or $cmd eq '%option') {
             if ($args =~ m|^\s+(\S+)\s+(.*)$|) {
                 my ($var, $val) = ($1, $2);
                 if ($var !~ m/^(V|with)_[a-z][a-zA-Z0-9_]*$/) {
                     &lint_warning($file, $done, $this, "unusually named macro: \"$var\" " .
                                   "(expected \"(V|with)_[a-z][a-zA-Z0-9_]*\")");
                     next;
                 }
                 if (length($val) == 0) {
                     &lint_error($file, $done, $this, "empty macro value");
                 }
             }
             else {
                 &lint_error($file, $done, $this, "invalid number of arguments to pre-processor " .
                             "directive \"$cmd\" (expected exactly 2 arguments)");
             }
         }
         $done .= $this;
     }
     #   check correct if/endif nesting
     my @stack = ();
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/^(%(?:if|else|endif|define|undefine|option)).*$/m) {
         $done .= $`; $this = $&; $todo = $';
         my $directive = $1;
         if ($directive eq '%if') {
             push(@stack, &lines($done . $this));
         }
         elsif ($directive eq '%endif') {
             if (@stack == 0) {
                 &lint_error($file, $done, $this, "found \%endif without corresponding opening \%if");
                 last;
             }
             pop(@stack);
         }
         $done .= $this;
     }
     my $line;
     while (defined($line = pop(@stack))) {
         &lint_error($file, undef, undef, "\%if at line $line never closed by \%endif");
     }
     #   check for indented preprocessor constructs
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/^[ \t]+(%(?:if|else|endif|define|undefine|option)).*$/m) {
         $done .= $`; $this = $&; $todo = $';
         my $directive = $1;
         &lint_error($file, $done, $this, "found indented \"$directive\" preprocessor directive (expected no indentation)");
         $done .= $this;
     }
 }
 ##  _________________________________________________________________
 ##
 ##  CHECK "script": shell scripts
 ##  _________________________________________________________________
 ##
 sub check_script {
     my ($file, $spec) = @_;
     my $done = ''; my $this = ''; my $todo = $spec;
     while ($todo =~ m/(\%(?:description|prep|build|install|check|files|clean|pre|post|preun|postun|trigger|triggerin|triggerun|triggerpostun|verifyscript))([^\n]*)\n(.*?\n)(?=\%(?:description|prep|build|install|check|files|clean|pre|post|preun|postun|trigger|triggerin|triggerun|triggerpostun|verifyscript)|$)/s) {
         $done .= $`; $this = $&; $todo = $';
         my ($section, $args, $script) = ($1, $2, $3);
         #   perform checks for a single script section
         &check_script_section($file, $done, $this, $section, $args, $script);
         $done .= $this;
     }
 }
 sub check_script_section {
     my ($file, $outer_done, $outer_this, $section, $args, $script) = @_;
     #   skip plain-text/non-scripting section %description
     return if ($section eq '%description');
     #   remove comment contents
     $outer_this =~ s|^[ \t]*#[^\n]*||mg;
     #   check shell redirections
     my $done = $outer_done; my $this = ''; my $todo = $outer_this;
     while (   $todo =~ m/[ \t]+(\d+)?[><][ \t]+\S+/s
            or $todo =~ m/[ \t]+[><](\&\d+)?[ \t]+\S+/s) {
         $done .= $`; $this = $&; $todo = $';
         &lint_warning($file, $done, $this, "section $section: whitespace after shell redirection (expected none)");
         $done .= $this;
     }
     #   utility function: extract a single shell command
     sub command_extract {
         my ($script) = @_;
         my $cmd = '';
         while ($script ne '') {
             $script =~ s/^([ \t]*'[^']*')/         $cmd .= $1, ''/se && next;
             $script =~ s/^([ \t]*"[^"]*")/         $cmd .= $1, ''/se && next;
             $script =~ s/^([ \t]*[^ \t;\)\\\r\n]+)/$cmd .= $1, ''/se && next;
             $script =~ s/^([ \t]*\\[ \t]*\r?\n)/   $cmd .= $1, ''/se && next;
             last;
         }
         return ($cmd, $script);
     }
     #   utility function: join a multi-line command
     sub multiline_join {
         my ($cmd) = @_;
         $cmd =~ s/([ \t]*\\[ \t]*\r?\n[ \t]*)/ /sg;
         return $cmd;
     }
     #   utility function: split command into arguments
     sub shell_tokenize {
         my ($cmd) = @_;
         my @cmd = ();
         while ($cmd ne '') {
             $cmd =~ s/^\s*('[^']*')/push(@cmd, $1), ''/se && next;
             $cmd =~ s/^\s*("[^"]*")/push(@cmd, $1), ''/se && next;
             $cmd =~ s/^\s*(\S+)/    push(@cmd, $1), ''/se && next;
             $cmd =~ s/^\s*$/                        ''/se && last;
         }
         return @cmd;
     }
     #   check filesystem path style
     $done = $outer_done; $this = ''; $todo = $outer_this;
     while ($todo =~ m/\%\{l_shtool\}\s+(\w+)\s+/s) {
         $done .= $`; $this = $&; $todo = $';
         ($this, $todo) = &command_extract($this . $todo);
         #   check for shtool options with no space before argument
         my $subthis = $this;
         $subthis =~ s/\%{[A-Za-z][A-Za-z0-9_]*}//sg;
         $subthis =~ s/\%{[A-Za-z][A-Za-z0-9_]*(?:\s+[^}]+?)?}//sg;
         #   remove content of quoted arguments as they might contain unrelated things to catch
         $subthis =~ s/'[^']*'/ARG/sg;
         $subthis =~ s/"[^"]*"/ARG/sg;
         $subthis =~ s/`[^`]*`/ARG/sg;
         #   remove us completely if line ends with a quote as this indicates we are a quoted argument to ourselfs
         $subthis =~ s/[^']*'$//s;
         $subthis =~ s/[^"]*"$//s;
         $subthis =~ s/[^`]*`$//s;
         $subthis =~ s/[^']*' \\\n//s;
         $subthis =~ s/[^"]*" \\\n//s;
         $subthis =~ s/[^`]*` \\\n//s;
         #   catch command termination by semicolon, pipe, or, and;
         $subthis =~ s/[;|&].*$//s;
         if ($subthis =~ m/\s-[a-zA-Z]\S/) {
             &lint_warning($file, $done, $this, "found use of shtool option with space omitted before argument");
         }
         #   openpkg-rc is special because does bootstrap things
         last if ($file =~ m|openpkg-rc\.spec$|);
         my @cmd = &shell_tokenize(&multiline_join($this));
         if ($cmd[1] eq 'mkdir') {
             #   join flags with their arguments
             for (my $i = 2; $i <= $#cmd; $i++) {
                 if ($cmd[$i] eq '-m') {
                     splice(@cmd, $i, 2, $cmd[$i].$cmd[$i+1]);
                 }
             }
             #   check paths
             for (my $i = $#cmd; $i > 1 and $cmd[$i] !~ m|^-| and $cmd[$i] !~ m|^\d+$|; $i--) {
                 if ($cmd[$i] =~ m|/$|) {
                     &lint_warning($file, $done, $this, "section $section: superfluous trailing slash on " .
                                   "created path in \"shtool mkdir\" command (expected none)");
                 }
             }
         }
         elsif ($cmd[1] eq 'install') {
             #   join flags with their arguments
             for (my $i = 2; $i <= $#cmd; $i++) {
                 if ($cmd[$i] =~ m/-(e|m|o|g)$/) {
                     splice(@cmd, $i, 2, $cmd[$i].$cmd[$i+1]);
                 }
                 elsif ($cmd[$i] eq '%{SOURCE') {
                     splice(@cmd, $i, 2, $cmd[$i].$cmd[$i+1]);
                 }
                 elsif ($cmd[$i] eq '%{l_value') {
                     while ($i < $#cmd and $cmd[$i+1] !~ m|\}$|s) {
                         splice(@cmd, $i, 2, $cmd[$i].$cmd[$i+1]);
                     }
                     splice(@cmd, $i, 2);
                     $i--;
                 }
             }
             #   determine last path argument
             my $i = $#cmd; $i-- while ($i > 1 and $cmd[$i] !~ m|^-| and $cmd[$i] !~ m|^\d+$|);
             #   check paths
             if (($#cmd - $i) > 2 and $cmd[-1] !~ m|/$|) {
                 #   simple case: multiple sources require target to be a directory
                 &lint_warning($file, $done, $this, "section $section: missing trailing slash on " .
                               "destination path in \"shtool install\" command (expected one) 1");
             }
             elsif (($#cmd - $i) == 2 and $cmd[-1] !~ m|/$|) {
                 #   complex case: single source, so we can check only known destination paths
                 if (   $cmd[-1] =~ m/\%\{l_prefix\}\/(bin|cgi|include|info|lib|pub|sbin)$/
                     or $cmd[-1] =~ m/\%\{l_prefix\}\/(etc|libexec|man|share|var)(\/[^\/]+)?$/) {
                     &lint_warning($file, $done, $this, "section $section: missing trailing slash on " .
                                   "destination path in \"shtool install\" command (expected one) 2");
                 }
             }
             else {
                 #   special case: if any path contains '*', then globbing might occur
                 for (my $i = 2; $i <= $#cmd; $i++) {
                     if ($cmd[$i] =~ m/\*/ and $cmd[-1] !~ m|/$|) {
                         &lint_warning($file, $done, $this, "section $section: missing trailing slash on " .
                                       "destination path in \"shtool install\" command (expected one) 3");
                         last;
                     }
                 }
             }
         }
         $done .= $this;
     }
     #   check for redundant 'export PATH' statements
     #$done = $outer_done; $this = ''; $todo = $outer_this;
     #while ($todo =~ m/\bexport[ \t]+([a-zA-Z_][a-zA-Z0-9_]*[ \t]+)*PATH\b/s) {
     #    $done .= $`; $this = $&; $todo = $';
     #    &lint_warning($file, $done, $this, "section $section: redundant \"export PATH\" statement (expected none)");
     #    $done .= $this;
     #}
     #   check for obsolete cpp build flags
     $done = $outer_done; $this = ''; $todo = $outer_this;
     while ($todo =~ m/-I\%\{l_prefix\}\/include(\/([^ \t"';]+?))?[ \t"';]/s) {
         $done .= $`; $this = $&; $todo = $';
         my ($subdir) = $2;
         &lint_warning($file, $done, $this, "section $section: hard-coded C pre-processor path option " .
                       "(use \"%{l_cppflags".($subdir ? " $subdir" : "")."}\" instead)");
         $done .= $this;
     }
     #   check for obsolete ld build flags
     $done = $outer_done; $this = ''; $todo = $outer_this;
     while ($todo =~ m/-L\%\{l_prefix\}\/lib(\/([^ \t"';]+?))?[ \t"';]/s) {
         $done .= $`; $this = $&; $todo = $';
         my ($subdir) = $2;
         &lint_warning($file, $done, $this, "section $section: hard-coded linker path option " .
                       "(use \"%{l_ldflags".($subdir ? " $subdir" : "")."}\" instead)");
         $done .= $this;
     }
     #   check for "raw" tool usage
     if ($section ne '%description' and $file !~ m|openpkg\.spec$|) {
         foreach my $token (&shell_tokenize($outer_this)) {
             if ($token =~ m/^(rpmtool|shtool|curl|bash|gzip|bzip2|tar|cc|cxx|make|patch)$/s) {
                 &lint_warning($file, undef, undef, "section $section: raw usage of standard tool \"$token\"" .
                               " (use \"%{l_${token}}\" instead)");
             }
         }
     }
     #   check for setup and patch macro usage
     if ($section eq '%prep') {
         $done = $outer_done; $this = ''; $todo = $outer_this;
         my @tokens = &shell_tokenize($outer_this);
         while ($todo =~ m/([^\n]*)\n/s) {
             $done .= $`; $this = $&; $todo = $';
             if ($this =~ m/^ *%setup.*  .*$/) {
                 &lint_warning($file, undef, undef, "section $section: multiple spaces in \"\%setup\" macro" .
                               " (reduce to single space)");
             }
             if ($this =~ m/^ *%setup.*-[ab]$/ and grep(/^\%setup+$/, @tokens) == 1) {
                 &lint_warning($file, undef, undef, "section $section: -[ab] option superflous for single \"\%setup\" macro" .
                               " (remove it)");
             }
             if ($this =~ m/^ *%patch.*  .*$/) {
                 &lint_warning($file, undef, undef, "section $section: multiple spaces in \"\%patch\" macro" .
                               " (reduce to single space)");
             }
             if ($this =~ m/^ *%patch.*-p +[01]/) {
                 &lint_warning($file, undef, undef, "section $section: syntactically wrong space in \"\%patch\" macro" .
                               " (use -pN)");
             }
             if ($this =~ m/^ *%patch.*-P 0\s*$/ and grep(/^\%patch+$/, @tokens) == 1) {
                 &lint_warning($file, undef, undef, "section $section: syntactically wrong space in \"\%patch\" macro" .
                               " (omit -P 0 for single patch)");
             }
             if ($this =~ m/^ *%patch.*-P [^0-9]/ and grep(/^\%patch+$/, @tokens)  > 1) {
                 &lint_warning($file, undef, undef, "section $section: syntactically wrong space in \"\%patch\" macro" .
                               " (use -P for multiple patches)");
             }
             $done .= $this;
         }
         if (grep(/^\%setup\d+$/, @tokens)) {
             &lint_warning($file, undef, undef, "section $section: numbered \"\%setup\" macro" .
                           " (do not use %setup directly followed by a number, replace with %setup ... -[ab])");
         }
         if (grep(/^\%patch\d+$/, @tokens)) {
             &lint_warning($file, undef, undef, "section $section: numbered \"\%patch\" macro" .
                           " (do not use %patch directly followed by a number, replace with %patch ... -P)");
         }
     }
     #   check for hard-coded prefix in %pre[un],%post[un] scripts
     if ($section =~ m/^\%(preun|postun|pre|post)$/s and $file !~ m|openpkg\.spec$|) {
         $done = $outer_done; $this = ''; $todo = $outer_this;
         while ($todo =~ m/\%\{l_prefix\}/s) {
             $done .= $`; $this = $&; $todo = $';
             &lint_warning($file, $done, $this, "section $section: hard-coded prefix (\%{l_prefix}) found " .
                           "(use \"\$RPM_INSTALL_PREFIX\" to allow relocation)");
             $done .= $this;
         }
     }
     #   check for sub-shell parenthesis style
     #   (this is such complicated because the Bourne Shell has a
     #   construct "case <value> in <pattern> ) <script> ;; ... esac"
     #   where the closing parenthesis makes heavy problems for our
     #   check. So we first have to get rid of this. Unfortunately this
     #   is again not easy because there exists nested(!) case/esac
     #   constructs. Hence, we have to use a small recursive descent
     #   parser which replaces the ")" in case/esac constructs with
     #   "PCLOSE". A similar thing is done with string literals, although
     #   here the job is more trivial).
     if ($section !~ m/^\%files$/s) {
         $done = $outer_done; $this = ''; $todo = $outer_this;
         $todo =~ s/`[^`]*`/STRING/sg;
         $todo =~ s/'[^']*'/STRING/sg;
         $todo =~ s/"[^"]*"/STRING/sg;
         $todo = (&parse_sh("", $todo))[0];
         sub parse_sh {
             my ($done, $todo) = @_;
             while ($todo =~ m/^(.*?)(case|;;)/s) {
                 if ($2 eq 'case') {
                     ($done, $todo) = &parse_case($done.$1, $2.$');
                 }
                 else {
                     ($done, $todo) = ($done.$1, $2.$');
                     return ($done, $todo);
                 }
             }
             ($done, $todo) = ($done . $todo, "");
             return ($done, $todo);
         }
         sub parse_case {
             my ($done, $todo) = @_;
             $todo =~ m|^\s*case\s+\S+\s+in\b|s or return (undef, undef);
             ($done, $todo) = ($done . $&, $');
             while ($todo =~ m|^(\s*[^)\n]+)(\))|s) {
                 ($done, $todo) = ($done . $1 . "PCLOSE", $');
                 ($done, $todo) = &parse_sh($done, $todo) or return (undef, undef);
                 $todo =~ m|^\s*;;|s or return (undef, undef);
                 ($done, $todo) = ($done . $&, $');
             }
             $todo =~ m|^\s*esac|s or return (undef, undef);
             ($done, $todo) = ($done . $&, $');
             return ($done, $todo);
         }
         if ($file !~ m|openpkg\.spec$| and $todo eq '') {
             &lint_warning($file, $outer_done, $outer_this,
                           "unable to correctly parse case/esac constructs in shell-script" .
                           " (sub-shell parenthesis check skipped)");
         }
         else {
             while ($todo =~ m/\)[ \t]*\n/s) {
                 $done .= $`; $this = $&; $todo = $';
                 &lint_warning($file, $done, $this, "problematic sub-shell construct without error handling " .
                               "(use \"...) || exit \$?\" to make sure it correctly exits on nested failure)");
                 $done .= $this;
             }
         }
     }
 }
 ##  _________________________________________________________________
 ##
 ##  CHECK "global": globals
 ##  _________________________________________________________________
 ##
 sub check_global {
     my ($file, $spec) = @_;
     #   check for deprecated use of %{name} macro
     my $done = ''; my $this = ''; my $todo = $spec;
     while ($todo =~ m/\%\{name\}/s) {
         $done .= $`; $this = $&; $todo = $';
         &lint_warning($file, $done, $this, "deprecated usage of %{name} macro (expected none)");
         $done .= $this;
     }
     #   FIXME: activate later
     #   check for over-long lines
     #$done = ''; $this = ''; $todo = $spec;
     #while ($todo =~ m/([^\n]{80,})\n/s) {
     #    $done .= $`; $this = $&; $todo = $';
     #    &lint_warning($file, $done, $this, "over-long line with ".sprintf("%d", length($1))." characters " .
     #                  "(expected maximum of 79 characters)");
     #    $done .= $this;
     #}
     #   check for "shtool install" with -e on same line
     my $done = ''; my $this = ''; my $todo = $spec;
     while ($todo =~ m/%{l_shtool} install[^\n]*-e/s) {
         $done .= $`; $this = $&; $todo = $';
         &lint_warning($file, $done, $this, "found -e option of \"shtool install\" on same line (expected separate lines)");
         $done .= $this;
     }
     #   check for "shtool install" with multiple -e on same line
     my $done = ''; my $this = ''; my $todo = $spec;
     while ($todo =~ m/%{l_shtool} install[^\n]+\\\n([^\n]*?-e[^\n]*?-e[^\n]*\\\n)+/s) {
         $done .= $`; $this = $&; $todo = $';
         &lint_warning($file, $done, $this, "found multiple -e options of \"shtool install\" on same line (expected separate lines)");
         $done .= $this;
     }
     #   check for deprecated use of "shtool install|subst -e @l_...@ %{l_...}"
     if ($file !~ m|openpkg-tool|) {
         my $done = ''; my $this = ''; my $todo = $spec;
         while ($todo =~ m/%{l_shtool} (install|subst)(?:\\\n|[^\n])*?-e(?:\\\n|[^\n])*?\@l_(prefix|[smrn](usr|grp|uid|gid))\@[^n]+%{l_\2}/s) {
             $done .= $`; $this = $&; $todo = $';
             &lint_warning($file, $done, $this, "deprecated usage of \"shtool $1 -e \@l_$2\@\" (expected use of %{l_value -s -a})");
             $done .= $this;
         }
     }
     #   check for constant "root" in %attr
     my $done = ''; my $this = ''; my $todo = $spec;
     while ($todo =~ m/%attr\(\s*(\d+)\s*,\s*root\s*,/s) {
         $done .= $`; $this = $&; $todo = $';
         &lint_warning($file, $done, $this, "found constant \"root\" in %attr (expected variable %{l_susr})");
         $done .= $this;
     }
     #   check for valid RPM macro usage
     if ($file !~ m|^(.+/)?openpkg\.spec$|s) {
         my $ok = `$rpm --eval '\%dump' 2>&1 | egrep "^-*[0-9][0-9]*: l_" | sed -e 's;^[^:]*: *\\(l_[a-zA-Z0-9_]*\\).*;\\1;' | sort -u`;
         my @ok = split(/\n/, $ok);
         my $todo = $spec;
         $todo =~ s|^([a-zA-Z][a-zA-Z0-9]+):\s+(.+)$|push(@ok, lc($1)), ''|mge;
         $todo =~ s/^\%(?:define|option)\s+(\S+)\s+.+$/push(@ok, $1), ''/mge;
         my $done = ''; my $this = ''; my $todo = $spec;
         while ($todo =~ m|\%\{([a-zA-Z][a-zA-Z0-9_]+)|s) {
             $done .= $`; $this = $&; $todo = $';
             my $name = $1;
             next if ($name =~ m/^(SOURCE|PATCH)\d*$/ or $name =~ m/^(expand|echo|warn|error)$/);
             if (not grep(/^\Q$name\E$/, @ok)) {
                 &lint_error($file, $done, $this, "unknown macro \"\%{$name}\"");
             }
             $done .= $this;
         }
     }
 }
 ##  _________________________________________________________________
 ##
 ##  CHECK "sources": source file consistency
 ##  _________________________________________________________________
 ##
 sub check_sources {
     my ($file, $spec) = @_;
     ##
     ##  PREPARATION
     ##
     my $D = {};
     my $S = {};
     my $i = 99;
     #   determine defines values
     my $done = ''; my $this = ''; my $todo = $spec;
     while ($todo =~ m/^\%(define|option)\s+(\S+)\s+(.+)\s*$/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($var, $val) = ($2, $3);
         $val =~ s|(\%\{([a-zA-Z_][a-zA-Z0-9_]*)\})|defined($D->{$2}) ? $D->{$2} : $1|sge;
         $D->{$var} = $val;
         $done .= $this;
     }
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/^([a-zA-Z][a-zA-Z0-9_]+):\s+(.*)$/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($var, $val) = (lc($1), $2);
         $val =~ s|(\%\{([a-zA-Z_][a-zA-Z0-9_]*)\})|defined($D->{$2}) ? $D->{$2} : $1|sge;
         $D->{$var} = $val;
         $done .= $this;
     }
     #   expand define values (allow one level of nesting)
     $spec =~ s|(\%\{([a-zA-Z_][a-zA-Z0-9_]*)\})|defined($D->{$2}) ? $D->{$2} : $1|sge;
     $spec =~ s|(\%\{([a-zA-Z_][a-zA-Z0-9_]*)\})|defined($D->{$2}) ? $D->{$2} : $1|sge;
     #   parse Source# and Patch# headers
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/^(Source|Patch)(\d+):[ \t]*(.*?)$/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($type, $num, $file) = (lc($1), $2, $3);
         my $url = "";
         if ($file =~ m|^(.+/)([^/]+)$|s) {
             ($url, $file) = ($1, $2);
         }
         if (not defined($S->{"$type$num"})) {
             $S->{"$type$num"} = {
                 -type   => $type,
                 -num    => $num,
                 -url    => $url,
                 -file   => $file,
                 -refhdr => 1,
                 -refcmd => 0,
                 -refmac => 0,
                 -refvar => 0,
             };
         }
         else {
             $S->{"$type$num"}->{-refhdr}++;
         }
         $done .= $this;
     }
     #   parse %setup and %patch commands
     $done = ''; $this = ''; $todo = $spec;
     $todo =~ s/^(\s*\%patch)((?:\s+-\S+|\s+-d\s+\S+)*)((?:\s+\d+)+)\s*$/&expand_patch($1, $2, $3)/mge;
     sub expand_patch {
         my ($cmd, $opts, $nums) = @_;
         my $cmds = '';
         $cmds .= "${cmd}0${opts}\n" if ($opts !~ m|\s+-P|s);
         $opts =~ s|\s+-P||s;
         while ($nums =~ s|^\s+(\d+)||) {
             my $num = $1;
             $cmds .= "${cmd}${num}${opts}\n";
         }
         return $cmds;
     }
     while ($todo =~ m/^\s*\%(setup|patch)(\d+)?(\s+.*)?$/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($type, $num, $opts) = ($1, $2, $3);
         $type = 'source' if ($type eq 'setup');
         my $num_force = '';
         if ($opts =~ m/\s-(?:a|b)\s*(\d+)/s) {
             $num_force = $1;
         }
         if ($num ne '' and $num_force ne '' and $num ne $num_force) {
             &lint_warning($file, $done, $this, "macro and enforced $type number conflict: $num <-> $num_force" .
                         " (expected either just enforced number or make them match)");
         }
         $num = $num_force if ($num_force ne '');
         $num = 0 if ($num eq '');
         next if ($opts =~ m|\s-T|s and $num == 0);
         if (not defined($S->{"$type$num"})) {
             $S->{"$type$num"} = {
                 -type   => $type,
                 -num    => $num,
                 -url    => "",
                 -file   => "",
                 -refhdr => 0,
                 -refcmd => 1,
                 -refmac => 0,
                 -refvar => 0,
             };
         }
         else {
             $S->{"$type$num"}->{-refcmd}++;
         }
         $done .= $this;
     }
     #   parse %{SOURCE#} and %{PATCH#} macros
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/\%\{(SOURCE|PATCH)(\d+)\}/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($type, $num) = (lc($1), $2);
         if (not defined($S->{"$type$num"})) {
             $S->{"$type$num"} = {
                 -type   => $type,
                 -num    => $num,
                 -url    => "",
                 -file   => "",
                 -refhdr => 0,
                 -refcmd => 0,
                 -refmac => 1,
                 -refvar => 0,
             };
         }
         else {
             $S->{"$type$num"}->{-refmac}++;
         }
         $done .= $this;
     }
     #   parse %{SOURCE ...} and %{PATCH ...} macros
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/\%\{(SOURCE|PATCH)\s+([^\s}]+)\}/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($type, $file) = (lc($1), $2);
         my $key = "";
         foreach my $src (keys(%{$S})) {
             if ($S->{$src}->{-type} eq $type and $S->{$src}->{-file} eq $file) {
                 $key = $src;
             }
         }
         if ($key eq '') {
             $S->{"$type$i"} = {
                 -type   => $type,
                 -num    => $i,
                 -url    => "",
                 -file   => $file,
                 -refhdr => 0,
                 -refcmd => 0,
                 -refmac => 1,
                 -refvar => 0,
             };
             $i++;
         }
         else {
             $S->{$key}->{-refmac}++;
         }
         $done .= $this;
     }
     #   parse $RPM_SOURCE_DIR based references
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/\$RPM_SOURCE_DIR\/([^\s;"']+)/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($file) = ($1);
         my $key = "";
         foreach my $src (keys(%{$S})) {
             if ($S->{$src}->{-file} eq $file) {
                 $key = $src;
             }
         }
         if ($key eq '') {
             $S->{"source$i"} = {
                 -type   => "source",
                 -num    => $i,
                 -url    => "",
                 -file   => $file,
                 -refhdr => 0,
                 -refcmd => 0,
                 -refmac => 0,
                 -refvar => 1,
             };
             $i++;
         }
         else {
             $S->{$key}->{-refmac}++;
         }
         $done .= $this;
     }
     ##
     ##  CHECKING
     ##
     #   check reference counts
     foreach my $src (%{$S}) {
         my $s = $S->{$src};
         my $str_hdr = ($s->{-type} eq 'source' ? 'Source' : 'Patch' ) . $s->{-num};
         my $str_cmd = ($s->{-type} eq 'source' ? '%setup' : '%patch') . $s->{-num};
         my $str_mac = ($s->{-type} eq 'source' ? '%{SOURCE ...}' : '%{PATCH ...}');
         my $str_var = "\$RPM_SOURCE_DIR";
         if ($file !~ m/\b(openpkg-.*|openpkg|vim|ncurses|openssh)\.spec$/) {
             if ($s->{-refhdr} > 0) {
                 if ($s->{-refcmd} == 0 and $s->{-refmac} == 0 and $s->{-refvar} == 0) {
                     &lint_error($file, undef, undef, "source \"$str_hdr\" defined (file $s->{-file}), but never used" .
                                 " (expected at least one reference via \"$str_cmd\", \"$str_mac\" or \"$str_var\")");
                 }
                 elsif ($s->{-refcmd} > 1) {
                     &lint_error($file, undef, undef, "source \"$str_hdr\" defined (file $s->{-file}), but used multiple times" .
                                 " (expected just one reference via \"$str_cmd\")");
                 }
             }
             else {
                 if ($s->{-refcmd}+$s->{-refmac}+$s->{-refvar} > 0) {
                     &lint_error($file, undef, undef, "source \"$str_hdr\" not defined, but used ".
                                 ($s->{-file} ? "(file ".$s->{-file}.")" : "").
                                 " (expected at least one definition via \"$str_hdr\")");
                 }
             }
         }
     }
     #   check for existing of sources on filesystem
     my $name = $file;
     $name =~ s|.*/([^/]+)$|$1|s;
     $name =~ s|\.spec$||s;
     my $cvsdir = `$rpm --define 'name $name' --eval '%{_specdir}'`;
     $cvsdir =~ s|\n$||s;
     $cvsdir =~ s|/+$||s;
     my $dstdir = `$rpm --define 'name $name' --eval '%{_sourcedir}'`;
     $dstdir =~ s|\n$||s;
     $dstdir =~ s|/+$||s;
     foreach my $src (%{$S}) {
         my $s = $S->{$src};
         next if (not $s->{-refhdr});
         if ($s->{-url} eq '' and not -f $cvsdir."/".$s->{-file} and not -f $dstdir."/".$s->{-file}) {
             &lint_error($file, undef, undef, "source \"$s->{-file}\" neither found in SRC nor DST locations (you have to provide it)");
         }
         elsif ($s->{-url} eq '' and not -f $cvsdir."/".$s->{-file} and -f $dstdir."/".$s->{-file}) {
             &lint_error($file, undef, undef, "source \"$s->{-file}\" not found in SRC, but in DST (expected it in SRC or want URL)");
         }
         elsif ($s->{-url} ne '' and not -f $cvsdir."/".$s->{-file} and not -f $dstdir."/".$s->{-file}) {
             &lint_error($file, undef, undef, "source \"$s->{-file}\" neither found in SRC nor DST locations (you have to download it)");
         }
         elsif ($s->{-url} ne '' and -f $cvsdir."/".$s->{-file} and not -f $dstdir."/".$s->{-file}) {
             &lint_error($file, undef, undef, "source \"$s->{-file}\" not found in DST, but in SRC (expected it in DST or want URL)");
         }
         #if ($s->{-url} ne '' and $s->{-file} !~ m/\d/) {
         #    &lint_warning($file, undef, undef, "vendor source \"$s->{-file}\" not versioned");
         #}
     }
     #   check for patch file naming
     foreach my $src (%{$S}) {
         my $s = $S->{$src};
         next if (not $s->{-refhdr});
         if (    $s->{-url} eq '' and $s->{-type} eq 'patch'
             and $s->{-file} !~ m|^${name}\.patch(\.[^./]+)?$|) {
             &lint_warning($file, undef, undef, "non-canonical patch filename \"$s->{-file}\"" .
                           " (expected to match \"${name}\\.patch(\\.[^./]+)?\$\")");
         }
     }
 }
 ##  _________________________________________________________________
 ##
 ##  CHECK "digest": digest consistency
 ##  _________________________________________________________________
 ##
 sub check_digest {
     my ($file, $spec) = @_;
     ##
     ##  PREPARATION
     ##
     my $D = {};
     my $S = {};
     #   determine defines values
     my $done = ''; my $this = ''; my $todo = $spec;
     while ($todo =~ m/^\%(define|option)\s+(\S+)\s+(.+)\s*$/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($var, $val) = ($2, $3);
         $val =~ s|(\%\{([a-zA-Z_][a-zA-Z0-9_]*)\})|defined($D->{$2}) ? $D->{$2} : $1|sge;
         $D->{$var} = $val;
         $done .= $this;
     }
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/^([a-zA-Z][a-zA-Z0-9_]+):\s+(.*)$/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($var, $val) = (lc($1), $2);
         $val =~ s|(\%\{([a-zA-Z_][a-zA-Z0-9_]*)\})|defined($D->{$2}) ? $D->{$2} : $1|sge;
         $D->{$var} = $val;
         $done .= $this;
     }
     #   expand define values (allow one level of nesting)
     $spec =~ s|(\%\{([a-zA-Z_][a-zA-Z0-9_]*)\})|defined($D->{$2}) ? $D->{$2} : $1|sge;
     $spec =~ s|(\%\{([a-zA-Z_][a-zA-Z0-9_]*)\})|defined($D->{$2}) ? $D->{$2} : $1|sge;
     #   determine locations
     my $name = $file;
     $name =~ s|.*/([^/]+)$|$1|s;
     $name =~ s|\.spec$||s;
     my $srcdir = `$rpm --define 'name $name' --eval '%{_specdir}'`;
     $srcdir =~ s|\n$||s;
     $srcdir =~ s|/+$||s;
     my $dstdir = `$rpm --define 'name $name' --eval '%{_sourcedir}'`;
     $dstdir =~ s|\n$||s;
     $dstdir =~ s|/+$||s;
     #   parse Source# and Patch# headers
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/^(Source|Patch)(\d+):[ \t]*(.*?)$/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($type, $num, $url) = (lc($1), $2, $3);
         my $file;
         if ($url =~ m|^.+/([^/]+)$|s) {
             $file = "$dstdir/$1";
         }
         else {
             $file = "$srcdir/$url";
         }
         if (not defined($S->{"$type$num"})) {
             $S->{"$type$num"} = {
                 -type   => $type,
                 -num    => $num,
                 -url    => $url,
                 -file   => $file
             };
         }
         else {
             $S->{"$type$num"}->{-refhdr}++;
         }
         $done .= $this;
     }
     #   parse BuildPreReq headers
     $done = ''; $this = ''; $todo = $spec;
     while ($todo =~ m/^BuildPreReq:[ \t]+digest\(sha1:\%\{(.+?)\}\)[ \t]+=[ \t]+([0-9a-fA-F]+)$/m) {
         $done .= $`; $this = $&; $todo = $';
         my ($macro, $sha1) = ($1, $2);
         my $url = $S->{lc($macro)}->{-url};
         my $filename = $S->{lc($macro)}->{-file};
         my $basename = $filename;
         $basename =~ s/^.+\/([^\/]+)$/$1/s;
         my $sha1_real = `$openssl sha1 $filename 2>/dev/null`;
         $sha1_real =~ s/^SHA1\s*\(.+?\)\s*=\s*([0-9a-fA-F]+)\s*$/$1/s;
         if (lc($sha1) ne lc($sha1_real)) {
             &lint_error($file, undef, undef, "source \"$basename\" (\%{$macro}) has a digest(sha1) requirement of \"$sha1\" (expected \"$sha1_real\")");
         }
         $done .= $this;
     }
 }

OpenPKG Specs / annotate

openpkg/lint-spec.pl@a2c6460cfb16 (annotated)

openpkg/lint-spec.pl