 @@ -1,1001 +1,1001 @@
 #! @PERL@
-# $NetBSD: pkglint.pl,v 1.802 2009/03/22 05:41:44 rillig Exp $
+# $NetBSD: pkglint.pl,v 1.803 2009/03/22 05:50:12 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' pkglint.pl
 #==========================================================================
 # 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}\".");
+		}
+	}
 @@ -5644,1999 +5644,1999 @@ sub checkline_mk_varassign($$$$$) {
 		my ($pkgvarname) = ($1);
 		if ($varname =~ m"^PKG_.*_REASON$") {
 			# ok
 		} elsif ($varname =~ m"^(?:DIST_SUBDIR|WRKSRC)$") {
 			$line->log_warning("${pkgvarname} should not be used in ${varname}, as it sometimes includes the PKGREVISION. Please use ${pkgvarname}_NOREV instead.");
 		} else {
 			$opt_debug_misc and $line->log_debug("Use of PKGNAME in ${varname}.");
+		}
+	}
 	if (exists(get_deprecated_map()->{$varname})) {
 		$line->log_warning("Definition of ${varname} is deprecated. ".get_deprecated_map()->{$varname});
 	} elsif (exists(get_deprecated_map()->{$varcanon})) {
 		$line->log_warning("Definition of ${varname} is deprecated. ".get_deprecated_map()->{$varcanon});
+	}
 	if ($varname =~ m"^SITES_") {
 		$line->log_warning("SITES_* is deprecated. Please use SITES.* instead.");
+	}
 	if ($value =~ m"^[^=]\@comment") {
 		$line->log_warning("Please don't use \@comment in ${varname}.");
 		$line->explain_warning(
 "Here you are defining a variable containing \@comment. As this value",
 "typically includes a space as the last character you probably also used",
 "quotes around the variable. This can lead to confusion when adding this",
 "variable to PLIST_SUBST, as all other variables are quoted using the :Q",
 "operator when they are appended. As it is hard to check whether a",
 "variable that is appended to PLIST_SUBST is already quoted or not, you",
 "should not have pre-quoted variables at all. To solve this, you should",
 "directly use PLIST_SUBST+= ${varname}=${value} or use any other",
 "variable for collecting the list of PLIST substitutions and later",
 "append that variable with PLIST_SUBST+= \${MY_PLIST_SUBST}.");
+	}
 	# Mark the variable as PLIST condition. This is later used in
 	# checkfile_PLIST.
 	if (defined($pkgctx_plist_subst_cond) && $value =~ m"(.+)=.*\@comment.*") {
 		$pkgctx_plist_subst_cond->{$1}++;
+	}
 	use constant op_to_use_time => {
 		":="	=> VUC_TIME_LOAD,
 		"!="	=> VUC_TIME_LOAD,
 		"="	=> VUC_TIME_RUN,
 		"+="	=> VUC_TIME_RUN,
 		"?="	=> VUC_TIME_RUN
 	};
 	$used_vars = extract_used_variables($line, $value);
 	my $vuc = PkgLint::VarUseContext->new(
 		op_to_use_time->{$op},
 		get_variable_type($line, $varname),
 		VUC_SHELLWORD_UNKNOWN,		# XXX: maybe PLAIN?
 		VUC_EXTENT_UNKNOWN
 	);
 	foreach my $used_var (@{$used_vars}) {
 		checkline_mk_varuse($line, $used_var, "", $vuc);
+	}
+}
 # The bmake parser is way too sloppy about syntax, so we need to check
 # that here.
+#
 sub checkline_mk_cond($$) {
 	my ($line, $cond) = @_;
 	my ($op, $varname, $match, $value);
 	$opt_debug_trace and $line->log_debug("checkline_mk_cond($cond)");
 	my $tree = parse_mk_cond($line, $cond);
 	if (tree_match($tree, ["not", ["empty", ["match", \$varname, \$match]]])) {
 		#$line->log_note("tree_match: varname=$varname, match=$match");
 		my $type = get_variable_type($line, $varname);
 		my $btype = defined($type) ? $type->basic_type : undef;
 		if (defined($btype) && ref($type->basic_type) eq "HASH") {
 			if ($match !~ m"[\$\[*]" && !exists($btype->{$match})) {
 				$line->log_warning("Invalid :M value \"$match\". Only { " . join(" ", sort keys %$btype) . " } are allowed.");
+			}
+		}
 		# Currently disabled because the valid options can also be defined in PKG_OPTIONS_GROUP.*.
 		# Additionally, all these variables may have multiple assigments (+=).
 		if (false && $varname eq "PKG_OPTIONS" && defined($pkgctx_vardef) && exists($pkgctx_vardef->{"PKG_SUPPORTED_OPTIONS"})) {
 			my $options = $pkgctx_vardef->{"PKG_SUPPORTED_OPTIONS"}->get("value");
 			if ($match !~ m"[\$\[*]" && index(" $options ", " $match ") == -1) {
 				$line->log_warning("Invalid option \"$match\". Only { $options } are allowed.");
+			}
+		}
 		# TODO: PKG_BUILD_OPTIONS. That requires loading the
 		# complete package definitition for the package "pkgbase"
 		# or some other database. If we could confine all option
 		# definitions to options.mk, this would become easier.
 	} elsif (tree_match($tree, [\$op, ["var", \$varname], ["string", \$value]])) {
 		checkline_mk_vartype($line, $varname, "use", $value, undef);
+	}
 	# XXX: When adding new cases, be careful that the variables may have
 	# been partially initialized by previous calls to tree_match.
 	# XXX: Maybe it is better to clear these references at the beginning
 	# of tree_match.
+}
+#
 # Procedures to check an array of lines.
