 @@ -1,1001 +1,1001 @@
 #! @PERL@
-# $NetBSD: pkglint.pl,v 1.862 2014/01/13 01:54:52 cheusov Exp $
+# $NetBSD: pkglint.pl,v 1.863 2014/03/02 08:39:01 obache 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;
 use PkgLint::Util;
 use PkgLint::Logging;
 use PkgLint::SimpleMatch;
 use PkgLint::Line;
 use PkgLint::FileUtil;
 use PkgLint::Type;
 use PkgLint::VarUseContext;
 use PkgLint::SubstContext;
 use PkgLint::CVS_Entry;
 use PkgLint::Change;
 package pkglint;
 #==========================================================================
 # This package contains the application-specific code of pkglint.
 # Most subroutines in this package follow a strict naming convention:
+#
 # The get_*() functions provide easy access to important non-trivial data
 # structures that are loaded from external files and are therefore cached.
+#
 # The is_*() functions return a boolean value and have no side effects.
+#
 # The checkline_*() procedures check a single line for compliance with some
 # rules.
+#
 # The checklines_*() procedures check an array of lines for compliance.
 # Usually they make use of several checkline_*() procedures.
+#
 # The checkfile_*() procedures load a file and check the lines of that
 # file. Usually they make use of several checklines_*() and checkline_*()
 # procedures.
+#
 # The checkdir_*() procedures check the files of a directory and call
 # checkfile_*() on them.
+#
 # Note: I have tried to order the subroutines so that there are no
 # back-references, that is, if you start reading the code from the top to
 # the bottom you should not find a call to a subroutine you haven't yet
 # seen.
 #==========================================================================
 use strict;
 use warnings;
 use Data::Dumper;
 use Digest::SHA1;
 use Getopt::Long qw(:config no_ignore_case bundling require_order);
 use Fcntl qw(:mode);
 use File::Basename;
 use File::stat;
 use Cwd;
 use pkgsrc::Dewey;
 BEGIN {
 	import PkgLint::Util qw(
 		array_to_hash assert
 		false true dont_know doesnt_matter
 		normalize_pathname
 	);
 	import PkgLint::Logging qw(
 		NO_FILE NO_LINE_NUMBER NO_LINES
 		log_fatal log_error log_warning log_note log_debug
 		explain_error explain_warning explain_info
 	);
 	import PkgLint::FileUtil qw(
 		load_file load_lines
 		save_autofix_changes
 	);
 	import PkgLint::Type qw(
 		LK_NONE LK_INTERNAL LK_EXTERNAL
 		GUESSED NOT_GUESSED
 	);
 	import PkgLint::VarUseContext 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
 	);
+}
+#
 # Buildtime configuration
+#
 use constant conf_distver	=> '@DISTVER@';
 use constant conf_make		=> '@MAKE@';
 use constant conf_datadir	=> '@DATADIR@';
+#
 # Global variables that can be modified via command line options.
+#
 # The pkgsrc directory, relative to the current working directory of
 # pkglint.
 my $cwd_pkgsrcdir	= undef;
 # The pkgsrc directory, relative to the directory that is currently
 # checked.
 my $cur_pkgsrcdir	= undef;
+#
 # Command Line Options
+#
 my $opt_check_ALTERNATIVES = true;
 my $opt_check_bl3	= true;
 my $opt_check_DESCR	= true;
 my $opt_check_distinfo	= true;
 my $opt_check_extra	= false;
 my $opt_check_global	= false;
 my $opt_check_INSTALL	= true;
 my $opt_check_Makefile	= true;
 my $opt_check_MESSAGE	= true;
 my $opt_check_mk	= true;
 my $opt_check_patches	= true;
 my $opt_check_PLIST	= true;
 my (%checks) = (
 	"ALTERNATIVES"	=> [\$opt_check_ALTERNATIVES, "check ALTERNATIVES files"],
 	"bl3"		=> [\$opt_check_bl3, "check buildlink3 files"],
 	"DESCR"		=> [\$opt_check_DESCR, "check DESCR file"],
 	"distinfo"	=> [\$opt_check_distinfo, "check distinfo file"],
 	"extra"		=> [\$opt_check_extra, "check various additional files"],
 	"global"	=> [\$opt_check_global, "inter-package checks"],
 	"INSTALL"	=> [\$opt_check_INSTALL, "check INSTALL and DEINSTALL scripts"],
 	"Makefile"	=> [\$opt_check_Makefile, "check Makefiles"],
 	"MESSAGE"	=> [\$opt_check_MESSAGE, "check MESSAGE files"],
 	"mk"		=> [\$opt_check_mk, "check other .mk files"],
 	"patches"	=> [\$opt_check_patches, "check patches"],
 	"PLIST"		=> [\$opt_check_PLIST, "check PLIST files"],
 );
 my $opt_debug_include	= false;
 my $opt_debug_misc	= false;
 my $opt_debug_patches	= false;
 my $opt_debug_quoting	= false;
 my $opt_debug_shell	= false;
 my $opt_debug_tools	= false;
 my $opt_debug_trace	= false;
 my $opt_debug_unchecked	= false;
 my $opt_debug_unused	= false;
 my $opt_debug_vartypes	= false;
 my $opt_debug_varuse	= false;
 my (%debug) = (
 	"include"	=> [\$opt_debug_include, "included files"],
 	"misc"		=> [\$opt_debug_misc, "all things that didn't fit elsewhere"],
 	"patches"	=> [\$opt_debug_patches, "the states of the patch parser"],
 	"quoting"	=> [\$opt_debug_quoting, "additional information about quoting"],
 	"shell"		=> [\$opt_debug_shell, "the parsers for shell words and shell commands"],
 	"tools"		=> [\$opt_debug_tools, "the tools framework"],
 	"trace"		=> [\$opt_debug_trace, "follow subroutine calls"],
 	"unchecked"	=> [\$opt_debug_unchecked, "show the current limitations of pkglint"],
 	"unused"	=> [\$opt_debug_unused, "unused variables"],
 	"vartypes"	=> [\$opt_debug_vartypes, "additional type information"],
 	"varuse"	=> [\$opt_debug_varuse, "contexts where variables are used"],
 );
 my $opt_warn_absname	= true;
 my $opt_warn_directcmd	= true;
 our $opt_warn_extra	= false;	# used by PkgLint::SubstContext
 my $opt_warn_order	= true;
 my $opt_warn_perm	= false;
 my $opt_warn_plist_depr	= false;
 my $opt_warn_plist_sort	= false;
 my $opt_warn_quoting	= false;
 my $opt_warn_space	= false;
 my $opt_warn_style	= false;
 my $opt_warn_types	= true;
 my $opt_warn_varorder	= false;
 my (%warnings) = (
 	"absname"	=> [\$opt_warn_absname, "warn about use of absolute file names"],
 	"directcmd"	=> [\$opt_warn_directcmd, "warn about use of direct command names instead of Make variables"],
 	"extra"		=> [\$opt_warn_extra, "enable some extra warnings"],
 	"order"		=> [\$opt_warn_order, "warn if Makefile entries are unordered"],
 	"perm"		=> [\$opt_warn_perm, "warn about unforeseen variable definition and use"],
 	"plist-depr"	=> [\$opt_warn_plist_depr, "warn about deprecated paths in PLISTs"],
 	"plist-sort"	=> [\$opt_warn_plist_sort, "warn about unsorted entries in PLISTs"],
 	"quoting"	=> [\$opt_warn_quoting, "warn about quoting issues"],
 	"space"		=> [\$opt_warn_space, "warn about inconsistent use of white-space"],
 	"style"		=> [\$opt_warn_style, "warn about stylistic issues"],
 	"types"		=> [\$opt_warn_types, "do some simple type checking in Makefiles"],
 	"varorder"	=> [\$opt_warn_varorder, "warn about the ordering of variables"],
 );
 my $opt_autofix		= false;
 my $opt_dumpmakefile	= false;
 my $opt_import		= false;
 my $opt_quiet		= false;
 my $opt_recursive	= false;
 my $opt_rcsidstring	= "NetBSD";
 my (@options) = (
 	# [ usage-opt, usage-message, getopt-opt, getopt-action ]
 	[ "-C{check,...}", "Enable or disable specific checks",
 	  "check|C=s",
 	  sub {
 		my ($opt, $val) = @_;
 		parse_multioption($val, \%checks);
 	  } ],
 	[ "-D{debug,...}", "Enable or disable debugging categories",
 	  "debugging|D=s",
 	  sub ($$) {
 		my ($opt, $val) = @_;
 		parse_multioption($val, \%debug);
 	  } ],
 	[ "-F|--autofix", "Try to automatically fix some errors (experimental)",
 	  "autofix|F", \$opt_autofix ],
 	[ "-I|--dumpmakefile", "Dump the Makefile after parsing",
 	  "dumpmakefile|I", \$opt_dumpmakefile ],
 	[ "-R|--rcsidstring", "Set the allowed RCS Id strings",
 	  "rcsidstring|R=s", \$opt_rcsidstring ],
 	[ "-V|--version", "print the version number of pkglint",
 	  "version|V",
 	  sub {
 		print(conf_distver . "\n");
 		exit(0);
 	  } ],
 	[ "-W{warn,...}", "enable or disable specific warnings",
 	  "warning|W=s",
 	  sub {
 		my ($opt, $val) = @_;
 		parse_multioption($val, \%warnings);
 	  } ],
 	[ "-e|--explain", "Explain the diagnostics or give further help",
 	  "explain|e", sub {
 		PkgLint::Logging::set_explain();
 	  } ],
 	[ "-g|--gcc-output-format", "Mimic the gcc output format",
 	  "gcc-output-format|g",
 	  sub {
 		PkgLint::Logging::set_gcc_output_format();
 	  } ],
 	[ "-h|--help", "print a detailed help message",
 	  "help|h",
 	  sub {
 		help(*STDOUT, 0, 1);
 	  } ],
 	[ "-i|--import", "Prepare the import of a wip package",
 	  "import|i", \$opt_import ],
 	# Note: This is intentionally undocumented.
 	[ "--pkgsrcdir", "Set the root directory of pkgsrc explicitly.",
 	  "pkgsrcdir=s", \$cwd_pkgsrcdir ],
 	[ "-q|--quiet", "Don't print a summary line when finishing",
 	  "quiet|q", \$opt_quiet ],
 	[ "-r|--recursive", "Recursive---check subdirectories, too",
 	  "recursive|r", \$opt_recursive ],
 	[ "-s|--source", "Show the source lines together with diagnostics",
 	  "source|s",
 	  sub {
 		PkgLint::Logging::set_show_source_flag();
 	  } ],
 );
 our $program		= $0;
