 @@ -1,16 +1,16 @@
-# $NetBSD: Makefile,v 1.485 2016/06/05 11:24:32 rillig Exp $
+# $NetBSD: Makefile,v 1.486 2016/06/10 19:42:41 rillig Exp $
-PKGNAME=	pkglint-5.4.0
+PKGNAME=	pkglint-5.4.1
 DISTFILES=	# none
 CATEGORIES=	pkgtools
 OWNER=		rillig@NetBSD.org
 HOMEPAGE=	http://www.NetBSD.org/docs/pkgsrc/
 COMMENT=	Verifier for NetBSD packages
 LICENSE=	2-clause-bsd
 CONFLICTS+=	pkglint4-[0-9]*
 WRKSRC=		${WRKDIR}/netbsd.org/pkglint
 NO_CHECKSUM=	yes
 USE_LANGUAGES=	# none
 USE_TOOLS+=	pax

 @@ -468,27 +468,26 @@ func (gd *GlobalData) loadDeprecatedVars
 		// July 2006
 		"USE_DIGEST":           "You can just remove it.",
 		"LTCONFIG_OVERRIDE":    "You can just remove it.",
 		"USE_GNU_GETTEXT":      "You can just remove it.",
 		"BUILD_ENV":            "Use PKGSRC_MAKE_ENV instead.",
 		"DYNAMIC_MASTER_SITES": "You can just remove it.",
 		// September 2006
 		"MAKEFILE": "Use MAKE_FILE instead.",
 		// November 2006
 		"SKIP_PORTABILITY_CHECK": "Use CHECK_PORTABILITY_SKIP (a list of patterns) instead.",
 		"PKG_SKIP_REASON":        "Use PKG_FAIL_REASON instead.",
 		// January 2007
 		"BUILDLINK_TRANSFORM.*": "Use BUILDLINK_FNAME_TRANSFORM.* instead.",
 		// March 2007
 		"SCRIPTDIR":       "You can just remove it.",
 		"NO_PKG_REGISTER": "You can just remove it.",
 		"NO_DEPENDS":      "You can just remove it.",
 		// October 2007
 		"_PKG_SILENT": "Use RUN (with more error checking) instead.",
 		"_PKG_DEBUG":  "Use RUN (with more error checking) instead.",
 		"LICENCE":     "Use LICENSE instead.",

 @@ -267,26 +267,36 @@ func (s *Suite) TestVartypeCheck_Option(
 		"undocumented",
 		"unknown")
 	c.Check(s.Output(), equals, "WARN: fname:3: Unknown option \"unknown\".\n")
