 @@ -1,1001 +1,1001 @@
 #! @PERL@
-# $NetBSD: pkglint.pl,v 1.792 2008/12/02 09:00:28 rillig Exp $
+# $NetBSD: pkglint.pl,v 1.793 2008/12/04 18:07:52 rillig Exp $
+#
 # pkglint - static analyzer and checker for pkgsrc packages
+#
 # Written by:
 #	Roland Illig <rillig@NetBSD.org>
+#
 # Based on work by:
 #	Hubert Feyrer <hubertf@NetBSD.org>
 #	Thorsten Frueauf <frueauf@NetBSD.org>
 #	Thomas Klausner <wiz@NetBSD.org>
 #	and others.
+#
 # Based on FreeBSD's portlint by:
 #	Jun-ichiro itojun Hagino <itojun@itojun.org>
 #	Yoshishige Arai <ryo2@on.rim.or.jp>
+#
 #	FreeBSD Id: portlint.pl,v 1.64 1998/02/28 02:34:05 itojun Exp
 #	Copyright(c) 1997 by Jun-ichiro Hagino <itojun@itojun.org>.
 #	All rights reserved.
 #	Freely redistributable.  Absolutely no warranty.
 # To get an overview of the code, run:
 #    sed -n -e 's,^\(sub .*\) {.*,  \1,p' -e '/^package/p'
 #==========================================================================
 # Note: The @EXPORT clauses in the packages must be in a BEGIN block,
 # because otherwise the names starting with an uppercase letter are not
 # recognized as subroutines but as file handles.
 #==========================================================================
 use strict;
 use warnings;
 package PkgLint::Util;
 #==========================================================================
 # This package is a catch-all for subroutines that are not application-spe-
 # cific. Currently it contains the boolean constants C<false> and C<true>,
 # as well as a function to print text in a table format, and a function
 # that converts an array into a hash. The latter is just for convenience
 # because I don't know of a Perl operator similar to qw() that can be used
 # for creating a hash.
 #==========================================================================
 BEGIN {
 	use Exporter;
 	use vars qw(@ISA @EXPORT_OK);
 	@ISA = qw(Exporter);
 	@EXPORT_OK = qw(
 		assert
 		false true dont_know doesnt_matter
 		min max
 		array_to_hash normalize_pathname print_table
 	);
+}
 use enum qw(false true dont_know doesnt_matter);
 sub assert($$) {
 	my ($cond, $msg) = @_;
 	my (@callers, $n);
 	if (!$cond) {
 		print STDERR ("FATAL: Assertion failed: ${msg}.\n");
 		for ($n = 0; my @info = caller($n); $n++) {
 			push(@callers, [$info[2], $info[3]]);
+		}
 		for (my $i = $#callers; $i >= 0; $i--) {
 			my $info = $callers[$i];
 			printf STDERR ("  line %4d called %s\n", $info->[0], $info->[1]);
+		}
 		exit(1);
+	}
+}
 sub min($$) {
 	my ($a, $b) = @_;
 	return ($a < $b) ? $a : $b;
+}
 sub max($$) {
 	my ($a, $b) = @_;
 	return ($a > $b) ? $a : $b;
+}
 # Prints the C<$table> on the C<$out> stream. The C<$table> shall be an
 # array of rows, each row shall be an array of cells, and each cell shall
 # be a string.
 sub print_table($$) {
 	my ($out, $table) = @_;
 	my (@width) = ();
 	foreach my $row (@{$table}) {
 		foreach my $i (0..$#{$row}) {
 			if (!defined($width[$i]) || length($row->[$i]) > $width[$i]) {
 				$width[$i] = length($row->[$i]);
+			}
+		}
+	}
 	foreach my $row (@{$table}) {
 		my ($max) = ($#{$row});
 		foreach my $i (0..$max) {
 			if ($i != 0) {
 				print $out ("  ");
+			}
 			print $out ($row->[$i]);
 			if ($i != $max) {
 				print $out (" " x ($width[$i] - length($row->[$i])));
+			}
+		}
 		print $out ("\n");
+	}
+}
 sub array_to_hash(@) {
 	my ($result) = {};
 	foreach my $arg (@_) {
 		$result->{$arg} = 1;
+	}
 	return $result;
+}
 sub normalize_pathname($) {
 	my ($fname) = @_;
 	# strip "." path components
 	$fname =~ s,^(?:\./)+,,;
 	$fname =~ s,/(?:\./)+,/,g;
 	$fname =~ s,/+,/,g;
 	# strip intermediate "../.." path components
 	while ($fname =~ s,/[^.][^/]*/[^.][^/]*/\.\./\.\./,/,) {
+	}
 	return $fname;
+}
 #== End of PkgLint::Util ==================================================
 package PkgLint::Logging;
 #==========================================================================
 # This package provides subroutines for printing messages to the user in a
 # common format. The subroutines all have the parameters C<$fname>,
 # C<$lineno> and C<$message>. In case there's no appropriate filename for
 # the message, NO_FILE may be passed, likewise for C<$lineno> and
 # NO_LINES. Before printing, the filename is normalized, that is,
 # "/foo/bar/../../" components are removed, as well as "." components.
 # At the end of the program, the subroutine print_summary_and_exit should
 # be called.
+#
 # Examples:
 #   log_error(NO_FILE, NO_LINES, "Invalid command line.");
 #   log_warning($fname, NO_LINES, "Not found.");
 #   log_debug($fname, $lineno, sprintf("invalid character (0x%02x).", $c));
 #==========================================================================
 use strict;
 use warnings;
 BEGIN {
 	use Exporter;
 	use vars qw(@ISA @EXPORT_OK);
 	@ISA = qw(Exporter);
 	@EXPORT_OK = qw(
 		NO_FILE NO_LINE_NUMBER NO_LINES
 		log_fatal log_error log_warning log_note log_debug
 		explain_error explain_warning explain_info
 		print_summary_and_exit
 		set_explain set_gcc_output_format
 		get_show_source_flag set_show_source_flag
 	);
 	import PkgLint::Util qw(
 		false true
 		normalize_pathname
 	);
+}
 use constant NO_FILE		=> undef;
 use constant NO_LINE_NUMBER	=> undef;
 use constant NO_LINES		=> undef;
 use enum qw(:LL_ FATAL ERROR WARNING NOTE DEBUG);
 use constant traditional_type	=> ["FATAL", "ERROR", "WARN", "NOTE", "DEBUG"];
 use constant gcc_type		=> ["fatal", "error", "warning", "note", "debug"];
 my $errors		= 0;
 my $warnings		= 0;
 my $gcc_output_format	= false;
 my $explain_flag	= false;
 my $show_source_flag	= false;
 sub strxvis($) {
 	my ($s) = @_;
 	$s =~ s/([^\x09\x20-\x7e])/"\\x" . unpack("H*", $1)/eg;
 	return $s;
+}
 sub log_message { # no prototype due to Perl weirdness
 	my ($level, $fname, $lineno, $message) = @_;
 	my ($text, $sep);
 	if (defined($fname)) {
 		$fname = normalize_pathname($fname);
+	}
 	$text = "";
 	$sep = "";
 	if (!$gcc_output_format) {
 		$text .= "${sep}" . traditional_type->[$level] . ":";
 		$sep = " ";
+	}
 	if (defined($fname)) {
 		$text .= defined($lineno)
 		    ? "${sep}${fname}:${lineno}"
 		    : "${sep}${fname}";
 		$sep = ": ";
+	}
 	if ($gcc_output_format) {
 		$text .= "${sep}" . gcc_type->[$level] . ":";
 		$sep = " ";
+	}
 	if (defined($message)) {
 		$text .= $sep . strxvis($message);
 		$sep = "";
+	}
 	if ($level == LL_FATAL) {
 		print STDERR ("${text}\n");
 	} else {
 		print STDOUT ("${text}\n");
+	}
+}
 sub log_fatal($$$)		{ log_message(LL_FATAL, @_); exit(1); }
 sub log_error($$$)		{ log_message(LL_ERROR, @_); $errors++; }
 sub log_warning($$$)		{ log_message(LL_WARNING, @_); $warnings++; }
 sub log_note($$$)		{ log_message(LL_NOTE, @_); }
 sub log_debug($$$)		{ log_message(LL_DEBUG, @_); }
 sub explain { # no prototype due to Perl weirdness
 	my ($loglevel, $fname, $lines, @texts) = @_;
 	my $out = ($loglevel == LL_FATAL) ? *STDERR : *STDOUT;
 	if ($explain_flag) {
 		foreach my $text ("", @texts, "") {
 			print $out ("\t${text}\n");
+		}
+	}
+}
 sub explain_error($$@)		{ explain(LL_ERROR, @_); }
 sub explain_warning($$@)	{ explain(LL_WARNING, @_); }
 sub explain_note($$@)		{ explain(LL_NOTE, @_); }
 sub print_summary_and_exit($) {
 	my ($quiet) = @_;
 	if (!$quiet) {
 		if ($errors != 0 || $warnings != 0) {
 			print("$errors errors and $warnings warnings found.\n");
 		} else {
 			print "looks fine.\n";
+		}
+	}
 	exit($errors != 0);
+}
 sub set_explain()		{ $explain_flag = true; }
 sub set_gcc_output_format()	{ $gcc_output_format = true; }
 sub get_show_source_flag()	{ return $show_source_flag; }
 sub set_show_source_flag()	{ $show_source_flag = true; }
 #== End of PkgLint::Logging ===============================================
 #==========================================================================
 # A SimpleMatch is the result of applying a regular expression to a Perl
 # scalar value. It can return the range and the text of the captured
 # groups.
 #==========================================================================
 package PkgLint::SimpleMatch;
 use enum qw(STRING STARTS ENDS N);
 sub new($$) {
 	my ($class, $string, $starts, $ends) = @_;
 	my ($self) = ([$string, [@{$starts}], [@{$ends}], $#{$ends}]);
 	bless($self, $class);
 	return $self;
+}
 sub string($)		{ return shift(@_)->[STRING]; }
 sub n($)		{ return shift(@_)->[N]; }
 sub has($$) {
 	my ($self, $n) = @_;
 	return 0 <= $n && $n <= $self->n
 	    && defined($self->[STARTS]->[$n])
 	    && defined($self->[ENDS]->[$n]);
+}
 sub text($$) {
 	my ($self, $n) = @_;
 	my $start = $self->[STARTS]->[$n];
 	my $end = $self->[ENDS]->[$n];
 	return substr($self->string, $start, $end - $start);
+}
 sub range($$) {
 	my ($self, $n) = @_;
 	return ($self->[STARTS]->[$n], $self->[ENDS]->[$n]);
+}
 #==========================================================================
 # When files are read in by pkglint, they are interpreted in terms of
 # lines. For Makefiles, line continuations are handled properly, allowing
 # multiple physical lines to end in a single logical line. For other files
 # there is a 1:1 translation.
+#
 # A difference between the physical and the logical lines is that the
 # physical lines include the line end sequence, whereas the logical lines
 # do not.
+#
 # A logical line is a class having the read-only fields C<file>,
 # C<lines>, C<text>, C<physlines> and C<is_changed>, as well as some
 # methods for printing diagnostics easily.
+#
 # Some other methods allow modification of the physical lines, but leave
 # the logical line (the C<text>) untouched. These methods are used in the
 # --autofix mode.
+#
 # A line can have some "extra" fields that allow the results of parsing to
 # be saved under a name.
 #==========================================================================
 package PkgLint::Line;
 BEGIN {
 	import PkgLint::Util qw(
 		false true
 		assert
 	);
+}
 use enum qw(FNAME LINES TEXT PHYSLINES CHANGED BEFORE AFTER EXTRA);
 sub new($$$$) {
 	my ($class, $fname, $lines, $text, $physlines) = @_;
 	my ($self) = ([$fname, $lines, $text, $physlines, false, [], [], {}]);
 	bless($self, $class);
 	return $self;
+}
 sub fname($)		{ return shift(@_)->[FNAME]; }
 sub lines($)		{ return shift(@_)->[LINES]; }
 sub text($)		{ return shift(@_)->[TEXT]; }
 # Note: physlines is _not_ a usual getter method.
 sub is_changed($)	{ return shift(@_)->[CHANGED]; }
 # querying, getting and setting the extra values.
 sub has($$) {
 	my ($self, $name) = @_;
 	return exists($self->[EXTRA]->{$name});
+}
 sub get($$) {
 	my ($self, $name) = @_;
 	assert(exists($self->[EXTRA]->{$name}), "Field ${name} does not exist.");
 	return $self->[EXTRA]->{$name};
+}
 sub set($$$) {
 	my ($self, $name, $value) = @_;
 	assert(!exists($self->[EXTRA]->{$name}), "Field ${name} already exists.");
 	# Make sure that the line does not become a cyclic data structure.
 	my $type = ref($value);
 	if ($type eq "") {
 		# ok
 	} elsif ($type eq "ARRAY") {
 		foreach my $element (@{$value}) {
 			my $element_type = ref($element);
 			assert($element_type eq "" || $element_type eq "PkgLint::SimpleMatch",
 				"Invalid array data type: name=${name}, type=${element_type}.");
+		}
 	} else {
 		assert(false, "Invalid data: name=${name}, value=${value}.");
+	}
 	$self->[EXTRA]->{$name} = $value;
+}
 sub physlines($) {
 	my ($self) = @_;
 	return [@{$self->[BEFORE]}, @{$self->[PHYSLINES]}, @{$self->[AFTER]}];
+}
 # Only for PkgLint::String support
 sub substring($$$$) {
 	my ($self, $line, $start, $end) = @_;
 	my ($text, $physlines);
 	return substr($self->[PHYSLINES]->[$line]->[1], $start, $end);
+}
 sub show_source($$) {
 	my ($self, $out) = @_;
 	if (PkgLint::Logging::get_show_source_flag()) {
 		foreach my $line (@{$self->physlines}) {
 			print $out ("> " . $line->[1]);
+		}
+	}
+}
 sub log_fatal($$) {
 	my ($self, $text) = @_;
 	$self->show_source(*STDERR);
 	PkgLint::Logging::log_fatal($self->fname, $self->[LINES], $text);
+}
 sub log_error($$) {
 	my ($self, $text) = @_;
 	$self->show_source(*STDOUT);
 	PkgLint::Logging::log_error($self->fname, $self->[LINES], $text);
+}
 sub log_warning($$) {
 	my ($self, $text) = @_;
 	$self->show_source(*STDOUT);
 	PkgLint::Logging::log_warning($self->fname, $self->[LINES], $text);
+}
 sub log_note($$) {
 	my ($self, $text) = @_;
 	$self->show_source(*STDOUT);
 	PkgLint::Logging::log_note($self->fname, $self->[LINES], $text);
+}
 sub log_debug($$) {
 	my ($self, $text) = @_;
 	$self->show_source(*STDOUT);
 	PkgLint::Logging::log_debug($self->fname, $self->[LINES], $text);
+}
 sub explain_error($@) {
 	my ($self, @texts) = @_;
 	PkgLint::Logging::explain_error($self->fname, $self->[LINES], @texts);
+}
 sub explain_warning($@) {
 	my ($self, @texts) = @_;
 	PkgLint::Logging::explain_warning($self->fname, $self->[LINES], @texts);
+}
 sub explain_note($@) {
 	my ($self, @texts) = @_;
 	PkgLint::Logging::explain_note($self->fname, $self->[LINES], @texts);
+}
 sub explain_info($@) {
 	my ($self, @texts) = @_;
 	PkgLint::Logging::explain_info($self->fname, $self->[LINES], @texts);
+}
 sub to_string($) {
 	my ($self) = @_;
 	return $self->fname . ":" . $self->[LINES] . ": " . $self->[TEXT];
+}
 sub prepend_before($$) {
 	my ($self, $text) = @_;
 	unshift(@{$self->[BEFORE]}, [0, "$text\n"]);
 	$self->[CHANGED] = true;
+}
 sub append_before($$) {
 	my ($self, $text) = @_;
 	push(@{$self->[BEFORE]}, [0, "$text\n"]);
 	$self->[CHANGED] = true;
+}
 sub prepend_after($$) {
 	my ($self, $text) = @_;
 	unshift(@{$self->[AFTER]}, [0, "$text\n"]);
 	$self->[CHANGED] = true;
+}
 sub append_after($$) {
 	my ($self, $text) = @_;
 	push(@{$self->[AFTER]}, [0, "$text\n"]);
 	$self->[CHANGED] = true;
+}
 sub delete($) {
 	my ($self) = @_;
 	$self->[PHYSLINES] = [];
 	$self->[CHANGED] = true;
+}
 sub replace($$$) {
 	my ($self, $from, $to) = @_;
 	my $phys = $self->[PHYSLINES];
 	foreach my $i (0..$#{$phys}) {
 		if ($phys->[$i]->[0] != 0 && $phys->[$i]->[1] =~ s/\Q$from\E/$to/g) {
 			$self->[CHANGED] = true;
+		}
+	}
+}
 sub replace_regex($$$) {
 	my ($self, $from_re, $to) = @_;
 	my $phys = $self->[PHYSLINES];
 	foreach my $i (0..$#{$phys}) {
 		if ($phys->[$i]->[0] != 0 && $phys->[$i]->[1] =~ s/$from_re/$to/) {
 			$self->[CHANGED] = true;
+		}
+	}
+}
 sub set_text($$) {
 	my ($self, $text) = @_;
 	$self->[PHYSLINES] = [[0, "$text\n"]];
 	$self->[CHANGED] = true;
+}
 #== End of PkgLint::Line ==================================================
 package PkgLint::FileUtil;
 #==========================================================================
 # This package provides subroutines for loading and saving line-oriented
 # files. The load_file() subroutine loads a file completely into memory,
 # optionally handling continuation line folding. The load_lines() subrou-
 # tine is an abbreviation for the common case of loading files without
 # continuation lines. The save_autofix_changes() subroutine examines an
 # array of lines if some of them have changed. It then saves the modified
 # files.
 #==========================================================================
 use strict;
 use warnings;
 BEGIN {
 	use Exporter;
 	use vars qw(@ISA @EXPORT_OK);
 	@ISA = qw(Exporter);
 	@EXPORT_OK = qw(
 		load_file load_lines
 		save_autofix_changes
 	);
 	import PkgLint::Util qw(
 		false true
 	);
 	import PkgLint::Logging qw(
 		NO_LINE_NUMBER
 		log_error log_note
 	);
+}
 sub load_physical_lines($) {
 	my ($fname) = @_;
 	my ($physlines, $line, $lineno);
 	$physlines = [];
 	open(F, "< $fname") or return undef;
 	$lineno = 0;
 	while (defined($line = <F>)) {
 		$lineno++;
 		push(@{$physlines}, [$lineno, $line]);
+	}
 	close(F) or return undef;
 	return $physlines;
+}
 sub get_logical_line($$$) {
 	my ($fname, $lines, $ref_lineno) = @_;
 	my ($value, $lineno, $first, $firstlineno, $lastlineno, $physlines);
 	$value = "";
 	$first = true;
 	$lineno = ${$ref_lineno};
 	$firstlineno = $lines->[$lineno]->[0];
 	$physlines = [];
 	for (; $lineno <= $#{$lines}; $lineno++) {
 		if ($lines->[$lineno]->[1] =~ m"^([ \t]*)(.*?)([ \t]*)(\\?)\n?$") {
 			my ($indent, $text, $outdent, $cont) = ($1, $2, $3, $4);
 			if ($first) {
 				$value .= $indent;
 				$first = false;
+			}
 			$value .= $text;
 			push(@{$physlines}, $lines->[$lineno]);
 			if ($cont eq "\\") {
 				$value .= " ";
 			} else {
 				$value .= $outdent;
 				last;
+			}
+		}
+	}
 	if ($lineno > $#{$lines}) {
 		# The last line in the file is a continuation line
 		$lineno--;
+	}
 	$lastlineno = $lines->[$lineno]->[0];
 	${$ref_lineno} = $lineno + 1;
 	return PkgLint::Line->new($fname,
 	    $firstlineno == $lastlineno
 		? $firstlineno
 		: "$firstlineno--$lastlineno",
 	    $value,
 	    $physlines);
+}
 sub load_lines($$) {
 	my ($fname, $fold_backslash_lines) = @_;
 	my ($physlines, $seen_newline, $loglines);
 	$physlines = load_physical_lines($fname);
 	if (!$physlines) {
 		return false;
+	}
 	$seen_newline = true;
 	$loglines = [];
 	if ($fold_backslash_lines) {
 		for (my $lineno = 0; $lineno <= $#{$physlines}; ) {
 			push(@{$loglines}, get_logical_line($fname, $physlines, \$lineno));
+		}
 	} else {
 		foreach my $physline (@{$physlines}) {
 			my $text = $physline->[1];
 			$text =~ s/\n$//;
 			push(@{$loglines}, PkgLint::Line->new($fname, $physline->[0], $text, [$physline]));
+		}
+	}
 	if (0 <= $#{$physlines} && $physlines->[-1]->[1] !~ m"\n$") {
 		log_error($fname, $physlines->[-1]->[0], "File must end with a newline.");
+	}
 	return $loglines;
+}
 sub load_file($) {
 	my ($fname) = @_;
 	return load_lines($fname, false);
+}
 sub save_autofix_changes($) {
 	my ($lines) = @_;
 	my (%changed, %physlines);
 	foreach my $line (@{$lines}) {
 		if ($line->is_changed) {
 			$changed{$line->fname}++;
+		}
 		push(@{$physlines{$line->fname}}, @{$line->physlines});
+	}
 	foreach my $fname (sort(keys(%changed))) {
 		my $new = "${fname}.pkglint.tmp";
 		if (!open(F, ">", $new)) {
 			log_error($new, NO_LINE_NUMBER, "$!");
 			next;
+		}
 		foreach my $physline (@{$physlines{$fname}}) {
 			print F ($physline->[1]);
+		}
 		if (!close(F)) {
 			log_error($new, NO_LINE_NUMBER, "$!");
 			next;
+		}
 		if (!rename($new, $fname)) {
 			log_error($fname, NO_LINE_NUMBER, "$!");
 			next;
+		}
 		log_note($fname, NO_LINE_NUMBER, "Has been autofixed. Please re-run pkglint.");
+	}
+}
 #== End of PkgLint::FileUtil ==============================================
 package PkgLint::Type;
 #==========================================================================
 # A Type in pkglint is a combination of a data type and a permission
 # specification. Further details can be found in the chapter ``The pkglint
 # type system'' of the pkglint book.
 #==========================================================================
 BEGIN {
 	import PkgLint::Util qw(
 		false true
 	);
 	import PkgLint::Logging qw(
 		log_warning NO_LINES
 	);
 	use Exporter;
 	use vars qw(@ISA @EXPORT_OK);
 	@ISA = qw(Exporter);
 	@EXPORT_OK = qw(
 		LK_NONE LK_INTERNAL LK_EXTERNAL
 		GUESSED NOT_GUESSED
 	);
+}
 use enum qw(KIND_OF_LIST BASIC_TYPE ACLS IS_GUESSED);
 use enum qw(:LK_ NONE INTERNAL EXTERNAL);
 use enum qw(:ACLE_ SUBJECT_RE PERMS);
 use enum qw(NOT_GUESSED GUESSED);
 sub new($$$) {
 	my ($class, $kind_of_list, $basic_type, $acls, $guessed) = @_;
 	my ($self) = ([$kind_of_list, $basic_type, $acls, $guessed]);
 	bless($self, $class);
 	return $self;
+}
 sub kind_of_list($)	{ return shift(@_)->[KIND_OF_LIST]; }
 sub basic_type($)	{ return shift(@_)->[BASIC_TYPE]; }
 # no getter method for acls
 sub is_guessed($)	{ return shift(@_)->[IS_GUESSED]; }
 sub perms($$) {
 	my ($self, $fname) = @_;
 	my ($perms);
 	foreach my $acl_entry (@{$self->[ACLS]}) {
 		if ($fname =~ $acl_entry->[ACLE_SUBJECT_RE]) {
 			return $acl_entry->[ACLE_PERMS];
+		}
+	}
 	return undef;
+}
 # Returns the union of all possible permissions. This can be used to
 # check whether a variable may be defined or used at all, or if it is
 # read-only.
 sub perms_union($) {
 	my ($self) = @_;
 	my ($perms);
 	$perms = "";
 	foreach my $acl_entry(@{$self->[ACLS]}) {
 		$perms .= $acl_entry->[ACLE_PERMS];
+	}
 	return $perms;
+}
 # Returns whether the type is considered an external list. All external
 # lists are, of course, as well as some other data types that are not
 # defined as lists to make the implementation of checkline_mk_vartype
 # easier.
 sub is_practically_a_list($) {
 	my ($self) = @_;
 	return ($self->kind_of_list == LK_EXTERNAL) ? true
 	    : ($self->kind_of_list == LK_INTERNAL) ? false
 	    : ($self->basic_type eq "BuildlinkPackages") ? true
 	    : ($self->basic_type eq "SedCommands") ? true
 	    : ($self->basic_type eq "ShellCommand") ? true
 	    : false;
+}
 # Returns whether variables of this type may be extended using the "+="
 # operator.
 sub may_use_plus_eq($) {
 	my ($self) = @_;
 	return ($self->kind_of_list != LK_NONE) ? true
 	    : ($self->basic_type eq "AwkCommand") ? true
 	    : ($self->basic_type eq "BuildlinkPackages") ? true
 	    : ($self->basic_type eq "SedCommands") ? true
 	    : false;
+}
 sub to_string($) {
 	my ($self) = @_;
 	return (["", "InternalList of ", "List of "]->[$self->kind_of_list]) . $self->basic_type;
+}
 #== End of PkgLint::Type ==================================================
 package PkgLint::VarUseContext;
 #==========================================================================
 # This class represents the various contexts in which make(1) variables can
 # appear in pkgsrc. Further details can be found in the chapter ``The
 # pkglint type system'' of the pkglint book.
 #==========================================================================
 BEGIN {
 	import PkgLint::Util qw(
 		false true
 	);
 	import PkgLint::Logging qw(
 		log_warning NO_LINES
 	);
 	use Exporter;
 	use vars qw(@ISA @EXPORT_OK);
 	@ISA = qw(Exporter);
 	@EXPORT_OK = qw(
 		VUC_TIME_UNKNOWN VUC_TIME_LOAD VUC_TIME_RUN
 		VUC_TYPE_UNKNOWN
 		VUC_SHELLWORD_UNKNOWN VUC_SHELLWORD_PLAIN VUC_SHELLWORD_DQUOT
 		  VUC_SHELLWORD_SQUOT VUC_SHELLWORD_BACKT VUC_SHELLWORD_FOR
 		VUC_EXTENT_UNKNOWN VUC_EXTENT_FULL VUC_EXTENT_WORD
 		  VUC_EXTENT_WORD_PART
 	);
+}
 use enum qw(TIME TYPE SHELLWORD EXTENT);
 use enum qw(:VUC_TIME_ UNKNOWN LOAD RUN);
 use constant VUC_TYPE_UNKNOWN => undef;
 use enum qw(:VUC_SHELLWORD_ UNKNOWN PLAIN DQUOT SQUOT BACKT FOR);
 use enum qw(:VUC_EXTENT_ UNKNOWN FULL WORD WORD_PART);
 my $pool = {};
 sub new($$$$$) {
 	my ($class, $time, $type, $shellword, $extent) = @_;
 	my ($self) = ([$time, $type, $shellword, $extent]);
 	bless($self, $class);
 	return $self;
+}
 sub new_from_pool($$$$$) {
 	my ($class, $time, $type, $shellword, $extent) = @_;
 	my $key = "${time}-${type}-${shellword}-${extent}";
 	if (!exists($pool->{$key})) {
 		$pool->{$key} = $class->new($time, $type, $shellword, $extent);
+	}
 	return $pool->{$key};
+}
 sub time($)		{ return shift(@_)->[TIME]; }
 sub type($)		{ return shift(@_)->[TYPE]; }
 sub shellword($)	{ return shift(@_)->[SHELLWORD]; }
 sub extent($)		{ return shift(@_)->[EXTENT]; }
 sub to_string($) {
 	my ($self) = @_;
 	return sprintf("(%s %s %s %s)",
 	    ["unknown-time", "load-time", "run-time"]->[$self->time],
 	    (defined($self->type) ? $self->type->to_string() : "no-type"),
 	    ["none", "plain", "squot", "dquot", "backt", "for"]->[$self->shellword],
 	    ["unknown", "full", "word", "word-part"]->[$self->extent]);
+}
 #== End of PkgLint::VarUseContext =========================================
 package PkgLint::SubstContext;
 #==========================================================================
 # This class records the state of a block of variable assignments that make
 # up a SUBST class. As these variable assignments are not easy to get right
 # unless you do it every day, and the possibility of typos is high, pkglint
 # provides additional checks for them.
 #==========================================================================
 BEGIN {
 	import PkgLint::Util qw(
 		false true
 	);
 	import PkgLint::Logging qw(
 		log_warning
 	);
+}
 use enum qw(:SUBST_ ID CLASS STAGE MESSAGE FILES SED VARS FILTER_CMD);
 sub new($) {
 	my ($class) = @_;
 	my ($self) = ([undef, undef, undef, undef, [], [], [], undef]);
 	bless($self, $class);
 	return $self;
+}
 sub subst_class($)		{ return shift(@_)->[SUBST_CLASS]; }
 sub subst_stage($)		{ return shift(@_)->[SUBST_STAGE]; }
 sub subst_message($)		{ return shift(@_)->[SUBST_MESSAGE]; }
 sub subst_files($)		{ return shift(@_)->[SUBST_FILES]; }
 sub subst_sed($)		{ return shift(@_)->[SUBST_SED]; }
 sub subst_vars($)		{ return shift(@_)->[SUBST_VARS]; }
 sub subst_filter_cmd($)		{ return shift(@_)->[SUBST_FILTER_CMD]; }
 sub subst_id($)			{ return shift(@_)->[SUBST_ID]; }
 sub init($) {
 	my ($self) = @_;
 	$self->[SUBST_ID] = undef;
 	$self->[SUBST_CLASS] = undef;
 	$self->[SUBST_STAGE] = undef;
 	$self->[SUBST_MESSAGE] = undef;
 	$self->[SUBST_FILES] = [];
 	$self->[SUBST_SED] = [];
 	$self->[SUBST_VARS] = [];
 	$self->[SUBST_FILTER_CMD] = undef;
+}
 sub check_end($$) {
 	my ($self, $line) = @_;
 	return unless defined($self->subst_id);
 	if (!defined($self->subst_class)) {
 		$main::opt_warn_extra and $line->log_warning("Incomplete SUBST block: SUBST_CLASSES missing.");
+	}
 	if (!defined($self->subst_stage)) {
 		$main::opt_warn_extra and $line->log_warning("Incomplete SUBST block: SUBST_STAGE missing.");
+	}
 	if (@{$self->subst_files} == 0) {
 		$main::opt_warn_extra and $line->log_warning("Incomplete SUBST block: SUBST_FILES missing.");
+	}
 	if (@{$self->subst_sed} == 0 && @{$self->subst_vars} == 0 && !defined($self->subst_filter_cmd)) {
 		$main::opt_warn_extra and $line->log_warning("Incomplete SUBST block: SUBST_SED or SUBST_VARS missing.");
+	}
 	$self->init();
+}
 sub is_complete($) {
 	my ($self) = @_;
 	return false unless defined($self->subst_id);
 	return false unless defined($self->subst_class);
 	return false unless defined($self->subst_files);
 	return false if @{$self->subst_sed} == 0 && @{$self->subst_vars} == 0;
 	return true;
+}
 sub check_varassign($$$$$) {
 	my ($self, $line, $varname, $op, $value) = @_;
 	my ($varbase, $varparam, $id);
 	if ($varname eq "SUBST_CLASSES") {
 		if ($value =~ m"^(\S+)\s") {
 			$main::opt_warn_extra and $line->log_warning("Please add only one class at a time to SUBST_CLASSES.");
 			$self->[SUBST_CLASS] = $1;
 			$self->[SUBST_ID] = $1;
 		} else {
 			if (defined($self->subst_class)) {
 				$main::opt_warn_extra and $line->log_warning("SUBST_CLASSES should only appear once in a SUBST block.");
+			}
 			$self->[SUBST_CLASS] = $value;
 			$self->[SUBST_ID] = $value;
+		}
 		return;
+	}
 	$id = $self->subst_id;
 	if ($varname =~ m"^(SUBST_(?:STAGE|MESSAGE|FILES|SED|VARS|FILTER_CMD))\.([\-\w_]+)$") {
 		($varbase, $varparam) = ($1, $2);
 		if (!defined($id)) {
 			$main::opt_warn_extra and $line->log_note("SUBST_CLASSES should precede the definition of ${varbase}.${varparam}.");
 			$id = $self->[SUBST_ID] = $varparam;
+		}
 	} else {
 		if (defined($id)) {
 			$main::opt_warn_extra and $line->log_warning("Foreign variable in SUBST block.");
+		}
 		return;
+	}
 	if ($varparam ne $id) {
 		# XXX: This code sometimes produces weird warnings. See
 		# meta-pkgs/xorg/Makefile.common 1.41 for an example.
 		if ($self->is_complete()) {
 			$self->check_end($line);
 			# The following assignment prevents an additional warning,
 			# but from a technically viewpoint, it is incorrect.
 			$self->[SUBST_CLASS] = $varparam;
 			$self->[SUBST_ID] = $varparam;
 			$id = $varparam;
 		} else {
 			$main::opt_warn_extra and $line->log_warning("Variable parameter \"${varparam}\" does not match SUBST class \"${id}\".");
+		}
+	}
 @@ -6424,1727 +6424,1733 @@ sub checkfile_buildlink3_mk($) {
 					$opt_debug_unchecked and $line->log_debug("Unchecked dependency pattern \"${value}\".");
+				}
 				$do_check = true;
+			}
 			if ($do_check && defined($abi_pkg) && defined($api_pkg)) {
 				if ($abi_pkg ne $api_pkg) {
 					$abi_line->log_warning("Package name mismatch between ${abi_pkg} ...");
 					$api_line->log_warning("... and ${api_pkg}.");
+				}
+			}
 			if ($do_check && defined($abi_version) && defined($api_version)) {
 				if (!dewey_cmp($abi_version, ">=", $api_version)) {
 					$abi_line->log_warning("ABI version (${abi_version}) should be at least ...");
 					$api_line->log_warning("... API version (${api_version}).");
+				}
+			}
 			if ($varname =~ m"^BUILDLINK_[\w_]+\.(.*)$") {
 				my ($varparam) = ($1);
 				if ($varparam ne $bl_pkgbase) {
 					$line->log_warning("Only buildlink variables for ${bl_pkgbase}, not ${varparam} may be set in this file.");
+				}
+			}
 			# TODO: More checks.
 		} elsif (expect($lines, \$lineno, qr"^(?:#.*)?$")) {
 			# Comments and empty lines are fine here.
 		} else {
 			$opt_debug_unchecked and lines_log_warning($lines, $lineno, "Unchecked line in fourth paragraph.");
 			$lineno++;
+		}
+	}
 	if (!defined($api_line)) {
 		$lines->[$lineno - 1]->log_warning("Definition of BUILDLINK_API_DEPENDS is missing.");
+	}
 	expect_empty_line($lines, \$lineno);
 	# Before the fifth paragraph, it may be necessary to resolve the build
 	# options of other packages.
 	if (expect($lines, \$lineno, qr"^pkgbase\s*:=\s*(\S+)$")) {
 		do {
 			expect_text($lines, \$lineno, ".include \"../../mk/pkg-build-options.mk\"");
 		} while (expect($lines, \$lineno, qr"^pkgbase\s*:=\s*(\S+)$"));
 		expect_empty_line($lines, \$lineno);
+	}
 	# Fifth paragraph (optional): Dependencies.
 	my $have_dependencies = false;
 	my $need_empty_line = false;
 	while (true) {
 		if (expect($lines, \$lineno, qr"^\.\s*include \"\.\./\.\./([^/]+/[^/]+)/buildlink3\.mk\"$")
 		 || expect($lines, \$lineno, qr"^\.\s*include \"\.\./\.\./mk/(\S+)\.buildlink3\.mk\"$")
 		 || expect($lines, \$lineno, qr"^\.if !empty\(PKG_BUILD_OPTIONS\.\Q${bl_pkgbase}\E:M\S+\)$")
 		 || expect($lines, \$lineno, qr"^\.endif$")) {
 			$have_dependencies = true;
 			$need_empty_line = true;
 		} elsif ($have_dependencies && expect($lines, \$lineno, qr"^$")) {
 			$need_empty_line = false;
 		} else {
 			last;
+		}
+	}
 	if ($need_empty_line) {
 		expect_empty_line($lines, \$lineno);
+	}
 	# Sixth paragraph: Reference counter.
 	if (!expect($lines, \$lineno, qr"^BUILDLINK_DEPTH:=\t+\$\{BUILDLINK_DEPTH:S/\+\$//\}$")) {
 		lines_log_warning($lines, $lineno, "Expected BUILDLINK_DEPTH:= \${BUILDLINK_DEPTH:S/+\$//}.");
 		explain_warning($lines, $lineno,
 			"Everything besides the .include lines for the buildlink3.mk files of",
 			"dependencies should go between the .if !empty({PKGNAME}_BUILDLINK3_MK)",
 			"and the corresponding .endif.");
 		return;
+	}
 	if ($lineno <= $#{$lines}) {
 		$lines->[$lineno]->log_warning("The file should end here.");
+	}
 	checklines_buildlink3_inclusion($lines);
+}
 sub checkfile_DESCR($) {
 	my ($fname) = @_;
 	my ($maxchars, $maxlines) = (80, 24);
 	my ($lines);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_DESCR()");
 	checkperms($fname);
 	if (!($lines = load_file($fname))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
 	if (@{$lines} == 0) {
 		log_error($fname, NO_LINE_NUMBER, "Must not be empty.");
 		return;
+	}
 	foreach my $line (@{$lines}) {
 		checkline_length($line, $maxchars);
 		checkline_trailing_whitespace($line);
 		checkline_valid_characters($line, regex_validchars);
 		checkline_spellcheck($line);
 		if ($line->text =~ m"\$\{") {
 			$line->log_warning("Variables are not expanded in the DESCR file.");
+		}
+	}
 	checklines_trailing_empty_lines($lines);
 	if (@{$lines} > $maxlines) {
 		my $line = $lines->[$maxlines];
 		$line->log_warning("File too long (should be no more than $maxlines lines).");
 		$line->explain_warning(
 "A common terminal size is 80x25 characters. The DESCR file should",
 "fit on one screen. It is also intended to give a _brief_ summary",
 "about the package's contents.");
+	}
 	autofix($lines);
+}
 sub checkfile_distinfo($) {
 	my ($fname) = @_;
 	my ($lines, %in_distinfo, $current_fname, $state, $patches_dir);
 	my ($di_is_committed);
 	use enum qw(:DIS_ start=0 SHA1=0 RMD160 Size);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_distinfo()");
 	$di_is_committed = is_committed($fname);
 	checkperms($fname);
 	if (!($lines = load_file($fname))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
 	if (@{$lines} == 0) {
 		log_error($fname, NO_LINE_NUMBER, "Must not be empty.");
 		return;
+	}
 	checkline_rcsid($lines->[0], "");
 	if (1 <= $#{$lines} && $lines->[1]->text ne "") {
 		$lines->[1]->log_note("Empty line expected.");
 		$lines->[1]->explain_note("This is merely for aesthetical purposes.");
+	}
 	$patches_dir = $patchdir;
 	if (!defined($patches_dir) && -d "${current_dir}/patches") {
 		$patches_dir = "patches";
 	} else {
 		# it stays undefined.
+	}
 	$current_fname = undef;
 	$state = DIS_start;
 	foreach my $line (@{$lines}[2..$#{$lines}]) {
 		if ($line->text !~ m"^(\w+) \(([^)]+)\) = (.*)(?: bytes)?$") {
 			$line->log_error("Unknown line type.");
 			next;
+		}
 		my ($alg, $chksum_fname, $sum) = ($1, $2, $3);
 		my $is_patch = (($chksum_fname =~ m"^patch-[A-Za-z0-9]+$") ? true : false);
 		if ($chksum_fname !~ m"^\w") {
 			$line->log_error("All file names should start with a letter.");
+		}
 		# Inter-package check for differing distfile checksums.
 		if ($opt_check_global && !$is_patch) {
 			# Note: Perl-specific auto-population.
 			if (exists($ipc_distinfo->{$alg}->{$chksum_fname})) {
 				my $other = $ipc_distinfo->{$alg}->{$chksum_fname};
 				if ($other->[1] eq $sum) {
 					# Fine.
 				} else {
 					$line->log_error("The ${alg} checksum for ${chksum_fname} differs ...");
 					$other->[0]->log_error("... from this one.");
+				}
 			} else {
 				$ipc_distinfo->{$alg}->{$chksum_fname} = [$line, $sum];
+			}
+		}
 		if ($alg eq "MD5") {
 			$line->log_error("MD5 checksums are obsolete.");
 			$line->explain_error(
 "Run \"".conf_make." makedistinfo\" to regenerate the distinfo file.");
 			next;
+		}
 		if ($state == DIS_SHA1) {
 			if ($alg eq "SHA1") {
 				$state = ($is_patch ? DIS_start : DIS_RMD160);
 				$current_fname = $chksum_fname;
 			} else {
 				$line->log_warning("Expected an SHA1 checksum.");
+			}
 		} elsif ($state == DIS_RMD160) {
 			$state = DIS_start;
 			if ($alg eq "RMD160") {
 				if ($chksum_fname eq $current_fname) {
 					$state = DIS_Size;
 				} else {
 					$line->log_warning("Expected an RMD160 checksum for ${current_fname}, not for ${chksum_fname}.");
+				}
 			} else {
 				if ($chksum_fname eq $current_fname) {
 					# This is an error because this really should be fixed.
 					$line->log_error("Expected an RMD160 checksum, not ${alg} for ${chksum_fname}.");
 				} else {
 					$line->log_warning("Expected an RMD160 checksum for ${current_fname}, not ${alg} for ${chksum_fname}.");
+				}
+			}
 		} elsif ($state == DIS_Size) {
 			$state = DIS_start;
 			if ($alg eq "Size") {
 				if ($chksum_fname ne $current_fname) {
 					$line->log_warning("Expected a Size checksum for ${current_fname}, not for ${chksum_fname}.");
+				}
 			} else {
 				if ($chksum_fname eq $current_fname) {
 					$line->log_warning("Expected a Size checksum, not ${alg} for ${chksum_fname}.");
 				} else {
 					$line->log_warning("Expected a Size checksum for ${current_fname}, not ${alg} for ${chksum_fname}.");
+				}
+			}
+		}
 		if ($is_patch && defined($patches_dir) && !(defined($distinfo_file) && $distinfo_file eq "./../../lang/php5/distinfo")) {
 			my $fname = "${current_dir}/${patches_dir}/${chksum_fname}";
 			if ($di_is_committed && !is_committed($fname)) {
 				$line->log_warning("${patches_dir}/${chksum_fname} is registered in distinfo but not added to CVS.");
+			}
 			if (open(PATCH, "<", $fname)) {
 				my $data = "";
 				foreach my $patchline (<PATCH>) {
 					$data .= $patchline unless $patchline =~ m"\$[N]etBSD";
+				}
 				close(PATCH);
 				my $chksum = Digest::SHA1::sha1_hex($data);
 				if ($sum ne $chksum) {
 					$line->log_error("${alg} checksum of ${chksum_fname} differs (expected ${sum}, got ${chksum}). Rerun '".conf_make." makepatchsum'.");
+				}
 			} elsif (true) {
 				$line->log_warning("${chksum_fname} does not exist.");
 				$line->explain_warning(
 "All patches that are mentioned in a distinfo file should actually exist.",
 "What's the use of a checksum if there is no file to check?");
+			}
+		}
 		$in_distinfo{$chksum_fname} = true;
+	}
 	checklines_trailing_empty_lines($lines);
 	if (defined($patches_dir)) {
 		foreach my $patch (<${current_dir}/${patches_dir}/patch-*>) {
 			$patch = basename($patch);
 			if (!exists($in_distinfo{$patch})) {
 				log_error($fname, NO_LINE_NUMBER, "$patch is not recorded. Rerun '".conf_make." makepatchsum'.");
+			}
+		}
+	}
+}
 sub checkfile_extra($) {
 	my ($fname) = @_;
 	my ($lines);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_extra()");
 	$lines = load_file($fname);
 	if (!$lines) {
 		log_error($fname, NO_LINE_NUMBER, "Could not be read.");
 		return;
+	}
 	checklines_trailing_empty_lines($lines);
 	checkperms($fname);
+}
 sub checkfile_INSTALL($) {
 	my ($fname) = @_;
 	my ($lines);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_INSTALL()");
 	checkperms($fname);
 	if (!($lines = load_file($fname))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
+}
 sub checkfile_MESSAGE($) {
 	my ($fname) = @_;
 	my ($lines);
 	my @explanation = (
 		"A MESSAGE file should consist of a header line, having 75 \"=\"",
 		"characters, followed by a line containing only the RCS Id, then an",
 		"empty line, your text and finally the footer line, which is the",
 		"same as the header line.");
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_MESSAGE()");
 	checkperms($fname);
 	if (!($lines = load_file($fname))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
 	if (@{$lines} < 3) {
 		log_warning($fname, NO_LINE_NUMBER, "File too short.");
 		explain_warning($fname, NO_LINE_NUMBER, @explanation);
 		return;
+	}
 	if ($lines->[0]->text ne "=" x 75) {
 		$lines->[0]->log_warning("Expected a line of exactly 75 \"=\" characters.");
 		explain_warning($fname, NO_LINE_NUMBER, @explanation);
+	}
 	checkline_rcsid($lines->[1], "");
 	foreach my $line (@{$lines}) {
 		checkline_length($line, 80);
 		checkline_trailing_whitespace($line);
 		checkline_valid_characters($line, regex_validchars);
 		checkline_spellcheck($line);
+	}
 	if ($lines->[-1]->text ne "=" x 75) {
 		$lines->[-1]->log_warning("Expected a line of exactly 75 \"=\" characters.");
 		explain_warning($fname, NO_LINE_NUMBER, @explanation);
+	}
 	checklines_trailing_empty_lines($lines);
+}
 sub checkfile_mk($) {
 	my ($fname) = @_;
 	my ($lines);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_mk()");
 	checkperms($fname);
 	if (!($lines = load_lines($fname, true))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
 	parselines_mk($lines);
 	checklines_mk($lines);
 	autofix($lines);
+}
 sub checkfile_package_Makefile($$) {
 	my ($fname, $lines) = @_;
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_package_Makefile(..., ...)");
 	checkperms($fname);
 	if (!exists($pkgctx_vardef->{"PLIST_SRC"})
 	    && !exists($pkgctx_vardef->{"GENERATE_PLIST"})
 	    && !exists($pkgctx_vardef->{"META_PACKAGE"})
 	    && defined($pkgdir)
 	    && !-f "${current_dir}/$pkgdir/PLIST"
 	    && !-f "${current_dir}/$pkgdir/PLIST.common") {
 		log_warning($fname, NO_LINE_NUMBER, "Neither PLIST nor PLIST.common exist, and PLIST_SRC is unset. Are you sure PLIST handling is ok?");
+	}
 	if ((exists($pkgctx_vardef->{"NO_CHECKSUM"}) || $pkgctx_vardef->{"META_PACKAGE"}) && is_emptydir("${current_dir}/${patchdir}")) {
 		if (-f "${current_dir}/${distinfo_file}") {
 			log_warning("${current_dir}/${distinfo_file}", NO_LINE_NUMBER, "This file should not exist if NO_CHECKSUM or META_PACKAGE is set.");
+		}
 	} else {
 		if (!-f "${current_dir}/${distinfo_file}") {
 			log_warning("${current_dir}/${distinfo_file}", NO_LINE_NUMBER, "File not found. Please run '".conf_make." makesum'.");
+		}
+	}
 	if (exists($pkgctx_vardef->{"REPLACE_PERL"}) && exists($pkgctx_vardef->{"NO_CONFIGURE"})) {
 		$pkgctx_vardef->{"REPLACE_PERL"}->log_warning("REPLACE_PERL is ignored when ...");
 		$pkgctx_vardef->{"NO_CONFIGURE"}->log_warning("... NO_CONFIGURE is set.");
+	}
 	if (exists($pkgctx_vardef->{"RESTRICTED"}) && !exists($pkgctx_vardef->{"LICENSE"})) {
 		$pkgctx_vardef->{"RESTRICTED"}->log_error("Restricted packages must have a LICENSE.");
+	}
 	if (exists($pkgctx_vardef->{"GNU_CONFIGURE"}) && exists($pkgctx_vardef->{"USE_LANGUAGES"})) {
 		my $languages_line = $pkgctx_vardef->{"USE_LANGUAGES"};
 		my $value = $languages_line->get("value");
 		if ($languages_line->has("comment") && $languages_line->get("comment") =~ m"\b(?:c|empty|none)\b"i) {
 			# Don't emit a warning, since the comment
 			# probably contains a statement that C is
 			# really not needed.
 		} elsif ($value !~ m"(?:^|\s+)(?:c|c99|objc)(?:\s+|$)") {
 			$pkgctx_vardef->{"GNU_CONFIGURE"}->log_warning("GNU_CONFIGURE almost always needs a C compiler, ...");
 			$languages_line->log_warning("... but \"c\" is not added to USE_LANGUAGES.");
+		}
+	}
 	my $distname_line = $pkgctx_vardef->{"DISTNAME"};
 	my $pkgname_line = $pkgctx_vardef->{"PKGNAME"};
 	my $distname = defined($distname_line) ? $distname_line->get("value") : undef;
 	my $pkgname = defined($pkgname_line) ? $pkgname_line->get("value") : undef;
 	my $nbpart = get_nbpart();
 	# Let's do some tricks to get the proper value of the package
 	# name more often.
 	if (defined($distname) && defined($pkgname)) {
 		$pkgname =~ s/\$\{DISTNAME\}/$distname/;
 		if ($pkgname =~ m"^(.*)\$\{DISTNAME:S(.)([^:]*)\2([^:]*)\2(g?)\}(.*)$") {
 			my ($before, $separator, $old, $new, $mod, $after) = ($1, $2, $3, $4, $5, $6);
 			my $newname = $distname;
 			$old = quotemeta($old);
 			$old =~ s/^\\\^/^/;
 			$old =~ s/\\\$$/\$/;
 			if ($mod eq "g") {
 				$newname =~ s/$old/$new/g;
 			} else {
 				$newname =~ s/$old/$new/;
+			}
 			$opt_debug_misc and $pkgname_line->log_debug("old pkgname=$pkgname");
 			$pkgname = $before . $newname . $after;
 			$opt_debug_misc and $pkgname_line->log_debug("new pkgname=$pkgname");
+		}
+	}
 	if (defined($pkgname) && defined($distname) && $pkgname eq $distname) {
 		$pkgname_line->log_note("PKGNAME is \${DISTNAME} by default. You probably don't need to define PKGNAME.");
+	}
 	if (!defined($pkgname) && defined($distname) && $distname !~ regex_unresolved && $distname !~ regex_pkgname) {
 		$distname_line->log_warning("As DISTNAME is not a valid package name, please define the PKGNAME explicitly.");
+	}
 	($effective_pkgname, $effective_pkgname_line, $effective_pkgbase, $effective_pkgversion)
 		= (defined($pkgname) && $pkgname !~ regex_unresolved && $pkgname =~ regex_pkgname) ? ($pkgname.$nbpart, $pkgname_line, $1, $2)
 		: (defined($distname) && $distname !~ regex_unresolved && $distname =~ regex_pkgname) ? ($distname.$nbpart, $distname_line, $1, $2)
 		: (undef, undef, undef, undef);
 	if (defined($effective_pkgname_line)) {
 		$opt_debug_misc and $effective_pkgname_line->log_debug("Effective name=${effective_pkgname} base=${effective_pkgbase} version=${effective_pkgversion}.");
+	}
 	checkpackage_possible_downgrade();
 	if (!exists($pkgctx_vardef->{"COMMENT"})) {
 		log_warning($fname, NO_LINE_NUMBER, "No COMMENT given.");
+	}
 	if (exists($pkgctx_vardef->{"USE_IMAKE"}) && exists($pkgctx_vardef->{"USE_X11"})) {
 		$pkgctx_vardef->{"USE_IMAKE"}->log_note("USE_IMAKE makes ...");
 		$pkgctx_vardef->{"USE_X11"}->log_note("... USE_X11 superfluous.");
+	}
 	if (defined($effective_pkgbase)) {
 		foreach my $suggested_update (@{get_suggested_package_updates()}) {
 			my ($line, $suggbase, $suggver, $suggcomm) = @{$suggested_update};
 			my $comment = (defined($suggcomm) ? " (${suggcomm})" : "");
 			next unless $effective_pkgbase eq $suggbase;
 			if (dewey_cmp($effective_pkgversion, "<", $suggver)) {
 				$effective_pkgname_line->log_warning("This package should be updated to ${suggver}${comment}.");
+			}
 			if (dewey_cmp($effective_pkgversion, "==", $suggver)) {
 				$effective_pkgname_line->log_note("The update request to ${suggver} from doc/TODO${comment} has been done.");
+			}
 			if (dewey_cmp($effective_pkgversion, ">", $suggver)) {
 				$effective_pkgname_line->log_note("This package is newer than the update request to ${suggver}${comment}.");
+			}
+		}
+	}
 	checklines_mk($lines);
 	checklines_package_Makefile_varorder($lines);
 	autofix($lines);
+}
 sub checkfile_patch($) {
 	my ($fname) = @_;
 	my ($lines);
 	my ($state, $redostate, $nextstate, $dellines, $addlines, $hunks);
 	my ($seen_comment, $current_fname, $current_ftype, $patched_files);
 	my ($leading_context_lines, $trailing_context_lines, $context_scanning_leading);
 	# Abbreviations used:
 	# style: [c] = context diff, [u] = unified diff
 	# scope: [f] = file, [h] = hunk, [l] = line
 	# action: [d] = delete, [m] = modify, [a] = add, [c] = context
 	use constant re_patch_rcsid	=> qr"^\$.*\$$";
 	use constant re_patch_text	=> qr"^(.+)$";
 	use constant re_patch_empty	=> qr"^$";
 	use constant re_patch_cfd	=> qr"^\*\*\*\s(\S+)(.*)$";
 	use constant re_patch_cfa	=> qr"^---\s(\S+)(.*)$";
 	use constant re_patch_ch	=> qr"^\*{15}(.*)$";
 	use constant re_patch_chd	=> qr"^\*{3}\s(\d+)(?:,(\d+))?\s\*{4}$";
 	use constant re_patch_cha	=> qr"^-{3}\s(\d+)(?:,(\d+))?\s-{4}$";
 	use constant re_patch_cld	=> qr"^(?:-\s(.*))?$";
 	use constant re_patch_clm	=> qr"^(?:!\s(.*))?$";
 	use constant re_patch_cla	=> qr"^(?:\+\s(.*))?$";
 	use constant re_patch_clc	=> qr"^(?:\s\s(.*))?$";
 	use constant re_patch_ufd	=> qr"^---\s(\S+)(?:\s+(.*))?$";
 	use constant re_patch_ufa	=> qr"^\+{3}\s(\S+)(?:\s+(.*))?$";
 	use constant re_patch_uh	=> qr"^\@\@\s-(?:(\d+),)?(\d+)\s\+(?:(\d+),)?(\d+)\s\@\@(.*)$";
 	use constant re_patch_uld	=> qr"^-(.*)$";
 	use constant re_patch_ula	=> qr"^\+(.*)$";
 	use constant re_patch_ulc	=> qr"^\s(.*)$";
 	use constant re_patch_ulnonl	=> qr"^\\ No newline at end of file$";
 	use enum qw(:PST_
 		START CENTER TEXT
 		CFA CH CHD CLD0 CLD CLA0 CLA
 		UFA UH UL
 	);
 	my ($line, $m);
 	my $check_text = sub($) {
 		my ($text) = @_;
 		if ($text =~ m"(\$(Author|Date|Header|Id|Locker|Log|Name|RCSfile|Revision|Source|State|$opt_rcsidstring)(?::[^\$]*)?\$)") {
 			my ($tag) = ($2);
 			if ($text =~ re_patch_uh) {
 				$line->log_warning("Found RCS tag \"\$${tag}\$\". Please remove it.");
 				$line->set_text($1);
 			} else {
 				$line->log_warning("Found RCS tag \"\$${tag}\$\". Please remove it by reducing the number of context lines using pkgdiff or \"diff -U[210]\".");
+			}
+		}
 	};
 	my $check_contents = sub() {
 		if ($m->has(1)) {
 			$check_text->($m->text(1));
+		}
 	};
 	my $check_added_contents = sub() {
 		my $text;
 		return unless $m->has(1);
 		$text = $m->text(1);
 		checkline_cpp_macro_names($line, $text);
 		checkline_spellcheck($line);
 		# XXX: This check is not as accurate as the similar one in
 		# checkline_mk_shelltext().
 		if (defined($current_fname)) {
 			if ($current_ftype eq "shell" || $current_ftype eq "make") {
 				my ($mm, $rest) = match_all($text, $regex_shellword);
 				foreach my $m (@{$mm}) {
 					my $shellword = $m->text(1);
 					if ($shellword =~ m"^#") {
 						last;
+					}
 					checkline_mk_absolute_pathname($line, $shellword);
+				}
 			} elsif ($current_ftype eq "source") {
 				checkline_source_absolute_pathname($line, $text);
 			} elsif ($current_ftype eq "configure") {
 				if ($text =~ m": Avoid regenerating within pkgsrc$") {
 					$line->log_error("This code must not be included in patches.");
 					$line->explain_error(
 "It is generated automatically by pkgsrc after the patch phase.",
 "",
 "For more details, look for \"configure-scripts-override\" in",
 "mk/configure/gnu-configure.mk.");
+				}
 			} elsif ($current_ftype eq "ignore") {
 				# Ignore it.
 			} else {
 				checkline_other_absolute_pathname($line, $text);
+			}
+		}
 	};
 	my $check_hunk_end = sub($$$) {
 		my ($deldelta, $adddelta, $newstate) = @_;
 		if ($deldelta > 0 && $dellines == 0) {
 			$redostate = $newstate;
 			if (defined($addlines) && $addlines > 0) {
 				$line->log_error("Expected ${addlines} more lines to be added.");
+			}
 		} elsif ($adddelta > 0 && $addlines == 0) {
 			$redostate = $newstate;
 			if (defined($dellines) && $dellines > 0) {
 				$line->log_error("Expected ${dellines} more lines to be deleted.");
+			}
 		} else {
 			if (defined($context_scanning_leading)) {
 				if ($deldelta != 0 && $adddelta != 0) {
 					if ($context_scanning_leading) {
 						$leading_context_lines++;
 					} else {
 						$trailing_context_lines++;
+					}
 				} else {
 					if ($context_scanning_leading) {
 						$context_scanning_leading = false;
 					} else {
 						$trailing_context_lines = 0;
+					}
+				}
+			}
 			if ($deldelta != 0) {
 				$dellines -= $deldelta;
+			}
 			if ($adddelta != 0) {
 				$addlines -= $adddelta;
+			}
 			if (!((defined($dellines) && $dellines > 0) ||
 			      (defined($addlines) && $addlines > 0))) {
 				if (defined($context_scanning_leading)) {
 					if ($leading_context_lines != $trailing_context_lines) {
 						$opt_debug_patches and $line->log_warning("The hunk that ends here does not have as many leading (${leading_context_lines}) as trailing (${trailing_context_lines}) lines of context.");
+					}
+				}
 				$nextstate = $newstate;
+			}
+		}
 	};
 	my $check_hunk_line = sub($$$$) {
 		my ($deldelta, $adddelta, $newstate, $check_added) = @_;
 		$check_contents->();
 		$check_hunk_end->($deldelta, $adddelta, $newstate);
 		if ($check_added) {
 			$check_added_contents->();
+		}
 	};
 	my $transitions =
 		[   [PST_START, re_patch_rcsid, PST_CENTER, sub() {
 			checkline_rcsid($line, "");
 		}], [PST_START, undef, PST_CENTER, sub() {
 			checkline_rcsid($line, "");
 		}], [PST_CENTER, re_patch_empty, PST_TEXT, sub() {
+			#
 		}], [PST_TEXT, re_patch_cfd, PST_CFA, sub() {
 			if (!$seen_comment) {
 				$opt_warn_style and $line->log_warning("Comment expected.");
+			}
 			$line->log_warning("Please use unified diffs (diff -u) for patches.");
 		}], [PST_TEXT, re_patch_ufd, PST_UFA, sub() {
 			if (!$seen_comment) {
 				$opt_warn_style and $line->log_warning("Comment expected.");
+			}
 		}], [PST_TEXT, re_patch_text, PST_TEXT, sub() {
 			$seen_comment = true;
 		}], [PST_TEXT, re_patch_empty, PST_TEXT, sub() {
+			#
 		}], [PST_TEXT, undef, PST_TEXT, sub() {
+			#
 		}], [PST_CENTER, re_patch_cfd, PST_CFA, sub() {
 			if ($seen_comment) {
 				$opt_warn_space and $line->log_note("Empty line expected.");
 			} else {
 				$opt_warn_style and $line->log_warning("Comment expected.");
+			}
 			$line->log_warning("Please use unified diffs (diff -u) for patches.");
 		}], [PST_CENTER, re_patch_ufd, PST_UFA, sub() {
 			if ($seen_comment) {
 				$opt_warn_space and $line->log_note("Empty line expected.");
 			} else {
 				$opt_warn_style and $line->log_warning("Comment expected.");
+			}
 		}], [PST_CENTER, undef, PST_TEXT, sub() {
 			$opt_warn_space and $line->log_note("Empty line expected.");
 		}], [PST_CFA, re_patch_cfa, PST_CH, sub() {
 			$current_fname = $m->text(1);
 			$current_ftype = get_filetype($line, $current_fname);
 			$opt_debug_patches and $line->log_debug("fname=$current_fname ftype=$current_ftype");
 			$patched_files++;
 			$hunks = 0;
 		}], [PST_CH, re_patch_ch, PST_CHD, sub() {
 			$hunks++;
 		}], [PST_CHD, re_patch_chd, PST_CLD0, sub() {
 			$dellines = ($m->has(2))
 			    ? (1 + $m->text(2) - $m->text(1))
 			    : ($m->text(1));
 		}], [PST_CLD0, re_patch_clc, PST_CLD, sub() {
 			$check_hunk_line->(1, 0, PST_CLD0, false);
 		}], [PST_CLD0, re_patch_cld, PST_CLD, sub() {
 			$check_hunk_line->(1, 0, PST_CLD0, false);
 		}], [PST_CLD0, re_patch_clm, PST_CLD, sub() {
 			$check_hunk_line->(1, 0, PST_CLD0, false);
 		}], [PST_CLD, re_patch_clc, PST_CLD, sub() {
 			$check_hunk_line->(1, 0, PST_CLD0, false);
 		}], [PST_CLD, re_patch_cld, PST_CLD, sub() {
 			$check_hunk_line->(1, 0, PST_CLD0, false);
 		}], [PST_CLD, re_patch_clm, PST_CLD, sub() {
 			$check_hunk_line->(1, 0, PST_CLD0, false);
 		}], [PST_CLD, undef, PST_CLD0, sub() {
 			if ($dellines != 0) {
 				$line->log_warning("Invalid number of deleted lines (${dellines} missing).");
+			}
 		}], [PST_CLD0, re_patch_cha, PST_CLA0, sub() {
 			$dellines = undef;
 			$addlines = ($m->has(2))
 			    ? (1 + $m->text(2) - $m->text(1))
 			    : ($m->text(1));
 		}], [PST_CLA0, re_patch_clc, PST_CLA, sub() {
 			$check_hunk_line->(0, 1, PST_CH, true);
 		}], [PST_CLA0, re_patch_clm, PST_CLA, sub() {
 			$check_hunk_line->(0, 1, PST_CH, true);
 		}], [PST_CLA0, re_patch_cla, PST_CLA, sub() {
 			$check_hunk_line->(0, 1, PST_CH, true);
 		}], [PST_CLA, re_patch_clc, PST_CLA, sub() {
 			$check_hunk_line->(0, 1, PST_CH, true);
 		}], [PST_CLA, re_patch_clm, PST_CLA, sub() {
 			$check_hunk_line->(0, 1, PST_CH, true);
 		}], [PST_CLA, re_patch_cla, PST_CLA, sub() {
 			$check_hunk_line->(0, 1, PST_CH, true);
 		}], [PST_CLA, undef, PST_CLA0, sub() {
 			if ($addlines != 0) {
 				$line->log_warning("Invalid number of added lines (${addlines} missing).");
+			}
 		}], [PST_CLA0, undef, PST_CH, sub() {
+			#
 		}], [PST_CH, undef, PST_TEXT, sub() {
+			#
 		}], [PST_UFA, re_patch_ufa, PST_UH, sub() {
 			$current_fname = $m->text(1);
 			$current_ftype = get_filetype($line, $current_fname);
 			$opt_debug_patches and $line->log_debug("fname=$current_fname ftype=$current_ftype");
 			$patched_files++;
 			$hunks = 0;
 		}], [PST_UH, re_patch_uh, PST_UL, sub() {
 			$dellines = ($m->has(1) ? $m->text(2) : 1);
 			$addlines = ($m->has(3) ? $m->text(4) : 1);
 			$check_text->($line->text);
 			if ($line->text =~ m"\r$") {
 				$line->log_error("The hunk header must not end with a CR character.");
 				$line->explain_error(
 "The MacOS X patch utility cannot handle these.");
+			}
 			$hunks++;
 			$context_scanning_leading = (($m->has(1) && $m->text(1) ne "1") ? true : undef);
 			$leading_context_lines = 0;
 			$trailing_context_lines = 0;
 		}], [PST_UL, re_patch_uld, PST_UL, sub() {
 			$check_hunk_line->(1, 0, PST_UH, false);
 		}], [PST_UL, re_patch_ula, PST_UL, sub() {
 			$check_hunk_line->(0, 1, PST_UH, true);
 		}], [PST_UL, re_patch_ulc, PST_UL, sub() {
 			$check_hunk_line->(1, 1, PST_UH, true);
 		}], [PST_UL, re_patch_ulnonl, PST_UL, sub() {
+			#
 		}], [PST_UL, re_patch_empty, PST_UL, sub() {
 			$opt_warn_space and $line->log_note("Leading white-space missing in hunk.");
 			$check_hunk_line->(1, 1, PST_UH, false);
 		}], [PST_UL, undef, PST_UH, sub() {
 			if ($dellines != 0 || $addlines != 0) {
 				$line->log_warning("Unexpected end of hunk (-${dellines},+${addlines} expected).");
+			}
 		}], [PST_UH, undef, PST_TEXT, sub() {
 			($hunks != 0) || $line->log_warning("No hunks for file ${current_fname}.");
 		}]];
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_patch()");
 	checkperms($fname);
 	if (!($lines = load_lines($fname, false))) {
 		log_error($fname, NO_LINE_NUMBER, "Could not be read.");
 		return;
+	}
 	if (@{$lines} == 0) {
 		log_error($fname, NO_LINE_NUMBER, "Must not be empty.");
 		return;
+	}
 	$state = PST_START;
 	$dellines = undef;
 	$addlines = undef;
 	$patched_files = 0;
 	$seen_comment = false;
 	$current_fname = undef;
 	$current_ftype = undef;
 	$hunks = undef;
 	for (my $lineno = 0; $lineno <= $#{$lines}; ) {
 		$line = $lines->[$lineno];
 		my $text = $line->text;
 		$opt_debug_patches and $line->log_debug("[${state} ${patched_files}/".($hunks||0)."/-".($dellines||0)."+".($addlines||0)."] $text");
 		my $found = false;
 		foreach my $t (@{$transitions}) {
 			if ($state == $t->[0]) {
 				if (!defined($t->[1])) {
 					$m = undef;
 				} elsif ($text =~ $t->[1]) {
 					$opt_debug_patches and $line->log_debug($t->[1]);
 					$m = PkgLint::SimpleMatch->new($text, \@-, \@+);
 				} else {
 					next;
+				}
 				$redostate = undef;
 				$nextstate = $t->[2];
 				$t->[3]->();
 				if (defined($redostate)) {
 					$state = $redostate;
 				} else {
 					$state = $nextstate;
 					if (defined($t->[1])) {
 						$lineno++;
+					}
+				}
 				$found = true;
 				last;
+			}
+		}
 		if (!$found) {
 			$line->log_error("Parse error: state=${state}");
 			$state = PST_TEXT;
 			$lineno++;
+		}
+	}
 	while ($state != PST_TEXT) {
 		$opt_debug_patches and log_debug($fname, "EOF", "[${state} ${patched_files}/".($hunks||0)."/-".($dellines||0)."+".($addlines||0)."]");
 		my $found = false;
 		foreach my $t (@{$transitions}) {
 			if ($state == $t->[0] && !defined($t->[1])) {
 				my $newstate;
 				$m = undef;
 				$redostate = undef;
 				$nextstate = $t->[2];
 				$t->[3]->();
 				$newstate = (defined($redostate)) ? $redostate : $nextstate;
 				if ($newstate == $state) {
 					log_fatal($fname, "EOF", "Internal error in the patch transition table.");
+				}
 				$state = $newstate;
 				$found = true;
 				last;
+			}
+		}
 		if (!$found) {
 			log_error($fname, "EOF", "Parse error: state=${state}");
 			$state = PST_TEXT;
+		}
+	}
 	if ($patched_files > 1) {
 		log_warning($fname, NO_LINE_NUMBER, "Contains patches for $patched_files files, should be only one.");
 	} elsif ($patched_files == 0) {
 		log_error($fname, NO_LINE_NUMBER, "Contains no patch.");
+	}
 	checklines_trailing_empty_lines($lines);
+}
 sub checkfile_PLIST($) {
 	my ($fname) = @_;
 	my ($lines, $last_file_seen);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_PLIST()");
 	checkperms($fname);
 	if (!($lines = load_file($fname))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
 	if (@{$lines} == 0) {
 		log_error($fname, NO_LINE_NUMBER, "Must not be empty.");
 		return;
+	}
 	checkline_rcsid($lines->[0], "\@comment ");
 	if (@$lines == 1) {
 		$lines->[0]->log_warning("PLIST files shouldn't be empty.");
 		$lines->[0]->explain_warning(
 "One reason for empty PLISTs is that this is a newly created package",
 "and that the author didn't run \"bmake print-PLIST\" after installing",
 "the files.",
 "",
 "Another reason, common for Perl packages, is that the final PLIST is",
 "automatically generated. Since the source PLIST is not used at all,",
 "you can remove it.",
 "",
 "Meta packages also don't need a PLIST file.");
+	}
 	# Get the list of all files from the PLIST.
 	my $all_files = {};
 	my $all_dirs = {};
 	my $extra_lines = [];
 	if (basename($fname) eq "PLIST.common_end") {
 		my $common_lines = load_file(dirname($fname) . "/PLIST.common");
 		if ($common_lines) {
 			$extra_lines = $common_lines;
+		}
+	}
 	foreach my $line (@{$extra_lines}, @{$lines}) {
 		my $text = $line->text;
 		if ($text =~ m"\$\{([\w_]+)\}(.*)") {
 			if (defined($pkgctx_plist_subst_cond) && exists($pkgctx_plist_subst_cond->{$1})) {
 				$opt_debug_misc and $line->log_debug("Removed PLIST_SUBST conditional $1.");
 				$text = $2;
+			}
+		}
 		if ($text =~ m"^[\w\$]") {
 			$all_files->{$text} = $line;
 			my $dir = $text;
 			while ($dir =~ s,/[^/]+$,,) {
 				$all_dirs->{$dir} = $line;
+			}
+		}
 		if ($text =~ m"^\@exec \$\{MKDIR\} %D/(.*)$") {
 			my $dir = $1;
 			do {
 				$all_dirs->{$dir} = $line;
 			} while ($dir =~ s,/[^/]+$,,);
+		}
+	}
 	foreach my $line (@{$lines}) {
 		my $text = $line->text;
 		if ($text =~ /\s$/) {
 			$line->log_error("pkgsrc does not support filenames ending in white-space.");
 			$line->explain_error(
 "Each character in the PLIST is relevant, even trailing white-space.");
+		}
 		# @foo directives.
 		if ($text =~ /^(?:\$\{[\w_]+\})?\@([a-z-]+)\s+(.*)/) {
 			my ($cmd, $arg) = ($1, $2);
 			if ($cmd eq "unexec" && $arg =~ m"^(rmdir|\$\{RMDIR\} \%D/)(.*)") {
 				my ($rmdir, $rest) = ($1, $2);
 				if ($rest !~ m"(?:true|\$\{TRUE\})") {
 					$line->log_warning("Please use \"\@dirrm\" instead of \"\@unexec rmdir\".");
+				}
 			} elsif (($cmd eq "exec" || $cmd eq "unexec")) {
 				if ($arg =~ /(?:install-info|\$\{INSTALL_INFO\})/) {
 					$line->log_warning("\@exec/unexec install-info is deprecated.");
 				} elsif ($arg =~ /ldconfig/ && $arg !~ m"/usr/bin/true") {
 					$line->log_error("ldconfig must be used with \"||/usr/bin/true\".");
+				}
 			} elsif ($cmd eq "comment") {
 				# nothing to do
 			} elsif ($cmd eq "dirrm") {
 				my @ids = get_shared_dir_ids($line, $arg);
 				if (@ids == 0) {
 					# Nothing to do
 				} elsif (@ids == 1) {
 					$line->log_warning("Please add \"USE_DIRS+= $ids[0]\" to the package Makefile and remove this line.");
 				} else {
 					my $s = join(" or ", map { "\"USE_DIRS+= $_\"" } @ids);
 					$line->log_warning("Please add $s to the package Makefile and remove this line.");
+				}
 				if (!exists($all_dirs->{$arg})) {
 					$line->log_warning("The PLIST does not contain files for \"$arg\".");
 					$line->explain_warning(
 "A package should only remove those directories that it created. When",
 "there are no files in the directory, it is unlikely that the package",
 "created the directory.");
+				}
 				if ($pkgpath ne "graphics/hicolor-icon-theme" && $arg =~ m"^share/icons/hicolor(?:$|/)") {
 					$line->log_warning("Please .include \"../../graphics/hicolor-icon-theme/buildlink3.mk\" and remove this line.");
+				}
 			} elsif ($cmd eq "imake-man") {
 				my (@args) = split(/\s+/, $arg);
 				if (@args != 3) {
 					$line->log_warning("Invalid number of arguments for imake-man.");
 				} else {
 					if ($args[2] eq "\${IMAKE_MANNEWSUFFIX}") {
 						warn_about_PLIST_imake_mannewsuffix($line);
+					}
+				}
 			} else {
 				$line->log_warning("Unknown PLIST directive \"\@$cmd\".");
+			}
 		# Pathnames.
 		} elsif ($text =~ m"^([A-Za-z0-9\$].*)/([^/]+)$") {
 			my ($dirname, $basename) = ($1, $2);
 			if ($opt_warn_plist_sort && $text =~ m"^\w" && $text !~ regex_unresolved) {
 				if (defined($last_file_seen)) {
 					if ($last_file_seen gt $text) {
 						$line->log_warning("${text} should be sorted before ${last_file_seen}.");
 					} elsif ($last_file_seen eq $text) {
 						$line->log_warning("Duplicate filename.");
+					}
+				}
 				$last_file_seen = $text;
+			}
 			if ($basename =~ m"\$\{IMAKE_MANNEWSUFFIX\}") {
 				warn_about_PLIST_imake_mannewsuffix($line);
+			}
 			if ($dirname =~ m"^bin/") {
 				$line->log_warning("The bin/ directory should not have subdirectories.");
 			} elsif ($dirname eq "bin") {
 				if (exists($all_files->{"man/man1/${basename}.1"})) {
 					# Fine.
 				} elsif (exists($all_files->{"man/man6/${basename}.6"})) {
 					# Fine.
 				} elsif (exists($all_files->{"\${IMAKE_MAN_DIR}/${basename}.\${IMAKE_MANNEWSUFFIX}"})) {
 					# Fine.
 				} else {
 					$opt_warn_extra and $line->log_warning("Manual page missing for bin/${basename}.");
+				}
 			} elsif ($text =~ m"^doc/") {
 				$line->log_error("Documentation must be installed under share/doc, not doc.");
 			} elsif ($text =~ m"^etc/rc\.d/") {
 				$line->log_error("RCD_SCRIPTS must not be registered in the PLIST. Please use the RCD_SCRIPTS framework.");
 			} elsif ($text =~ m"^etc/") {
 				my $f = "mk/pkginstall/bsd.pkginstall.mk";
 				assert(-f "${cwd_pkgsrcdir}/${f}", "${cwd_pkgsrcdir}/${f} is not a regular file.");
 				$line->log_error("Configuration files must not be registered in the PLIST. Please use the CONF_FILES framework, which is described in ${f}.");
 			} elsif ($text =~ m"^include/.*\.(?:h|hpp)$") {
 				# Fine.
 			} elsif ($text eq "info/dir") {
 				$line->log_error("\"info/dir\" must not be listed. Use install-info to add/remove an entry.");
 			} elsif ($text =~ m"^info/.+$") {
 				if (defined($pkgctx_vardef) && !exists($pkgctx_vardef->{"INFO_FILES"})) {
 					$line->log_warning("Packages that install info files should set INFO_FILES.");
+				}
 			} elsif (defined($effective_pkgbase) && $text =~ m"^lib/\Q${effective_pkgbase}\E/") {
 				# Fine.
 			} elsif ($text =~ m"^lib/locale/") {
 				$line->log_error("\"lib/locale\" must not be listed. Use \${PKGLOCALEDIR}/locale and set USE_PKGLOCALEDIR instead.");
 			} elsif ($text =~ m"^(lib/(?:.*/)*)([^/]+)\.(so|a|la)$") {
 				my ($dir, $lib, $ext) = ($1, $2, $3);
 				if ($dir eq "lib/" && $lib !~ m"^lib") {
 					$opt_warn_extra and $line->log_warning("Library filename does not start with \"lib\".");
+				}
 				if ($ext eq "la") {
 					if (defined($pkgctx_vardef) && !exists($pkgctx_vardef->{"USE_LIBTOOL"})) {
 						$line->log_warning("Packages that install libtool libraries should define USE_LIBTOOL.");
+					}
+				}
 			} elsif ($text =~ m"^man/(cat|man)(\w+)/(.*?)\.(\w+)(\.gz)?$") {
 				my ($cat_or_man, $section, $manpage, $ext, $gz) = ($1, $2, $3, $4, $5);
 				if ($section !~ m"^[\dln]$") {
 					$line->log_warning("Unknown section \"${section}\" for manual page.");
+				}
 				if ($cat_or_man eq "cat" && !exists($all_files->{"man/man${section}/${manpage}.${section}"})) {
 					$line->log_warning("Preformatted manual page without unformatted one.");
+				}
 				if ($cat_or_man eq "cat") {
 					if ($ext ne "0") {
 						$line->log_warning("Preformatted manual pages should end in \".0\".");
+					}
 				} else {
 					if ($section ne $ext) {
 						$line->log_warning("Mismatch between the section (${section}) and extension (${ext}) of the manual page.");
+					}
+				}
 				if (defined($gz)) {
 					$line->log_note("The .gz extension is unnecessary for manual pages.");
 					$line->explain_note(
 "Whether the manual pages are installed in compressed form or not is",
 "configured by the pkgsrc user. Compression and decompression takes place",
 "automatically, no matter if the .gz extension is mentioned in the PLIST",
 "or not.");
+				}
 			} elsif ($text =~ m"^man/cat") {
 				$line->log_warning("Invalid filename \"${text}\" for preformatted manual page.");
 			} elsif ($text =~ m"^man/man") {
 				$line->log_warning("Invalid filename \"${text}\" for unformatted manual page.");
 			} elsif ($text =~ m"^sbin/(.*)") {
 				my ($binname) = ($1);
 				if (!exists($all_files->{"man/man8/${binname}.8"})) {
 					$opt_warn_extra and $line->log_warning("Manual page missing for sbin/${binname}.");
+				}
 			} elsif ($dirname eq "share/aclocal" && $basename =~ m"\.m4$") {
 				# Fine.
 			} elsif ($text =~ m"^share/doc/html/") {
 				$opt_warn_plist_depr and $line->log_warning("Use of \"share/doc/html\" is deprecated. Use \"share/doc/\${PKGBASE}\" instead.");
 			} elsif (defined($effective_pkgbase) && $text =~ m"^share/doc/\Q${effective_pkgbase}\E/") {
 				# Fine.
 			} elsif (defined($effective_pkgbase) && $text =~ m"^share/examples/\Q${effective_pkgbase}\E/") {
 				# Fine.
 			} elsif (defined($effective_pkgbase) && $text =~ m"^share/\Q${effective_pkgbase}\E/") {
 				# Fine.
 			} elsif ($pkgpath ne "graphics/hicolor-icon-theme" && $text =~ m"^share/icons/hicolor/icon-theme\.cache") {
 				$line->log_error("Please .include \"../../graphics/hicolor-icon-theme/buildlink3.mk\" and remove this line.");
 			} elsif ($text =~ m"^share/info/") {
 				$line->log_warning("Info pages should be installed into info/, not share/info/.");
 				$line->explain_warning(
 "To fix this, you should add INFO_FILES=yes to the package Makefile.");
 			} elsif ($text =~ m"^share/locale/[\w\@_]+/LC_MESSAGES/[^/]+\.mo$") {
 				# Fine.
 			} elsif ($text =~ m"^share/man/") {
 				$line->log_warning("Man pages should be installed into man/, not share/man/.");
 			} else {
 				$opt_debug_unchecked and $line->log_debug("Unchecked pathname \"${text}\".");
+			}
 			if ($text =~ /\${PKGLOCALEDIR}/ && defined($pkgctx_vardef) && !exists($pkgctx_vardef->{"USE_PKGLOCALEDIR"})) {
 				$line->log_warning("PLIST contains \${PKGLOCALEDIR}, but USE_PKGLOCALEDIR was not found.");
+			}
 			if ($text =~ m"/CVS/") {
 				$line->log_warning("CVS files should not be in the PLIST.");
+			}
 			if ($text =~ m"\.orig$") {
 				$line->log_warning(".orig files should not be in the PLIST.");
+			}
 			if ($text =~ m"/perllocal\.pod$") {
 				$line->log_warning("perllocal.pod files should not be in the PLIST.");
 				$line->explain_warning(
 "This file is handled automatically by the INSTALL/DEINSTALL scripts,",
 "since its contents changes frequently.");
+			}
 			if ($text =~ m"^(.*)(\.a|\.so[0-9.]*)$") {
 				my ($basename, $ext) = ($1, $2);
 				if (exists($all_files->{"${basename}.la"})) {
 					$line->log_warning("Redundant library found. The libtool library is in line " . $all_files->{"${basename}.la"}->lines . ".");
+				}
+			}
 		} elsif ($text =~ m"^\$\{[\w_]+\}$") {
 			# A variable on its own line.
 		} else {
 			$line->log_error("Unknown line type.");
+		}
+	}
 	checklines_trailing_empty_lines($lines);
 	autofix($lines);
+}
 sub checkfile($) {
 	my ($fname) = @_;
 	my ($st, $basename);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile()");
 	$basename = basename($fname);
 	if ($basename =~ m"^(?:work.*|.*~|.*\.orig|.*\.rej)$") {
 		if ($opt_import) {
 			log_error($fname, NO_LINE_NUMBER, "Must be cleaned up before committing the package.");
+		}
 		return;
+	}
 	if (!($st = lstat($fname))) {
 		log_error($fname, NO_LINE_NUMBER, "$!");
 		return;
+	}
 	if (S_ISDIR($st->mode)) {
 		if ($basename eq "files" || $basename eq "patches" || $basename eq "CVS") {
 			# Ok
 		} elsif (!is_emptydir($fname)) {
 			log_warning($fname, NO_LINE_NUMBER, "Unknown directory name.");
+		}
 	} elsif (S_ISLNK($st->mode)) {
 		if ($basename !~ m"^work") {
 			log_warning($fname, NO_LINE_NUMBER, "Unknown symlink name.");
+		}
 	} elsif (!S_ISREG($st->mode)) {
 		log_error($fname, NO_LINE_NUMBER, "Only files and directories are allowed in pkgsrc.");
 	} elsif ($basename eq "ALTERNATIVES") {
 		$opt_check_ALTERNATIVES and checkfile_ALTERNATIVES($fname);
 	} elsif ($basename eq "buildlink3.mk") {
 		$opt_check_bl3 and checkfile_buildlink3_mk($fname);
 	} elsif ($basename =~ m"^(?:.*\.mk|Makefile.*)$") {
 		$opt_check_mk and checkfile_mk($fname);
 	} elsif ($basename =~ m"^DESCR") {
 		$opt_check_DESCR and checkfile_DESCR($fname);
 	} elsif ($basename =~ m"^distinfo") {
 		$opt_check_distinfo and checkfile_distinfo($fname);
 	} elsif ($basename eq "DEINSTALL" || $basename eq "INSTALL") {
 		$opt_check_INSTALL and checkfile_INSTALL($fname);
 	} elsif ($basename =~ m"^MESSAGE") {
 		$opt_check_MESSAGE and checkfile_MESSAGE($fname);
 	} elsif ($basename =~ m"^patch-[A-Za-z0-9]*$") {
 		$opt_check_patches and checkfile_patch($fname);
 	} elsif ($fname =~ m"(?:^|/)patches/manual-[^/]*$") {
 		$opt_debug_unchecked and log_debug($fname, NO_LINE_NUMBER, "Unchecked file \"${fname}\".");
 	} elsif ($fname =~ m"(?:^|/)patches/[^/]*$") {
 		log_warning($fname, NO_LINE_NUMBER, "Patch files should be named \"patch-\", followed by letters and digits only.");
 	} elsif ($basename =~ m"^PLIST") {
 		$opt_check_PLIST and checkfile_PLIST($fname);
 	} elsif ($basename eq "TODO" || $basename eq "README") {
 		# Ok
 	} elsif ($basename =~ m"^CHANGES-.*") {
 		load_doc_CHANGES($fname);
 	} elsif (!-T $fname) {
 		log_warning($fname, NO_LINE_NUMBER, "Unexpectedly found a binary file.");
 	} else {
 		log_warning($fname, NO_LINE_NUMBER, "Unexpected file found.");
 		$opt_check_extra and checkfile_extra($fname);
+	}
+}
 sub my_split($$) {
 	my ($delimiter, $s) = @_;
 	my ($pos, $next, @result);
 	$pos = 0;
 	for ($pos = 0; $pos != -1; $pos = $next) {
 		$next = index($s, $delimiter, $pos);
 		push @result, (($next == -1) ? substr($s, $pos) : substr($s, $pos, $next - $pos));
 		if ($next != -1) {
 			$next += length($delimiter);
+		}
+	}
 	return @result;
+}
 # Checks that the files in the directory are in sync with CVS's status.
+#
 sub checkdir_CVS($) {
 	my ($fname) = @_;
 	my $cvs_entries = load_file("$fname/CVS/Entries");
 	my $cvs_entries_log = load_file("$fname/CVS/Entries.Log");
 	return unless $cvs_entries;
 	foreach my $line (@$cvs_entries) {
 		my ($type, $fname, $mtime, $date, $keyword_mode, $tag, $undef) = my_split("/", $line->text);
 		next if ($type eq "D" && !defined($fname));
 		assert($type eq "" || $type eq "D", "Unknown line format: " . $line->text);
 		assert(defined($tag), "Unknown line format: " . $line->text);
 		assert(defined($keyword_mode), "Unknown line format: " . $line->text);
 		assert(!defined($undef), "Unknown line format: " . $line->text);
+	}
+}
+#
 # Procedures to check a directory including the files in it.
+#
 sub checkdir_root() {
 	my ($fname) = "${current_dir}/Makefile";
 	my ($lines, $prev_subdir, @subdirs);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkdir_root()");
 	if (!($lines = load_lines($fname, true))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
 	parselines_mk($lines);
 	if (0 <= $#{$lines}) {
 		checkline_rcsid_regex($lines->[0], qr"#\s+", "# ");
+	}
 	foreach my $line (@{$lines}) {
 		if ($line->text =~ m"^(#?)SUBDIR\s*\+=(\s*)(\S+)\s*(?:#\s*(.*?)\s*|)$") {
 			my ($comment_flag, $indentation, $subdir, $comment) = ($1, $2, $3, $4);
 			if ($comment_flag eq "#" && (!defined($comment) || $comment eq "")) {
 				$line->log_warning("${subdir} commented out without giving a reason.");
+			}
 			if ($indentation ne "\t") {
 				$line->log_warning("Indentation should be a single tab character.");
+			}
 			if ($subdir =~ m"\$" || !-f "${current_dir}/${subdir}/Makefile") {
 				next;
+			}
 			if (defined($prev_subdir) && $subdir eq $prev_subdir) {
 				$line->log_error("${subdir} must only appear once.");
 			} elsif (defined($prev_subdir) && $subdir lt $prev_subdir) {
 				$line->log_warning("${subdir} should come before ${prev_subdir}.");
 			} else {
 				# correctly ordered
+			}
 			$prev_subdir = $subdir;
 			if ($comment_flag eq "") {
 				push(@subdirs, "${current_dir}/${subdir}");
+			}
+		}
+	}
 	checklines_mk($lines);
 	if ($opt_recursive) {
 		push(@todo_items, @subdirs);
+	}
+}
 sub checkdir_category() {
 	my $fname = "${current_dir}/Makefile";
 	my ($lines, $lineno);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkdir_category()");
 	if (!($lines = load_lines($fname, true))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
 	parselines_mk($lines);
 	$lineno = 0;
 	# The first line must contain the RCS Id
 	if ($lineno <= $#{$lines} && checkline_rcsid_regex($lines->[$lineno], qr"#\s+", "# ")) {
 		$lineno++;
+	}
 	# Then, arbitrary comments may follow
 	while ($lineno <= $#{$lines} && $lines->[$lineno]->text =~ m"^#") {
 		$lineno++;
+	}
 	# Then we need an empty line
 	expect_empty_line($lines, \$lineno);
 	# Then comes the COMMENT line
 	if ($lineno <= $#{$lines} && $lines->[$lineno]->text =~ m"^COMMENT=\t*(.*)") {
 		my ($comment) = ($1);
 		checkline_valid_characters_in_variable($lines->[$lineno], qr"[-\040'(),/0-9A-Za-z]");
 		$lineno++;
 	} else {
 		$lines->[$lineno]->log_error("COMMENT= line expected.");
+	}
 	# Then we need an empty line
 	expect_empty_line($lines, \$lineno);
 	# And now to the most complicated part of the category Makefiles,
 	# the (hopefully) sorted list of SUBDIRs. The first step is to
 	# collect the SUBDIRs in the Makefile and in the file system.
 	my (@f_subdirs, @m_subdirs);
 	@f_subdirs = sort(get_subdirs($current_dir));
 	my $prev_subdir = undef;
 	while ($lineno <= $#{$lines}) {
 		my $line = $lines->[$lineno];
 		if ($line->text =~ m"^(#?)SUBDIR\+=(\s*)(\S+)\s*(?:#\s*(.*?)\s*|)$") {
 			my ($comment_flag, $indentation, $subdir, $comment) = ($1, $2, $3, $4);
 			if ($comment_flag eq "#" && (!defined($comment) || $comment eq "")) {
 				$line->log_warning("${subdir} commented out without giving a reason.");
+			}
 			if ($indentation ne "\t") {
 				$line->log_warning("Indentation should be a single tab character.");
+			}
 			if (defined($prev_subdir) && $subdir eq $prev_subdir) {
 				$line->log_error("${subdir} must only appear once.");
 			} elsif (defined($prev_subdir) && $subdir lt $prev_subdir) {
 				$line->log_warning("${subdir} should come before ${prev_subdir}.");
 			} else {
 				# correctly ordered
+			}
 			push(@m_subdirs, [$subdir, $line, $comment_flag ? false : true]);
 			$prev_subdir = $subdir;
 			$lineno++;
 		} else {
 			if ($line->text ne "") {
 				$line->log_error("SUBDIR+= line or empty line expected.");
+			}
 			last;
+		}
+	}
 	# To prevent unnecessary warnings about subdirectories that are
 	# in one list, but not in the other, we generate the sets of
 	# subdirs of each list.
 	my (%f_check, %m_check);
 	foreach my $f (@f_subdirs) { $f_check{$f} = true; }
 	foreach my $m (@m_subdirs) { $m_check{$m->[0]} = true; }
 	my ($f_index, $f_atend, $f_neednext, $f_current) = (0, false, true, undef, undef);
 	my ($m_index, $m_atend, $m_neednext, $m_current) = (0, false, true, undef, undef);
 	my ($line, $m_recurse);
 	my (@subdirs);
 	while (!($m_atend && $f_atend)) {
 		if (!$m_atend && $m_neednext) {
 			$m_neednext = false;
 			if ($m_index > $#m_subdirs) {
 				$m_atend = true;
 				$line = $lines->[$lineno];
 				next;
 			} else {
 				$m_current = $m_subdirs[$m_index]->[0];
 				$line = $m_subdirs[$m_index]->[1];
 				$m_recurse = $m_subdirs[$m_index]->[2];
 				$m_index++;
+			}
+		}
 		if (!$f_atend && $f_neednext) {
 			$f_neednext = false;
 			if ($f_index > $#f_subdirs) {
 				$f_atend = true;
 				next;
 			} else {
 				$f_current = $f_subdirs[$f_index++];
+			}
+		}
 		if (!$f_atend && ($m_atend || $f_current lt $m_current)) {
 			if (!exists($m_check{$f_current})) {
 				$line->log_error("${f_current} exists in the file system, but not in the Makefile.");
 				$line->append_before("SUBDIR+=\t${f_current}");
+			}
 			$f_neednext = true;
 		} elsif (!$m_atend && ($f_atend || $m_current lt $f_current)) {
 			if (!exists($f_check{$m_current})) {
 				$line->log_error("${m_current} exists in the Makefile, but not in the file system.");
 				$line->delete();
+			}
 			$m_neednext = true;
 		} else { # $f_current eq $m_current
 			$f_neednext = true;
 			$m_neednext = true;
 			if ($m_recurse) {
 				push(@subdirs, "${current_dir}/${m_current}");
+			}
+		}
+	}
 	# the wip category Makefile may have its own targets for generating
 	# indexes and READMEs. Just skip them.
 	if ($is_wip) {
 		while ($lineno <= $#{$lines} - 2) {
 			$lineno++;
+		}
+	}
 	expect_empty_line($lines, \$lineno);
 	# And, last but not least, the .include line
 	my $final_line = ".include \"../mk/bsd.pkg.subdir.mk\"";
 	expect($lines, \$lineno, qr"\Q$final_line\E")
 	|| expect_text($lines, \$lineno, ".include \"../mk/misc/category.mk\"");
 	if ($lineno <= $#{$lines}) {
 		$lines->[$lineno]->log_error("The file should end here.");
+	}
 	checklines_mk($lines);
 	autofix($lines);
 	if ($opt_recursive) {
 		unshift(@todo_items, @subdirs);
+	}
+}
 sub checkdir_package() {
 	my ($lines, $have_distinfo, $have_patches);
 	# Initialize global variables
 	$pkgdir = undef;
 	$filesdir = "files";
 	$patchdir = "patches";
 	$distinfo_file = "distinfo";
 	$effective_pkgname = undef;
 	$effective_pkgbase = undef;
 	$effective_pkgversion = undef;
 	$effective_pkgname_line = undef;
 	$seen_bsd_prefs_mk = false;
 	$pkgctx_vardef = {%{get_userdefined_variables()}};
 	$pkgctx_varuse = {};
 	$pkgctx_bl3 = {};
 	$pkgctx_plist_subst_cond = {};
 	$seen_Makefile_common = false;
 	# we need to handle the Makefile first to get some variables
 	if (!load_package_Makefile("${current_dir}/Makefile", \$lines)) {
 		log_error("${current_dir}/Makefile", NO_LINE_NUMBER, "Cannot be read.");
 		goto cleanup;
+	}
 	my @files = <${current_dir}/*>;
 	if ($pkgdir ne ".") {
 		push(@files, <${current_dir}/${pkgdir}/*>);
+	}
 	if ($opt_check_extra) {
 		push(@files, <${current_dir}/${filesdir}/*>);
+	}
 	push(@files, <${current_dir}/${patchdir}/*>);
 	if ($distinfo_file !~ m"^(?:\./)?distinfo$") {
 		push(@files, "${current_dir}/${distinfo_file}");
+	}
 	$have_distinfo = false;
 	$have_patches = false;
 	# Determine the used variables before checking any of the
 	# Makefile fragments.
 	foreach my $fname (@files) {
 		if ($fname =~ m"^((?:.*/)?Makefile\..*|.*\.mk)$"
 		&& (defined(my $lines = load_lines($fname, true)))) {
 			parselines_mk($lines);
 			determine_used_variables($lines);
+		}
+	}
 	foreach my $fname (@files) {
 		if ($fname eq "${current_dir}/Makefile") {
 			$opt_check_Makefile and checkfile_package_Makefile($fname, $lines);
 		} else {
 			checkfile($fname);
+		}
 		if ($fname =~ m"/patches/patch-[A-Za-z0-9]*$") {
 			$have_patches = true;
 		} elsif ($fname =~ m"/distinfo$") {
 			$have_distinfo = true;
+		}
+	}
 	if ($opt_check_distinfo && $opt_check_patches) {
 		if ($have_patches && ! $have_distinfo) {
 			log_warning("${current_dir}/$distinfo_file", NO_LINE_NUMBER, "File not found. Please run '".conf_make." makepatchsum'.");
+		}
+	}
 	if (!is_emptydir("${current_dir}/scripts")) {
 		log_warning("${current_dir}/scripts", NO_LINE_NUMBER, "This directory and its contents are deprecated! Please call the script(s) explicitly from the corresponding target(s) in the pkg's Makefile.");
+	}
 cleanup:
 	# Clean up global variables.
 	$pkgdir = undef;
 	$filesdir = undef;
 	$patchdir = undef;
 	$distinfo_file = undef;
 	$effective_pkgname = undef;
 	$effective_pkgbase = undef;
 	$effective_pkgversion = undef;
 	$effective_pkgname_line = undef;
 	$seen_bsd_prefs_mk = undef;
 	$pkgctx_vardef = undef;
 	$pkgctx_varuse = undef;
 	$pkgctx_bl3 = undef;
 	$pkgctx_plist_subst_cond = undef;
 	$seen_Makefile_common = undef;
+}
+#
 # Selecting the proper checking procedures for a directory entry.
+#
 sub checkitem($) {
 	my ($item) = @_;
 	my ($st, $is_dir, $is_reg);
 	if (!($st = lstat($item))) {
 		log_error($item, NO_LINE_NUMBER, "Does not exist.");
 		return;
+	}
 	$is_dir = S_ISDIR($st->mode);
 	$is_reg = S_ISREG($st->mode);
 	if (!$is_reg && !$is_dir) {
 		log_error($item, NO_LINE_NUMBER, "Must be a file or directory.");
 		return;
+	}
 	$current_dir = $is_dir ? $item : dirname($item);
 	my $abs_current_dir = Cwd::abs_path($current_dir);
 	$is_wip = !$opt_import && ($abs_current_dir =~ m"/wip(?:/|$)");
 	$is_internal = ($abs_current_dir =~ m"/mk(?:/|$)");
 	# Determine the root directory of pkgsrc. By only overwriting
 	# the global variable $cwd_pkgsrcdir when we are checking inside
 	# a pkgsrc tree, the user can specify a tree with the
 	# --pkgsrcdir option and then check files (but not directories)
 	# outside of any pkgsrc tree.
 	$cur_pkgsrcdir = undef;
 	$pkgpath = undef;
 	foreach my $d (".", "..", "../..", "../../..") {
 		if (-f "${current_dir}/${d}/mk/bsd.pkg.mk") {
 			$cur_pkgsrcdir = $d;
 			$pkgpath = relative_path("${current_dir}/${d}", $current_dir);
+		}
+	}
 	if (!defined($cwd_pkgsrcdir) && defined($cur_pkgsrcdir)) {
 		$cwd_pkgsrcdir = "${current_dir}/${cur_pkgsrcdir}";
+	}
 	if (!defined($cwd_pkgsrcdir)) {
 		log_error($item, NO_LINE_NUMBER, "Cannot determine the pkgsrc root directory.");
 		return;
+	}
 	check_pkglint_version();	# (needs $cwd_pkgsrcdir)
 	return if $is_dir && is_emptydir($item);
 	if ($is_dir) {
 		checkdir_CVS($item);
+	}
 	if ($is_reg) {
 		checkfile($item);
 	} elsif (!defined($cur_pkgsrcdir)) {
 		log_error($item, NO_LINES, "Cannot check directories outside a pkgsrc tree.");
 	} elsif ($cur_pkgsrcdir eq "../..") {
 		checkdir_package();
 	} elsif ($cur_pkgsrcdir eq "..") {
 		checkdir_category();
 	} elsif ($cur_pkgsrcdir eq ".") {
 		checkdir_root();
 	} else {
 		log_error($item, NO_LINE_NUMBER, "Don't know how to check this directory.");
+	}
+}
+#
 # The main program
+#
 sub main() {
 	$| = true;
 	parse_command_line();
 	@todo_items = (@ARGV != 0) ? @ARGV : (".");
 	while (@todo_items != 0) {
 		checkitem(shift(@todo_items));
+	}
 	PkgLint::Logging::print_summary_and_exit($opt_quiet);
+}
 main();