+#
 # Commonly used regular expressions.
+#
 use constant regex_dependency_lge => qr"^((?:\$\{[\w_]+\}|[\w_\.]|-[^\d])+)[<>]=?(\d[^-*?\[\]]*)$";
 use constant regex_dependency_wildcard
 				=> qr"^((?:\$\{[\w_]+\}|[\w_\.]|-[^\d\[])+)-(?:\[0-9\]\*|\d[^-]*)$";
 use constant regex_gnu_configure_volatile_vars
 				=> qr"^(?:.*_)?(?:CFLAGS||CPPFLAGS|CXXFLAGS|FFLAGS|LDFLAGS|LIBS)$";
 use constant regex_mk_comment	=> qr"^ *\s*#(.*)$";
 use constant regex_mk_cond	=> qr"^\.(\s*)(if|ifdef|ifndef|else|elif|endif|for|endfor|undef)(?:\s+([^\s#][^#]*?))?\s*(?:#.*)?$";
 use constant regex_mk_dependency=> qr"^([^\s:]+(?:\s*[^\s:]+)*)(\s*):\s*([^#]*?)(?:\s*#.*)?$";
 use constant regex_mk_include	=> qr"^\.\s*(s?include)\s+\"([^\"]+)\"\s*(?:#.*)?$";
 use constant regex_mk_sysinclude=> qr"^\.\s*s?include\s+<([^>]+)>\s*(?:#.*)?$";
 use constant regex_mk_shellvaruse => qr"(?:^|[^\$])\$\$\{?(\w+)\}?"; # XXX: not perfect
 use constant regex_pkgname	=> qr"^([\w\-.+]+)-(\d(?:\w|\.\d)*)$";
 use constant regex_mk_shellcmd	=> qr"^\t(.*)$";
 use constant regex_rcs_conflict	=> qr"^(<<<<<<<|=======|>>>>>>>)";
 use constant regex_unresolved	=> qr"\$\{";
 use constant regex_validchars	=> qr"[\011\040-\176]";
 # Note: the following regular expression looks more complicated than
 # necessary to avoid a stack overflow in the Perl interpreter.
 # The leading white-space may only consist of \040 characters, otherwise
 # the order of regex_varassign and regex_mk_shellcmd becomes important.
 use constant regex_varassign	=> qr"^ *([-*+A-Z_a-z0-9.\${}\[]+?)\s*(=|\?=|\+=|:=|!=)\s*((?:[^\\#\s]+|\s+?|(?:\\#)+|\\)*?)(?:\s*(#.*))?$";
 use constant regex_sh_varassign	=> qr"^([A-Z_a-z][0-9A-Z_a-z]*)=";
 # The following "constants" are often used in contexts where
 # interpolation comes handy, so they are variables. Nevertheless they
 # are not modified.
 # This regular expression cannot parse all kinds of shell programs, but
 # it will catch almost all shell programs that are portable enough to be
 # used in pkgsrc.
 my $regex_shellword		=  qr"\s*(
 	\#.*				# shell comment
+	|
 	(?:	'[^']*'			# single quoted string
 	|	\"(?:\\.|[^\"\\])*\"	# double quoted string
 	|	\`[^\`]*\`		# backticks string
 	|	\\\$\$			# an escaped dollar sign
 	|	\\[^\$]			# other escaped characters
 	|	\$[\w_]			# one-character make(1) variable
 	|	\$\{[^{}]+\}		# make(1) variable
 	|	\$\([^()]+\)		# make(1) variable, $(...)
 	|	\$[/\@<^]		# special make(1) variables
 	|	\$\$[0-9A-Z_a-z]+	# shell variable
 	|	\$\$[\#?@]		# special shell variables
 	|	\$\$\$\$		# the special pid shell variable
 	|	\$\$\{[0-9A-Z_a-z]+\}	# shell variable in braces
 	|	\$\$\(			# POSIX-style backticks replacement
 	|	[^\(\)'\"\\\s;&\|<>\`\$] # non-special character
 	|	\$\{[^\s\"'`]+		# HACK: nested make(1) variables
 	)+ | ;;? | &&? | \|\|? | \( | \) | >& | <<? | >>? | \#.*)"sx;
 my $regex_varname		= qr"(?:[-*+.0-9A-Z_a-z{}\[]+|\$\{[\w_]+\})+";
 my $regex_pkgbase		= qr"(?:[+.0-9A-Z_a-z]|-[A-Z_a-z])+";
 my $regex_pkgversion		= qr"\d(?:\w|\.\d)*";
+#
 # Commonly used explanations for diagnostics.
+#
 use constant expl_relative_dirs	=> (
 	"Directories in the form \"../../category/package\" make it easier to",
 	"move a package around in pkgsrc, for example from pkgsrc-wip to the",
 	"main pkgsrc repository.");
+#
 # Global variables.
+#
 my $current_dir;		# The currently checked directory.
 my $is_wip;			# Is the current directory from pkgsrc-wip?
 my $is_internal;		# Is the current item from the infrastructure?
+#
 # Variables for inter-package checks.
+#
 my $ipc_distinfo;		# Maps "$alg:$fname" => "checksum".
 my %ipc_used_licenses;		# { license name => true }
 my $ipc_checking_root_recursively; # For checking unused licenses
 # Context of the package that is currently checked.
 my $pkgpath;			# The relative path to the package within PKGSRC
 my $pkgdir;			# PKGDIR from the package Makefile
 my $filesdir;			# FILESDIR from the package Makefile
 my $patchdir;			# PATCHDIR from the package Makefile
 my $distinfo_file;		# DISTINFO_FILE from the package Makefile
 my $effective_pkgname;		# PKGNAME or DISTNAME from the package Makefile
 my $effective_pkgbase;		# The effective PKGNAME without the version
 my $effective_pkgversion;	# The version part of the effective PKGNAME
 my $effective_pkgname_line;	# The origin of the three effective_* values
 my $seen_bsd_prefs_mk;		# Has bsd.prefs.mk already been included?
 my $pkgctx_vardef;		# { varname => line }
 my $pkgctx_varuse;		# { varname => line }
 my $pkgctx_bl3;			# { buildlink3.mk name => line } (contains
 				# only buildlink3.mk files that are directly
 				# included)
 my $pkgctx_plist_subst_cond;	# { varname => 1 } list of all variables
 				# that are used as conditionals (@comment
 				# or nothing) in PLISTs.
 my $pkgctx_included;		# { fname => line }
 my $seen_Makefile_common;	# Does the package have any .includes?
 # Context of the Makefile that is currently checked.
 my $mkctx_for_variables;	# The variables currently used in .for loops
 my $mkctx_indentations;		# Indentation depth of preprocessing directives
 my $mkctx_target;		# Current make(1) target
 my $mkctx_vardef;		# { varname => line } for all variables that
 				# are defined in the current file
 my $mkctx_varuse;		# { varname => line } for all variables
 				# that are used in the current file
 my $mkctx_build_defs;		# Set of variables that are registered in
 				# BUILD_DEFS, to assure that all user-defined
 				# variables are added to it.
 my $mkctx_plist_vars;		# The same for PLIST_VARS.
 my $mkctx_tools;		# Set of tools that are declared to be used.
 my @todo_items;			# The list of directory entries that still need
 				# to be checked. Mostly relevant with
 				# --recursive.
+#
 # Command line parsing and handling.