+}
 func (s *Suite) TestVartypeCheck_Pathlist(c *check.C) {
 	runVartypeChecks("PATH", opAssign, (*VartypeCheck).Pathlist,
 		"/usr/bin:/usr/sbin:.:${LOCALBASE}/bin")
 	c.Check(s.Output(), equals, "WARN: fname:1: All components of PATH (in this case \".\") should be absolute paths.\n")
+}
 func (s *Suite) Test_VartypeCheck_Perms(c *check.C) {
 	runVartypeChecks("CONF_FILES_PERMS", opAssignAppend, (*VartypeCheck).Perms,
 		"root",
 		"${ROOT_USER}",
 		"ROOT_USER",
 		"${REAL_ROOT_USER}")
 	c.Check(s.Output(), equals, "ERROR: fname:2: ROOT_USER must not be used in permission definitions. Use REAL_ROOT_USER instead.\n")
+}
 func (s *Suite) TestVartypeCheck_PkgOptionsVar(c *check.C) {
 	runVartypeChecks("PKG_OPTIONS_VAR.screen", opAssign, (*VartypeCheck).PkgOptionsVar,
 		"PKG_OPTIONS.${PKGBASE}")
 	c.Check(s.Output(), equals, "ERROR: fname:1: PKGBASE must not be used in PKG_OPTIONS_VAR.\n")
+}
 func (s *Suite) TestVartypeCheck_PkgRevision(c *check.C) {
 	runVartypeChecks("PKGREVISION", opAssign, (*VartypeCheck).PkgRevision,
 		"3a")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: PKGREVISION must be a positive integer number.\n"+

 @@ -206,28 +206,29 @@ func (mkline *MkLine) checkInclude() {
 		mkline.Error1("%s must not be included directly. Include \"../../mk/x11.buildlink3.mk\" instead.", includefile)
 	case hasSuffix(includefile, "/jpeg/buildlink3.mk"):
 		mkline.Error1("%s must not be included directly. Include \"../../mk/jpeg.buildlink3.mk\" instead.", includefile)
 	case hasSuffix(includefile, "/intltool/buildlink3.mk"):
 		mkline.Warn0("Please write \"USE_TOOLS+= intltool\" instead of this line.")
 	case hasSuffix(includefile, "/builtin.mk"):
 		mkline.Line.Error2("%s must not be included directly. Include \"%s/buildlink3.mk\" instead.", includefile, path.Dir(includefile))
+	}
+}
-func (mkline *MkLine) checkCond(indentation *Indentation, forVars map[string]bool) {
+func (mkline *MkLine) checkCond(forVars map[string]bool) {
 	indent, directive, args := mkline.Indent(), mkline.Directive(), mkline.Args()
 	indentation := &G.Mk.indentation
 	switch directive {
 	case "endif", "endfor", "elif", "else":
 		if indentation.Len() > 1 {
 			indentation.Pop()
 		} else {
 			mkline.Error1("Unmatched .%s.", directive)
+		}
+	}
 	// Check the indentation
 	if expected := strings.Repeat(" ", indentation.Depth()); indent != expected {
 		if G.opts.WarnSpace && !mkline.Line.AutofixReplace("."+indent, "."+expected) {
 @@ -933,26 +934,30 @@ func (mkline *MkLine) checkVarassignSpec
 			"only the state of the variable), whose meaning could be described",
 			"with \"none\".  It is this meaning that should be described.")
+	}
 	if m, revvarname := match1(value, `\$\{(PKGNAME|PKGVERSION)[:\}]`); m {
 		if varname == "DIST_SUBDIR" || varname == "WRKSRC" {
 			mkline.Line.Warnf("%s should not be used in %s, as it includes the PKGREVISION. Please use %s_NOREV instead.", revvarname, varname, revvarname)
+		}
+	}
 	if hasPrefix(varname, "SITES_") {
 		mkline.Warn0("SITES_* is deprecated. Please use SITES.* instead.")
+	}
 	if varname == "PKG_SKIP_REASON" && G.Mk.indentation.DependsOn("OPSYS") {
 		mkline.Note0("Consider defining NOT_FOR_PLATFORM instead of setting PKG_SKIP_REASON depending on ${OPSYS}.")
+	}
+}
 func (mkline *MkLine) checkVarassignBsdPrefs() {
 	if G.opts.WarnExtra && mkline.Op() == opAssignDefault && G.Pkg != nil && !G.Pkg.SeenBsdPrefsMk {
 		switch mkline.Varcanon() {
 		case "BUILDLINK_PKGSRCDIR.*", "BUILDLINK_DEPMETHOD.*", "BUILDLINK_ABI_DEPENDS.*":
 			return
+		}
 		mkline.Warn0("Please include \"../../mk/bsd.prefs.mk\" before using \"?=\".")
 		Explain(
 			"The ?= operator is used to provide a default value to a variable.",
 			"In pkgsrc, many variables can be set by the pkgsrc user in the",
 @@ -1214,26 +1219,54 @@ func (mkline *MkLine) CheckCond() {
 	})
 	cond.Visit("compareVarStr", func(node *Tree) {
 		varuse := node.args[0].(MkVarUse)
 		varname := varuse.varname
 		varmods := varuse.modifiers
 		value := node.args[2].(string)
 		if len(varmods) == 0 {
 			mkline.CheckVartype(varname, opUse, value, "")
 		} else if len(varmods) == 1 && matches(varmods[0], `^[MN]`) && value != "" {
 			mkline.CheckVartype(varname, opUseMatch, value, "")
+		}
 	})
 	mkline.rememberUsedVariables(cond)
+}
 func (mkline *MkLine) rememberUsedVariables(cond *Tree) {
 	if G.Mk == nil {
 		return
+	}
 	indentation := &G.Mk.indentation
 	arg0varname := func(node *Tree) {
 		varname := node.args[0].(string)
 		indentation.AddVar(varname)
+	}
 	arg0varuse := func(node *Tree) {
 		varuse := node.args[0].(MkVarUse)
 		indentation.AddVar(varuse.varname)
+	}
 	arg2varuse := func(node *Tree) {
 		varuse := node.args[2].(MkVarUse)
 		indentation.AddVar(varuse.varname)
+	}
 	cond.Visit("defined", arg0varname)
 	cond.Visit("empty", arg0varuse)
 	cond.Visit("compareVarNum", arg0varuse)
 	cond.Visit("compareVarStr", arg0varuse)
 	cond.Visit("compareVarVar", arg0varuse)
 	cond.Visit("compareVarVar", arg2varuse)
+}
 func (mkline *MkLine) CheckValidCharactersInValue(reValid string) {
 	rest := regcomp(reValid).ReplaceAllString(mkline.Value(), "")
 	if rest != "" {
 		uni := ""
 		for _, c := range rest {
 			uni += fmt.Sprintf(" %U", c)
+		}
 		mkline.Warn2("%s contains invalid characters (%s).", mkline.Varname(), uni[1:])
+	}
+}
 @@ -1669,20 +1702,52 @@ const (
+)
 func (e vucExtent) String() string { return [...]string{"word", "wordpart"}[e] }
 func (vuc *VarUseContext) String() string {
 	typename := "no-type"
 	if vuc.vartype != nil {
 		typename = vuc.vartype.String()
+	}
 	return fmt.Sprintf("(%s time:%s quoting:%s extent:%s)", typename, vuc.time, vuc.quoting, vuc.extent)
+}
 type Indentation struct {
-	data []int
+	depth         []int             // Number of space characters; always a multiple of 2
 	conditionVars []map[string]bool // Variables on which the current path depends
+}
 func (ind *Indentation) Len() int {
 	return len(ind.depth)
+}
-func (ind *Indentation) Len() int        { return len(ind.data) }
+func (ind *Indentation) Depth() int {
-func (ind *Indentation) Depth() int      { return ind.data[len(ind.data)-1] }
+	return ind.depth[len(ind.depth)-1]
 func (ind *Indentation) Pop()            { ind.data = ind.data[:len(ind.data)-1] }
 func (ind *Indentation) Push(indent int) { ind.data = append(ind.data, indent) }
 func (ind *Indentation) Pop() {
 	newlen := ind.Len() - 1
 	ind.depth = ind.depth[:newlen]
 	ind.conditionVars = ind.conditionVars[:newlen]
+}
 func (ind *Indentation) Push(indent int) {
 	ind.depth = append(ind.depth, indent)
 	ind.conditionVars = append(ind.conditionVars, nil)
+}
 func (ind *Indentation) AddVar(varname string) {
 	level := ind.Len() - 1
 	if ind.conditionVars[level] == nil {
 		ind.conditionVars[level] = make(map[string]bool)
+	}
 	ind.conditionVars[level][varname] = true
+}
 func (ind *Indentation) DependsOn(varname string) bool {
 	for _, vars := range ind.conditionVars {
 		if vars[varname] {
 			return true
+		}
+	}
 	return false
+}

 @@ -7,51 +7,53 @@ import (
 // MkLines contains data for the Makefile (or *.mk) that is currently checked.
 type MkLines struct {
 	mklines        []*MkLine
 	lines          []*Line
 	forVars        map[string]bool    // The variables currently used in .for loops
 	target         string             // Current make(1) target
 	vardef         map[string]*MkLine // varname => line; for all variables that are defined in the current file
 	varuse         map[string]*MkLine // varname => line; for all variables that are used in the current file
 	buildDefs      map[string]bool    // Variables that are registered in BUILD_DEFS, to ensure that all user-defined variables are added to it.
 	plistVars      map[string]bool    // Variables that are registered in PLIST_VARS, to ensure that all user-defined variables are added to it.
 	tools          map[string]bool    // Set of tools that are declared to be used.
 	SeenBsdPrefsMk bool
 	indentation    Indentation // Indentation depth of preprocessing directives
+}
 func NewMkLines(lines []*Line) *MkLines {
 	mklines := make([]*MkLine, len(lines))
 	for i, line := range lines {
 		mklines[i] = NewMkLine(line)
+	}
 	tools := make(map[string]bool)
 	for toolname, tool := range G.globalData.Tools.byName {
 		if tool.Predefined {
 			tools[toolname] = true
+		}
+	}
 	return &MkLines{
 		mklines,
 		lines,
 		make(map[string]bool),
 		"",
 		make(map[string]*MkLine),
 		make(map[string]*MkLine),
 		make(map[string]bool),
 		make(map[string]bool),
 		tools,
-		false}
+		false,
 		Indentation{}}
+}
 func (mklines *MkLines) DefineVar(mkline *MkLine, varname string) {
 	if mklines.vardef[varname] == nil {
 		mklines.vardef[varname] = mkline
+	}
 	varcanon := varnameCanon(varname)
 	if mklines.vardef[varcanon] == nil {
 		mklines.vardef[varcanon] = mkline
+	}
+}
 func (mklines *MkLines) UseVar(mkline *MkLine, varname string) {
 @@ -89,48 +91,49 @@ func (mklines *MkLines) Check() {
+	}
 	// In the first pass, all additions to BUILD_DEFS and USE_TOOLS
 	// are collected to make the order of the definitions irrelevant.
 	mklines.DetermineUsedVariables()
 	mklines.determineDefinedVariables()
 	// In the second pass, the actual checks are done.
 	mklines.lines[0].CheckRcsid(`#\s+`, "# ")
 	var substcontext SubstContext
 	var varalign VaralignBlock
-	indentation := Indentation{[]int{0}} // Indentation depth of preprocessing directives
+	indentation := &mklines.indentation
 	indentation.Push(0)
 	for _, mkline := range mklines.mklines {
 		mkline.Check()
 		varalign.Check(mkline)
 		switch {
 		case mkline.IsEmpty():
 			substcontext.Finish(mkline)
 		case mkline.IsVarassign():
 			mklines.target = ""
 			substcontext.Varassign(mkline)
 		case mkline.IsInclude():
 			mklines.target = ""
 			switch path.Base(mkline.Includefile()) {
 			case "bsd.prefs.mk", "bsd.fast.prefs.mk", "bsd.builtin.mk":
 				mklines.setSeenBsdPrefsMk()
+			}
 		case mkline.IsCond():
-			mkline.checkCond(&indentation, mklines.forVars)
+			mkline.checkCond(mklines.forVars)
 		case mkline.IsDependency():
 			mkline.checkDependencyRule(allowedTargets)
 			mklines.target = mkline.Targets()
+		}
+	}
 	lastMkline := mklines.mklines[len(mklines.mklines)-1]
 	substcontext.Finish(lastMkline)
 	varalign.Finish()
 	ChecklinesTrailingEmptyLines(mklines.lines)
 	if indentation.Len() != 1 && indentation.Depth() != 0 {

 @@ -234,13 +234,27 @@ func (s *Suite) Test_MkLines_LoopModifie
 	mklines := s.NewMkLines("chat/xchat/Makefile",
 		"# $"+"NetBSD$",
 		"GCONF_SCHEMAS=\tapps_xchat_url_handler.schemas",
 		"post-install:",
 		"\t${GCONF_SCHEMAS:@.s.@"+
 			"${INSTALL_DATA} ${WRKSRC}/src/common/dbus/${.s.} ${DESTDIR}${GCONF_SCHEMAS_DIR}/@}")
 	mklines.Check()
 	c.Check(s.Output(), equals, ""+ // No warning about missing @ at the end
 		"WARN: chat/xchat/Makefile:4: Unknown shell command \"${GCONF_SCHEMAS:@.s.@"+
 		"${INSTALL_DATA} ${WRKSRC}/src/common/dbus/${.s.} ${DESTDIR}${GCONF_SCHEMAS_DIR}/@}\".\n")
+}
 func (s *Suite) Test_MkLines_Indentation_DependsOn(c *check.C) {
 	G.globalData.InitVartypes()
 	mklines := s.NewMkLines("Makefile",
 		"# $"+"NetBSD$",
 		"PKG_SKIP_REASON+=\t\"Fails everywhere\"",
 		".if ${OPSYS} == \"Cygwin\"",
 		"PKG_SKIP_REASON+=\t\"Fails on Cygwin\"",
 		".endif")
 	mklines.Check()
 	c.Check(s.Output(), equals, "NOTE: Makefile:4: Consider defining NOT_FOR_PLATFORM instead of setting PKG_SKIP_REASON depending on ${OPSYS}.\n")
+}

 @@ -196,27 +196,27 @@ func (gd *GlobalData) InitVartypes() {
 	pkglist("CONFIGURE_DIRS", lkShell, CheckvarWrksrcSubdirectory)
 	acl("CONFIGURE_ENV", lkShell, CheckvarShellWord, "Makefile, Makefile.common: append, set, use; buildlink3.mk, builtin.mk: append; *.mk: append, use")
 	pkg("CONFIGURE_HAS_INFODIR", lkNone, CheckvarYesNo)
 	pkg("CONFIGURE_HAS_LIBDIR", lkNone, CheckvarYesNo)
 	pkg("CONFIGURE_HAS_MANDIR", lkNone, CheckvarYesNo)
 	pkg("CONFIGURE_SCRIPT", lkNone, CheckvarPathname)
 	acl("CONFIG_GUESS_OVERRIDE", lkShell, CheckvarPathmask, "Makefile, Makefile.common: set, append")
 	acl("CONFIG_STATUS_OVERRIDE", lkShell, CheckvarPathmask, "Makefile, Makefile.common: set, append")
 	acl("CONFIG_SHELL", lkNone, CheckvarPathname, "Makefile, Makefile.common: set")
 	acl("CONFIG_SUB_OVERRIDE", lkShell, CheckvarPathmask, "Makefile, Makefile.common: set, append")
 	pkglist("CONFLICTS", lkSpace, CheckvarDependency)
 	pkglist("CONF_FILES", lkShell, CheckvarShellWord)
 	pkg("CONF_FILES_MODE", lkNone, enum("0644 0640 0600 0400"))
-	pkglist("CONF_FILES_PERMS", lkShell, CheckvarShellWord)
+	pkglist("CONF_FILES_PERMS", lkShell, CheckvarPerms)
 	sys("COPY", lkNone, enum("-c")) // The flag that tells ${INSTALL} to copy a file
 	sys("CPP", lkNone, CheckvarShellCommand)
 	pkglist("CPPFLAGS*", lkShell, CheckvarCFlag)
 	acl("CRYPTO", lkNone, CheckvarYes, "Makefile: set")
 	sys("CXX", lkNone, CheckvarShellCommand)
 	pkglist("CXXFLAGS*", lkShell, CheckvarCFlag)
 	acl("DEINSTALL_FILE", lkNone, CheckvarPathname, "Makefile: set")
 	acl("DEINSTALL_SRC", lkShell, CheckvarPathname, "Makefile: set; Makefile.common: default, set")
 	acl("DEINSTALL_TEMPLATES", lkShell, CheckvarPathname, "Makefile: set, append; Makefile.common: set, default, append")
 	sys("DELAYED_ERROR_MSG", lkNone, CheckvarShellCommand)
 	sys("DELAYED_WARNING_MSG", lkNone, CheckvarShellCommand)
 	pkglist("DEPENDS", lkSpace, CheckvarDependencyWithPath)
 	usr("DEPENDS_TARGET", lkShell, CheckvarIdentifier)
 @@ -390,27 +390,27 @@ func (gd *GlobalData) InitVartypes() {
 	pkg("LICENSE_FILE", lkNone, CheckvarPathname)
 	sys("LINKER_RPATH_FLAG", lkNone, CheckvarShellWord)
 	sys("LOWER_OPSYS", lkNone, CheckvarIdentifier)
 	acl("LTCONFIG_OVERRIDE", lkShell, CheckvarPathmask, "Makefile: set, append; Makefile.common: append")
 	sys("MACHINE_ARCH", lkNone, enumMachineArch)
 	sys("MACHINE_GNU_ARCH", lkNone, enumMachineGnuArch)
 	sys("MACHINE_GNU_PLATFORM", lkNone, CheckvarMachineGnuPlatform)
 	sys("MACHINE_PLATFORM", lkNone, CheckvarMachinePlatform)
 	acl("MAINTAINER", lkNone, CheckvarMailAddress, "Makefile: set; Makefile.common: default")
 	sys("MAKE", lkNone, CheckvarShellCommand)
 	pkglist("MAKEFLAGS", lkShell, CheckvarShellWord)
 	acl("MAKEVARS", lkShell, CheckvarVarname, "builtin.mk: append; buildlink3.mk: append; hacks.mk: append")
 	pkglist("MAKE_DIRS", lkShell, CheckvarPathname)
-	pkglist("MAKE_DIRS_PERMS", lkShell, CheckvarShellWord)
+	pkglist("MAKE_DIRS_PERMS", lkShell, CheckvarPerms)
 	acl("MAKE_ENV", lkShell, CheckvarShellWord, "Makefile: append, set, use; Makefile.common: append, set, use; buildlink3.mk: append; builtin.mk: append; *.mk: append, use")
 	pkg("MAKE_FILE", lkNone, CheckvarPathname)
 	pkglist("MAKE_FLAGS", lkShell, CheckvarShellWord)
 	usr("MAKE_JOBS", lkNone, CheckvarInteger)
 	pkg("MAKE_JOBS_SAFE", lkNone, CheckvarYesNo)
 	pkg("MAKE_PROGRAM", lkNone, CheckvarShellCommand)
 	acl("MANCOMPRESSED", lkNone, CheckvarYesNo, "Makefile: set; Makefile.common: default, set")
 	acl("MANCOMPRESSED_IF_MANZ", lkNone, CheckvarYes, "Makefile: set; Makefile.common: default, set")
 	sys("MANGRP", lkNone, CheckvarUserGroupName)
 	sys("MANMODE", lkNone, CheckvarFileMode)
 	sys("MANOWN", lkNone, CheckvarUserGroupName)
 	pkglist("MASTER_SITES", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_APACHE", lkShell, CheckvarFetchURL)
 @@ -467,27 +467,27 @@ func (gd *GlobalData) InitVartypes() {
 	acl("NO_SRC_ON_CDROM", lkNone, CheckvarRestricted, "Makefile, Makefile.common: set")
 	acl("NO_SRC_ON_FTP", lkNone, CheckvarRestricted, "Makefile, Makefile.common: set")
 	pkglist("ONLY_FOR_COMPILER", lkShell, enum("ccc clang gcc hp icc ido mipspro mipspro-ucode pcc sunpro xlc"))
 	pkglist("ONLY_FOR_PLATFORM", lkSpace, CheckvarMachinePlatformPattern)
 	pkg("ONLY_FOR_UNPRIVILEGED", lkNone, CheckvarYesNo)
 	sys("OPSYS", lkNone, CheckvarIdentifier)
 	acl("OPSYSVARS", lkShell, CheckvarVarname, "Makefile, Makefile.common: append")
 	acl("OSVERSION_SPECIFIC", lkNone, CheckvarYes, "Makefile, Makefile.common: set")
 	sys("OS_VERSION", lkNone, CheckvarVersion)
 	pkg("OVERRIDE_DIRDEPTH*", lkNone, CheckvarInteger)
 	pkg("OVERRIDE_GNU_CONFIG_SCRIPTS", lkNone, CheckvarYes)
 	acl("OWNER", lkNone, CheckvarMailAddress, "Makefile: set; Makefile.common: default")
 	pkglist("OWN_DIRS", lkShell, CheckvarPathname)
-	pkglist("OWN_DIRS_PERMS", lkShell, CheckvarShellWord)
+	pkglist("OWN_DIRS_PERMS", lkShell, CheckvarPerms)
 	sys("PAMBASE", lkNone, CheckvarPathname)
 	usr("PAM_DEFAULT", lkNone, enum("linux-pam openpam solaris-pam"))
 	acl("PATCHDIR", lkNone, CheckvarRelativePkgPath, "Makefile: set; Makefile.common: default, set")
 	pkglist("PATCHFILES", lkShell, CheckvarFilename)
 	acl("PATCH_ARGS", lkShell, CheckvarShellWord, "")
 	acl("PATCH_DIST_ARGS", lkShell, CheckvarShellWord, "Makefile: set, append")
 	acl("PATCH_DIST_CAT", lkNone, CheckvarShellCommand, "")
 	acl("PATCH_DIST_STRIP*", lkNone, CheckvarShellWord, "Makefile, Makefile.common: set; buildlink3.mk:; builtin.mk:; *.mk: set")
 	acl("PATCH_SITES", lkShell, CheckvarFetchURL, "Makefile: set; options.mk: set; Makefile.common: set")
 	acl("PATCH_STRIP", lkNone, CheckvarShellWord, "")
 	pkg("PERL5_USE_PACKLIST", lkNone, CheckvarYesNo)
 	acl("PERL5_PACKLIST", lkShell, CheckvarPerl5Packlist, "Makefile: set; options.mk: set, append")
 	acl("PERL5_PACKLIST_DIR", lkNone, CheckvarPathname, "")
 @@ -554,27 +554,27 @@ func (gd *GlobalData) InitVartypes() {
 	acl("PKG_OPTIONS_NONEMPTY_SETS", lkSpace, CheckvarIdentifier, "")
 	acl("PKG_OPTIONS_OPTIONAL_GROUPS", lkSpace, CheckvarIdentifier, "options.mk: set, append")
 	acl("PKG_OPTIONS_REQUIRED_GROUPS", lkSpace, CheckvarIdentifier, "options.mk: set; Makefile: set")
 	acl("PKG_OPTIONS_SET.*", lkSpace, CheckvarOption, "")
 	acl("PKG_OPTIONS_VAR", lkNone, CheckvarPkgOptionsVar, "options.mk: set; Makefile, Makefile.common: set; bsd.options.mk: use-loadtime")
 	acl("PKG_PRESERVE", lkNone, CheckvarYes, "Makefile: set")
 	acl("PKG_SHELL", lkNone, CheckvarPathname, "Makefile, Makefile.common: set")
 	acl("PKG_SHELL.*", lkNone, CheckvarPathname, "Makefile, Makefile.common: set")
 	acl("PKG_SHLIBTOOL", lkNone, CheckvarPathname, "")
 	pkglist("PKG_SKIP_REASON", lkShell, CheckvarShellWord)
 	acl("PKG_SUGGESTED_OPTIONS", lkShell, CheckvarOption, "options.mk: set, append; Makefile: set, append; Makefile.common: set")
 	acl("PKG_SUPPORTED_OPTIONS", lkShell, CheckvarOption, "options.mk: set, append, use; Makefile: set, append; Makefile.common: set")
 	pkg("PKG_SYSCONFDIR*", lkNone, CheckvarPathname)
-	pkglist("PKG_SYSCONFDIR_PERMS", lkShell, CheckvarShellWord)
+	pkglist("PKG_SYSCONFDIR_PERMS", lkShell, CheckvarPerms)
 	sys("PKG_SYSCONFBASEDIR", lkNone, CheckvarPathname)
 	pkg("PKG_SYSCONFSUBDIR", lkNone, CheckvarPathname)
 	acl("PKG_SYSCONFVAR", lkNone, CheckvarIdentifier, "") // FIXME: name/type mismatch.
 	acl("PKG_UID", lkNone, CheckvarInteger, "Makefile: set")
 	acl("PKG_USERS", lkShell, CheckvarShellWord, "Makefile: set, append")
 	pkg("PKG_USERS_VARS", lkShell, CheckvarVarname)
 	acl("PKG_USE_KERBEROS", lkNone, CheckvarYes, "Makefile, Makefile.common: set")
 	// PLIST.* has special handling code
 	pkglist("PLIST_VARS", lkShell, CheckvarIdentifier)
 	pkglist("PLIST_SRC", lkShell, CheckvarRelativePkgPath)
 	pkglist("PLIST_SUBST", lkShell, CheckvarShellWord)
 	acl("PLIST_TYPE", lkNone, enum("dynamic static"), "")
 	acl("PREPEND_PATH", lkShell, CheckvarPathname, "")
 @@ -604,47 +604,47 @@ func (gd *GlobalData) InitVartypes() {
 	pkglist("REPLACE_AWK", lkShell, CheckvarPathmask)
 	pkglist("REPLACE_BASH", lkShell, CheckvarPathmask)
 	pkglist("REPLACE_CSH", lkShell, CheckvarPathmask)
 	acl("REPLACE_EMACS", lkShell, CheckvarPathmask, "")
 	acl("REPLACE_FILES.*", lkShell, CheckvarPathmask, "Makefile, Makefile.common: set, append")
 	acl("REPLACE_INTERPRETER", lkShell, CheckvarIdentifier, "Makefile, Makefile.common: append")
 	pkglist("REPLACE_KSH", lkShell, CheckvarPathmask)
 	pkglist("REPLACE_LOCALEDIR_PATTERNS", lkShell, CheckvarFilemask)
 	pkglist("REPLACE_LUA", lkShell, CheckvarPathmask)
 	pkglist("REPLACE_PERL", lkShell, CheckvarPathmask)
 	pkglist("REPLACE_PYTHON", lkShell, CheckvarPathmask)
 	pkglist("REPLACE_SH", lkShell, CheckvarPathmask)
 	pkglist("REQD_DIRS", lkShell, CheckvarPathname)
-	pkglist("REQD_DIRS_PERMS", lkShell, CheckvarShellWord)
+	pkglist("REQD_DIRS_PERMS", lkShell, CheckvarPerms)
 	pkglist("REQD_FILES", lkShell, CheckvarPathname)
 	pkg("REQD_FILES_MODE", lkNone, enum("0644 0640 0600 0400"))
-	pkglist("REQD_FILES_PERMS", lkShell, CheckvarShellWord)
+	pkglist("REQD_FILES_PERMS", lkShell, CheckvarPerms)
 	pkg("RESTRICTED", lkNone, CheckvarMessage)
 	usr("ROOT_USER", lkNone, CheckvarUserGroupName)
 	usr("ROOT_GROUP", lkNone, CheckvarUserGroupName)
 	usr("RUBY_VERSION_REQD", lkNone, CheckvarVersion)
 	sys("RUN", lkNone, CheckvarShellCommand)
 	sys("RUN_LDCONFIG", lkNone, CheckvarYesNo)
 	acl("SCRIPTS_ENV", lkShell, CheckvarShellWord, "Makefile, Makefile.common: append")
 	usr("SETUID_ROOT_PERMS", lkShell, CheckvarShellWord)
 	sys("SHAREGRP", lkNone, CheckvarUserGroupName)
 	sys("SHAREMODE", lkNone, CheckvarFileMode)
 	sys("SHAREOWN", lkNone, CheckvarUserGroupName)
 	sys("SHCOMMENT", lkNone, CheckvarShellCommand)
 	acl("SHLIB_HANDLING", lkNone, enum("YES NO no"), "")
 	acl("SHLIBTOOL", lkNone, CheckvarShellCommand, "Makefile: use")
 	acl("SHLIBTOOL_OVERRIDE", lkShell, CheckvarPathmask, "Makefile: set, append; Makefile.common: append")
 	acl("SITES.*", lkShell, CheckvarFetchURL, "Makefile, Makefile.common, options.mk: set, append, use")
-	pkglist("SPECIAL_PERMS", lkShell, CheckvarShellWord)
+	pkglist("SPECIAL_PERMS", lkShell, CheckvarPerms)
 	sys("STEP_MSG", lkNone, CheckvarShellCommand)
 	acl("SUBDIR", lkShell, CheckvarFilename, "Makefile: append; *:")
 	acl("SUBST_CLASSES", lkShell, CheckvarIdentifier, "Makefile: set, append; *: append")
 	acl("SUBST_FILES.*", lkShell, CheckvarPathmask, "Makefile: set, append; Makefile.*, *.mk: set, append")
 	acl("SUBST_FILTER_CMD.*", lkNone, CheckvarShellCommand, "Makefile, Makefile.*, *.mk: set")
 	acl("SUBST_MESSAGE.*", lkNone, CheckvarMessage, "Makefile, Makefile.*, *.mk: set")
 	acl("SUBST_SED.*", lkNone, CheckvarSedCommands, "Makefile, Makefile.*, *.mk: set, append")
 	pkg("SUBST_STAGE.*", lkNone, CheckvarStage)
 	pkglist("SUBST_VARS.*", lkShell, CheckvarVarname)
 	pkglist("SUPERSEDES", lkSpace, CheckvarDependency)
 	pkglist("TEST_DIRS", lkShell, CheckvarWrksrcSubdirectory)
 	pkglist("TEST_ENV", lkShell, CheckvarShellWord)
 	acl("TEST_TARGET", lkShell, CheckvarIdentifier, "Makefile: set; Makefile.common: default, set; options.mk: set, append")
 @@ -662,26 +662,27 @@ func (gd *GlobalData) InitVartypes() {
 	sys("TOOLS_PATH.*", lkNone, CheckvarPathname)
 	sys("TOOLS_PLATFORM.*", lkNone, CheckvarShellCommand)
 	sys("TOUCH_FLAGS", lkShell, CheckvarShellWord)
 	pkglist("UAC_REQD_EXECS", lkShell, CheckvarPrefixPathname)
 	acl("UNLIMIT_RESOURCES", lkShell, enum("datasize stacksize memorysize"), "Makefile: set, append; Makefile.common: append")
 	usr("UNPRIVILEGED_USER", lkNone, CheckvarUserGroupName)
 	usr("UNPRIVILEGED_GROUP", lkNone, CheckvarUserGroupName)
 	pkglist("UNWRAP_FILES", lkShell, CheckvarPathmask)
 	usr("UPDATE_TARGET", lkShell, CheckvarIdentifier)
 	pkg("USE_BSD_MAKEFILE", lkNone, CheckvarYes)
 	acl("USE_BUILTIN.*", lkNone, CheckvarYesNoIndirectly, "builtin.mk: set")
 	pkg("USE_CMAKE", lkNone, CheckvarYes)
 	acl("USE_CROSSBASE", lkNone, CheckvarYes, "Makefile: set")
 	usr("USE_DESTDIR", lkNone, CheckvarYes)
 	pkg("USE_FEATURES", lkShell, CheckvarIdentifier)
 	pkg("USE_GCC_RUNTIME", lkNone, CheckvarYesNo)
 	pkg("USE_GNU_CONFIGURE_HOST", lkNone, CheckvarYesNo)
 	acl("USE_GNU_ICONV", lkNone, CheckvarYes, "Makefile, Makefile.common: set; options.mk: set")
 	acl("USE_IMAKE", lkNone, CheckvarYes, "Makefile: set")
 	pkg("USE_JAVA", lkNone, enum("run yes build"))
 	pkg("USE_JAVA2", lkNone, enum("YES yes no 1.4 1.5 6 7 8"))
 	acl("USE_LANGUAGES", lkShell, enum("ada c c99 c++ fortran fortran77 java objc"), "Makefile, Makefile.common, options.mk: set, append")
 	pkg("USE_LIBTOOL", lkNone, CheckvarYes)
 	pkg("USE_MAKEINFO", lkNone, CheckvarYes)
 	pkg("USE_MSGFMT_PLURALS", lkNone, CheckvarYes)
 	pkg("USE_NCURSES", lkNone, CheckvarYes)
 	pkg("USE_OLD_DES_API", lkNone, CheckvarYesNo)

 @@ -226,26 +226,27 @@ var (
 	CheckvarInteger                = &VarChecker{"Integer", (*VartypeCheck).Integer}
 	CheckvarLdFlag                 = &VarChecker{"LdFlag", (*VartypeCheck).LdFlag}
 	CheckvarLicense                = &VarChecker{"License", (*VartypeCheck).License}
 	CheckvarMachineGnuPlatform     = &VarChecker{"MachineGnuPlatform", (*VartypeCheck).MachineGnuPlatform}
 	CheckvarMachinePlatform        = &VarChecker{"MachinePlatform", (*VartypeCheck).MachinePlatform}
 	CheckvarMachinePlatformPattern = &VarChecker{"MachinePlatformPattern", (*VartypeCheck).MachinePlatformPattern}
 	CheckvarMailAddress            = &VarChecker{"MailAddress", (*VartypeCheck).MailAddress}
 	CheckvarMessage                = &VarChecker{"Message", (*VartypeCheck).Message}
 	CheckvarOption                 = &VarChecker{"Option", (*VartypeCheck).Option}
 	CheckvarPathlist               = &VarChecker{"Pathlist", (*VartypeCheck).Pathlist}
 	CheckvarPathmask               = &VarChecker{"Pathmask", (*VartypeCheck).Pathmask}
 	CheckvarPathname               = &VarChecker{"Pathname", (*VartypeCheck).Pathname}
 	CheckvarPerl5Packlist          = &VarChecker{"Perl5Packlist", (*VartypeCheck).Perl5Packlist}
 	CheckvarPerms                  = &VarChecker{"Perms", (*VartypeCheck).Perms}
 	CheckvarPkgName                = &VarChecker{"PkgName", (*VartypeCheck).PkgName}
 	CheckvarPkgPath                = &VarChecker{"PkgPath", (*VartypeCheck).PkgPath}
 	CheckvarPkgOptionsVar          = &VarChecker{"PkgOptionsVar", (*VartypeCheck).PkgOptionsVar}
 	CheckvarPkgRevision            = &VarChecker{"PkgRevision", (*VartypeCheck).PkgRevision}
 	CheckvarPrefixPathname         = &VarChecker{"PrefixPathname", (*VartypeCheck).PrefixPathname}
 	CheckvarPythonDependency       = &VarChecker{"PythonDependency", (*VartypeCheck).PythonDependency}
 	CheckvarRelativePkgDir         = &VarChecker{"RelativePkgDir", (*VartypeCheck).RelativePkgDir}
 	CheckvarRelativePkgPath        = &VarChecker{"RelativePkgPath", (*VartypeCheck).RelativePkgPath}
 	CheckvarRestricted             = &VarChecker{"Restricted", (*VartypeCheck).Restricted}
 	CheckvarSedCommand             = &VarChecker{"SedCommand", (*VartypeCheck).SedCommand}
 	CheckvarSedCommands            = &VarChecker{"SedCommands", nil}
 	CheckvarShellCommand           = &VarChecker{"ShellCommand", nil}
 	CheckvarShellCommands          = &VarChecker{"ShellCommands", nil}

	@@ -652,26 +652,33 @@ func (cv *VartypeCheck) Pathname() {		@@ -652,26 +652,33 @@ func (cv *VartypeCheck) Pathname() {
652	}	652	}
653	if !matches(cv.valueNovar, `^[#\-0-9A-Za-z._~+%/]*$`) {	653	if !matches(cv.valueNovar, `^[#\-0-9A-Za-z._~+%/]*$`) {
654	cv.line.Warn1("%q is not a valid pathname.", cv.value)	654	cv.line.Warn1("%q is not a valid pathname.", cv.value)
655	}	655	}
656	cv.line.CheckAbsolutePathname(cv.value)	656	cv.line.CheckAbsolutePathname(cv.value)
657	}	657	}
658		658
659	func (cv *VartypeCheck) Perl5Packlist() {	659	func (cv *VartypeCheck) Perl5Packlist() {
660	if cv.value != cv.valueNovar {	660	if cv.value != cv.valueNovar {
661	cv.line.Warn1("%s should not depend on other variables.", cv.varname)	661	cv.line.Warn1("%s should not depend on other variables.", cv.varname)
662	}	662	}
663	}	663	}
664		664
		665	func (cv *VartypeCheck) Perms() {
		666	if cv.value == "${ROOT_USER}" \|\| cv.value == "${ROOT_GROUP}" {
		667	valuename := cv.value[2 : len(cv.value)-1]
		668	cv.line.Error1("%s must not be used in permission definitions. Use REAL_%[1]s instead.", valuename)
		669	}
		670	}
		671
665	func (cv *VartypeCheck) PkgName() {	672	func (cv *VartypeCheck) PkgName() {
666	if cv.op != opUseMatch && cv.value == cv.valueNovar && !matches(cv.value, rePkgname) {	673	if cv.op != opUseMatch && cv.value == cv.valueNovar && !matches(cv.value, rePkgname) {
667	cv.line.Warn1("%q is not a valid package name. A valid package name has the form packagename-version, where version consists only of digits, letters and dots.", cv.value)	674	cv.line.Warn1("%q is not a valid package name. A valid package name has the form packagename-version, where version consists only of digits, letters and dots.", cv.value)
668	}	675	}
669	}	676	}
670		677
671	func (cv *VartypeCheck) PkgOptionsVar() {	678	func (cv *VartypeCheck) PkgOptionsVar() {
672	cv.mkline.CheckVartypePrimitive(cv.varname, CheckvarVarname, cv.op, cv.value, cv.comment, false, cv.guessed)	679	cv.mkline.CheckVartypePrimitive(cv.varname, CheckvarVarname, cv.op, cv.value, cv.comment, false, cv.guessed)
673	if matches(cv.value, `\$\{PKGBASE[:\}]`) {	680	if matches(cv.value, `\$\{PKGBASE[:\}]`) {
674	cv.line.Error0("PKGBASE must not be used in PKG_OPTIONS_VAR.")	681	cv.line.Error0("PKGBASE must not be used in PKG_OPTIONS_VAR.")
675	Explain3(	682	Explain3(
676	"PKGBASE is defined in bsd.pkg.mk, which is included as the",	683	"PKGBASE is defined in bsd.pkg.mk, which is included as the",
677	"very last file, but PKG_OPTIONS_VAR is evaluated earlier.",	684	"very last file, but PKG_OPTIONS_VAR is evaluated earlier.",