+#
 sub checklines_trailing_empty_lines($) {
 	my ($lines) = @_;
 	my ($last, $max);
 	$max = $#{$lines} + 1;
 	for ($last = $max; $last > 1 && $lines->[$last - 1]->text eq ""; ) {
 		$last--;
+	}
 	if ($last != $max) {
 		$lines->[$last]->log_note("Trailing empty lines.");
+	}
+}
 sub checklines_package_Makefile_varorder($) {
 	my ($lines) = @_;
 	return unless $opt_warn_varorder;
 	use enum qw(once optional many);
 	my (@sections) = (
 		[ "Initial comments", once,
+			[
+			]
 		],
 		[ "Unsorted stuff, part 1", once,
+			[
 				[ "DISTNAME", once ],
 				[ "PKGNAME",  optional ],
 				[ "PKGREVISION", optional ],
 				[ "SVR4_PKGNAME", optional ],
 				[ "CATEGORIES", once ],
 				[ "MASTER_SITES", optional ],
 				[ "DIST_SUBDIR", optional ],
 				[ "EXTRACT_SUFX", optional ],
 				[ "DISTFILES", many ],
 				[ "SITES.*", many ],
+			]
 		],
 		[ "Distribution patches", optional,
+			[
 				[ "PATCH_SITES", optional ], # or once?
 				[ "PATCH_SITE_SUBDIR", optional ],
 				[ "PATCHFILES", optional ], # or once?
 				[ "PATCH_DIST_ARGS", optional ],
 				[ "PATCH_DIST_STRIP", optional ],
 				[ "PATCH_DIST_CAT", optional ],
+			]
 		],
 		[ "Unsorted stuff, part 2", once,
+			[
 				[ "MAINTAINER", optional ],
 				[ "OWNER", optional ],
 				[ "HOMEPAGE", optional ],
 				[ "COMMENT", once ],
+			]
 		],
 		[ "Legal issues", optional,
+			[
 				[ "LICENSE", once ],
 				[ "RESTRICTED", optional ],
 				[ "NO_BIN_ON_CDROM", optional ],
 				[ "NO_BIN_ON_FTP", optional ],
 				[ "NO_SRC_ON_CDROM", optional ],
 				[ "NO_SRC_ON_FTP", optional ],
+			]
 		],
 		[ "Technical restrictions", optional,
+			[
 				[ "NOT_FOR_PLATFORM", many ],
 				[ "ONLY_FOR_PLATFORM", many ],
 				[ "NOT_FOR_COMPILER", many ],
 				[ "ONLY_FOR_COMPILER", many ],
 				[ "NOT_FOR_UNPRIVILEGED", optional ],
 				[ "ONLY_FOR_UNPRIVILEGED", optional ],
+			]
 		],
 		[ "Dependencies", optional,
+			[
 				[ "BUILD_DEPENDS", many ],
 				[ "DEPENDS", many ],
+			]
+		]
 	);
 	if (!defined($seen_Makefile_common) || $seen_Makefile_common) {
 		return;
+	}
 	my ($lineno, $sectindex, $varindex) = (0, -1, 0);
 	my ($next_section, $vars, $below, $below_what) = (true, undef, {}, undef);
 	# If the current section is optional but contains non-optional
 	# fields, the complete section may be skipped as long as there
 	# has not been a non-optional variable.
 	my $may_skip_section = false;
 	# In each iteration, one of the following becomes true:
 	# - new.lineno > old.lineno
 	# - new.sectindex > old.sectindex
 	# - new.sectindex == old.sectindex && new.varindex > old.varindex
 	# - new.next_section == true && old.next_section == false
 	while ($lineno <= $#{$lines}) {
 		my $line = $lines->[$lineno];
 		my $text = $line->text;
 		$opt_debug_misc and $line->log_debug("[varorder] section ${sectindex} variable ${varindex}.");
 		if ($next_section) {
 			$next_section = false;
 			$sectindex++;
 			last if ($sectindex > $#sections);
 			$vars = $sections[$sectindex]->[2];
 			$may_skip_section = ($sections[$sectindex]->[1] == optional);
 			$varindex = 0;
+		}
 		if ($text =~ m"^#") {
 			$lineno++;
 		} elsif ($line->has("varcanon")) {
 			my $varcanon = $line->get("varcanon");
 			if (exists($below->{$varcanon})) {
 				if (defined($below->{$varcanon})) {
 					$line->log_warning("${varcanon} appears too late. Please put it below $below->{$varcanon}.");
 				} else {
 					$line->log_warning("${varcanon} appears too late. It should be the very first definition.");
+				}
 				$lineno++;
 				next;
+			}
 			while ($varindex <= $#{$vars} && $varcanon ne $vars->[$varindex]->[0] && ($vars->[$varindex]->[1] != once || $may_skip_section)) {
 				if ($vars->[$varindex]->[1] == once) {
 					$may_skip_section = false;
+				}
 				$below->{$vars->[$varindex]->[0]} = $below_what;
 				$varindex++;
+			}
 			if ($varindex > $#{$vars}) {
 				if ($sections[$sectindex]->[1] != optional) {
 					$line->log_warning("Empty line expected.");
+				}
 				$next_section = true;
 			} elsif ($varcanon ne $vars->[$varindex]->[0]) {
 				$line->log_warning("Expected " . $vars->[$varindex]->[0] . ", but found " . $varcanon . ".");
 				$lineno++;
 			} else {
 				if ($vars->[$varindex]->[1] != many) {
 					$below->{$vars->[$varindex]->[0]} = $below_what;
 					$varindex++;
+				}
 				$lineno++;
+			}
 			$below_what = $varcanon;
 		} else {
 			while ($varindex <= $#{$vars}) {
 				if ($vars->[$varindex]->[1] == once && !$may_skip_section) {
 					$line->log_warning($vars->[$varindex]->[0] . " should be set here.");
+				}
 				$below->{$vars->[$varindex]->[0]} = $below_what;
 				$varindex++;
+			}
 			$next_section = true;
 			if ($text eq "") {
 				$below_what = "the previous empty line";
 				$lineno++;
+			}
+		}
+	}
+}
 sub checklines_mk($) {
 	my ($lines) = @_;
 	my ($allowed_targets) = ({});
 	my ($substcontext) = PkgLint::SubstContext->new();
 	assert(@{$lines} != 0, "checklines_mk may only be called with non-empty lines.");
 	$opt_debug_trace and log_debug($lines->[0]->fname, NO_LINES, "checklines_mk()");
 	# Define global variables for the Makefile context.
 	$mkctx_indentations = [0];
 	$mkctx_target = undef;
 	$mkctx_for_variables = {};
 	$mkctx_vardef = {};
 	$mkctx_build_defs = {};
 	$mkctx_plist_vars = {};
 	$mkctx_tools = {%{get_predefined_tool_names()}};
 	$mkctx_varuse = {};
 	determine_used_variables($lines);
 	foreach my $prefix (qw(pre do post)) {
 		foreach my $action (qw(fetch extract patch tools wrapper configure build test install package clean)) {
 			$allowed_targets->{"${prefix}-${action}"} = true;
+		}
+	}
+	#
 	# In the first pass, all additions to BUILD_DEFS and USE_TOOLS
 	# are collected to make the order of the definitions irrelevant.
+	#
 	foreach my $line (@{$lines}) {
 		next unless $line->has("is_varassign");
 		my $varcanon = $line->get("varcanon");
 		if ($varcanon eq "BUILD_DEFS" || $varcanon eq "PKG_GROUPS_VARS" || $varcanon eq "PKG_USERS_VARS") {
 			foreach my $varname (split(qr"\s+", $line->get("value"))) {
 				$mkctx_build_defs->{$varname} = true;
 				$opt_debug_misc and $line->log_debug("${varname} is added to BUILD_DEFS.");
+			}
 		} elsif ($varcanon eq "PLIST_VARS") {
 			foreach my $id (split(qr"\s+", $line->get("value"))) {
 				$mkctx_plist_vars->{"PLIST.$id"} = true;
 				$opt_debug_misc and $line->log_debug("PLIST.${id} is added to PLIST_VARS.");
 				use_var($line, "PLIST.$id");
+			}
 		} elsif ($varcanon eq "USE_TOOLS") {
 			foreach my $tool (split(qr"\s+", $line->get("value"))) {
 				$mkctx_tools->{$tool} = true;
 				$opt_debug_misc and $line->log_debug("${tool} is added to USE_TOOLS.");
+			}
 		} elsif ($varcanon eq "SUBST_VARS.*") {
 			foreach my $svar (split(/\s+/, $line->get("value"))) {
 				use_var($svar, varname_canon($svar));
 				$opt_debug_misc and $line->log_debug("varuse $svar");
+			}
+		}
+	}
+	#
 	# In the second pass, all "normal" checks are done.
+	#
 	if (0 <= $#{$lines}) {
 		checkline_rcsid_regex($lines->[0], qr"^#\s+", "# ");
+	}
 	foreach my $line (@{$lines}) {
 		my $text = $line->text;
 		checkline_trailing_whitespace($line);
 		checkline_spellcheck($line);
 		if ($line->has("is_empty")) {
 			$substcontext->check_end($line);
 		} elsif ($line->has("is_comment")) {
 			# No further checks.
 		} elsif ($text =~ regex_varassign) {
 			my ($varname, $op, undef, $comment) = ($1, $2, $3, $4);
 			my $space1 = substr($text, $+[1], $-[2] - $+[1]);
 			my $align = substr($text, $+[2], $-[3] - $+[2]);
 			my $value = $line->get("value");
 			if ($align !~ m"^(\t*|[ ])$") {
 				$opt_warn_space && $line->log_note("Alignment of variable values should be done with tabs, not spaces.");
 				my $prefix = "${varname}${space1}${op}";
 				my $aligned_len = tablen("${prefix}${align}");
 				if ($aligned_len % 8 == 0) {
 					my $tabalign = ("\t" x (($aligned_len - tablen($prefix) + 7) / 8));
 					$line->replace("${prefix}${align}", "${prefix}${tabalign}");
+				}
+			}
 			checkline_mk_varassign($line, $varname, $op, $value, $comment);
 			$substcontext->check_varassign($line, $varname, $op, $value);
 		} elsif ($text =~ regex_mk_shellcmd) {
 			my ($shellcmd) = ($1);
 			checkline_mk_shellcmd($line, $shellcmd);
 		} elsif ($text =~ regex_mk_include) {
 			my ($include, $includefile) = ($1, $2);
 			$opt_debug_include and $line->log_debug("includefile=${includefile}");
 			checkline_relative_path($line, $includefile, $include eq "include");
 			if ($includefile =~ m"../Makefile$") {
 				$line->log_error("Other Makefiles must not be included directly.");
 				$line->explain_warning(
 "If you want to include portions of another Makefile, extract",
 "the common parts and put them into a Makefile.common. After",
 "that, both this one and the other package should include the",
 "Makefile.common.");
+			}
 			if ($includefile eq "../../mk/bsd.prefs.mk") {
 				if ($line->fname =~ m"buildlink3\.mk$") {
 					$line->log_note("For efficiency reasons, please include bsd.fast.prefs.mk instead of bsd.prefs.mk.");
+				}
 				$seen_bsd_prefs_mk = true;
 			} elsif ($includefile eq "../../mk/bsd.fast.prefs.mk") {
 				$seen_bsd_prefs_mk = true;
+			}
 			if ($includefile =~ m"/x11-links/buildlink3\.mk$") {
 				$line->log_error("${includefile} must not be included directly. Include \"../../mk/x11.buildlink3.mk\" instead.");
+			}
 			if ($includefile =~ m"/intltool/buildlink3\.mk$") {
 				$line->log_warning("Please say \"USE_TOOLS+= intltool\" instead of this line.");
+			}
 			if ($includefile =~ m"(.*)/builtin\.mk$") {
 				my ($dir) = ($1);
 				$line->log_error("${includefile} must not be included directly. Include \"${dir}/buildlink3.mk\" instead.");
+			}
 		} elsif ($text =~ regex_mk_sysinclude) {
 			my ($includefile, $comment) = ($1, $2);
 			# No further action.
 		} elsif ($text =~ regex_mk_cond) {
 			my ($indent, $directive, $args, $comment) = ($1, $2, $3, $4);
 			use constant regex_directives_with_args => qr"^(?:if|ifdef|ifndef|elif|for|undef)$";
 			if ($directive =~ m"^(?:endif|endfor|elif|else)$") {
 				if ($#{$mkctx_indentations} >= 1) {
 					pop(@{$mkctx_indentations});
 				} else {
 					$line->log_error("Unmatched .${directive}.");
+				}
+			}
 			# Check the indentation
 			if ($indent ne " " x $mkctx_indentations->[-1]) {
 				$opt_warn_space and $line->log_note("This directive should be indented by ".$mkctx_indentations->[-1]." spaces.");
+			}
 			if ($directive eq "if" && $args =~ m"^!defined\([\w]+_MK\)$") {
 				push(@{$mkctx_indentations}, $mkctx_indentations->[-1]);
 			} elsif ($directive =~ m"^(?:if|ifdef|ifndef|for|elif|else)$") {
 				push(@{$mkctx_indentations}, $mkctx_indentations->[-1] + 2);
+			}
 			if ($directive =~ regex_directives_with_args && !defined($args)) {
 				$line->log_error("\".${directive}\" must be given some arguments.");
 			} elsif ($directive !~ regex_directives_with_args && defined($args)) {
 				$line->log_error("\".${directive}\" does not take arguments.");
 				if ($directive eq "else") {
 					$line->log_note("If you meant \"else if\", use \".elif\".");
+				}
 			} elsif ($directive eq "if" || $directive eq "elif") {
 				checkline_mk_cond($line, $args);
 			} elsif ($directive eq "ifdef" || $directive eq "ifndef") {
 				if ($args =~ m"\s") {
 					$line->log_error("The \".${directive}\" directive can only handle _one_ argument.");
 				} else {
 					$line->log_warning("The \".${directive}\" directive is deprecated. Please use \".if "
 						. (($directive eq "ifdef" ? "" : "!"))
 						. "defined(${args})\" instead.");
+				}
 			} elsif ($directive eq "for") {
 				if ($args =~ m"^(\S+(?:\s*\S+)*?)\s+in\s+(.*)$") {
 					my ($vars, $values) = ($1, $2);
 					foreach my $var (split(qr"\s+", $vars)) {
 						if (!$is_internal && $var =~ m"^_") {
 							$line->log_warning("Variable names starting with an underscore are reserved for internal pkgsrc use.");
+						}
 						if ($var =~ m"^[_a-z][_a-z0-9]*$") {
 							# Fine.
 						} elsif ($var =~ m"[A-Z]") {
 							$line->log_warning(".for variable names should not contain uppercase letters.");
 						} else {
 							$line->log_error("Invalid variable name \"${var}\".");
+						}
 						$mkctx_for_variables->{$var} = true;
+					}
 					# Check if any of the value's types is not guessed.
 					my $guessed = true;
 					foreach my $value (split(qr"\s+", $values)) { # XXX: too simple
 						if ($value =~ m"^\$\{(.*)\}") {
 							my $type = get_variable_type($line, $1);
 							if (defined($type) && !$type->is_guessed()) {
 								$guessed = false;
+							}
+						}
+					}
 					my $for_loop_type = PkgLint::Type->new(
 						LK_INTERNAL,
 						"Unchecked",
 						[[qr".*", "pu"]],
 						$guessed
 					);
 					my $for_loop_context = PkgLint::VarUseContext->new(
 						VUC_TIME_LOAD,
 						$for_loop_type,
 						VUC_SHELLWORD_FOR,
 						VUC_EXTENT_WORD
 					);
 					foreach my $var (@{extract_used_variables($line, $values)}) {
 						checkline_mk_varuse($line, $var, "", $for_loop_context);
+					}
+				}
 			} elsif ($directive eq "undef" && defined($args)) {
 				foreach my $var (split(qr"\s+", $args)) {
 					if (exists($mkctx_for_variables->{$var})) {
 						$line->log_note("Using \".undef\" after a \".for\" loop is unnecessary.");
+					}
+				}
+			}
 		} elsif ($text =~ regex_mk_dependency) {
 			my ($targets, $dependencies) = ($1, $2);
 			$opt_debug_misc and $line->log_debug("targets=${targets}, dependencies=${dependencies}");
 			$mkctx_target = $targets;
 			foreach my $source (split(/\s+/, $dependencies)) {
 				if ($source eq ".PHONY") {
 					foreach my $target (split(/\s+/, $targets)) {
 						$allowed_targets->{$target} = true;
+					}
+				}
+			}
 			foreach my $target (split(/\s+/, $targets)) {
 				if ($target eq ".PHONY") {
 					foreach my $dep (split(qr"\s+", $dependencies)) {
 						$allowed_targets->{$dep} = true;
+					}
 				} elsif ($target eq ".ORDER") {
 					# TODO: Check for spelling mistakes.
 				} elsif (!exists($allowed_targets->{$target})) {
 					$line->log_warning("Unusual target \"${target}\".");
 					$line->explain_warning(
 "If you really want to define your own targets, you can \"declare\"",
 "them by inserting a \".PHONY: my-target\" line before this line. This",
 "will tell make(1) to not interpret this target's name as a filename.");
+				}
+			}
 		} elsif ($text =~ m"^\.\s*(\S*)") {
 			my ($directive) = ($1);
 			$line->log_error("Unknown directive \".${directive}\".");
 		} elsif ($text =~ m"^ ") {
 			$line->log_warning("Makefile lines should not start with space characters.");
 			$line->explain_warning(
 "If you want this line to contain a shell program, use a tab",
 "character for indentation. Otherwise please remove the leading",
 "white-space.");
 		} else {
 			$line->log_error("[Internal] Unknown line format: $text");
+		}
+	}
 	if (@{$lines} > 0) {
 		$substcontext->check_end($lines->[-1]);
+	}
 	checklines_trailing_empty_lines($lines);
 	if ($#{$mkctx_indentations} != 0) {
 		$lines->[-1]->log_error("Directive indentation is not 0, but ".$mkctx_indentations->[-1]." at EOF.");
+	}
 	# Clean up global variables.
 	$mkctx_for_variables = undef;
 	$mkctx_indentations = undef;
 	$mkctx_target = undef;
 	$mkctx_vardef = undef;
 	$mkctx_build_defs = undef;
 	$mkctx_plist_vars = undef;
 	$mkctx_tools = undef;
 	$mkctx_varuse = undef;
+}
 sub checklines_buildlink3_inclusion($) {
 	my ($lines) = @_;
 	my ($included_files);
 	assert(@{$lines} != 0, "The lines array must be non-empty.");
 	$opt_debug_trace and log_debug($lines->[0]->fname, NO_LINES, "checklines_buildlink3_inclusion()");
 	if (!defined($pkgctx_bl3)) {
 		return;
+	}
 	# Collect all the included buildlink3.mk files from the file.
 	$included_files = {};
 	foreach my $line (@{$lines}) {
 		if ($line->text =~ regex_mk_include) {
 			my (undef, $file, $comment) = ($1, $2, $3);
 			if ($file =~ m"^\.\./\.\./(.*)/buildlink3\.mk") {
 				my ($bl3) = ($1);
 				$included_files->{$bl3} = $line;
 				if (!exists($pkgctx_bl3->{$bl3})) {
 					$line->log_warning("${bl3}/buildlink3.mk is included by this file but not by the package.");
+				}
+			}
+		}
+	}
 	# Print debugging messages for all buildlink3.mk files that are
 	# included by the package but not by this buildlink3.mk file.
 	foreach my $package_bl3 (sort(keys(%{$pkgctx_bl3}))) {
 		if (!exists($included_files->{$package_bl3})) {
 			$opt_debug_misc and $pkgctx_bl3->{$package_bl3}->log_debug("${package_bl3}/buildlink3.mk is included by the package but not by the buildlink3.mk file.");
+		}
+	}
+}
+#
 # Procedures to check a single file.
+#
 sub checkfile_ALTERNATIVES($) {
 	my ($fname) = @_;
 	my ($lines);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_ALTERNATIVES()");
 	checkperms($fname);
 	if (!($lines = load_file($fname))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
+}
 sub checklines_buildlink3_mk_2009($$$);
 sub checklines_buildlink3_mk_pre2009($$);
 sub checkfile_buildlink3_mk($) {
 	my ($fname) = @_;
 	my ($lines, $lineno, $m);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_buildlink3_mk()");
 	checkperms($fname);
 	if (!($lines = load_lines($fname, true))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
 	if (@{$lines} == 0) {
 		log_error($fname, NO_LINES, "Must not be empty.");
 		return;
+	}
 	parselines_mk($lines);
 	checklines_mk($lines);
 	$lineno = 0;
 	# Header comments
 	while ($lineno <= $#{$lines} && (my $text = $lines->[$lineno]->text) =~ m"^#") {
 		if ($text =~ m"^# XXX") {
 			$lines->[$lineno]->log_note("Please read this comment and remove it if appropriate.");
+		}
 		$lineno++;
+	}
 	expect_empty_line($lines, \$lineno);
 	# This line does not belong here, but appears often.
 	if (expect($lines, \$lineno, qr"^BUILDLINK_DEPMETHOD\.(\S+)\?=.*$")) {
 		$lines->[$lineno - 1]->log_warning("This line belongs inside the .ifdef block.");
 		while ($lines->[$lineno]->text eq "") {
 			$lineno++;
+		}
+	}
 	if (($m = expect($lines, \$lineno, qr"^BUILDLINK_TREE\+=\s*(\S+)$"))) {
 		checklines_buildlink3_mk_2009($lines, $lineno, $m->text(1));
 	} else {
 		checklines_buildlink3_mk_pre2009($lines, $lineno);
+	}
+}
 sub checklines_buildlink3_mk_pre2009($$) {
 	my ($lines, $lineno) = @_;
 	my ($m);
 	my ($bl_PKGBASE_line, $bl_PKGBASE);
 	my ($bl_pkgbase_line, $bl_pkgbase);
 	my ($abi_line, $abi_pkg, $abi_version);
 	my ($api_line, $api_pkg, $api_version);
 	# First paragraph: Reference counters.
 	if (!expect($lines, \$lineno, qr"^BUILDLINK_DEPTH:=\t+\$\{BUILDLINK_DEPTH\}\+$")) {
 		# When none of the formats has been found, prefer the 2009 format.
 		lines_log_warning($lines, $lineno, "Expected BUILDLINK_TREE line.");
 		return;
+	}
 	if (($m = expect($lines, \$lineno, qr"^(.*)_BUILDLINK3_MK:=\t*\$\{\1_BUILDLINK3_MK\}\+$"))) {
 		$bl_PKGBASE_line = $lines->[$lineno - 1];
 		$bl_PKGBASE = $m->text(1);
 		$opt_debug_misc and $bl_PKGBASE_line->log_debug("bl_PKGBASE=${bl_PKGBASE}");
 	} else {
 		lines_log_warning($lines, $lineno, "Expected {PKGNAME}_BUILDLINK3_MK:= \${{PKGNAME}_BUILDLINK3_MK}+.");
 		return;
+	}
 	expect_empty_line($lines, \$lineno);
 	# Second paragraph: Adding the dependency.
 	if (!expect($lines, \$lineno, qr"^\.if !empty\(BUILDLINK_DEPTH:M\+\)$")) {
 		if (!expect_text($lines, \$lineno, ".if \${BUILDLINK_DEPTH} == \"+\"")) {
 			return;
+		}
+	}
 	if (($m = expect($lines, \$lineno, qr"^BUILDLINK_DEPENDS\+=\t+(\S+)$"))) {
 		$bl_pkgbase_line = $lines->[$lineno - 1];
 		$bl_pkgbase = $m->text(1);
 		$opt_debug_misc and $bl_pkgbase_line->log_debug("bl_pkgbase=${bl_pkgbase}");
 	} else {
 		lines_log_warning($lines, $lineno, "BUILDLINK_DEPENDS line expected.");
 		return;
+	}
 	my $norm_bl_pkgbase = $bl_pkgbase;
 	$norm_bl_pkgbase =~ s/-/_/g;
 	$norm_bl_pkgbase = uc($norm_bl_pkgbase);
 	if ($norm_bl_pkgbase ne $bl_PKGBASE) {
 		$bl_PKGBASE_line->log_error("Package name mismatch between ${bl_PKGBASE} ...");
 		$bl_pkgbase_line->log_error("... and ${bl_pkgbase}.");
+	}
 	if (defined($effective_pkgbase) && $effective_pkgbase ne $bl_pkgbase) {
 		$bl_pkgbase_line->log_error("Package name mismatch between ${bl_pkgbase} ...");
 		$effective_pkgname_line->log_error("... and ${effective_pkgbase}.");
+	}
 	if (!expect_text($lines, \$lineno, ".endif")) {
 		return;
+	}
 	expect_empty_line($lines, \$lineno);
 	# Third paragraph: Duplicate elimination.
 	if (expect($lines, \$lineno, qr"^BUILDLINK_PACKAGES:=\t+\$\{BUILDLINK_PACKAGES:N\Q${bl_pkgbase}\E\}\s+\Q${bl_pkgbase}\E$")) {
 		# The compressed form of duplicate elimination.
 	} else {
 		if (!expect($lines, \$lineno, qr"^BUILDLINK_PACKAGES:=\t+\$\{BUILDLINK_PACKAGES:N\Q${bl_pkgbase}\E\}$")) {
 			lines_log_warning($lines, $lineno, "Expected BUILDLINK_PACKAGES:= \${BUILDLINK_PACKAGES:N${bl_pkgbase}} line.");
 			return;
+		}
 		if (!expect($lines, \$lineno, qr"^BUILDLINK_PACKAGES\+=\t+\Q${bl_pkgbase}\E$")) {
 			lines_log_warning($lines, $lineno, "Expected BUILDLINK_PACKAGES+= ${bl_pkgbase} line.");
 			return;
+		}
+	}
 	expect_text($lines, \$lineno, "BUILDLINK_ORDER:=\t\${BUILDLINK_ORDER} \${BUILDLINK_DEPTH}${bl_pkgbase}");
 	expect_empty_line($lines, \$lineno);
 	# Fourth paragraph: Package information.
 	if (!expect($lines, \$lineno, qr"^\.if !empty\(\Q${bl_PKGBASE}\E_BUILDLINK3_MK:M\+\)$")) {
 		if (!expect_text($lines, \$lineno, ".if \${${bl_PKGBASE}_BUILDLINK3_MK} == \"+\"")) {
 			return;
+		}
+	}
 	while (!expect($lines, \$lineno, qr"^\.endif.*$")) {
 		if ($lineno > $#{$lines}) {
 			lines_log_warning($lines, $lineno, "Expected .endif");
 			return;
+		}
 		my $line = $lines->[$lineno];
 		if (($m = expect($lines, \$lineno, regex_varassign))) {
 			my ($varname, $value) = ($m->text(1), $m->text(3));
 			my $do_check = false;
 			if ($varname eq "BUILDLINK_ABI_DEPENDS.${bl_pkgbase}") {
 				$abi_line = $line;
 				if ($value =~ regex_dependency_gt) {
 					($abi_pkg, $abi_version) = ($1, $2);
 				} elsif ($value =~ regex_dependency_wildcard) {
 					($abi_pkg) = ($1);
 				} else {
 					$opt_debug_unchecked and $line->log_debug("Unchecked dependency pattern \"${value}\".");
+				}
 				$do_check = true;
+			}
 			if ($varname eq "BUILDLINK_API_DEPENDS.${bl_pkgbase}") {
 				$api_line = $line;
 				if ($value =~ regex_dependency_gt) {
 					($api_pkg, $api_version) = ($1, $2);
 				} elsif ($value =~ regex_dependency_wildcard) {
 					($api_pkg) = ($1);
 				} else {
 					$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);
+}
 # This code is copy-pasted from checklines_buildlink3_mk_pre2009, which
 # will disappear after branching 2010Q1.
+#
 # In 2009, the format of the buildlink3.mk files has been revised to
 # improve the speed of pkgsrc. As a result, the file format has improved
 # in legibility and size.
 sub checklines_buildlink3_mk_2009($$$) {
 	my ($lines, $lineno, $pkgid) = @_;
 	my ($m);
 	my ($bl_PKGBASE_line, $bl_PKGBASE);
 	my ($bl_pkgbase_line, $bl_pkgbase);
 	my ($abi_line, $abi_pkg, $abi_version);
 	my ($api_line, $api_pkg, $api_version);
 	# First paragraph: Introduction of the package identifier
 	$bl_pkgbase_line = $lines->[$lineno - 1];
 	$bl_pkgbase = $pkgid;
 	$opt_debug_misc and $bl_pkgbase_line->log_debug("bl_pkgbase=${bl_pkgbase}");
 	expect_empty_line($lines, \$lineno);
 	# Second paragraph: multiple inclusion protection and introduction
 	# of the uppercase package identifier.
 	return unless ($m = expect_re($lines, \$lineno, qr"^\.if !defined\((\S+)_BUILDLINK3_MK\)$"));
 	$bl_PKGBASE_line = $lines->[$lineno - 1];
 	$bl_PKGBASE = $m->text(1);
 	$opt_debug_misc and $bl_PKGBASE_line->log_debug("bl_PKGBASE=${bl_PKGBASE}");
 	expect_re($lines, \$lineno, qr"^\Q$bl_PKGBASE\E_BUILDLINK3_MK:=$");
 	expect_empty_line($lines, \$lineno);
 	my $norm_bl_pkgbase = $bl_pkgbase;
 	$norm_bl_pkgbase =~ s/-/_/g;
 	$norm_bl_pkgbase = uc($norm_bl_pkgbase);
 	if ($norm_bl_pkgbase ne $bl_PKGBASE) {
 		$bl_PKGBASE_line->log_error("Package name mismatch between ${bl_PKGBASE} ...");
 		$bl_pkgbase_line->log_error("... and ${bl_pkgbase}.");
+	}
 	if (defined($effective_pkgbase) && $effective_pkgbase ne $bl_pkgbase) {
 		$bl_pkgbase_line->log_error("Package name mismatch between ${bl_pkgbase} ...");
 		$effective_pkgname_line->log_error("... and ${effective_pkgbase}.");
+	}
 	# Third paragraph: Package information.
 	my $if_level = 1; # the first .if is from the second paragraph.
 	while (true) {
 		if ($lineno > $#{$lines}) {
 			lines_log_warning($lines, $lineno, "Expected .endif");
 			return;
+		}
 		my $line = $lines->[$lineno];
 		if (($m = expect($lines, \$lineno, regex_varassign))) {
 			my ($varname, $value) = ($m->text(1), $m->text(3));
 			my $do_check = false;
 			if ($varname eq "BUILDLINK_ABI_DEPENDS.${bl_pkgbase}") {
 				$abi_line = $line;
 				if ($value =~ regex_dependency_gt) {
 					($abi_pkg, $abi_version) = ($1, $2);
 				} elsif ($value =~ regex_dependency_wildcard) {
 					($abi_pkg) = ($1);
 				} else {
 					$opt_debug_unchecked and $line->log_debug("Unchecked dependency pattern \"${value}\".");
+				}
 				$do_check = true;
+			}
 			if ($varname eq "BUILDLINK_API_DEPENDS.${bl_pkgbase}") {
 				$api_line = $line;
 				if ($value =~ regex_dependency_gt) {
 					($api_pkg, $api_version) = ($1, $2);
 				} elsif ($value =~ regex_dependency_wildcard) {
 					($api_pkg) = ($1);
 				} else {
 					$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.");
+				}
+			}
 			if ($varname eq "pkgbase") {
-				expect_re($lines, \$lineno, "^\.\s*include \"../../mk/pkg-build-options.mk\"$");
+				expect_re($lines, \$lineno, qr"^\.\s*include \"../../mk/pkg-build-options.mk\"$");
+			}
 			# TODO: More checks.
 		} elsif (expect($lines, \$lineno, qr"^(?:#.*)?$")) {
 			# Comments and empty lines are fine here.
 		} elsif (expect($lines, \$lineno, qr"^\.\s*include \"\.\./\.\./([^/]+/[^/]+)/buildlink3\.mk\"$")
 			|| expect($lines, \$lineno, qr"^\.\s*include \"\.\./\.\./mk/(\S+)\.buildlink3\.mk\"$")) {
 			# TODO: Maybe check dependency lines.
 		} elsif (expect($lines, \$lineno, qr"^\.if !empty\(PKG_BUILD_OPTIONS\.\Q${bl_pkgbase}\E:M\S+\)$")) {
 			$if_level++;
 		} elsif (expect($lines, \$lineno, qr"^\.endif.*$")) {
 			$if_level--;
 			last if $if_level == 0;
 		} else {
 			$opt_debug_unchecked and lines_log_warning($lines, $lineno, "Unchecked line in third paragraph.");
 			$lineno++;
+		}
+	}
 	if (!defined($api_line)) {
 		$lines->[$lineno - 1]->log_warning("Definition of BUILDLINK_API_DEPENDS is missing.");
+	}
 	expect_empty_line($lines, \$lineno);
 	# Fourth paragraph: Cleanup, corresponding to the first paragraph.
 	return unless expect_re($lines, \$lineno, qr"^BUILDLINK_TREE\+=\s*-\Q$bl_pkgbase\E$");
 	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->{"PKG_DESTDIR_SUPPORT"}) && !exists($pkgctx_vardef->{"META_PACKAGE"})) {
 		log_warning($fname, NO_LINE_NUMBER, "This package has not set PKG_DESTDIR_SUPPORT.");
+	}
 	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}.");
 		# XXX: too many false positives
 		if (false && $pkgpath =~ m"/([^/]+)$" && $effective_pkgbase ne $1) {
 			$effective_pkgname_line->log_warning("Mismatch between PKGNAME ($effective_pkgname) and package directory ($1).");
+		}
+	}
 	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;
+			}
+		}
 	};
 	# @param deldelta
 	#	The number of lines that are deleted from the patched file.
 	# @param adddelta
 	#	The number of lines that are added to the patched file.
 	# @param newstate
 	#	The follow-up state when this line is the last line to be
 	#	added in this hunk of the patch.