+#
 sub help($$$) {
 	my ($out, $exitval, $show_all) = @_;
 	my ($prog) = (basename($program, '.pl'));
 	print $out ("usage: $prog [options] [package_directory]\n\n");
 	my (@option_table) = ();
 	foreach my $opt (@options) {
 		push(@option_table, ["  ", $opt->[0], $opt->[1]]);
+	}
 	print $out ("options:\n");
 	PkgLint::Util::print_table($out, \@option_table);
 	print $out ("\n");
 	if (!$show_all) {
 		exit($exitval);
+	}
 	my $categories = [
 		# options, leading text,
 		[ \%checks, "checks", "check" ],
 		[ \%debug, "debugging options", "debug" ],
 		[ \%warnings, "warnings", "warning" ],
 	];
 	foreach my $category (@{$categories}) {
 		my ($options, $leading, $name) = (@{$category});
 		my $table = [
 			["  ", "all", "", "enable all ".$category->[1]],
 			["  ", "none", "", "disable all ".$category->[1]],
 		];
 		foreach my $opt (sort keys %{$options}) {
 			push(@{$table}, [ "  ", $opt,
 				(${$options->{$opt}->[0]} ? "(enabled)" : "(disabled)"),
 				$options->{$opt}->[1]]);
+		}
 		print $out ("${leading}: (use \"${name}\" to enable, \"no-${name}\" to disable)\n");
 		PkgLint::Util::print_table($out, $table);
 		print $out ("\n");
+	}
 	exit($exitval);
+}
 sub parse_multioption($$) {
 	my ($value, $optdefs) = @_;
 	foreach my $opt (split(qr",", $value)) {
 		if ($opt eq "none") {
 			foreach my $key (keys %{$optdefs}) {
 				${$optdefs->{$key}->[0]} = false;
+			}
 		} elsif ($opt eq "all") {
 			foreach my $key (keys %{$optdefs}) {
 				${$optdefs->{$key}->[0]} = true;
+			}
 		} else {
 			my ($value) = (($opt =~ s/^no-//) ? false : true);
 			if (exists($optdefs->{$opt})) {
 				${$optdefs->{$opt}->[0]} = $value;
 			} else {
 				print STDERR ("Invalid option: ${opt}\n");
 				help(*STDERR, 1, 0);
+			}
+		}
+	}
+}
 sub parse_command_line() {
 	my (%options);
 	foreach my $opt (@options) {
 		$options{$opt->[2]} = $opt->[3];
+	}
+	{
 		local $SIG{__WARN__} = sub {};
 		if (!GetOptions(%options)) {
 			help(*STDERR, 1, false);
+		}
+	}
+}
+#
 # Caching subroutines.
+#
 # The get_regex_plurals() function returns a regular expression that
 # matches for all make(1) variable names that are considered lists
 # of something.
+#
 # Rationale:
+#
 # The pkglint author thinks that variables containing lists of things
 # should have a name indicating some plural form. Sadly, there are other
 # reasons like backwards compatibility and other developer's
 # expectations that make changes to most of the following variables
 # highly unlikely.
 my $get_regex_plurals_value = undef;
 sub get_regex_plurals() {
 	if (defined($get_regex_plurals_value)) {
 		return $get_regex_plurals_value;
+	}
 	my @plurals_ok = qw(
 		.*S
 		.*LIST
 		.*_AWK
 		.*_ENV
 		.*_REQD
 		.*_SED
 		.*_SKIP
 		BUILDLINK_LDADD
 		COMMENT
 		EXTRACT_ONLY
 		FETCH_MESSAGE
 		GENERATE_PLIST
 		PLIST_CAT
 		PLIST_PRE
 		PREPEND_PATH
 	);
 	my @plurals_missing_an_s = qw(
 		.*_OVERRIDE
 		.*_PREREQ
 		.*_SRC
 		.*_SUBST
 		.*_TARGET
 		.*_TMPL
 		BUILDLINK_DEPMETHOD
 		BUILDLINK_TRANSFORM
 		EVAL_PREFIX
 		INTERACTIVE_STAGE
 		LICENSE
 		MASTER_SITE_.*
 		MASTER_SORT_REGEX
 		NOT_FOR_COMPILER
 		NOT_FOR_PLATFORM
 		ONLY_FOR_COMPILER
 		ONLY_FOR_PLATFORM
 		PERL5_PACKLIST
 		PKG_FAIL_REASON
 		PKG_SKIP_REASON
 	);
 	my @plurals_reluctantly_accepted = qw(
 		CRYPTO
 		DEINSTALL_TEMPLATE
 		FIX_RPATH
 		INSTALL_TEMPLATE
 		PYTHON_VERSIONS_INCOMPATIBLE
 		REPLACE_INTERPRETER
 		REPLACE_PERL
 		REPLACE_RUBY
 		RESTRICTED
 		SITES_.*
 		TOOLS_ALIASES\.*
 		TOOLS_BROKEN
 		TOOLS_CREATE
 		TOOLS_GNU_MISSING
 		TOOLS_NOOP
 	);
 	my $plurals = join("|",
 		@plurals_ok,
 		@plurals_missing_an_s,
 		@plurals_reluctantly_accepted
 	);
 	$get_regex_plurals_value = qr"^(?:${plurals})$";
 	return $get_regex_plurals_value;
+}
+#
 # Loading pkglint-specific data from files.
+#
 # The symbol table for ACL definitions maps ACL names to ACLs.
 my $acl_definitions = {};
 sub parse_acls($$) {
 	my ($line, $acltext) = @_;
 	my ($acls);
 	use constant ACL_shortcuts => {
 		"b" => qr"(?:^|/)buildlink3\.mk$",
 		"c" => qr"(?:^|/)Makefile\.common$",
 		"h" => qr"(?:^|/)hacks\.mk$",
 		"m" => qr"(?:^|/)Makefile$",
 		"o" => qr"(?:^|/)options\.mk$",
 	};
 	my $regex_acl_entry = qr"^(?:
 		  \$([\w_]+)			# $acl_name
 		| ([\w.*]+|_):([adpsu]*)	# file*mask:perms
 		) (?:\,\s*|$)"x;
 	if (!defined($acltext)) {
 		return undef;
+	}
 	$acls = [];
 	while ($acltext =~ s,$regex_acl_entry,,) {
 		my ($acldef, $subject, $perms) = ($1, $2, $3);
 		if (defined($acldef)) {
 			if (!exists($acl_definitions->{$acldef})) {
 				$line->log_fatal("ACL definition ${acldef} not found.");
 			} else {
 				push(@{$acls}, @{$acl_definitions->{$acldef}});
+			}
 		} else {
 			# Transform $subject to a regular expression.
 			$subject =~ s/\./[.]/g;
 			$subject =~ s/\*/.*/g;
 			push(@{$acls}, [exists(ACL_shortcuts->{$subject}) ? ACL_shortcuts->{$subject} : qr"(?:^|/)${subject}$", $perms]);
+		}
+	}
 	if ($acltext ne "") {
 		$line->log_fatal("Invalid ACL: ${acltext}.");
+	}
 	return $acls;
+}
 my $get_vartypes_basictypes_result = undef;
 sub get_vartypes_basictypes() {
 	if (defined($get_vartypes_basictypes_result)) {
 		return $get_vartypes_basictypes_result;
+	}
 	my $lines = load_file($program);
 	my $types = {};
 	assert($lines, "Couldn't load pkglint.pl from $program");
 	foreach my $line (@$lines) {
 		if ($line->text =~ m"^\s+(\w+) => sub \{$") {
 			# XXX lookup in %type_dispatch instead
 			$types->{$1} = 1;
+		}
+	}
 	return ($get_vartypes_basictypes_result = $types);
+}
 my $get_vartypes_map_result = undef;
 sub get_vartypes_map() {
 	my ($fname, $vartypes);
 	if (defined($get_vartypes_map_result)) {
 		return $get_vartypes_map_result;
+	}
 	use constant re_acl_def => qr"^
 		acl \s+
 		(\w+) \s+				# ACL name
 		= \s+
 		\[ ([^\]]*) \]				# ACL value
 		(?:\s*\#.*)?				# optional comment
 		$"x;
 	use constant re_vartypedef => qr"^
 		([\w\d_.]+?)				# $1 = variable name
 		(\*|\.\*|) \s+				# $2 = parameterized?
 		(?:(InternalList|List) \s+ of \s+)?	# $3 ?= kind of list
 		(?:([\w\d_]+)				# $4 ?= basic type
 		  | \{\s*([\w\d_+,\-.\s]+?)\s*\})	# $5 ?= enumeration values
 		(?:\s+ \[ ([^\]]*) \])?			# $6 ?= optional ACL
 		(?:\s*\#.*)?				# $7 ?= optional comment
 		$"x;
 	$fname = conf_datadir."/makevars.map";
 	$vartypes = {};
 	if ((my $lines = load_lines($fname, true))) {
 		foreach my $line (@{$lines}) {
 			if ($line->text =~ m"^(?:#.*|\s*)$") {
 				# ignore empty and comment lines
 			} elsif ($line->text =~ re_acl_def) {
 				my ($aclname, $aclvalue) = ($1, $2);
 				$acl_definitions->{$aclname} = parse_acls($line, $aclvalue);
 			} elsif ($line->text =~ re_vartypedef) {
 				my ($varname, $par, $kind_of_list_text, $typename, $enums, $acltext) = ($1, $2, $3, $4, $5, $6);
 				my $kind_of_list = !defined($kind_of_list_text) ? LK_NONE
 				    : ($kind_of_list_text eq "List") ? LK_EXTERNAL
 				    : LK_INTERNAL;
 				if (defined($typename) && !exists(get_vartypes_basictypes()->{$typename})) {
 					$line->log_fatal("Unknown basic type \"$typename\" for variable $varname. "
 						. "Valid basic types are "
 						. join(", ", sort keys %{get_vartypes_basictypes()})
 						. ".");
+				}
 				my $basic_type = defined($enums)
 				    ? array_to_hash(split(qr"\s+", $enums))
 				    : $typename;
 				my $type = PkgLint::Type->new($kind_of_list, $basic_type, parse_acls($line, $acltext), NOT_GUESSED);
 				if ($par eq "" || $par eq "*") {
 					$vartypes->{$varname} = $type;
+				}
 				if ($par eq "*" || $par eq ".*") {
 					$vartypes->{"${varname}.*"} = $type;
+				}
 			} else {
 				$line->log_fatal("Unknown line format.");
+			}
+		}
 	} else {
 		log_fatal($fname, NO_LINE_NUMBER, "Cannot be read.");
+	}
 # TODO: Enable when the time is ripe.
 if (false) {
 	# Additionally, scan mk/defaults/mk.conf for variable
 	# definitions. All these variables are reserved for the user and
 	# must not be set within packages.
 	$fname = "${cwd_pkgsrcdir}/mk/defaults/mk.conf";
 	if ((my $lines = load_file($fname))) {
 		foreach my $line (@{$lines}) {
 			if ($line->text =~ m"^#?([\w_]+)\?=") {
 				my ($varname) = ($1);
 				$opt_debug_misc and $line->log_debug("Found user-definable variable ${varname}.");
 				$vartypes->{$varname} = "Userdefined"; # FIXME: type error
+			}
+		}
 	} else {
 		log_fatal($fname, NO_LINE_NUMBER, "Cannot be read.");
+	}
+}
 	return ($get_vartypes_map_result = $vartypes);
+}
 my $get_deprecated_map_result = undef;
 sub get_deprecated_map() {
 	my ($fname, $lines, $vars);
 	if (defined($get_deprecated_map_result)) {
 		return $get_deprecated_map_result;
+	}
 	$fname = conf_datadir."/deprecated.map";
 	if (!($lines = load_file($fname))) {
 		log_fatal($fname, NO_LINE_NUMBER, "Cannot be read.");
+	}
 	$vars = {};
 	foreach my $line (@{$lines}) {
 		if ($line->text =~ m"^#" || $line->text =~ m"^\s*$") {
 			# Ignore empty and comment lines.
 		} elsif ($line->text =~ m"^(\S+)\s+(.*)$") {
 			$vars->{$1} = $2;
 		} else {
 			$line->log_fatal("Unknown line format.");
+		}
+	}
 	return ($get_deprecated_map_result = $vars);
+}
 my $load_dist_sites_url2name = undef;
 my $load_dist_sites_names = undef;
 sub load_dist_sites() {
 	my ($fname) = ("${cwd_pkgsrcdir}/mk/fetch/sites.mk");
 	my ($lines) = load_file($fname);
 	my ($varname) = undef;
 	my ($ignoring) = false;
 	my ($url2name) = {};
 	my ($names) = {};
 	if (!$lines) {
 		log_error($fname, NO_LINE_NUMBER, "Could not be read.");
 		$load_dist_sites_url2name = $url2name;
 		$load_dist_sites_names = $names;
 		return;
+	}
 	foreach my $line (@{$lines}) {
 		my $text = $line->text;
 		if ($text =~ m"^(MASTER_SITE_\w+)\+=\s*\\$"o) {
 			$varname = $1;
 			$names->{$varname} = true;
 			$ignoring = false;
 		} elsif ($text eq "MASTER_SITE_BACKUP?=\t\\") {
 			$ignoring = true;
 		} elsif ($text =~ m"^\t((?:http://|ftp://)\S+/)(?:|\s*\\)$"o) {
 			if (!$ignoring) {
 				if (defined($varname)) {
 					$url2name->{$1} = $varname;
 				} else {
 					$line->log_error("Lonely URL found.");
+				}
+			}
 		} elsif ($text =~ m"^(?:#.*|\s*)$") {
 			# ignore empty and comment lines
 		} elsif ($text =~ m"BSD_SITES_MK") {
 			# ignore multiple inclusion guards
 		} else {
 			$line->log_fatal("Unknown line type.");
+		}
+	}
 	# Explicitly allowed, although not defined in mk/fetch/sites.mk.
 	$names->{"MASTER_SITE_SUSE_UPD"} = true;
 	$names->{"MASTER_SITE_LOCAL"} = true;
 	$opt_debug_misc and log_debug($fname, NO_LINES, "Loaded " . scalar(keys(%{$url2name})) . " MASTER_SITE_* definitions.");
 	$load_dist_sites_url2name = $url2name;
 	$load_dist_sites_names = $names;
+}
 sub get_dist_sites() {
 	if (!defined($load_dist_sites_url2name)) {
 		load_dist_sites();
+	}
 	return $load_dist_sites_url2name;
+}
 sub get_dist_sites_names() {
 	if (!defined($load_dist_sites_names)) {
 		load_dist_sites();
+	}
 	return $load_dist_sites_names;
+}
 my $get_pkg_options_result = undef;
 sub get_pkg_options() {
 	if (defined($get_pkg_options_result)) {
 		return $get_pkg_options_result;
+	}
 	my ($fname) = ("${cwd_pkgsrcdir}/mk/defaults/options.description");
 	my ($lines, $options);
 	if (!($lines = load_file($fname))) {
 		log_fatal($fname, NO_LINE_NUMBER, "Cannot be read.");
+	}
 	$options = {};
 	foreach my $line (@{$lines}) {
 		if ($line->text =~ m"^([-0-9a-z_+]+)(?:\s+(.*))?$") {
 			my ($optname, $optdescr) = ($1, $2);
 			$options->{$optname} = defined($optdescr)
 			    ? $optdescr
 			    : "";
 		} else {
 			$line->log_error("Unknown line format.");
+		}
+	}
 	return ($get_pkg_options_result = $options);
+}
 my $load_tool_names_system_build_defs = undef;		# XXX: misplaced, but works
 my $load_tool_names_tools = undef;
 my $load_tool_names_vartools = undef;
 my $load_tool_names_varname_to_toolname = undef;
 my $load_tool_names_predefined_tools = undef;
 sub load_tool_names() {
 	my ($tools, $vartools, $predefined_tools, $varname_to_toolname, @tool_files);
 	my ($system_build_defs);
+	#
 	# Get the list of files that define the tools from bsd.tools.mk.
+	#
 	@tool_files = ("defaults.mk");
+	{
 		my $fname = "${cwd_pkgsrcdir}/mk/tools/bsd.tools.mk";
 		my $lines = load_lines($fname, true);
 		if (!$lines) {
 			log_fatal($fname, NO_LINE_NUMBER, "Cannot be read.");
+		}
 		foreach my $line (@{$lines}) {
 			if ($line->text =~ regex_mk_include) {
 				my (undef, $includefile) = ($1, $2);
 				if ($includefile =~ m"^(?:\$\{PKGSRCDIR\}/mk/tools/)?([^/]+)$") {
 					push(@tool_files, $1);
+				}
+			}
+		}
+	}
 	assert(scalar(@tool_files) > 1, "Too few tool files. Maybe the files have been renamed again?");
+	#
 	# Scan the tool files for the actual definitions of the tools.
+	#
 	$tools = {};
 	$vartools = {};
 	$predefined_tools = {};
 	$varname_to_toolname = {};
 	$system_build_defs = {};
 	foreach my $basename (@tool_files) {
 		my $fname = "${cwd_pkgsrcdir}/mk/tools/${basename}";
 		my $lines = load_lines($fname, true);
 		if (!$lines) {
 			log_fatal($fname, NO_LINE_NUMBER, "Cannot be read.");
+		}
 		foreach my $line (@{$lines}) {
 			if ($line->text =~ regex_varassign) {
 				my ($varname, undef, $value, undef) = ($1, $2, $3, $4);
 				if ($varname eq "TOOLS_CREATE" && $value =~ m"^([-\w.]+|\[)$") {
 					$tools->{$value} = true;
 				} elsif ($varname =~ m"^(?:_TOOLS_VARNAME)\.([-\w.]+|\[)$") {
 					$tools->{$1} = true;
 					$vartools->{$1} = $value;
 					$varname_to_toolname->{$value} = $1;
 				} elsif ($varname =~ m"^(?:TOOLS_PATH|_TOOLS_DEPMETHOD)\.([-\w.]+|\[)$") {
 					$tools->{$1} = true;
 				} elsif ($varname =~ m"^_TOOLS\.(.*)") {
 					$tools->{$1} = true;
 					foreach my $tool (split(qr"\s+", $value)) {
 						$tools->{$tool} = true;
+					}
+				}
+			}
+		}
+	}
 	foreach my $basename ("bsd.pkg.mk") {
 		my $fname = "${cwd_pkgsrcdir}/mk/${basename}";
 		my $lines = load_lines($fname, true);
 		my $cond_depth = 0;
 		if (!$lines) {
 			log_fatal($fname, NO_LINE_NUMBER, "Cannot be read.");
+		}
 		foreach my $line (@{$lines}) {
 			my $text = $line->text;
 			if ($text =~ regex_varassign) {
 				my ($varname, undef, $value, undef) = ($1, $2, $3, $4);
 				if ($varname eq "USE_TOOLS") {
 					$opt_debug_tools and $line->log_debug("[cond_depth=${cond_depth}] $value");
 					if ($cond_depth == 0) {
 						foreach my $tool (split(qr"\s+", $value)) {
 							if ($tool !~ regex_unresolved && exists($tools->{$tool})) {
 								$predefined_tools->{$tool} = true;
 								# The path (without arguments) to the tool
 								$predefined_tools->{"TOOLS_${tool}"} = true;
+							}
+						}
+					}
 				} elsif ($varname eq "_BUILD_DEFS") {
 					foreach my $bdvar (split(qr"\s+", $value)) {
 						$system_build_defs->{$bdvar} = true;
+					}
+				}
 			} elsif ($text =~ regex_mk_cond) {
 				my ($indent, $cond, $args, $comment) = ($1, $2, $3, $4);
 				if ($cond =~ m"^(?:if|ifdef|ifndef|for)$") {
 					$cond_depth++;
 				} elsif ($cond =~ m"^(?:endif|endfor)$") {
 					$cond_depth--;
+				}
+			}
+		}
+	}
 	$opt_debug_tools and log_debug(NO_FILE, NO_LINE_NUMBER, "Known tools: ".join(" ", sort(keys(%{$tools}))));
 	$opt_debug_tools and log_debug(NO_FILE, NO_LINE_NUMBER, "Known vartools: ".join(" ", sort(keys(%{$vartools}))));
 @@ -6066,1520 +6066,1524 @@ sub checkfile_extra($) {
 	checklines_trailing_empty_lines($lines);
 	checkperms($fname);
+}
 sub checkfile_INSTALL($) {
 	my ($fname) = @_;
 	my ($lines);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_INSTALL()");
 	checkperms($fname);
 	if (!($lines = load_file($fname))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
+}
 sub checkfile_MESSAGE($) {
 	my ($fname) = @_;
 	my ($lines);
 	my @explanation = (
 		"A MESSAGE file should consist of a header line, having 75 \"=\"",
 		"characters, followed by a line containing only the RCS Id, then an",
 		"empty line, your text and finally the footer line, which is the",
 		"same as the header line.");
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_MESSAGE()");
 	checkperms($fname);
 	if (!($lines = load_file($fname))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
 	if (@{$lines} < 3) {
 		log_warning($fname, NO_LINE_NUMBER, "File too short.");
 		explain_warning($fname, NO_LINE_NUMBER, @explanation);
 		return;
+	}
 	if ($lines->[0]->text ne "=" x 75) {
 		$lines->[0]->log_warning("Expected a line of exactly 75 \"=\" characters.");
 		explain_warning($fname, NO_LINE_NUMBER, @explanation);
+	}
 	checkline_rcsid($lines->[1], "");
 	foreach my $line (@{$lines}) {
 		checkline_length($line, 80);
 		checkline_trailing_whitespace($line);
 		checkline_valid_characters($line, regex_validchars);
 		checkline_spellcheck($line);
+	}
 	if ($lines->[-1]->text ne "=" x 75) {
 		$lines->[-1]->log_warning("Expected a line of exactly 75 \"=\" characters.");
 		explain_warning($fname, NO_LINE_NUMBER, @explanation);
+	}
 	checklines_trailing_empty_lines($lines);
+}
 sub checkfile_mk($) {
 	my ($fname) = @_;
 	my ($lines);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_mk()");
 	checkperms($fname);
 	if (!($lines = load_lines($fname, true))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
 	parselines_mk($lines);
 	checklines_mk($lines);
 	autofix($lines);
+}
 sub checkfile_package_Makefile($$) {
 	my ($fname, $lines) = @_;
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile_package_Makefile(..., ...)");
 	checkperms($fname);
 	if (!exists($pkgctx_vardef->{"PLIST_SRC"})
 	    && !exists($pkgctx_vardef->{"GENERATE_PLIST"})
 	    && !exists($pkgctx_vardef->{"META_PACKAGE"})
 	    && defined($pkgdir)
 	    && !-f "${current_dir}/$pkgdir/PLIST"
 	    && !-f "${current_dir}/$pkgdir/PLIST.common") {
 		log_warning($fname, NO_LINE_NUMBER, "Neither PLIST nor PLIST.common exist, and PLIST_SRC is unset. Are you sure PLIST handling is ok?");
+	}
 	if ((exists($pkgctx_vardef->{"NO_CHECKSUM"}) || $pkgctx_vardef->{"META_PACKAGE"}) && is_emptydir("${current_dir}/${patchdir}")) {
 		if (-f "${current_dir}/${distinfo_file}") {
 			log_warning("${current_dir}/${distinfo_file}", NO_LINE_NUMBER, "This file should not exist if NO_CHECKSUM or META_PACKAGE is set.");
+		}
 	} else {
 		if (!-f "${current_dir}/${distinfo_file}") {
 			log_warning("${current_dir}/${distinfo_file}", NO_LINE_NUMBER, "File not found. Please run '".conf_make." makesum'.");
+		}
+	}
 	if (exists($pkgctx_vardef->{"REPLACE_PERL"}) && exists($pkgctx_vardef->{"NO_CONFIGURE"})) {
 		$pkgctx_vardef->{"REPLACE_PERL"}->log_warning("REPLACE_PERL is ignored when ...");
 		$pkgctx_vardef->{"NO_CONFIGURE"}->log_warning("... NO_CONFIGURE is set.");
+	}
 	if (!exists($pkgctx_vardef->{"LICENSE"})) {
 		log_error($fname, NO_LINE_NUMBER, "Each package must define its 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}.");
 				$effective_pkgname_line->explain_warning(
 "The wishlist for package updates in doc/TODO mentions that a newer",
 "version of this package is available.");
+			}
 			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 @comment_explanation = (
 "Each patch must document why it is necessary. If it has been applied",
 "because of a security issue, a reference to the CVE should be mentioned",
 "as well.",
 "",
 "Since it is our goal to have as few patches as possible, all patches",
 "should be sent to the upstream maintainers of the package. After you",
 "have done so, you should add a reference to the bug report containing",
 "the patch.");
 	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) {
 				$line->log_error("Comment expected.");
 				$line->explain_error(@comment_explanation);
+			}
 			$line->log_warning("Please use unified diffs (diff -u) for patches.");
 		}], [PST_TEXT, re_patch_ufd, PST_UFA, sub() {
 			if (!$seen_comment) {
 				$line->log_error("Comment expected.");
 				$line->explain_error(@comment_explanation);
+			}
 		}], [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 {
 				$line->log_error("Comment expected.");
 				$line->explain_error(@comment_explanation);
+			}
 			$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 {
 				$line->log_error("Comment expected.");
 				$line->explain_error(@comment_explanation);
+			}
 		}], [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 remove this line. It is no longer necessary.");
+				}
 			} 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") {
 				$line->log_warning("\@dirrm is obsolete. Please remove this line.");
 				$line->explain_warning(
 "Directories are removed automatically when they are empty.",
 "When a package needs an empty directory, it can use the \@pkgdir",
 "command in the PLIST");
 			} 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);
+					}
+				}
 			} elsif ($cmd eq "pkgdir") {
 				# TODO: What can we check here?
 			} 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}.");
 						$line->explain_warning(
 "For aesthetic reasons, the files in the PLIST should be sorted",
 "alphabetically.");
 					} elsif ($last_file_seen eq $text) {
 						$line->log_warning("Duplicate filename.");
+					}
+				}
 				$last_file_seen = $text;
+			}
 			if ($basename =~ m"\$\{IMAKE_MANNEWSUFFIX\}") {
 				warn_about_PLIST_imake_mannewsuffix($line);
+			}
 			if ($dirname =~ m"^bin/") {
 				$line->log_warning("The bin/ directory should not have subdirectories.");
 			} elsif ($dirname eq "bin") {
 				if (exists($all_files->{"man/man1/${basename}.1"})) {
 					# Fine.
 				} elsif (exists($all_files->{"man/man6/${basename}.6"})) {
 					# Fine.
 				} elsif (exists($all_files->{"\${IMAKE_MAN_DIR}/${basename}.\${IMAKE_MANNEWSUFFIX}"})) {
 					# Fine.
 				} else {
 					$opt_warn_extra and $line->log_warning("Manual page missing for bin/${basename}.");
 					$opt_warn_extra and $line->explain_warning(
 "All programs that can be run directly by the user should have a manual",
 "page for quick reference. The programs in the bin/ directory should have",
 "corresponding manual pages in section 1 (filename program.1), not in",
 "section 8.");
+				}
 			} elsif ($text =~ m"^doc/") {
 				$line->log_error("Documentation must be installed under share/doc, not doc.");
 			} elsif ($text =~ m"^etc/rc\.d/") {
 				$line->log_error("RCD_SCRIPTS must not be registered in the PLIST. Please use the RCD_SCRIPTS framework.");
 			} elsif ($text =~ m"^etc/") {
 				my $f = "mk/pkginstall/bsd.pkginstall.mk";
 				assert(-f "${cwd_pkgsrcdir}/${f}", "${cwd_pkgsrcdir}/${f} is not a regular file.");
 				$line->log_error("Configuration files must not be registered in the PLIST. Please use the CONF_FILES framework, which is described in ${f}.");
 			} elsif ($text =~ m"^include/.*\.(?:h|hpp)$") {
 				# Fine.
 			} elsif ($text eq "info/dir") {
 				$line->log_error("\"info/dir\" must not be listed. Use install-info to add/remove an entry.");
 			} elsif ($text =~ m"^info/.+$") {
 				if (defined($pkgctx_vardef) && !exists($pkgctx_vardef->{"INFO_FILES"})) {
 					$line->log_warning("Packages that install info files should set INFO_FILES.");
+				}
 			} elsif (defined($effective_pkgbase) && $text =~ m"^lib/\Q${effective_pkgbase}\E/") {
 				# Fine.
 			} elsif ($text =~ m"^lib/locale/") {
 				$line->log_error("\"lib/locale\" must not be listed. Use \${PKGLOCALEDIR}/locale and set USE_PKGLOCALEDIR instead.");
 			} elsif ($text =~ m"^(lib/(?:.*/)*)([^/]+)\.(so|a|la)$") {
 				my ($dir, $lib, $ext) = ($1, $2, $3);
 				if ($dir eq "lib/" && $lib !~ m"^lib") {
 					$opt_warn_extra and $line->log_warning("Library filename does not start with \"lib\".");
+				}
 				if ($ext eq "la") {
 					if (defined($pkgctx_vardef) && !exists($pkgctx_vardef->{"USE_LIBTOOL"})) {
 						$line->log_warning("Packages that install libtool libraries should define USE_LIBTOOL.");
+					}
+				}
 			} elsif ($text =~ m"^man/(cat|man)(\w+)/(.*?)\.(\w+)(\.gz)?$") {
 				my ($cat_or_man, $section, $manpage, $ext, $gz) = ($1, $2, $3, $4, $5);
 				if ($section !~ m"^[\dln]$") {
 					$line->log_warning("Unknown section \"${section}\" for manual page.");
+				}
 				if ($cat_or_man eq "cat" && !exists($all_files->{"man/man${section}/${manpage}.${section}"})) {
 					$line->log_warning("Preformatted manual page without unformatted one.");
+				}
 				if ($cat_or_man eq "cat") {
 					if ($ext ne "0") {
 						$line->log_warning("Preformatted manual pages should end in \".0\".");
+					}
 				} else {
 					if ($section ne $ext) {
 						$line->log_warning("Mismatch between the section (${section}) and extension (${ext}) of the manual page.");
+					}
+				}
 				if (defined($gz)) {
 					$line->log_note("The .gz extension is unnecessary for manual pages.");
 					$line->explain_note(
 "Whether the manual pages are installed in compressed form or not is",
 "configured by the pkgsrc user. Compression and decompression takes place",
 "automatically, no matter if the .gz extension is mentioned in the PLIST",
 "or not.");
+				}
 			} elsif ($text =~ m"^man/cat") {
 				$line->log_warning("Invalid filename \"${text}\" for preformatted manual page.");
 			} elsif ($text =~ m"^man/man") {
 				$line->log_warning("Invalid filename \"${text}\" for unformatted manual page.");
 			} elsif ($text =~ m"^sbin/(.*)") {
 				my ($binname) = ($1);
 				if (!exists($all_files->{"man/man8/${binname}.8"})) {
 					$opt_warn_extra and $line->log_warning("Manual page missing for sbin/${binname}.");
 					$opt_warn_extra and $line->explain_warning(
 "All programs that can be run directly by the user should have a manual",
 "page for quick reference. The programs in the sbin/ directory should have",
 "corresponding manual pages in section 8 (filename program.8), not in",
 "section 1.");
+				}
 			} elsif ($text =~ m"^share/applications/.*\.desktop$") {
 				my $f = "../../sysutils/desktop-file-utils/desktopdb.mk";
 				if (defined($pkgctx_included) && !exists($pkgctx_included->{$f})) {
 					$line->log_warning("Packages that install a .desktop entry may .include \"$f\".");
 					$line->explain_warning(
 "If *.desktop files contain MimeType keys, global MIME Type registory DB",
 "must be updated by desktop-file-utils.",
 "Otherwise, this warning is harmless.");
+				}
 			} elsif ($pkgpath ne "graphics/hicolor-icon-theme" && $text =~ m"^share/icons/hicolor(?:$|/)") {
 				my $f = "../../graphics/hicolor-icon-theme/buildlink3.mk";
 				if (defined($pkgctx_included) && !exists($pkgctx_included->{$f})) {
 					$line->log_error("Please .include \"$f\" in the Makefile");
 					$line->explain_error(
 "If hicolor icon themes are installed, icon theme cache must be",
 "maintained. The hicolor-icon-theme package takes care of that.");
+				}
 			} elsif ($pkgpath ne "graphics/gnome-icon-theme" && $text =~ m"^share/icons/gnome(?:$|/)") {
 				my $f = "../../graphics/gnome-icon-theme/buildlink3.mk";
 				if (defined($pkgctx_included) && !exists($pkgctx_included->{$f})) {
 					$line->log_error("Please .include \"$f\"");
 					$line->explain_error(
 "If Gnome icon themes are installed, icon theme cache must be maintained.");
+				}
 			} elsif ($dirname eq "share/aclocal" && $basename =~ m"\.m4$") {
 				# Fine.
 			} elsif ($text =~ m"^share/doc/html/") {
 				$opt_warn_plist_depr and $line->log_warning("Use of \"share/doc/html\" is deprecated. Use \"share/doc/\${PKGBASE}\" instead.");
 			} elsif (defined($effective_pkgbase) && $text =~ m"^share/doc/\Q${effective_pkgbase}\E/") {
 				# Fine.
 			} elsif (defined($effective_pkgbase) && $text =~ m"^share/examples/\Q${effective_pkgbase}\E/") {
 				# Fine.
 			} elsif (defined($effective_pkgbase) && $text =~ m"^share/\Q${effective_pkgbase}\E/") {
 				# Fine.
 			} elsif ($pkgpath ne "graphics/hicolor-icon-theme" && $text =~ m"^share/icons/hicolor/icon-theme\.cache") {
 				$line->log_error("Please .include \"../../graphics/hicolor-icon-theme/buildlink3.mk\" and remove this line.");
 			} elsif ($text =~ m"^share/info/") {
 				$line->log_warning("Info pages should be installed into info/, not share/info/.");
 				$line->explain_warning(
 "To fix this, you should add INFO_FILES=yes to the package Makefile.");
 			} elsif ($text =~ m"^share/locale/[\w\@_]+/LC_MESSAGES/[^/]+\.mo$") {
 				# Fine.
 			} elsif ($text =~ m"^share/man/") {
 				$line->log_warning("Man pages should be installed into man/, not share/man/.");
 			} else {
 				$opt_debug_unchecked and $line->log_debug("Unchecked pathname \"${text}\".");
+			}
 			if ($text =~ /\${PKGLOCALEDIR}/ && defined($pkgctx_vardef) && !exists($pkgctx_vardef->{"USE_PKGLOCALEDIR"})) {
 				$line->log_warning("PLIST contains \${PKGLOCALEDIR}, but USE_PKGLOCALEDIR was not found.");
+			}
 			if ($text =~ m"/CVS/") {
 				$line->log_warning("CVS files should not be in the PLIST.");
+			}
 			if ($text =~ m"\.orig$") {
 				$line->log_warning(".orig files should not be in the PLIST.");
+			}
 			if ($text =~ m"/perllocal\.pod$") {
 				$line->log_warning("perllocal.pod files should not be in the PLIST.");
 				$line->explain_warning(
 "This file is handled automatically by the INSTALL/DEINSTALL scripts,",
 "since its contents changes frequently.");
+			}
 			if ($text =~ m"^(.*)(\.a|\.so[0-9.]*)$") {
 				my ($basename, $ext) = ($1, $2);
 				if (exists($all_files->{"${basename}.la"})) {
 					$line->log_warning("Redundant library found. The libtool library is in line " . $all_files->{"${basename}.la"}->lines . ".");
+				}
+			}
 		} elsif ($text =~ m"^\$\{[\w_]+\}$") {
 			# A variable on its own line.
 		} else {
 			$line->log_error("Unknown line type.");
+		}
+	}
 	checklines_trailing_empty_lines($lines);
 	autofix($lines);