+	#
 	my $check_hunk_line = sub($$$) {
 		my ($deldelta, $adddelta, $newstate) = @_;
 		$check_contents->();
 		$check_hunk_end->($deldelta, $adddelta, $newstate);
 		# If -Wextra is given, the context lines are checked for
 		# absolute paths and similar things. If it is not given,
 		# only those lines that really add something to the patched
 		# file are checked.
 		if ($adddelta != 0 && ($deldelta == 0 || $opt_warn_extra)) {
 			$check_added_contents->();
+		}
 	};
 	my $transitions =
 		# [ from state, regex, to state, action ]
 		[   [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);
 		}], [PST_CLD0, re_patch_cld, PST_CLD, sub() {
 			$check_hunk_line->(1, 0, PST_CLD0);
 		}], [PST_CLD0, re_patch_clm, PST_CLD, sub() {
 			$check_hunk_line->(1, 0, PST_CLD0);
 		}], [PST_CLD, re_patch_clc, PST_CLD, sub() {
 			$check_hunk_line->(1, 0, PST_CLD0);
 		}], [PST_CLD, re_patch_cld, PST_CLD, sub() {
 			$check_hunk_line->(1, 0, PST_CLD0);
 		}], [PST_CLD, re_patch_clm, PST_CLD, sub() {
 			$check_hunk_line->(1, 0, PST_CLD0);
 		}], [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);
 		}], [PST_CLA0, re_patch_clm, PST_CLA, sub() {
 			$check_hunk_line->(0, 1, PST_CH);
 		}], [PST_CLA0, re_patch_cla, PST_CLA, sub() {
 			$check_hunk_line->(0, 1, PST_CH);
 		}], [PST_CLA, re_patch_clc, PST_CLA, sub() {
 			$check_hunk_line->(0, 1, PST_CH);
 		}], [PST_CLA, re_patch_clm, PST_CLA, sub() {
 			$check_hunk_line->(0, 1, PST_CH);
 		}], [PST_CLA, re_patch_cla, PST_CLA, sub() {
 			$check_hunk_line->(0, 1, PST_CH);
 		}], [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);
 		}], [PST_UL, re_patch_ula, PST_UL, sub() {
 			$check_hunk_line->(0, 1, PST_UH);
 		}], [PST_UL, re_patch_ulc, PST_UL, sub() {
 			$check_hunk_line->(1, 1, PST_UH);
 		}], [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);
 		}], [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_error("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) {