+}
 sub checkfile($) {
 	my ($fname) = @_;
 	my ($st, $basename);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkfile()");
 	$basename = basename($fname);
 	if ($basename =~ m"^(?:work.*|.*~|.*\.orig|.*\.rej)$") {
 		if ($opt_import) {
 			log_error($fname, NO_LINE_NUMBER, "Must be cleaned up before committing the package.");
+		}
 		return;
+	}
 	if (!($st = lstat($fname))) {
 		log_error($fname, NO_LINE_NUMBER, "$!");
 		return;
+	}
 	if (S_ISDIR($st->mode)) {
 		if ($basename eq "files" || $basename eq "patches" || $basename eq "CVS") {
 			# Ok
 		} elsif ($fname =~ m"(?:^|/)files/[^/]*$") {
 			# Ok
 		} elsif (!is_emptydir($fname)) {
 			log_warning($fname, NO_LINE_NUMBER, "Unknown directory name.");
+		}
 	} elsif (S_ISLNK($st->mode)) {
 		if ($basename !~ m"^work") {
 			log_warning($fname, NO_LINE_NUMBER, "Unknown symlink name.");
+		}
 	} elsif (!S_ISREG($st->mode)) {
 		log_error($fname, NO_LINE_NUMBER, "Only files and directories are allowed in pkgsrc.");
 	} elsif ($basename eq "ALTERNATIVES") {
 		$opt_check_ALTERNATIVES and checkfile_ALTERNATIVES($fname);
 	} elsif ($basename eq "buildlink3.mk") {
 		$opt_check_bl3 and checkfile_buildlink3_mk($fname);
 	} elsif ($basename =~ m"^DESCR") {
 		$opt_check_DESCR and checkfile_DESCR($fname);
 	} elsif ($basename =~ m"^distinfo") {
 		$opt_check_distinfo and checkfile_distinfo($fname);
 	} elsif ($basename eq "DEINSTALL" || $basename eq "INSTALL") {
 		$opt_check_INSTALL and checkfile_INSTALL($fname);
 	} elsif ($basename =~ m"^MESSAGE") {
 		$opt_check_MESSAGE and checkfile_MESSAGE($fname);
 	} elsif ($basename =~ m"^patch-[-A-Za-z0-9_.~+]*[A-Za-z0-9_]$") {
 		$opt_check_patches and checkfile_patch($fname);
 	} elsif ($fname =~ m"(?:^|/)patches/manual[^/]*$") {
 		$opt_debug_unchecked and log_debug($fname, NO_LINE_NUMBER, "Unchecked file \"${fname}\".");
 	} elsif ($fname =~ m"(?:^|/)patches/[^/]*$") {
 		log_warning($fname, NO_LINE_NUMBER, "Patch files should be named \"patch-\", followed by letters, '-', '_', '.', and digits only.");
 	} elsif ($basename =~ m"^(?:.*\.mk|Makefile.*)$" and not $fname =~ m,files/, and not $fname =~ m,patches/,) {
 		$opt_check_mk and checkfile_mk($fname);
 	} elsif ($basename =~ m"^PLIST") {
 		$opt_check_PLIST and checkfile_PLIST($fname);
 	} elsif ($basename eq "TODO" || $basename eq "README") {
 		# Ok
 	} elsif ($basename =~ m"^CHANGES-.*") {
 		load_doc_CHANGES($fname);
 	} elsif (!-T $fname) {
 		log_warning($fname, NO_LINE_NUMBER, "Unexpectedly found a binary file.");
 	} elsif ($fname =~ m"(?:^|/)files/[^/]*$") {
 		# Ok
 	} else {
 		log_warning($fname, NO_LINE_NUMBER, "Unexpected file found.");
 		$opt_check_extra and checkfile_extra($fname);
+	}
+}
 sub my_split($$) {
 	my ($delimiter, $s) = @_;
 	my ($pos, $next, @result);
 	$pos = 0;
 	for ($pos = 0; $pos != -1; $pos = $next) {
 		$next = index($s, $delimiter, $pos);
 		push @result, (($next == -1) ? substr($s, $pos) : substr($s, $pos, $next - $pos));
 		if ($next != -1) {
 			$next += length($delimiter);
+		}
+	}
 	return @result;
+}
 # Checks that the files in the directory are in sync with CVS's status.
+#
 sub checkdir_CVS($) {
 	my ($fname) = @_;
 	my $cvs_entries = load_file("$fname/CVS/Entries");
 	my $cvs_entries_log = load_file("$fname/CVS/Entries.Log");
 	return unless $cvs_entries;
 	foreach my $line (@$cvs_entries) {
 		my ($type, $fname, $mtime, $date, $keyword_mode, $tag, $undef) = my_split("/", $line->text);
 		next if ($type eq "D" && !defined($fname));
 		assert($type eq "" || $type eq "D", "Unknown line format: " . $line->text);
 		assert(defined($tag), "Unknown line format: " . $line->text);
 		assert(defined($keyword_mode), "Unknown line format: " . $line->text);
 		assert(!defined($undef), "Unknown line format: " . $line->text);
+	}
+}
+#
 # Procedures to check a directory including the files in it.
+#
 sub checkdir_root() {
 	my ($fname) = "${current_dir}/Makefile";
 	my ($lines, $prev_subdir, @subdirs);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkdir_root()");
 	if (!($lines = load_lines($fname, true))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
 	parselines_mk($lines);
 	if (0 <= $#{$lines}) {
 		checkline_rcsid_regex($lines->[0], qr"#\s+", "# ");
+	}
 	foreach my $line (@{$lines}) {
 		if ($line->text =~ m"^(#?)SUBDIR\s*\+=(\s*)(\S+)\s*(?:#\s*(.*?)\s*|)$") {
 			my ($comment_flag, $indentation, $subdir, $comment) = ($1, $2, $3, $4);
 			if ($comment_flag eq "#" && (!defined($comment) || $comment eq "")) {
 				$line->log_warning("${subdir} commented out without giving a reason.");
+			}
 			if ($indentation ne "\t") {
 				$line->log_warning("Indentation should be a single tab character.");
+			}
 			if ($subdir =~ m"\$" || !-f "${current_dir}/${subdir}/Makefile") {
 				next;
+			}
 			if (!defined($prev_subdir) || $subdir gt $prev_subdir) {
 				# correctly ordered
 			} elsif ($subdir eq $prev_subdir) {
 				$line->log_error("${subdir} must only appear once.");
 			} elsif ($prev_subdir eq "x11" && $subdir eq "archivers") {
 				# ignore that one, since it is documented in the top-level Makefile
 			} else {
 				$line->log_warning("${subdir} should come before ${prev_subdir}.");
+			}
 			$prev_subdir = $subdir;
 			if ($comment_flag eq "") {
 				push(@subdirs, "${current_dir}/${subdir}");
+			}
+		}
+	}
 	checklines_mk($lines);
 	if ($opt_recursive) {
 		$ipc_checking_root_recursively = true;
 		push(@todo_items, @subdirs);
+	}
+}
 sub checkdir_category() {
 	my $fname = "${current_dir}/Makefile";
 	my ($lines, $lineno);
 	$opt_debug_trace and log_debug($fname, NO_LINES, "checkdir_category()");
 	if (!($lines = load_lines($fname, true))) {
 		log_error($fname, NO_LINE_NUMBER, "Cannot be read.");
 		return;
+	}
 	parselines_mk($lines);
 	$lineno = 0;
 	# The first line must contain the RCS Id
 	if ($lineno <= $#{$lines} && checkline_rcsid_regex($lines->[$lineno], qr"#\s+", "# ")) {
 		$lineno++;
+	}
 	# Then, arbitrary comments may follow
 	while ($lineno <= $#{$lines} && $lines->[$lineno]->text =~ m"^#") {
 		$lineno++;
+	}
 	# Then we need an empty line
 	expect_empty_line($lines, \$lineno);
 	# Then comes the COMMENT line
 	if ($lineno <= $#{$lines} && $lines->[$lineno]->text =~ m"^COMMENT=\t*(.*)") {
 		my ($comment) = ($1);
 		checkline_valid_characters_in_variable($lines->[$lineno], qr"[-\040'(),/0-9A-Za-z]");
 		$lineno++;
 	} else {
 		$lines->[$lineno]->log_error("COMMENT= line expected.");
+	}
 	# Then we need an empty line
 	expect_empty_line($lines, \$lineno);
 	# And now to the most complicated part of the category Makefiles,
 	# the (hopefully) sorted list of SUBDIRs. The first step is to
 	# collect the SUBDIRs in the Makefile and in the file system.
 	my (@f_subdirs, @m_subdirs);
 	@f_subdirs = sort(get_subdirs($current_dir));
 	my $prev_subdir = undef;
 	while ($lineno <= $#{$lines}) {
 		my $line = $lines->[$lineno];
 		if ($line->text =~ m"^(#?)SUBDIR\+=(\s*)(\S+)\s*(?:#\s*(.*?)\s*|)$") {
 			my ($comment_flag, $indentation, $subdir, $comment) = ($1, $2, $3, $4);
 			if ($comment_flag eq "#" && (!defined($comment) || $comment eq "")) {
 				$line->log_warning("${subdir} commented out without giving a reason.");
+			}
 			if ($indentation ne "\t") {
 				$line->log_warning("Indentation should be a single tab character.");
+			}
 			if (defined($prev_subdir) && $subdir eq $prev_subdir) {
 				$line->log_error("${subdir} must only appear once.");
 			} elsif (defined($prev_subdir) && $subdir lt $prev_subdir) {
 				$line->log_warning("${subdir} should come before ${prev_subdir}.");
 			} else {
 				# correctly ordered
+			}
 			push(@m_subdirs, [$subdir, $line, $comment_flag ? false : true]);
 			$prev_subdir = $subdir;
 			$lineno++;
 		} else {
 			if ($line->text ne "") {
 				$line->log_error("SUBDIR+= line or empty line expected.");
+			}
 			last;
+		}
+	}
 	# To prevent unnecessary warnings about subdirectories that are
 	# in one list, but not in the other, we generate the sets of
 	# subdirs of each list.
 	my (%f_check, %m_check);
 	foreach my $f (@f_subdirs) { $f_check{$f} = true; }
 	foreach my $m (@m_subdirs) { $m_check{$m->[0]} = true; }
 	my ($f_index, $f_atend, $f_neednext, $f_current) = (0, false, true, undef, undef);
 	my ($m_index, $m_atend, $m_neednext, $m_current) = (0, false, true, undef, undef);
 	my ($line, $m_recurse);
 	my (@subdirs);
 	while (!($m_atend && $f_atend)) {
 		if (!$m_atend && $m_neednext) {
 			$m_neednext = false;
 			if ($m_index > $#m_subdirs) {
 				$m_atend = true;
 				$line = $lines->[$lineno];
 				next;
 			} else {
 				$m_current = $m_subdirs[$m_index]->[0];
 				$line = $m_subdirs[$m_index]->[1];
 				$m_recurse = $m_subdirs[$m_index]->[2];
 				$m_index++;
+			}
+		}
 		if (!$f_atend && $f_neednext) {
 			$f_neednext = false;
 			if ($f_index > $#f_subdirs) {
 				$f_atend = true;
 				next;
 			} else {
 				$f_current = $f_subdirs[$f_index++];
+			}
+		}
 		if (!$f_atend && ($m_atend || $f_current lt $m_current)) {
 			if (!exists($m_check{$f_current})) {
 				$line->log_error("${f_current} exists in the file system, but not in the Makefile.");
 				$line->append_before("SUBDIR+=\t${f_current}");
+			}
 			$f_neednext = true;
 		} elsif (!$m_atend && ($f_atend || $m_current lt $f_current)) {
 			if (!exists($f_check{$m_current})) {
 				$line->log_error("${m_current} exists in the Makefile, but not in the file system.");
 				$line->delete();
+			}
 			$m_neednext = true;
 		} else { # $f_current eq $m_current
 			$f_neednext = true;
 			$m_neednext = true;
 			if ($m_recurse) {
 				push(@subdirs, "${current_dir}/${m_current}");
+			}
+		}
+	}
 	# the wip category Makefile may have its own targets for generating
 	# indexes and READMEs. Just skip them.
 	if ($is_wip) {
 		while ($lineno <= $#{$lines} - 2) {
 			$lineno++;
+		}
+	}
 	expect_empty_line($lines, \$lineno);
 	# And, last but not least, the .include line
 	my $final_line = ".include \"../mk/bsd.pkg.subdir.mk\"";
 	expect($lines, \$lineno, qr"\Q$final_line\E")
 	|| expect_text($lines, \$lineno, ".include \"../mk/misc/category.mk\"");
 	if ($lineno <= $#{$lines}) {
 		$lines->[$lineno]->log_error("The file should end here.");
+	}
 	checklines_mk($lines);
 	autofix($lines);
 	if ($opt_recursive) {
 		unshift(@todo_items, @subdirs);
+	}
+}
 sub checkdir_package() {
 	my ($lines, $have_distinfo, $have_patches);
 	# Initialize global variables
 	$pkgdir = undef;
 	$filesdir = "files";
 	$patchdir = "patches";
 	$distinfo_file = "distinfo";
 	$effective_pkgname = undef;
 	$effective_pkgbase = undef;
 	$effective_pkgversion = undef;
 	$effective_pkgname_line = undef;
 	$seen_bsd_prefs_mk = false;
 	$pkgctx_vardef = {%{get_userdefined_variables()}};
 	$pkgctx_varuse = {};
 	$pkgctx_bl3 = {};
 	$pkgctx_plist_subst_cond = {};
 	$pkgctx_included = {};
 	$seen_Makefile_common = false;
 	# we need to handle the Makefile first to get some variables
 	if (!load_package_Makefile("${current_dir}/Makefile", \$lines)) {
 		log_error("${current_dir}/Makefile", NO_LINE_NUMBER, "Cannot be read.");
 		goto cleanup;
+	}
 	my @files = <${current_dir}/*>;
 	if ($pkgdir ne ".") {
 		push(@files, <${current_dir}/${pkgdir}/*>);
+	}
 	if ($opt_check_extra) {
 		push(@files, <${current_dir}/${filesdir}/*>);
+	}
 	push(@files, <${current_dir}/${patchdir}/*>);
 	if ($distinfo_file !~ m"^(?:\./)?distinfo$") {
 		push(@files, "${current_dir}/${distinfo_file}");
+	}
 	$have_distinfo = false;
 	$have_patches = false;
 	# Determine the used variables before checking any of the
 	# Makefile fragments.
 	foreach my $fname (@files) {
 		if (($fname =~ m"^((?:.*/)?Makefile\..*|.*\.mk)$")
 		&& (not $fname =~ m"patch-")
 		&& (not $fname =~ m"${pkgdir}/")
 		&& (not $fname =~ m"${filesdir}/")
 		&& (defined(my $lines = load_lines($fname, true)))) {
 			parselines_mk($lines);
 			determine_used_variables($lines);
+		}
+	}
 	foreach my $fname (@files) {
 		if ($fname eq "${current_dir}/Makefile") {
 			$opt_check_Makefile and checkfile_package_Makefile($fname, $lines);
 		} else {
 			checkfile($fname);
+		}
 		if ($fname =~ m"/patches/patch-*$") {
 			$have_patches = true;
 		} elsif ($fname =~ m"/distinfo$") {
 			$have_distinfo = true;
+		}
+	}
 	if ($opt_check_distinfo && $opt_check_patches) {
 		if ($have_patches && ! $have_distinfo) {
 			log_warning("${current_dir}/$distinfo_file", NO_LINE_NUMBER, "File not found. Please run '".conf_make." makepatchsum'.");
+		}
+	}
 	if (!is_emptydir("${current_dir}/scripts")) {
 		log_warning("${current_dir}/scripts", NO_LINE_NUMBER, "This directory and its contents are deprecated! Please call the script(s) explicitly from the corresponding target(s) in the pkg's Makefile.");
+	}
 cleanup:
 	# Clean up global variables.
 	$pkgdir = undef;
 	$filesdir = undef;
 	$patchdir = undef;
 	$distinfo_file = undef;
 	$effective_pkgname = undef;
 	$effective_pkgbase = undef;
 	$effective_pkgversion = undef;
 	$effective_pkgname_line = undef;
 	$seen_bsd_prefs_mk = undef;
 	$pkgctx_vardef = undef;
 	$pkgctx_varuse = undef;
 	$pkgctx_bl3 = undef;
 	$pkgctx_plist_subst_cond = undef;
 	$pkgctx_included = undef;
 	$seen_Makefile_common = undef;
+}
+#
 # Selecting the proper checking procedures for a directory entry.
+#
 sub checkitem($) {
 	my ($item) = @_;
 	my ($st, $is_dir, $is_reg);
 	if (!($st = lstat($item))) {
 		log_error($item, NO_LINE_NUMBER, "Does not exist.");
 		return;
+	}
 	$is_dir = S_ISDIR($st->mode);
 	$is_reg = S_ISREG($st->mode);
 	if (!$is_reg && !$is_dir) {
 		log_error($item, NO_LINE_NUMBER, "Must be a file or directory.");
 		return;
+	}
 	$current_dir = $is_dir ? $item : dirname($item);
 	my $abs_current_dir = Cwd::abs_path($current_dir);
 	$is_wip = !$opt_import && ($abs_current_dir =~ m"/wip(?:/|$)");
 	$is_internal = ($abs_current_dir =~ m"/mk(?:/|$)");
 	# Determine the root directory of pkgsrc. By only overwriting
 	# the global variable $cwd_pkgsrcdir when we are checking inside
 	# a pkgsrc tree, the user can specify a tree with the
 	# --pkgsrcdir option and then check files (but not directories)
 	# outside of any pkgsrc tree.
 	$cur_pkgsrcdir = undef;
 	$pkgpath = undef;
 	foreach my $d (".", "..", "../..", "../../..") {
 		if (-f "${current_dir}/${d}/mk/bsd.pkg.mk") {
 			$cur_pkgsrcdir = $d;
 			$pkgpath = relative_path("${current_dir}/${d}", $current_dir);
+		}
+	}
 	if (!defined($cwd_pkgsrcdir) && defined($cur_pkgsrcdir)) {
 		$cwd_pkgsrcdir = "${current_dir}/${cur_pkgsrcdir}";
+	}
 	if (!defined($cwd_pkgsrcdir)) {
 		log_error($item, NO_LINE_NUMBER, "Cannot determine the pkgsrc root directory.");
 		return;
+	}
 	check_pkglint_version();	# (needs $cwd_pkgsrcdir)
 	return if $is_dir && is_emptydir($item);
 	if ($is_dir) {
 		checkdir_CVS($item);
+	}
 	if ($is_reg) {
 		checkfile($item);
 	} elsif (!defined($cur_pkgsrcdir)) {
 		log_error($item, NO_LINES, "Cannot check directories outside a pkgsrc tree.");
 	} elsif ($cur_pkgsrcdir eq "../..") {
 		checkdir_package();
 	} elsif ($cur_pkgsrcdir eq "..") {
 		checkdir_category();
 	} elsif ($cur_pkgsrcdir eq ".") {
 		checkdir_root();
 	} else {
 		log_error($item, NO_LINE_NUMBER, "Don't know how to check this directory.");
+	}
+}
+#
 # The main program
+#
 sub main() {
 	$| = true;
 	parse_command_line();
 	@todo_items = (@ARGV != 0) ? @ARGV : (".");
 	while (@todo_items != 0) {
 		checkitem(shift(@todo_items));
+	}
 	if ($ipc_checking_root_recursively) {
 		check_unused_licenses();
+	}
 	PkgLint::Logging::print_summary_and_exit($opt_quiet);
+}
 main() unless caller();