Updated pkglint to 5.4.7.

Changes since 5.4.6:

* Allow conditionals of the form "${var1}" == "${var2}"
* Check for indentation of .include directives
* Check arbitrarily complex license conditions
* General code cleanup

30 files changed, 1363 insertions, 1268 deletions

diff --git a/pkgtools/pkglint/Makefile b/pkgtools/pkglint/Makefile
index 3eaab137338..a34e3ca17e7 100644
--- a/pkgtools/pkglint/Makefile
+++ b/pkgtools/pkglint/Makefile
@@ -1,6 +1,6 @@
-# $NetBSD: Makefile,v 1.491 2016/07/10 11:37:27 rillig Exp $
+# $NetBSD: Makefile,v 1.492 2016/07/10 21:24:47 rillig Exp $
 
-PKGNAME=	pkglint-5.4.6
+PKGNAME=	pkglint-5.4.7
 DISTFILES=	# none
 CATEGORIES=	pkgtools
 
diff --git a/pkgtools/pkglint/files/globaldata.go b/pkgtools/pkglint/files/globaldata.go
index 5e396d302ba..4bf6699bfb6 100644
--- a/pkgtools/pkglint/files/globaldata.go
+++ b/pkgtools/pkglint/files/globaldata.go
@@ -114,7 +114,7 @@ func (gd *GlobalData) loadTools() {
 		fname := G.globalData.Pkgsrcdir + "/mk/tools/bsd.tools.mk"
 		lines := LoadExistingLines(fname, true)
 		for _, line := range lines {
-			if m, _, includefile := match2(line.Text, reMkInclude); m {
+			if m, _, _, includefile := match3(line.Text, reMkInclude); m {
 				if !contains(includefile, "/") {
 					toolFiles = append(toolFiles, includefile)
 				}
diff --git a/pkgtools/pkglint/files/globaldata_test.go b/pkgtools/pkglint/files/globaldata_test.go
index 7e3287b19e0..3dfd757dc35 100644
--- a/pkgtools/pkglint/files/globaldata_test.go
+++ b/pkgtools/pkglint/files/globaldata_test.go
@@ -7,8 +7,8 @@ import (
 func (s *Suite) Test_GlobalData_InitVartypes(c *check.C) {
 	G.globalData.InitVartypes()
 
-	c.Check(G.globalData.vartypes["BSD_MAKE_ENV"].checker.name, equals, "ShellWord")
-	c.Check(G.globalData.vartypes["USE_BUILTIN.*"].checker.name, equals, "YesNoIndirectly")
+	c.Check(G.globalData.vartypes["BSD_MAKE_ENV"].basicType.name, equals, "ShellWord")
+	c.Check(G.globalData.vartypes["USE_BUILTIN.*"].basicType.name, equals, "YesNoIndirectly")
 }
 
 func (s *Suite) Test_parselinesSuggestedUpdates(c *check.C) {
diff --git a/pkgtools/pkglint/files/license.y b/pkgtools/pkglint/files/license.y
new file mode 100755
index 00000000000..802fc8a3713
--- /dev/null
+++ b/pkgtools/pkglint/files/license.y
@@ -0,0 +1,35 @@
+%{
+package main
+%}
+
+%token <Node> ltNAME
+%token ltAND ltOR ltOPEN ltCLOSE
+
+%union {
+	Node *LicenseCondition
+}
+
+%type <Node> start list condition
+
+%%
+
+start : list {
+	liyylex.(*licenseLexer).result = $$
+}
+
+list : condition {
+	$$ = $1
+}
+list : list ltAND condition {
+	$$.And = append($$.And, $3)
+}
+list : list ltOR condition {
+	$$.Or = append($$.Or, $3)
+}
+
+condition : ltNAME {
+	$$ = $1
+}
+condition : ltOPEN list ltCLOSE {
+	$$ = &LicenseCondition{Main: $2}
+}
diff --git a/pkgtools/pkglint/files/licenses.go b/pkgtools/pkglint/files/licenses.go
index 0009e6e56e4..ffb6378f88a 100644
--- a/pkgtools/pkglint/files/licenses.go
+++ b/pkgtools/pkglint/files/licenses.go
@@ -2,16 +2,78 @@ package main
 
 import (
 	"io/ioutil"
-	"strings"
 )
 
-func parseLicenses(licenses string) []string {
-	noPerl := strings.Replace(licenses, "${PERL5_LICENSE}", "gnu-gpl-v2 OR artistic", -1)
-	noOps := regcomp(`[()]|AND|OR`).ReplaceAllString(noPerl, "") // cheated
-	return splitOnSpace(strings.TrimSpace(noOps))
+//go:generate go tool yacc -p liyy -o licenseyacc.go -v licenseyacc.log license.y
+
+// LicenseCondition describes a complex license condition.
+// It has either `Name` or `Main` set.
+type LicenseCondition struct {
+	Name string
+	Main *LicenseCondition
+	And  []*LicenseCondition
+	Or   []*LicenseCondition
+}
+
+func (lc *LicenseCondition) Walk(callback func(*LicenseCondition)) {
+	callback(lc)
+	if lc.Main != nil {
+		lc.Main.Walk(callback)
+	}
+	for _, and := range lc.And {
+		and.Walk(callback)
+	}
+	for _, or := range lc.Or {
+		or.Walk(callback)
+	}
+}
+
+type licenseLexer struct {
+	repl   *PrefixReplacer
+	result *LicenseCondition
+	error  string
 }
 
-func checktoplevelUnusedLicenses() {
+func (lexer *licenseLexer) Lex(llval *liyySymType) int {
+	repl := lexer.repl
+	repl.AdvanceHspace()
+	switch {
+	case repl.rest == "":
+		return 0
+	case repl.AdvanceStr("("):
+		return ltOPEN
+	case repl.AdvanceStr(")"):
+		return ltCLOSE
+	case repl.AdvanceRegexp(`^[\w-.]+`):
+		word := repl.m[0]
+		switch word {
+		case "AND":
+			return ltAND
+		case "OR":
+			return ltOR
+		default:
+			llval.Node = &LicenseCondition{Name: word}
+			return ltNAME
+		}
+	}
+	return -1
+}
+
+func (lexer *licenseLexer) Error(s string) {
+	lexer.error = s
+}
+
+func parseLicenses(licenses string) *LicenseCondition {
+	expanded := resolveVariableRefs(licenses) // For ${PERL5_LICENSE}
+	lexer := &licenseLexer{repl: NewPrefixReplacer(expanded)}
+	result := liyyNewParser().Parse(lexer)
+	if result == 0 {
+		return lexer.result
+	}
+	return nil
+}
+
+func checkToplevelUnusedLicenses() {
 	if G.UsedLicenses == nil {
 		return
 	}
@@ -29,38 +91,68 @@ func checktoplevelUnusedLicenses() {
 	}
 }
 
-func checklineLicense(line *MkLine, value string) {
-	licenses := parseLicenses(value)
-	for _, license := range licenses {
-		var licenseFile string
-		if G.Pkg != nil {
-			if licenseFileValue, ok := G.Pkg.varValue("LICENSE_FILE"); ok {
-				licenseFile = G.CurrentDir + "/" + resolveVarsInRelativePath(licenseFileValue, false)
-			}
-		}
-		if licenseFile == "" {
-			licenseFile = G.globalData.Pkgsrcdir + "/licenses/" + license
-			if G.UsedLicenses != nil {
-				G.UsedLicenses[license] = true
-			}
-		}
+type LicenseChecker struct {
+	MkLine *MkLine
+}
 
-		if !fileExists(licenseFile) {
-			line.Warn1("License file %s does not exist.", cleanpath(licenseFile))
+func (lc *LicenseChecker) Check(value string, op MkOperator) {
+	licenses := parseLicenses(ifelseStr(op == opAssignAppend, "append-placeholder ", "") + value)
+
+	if licenses == nil {
+		if op == opAssign {
+			lc.MkLine.Line.Error1("Parse error for license condition %q.", value)
+		} else {
+			lc.MkLine.Line.Error1("Parse error for appended license condition %q.", value)
 		}
+		return
+	}
+
+	licenses.Walk(lc.checkNode)
+}
 
-		switch license {
-		case "fee-based-commercial-use",
-			"no-commercial-use",
-			"no-profit",
-			"no-redistribution",
-			"shareware":
-			line.Warn1("License %q is deprecated.", license)
-			Explain(
-				"Instead of using these deprecated licenses, extract the actual",
-				"license from the package into the pkgsrc/licenses/ directory",
-				"and define LICENSE to that file name.  See the pkgsrc guide,",
-				"keyword LICENSE, for more information.")
+func (lc *LicenseChecker) checkNode(cond *LicenseCondition) {
+	license := cond.Name
+	if license == "" || license == "append-placeholder" {
+		return
+	}
+
+	var licenseFile string
+	if G.Pkg != nil {
+		if licenseFileValue, ok := G.Pkg.varValue("LICENSE_FILE"); ok {
+			licenseFile = G.CurrentDir + "/" + resolveVarsInRelativePath(licenseFileValue, false)
+		}
+	}
+	if licenseFile == "" {
+		licenseFile = G.globalData.Pkgsrcdir + "/licenses/" + license
+		if G.UsedLicenses != nil {
+			G.UsedLicenses[license] = true
 		}
 	}
+
+	if !fileExists(licenseFile) {
+		lc.MkLine.Warn1("License file %s does not exist.", cleanpath(licenseFile))
+	}
+
+	switch license {
+	case "fee-based-commercial-use",
+		"no-commercial-use",
+		"no-profit",
+		"no-redistribution",
+		"shareware":
+		lc.MkLine.Error1("License %q must not be used.", license)
+		Explain(
+			"Instead of using these deprecated licenses, extract the actual",
+			"license from the package into the pkgsrc/licenses/ directory",
+			"and define LICENSE to that file name.  See the pkgsrc guide,",
+			"keyword LICENSE, for more information.")
+	}
+
+	if len(cond.And) > 0 && len(cond.Or) > 0 {
+		lc.MkLine.Line.Error0("AND and OR operators in license conditions can only be combined using parentheses.")
+		Explain(
+			"Examples for valid license conditions are:",
+			"",
+			"\tlicense1 AND license2 AND (license3 OR license4)",
+			"\t(((license1 OR license2) AND (license3 OR license4)))")
+	}
 }
diff --git a/pkgtools/pkglint/files/licenses_test.go b/pkgtools/pkglint/files/licenses_test.go
index ca2f360b477..8129dbae86d 100644
--- a/pkgtools/pkglint/files/licenses_test.go
+++ b/pkgtools/pkglint/files/licenses_test.go
@@ -5,8 +5,8 @@ import (
 )
 
 func (s *Suite) Test_parseLicenses(c *check.C) {
-	c.Check(parseLicenses("gnu-gpl-v2"), check.DeepEquals, []string{"gnu-gpl-v2"})
-	c.Check(parseLicenses("AND artistic"), check.DeepEquals, []string{"artistic"})
+	c.Check(parseLicenses("gnu-gpl-v2"), check.DeepEquals, &LicenseCondition{Name: "gnu-gpl-v2"})
+	c.Check(parseLicenses("AND artistic"), check.IsNil)
 }
 
 func (s *Suite) Test_checklineLicense(c *check.C) {
@@ -15,19 +15,32 @@ func (s *Suite) Test_checklineLicense(c *check.C) {
 	G.globalData.Pkgsrcdir = s.tmpdir
 	G.CurrentDir = s.tmpdir
 
-	checklineLicense(mkline, "gpl-v2")
+	licenseChecker := &LicenseChecker{mkline}
+	licenseChecker.Check("gpl-v2", opAssign)
 
 	c.Check(s.Output(), equals, "WARN: Makefile:7: License file ~/licenses/gpl-v2 does not exist.\n")
 
-	checklineLicense(mkline, "no-profit shareware")
+	licenseChecker.Check("no-profit shareware", opAssign)
+
+	c.Check(s.Output(), equals, "ERROR: Makefile:7: Parse error for license condition \"no-profit shareware\".\n")
+
+	licenseChecker.Check("no-profit AND shareware", opAssign)
 
 	c.Check(s.Output(), equals, ""+
 		"WARN: Makefile:7: License file ~/licenses/no-profit does not exist.\n"+
-		"WARN: Makefile:7: License \"no-profit\" is deprecated.\n"+
+		"ERROR: Makefile:7: License \"no-profit\" must not be used.\n"+
 		"WARN: Makefile:7: License file ~/licenses/shareware does not exist.\n"+
-		"WARN: Makefile:7: License \"shareware\" is deprecated.\n")
+		"ERROR: Makefile:7: License \"shareware\" must not be used.\n")
+
+	licenseChecker.Check("gnu-gpl-v2", opAssign)
+
+	c.Check(s.Output(), equals, "")
+
+	licenseChecker.Check("gnu-gpl-v2 AND gnu-gpl-v2 OR gnu-gpl-v2", opAssign)
+
+	c.Check(s.Output(), equals, "ERROR: Makefile:7: AND and OR operators in license conditions can only be combined using parentheses.\n")
 
-	checklineLicense(mkline, "gnu-gpl-v2")
+	licenseChecker.Check("(gnu-gpl-v2 OR gnu-gpl-v2) AND gnu-gpl-v2", opAssign)
 
 	c.Check(s.Output(), equals, "")
 }
diff --git a/pkgtools/pkglint/files/main.go b/pkgtools/pkglint/files/main.go
index c12fb988dba..05d8cb950e6 100644
--- a/pkgtools/pkglint/files/main.go
+++ b/pkgtools/pkglint/files/main.go
@@ -67,7 +67,7 @@ func (pkglint *Pkglint) Main(args ...string) (exitcode int) {
 		CheckDirent(item)
 	}
 
-	checktoplevelUnusedLicenses()
+	checkToplevelUnusedLicenses()
 	pkglint.PrintSummary()
 	if G.opts.Profiling {
 		G.loghisto.PrintStats("loghisto", G.logOut, 0)
diff --git a/pkgtools/pkglint/files/mkline.go b/pkgtools/pkglint/files/mkline.go
index 8b3bb1a8f58..7fadfb7533e 100644
--- a/pkgtools/pkglint/files/mkline.go
+++ b/pkgtools/pkglint/files/mkline.go
@@ -13,15 +13,34 @@ import (
 type MkLine struct {
 	Line *Line
 
-	xtype      uint8
-	xmustexist bool
-	xop        MkOperator
-	xvalign    string
-	xs1        string
-	xs2        string
-	xs3        string
-	xvalue     string
-	xcomment   string
+	xtype uint8
+	data  interface{} // One of the following mkLine* types
+}
+type mkLineAssign struct {
+	varname    string
+	varcanon   string
+	varparam   string
+	op         MkOperator
+	valueAlign string
+	value      string
+	comment    string
+}
+type mkLineShell struct {
+	command string
+}
+type mkLineConditional struct {
+	indent    string
+	directive string
+	args      string
+}
+type mkLineInclude struct {
+	mustexist   bool
+	indent      string
+	includeFile string
+}
+type mkLineDependency struct {
+	targets string
+	sources string
 }
 
 func (mkline *MkLine) Error1(format, arg1 string)      { mkline.Line.Error1(format, arg1) }
@@ -62,27 +81,28 @@ func NewMkLine(line *Line) (mkline *MkLine) {
 		varparam := varnameParam(varname)
 
 		mkline.xtype = 1
-		mkline.xs1 = varname
-		mkline.xs2 = varnameCanon(varname)
-		mkline.xs3 = varparam
-		mkline.xop = NewMkOperator(op)
-		mkline.xvalign = valueAlign
-		mkline.xvalue = value
-		mkline.xcomment = comment
+		mkline.data = mkLineAssign{
+			varname,
+			varnameCanon(varname),
+			varparam,
+			NewMkOperator(op),
+			valueAlign,
+			value,
+			comment}
 		mkline.Tokenize(value)
 		return
 	}
 
 	if hasPrefix(text, "\t") {
+		shellcmd := text[1:]
 		mkline.xtype = 2
-		mkline.xs1 = text[1:]
-		mkline.Tokenize(mkline.xs1)
+		mkline.data = mkLineShell{shellcmd}
+		mkline.Tokenize(shellcmd)
 		return
 	}
 
 	if index := strings.IndexByte(text, '#'); index != -1 && strings.TrimSpace(text[:index]) == "" {
 		mkline.xtype = 3
-		mkline.xcomment = text[index+1:]
 		return
 	}
 
@@ -93,30 +113,25 @@ func NewMkLine(line *Line) (mkline *MkLine) {
 
 	if m, indent, directive, args := matchMkCond(text); m {
 		mkline.xtype = 5
-		mkline.xs1 = indent
-		mkline.xs2 = directive
-		mkline.xs3 = args
+		mkline.data = mkLineConditional{indent, directive, args}
 		return
 	}
 
-	if m, directive, includefile := match2(text, reMkInclude); m {
+	if m, indent, directive, includefile := match3(text, reMkInclude); m {
 		mkline.xtype = 6
-		mkline.xmustexist = directive == "include"
-		mkline.xs1 = includefile
+		mkline.data = mkLineInclude{directive == "include", indent, includefile}
 		return
 	}
 
-	if m, directive, includefile := match2(text, `^\.\s*(s?include)\s+<([^>]+)>\s*(?:#.*)?$`); m {
+	if m, indent, directive, includefile := match3(text, `^\.(\s*)(s?include)\s+<([^>]+)>\s*(?:#.*)?$`); m {
 		mkline.xtype = 7
-		mkline.xmustexist = directive == "include"
-		mkline.xs1 = includefile
+		mkline.data = mkLineInclude{directive == "include", indent, includefile}
 		return
 	}
 
 	if m, targets, whitespace, sources := match3(text, `^([^\s:]+(?:\s*[^\s:]+)*)(\s*):\s*([^#]*?)(?:\s*#.*)?$`); m {
 		mkline.xtype = 8
-		mkline.xs1 = targets
-		mkline.xs2 = sources
+		mkline.data = mkLineDependency{targets, sources}
 		if whitespace != "" {
 			line.Warn0("Space before colon in dependency line.")
 		}
@@ -134,29 +149,35 @@ func NewMkLine(line *Line) (mkline *MkLine) {
 func (mkline *MkLine) String() string {
 	return fmt.Sprintf("%s:%s", mkline.Line.Fname, mkline.Line.linenos())
 }
-func (mkline *MkLine) IsVarassign() bool   { return mkline.xtype == 1 }
-func (mkline *MkLine) Varname() string     { return mkline.xs1 }
-func (mkline *MkLine) Varcanon() string    { return mkline.xs2 }
-func (mkline *MkLine) Varparam() string    { return mkline.xs3 }
-func (mkline *MkLine) Op() MkOperator      { return mkline.xop }
-func (mkline *MkLine) ValueAlign() string  { return mkline.xvalign }
-func (mkline *MkLine) Value() string       { return mkline.xvalue }
-func (mkline *MkLine) Comment() string     { return mkline.xcomment }
-func (mkline *MkLine) IsShellcmd() bool    { return mkline.xtype == 2 }
-func (mkline *MkLine) Shellcmd() string    { return mkline.xs1 }
-func (mkline *MkLine) IsComment() bool     { return mkline.xtype == 3 }
-func (mkline *MkLine) IsEmpty() bool       { return mkline.xtype == 4 }
-func (mkline *MkLine) IsCond() bool        { return mkline.xtype == 5 }
-func (mkline *MkLine) Indent() string      { return mkline.xs1 }
-func (mkline *MkLine) Directive() string   { return mkline.xs2 }
-func (mkline *MkLine) Args() string        { return mkline.xs3 }
-func (mkline *MkLine) IsInclude() bool     { return mkline.xtype == 6 }
-func (mkline *MkLine) MustExist() bool     { return mkline.xmustexist }
-func (mkline *MkLine) Includefile() string { return mkline.xs1 }
-func (mkline *MkLine) IsSysinclude() bool  { return mkline.xtype == 7 }
-func (mkline *MkLine) IsDependency() bool  { return mkline.xtype == 8 }
-func (mkline *MkLine) Targets() string     { return mkline.xs1 }
-func (mkline *MkLine) Sources() string     { return mkline.xs2 }
+func (mkline *MkLine) IsVarassign() bool        { return mkline.xtype == 1 }
+func (mkline *MkLine) IsShellcmd() bool         { return mkline.xtype == 2 }
+func (mkline *MkLine) IsComment() bool          { return mkline.xtype == 3 }
+func (mkline *MkLine) IsEmpty() bool            { return mkline.xtype == 4 }
+func (mkline *MkLine) IsCond() bool             { return mkline.xtype == 5 }
+func (mkline *MkLine) IsInclude() bool          { return mkline.xtype == 6 }
+func (mkline *MkLine) IsSysinclude() bool       { return mkline.xtype == 7 }
+func (mkline *MkLine) IsDependency() bool       { return mkline.xtype == 8 }
+func (mkline *MkLine) Varname() string          { return mkline.data.(mkLineAssign).varname }
+func (mkline *MkLine) Varcanon() string         { return mkline.data.(mkLineAssign).varcanon }
+func (mkline *MkLine) Varparam() string         { return mkline.data.(mkLineAssign).varparam }
+func (mkline *MkLine) Op() MkOperator           { return mkline.data.(mkLineAssign).op }
+func (mkline *MkLine) ValueAlign() string       { return mkline.data.(mkLineAssign).valueAlign }
+func (mkline *MkLine) Value() string            { return mkline.data.(mkLineAssign).value }
+func (mkline *MkLine) VarassignComment() string { return mkline.data.(mkLineAssign).comment }
+func (mkline *MkLine) Shellcmd() string         { return mkline.data.(mkLineShell).command }
+func (mkline *MkLine) Indent() string {
+	if mkline.IsCond() {
+		return mkline.data.(mkLineConditional).indent
+	} else {
+		return mkline.data.(mkLineInclude).indent
+	}
+}
+func (mkline *MkLine) Directive() string   { return mkline.data.(mkLineConditional).directive }
+func (mkline *MkLine) Args() string        { return mkline.data.(mkLineConditional).args }
+func (mkline *MkLine) MustExist() bool     { return mkline.data.(mkLineInclude).mustexist }
+func (mkline *MkLine) Includefile() string { return mkline.data.(mkLineInclude).includeFile }
+func (mkline *MkLine) Targets() string     { return mkline.data.(mkLineDependency).targets }
+func (mkline *MkLine) Sources() string     { return mkline.data.(mkLineDependency).sources }
 
 func (mkline *MkLine) Check() {
 	mkline.Line.CheckTrailingWhitespace()
@@ -186,6 +207,10 @@ func (mkline *MkLine) checkInclude() {
 		defer tracecall0()()
 	}
 
+	if mkline.Indent() != "" {
+		mkline.checkDirectiveIndentation()
+	}
+
 	includefile := mkline.Includefile()
 	mustExist := mkline.MustExist()
 	if G.opts.Debug {
@@ -230,7 +255,8 @@ func (mkline *MkLine) checkInclude() {
 }
 
 func (mkline *MkLine) checkCond(forVars map[string]bool) {
-	indent, directive, args := mkline.Indent(), mkline.Directive(), mkline.Args()
+	directive := mkline.Directive()
+	args := mkline.Args()
 	indentation := &G.Mk.indentation
 
 	switch directive {
@@ -242,12 +268,7 @@ func (mkline *MkLine) checkCond(forVars map[string]bool) {
 		}
 	}
 
-	// Check the indentation
-	if expected := strings.Repeat(" ", indentation.Depth()); indent != expected {
-		if G.opts.WarnSpace && !mkline.Line.AutofixReplace("."+indent, "."+expected) {
-			mkline.Line.Notef("This directive should be indented by %d spaces.", indentation.Depth())
-		}
-	}
+	mkline.checkDirectiveIndentation()
 
 	if directive == "if" && matches(args, `^!defined\([\w]+_MK\)$`) {
 		indentation.Push(indentation.Depth())
@@ -256,27 +277,23 @@ func (mkline *MkLine) checkCond(forVars map[string]bool) {
 		indentation.Push(indentation.Depth() + 2)
 	}
 
-	const reDirectivesWithArgs = `^(?:if|ifdef|ifndef|elif|for|undef)$`
-	if matches(directive, reDirectivesWithArgs) && args == "" {
-		mkline.Error1("\".%s\" requires arguments.", directive)
-
-	} else if !matches(directive, reDirectivesWithArgs) && args != "" {
-		mkline.Error1("\".%s\" does not take arguments.", directive)
-
-		if directive == "else" {
-			mkline.Note0("If you meant \"else if\", use \".elif\".")
+	needsArgument := matches(directive, `^(?:if|ifdef|ifndef|elif|for|undef)$`)
+	if needsArgument != (args != "") {
+		if needsArgument {
+			mkline.Error1("\".%s\" requires arguments.", directive)
+		} else {
+			mkline.Error1("\".%s\" does not take arguments.", directive)
+			if directive == "else" {
+				mkline.Note0("If you meant \"else if\", use \".elif\".")
+			}
 		}
 
 	} else if directive == "if" || directive == "elif" {
 		mkline.CheckCond()
 
 	} else if directive == "ifdef" || directive == "ifndef" {
-		if matches(args, `\s`) {
-			mkline.Error1("The \".%s\" directive can only handle _one_ argument.", directive)
-		} else {
-			mkline.Line.Warnf("The \".%s\" directive is deprecated. Please use \".if %sdefined(%s)\" instead.",
-				directive, ifelseStr(directive == "ifdef", "", "!"), args)
-		}
+		mkline.Line.Warnf("The \".%s\" directive is deprecated. Please use \".if %sdefined(%s)\" instead.",
+			directive, ifelseStr(directive == "ifdef", "", "!"), args)
 
 	} else if directive == "for" {
 		if m, vars, values := match2(args, `^(\S+(?:\s*\S+)*?)\s+in\s+(.*)$`); m {
@@ -307,7 +324,7 @@ func (mkline *MkLine) checkCond(forVars map[string]bool) {
 				}
 			}
 
-			forLoopType := &Vartype{lkSpace, CheckvarUnchecked, []AclEntry{{"*", aclpAllRead}}, guessed}
+			forLoopType := &Vartype{lkSpace, BtUnknown, []AclEntry{{"*", aclpAllRead}}, guessed}
 			forLoopContext := &VarUseContext{forLoopType, vucTimeParse, vucQuotFor, false}
 			for _, forLoopVar := range mkline.extractUsedVariables(values) {
 				mkline.CheckVaruse(&MkVarUse{forLoopVar, nil}, forLoopContext)
@@ -323,6 +340,19 @@ func (mkline *MkLine) checkCond(forVars map[string]bool) {
 	}
 }
 
+func (mkline *MkLine) checkDirectiveIndentation() {
+	if G.Mk == nil {
+		return
+	}
+	indent := mkline.Indent()
+	indentation := G.Mk.indentation
+	if expected := strings.Repeat(" ", indentation.Depth()); indent != expected {
+		if G.opts.WarnSpace && !mkline.Line.AutofixReplace("."+indent, "."+expected) {
+			mkline.Line.Notef("This directive should be indented by %d spaces.", indentation.Depth())
+		}
+	}
+}
+
 func (mkline *MkLine) checkDependencyRule(allowedTargets map[string]bool) {
 	targets := splitOnSpace(mkline.Targets())
 	sources := splitOnSpace(mkline.Sources())
@@ -757,7 +787,7 @@ func (mkline *MkLine) checkVarassign() {
 	varname := mkline.Varname()
 	op := mkline.Op()
 	value := mkline.Value()
-	comment := mkline.Comment()
+	comment := mkline.VarassignComment()
 	varcanon := varnameCanon(varname)
 
 	if G.opts.Debug {
@@ -928,7 +958,7 @@ func (mkline *MkLine) checkVarassignSpecific() {
 		mkline.checkVarassignPythonVersions(varname, value)
 	}
 
-	if mkline.Comment() == "# defined" && !hasSuffix(varname, "_MK") && !hasSuffix(varname, "_COMMON") {
+	if mkline.VarassignComment() == "# defined" && !hasSuffix(varname, "_MK") && !hasSuffix(varname, "_COMMON") {
 		mkline.Note0("Please use \"# empty\", \"# none\" or \"yes\" instead of \"# defined\".")
 		Explain(
 			"The value #defined says something about the state of the variable,",
@@ -1031,27 +1061,27 @@ func (mkline *MkLine) CheckVartype(varname string, op MkOperator, value, comment
 		}
 
 	case vartype.kindOfList == lkNone:
-		mkline.CheckVartypePrimitive(varname, vartype.checker, op, value, comment, vartype.guessed)
+		mkline.CheckVartypePrimitive(varname, vartype.basicType, op, value, comment, vartype.guessed)
 
 	case value == "":
 		break
 
 	case vartype.kindOfList == lkSpace:
 		for _, word := range splitOnSpace(value) {
-			mkline.CheckVartypePrimitive(varname, vartype.checker, op, word, comment, vartype.guessed)
+			mkline.CheckVartypePrimitive(varname, vartype.basicType, op, word, comment, vartype.guessed)
 		}
 
 	case vartype.kindOfList == lkShell:
 		words, _ := splitIntoMkWords(mkline.Line, value)
 		for _, word := range words {
-			mkline.CheckVartypePrimitive(varname, vartype.checker, op, word, comment, vartype.guessed)
+			mkline.CheckVartypePrimitive(varname, vartype.basicType, op, word, comment, vartype.guessed)
 		}
 	}
 }
 
 // For some variables (like `BuildlinkDepth`), `op` influences the valid values.
 // The `comment` parameter comes from a variable assignment, when a part of the line is commented out.
-func (mkline *MkLine) CheckVartypePrimitive(varname string, checker *VarChecker, op MkOperator, value, comment string, guessed bool) {
+func (mkline *MkLine) CheckVartypePrimitive(varname string, checker *BasicType, op MkOperator, value, comment string, guessed bool) {
 	if G.opts.Debug {
 		defer tracecall(varname, checker.name, op, value, comment, guessed)()
 	}
@@ -1330,7 +1360,7 @@ func (mkline *MkLine) variableNeedsQuoting(varname string, vartype *Vartype, vuc
 		return nqDontKnow
 	}
 
-	if vartype.checker.IsEnum() || vartype.IsBasicSafe() {
+	if vartype.basicType.IsEnum() || vartype.IsBasicSafe() {
 		if vartype.kindOfList == lkNone {
 			return nqDoesntMatter
 		}
@@ -1355,7 +1385,7 @@ func (mkline *MkLine) variableNeedsQuoting(varname string, vartype *Vartype, vuc
 
 	// A shell word may appear as part of a shell word, for example COMPILER_RPATH_FLAG.
 	if vuc.IsWordPart && vuc.quoting == vucQuotPlain {
-		if vartype.kindOfList == lkNone && vartype.checker == CheckvarShellWord {
+		if vartype.kindOfList == lkNone && vartype.basicType == BtShellWord {
 			return nqNo
 		}
 	}
@@ -1406,10 +1436,10 @@ func (mkline *MkLine) variableNeedsQuoting(varname string, vartype *Vartype, vuc
 
 	if wantList != haveList {
 		if vuc.vartype != nil && vartype != nil {
-			if vuc.vartype.checker == CheckvarFetchURL && vartype.checker == CheckvarHomepage {
+			if vuc.vartype.basicType == BtFetchURL && vartype.basicType == BtHomepage {
 				return nqNo
 			}
-			if vuc.vartype.checker == CheckvarHomepage && vartype.checker == CheckvarFetchURL {
+			if vuc.vartype.basicType == BtHomepage && vartype.basicType == BtFetchURL {
 				return nqNo // Just for HOMEPAGE=${MASTER_SITE_*:=subdir/}.
 			}
 		}
@@ -1452,11 +1482,11 @@ func (mkline *MkLine) getVariableType(varname string) *Vartype {
 				perms |= aclpUseLoadtime
 			}
 		}
-		return &Vartype{lkNone, CheckvarShellCommand, []AclEntry{{"*", perms}}, false}
+		return &Vartype{lkNone, BtShellCommand, []AclEntry{{"*", perms}}, false}
 	}
 
 	if m, toolvarname := match1(varname, `^TOOLS_(.*)`); m && G.globalData.Tools.byVarname[toolvarname] != nil {
-		return &Vartype{lkNone, CheckvarPathname, []AclEntry{{"*", aclpUse}}, false}
+		return &Vartype{lkNone, BtPathname, []AclEntry{{"*", aclpUse}}, false}
 	}
 
 	allowAll := []AclEntry{{"*", aclpAll}}
@@ -1467,35 +1497,35 @@ func (mkline *MkLine) getVariableType(varname string) *Vartype {
 	var gtype *Vartype
 	switch {
 	case hasSuffix(varbase, "DIRS"):
-		gtype = &Vartype{lkShell, CheckvarPathmask, allowRuntime, true}
+		gtype = &Vartype{lkShell, BtPathmask, allowRuntime, true}
 	case hasSuffix(varbase, "DIR") && !hasSuffix(varbase, "DESTDIR"), hasSuffix(varname, "_HOME"):
-		gtype = &Vartype{lkNone, CheckvarPathname, allowRuntime, true}
+		gtype = &Vartype{lkNone, BtPathname, allowRuntime, true}
 	case hasSuffix(varbase, "FILES"):
-		gtype = &Vartype{lkShell, CheckvarPathmask, allowRuntime, true}
+		gtype = &Vartype{lkShell, BtPathmask, allowRuntime, true}
 	case hasSuffix(varbase, "FILE"):
-		gtype = &Vartype{lkNone, CheckvarPathname, allowRuntime, true}
+		gtype = &Vartype{lkNone, BtPathname, allowRuntime, true}
 	case hasSuffix(varbase, "PATH"):
-		gtype = &Vartype{lkNone, CheckvarPathlist, allowRuntime, true}
+		gtype = &Vartype{lkNone, BtPathlist, allowRuntime, true}
 	case hasSuffix(varbase, "PATHS"):
-		gtype = &Vartype{lkShell, CheckvarPathname, allowRuntime, true}
+		gtype = &Vartype{lkShell, BtPathname, allowRuntime, true}
 	case hasSuffix(varbase, "_USER"):
-		gtype = &Vartype{lkNone, CheckvarUserGroupName, allowAll, true}
+		gtype = &Vartype{lkNone, BtUserGroupName, allowAll, true}
 	case hasSuffix(varbase, "_GROUP"):
-		gtype = &Vartype{lkNone, CheckvarUserGroupName, allowAll, true}
+		gtype = &Vartype{lkNone, BtUserGroupName, allowAll, true}
 	case hasSuffix(varbase, "_ENV"):
-		gtype = &Vartype{lkShell, CheckvarShellWord, allowRuntime, true}
+		gtype = &Vartype{lkShell, BtShellWord, allowRuntime, true}
 	case hasSuffix(varbase, "_CMD"):
-		gtype = &Vartype{lkNone, CheckvarShellCommand, allowRuntime, true}
+		gtype = &Vartype{lkNone, BtShellCommand, allowRuntime, true}
 	case hasSuffix(varbase, "_ARGS"):
-		gtype = &Vartype{lkShell, CheckvarShellWord, allowRuntime, true}
+		gtype = &Vartype{lkShell, BtShellWord, allowRuntime, true}
 	case hasSuffix(varbase, "_CFLAGS"), hasSuffix(varname, "_CPPFLAGS"), hasSuffix(varname, "_CXXFLAGS"):
-		gtype = &Vartype{lkShell, CheckvarCFlag, allowRuntime, true}
+		gtype = &Vartype{lkShell, BtCFlag, allowRuntime, true}
 	case hasSuffix(varname, "_LDFLAGS"):
-		gtype = &Vartype{lkShell, CheckvarLdFlag, allowRuntime, true}
+		gtype = &Vartype{lkShell, BtLdFlag, allowRuntime, true}
 	case hasSuffix(varbase, "_MK"):
-		gtype = &Vartype{lkNone, CheckvarUnchecked, allowAll, true}
+		gtype = &Vartype{lkNone, BtUnknown, allowAll, true}
 	case hasPrefix(varbase, "PLIST."):
-		gtype = &Vartype{lkNone, CheckvarYes, allowAll, true}
+		gtype = &Vartype{lkNone, BtYes, allowAll, true}
 	}
 
 	if G.opts.Debug {
diff --git a/pkgtools/pkglint/files/mkline_test.go b/pkgtools/pkglint/files/mkline_test.go
index 5b456e147d9..74f8a48e89e 100644
--- a/pkgtools/pkglint/files/mkline_test.go
+++ b/pkgtools/pkglint/files/mkline_test.go
@@ -16,7 +16,7 @@ func (s *Suite) Test_MkLine_CheckVartype_simple_type(c *check.C) {
 	vartype := mkline.getVariableType("COMMENT")
 
 	c.Assert(vartype, check.NotNil)
-	c.Check(vartype.checker.name, equals, "Comment")
+	c.Check(vartype.basicType.name, equals, "Comment")
 	c.Check(vartype.guessed, equals, false)
 	c.Check(vartype.kindOfList, equals, lkNone)
 
@@ -157,8 +157,8 @@ func (s *Suite) Test_NewMkLine(c *check.C) {
 		"# whole line comment",
 		"",
 		".  if !empty(PKGNAME:M*-*) # cond comment",
-		".include \"../../mk/bsd.prefs.mk\" # include comment",
-		".include <subdir.mk> # sysinclude comment",
+		".    include \"../../mk/bsd.prefs.mk\" # include comment",
+		".    include <subdir.mk> # sysinclude comment",
 		"target1 target2: source1 source2",
 		"target : source",
 		"VARNAME+=value"))
@@ -170,13 +170,12 @@ func (s *Suite) Test_NewMkLine(c *check.C) {
 	c.Check(ln[0].Varparam(), equals, "param")
 	c.Check(ln[0].Op(), equals, opAssignDefault)
 	c.Check(ln[0].Value(), equals, "value")
-	c.Check(ln[0].Comment(), equals, "# varassign comment")
+	c.Check(ln[0].VarassignComment(), equals, "# varassign comment")
 
 	c.Check(ln[1].IsShellcmd(), equals, true)
 	c.Check(ln[1].Shellcmd(), equals, "shell command # shell comment")
 
 	c.Check(ln[2].IsComment(), equals, true)
-	c.Check(ln[2].Comment(), equals, " whole line comment")
 
 	c.Check(ln[3].IsEmpty(), equals, true)
 
@@ -184,22 +183,20 @@ func (s *Suite) Test_NewMkLine(c *check.C) {
 	c.Check(ln[4].Indent(), equals, "  ")
 	c.Check(ln[4].Directive(), equals, "if")
 	c.Check(ln[4].Args(), equals, "!empty(PKGNAME:M*-*)")
-	c.Check(ln[4].Comment(), equals, "") // Not needed
 
 	c.Check(ln[5].IsInclude(), equals, true)
+	c.Check(ln[5].Indent(), equals, "    ")
 	c.Check(ln[5].MustExist(), equals, true)
 	c.Check(ln[5].Includefile(), equals, "../../mk/bsd.prefs.mk")
-	c.Check(ln[5].Comment(), equals, "") // Not needed
 
 	c.Check(ln[6].IsSysinclude(), equals, true)
+	c.Check(ln[6].Indent(), equals, "    ")
 	c.Check(ln[6].MustExist(), equals, true)
 	c.Check(ln[6].Includefile(), equals, "subdir.mk")
-	c.Check(ln[6].Comment(), equals, "") // Not needed
 
 	c.Check(ln[7].IsDependency(), equals, true)
 	c.Check(ln[7].Targets(), equals, "target1 target2")
 	c.Check(ln[7].Sources(), equals, "source1 source2")
-	c.Check(ln[7].Comment(), equals, "") // Not needed
 
 	c.Check(ln[9].IsVarassign(), equals, true)
 	c.Check(ln[9].Varname(), equals, "VARNAME")
@@ -766,7 +763,7 @@ func (s *Suite) Test_MkLine_CheckCond_comparison_with_shell_command(c *check.C)
 	c.Check(s.Output(), equals, "") // Don’t warn about unknown shell command "cc".
 }
 
-func (s *Suite) disabled_Test_MkLine_Pkgmandir(c *check.C) {
+func (s *Suite) Test_MkLine_Pkgmandir(c *check.C) {
 	s.UseCommandLine(c, "-Wall")
 	G.globalData.InitVartypes()
 	G.Mk = s.NewMkLines("chat/ircII/Makefile",
diff --git a/pkgtools/pkglint/files/mklines.go b/pkgtools/pkglint/files/mklines.go
index df2ffbbaf24..2ef80f29ad5 100644
--- a/pkgtools/pkglint/files/mklines.go
+++ b/pkgtools/pkglint/files/mklines.go
@@ -291,7 +291,7 @@ func (va *VaralignBlock) Finish() {
 }
 
 func (va *VaralignBlock) fixalign(mkline *MkLine, prefix, oldalign string) {
-	if mkline.Value() == "" && mkline.Comment() == "" {
+	if mkline.Value() == "" && mkline.VarassignComment() == "" {
 		return
 	}
 
diff --git a/pkgtools/pkglint/files/mkparser.go b/pkgtools/pkglint/files/mkparser.go
index ba7e141ac44..bec7d94f14a 100644
--- a/pkgtools/pkglint/files/mkparser.go
+++ b/pkgtools/pkglint/files/mkparser.go
@@ -314,6 +314,16 @@ func (p *MkParser) mkCondAtom() *Tree {
 					return NewTree("compareVarStr", *lhs, op, repl.m[0])
 				} else if rhs := p.VarUse(); rhs != nil {
 					return NewTree("compareVarVar", *lhs, op, *rhs)
+				} else if repl.PeekByte() == '"' {
+					mark := repl.Mark()
+					if repl.AdvanceStr("\"") {
+						if quotedRHS := p.VarUse(); quotedRHS != nil {
+							if repl.AdvanceStr("\"") {
+								return NewTree("compareVarVar", *lhs, op, *quotedRHS)
+							}
+						}
+					}
+					repl.Reset(mark)
 				}
 			} else {
 				return NewTree("not", NewTree("empty", *lhs)) // See devel/bmake/files/cond.c:/\* For \.if \$/
diff --git a/pkgtools/pkglint/files/mkparser_test.go b/pkgtools/pkglint/files/mkparser_test.go
index 34f6839ec28..fd248fce426 100644
--- a/pkgtools/pkglint/files/mkparser_test.go
+++ b/pkgtools/pkglint/files/mkparser_test.go
@@ -159,6 +159,10 @@ func (s *Suite) Test_MkParser_MkCond(c *check.C) {
 		NewTree("compareVarStr", varuse("VARNAME"), "!=", "Value"))
 	check("\"${VARNAME}\" != Value",
 		NewTree("compareVarStr", varuse("VARNAME"), "!=", "Value"))
+	check("${pkg} == \"${name}\"",
+		NewTree("compareVarVar", varuse("pkg"), "==", varuse("name")))
+	check("\"${pkg}\" == \"${name}\"",
+		NewTree("compareVarVar", varuse("pkg"), "==", varuse("name")))
 	check("(defined(VARNAME))",
 		NewTree("defined", "VARNAME"))
 	check("exists(/etc/hosts)",
diff --git a/pkgtools/pkglint/files/mkshparser_test.go b/pkgtools/pkglint/files/mkshparser_test.go
index 21b7f0bf1c9..f1682b17190 100644
--- a/pkgtools/pkglint/files/mkshparser_test.go
+++ b/pkgtools/pkglint/files/mkshparser_test.go
@@ -19,7 +19,7 @@ func (s *ShSuite) Test_ShellParser_program(c *check.C) {
 		b.List())
 
 	s.test("echo ;",
-		b.List().AddCommand(b.SimpleCommand("echo")).AddSeparator(";"))
+		b.List().AddCommand(b.SimpleCommand("echo")).AddSemicolon())
 
 	s.test("echo",
 		b.List().AddCommand(b.SimpleCommand("echo")))
@@ -37,48 +37,48 @@ func (s *ShSuite) Test_ShellParser_program(c *check.C) {
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false,
 			b.SimpleCommand("${CAT}", "${PKGDIR}/PLIST"),
 			b.While(
-				b.List().AddCommand(b.SimpleCommand("read", "entry")).AddSeparator(";"),
-				b.List().AddCommand(b.SimpleCommand(":")).AddSeparator(";"))))))
+				b.List().AddCommand(b.SimpleCommand("read", "entry")).AddSemicolon(),
+				b.List().AddCommand(b.SimpleCommand(":")).AddSemicolon())))))
 
 	s.test("while read entry ; do case \"$$entry\" in include/c-client/* ) ${INSTALL_DATA} $$src $$dest ; esac ; done",
 		b.List().AddCommand(b.While(
-			b.List().AddCommand(b.SimpleCommand("read", "entry")).AddSeparator(";"),
+			b.List().AddCommand(b.SimpleCommand("read", "entry")).AddSemicolon(),
 			b.List().AddCommand(b.Case(
 				b.Token("\"$$entry\""),
 				b.CaseItem(
 					b.Words("include/c-client/*"),
 					b.List().AddCommand(b.SimpleCommand("${INSTALL_DATA}", "$$src", "$$dest")),
-					&SEP_SEMI))).AddSeparator(";"))))
+					sepSemicolon))).AddSemicolon())))
 
 	s.test("command | while condition ; do case selector in pattern ) : ; esac ; done",
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false,
 			b.SimpleCommand("command"),
 			b.While(
-				b.List().AddCommand(b.SimpleCommand("condition")).AddSeparator(";"),
+				b.List().AddCommand(b.SimpleCommand("condition")).AddSemicolon(),
 				b.List().AddCommand(b.Case(
 					b.Token("selector"),
 					b.CaseItem(
 						b.Words("pattern"),
 						b.List().AddCommand(b.SimpleCommand(":")),
-						&SEP_SEMI))).AddSeparator(";"))))))
+						sepSemicolon))).AddSemicolon())))))
 
 	s.test("command1 \n command2 \n command3",
 		b.List().
 			AddCommand(b.SimpleCommand("command1")).
-			AddSeparator(SEP_NEWLINE).
+			AddNewline().
 			AddCommand(b.SimpleCommand("command2")).
-			AddSeparator(SEP_NEWLINE).
+			AddNewline().
 			AddCommand(b.SimpleCommand("command3")))
 
 	s.test("if condition; then action; else case selector in pattern) case-item-action ;; esac; fi",
 		b.List().AddCommand(b.If(
-			b.List().AddCommand(b.SimpleCommand("condition")).AddSeparator(";"),
-			b.List().AddCommand(b.SimpleCommand("action")).AddSeparator(";"),
+			b.List().AddCommand(b.SimpleCommand("condition")).AddSemicolon(),
+			b.List().AddCommand(b.SimpleCommand("action")).AddSemicolon(),
 			b.List().AddCommand(b.Case(
 				b.Token("selector"),
 				b.CaseItem(
 					b.Words("pattern"),
-					b.List().AddCommand(b.SimpleCommand("case-item-action")), nil))).AddSeparator(";"))))
+					b.List().AddCommand(b.SimpleCommand("case-item-action")), sepNone))).AddSemicolon())))
 }
 
 func (s *ShSuite) Test_ShellParser_list(c *check.C) {
@@ -92,15 +92,15 @@ func (s *ShSuite) Test_ShellParser_list(c *check.C) {
 	s.test("echo1 ; echo2",
 		b.List().
 			AddCommand(b.SimpleCommand("echo1")).
-			AddSeparator(";").
+			AddSemicolon().
 			AddCommand(b.SimpleCommand("echo2")))
 
 	s.test("echo1 ; echo2 &",
 		b.List().
 			AddCommand(b.SimpleCommand("echo1")).
-			AddSeparator(";").
+			AddSemicolon().
 			AddCommand(b.SimpleCommand("echo2")).
-			AddSeparator("&"))
+			AddBackground())
 }
 
 func (s *ShSuite) Test_ShellParser_and_or(c *check.C) {
@@ -153,8 +153,8 @@ func (s *ShSuite) Test_ShellParser_pipe_sequence(c *check.C) {
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false,
 			b.SimpleCommand("command1"),
 			b.If(
-				b.List().AddCommand(b.SimpleCommand("true")).AddSeparator(";"),
-				b.List().AddCommand(b.SimpleCommand(":")).AddSeparator(";"))))))
+				b.List().AddCommand(b.SimpleCommand("true")).AddSemicolon(),
+				b.List().AddCommand(b.SimpleCommand(":")).AddSemicolon())))))
 }
 
 func (s *ShSuite) Test_ShellParser_command(c *check.C) {
@@ -166,20 +166,20 @@ func (s *ShSuite) Test_ShellParser_command(c *check.C) {
 	s.test("while 1; do 2; done",
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false,
 			b.While(
-				b.List().AddCommand(b.SimpleCommand("1")).AddSeparator(";"),
-				b.List().AddCommand(b.SimpleCommand("2")).AddSeparator(";"))))))
+				b.List().AddCommand(b.SimpleCommand("1")).AddSemicolon(),
+				b.List().AddCommand(b.SimpleCommand("2")).AddSemicolon())))))
 
 	s.test("while 1; do 2; done 1>&2",
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false,
 			b.While(
-				b.List().AddCommand(b.SimpleCommand("1")).AddSeparator(";"),
-				b.List().AddCommand(b.SimpleCommand("2")).AddSeparator(";"),
+				b.List().AddCommand(b.SimpleCommand("1")).AddSemicolon(),
+				b.List().AddCommand(b.SimpleCommand("2")).AddSemicolon(),
 				b.Redirection(1, ">&", "2"))))))
 
 	s.test("func(){ echo hello;} 2>&1",
 		b.List().AddCommand(b.Function(
 			"func",
-			b.Brace(b.List().AddCommand(b.SimpleCommand("echo", "hello")).AddSeparator(";")).Compound,
+			b.Brace(b.List().AddCommand(b.SimpleCommand("echo", "hello")).AddSemicolon()).Compound,
 			b.Redirection(2, ">&", "1"))))
 }
 
@@ -188,7 +188,7 @@ func (s *ShSuite) Test_ShellParser_compound_command(c *check.C) {
 
 	s.test("{ brace ; }",
 		b.List().AddCommand(b.Brace(
-			b.List().AddCommand(b.SimpleCommand("brace")).AddSeparator(";"))))
+			b.List().AddCommand(b.SimpleCommand("brace")).AddSemicolon())))
 
 	s.test("( subshell )",
 		b.List().AddCommand(b.Subshell(
@@ -198,7 +198,7 @@ func (s *ShSuite) Test_ShellParser_compound_command(c *check.C) {
 		b.List().AddCommand(b.For(
 			"i",
 			b.Words("*"),
-			b.List().AddCommand(b.SimpleCommand("echo", "$i")).AddSeparator(";"))))
+			b.List().AddCommand(b.SimpleCommand("echo", "$i")).AddSemicolon())))
 
 	s.test("case $i in esac",
 		b.List().AddCommand(b.Case(
@@ -210,8 +210,8 @@ func (s *ShSuite) Test_ShellParser_subshell(c *check.C) {
 	b := s.init(c)
 
 	sub3 := b.Subshell(b.List().AddCommand(b.SimpleCommand("sub3")))
-	sub2 := b.Subshell(b.List().AddCommand(sub3).AddSeparator(";").AddCommand(b.SimpleCommand("sub2")))
-	sub1 := b.Subshell(b.List().AddCommand(sub2).AddSeparator(";").AddCommand(b.SimpleCommand("sub1")))
+	sub2 := b.Subshell(b.List().AddCommand(sub3).AddSemicolon().AddCommand(b.SimpleCommand("sub2")))
+	sub1 := b.Subshell(b.List().AddCommand(sub2).AddSemicolon().AddCommand(b.SimpleCommand("sub1")))
 	s.test("( ( ( sub3 ) ; sub2 ) ; sub1 )", b.List().AddCommand(sub1))
 }
 
@@ -236,32 +236,32 @@ func (s *ShSuite) Test_ShellParser_for_clause(c *check.C) {
 		b.List().AddCommand(b.For(
 			"var",
 			b.Words("\"$$@\""),
-			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSeparator(";"))))
+			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSemicolon())))
 
 	// Only linebreak is allowed, but not semicolon.
 	s.test("for var \n do echo $var ; done",
 		b.List().AddCommand(b.For(
 			"var",
 			b.Words("\"$$@\""),
-			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSeparator(";"))))
+			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSemicolon())))
 
 	s.test("for var in a b c ; do echo $var ; done",
 		b.List().AddCommand(b.For(
 			"var",
 			b.Words("a", "b", "c"),
-			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSeparator(";"))))
+			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSemicolon())))
 
 	s.test("for var \n \n \n in a b c ; do echo $var ; done",
 		b.List().AddCommand(b.For(
 			"var",
 			b.Words("a", "b", "c"),
-			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSeparator(";"))))
+			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSemicolon())))
 
 	s.test("for var in in esac ; do echo $var ; done",
 		b.List().AddCommand(b.For(
 			"var",
 			b.Words("in", "esac"),
-			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSeparator(";"))))
+			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSemicolon())))
 
 	// No semicolon necessary between the two “done”.
 	s.test("for i in 1; do for j in 1; do echo $$i$$j; done done",
@@ -271,7 +271,7 @@ func (s *ShSuite) Test_ShellParser_for_clause(c *check.C) {
 			b.List().AddCommand(b.For(
 				"j",
 				b.Words("1"),
-				b.List().AddCommand(b.SimpleCommand("echo", "$$i$$j")).AddSeparator(";"))))))
+				b.List().AddCommand(b.SimpleCommand("echo", "$$i$$j")).AddSemicolon())))))
 }
 
 func (s *ShSuite) Test_ShellParser_case_clause(c *check.C) {
@@ -283,33 +283,33 @@ func (s *ShSuite) Test_ShellParser_case_clause(c *check.C) {
 	s.test("case selector in pattern) ;; pattern) esac",
 		b.List().AddCommand(b.Case(
 			b.Token("selector"),
-			b.CaseItem(b.Words("pattern"), b.List(), nil),
-			b.CaseItem(b.Words("pattern"), b.List(), nil))))
+			b.CaseItem(b.Words("pattern"), b.List(), sepNone),
+			b.CaseItem(b.Words("pattern"), b.List(), sepNone))))
 
 	s.test("case $$i in *.c | *.h ) echo C ;; * ) echo Other ; esac",
 		b.List().AddCommand(b.Case(
 			b.Token("$$i"),
-			b.CaseItem(b.Words("*.c", "*.h"), b.List().AddCommand(b.SimpleCommand("echo", "C")), nil),
-			b.CaseItem(b.Words("*"), b.List().AddCommand(b.SimpleCommand("echo", "Other")), &SEP_SEMI))))
+			b.CaseItem(b.Words("*.c", "*.h"), b.List().AddCommand(b.SimpleCommand("echo", "C")), sepNone),
+			b.CaseItem(b.Words("*"), b.List().AddCommand(b.SimpleCommand("echo", "Other")), sepSemicolon))))
 
 	s.test("case $$i in *.c ) echo ; esac",
 		b.List().AddCommand(b.Case(
 			b.Token("$$i"),
-			b.CaseItem(b.Words("*.c"), b.List().AddCommand(b.SimpleCommand("echo")), &SEP_SEMI))))
+			b.CaseItem(b.Words("*.c"), b.List().AddCommand(b.SimpleCommand("echo")), sepSemicolon))))
 
 	s.test("case selector in pattern) case-item-action ; esac",
 		b.List().AddCommand(b.Case(
 			b.Token("selector"),
 			b.CaseItem(
 				b.Words("pattern"),
-				b.List().AddCommand(b.SimpleCommand("case-item-action")), &SEP_SEMI))))
+				b.List().AddCommand(b.SimpleCommand("case-item-action")), sepSemicolon))))
 
 	s.test("case selector in pattern) case-item-action ;; esac",
 		b.List().AddCommand(b.Case(
 			b.Token("selector"),
 			b.CaseItem(
 				b.Words("pattern"),
-				b.List().AddCommand(b.SimpleCommand("case-item-action")), nil))))
+				b.List().AddCommand(b.SimpleCommand("case-item-action")), sepNone))))
 
 }
 
@@ -319,17 +319,17 @@ func (s *ShSuite) Test_ShellParser_if_clause(c *check.C) {
 	s.test(
 		"if true ; then echo yes ; else echo no ; fi",
 		b.List().AddCommand(b.If(
-			b.List().AddCommand(b.SimpleCommand("true")).AddSeparator(";"),
-			b.List().AddCommand(b.SimpleCommand("echo", "yes")).AddSeparator(";"),
-			b.List().AddCommand(b.SimpleCommand("echo", "no")).AddSeparator(";"))))
+			b.List().AddCommand(b.SimpleCommand("true")).AddSemicolon(),
+			b.List().AddCommand(b.SimpleCommand("echo", "yes")).AddSemicolon(),
+			b.List().AddCommand(b.SimpleCommand("echo", "no")).AddSemicolon())))
 
 	// No semicolon necessary between the two “fi”.
 	s.test("if cond1; then if cond2; then action; fi fi",
 		b.List().AddCommand(b.If(
-			b.List().AddCommand(b.SimpleCommand("cond1")).AddSeparator(";"),
+			b.List().AddCommand(b.SimpleCommand("cond1")).AddSemicolon(),
 			b.List().AddCommand(b.If(
-				b.List().AddCommand(b.SimpleCommand("cond2")).AddSeparator(";"),
-				b.List().AddCommand(b.SimpleCommand("action")).AddSeparator(";"))))))
+				b.List().AddCommand(b.SimpleCommand("cond2")).AddSemicolon(),
+				b.List().AddCommand(b.SimpleCommand("action")).AddSemicolon())))))
 }
 
 func (s *ShSuite) Test_ShellParser_while_clause(c *check.C) {
@@ -337,8 +337,8 @@ func (s *ShSuite) Test_ShellParser_while_clause(c *check.C) {
 
 	s.test("while condition ; do action ; done",
 		b.List().AddCommand(b.While(
-			b.List().AddCommand(b.SimpleCommand("condition")).AddSeparator(";"),
-			b.List().AddCommand(b.SimpleCommand("action")).AddSeparator(";"))))
+			b.List().AddCommand(b.SimpleCommand("condition")).AddSemicolon(),
+			b.List().AddCommand(b.SimpleCommand("action")).AddSemicolon())))
 }
 
 func (s *ShSuite) Test_ShellParser_until_clause(c *check.C) {
@@ -346,8 +346,8 @@ func (s *ShSuite) Test_ShellParser_until_clause(c *check.C) {
 
 	s.test("until condition ; do action ; done",
 		b.List().AddCommand(b.Until(
-			b.List().AddCommand(b.SimpleCommand("condition")).AddSeparator(";"),
-			b.List().AddCommand(b.SimpleCommand("action")).AddSeparator(";"))))
+			b.List().AddCommand(b.SimpleCommand("condition")).AddSemicolon(),
+			b.List().AddCommand(b.SimpleCommand("action")).AddSemicolon())))
 }
 
 func (s *ShSuite) Test_ShellParser_function_definition(c *check.C) {
@@ -362,9 +362,9 @@ func (s *ShSuite) Test_ShellParser_brace_group(c *check.C) {
 	// No semicolon necessary after the closing brace.
 	s.test("if true; then { echo yes; } fi",
 		b.List().AddCommand(b.If(
-			b.List().AddCommand(b.SimpleCommand("true")).AddSeparator(";"),
+			b.List().AddCommand(b.SimpleCommand("true")).AddSemicolon(),
 			b.List().AddCommand(b.Brace(
-				b.List().AddCommand(b.SimpleCommand("echo", "yes")).AddSeparator(";"))))))
+				b.List().AddCommand(b.SimpleCommand("echo", "yes")).AddSemicolon())))))
 }
 
 func (s *ShSuite) Test_ShellParser_simple_command(c *check.C) {
@@ -477,10 +477,10 @@ func (s *ShSuite) test(program string, expected *MkShList) {
 
 	if ok1, ok2 := c.Check(succeeded, equals, 0), c.Check(lexer.error, equals, ""); ok1 && ok2 {
 		if !c.Check(lexer.result, deepEquals, expected) {
-			actualJson, actualErr := json.MarshalIndent(lexer.result, "", "  ")
-			expectedJson, expectedErr := json.MarshalIndent(expected, "", "  ")
+			actualJSON, actualErr := json.MarshalIndent(lexer.result, "", "  ")
+			expectedJSON, expectedErr := json.MarshalIndent(expected, "", "  ")
 			if c.Check(actualErr, check.IsNil) && c.Check(expectedErr, check.IsNil) {
-				c.Check(string(actualJson), deepEquals, string(expectedJson))
+				c.Check(string(actualJSON), deepEquals, string(expectedJSON))
 			}
 		}
 	} else {
@@ -584,7 +584,7 @@ func (b *MkShBuilder) Case(selector *ShToken, items ...*MkShCaseItem) *MkShComma
 	return &MkShCommand{Compound: &MkShCompoundCommand{Case: &MkShCaseClause{selector, items}}}
 }
 
-func (b *MkShBuilder) CaseItem(patterns []*ShToken, action *MkShList, separator *MkShSeparator) *MkShCaseItem {
+func (b *MkShBuilder) CaseItem(patterns []*ShToken, action *MkShList, separator MkShSeparator) *MkShCaseItem {
 	return &MkShCaseItem{patterns, action, separator}
 }
 
diff --git a/pkgtools/pkglint/files/mkshtypes.go b/pkgtools/pkglint/files/mkshtypes.go
index 5349ddeb9fb..5bee1c276c9 100644
--- a/pkgtools/pkglint/files/mkshtypes.go
+++ b/pkgtools/pkglint/files/mkshtypes.go
@@ -80,7 +80,7 @@ type MkShCaseClause struct {
 type MkShCaseItem struct {
 	Patterns  []*ShToken
 	Action    *MkShList
-	Separator *MkShSeparator
+	Separator MkShSeparator
 }
 
 type MkShIfClause struct {
@@ -163,11 +163,11 @@ type MkShRedirection struct {
 	Target *ShToken
 }
 
-// One of ";", "&", "\n"
-type MkShSeparator string
+type MkShSeparator uint8
 
-var (
-	SEP_SEMI       MkShSeparator = ";"
-	SEP_BACKGROUND MkShSeparator = "&"
-	SEP_NEWLINE    MkShSeparator = "\n"
+const (
+	sepNone       MkShSeparator = iota
+	sepSemicolon                // ;
+	sepBackground               // &
+	sepNewline                  // \n
 )
diff --git a/pkgtools/pkglint/files/mkshtypes_test.go b/pkgtools/pkglint/files/mkshtypes_test.go
new file mode 100644
index 00000000000..a6735039cff
--- /dev/null
+++ b/pkgtools/pkglint/files/mkshtypes_test.go
@@ -0,0 +1,5 @@
+package main
+
+func (list *MkShList) AddSemicolon() *MkShList  { return list.AddSeparator(sepSemicolon) }
+func (list *MkShList) AddBackground() *MkShList { return list.AddSeparator(sepBackground) }
+func (list *MkShList) AddNewline() *MkShList    { return list.AddSeparator(sepNewline) }
diff --git a/pkgtools/pkglint/files/mktypes.go b/pkgtools/pkglint/files/mktypes.go
index f322bfa8e95..5067ab64c80 100644
--- a/pkgtools/pkglint/files/mktypes.go
+++ b/pkgtools/pkglint/files/mktypes.go
@@ -9,10 +9,6 @@ type MkVarUse struct {
 	modifiers []string // E.g. "Q", "S/from/to/"
 }
 
-func NewMkVarUse(varname string, modifiers ...string) *MkVarUse {
-	return &MkVarUse{varname, modifiers}
-}
-
 func (vu *MkVarUse) Mod() string {
 	mod := ""
 	for _, modifier := range vu.modifiers {
diff --git a/pkgtools/pkglint/files/mktypes_test.go b/pkgtools/pkglint/files/mktypes_test.go
index cbeda6cc368..a23fb991a36 100644
--- a/pkgtools/pkglint/files/mktypes_test.go
+++ b/pkgtools/pkglint/files/mktypes_test.go
@@ -4,6 +4,10 @@ import (
 	check "gopkg.in/check.v1"
 )
 
+func NewMkVarUse(varname string, modifiers ...string) *MkVarUse {
+	return &MkVarUse{varname, modifiers}
+}
+
 func (s *Suite) Test_MkVarUse_Mod(c *check.C) {
 	varuse := &MkVarUse{"varname", []string{"Q"}}
 
diff --git a/pkgtools/pkglint/files/package.go b/pkgtools/pkglint/files/package.go
index 3f9204be4dd..abfb475bdbf 100644
--- a/pkgtools/pkglint/files/package.go
+++ b/pkgtools/pkglint/files/package.go
@@ -394,7 +394,7 @@ func (pkg *Package) checkfilePackageMakefile(fname string, mklines *MkLines) {
 	}
 
 	if gnuLine, useLine := vardef["GNU_CONFIGURE"], vardef["USE_LANGUAGES"]; gnuLine != nil && useLine != nil {
-		if matches(useLine.Comment(), `(?-i)\b(?:c|empty|none)\b`) {
+		if matches(useLine.VarassignComment(), `(?-i)\b(?:c|empty|none)\b`) {
 			// Don't emit a warning, since the comment
 			// probably contains a statement that C is
 			// really not needed.
@@ -453,7 +453,7 @@ func (pkg *Package) determineEffectivePkgVars() {
 		pkgname = pkg.pkgnameFromDistname(pkgname, distname)
 	}
 
-	if pkgname != "" && pkgname == distname && pkgnameLine.Comment() == "" {
+	if pkgname != "" && pkgname == distname && pkgnameLine.VarassignComment() == "" {
 		pkgnameLine.Note0("PKGNAME is ${DISTNAME} by default. You probably don't need to define PKGNAME.")
 	}
 
diff --git a/pkgtools/pkglint/files/pkglint.go b/pkgtools/pkglint/files/pkglint.go
index 4a1d643fe6e..ab8c391624d 100644
--- a/pkgtools/pkglint/files/pkglint.go
+++ b/pkgtools/pkglint/files/pkglint.go
@@ -7,7 +7,7 @@ import (
 )
 
 const (
-	reMkInclude = `^\.\s*(s?include)\s+\"([^\"]+)\"\s*(?:#.*)?$`
+	reMkInclude = `^\.(\s*)(s?include)\s+\"([^\"]+)\"\s*(?:#.*)?$`
 	rePkgname   = `^([\w\-.+]+)-(\d(?:\w|\.\d)*)$`
 )
 
diff --git a/pkgtools/pkglint/files/shell.go b/pkgtools/pkglint/files/shell.go
index 00b9faf8c64..0ed87fc1598 100644
--- a/pkgtools/pkglint/files/shell.go
+++ b/pkgtools/pkglint/files/shell.go
@@ -8,7 +8,6 @@ import (
 )
 
 const (
-	reShVarassign    = `^([A-Z_a-z]\w*)=`
 	reShVarname      = `(?:[!#*\-\d?@]|\$\$|[A-Za-z_]\w*)`
 	reShVarexpansion = `(?:(?:#|##|%|%%|:-|:=|:\?|:\+|\+)[^$\\{}]*)`
 	reShVaruse       = `\$\$` + `(?:` + reShVarname + `|` + `\{` + reShVarname + `(?:` + reShVarexpansion + `)?` + `\})`
@@ -24,7 +23,7 @@ func NewShellLine(mkline *MkLine) *ShellLine {
 	return &ShellLine{mkline.Line, mkline}
 }
 
-var shellcommandsContextType = &Vartype{lkNone, CheckvarShellCommands, []AclEntry{{"*", aclpAllRuntime}}, false}
+var shellcommandsContextType = &Vartype{lkNone, BtShellCommands, []AclEntry{{"*", aclpAllRuntime}}, false}
 var shellwordVuc = &VarUseContext{shellcommandsContextType, vucTimeUnknown, vucQuotPlain, false}
 
 func (shline *ShellLine) CheckWord(token string, checkQuoting bool) {
@@ -430,37 +429,37 @@ func NewSimpleCommandChecker(shline *ShellLine, cmd *MkShSimpleCommand) *SimpleC
 
 }
 
-func (c *SimpleCommandChecker) Check() {
+func (scc *SimpleCommandChecker) Check() {
 	if G.opts.Debug {
-		defer tracecall(c.strcmd)()
+		defer tracecall(scc.strcmd)()
 	}
 
-	c.checkCommandStart()
-	c.checkAbsolutePathnames()
-	c.checkAutoMkdirs()
-	c.checkInstallMulti()
-	c.checkPaxPe()
-	c.checkEchoN()
+	scc.checkCommandStart()
+	scc.checkAbsolutePathnames()
+	scc.checkAutoMkdirs()
+	scc.checkInstallMulti()
+	scc.checkPaxPe()
+	scc.checkEchoN()
 }
 
-func (ctx *SimpleCommandChecker) checkCommandStart() {
+func (scc *SimpleCommandChecker) checkCommandStart() {
 	if G.opts.Debug {
 		defer tracecall()()
 	}
 
-	shellword := ctx.strcmd.Name
+	shellword := scc.strcmd.Name
 	switch {
 	case shellword == "${RUN}" || shellword == "":
-	case ctx.handleForbiddenCommand():
-	case ctx.handleTool():
-	case ctx.handleCommandVariable():
+	case scc.handleForbiddenCommand():
+	case scc.handleTool():
+	case scc.handleCommandVariable():
 	case matches(shellword, `^(?::|break|cd|continue|eval|exec|exit|export|read|set|shift|umask|unset)$`):
 	case hasPrefix(shellword, "./"): // All commands from the current directory are fine.
 	case hasPrefix(shellword, "${PKGSRCDIR"): // With or without the :Q modifier
-	case ctx.handleComment():
+	case scc.handleComment():
 	default:
 		if G.opts.WarnExtra && !(G.Mk != nil && G.Mk.indentation.DependsOn("OPSYS")) {
-			ctx.shline.line.Warn1("Unknown shell command %q.", shellword)
+			scc.shline.line.Warn1("Unknown shell command %q.", shellword)
 			Explain3(
 				"If you want your package to be portable to all platforms that pkgsrc",
 				"supports, you should only use shell commands that are covered by the",
@@ -469,38 +468,38 @@ func (ctx *SimpleCommandChecker) checkCommandStart() {
 	}
 }
 
-func (ctx *SimpleCommandChecker) handleTool() bool {
+func (scc *SimpleCommandChecker) handleTool() bool {
 	if G.opts.Debug {
 		defer tracecall()()
 	}
 
-	shellword := ctx.strcmd.Name
+	shellword := scc.strcmd.Name
 	tool := G.globalData.Tools.byName[shellword]
 	if tool == nil {
 		return false
 	}
 
 	if !G.Mk.tools[shellword] && !G.Mk.tools["g"+shellword] {
-		ctx.shline.line.Warn1("The %q tool is used but not added to USE_TOOLS.", shellword)
+		scc.shline.line.Warn1("The %q tool is used but not added to USE_TOOLS.", shellword)
 	}
 
 	if tool.MustUseVarForm {
-		ctx.shline.line.Warn2("Please use \"${%s}\" instead of %q.", tool.Varname, shellword)
+		scc.shline.line.Warn2("Please use \"${%s}\" instead of %q.", tool.Varname, shellword)
 	}
 
-	ctx.shline.checkCommandUse(shellword)
+	scc.shline.checkCommandUse(shellword)
 	return true
 }
 
-func (ctx *SimpleCommandChecker) handleForbiddenCommand() bool {
+func (scc *SimpleCommandChecker) handleForbiddenCommand() bool {
 	if G.opts.Debug {
 		defer tracecall()()
 	}
 
-	shellword := ctx.strcmd.Name
+	shellword := scc.strcmd.Name
 	switch path.Base(shellword) {
 	case "ktrace", "mktexlsr", "strace", "texconfig", "truss":
-		ctx.shline.line.Error1("%q must not be used in Makefiles.", shellword)
+		scc.shline.line.Error1("%q must not be used in Makefiles.", shellword)
 		Explain3(
 			"This command must appear in INSTALL scripts, not in the package",
 			"Makefile, so that the package also works if it is installed as a binary",
@@ -510,24 +509,24 @@ func (ctx *SimpleCommandChecker) handleForbiddenCommand() bool {
 	return false
 }
 
-func (ctx *SimpleCommandChecker) handleCommandVariable() bool {
+func (scc *SimpleCommandChecker) handleCommandVariable() bool {
 	if G.opts.Debug {
 		defer tracecall()()
 	}
 
-	shellword := ctx.strcmd.Name
+	shellword := scc.strcmd.Name
 	if m, varname := match1(shellword, `^\$\{([\w_]+)\}$`); m {
 
 		if tool := G.globalData.Tools.byVarname[varname]; tool != nil {
 			if !G.Mk.tools[tool.Name] {
-				ctx.shline.line.Warn1("The %q tool is used but not added to USE_TOOLS.", tool.Name)
+				scc.shline.line.Warn1("The %q tool is used but not added to USE_TOOLS.", tool.Name)
 			}
-			ctx.shline.checkCommandUse(shellword)
+			scc.shline.checkCommandUse(shellword)
 			return true
 		}
 
-		if vartype := ctx.shline.mkline.getVariableType(varname); vartype != nil && vartype.checker.name == "ShellCommand" {
-			ctx.shline.checkCommandUse(shellword)
+		if vartype := scc.shline.mkline.getVariableType(varname); vartype != nil && vartype.basicType.name == "ShellCommand" {
+			scc.shline.checkCommandUse(shellword)
 			return true
 		}
 
@@ -540,12 +539,12 @@ func (ctx *SimpleCommandChecker) handleCommandVariable() bool {
 	return false
 }
 
-func (ctx *SimpleCommandChecker) handleComment() bool {
+func (scc *SimpleCommandChecker) handleComment() bool {
 	if G.opts.Debug {
 		defer tracecall()()
 	}
 
-	shellword := ctx.strcmd.Name
+	shellword := scc.strcmd.Name
 	if G.opts.Debug {
 		defer tracecall1(shellword)()
 	}
@@ -555,13 +554,13 @@ func (ctx *SimpleCommandChecker) handleComment() bool {
 	}
 
 	semicolon := contains(shellword, ";")
-	multiline := ctx.shline.line.IsMultiline()
+	multiline := scc.shline.line.IsMultiline()
 
 	if semicolon {
-		ctx.shline.line.Warn0("A shell comment should not contain semicolons.")
+		scc.shline.line.Warn0("A shell comment should not contain semicolons.")
 	}
 	if multiline {
-		ctx.shline.line.Warn0("A shell comment does not stop at the end of line.")
+		scc.shline.line.Warn0("A shell comment does not stop at the end of line.")
 	}
 
 	if semicolon || multiline {
@@ -582,83 +581,19 @@ func (ctx *SimpleCommandChecker) handleComment() bool {
 	return true
 }
 
-type ShellProgramChecker struct {
-	shline *ShellLine
-}
-
-func (c *ShellProgramChecker) checkConditionalCd(list *MkShList) {
-	if G.opts.Debug {
-		defer tracecall()()
-	}
-
-	getSimple := func(list *MkShList) *MkShSimpleCommand {
-		if len(list.AndOrs) == 1 {
-			if len(list.AndOrs[0].Pipes) == 1 {
-				if len(list.AndOrs[0].Pipes[0].Cmds) == 1 {
-					return list.AndOrs[0].Pipes[0].Cmds[0].Simple
-				}
-			}
-		}
-		return nil
-	}
-
-	checkConditionalCd := func(cmd *MkShSimpleCommand) {
-		if NewStrCommand(cmd).Name == "cd" {
-			c.shline.line.Error0("The Solaris /bin/sh cannot handle \"cd\" inside conditionals.")
-			Explain3(
-				"When the Solaris shell is in \"set -e\" mode and \"cd\" fails, the",
-				"shell will exit, no matter if it is protected by an \"if\" or the",
-				"\"||\" operator.")
-		}
-	}
-
-	(*MkShWalker).Walk(nil, list, func(node interface{}) {
-		if cmd, ok := node.(*MkShIfClause); ok {
-			for _, cond := range cmd.Conds {
-				if simple := getSimple(cond); simple != nil {
-					checkConditionalCd(simple)
-				}
-			}
-		}
-		if cmd, ok := node.(*MkShLoopClause); ok {
-			if simple := getSimple(cmd.Cond); simple != nil {
-				checkConditionalCd(simple)
-			}
-		}
-	})
-}
-
-func (c *ShellProgramChecker) checkWords(words []*ShToken, checkQuoting bool) {
-	if G.opts.Debug {
-		defer tracecall()()
-	}
-
-	for _, word := range words {
-		c.checkWord(word, checkQuoting)
-	}
-}
-
-func (c *ShellProgramChecker) checkWord(word *ShToken, checkQuoting bool) {
-	if G.opts.Debug {
-		defer tracecall(word.MkText)()
-	}
-
-	c.shline.CheckWord(word.MkText, checkQuoting)
-}
-
-func (c *SimpleCommandChecker) checkAbsolutePathnames() {
+func (scc *SimpleCommandChecker) checkAbsolutePathnames() {
 	if G.opts.Debug {
 		defer tracecall()()
 	}
 
-	cmdname := c.strcmd.Name
+	cmdname := scc.strcmd.Name
 	isSubst := false
-	for _, arg := range c.strcmd.Args {
+	for _, arg := range scc.strcmd.Args {
 		if !isSubst {
-			c.shline.line.CheckAbsolutePathname(arg)
+			scc.shline.line.CheckAbsolutePathname(arg)
 		}
 		if false && isSubst && !matches(arg, `"^[\"\'].*[\"\']$`) {
-			c.shline.line.Warn1("Substitution commands like %q should always be quoted.", arg)
+			scc.shline.line.Warn1("Substitution commands like %q should always be quoted.", arg)
 			Explain3(
 				"Usually these substitution commands contain characters like '*' or",
 				"other shell metacharacters that might lead to lookup of matching",
@@ -668,16 +603,16 @@ func (c *SimpleCommandChecker) checkAbsolutePathnames() {
 	}
 }
 
-func (ctx *SimpleCommandChecker) checkAutoMkdirs() {
+func (scc *SimpleCommandChecker) checkAutoMkdirs() {
 	if G.opts.Debug {
 		defer tracecall()()
 	}
 
-	cmdname := ctx.strcmd.Name
+	cmdname := scc.strcmd.Name
 	switch {
 	case cmdname == "${MKDIR}":
 		break
-	case cmdname == "${INSTALL}" && ctx.strcmd.HasOption("-d"):
+	case cmdname == "${INSTALL}" && scc.strcmd.HasOption("-d"):
 		cmdname = "${INSTALL} -d"
 	case matches(cmdname, `^\$\{INSTALL_.*_DIR\}$`):
 		break
@@ -685,10 +620,10 @@ func (ctx *SimpleCommandChecker) checkAutoMkdirs() {
 		return
 	}
 
-	for _, arg := range ctx.strcmd.Args {
+	for _, arg := range scc.strcmd.Args {
 		if !contains(arg, "$$") && !matches(arg, `\$\{[_.]*[a-z]`) {
 			if m, dirname := match1(arg, `^(?:\$\{DESTDIR\})?\$\{PREFIX(?:|:Q)\}/(.*)`); m {
-				ctx.shline.line.Note2("You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= %s\" instead of %q.", dirname, cmdname)
+				scc.shline.line.Note2("You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= %s\" instead of %q.", dirname, cmdname)
 				Explain(
 					"Many packages include a list of all needed directories in their",
 					"PLIST file.  In such a case, you can just set AUTO_MKDIRS=yes and",
@@ -705,12 +640,12 @@ func (ctx *SimpleCommandChecker) checkAutoMkdirs() {
 	}
 }
 
-func (ctx *SimpleCommandChecker) checkInstallMulti() {
+func (scc *SimpleCommandChecker) checkInstallMulti() {
 	if G.opts.Debug {
 		defer tracecall()()
 	}
 
-	cmd := ctx.strcmd
+	cmd := scc.strcmd
 
 	if hasPrefix(cmd.Name, "${INSTALL_") && hasSuffix(cmd.Name, "_DIR}") {
 		prevdir := ""
@@ -722,7 +657,7 @@ func (ctx *SimpleCommandChecker) checkInstallMulti() {
 				break
 			default:
 				if prevdir != "" {
-					ctx.shline.line.Warn0("The INSTALL_*_DIR commands can only handle one directory at a time.")
+					scc.shline.line.Warn0("The INSTALL_*_DIR commands can only handle one directory at a time.")
 					Explain2(
 						"Many implementations of install(1) can handle more, but pkgsrc aims",
 						"at maximum portability.")
@@ -734,13 +669,13 @@ func (ctx *SimpleCommandChecker) checkInstallMulti() {
 	}
 }
 
-func (ctx *SimpleCommandChecker) checkPaxPe() {
+func (scc *SimpleCommandChecker) checkPaxPe() {
 	if G.opts.Debug {
 		defer tracecall()()
 	}
 
-	if ctx.strcmd.Name == "${PAX}" && ctx.strcmd.HasOption("-pe") {
-		ctx.shline.line.Warn0("Please use the -pp option to pax(1) instead of -pe.")
+	if scc.strcmd.Name == "${PAX}" && scc.strcmd.HasOption("-pe") {
+		scc.shline.line.Warn0("Please use the -pp option to pax(1) instead of -pe.")
 		Explain3(
 			"The -pe option tells pax to preserve the ownership of the files, which",
 			"means that the installed files will belong to the user that has built",
@@ -748,17 +683,81 @@ func (ctx *SimpleCommandChecker) checkPaxPe() {
 	}
 }
 
-func (ctx *SimpleCommandChecker) checkEchoN() {
+func (scc *SimpleCommandChecker) checkEchoN() {
+	if G.opts.Debug {
+		defer tracecall()()
+	}
+
+	if scc.strcmd.Name == "${ECHO}" && scc.strcmd.HasOption("-n") {
+		scc.shline.line.Warn0("Please use ${ECHO_N} instead of \"echo -n\".")
+	}
+}
+
+type ShellProgramChecker struct {
+	shline *ShellLine
+}
+
+func (spc *ShellProgramChecker) checkConditionalCd(list *MkShList) {
+	if G.opts.Debug {
+		defer tracecall()()
+	}
+
+	getSimple := func(list *MkShList) *MkShSimpleCommand {
+		if len(list.AndOrs) == 1 {
+			if len(list.AndOrs[0].Pipes) == 1 {
+				if len(list.AndOrs[0].Pipes[0].Cmds) == 1 {
+					return list.AndOrs[0].Pipes[0].Cmds[0].Simple
+				}
+			}
+		}
+		return nil
+	}
+
+	checkConditionalCd := func(cmd *MkShSimpleCommand) {
+		if NewStrCommand(cmd).Name == "cd" {
+			spc.shline.line.Error0("The Solaris /bin/sh cannot handle \"cd\" inside conditionals.")
+			Explain3(
+				"When the Solaris shell is in \"set -e\" mode and \"cd\" fails, the",
+				"shell will exit, no matter if it is protected by an \"if\" or the",
+				"\"||\" operator.")
+		}
+	}
+
+	(*MkShWalker).Walk(nil, list, func(node interface{}) {
+		if cmd, ok := node.(*MkShIfClause); ok {
+			for _, cond := range cmd.Conds {
+				if simple := getSimple(cond); simple != nil {
+					checkConditionalCd(simple)
+				}
+			}
+		}
+		if cmd, ok := node.(*MkShLoopClause); ok {
+			if simple := getSimple(cmd.Cond); simple != nil {
+				checkConditionalCd(simple)
+			}
+		}
+	})
+}
+
+func (spc *ShellProgramChecker) checkWords(words []*ShToken, checkQuoting bool) {
 	if G.opts.Debug {
 		defer tracecall()()
 	}
 
-	if ctx.strcmd.Name == "${ECHO}" && ctx.strcmd.HasOption("-n") {
-		ctx.shline.line.Warn0("Please use ${ECHO_N} instead of \"echo -n\".")
+	for _, word := range words {
+		spc.checkWord(word, checkQuoting)
 	}
 }
 
-func (ctx *ShellProgramChecker) checkPipeExitcode(line *Line, pipeline *MkShPipeline) {
+func (spc *ShellProgramChecker) checkWord(word *ShToken, checkQuoting bool) {
+	if G.opts.Debug {
+		defer tracecall(word.MkText)()
+	}
+
+	spc.shline.CheckWord(word.MkText, checkQuoting)
+}
+
+func (scc *ShellProgramChecker) checkPipeExitcode(line *Line, pipeline *MkShPipeline) {
 	if G.opts.Debug {
 		defer tracecall()()
 	}
@@ -774,7 +773,7 @@ func (ctx *ShellProgramChecker) checkPipeExitcode(line *Line, pipeline *MkShPipe
 	}
 }
 
-func (ctx *ShellProgramChecker) checkSetE(list *MkShList, eflag *bool) {
+func (scc *ShellProgramChecker) checkSetE(list *MkShList, eflag *bool) {
 	if G.opts.Debug {
 		defer tracecall()()
 	}
@@ -782,7 +781,7 @@ func (ctx *ShellProgramChecker) checkSetE(list *MkShList, eflag *bool) {
 	// Disabled until the shell parser can recognize "command || exit 1" reliably.
 	if false && G.opts.WarnExtra && !*eflag && "the current token" == ";" {
 		*eflag = true
-		ctx.shline.line.Warn1("Please switch to \"set -e\" mode before using a semicolon (the one after %q) to separate commands.", "previous token")
+		scc.shline.line.Warn1("Please switch to \"set -e\" mode before using a semicolon (the one after %q) to separate commands.", "previous token")
 		Explain(
 			"Normally, when a shell command fails (returns non-zero), the",
 			"remaining commands are still executed.  For example, the following",
@@ -898,84 +897,3 @@ func splitIntoMkWords(line *Line, text string) (words []string, rest string) {
 	}
 	return words, word + p.mkp.Rest()
 }
-
-type ShQuote struct {
-	repl *PrefixReplacer
-	q    ShQuoting
-}
-
-func NewShQuote(s string) *ShQuote {
-	return &ShQuote{NewPrefixReplacer(s), shqPlain}
-}
-
-func (sq *ShQuote) Feed(str string) {
-	const (
-		reSkip = "^[^\"'`\\\\]+" // Characters that don’t influence the quoting mode.
-	)
-
-	repl := sq.repl
-	repl.rest += str
-	for repl.rest != "" {
-		if repl.AdvanceRegexp(reSkip) {
-			continue
-		}
-
-		mark := repl.Mark()
-		switch sq.q {
-		case shqPlain:
-			switch {
-			case repl.AdvanceStr("\""):
-				sq.q = shqDquot
-			case repl.AdvanceStr("'"):
-				sq.q = shqSquot
-			case repl.AdvanceStr("`"):
-				sq.q = shqBackt
-			case repl.AdvanceRegexp(`^\\.`):
-			}
-
-		case shqDquot:
-			switch {
-			case repl.AdvanceStr("\""):
-				sq.q = shqPlain
-			case repl.AdvanceStr("`"):
-				sq.q = shqDquotBackt
-			case repl.AdvanceStr("'"):
-			case repl.AdvanceRegexp(`^\\.`):
-			}
-		case shqSquot:
-			switch {
-			case repl.AdvanceStr("'"):
-				sq.q = shqPlain
-			case repl.AdvanceRegexp(`^[^']+`):
-			}
-		case shqBackt:
-			switch {
-			case repl.AdvanceStr("`"):
-				sq.q = shqPlain
-			case repl.AdvanceStr("'"):
-				sq.q = shqBacktSquot
-			case repl.AdvanceRegexp(`^\\.`):
-			}
-
-		case shqDquotBackt:
-			switch {
-			case repl.AdvanceStr("`"):
-				sq.q = shqDquot
-			case repl.AdvanceStr("'"):
-				sq.q = shqDquotBacktSquot
-			case repl.AdvanceRegexp(`^\\.`):
-			}
-		case shqDquotBacktSquot:
-			switch {
-			case repl.AdvanceStr("'"):
-				sq.q = shqDquotBackt
-			}
-		}
-
-		if repl.Since(mark) == "" {
-			traceStep2("ShQuote.stuck stack=%s rest=%s", sq.q.String(), sq.repl.rest)
-			repl.AdvanceRest()
-			sq.q = shqUnknown
-		}
-	}
-}
diff --git a/pkgtools/pkglint/files/shell.y b/pkgtools/pkglint/files/shell.y
index 45080ca1c62..2a9c0587424 100644
--- a/pkgtools/pkglint/files/shell.y
+++ b/pkgtools/pkglint/files/shell.y
@@ -153,9 +153,9 @@ term : term separator and_or {
 
 for_clause : tkFOR tkWORD linebreak do_group {
 	args := NewShToken("\"$$@\"",
-		NewShAtom(shtWord, "\"",shqDquot),
-		NewShAtom(shtWord, "$$@",shqDquot),
-		NewShAtom(shtWord,"\"",shqPlain))
+		&ShAtom{shtWord, "\"",shqDquot, nil},
+		&ShAtom{shtWord, "$$@",shqDquot, nil},
+		&ShAtom{shtWord,"\"",shqPlain, nil})
 	$$ = &MkShForClause{$2.MkText, []*ShToken{args}, $4}
 }
 for_clause : tkFOR tkWORD linebreak tkIN sequential_sep do_group {
@@ -208,20 +208,20 @@ case_selector : pattern tkRPAREN {
 }
 
 case_item_ns : case_selector linebreak {
-	$$ = &MkShCaseItem{$1, &MkShList{}, nil}
+	$$ = &MkShCaseItem{$1, &MkShList{}, sepNone}
 }
 case_item_ns : case_selector linebreak term linebreak {
-	$$ = &MkShCaseItem{$1, $3, nil}
+	$$ = &MkShCaseItem{$1, $3, sepNone}
 }
 case_item_ns : case_selector linebreak term separator_op linebreak {
-	$$ = &MkShCaseItem{$1, $3, &$4}
+	$$ = &MkShCaseItem{$1, $3, $4}
 }
 
 case_item : case_selector linebreak tkSEMISEMI linebreak {
-	$$ = &MkShCaseItem{$1, &MkShList{}, nil}
+	$$ = &MkShCaseItem{$1, &MkShList{}, sepNone}
 }
 case_item : case_selector compound_list tkSEMISEMI linebreak {
-	$$ = &MkShCaseItem{$1, $2, nil}
+	$$ = &MkShCaseItem{$1, $2, sepNone}
 }
 
 pattern : tkWORD {
@@ -401,22 +401,22 @@ linebreak : /* empty */ {
 }
 
 separator_op : tkBACKGROUND {
-	$$ = "&"
+	$$ = sepBackground
 }
 separator_op : tkSEMI {
-	$$ = ";"
+	$$ = sepSemicolon
 }
 
 separator : separator_op linebreak {
 	/* empty */
 }
 separator : newline_list {
-	$$ = "\n"
+	$$ = sepNewline
 }
 
 sequential_sep : tkSEMI linebreak {
-	$$ = ";"
+	$$ = sepSemicolon
 }
 sequential_sep : tkNEWLINE linebreak {
-	$$ = "\n"
+	$$ = sepNewline
 }
diff --git a/pkgtools/pkglint/files/shell_test.go b/pkgtools/pkglint/files/shell_test.go
index f34629b460b..6824fbb934c 100644
--- a/pkgtools/pkglint/files/shell_test.go
+++ b/pkgtools/pkglint/files/shell_test.go
@@ -1,8 +1,6 @@
 package main
 
 import (
-	"strings"
-
 	check "gopkg.in/check.v1"
 )
 
@@ -500,24 +498,6 @@ func (s *Suite) Test_ShellLine__shell_comment_with_line_continuation(c *check.C)
 	c.Check(s.Output(), equals, "WARN: ~/Makefile:3--4: A shell comment does not stop at the end of line.\n")
 }
 
-func (s *Suite) Test_ShQuote(c *check.C) {
-	traceQuoting := func(input string) (result string) {
-		sq := NewShQuote("")
-		for _, part := range strings.Split(input, "x") {
-			sq.Feed(part)
-			result += part + "[" + sq.q.String() + "]"
-		}
-		return
-	}
-
-	c.Check(traceQuoting("x\"x`x`x\"x'x\"x'"), equals, "[plain]\"[d]`[db]`[d]\"[plain]'[s]\"[s]'[plain]")
-	c.Check(traceQuoting("x\"x`x'x'x`x\""), equals, "[plain]\"[d]`[db]'[dbs]'[db]`[d]\"[plain]")
-	c.Check(traceQuoting("x\\\"x\\'x\\`x\\\\"), equals, "[plain]\\\"[plain]\\'[plain]\\`[plain]\\\\[plain]")
-	c.Check(traceQuoting("x\"x\\\"x\\'x\\`x\\\\"), equals, "[plain]\"[d]\\\"[d]\\'[d]\\`[d]\\\\[d]")
-	c.Check(traceQuoting("x'x\\\"x\\'x\\`x\\\\"), equals, "[plain]'[s]\\\"[s]\\'[plain]\\`[plain]\\\\[plain]")
-	c.Check(traceQuoting("x`x\\\"x\\'x\\`x\\\\"), equals, "[plain]`[b]\\\"[b]\\'[b]\\`[b]\\\\[b]")
-}
-
 func (s *Suite) Test_ShellLine_unescapeBackticks(c *check.C) {
 	shline := NewShellLine(NewMkLine(dummyLine))
 	// foobar="`echo \"foo   bar\"`"
diff --git a/pkgtools/pkglint/files/shtokenizer.go b/pkgtools/pkglint/files/shtokenizer.go
index c585cf32b2e..c4e48ed32d8 100644
--- a/pkgtools/pkglint/files/shtokenizer.go
+++ b/pkgtools/pkglint/files/shtokenizer.go
@@ -137,7 +137,7 @@ func (p *ShTokenizer) shAtomSub() *ShAtom {
 	repl := p.parser.repl
 	mark := repl.Mark()
 	atom := func(typ ShAtomType) *ShAtom {
-		return NewShAtom(typ, repl.Since(mark), shqSubsh)
+		return &ShAtom{typ, repl.Since(mark), shqSubsh, nil}
 	}
 	switch {
 	case repl.AdvanceHspace():
@@ -151,7 +151,7 @@ func (p *ShTokenizer) shAtomSub() *ShAtom {
 	case repl.AdvanceRegexp(`^#.*`):
 		return &ShAtom{shtComment, repl.m[0], q, nil}
 	case repl.AdvanceStr(")"):
-		return NewShAtom(shtWord, repl.s, shqPlain)
+		return &ShAtom{shtWord, repl.s, shqPlain, nil}
 	case repl.AdvanceRegexp(`^(?:[!#%*+,\-./0-9:=?@A-Z\[\]^_a-z{}~]+|\\[^$]|` + reShDollar + `)+`):
 		return &ShAtom{shtWord, repl.m[0], q, nil}
 	}
diff --git a/pkgtools/pkglint/files/shtypes.go b/pkgtools/pkglint/files/shtypes.go
index bbdf2d42750..8e11e5271ce 100644
--- a/pkgtools/pkglint/files/shtypes.go
+++ b/pkgtools/pkglint/files/shtypes.go
@@ -44,14 +44,6 @@ type ShAtom struct {
 	Data    interface{}
 }
 
-func NewShAtom(typ ShAtomType, text string, quoting ShQuoting) *ShAtom {
-	return &ShAtom{typ, text, quoting, nil}
-}
-
-func NewShAtomVaruse(text string, quoting ShQuoting, varname string, modifiers ...string) *ShAtom {
-	return &ShAtom{shtVaruse, text, quoting, NewMkVarUse(varname, modifiers...)}
-}
-
 func (token *ShAtom) String() string {
 	if token.Type == shtWord && token.Quoting == shqPlain && token.Data == nil {
 		return fmt.Sprintf("%q", token.MkText)
@@ -79,7 +71,6 @@ const (
 	shqSubshSquot
 	shqDquotBacktDquot
 	shqDquotBacktSquot
-	shqUnknown
 )
 
 func (q ShQuoting) String() string {
@@ -88,7 +79,6 @@ func (q ShQuoting) String() string {
 		"d", "s", "b", "S",
 		"db", "bd", "bs", "Ss",
 		"dbd", "dbs",
-		"unknown",
 	}[q]
 }
 
diff --git a/pkgtools/pkglint/files/shtypes_test.go b/pkgtools/pkglint/files/shtypes_test.go
index 98b88a24238..263f459abbb 100644
--- a/pkgtools/pkglint/files/shtypes_test.go
+++ b/pkgtools/pkglint/files/shtypes_test.go
@@ -4,10 +4,18 @@ import (
 	check "gopkg.in/check.v1"
 )
 
+func NewShAtom(typ ShAtomType, text string, quoting ShQuoting) *ShAtom {
+	return &ShAtom{typ, text, quoting, nil}
+}
+
+func NewShAtomVaruse(text string, quoting ShQuoting, varname string, modifiers ...string) *ShAtom {
+	return &ShAtom{shtVaruse, text, quoting, NewMkVarUse(varname, modifiers...)}
+}
+
 func (s *Suite) Test_ShAtom_String(c *check.C) {
 	c.Check(shtComment.String(), equals, "comment")
 }
 
 func (s *Suite) Test_ShQuoting_String(c *check.C) {
-	c.Check(shqUnknown.String(), equals, "unknown")
+	c.Check(shqDquotBacktSquot.String(), equals, "dbs")
 }
diff --git a/pkgtools/pkglint/files/vardefs.go b/pkgtools/pkglint/files/vardefs.go
index 303bfa36b81..553b9e063ea 100644
--- a/pkgtools/pkglint/files/vardefs.go
+++ b/pkgtools/pkglint/files/vardefs.go
@@ -17,734 +17,734 @@ import (
 // Last synced with mk/defaults/mk.conf revision 1.118
 
 func (gd *GlobalData) InitVartypes() {
-	usr("ALLOW_VULNERABLE_PACKAGES", lkNone, CheckvarYes)
+	usr("ALLOW_VULNERABLE_PACKAGES", lkNone, BtYes)
 	usr("MANINSTALL", lkShell, enum("maninstall catinstall"))
-	usr("MANZ", lkNone, CheckvarYes)
-	usr("GZIP", lkShell, CheckvarShellWord)
-	usr("MKCRYPTO", lkNone, CheckvarYesNo)
-	usr("OBJHOSTNAME", lkNone, CheckvarYes)
-	usr("OBJMACHINE", lkNone, CheckvarYes)
-	usr("PKG_SUFX", lkNone, CheckvarFilename)
+	usr("MANZ", lkNone, BtYes)
+	usr("GZIP", lkShell, BtShellWord)
+	usr("MKCRYPTO", lkNone, BtYesNo)
+	usr("OBJHOSTNAME", lkNone, BtYes)
+	usr("OBJMACHINE", lkNone, BtYes)
+	usr("PKG_SUFX", lkNone, BtFilename)
 	usr("PKGSRC_LOCKTYPE", lkNone, enum("none sleep once"))
-	usr("PKGSRC_SLEEPSECS", lkNone, CheckvarInteger)
-	usr("USETBL", lkNone, CheckvarYes)
+	usr("PKGSRC_SLEEPSECS", lkNone, BtInteger)
+	usr("USETBL", lkNone, BtYes)
 	usr("ABI", lkNone, enum("32 64"))
-	usr("PKG_DEVELOPER", lkNone, CheckvarYesNo)
-	usr("USE_ABI_DEPENDS", lkNone, CheckvarYesNo)
+	usr("PKG_DEVELOPER", lkNone, BtYesNo)
+	usr("USE_ABI_DEPENDS", lkNone, BtYesNo)
 	usr("PKG_REGISTER_SHELLS", lkNone, enum("YES NO"))
 	usr("PKGSRC_COMPILER", lkShell, enum("ccache ccc clang distcc f2c gcc hp icc ido gcc mipspro mipspro-ucode pcc sunpro xlc"))
-	usr("PKGSRC_MESSAGE_RECIPIENTS", lkShell, CheckvarMailAddress)
-	usr("PKGSRC_SHOW_BUILD_DEFS", lkNone, CheckvarYesNo)
-	usr("PKGSRC_SHOW_PATCH_ERRORMSG", lkNone, CheckvarYesNo)
-	usr("PKGSRC_RUN_TEST", lkNone, CheckvarYesNo)
-	usr("PREFER_PKGSRC", lkShell, CheckvarIdentifier)
-	usr("PREFER_NATIVE", lkShell, CheckvarIdentifier)
-	usr("PREFER_NATIVE_PTHREADS", lkNone, CheckvarYesNo)
-	usr("LOCALBASE", lkNone, CheckvarPathname)
-	usr("CROSSBASE", lkNone, CheckvarPathname)
-	usr("VARBASE", lkNone, CheckvarPathname)
+	usr("PKGSRC_MESSAGE_RECIPIENTS", lkShell, BtMailAddress)
+	usr("PKGSRC_SHOW_BUILD_DEFS", lkNone, BtYesNo)
+	usr("PKGSRC_SHOW_PATCH_ERRORMSG", lkNone, BtYesNo)
+	usr("PKGSRC_RUN_TEST", lkNone, BtYesNo)
+	usr("PREFER_PKGSRC", lkShell, BtIdentifier)
+	usr("PREFER_NATIVE", lkShell, BtIdentifier)
+	usr("PREFER_NATIVE_PTHREADS", lkNone, BtYesNo)
+	usr("LOCALBASE", lkNone, BtPathname)
+	usr("CROSSBASE", lkNone, BtPathname)
+	usr("VARBASE", lkNone, BtPathname)
 	usr("X11_TYPE", lkNone, enum("modular native"))
-	usr("X11BASE", lkNone, CheckvarPathname)
-	usr("MOTIFBASE", lkNone, CheckvarPathname)
-	usr("PKGINFODIR", lkNone, CheckvarPathname)
-	usr("PKGMANDIR", lkNone, CheckvarPathname)
-	usr("USE_XPKGWEDGE", lkNone, CheckvarYesNo)
-	usr("BSDSRCDIR", lkNone, CheckvarPathname)
-	usr("BSDXSRCDIR", lkNone, CheckvarPathname)
-	usr("DISTDIR", lkNone, CheckvarPathname)
-	usr("DIST_PATH", lkNone, CheckvarPathlist)
-	usr("DEFAULT_VIEW", lkNone, CheckvarUnchecked)
-	usr("FETCH_CMD", lkNone, CheckvarShellCommand)
+	usr("X11BASE", lkNone, BtPathname)
+	usr("MOTIFBASE", lkNone, BtPathname)
+	usr("PKGINFODIR", lkNone, BtPathname)
+	usr("PKGMANDIR", lkNone, BtPathname)
+	usr("USE_XPKGWEDGE", lkNone, BtYesNo)
+	usr("BSDSRCDIR", lkNone, BtPathname)
+	usr("BSDXSRCDIR", lkNone, BtPathname)
+	usr("DISTDIR", lkNone, BtPathname)
+	usr("DIST_PATH", lkNone, BtPathlist)
+	usr("DEFAULT_VIEW", lkNone, BtUnknown)
+	usr("FETCH_CMD", lkNone, BtShellCommand)
 	usr("FETCH_USING", lkNone, enum("curl custom fetch ftp manual wget"))
-	usr("FETCH_RESUME_ARGS", lkShell, CheckvarShellWord)
-	usr("FETCH_OUTPUT_ARGS", lkShell, CheckvarShellWord)
-	usr("LIBTOOLIZE_PLIST", lkNone, CheckvarYesNo)
-	usr("PKG_RESUME_TRANSFERS", lkNone, CheckvarYesNo)
-	usr("PKG_SYSCONFBASE", lkNone, CheckvarPathname)
-	usr("RCD_SCRIPTS_DIR", lkNone, CheckvarPathname)
-	usr("PACKAGES", lkNone, CheckvarPathname)
-	usr("PKGVULNDIR", lkNone, CheckvarPathname)
-	usr("PASSIVE_FETCH", lkNone, CheckvarYes)
+	usr("FETCH_RESUME_ARGS", lkShell, BtShellWord)
+	usr("FETCH_OUTPUT_ARGS", lkShell, BtShellWord)
+	usr("LIBTOOLIZE_PLIST", lkNone, BtYesNo)
+	usr("PKG_RESUME_TRANSFERS", lkNone, BtYesNo)
+	usr("PKG_SYSCONFBASE", lkNone, BtPathname)
+	usr("RCD_SCRIPTS_DIR", lkNone, BtPathname)
+	usr("PACKAGES", lkNone, BtPathname)
+	usr("PKGVULNDIR", lkNone, BtPathname)
+	usr("PASSIVE_FETCH", lkNone, BtYes)
 	usr("PATCH_FUZZ_FACTOR", lkNone, enum("-F0 -F1 -F2 -F3"))
-	usr("ACCEPTABLE_LICENSES", lkShell, CheckvarIdentifier)
-	usr("SPECIFIC_PKGS", lkNone, CheckvarYes)
-	usr("SITE_SPECIFIC_PKGS", lkShell, CheckvarPkgPath)
-	usr("HOST_SPECIFIC_PKGS", lkShell, CheckvarPkgPath)
-	usr("GROUP_SPECIFIC_PKGS", lkShell, CheckvarPkgPath)
-	usr("USER_SPECIFIC_PKGS", lkShell, CheckvarPkgPath)
-	usr("FAILOVER_FETCH", lkNone, CheckvarYes)
-	usr("MASTER_SORT", lkShell, CheckvarUnchecked)
-	usr("MASTER_SORT_REGEX", lkShell, CheckvarUnchecked)
-	usr("PATCH_DEBUG", lkNone, CheckvarYes)
-	usr("PKG_FC", lkNone, CheckvarShellCommand)
-	usr("IMAKE", lkNone, CheckvarShellCommand)
-	usr("IMAKEOPTS", lkShell, CheckvarShellWord)
-	usr("PRE_ROOT_CMD", lkNone, CheckvarShellCommand)
-	pkg("USE_GAMESGROUP", lkNone, CheckvarYesNo)
-	usr("SU_CMD", lkNone, CheckvarShellCommand)
-	usr("SU_CMD_PATH_APPEND", lkNone, CheckvarPathlist)
-	usr("FATAL_OBJECT_FMT_SKEW", lkNone, CheckvarYesNo)
-	usr("WARN_NO_OBJECT_FMT", lkNone, CheckvarYesNo)
-	usr("SMART_MESSAGES", lkNone, CheckvarYes)
-	usr("BINPKG_SITES", lkShell, CheckvarURL)
-	usr("BIN_INSTALL_FLAG", lkShell, CheckvarShellWord)
-	usr("LOCALPATCHES", lkNone, CheckvarPathname)
+	usr("ACCEPTABLE_LICENSES", lkShell, BtIdentifier)
+	usr("SPECIFIC_PKGS", lkNone, BtYes)
+	usr("SITE_SPECIFIC_PKGS", lkShell, BtPkgPath)
+	usr("HOST_SPECIFIC_PKGS", lkShell, BtPkgPath)
+	usr("GROUP_SPECIFIC_PKGS", lkShell, BtPkgPath)
+	usr("USER_SPECIFIC_PKGS", lkShell, BtPkgPath)
+	usr("FAILOVER_FETCH", lkNone, BtYes)
+	usr("MASTER_SORT", lkShell, BtUnknown)
+	usr("MASTER_SORT_REGEX", lkShell, BtUnknown)
+	usr("PATCH_DEBUG", lkNone, BtYes)
+	usr("PKG_FC", lkNone, BtShellCommand)
+	usr("IMAKE", lkNone, BtShellCommand)
+	usr("IMAKEOPTS", lkShell, BtShellWord)
+	usr("PRE_ROOT_CMD", lkNone, BtShellCommand)
+	pkg("USE_GAMESGROUP", lkNone, BtYesNo)
+	usr("SU_CMD", lkNone, BtShellCommand)
+	usr("SU_CMD_PATH_APPEND", lkNone, BtPathlist)
+	usr("FATAL_OBJECT_FMT_SKEW", lkNone, BtYesNo)
+	usr("WARN_NO_OBJECT_FMT", lkNone, BtYesNo)
+	usr("SMART_MESSAGES", lkNone, BtYes)
+	usr("BINPKG_SITES", lkShell, BtURL)
+	usr("BIN_INSTALL_FLAG", lkShell, BtShellWord)
+	usr("LOCALPATCHES", lkNone, BtPathname)
 
 	// some other variables, sorted alphabetically
 
-	acl(".CURDIR", lkNone, CheckvarPathname, "buildlink3.mk:; *: use, use-loadtime")
-	acl(".TARGET", lkNone, CheckvarPathname, "buildlink3.mk:; *: use, use-loadtime")
-	acl("ALL_ENV", lkShell, CheckvarShellWord, "")
-	acl("ALTERNATIVES_FILE", lkNone, CheckvarFilename, "")
-	acl("ALTERNATIVES_SRC", lkShell, CheckvarPathname, "")
-	pkg("APACHE_MODULE", lkNone, CheckvarYes)
-	sys("AR", lkNone, CheckvarShellCommand)
-	sys("AS", lkNone, CheckvarShellCommand)
-	pkglist("AUTOCONF_REQD", lkShell, CheckvarVersion)
-	acl("AUTOMAKE_OVERRIDE", lkShell, CheckvarPathmask, "")
-	pkglist("AUTOMAKE_REQD", lkShell, CheckvarVersion)
-	pkg("AUTO_MKDIRS", lkNone, CheckvarYesNo)
-	usr("BATCH", lkNone, CheckvarYes)
-	acl("BDB185_DEFAULT", lkNone, CheckvarUnchecked, "")
-	sys("BDBBASE", lkNone, CheckvarPathname)
+	acl(".CURDIR", lkNone, BtPathname, "buildlink3.mk:; *: use, use-loadtime")
+	acl(".TARGET", lkNone, BtPathname, "buildlink3.mk:; *: use, use-loadtime")
+	acl("ALL_ENV", lkShell, BtShellWord, "")
+	acl("ALTERNATIVES_FILE", lkNone, BtFilename, "")
+	acl("ALTERNATIVES_SRC", lkShell, BtPathname, "")
+	pkg("APACHE_MODULE", lkNone, BtYes)
+	sys("AR", lkNone, BtShellCommand)
+	sys("AS", lkNone, BtShellCommand)
+	pkglist("AUTOCONF_REQD", lkShell, BtVersion)
+	acl("AUTOMAKE_OVERRIDE", lkShell, BtPathmask, "")
+	pkglist("AUTOMAKE_REQD", lkShell, BtVersion)
+	pkg("AUTO_MKDIRS", lkNone, BtYesNo)
+	usr("BATCH", lkNone, BtYes)
+	acl("BDB185_DEFAULT", lkNone, BtUnknown, "")
+	sys("BDBBASE", lkNone, BtPathname)
 	pkg("BDB_ACCEPTED", lkShell, enum("db1 db2 db3 db4 db5"))
 	acl("BDB_DEFAULT", lkNone, enum("db1 db2 db3 db4 db5"), "")
-	sys("BDB_LIBS", lkShell, CheckvarLdFlag)
+	sys("BDB_LIBS", lkShell, BtLdFlag)
 	sys("BDB_TYPE", lkNone, enum("db1 db2 db3 db4 db5"))
-	sys("BINGRP", lkNone, CheckvarUserGroupName)
-	sys("BINMODE", lkNone, CheckvarFileMode)
-	sys("BINOWN", lkNone, CheckvarUserGroupName)
-	acl("BOOTSTRAP_DEPENDS", lkSpace, CheckvarDependencyWithPath, "Makefile, Makefile.common, *.mk: append")
-	pkg("BOOTSTRAP_PKG", lkNone, CheckvarYesNo)
-	acl("BROKEN", lkNone, CheckvarMessage, "")
-	pkg("BROKEN_GETTEXT_DETECTION", lkNone, CheckvarYesNo)
-	pkglist("BROKEN_EXCEPT_ON_PLATFORM", lkShell, CheckvarMachinePlatformPattern)
-	pkglist("BROKEN_ON_PLATFORM", lkSpace, CheckvarMachinePlatformPattern)
-	sys("BSD_MAKE_ENV", lkShell, CheckvarShellWord)
-	acl("BUILDLINK_ABI_DEPENDS.*", lkSpace, CheckvarDependency, "builtin.mk: append, use-loadtime; *: append")
-	acl("BUILDLINK_API_DEPENDS.*", lkSpace, CheckvarDependency, "builtin.mk: append, use-loadtime; *: append")
-	acl("BUILDLINK_CONTENTS_FILTER", lkNone, CheckvarShellCommand, "")
-	sys("BUILDLINK_CFLAGS", lkShell, CheckvarCFlag)
-	bl3list("BUILDLINK_CFLAGS.*", lkShell, CheckvarCFlag)
-	sys("BUILDLINK_CPPFLAGS", lkShell, CheckvarCFlag)
-	bl3list("BUILDLINK_CPPFLAGS.*", lkShell, CheckvarCFlag)
-	acl("BUILDLINK_CONTENTS_FILTER.*", lkNone, CheckvarShellCommand, "buildlink3.mk: set")
-	acl("BUILDLINK_DEPENDS", lkSpace, CheckvarIdentifier, "buildlink3.mk: append")
-	acl("BUILDLINK_DEPMETHOD.*", lkShell, CheckvarBuildlinkDepmethod, "buildlink3.mk: default, append, use; Makefile: set, append; Makefile.common, *.mk: append")
-	acl("BUILDLINK_DIR", lkNone, CheckvarPathname, "*: use")
-	bl3list("BUILDLINK_FILES.*", lkShell, CheckvarPathmask)
-	acl("BUILDLINK_FILES_CMD.*", lkNone, CheckvarShellCommand, "")
-	acl("BUILDLINK_INCDIRS.*", lkShell, CheckvarPathname, "buildlink3.mk: default, append; Makefile, Makefile.common, *.mk: use")
-	acl("BUILDLINK_JAVA_PREFIX.*", lkNone, CheckvarPathname, "buildlink3.mk: set, use")
-	acl("BUILDLINK_LDADD.*", lkShell, CheckvarLdFlag, "builtin.mk: set, default, append, use; buildlink3.mk: append, use; Makefile, Makefile.common, *.mk: use")
-	acl("BUILDLINK_LDFLAGS", lkShell, CheckvarLdFlag, "*: use")
-	bl3list("BUILDLINK_LDFLAGS.*", lkShell, CheckvarLdFlag)
-	acl("BUILDLINK_LIBDIRS.*", lkShell, CheckvarPathname, "buildlink3.mk, builtin.mk: append; Makefile, Makefile.common, *.mk: use")
-	acl("BUILDLINK_LIBS.*", lkShell, CheckvarLdFlag, "buildlink3.mk: append")
-	acl("BUILDLINK_PASSTHRU_DIRS", lkShell, CheckvarPathname, "Makefile, Makefile.common, buildlink3.mk, hacks.mk: append")
-	acl("BUILDLINK_PASSTHRU_RPATHDIRS", lkShell, CheckvarPathname, "Makefile, Makefile.common, buildlink3.mk, hacks.mk: append")
-	acl("BUILDLINK_PKGSRCDIR.*", lkNone, CheckvarRelativePkgDir, "buildlink3.mk: default, use-loadtime")
-	acl("BUILDLINK_PREFIX.*", lkNone, CheckvarPathname, "builtin.mk: set, use; Makefile, Makefile.common, *.mk: use")
-	acl("BUILDLINK_RPATHDIRS.*", lkShell, CheckvarPathname, "buildlink3.mk: append")
-	acl("BUILDLINK_TARGETS", lkShell, CheckvarIdentifier, "")
-	acl("BUILDLINK_FNAME_TRANSFORM.*", lkNone, CheckvarSedCommands, "Makefile, buildlink3.mk, builtin.mk, hacks.mk: append")
-	acl("BUILDLINK_TRANSFORM", lkShell, CheckvarWrapperTransform, "*: append")
-	acl("BUILDLINK_TRANSFORM.*", lkShell, CheckvarWrapperTransform, "*: append")
-	acl("BUILDLINK_TREE", lkShell, CheckvarIdentifier, "buildlink3.mk: append")
-	acl("BUILD_DEFS", lkShell, CheckvarVariableName, "Makefile, Makefile.common, options.mk: append")
-	pkglist("BUILD_DEFS_EFFECTS", lkShell, CheckvarVariableName)
-	acl("BUILD_DEPENDS", lkSpace, CheckvarDependencyWithPath, "Makefile, Makefile.common, *.mk: append")
-	pkglist("BUILD_DIRS", lkShell, CheckvarWrksrcSubdirectory)
-	pkglist("BUILD_ENV", lkShell, CheckvarShellWord)
-	sys("BUILD_MAKE_CMD", lkNone, CheckvarShellCommand)
-	pkglist("BUILD_MAKE_FLAGS", lkShell, CheckvarShellWord)
-	pkglist("BUILD_TARGET", lkShell, CheckvarIdentifier)
-	pkglist("BUILD_TARGET.*", lkShell, CheckvarIdentifier)
-	pkg("BUILD_USES_MSGFMT", lkNone, CheckvarYes)
-	acl("BUILTIN_PKG", lkNone, CheckvarIdentifier, "builtin.mk: set, use-loadtime, use")
-	acl("BUILTIN_PKG.*", lkNone, CheckvarPkgName, "builtin.mk: set, use-loadtime, use")
-	acl("BUILTIN_FIND_FILES_VAR", lkShell, CheckvarVariableName, "builtin.mk: set")
-	acl("BUILTIN_FIND_FILES.*", lkShell, CheckvarPathname, "builtin.mk: set")
-	acl("BUILTIN_FIND_GREP.*", lkNone, CheckvarString, "builtin.mk: set")
-	acl("BUILTIN_FIND_HEADERS_VAR", lkShell, CheckvarVariableName, "builtin.mk: set")
-	acl("BUILTIN_FIND_HEADERS.*", lkShell, CheckvarPathname, "builtin.mk: set")
-	acl("BUILTIN_FIND_LIBS", lkShell, CheckvarPathname, "builtin.mk: set")
-	acl("BUILTIN_IMAKE_CHECK", lkShell, CheckvarUnchecked, "builtin.mk: set")
-	acl("BUILTIN_IMAKE_CHECK.*", lkNone, CheckvarYesNo, "")
-	sys("BUILTIN_X11_TYPE", lkNone, CheckvarUnchecked)
-	sys("BUILTIN_X11_VERSION", lkNone, CheckvarUnchecked)
-	acl("CATEGORIES", lkShell, CheckvarCategory, "Makefile: set, append; Makefile.common: set, default, append")
-	sys("CC_VERSION", lkNone, CheckvarMessage)
-	sys("CC", lkNone, CheckvarShellCommand)
-	pkglist("CFLAGS", lkShell, CheckvarCFlag)   // may also be changed by the user
-	pkglist("CFLAGS.*", lkShell, CheckvarCFlag) // may also be changed by the user
-	acl("CHECK_BUILTIN", lkNone, CheckvarYesNo, "builtin.mk: default; Makefile: set")
-	acl("CHECK_BUILTIN.*", lkNone, CheckvarYesNo, "Makefile, options.mk, buildlink3.mk: set; builtin.mk: default; *: use-loadtime")
-	acl("CHECK_FILES_SKIP", lkShell, CheckvarBasicRegularExpression, "Makefile, Makefile.common: append")
-	pkg("CHECK_FILES_SUPPORTED", lkNone, CheckvarYesNo)
-	usr("CHECK_HEADERS", lkNone, CheckvarYesNo)
-	pkglist("CHECK_HEADERS_SKIP", lkShell, CheckvarPathmask)
-	usr("CHECK_INTERPRETER", lkNone, CheckvarYesNo)
-	pkglist("CHECK_INTERPRETER_SKIP", lkShell, CheckvarPathmask)
-	usr("CHECK_PERMS", lkNone, CheckvarYesNo)
-	pkglist("CHECK_PERMS_SKIP", lkShell, CheckvarPathmask)
-	usr("CHECK_PORTABILITY", lkNone, CheckvarYesNo)
-	pkglist("CHECK_PORTABILITY_SKIP", lkShell, CheckvarPathmask)
-	acl("CHECK_SHLIBS", lkNone, CheckvarYesNo, "Makefile: set")
-	pkglist("CHECK_SHLIBS_SKIP", lkShell, CheckvarPathmask)
-	acl("CHECK_SHLIBS_SUPPORTED", lkNone, CheckvarYesNo, "Makefile: set")
-	pkglist("CHECK_WRKREF_SKIP", lkShell, CheckvarPathmask)
-	pkg("CMAKE_ARG_PATH", lkNone, CheckvarPathname)
-	pkglist("CMAKE_ARGS", lkShell, CheckvarShellWord)
-	pkglist("CMAKE_ARGS.*", lkShell, CheckvarShellWord)
-	acl("COMMENT", lkNone, CheckvarComment, "Makefile, Makefile.common: set, append")
+	sys("BINGRP", lkNone, BtUserGroupName)
+	sys("BINMODE", lkNone, BtFileMode)
+	sys("BINOWN", lkNone, BtUserGroupName)
+	acl("BOOTSTRAP_DEPENDS", lkSpace, BtDependencyWithPath, "Makefile, Makefile.common, *.mk: append")
+	pkg("BOOTSTRAP_PKG", lkNone, BtYesNo)
+	acl("BROKEN", lkNone, BtMessage, "")
+	pkg("BROKEN_GETTEXT_DETECTION", lkNone, BtYesNo)
+	pkglist("BROKEN_EXCEPT_ON_PLATFORM", lkShell, BtMachinePlatformPattern)
+	pkglist("BROKEN_ON_PLATFORM", lkSpace, BtMachinePlatformPattern)
+	sys("BSD_MAKE_ENV", lkShell, BtShellWord)
+	acl("BUILDLINK_ABI_DEPENDS.*", lkSpace, BtDependency, "builtin.mk: append, use-loadtime; *: append")
+	acl("BUILDLINK_API_DEPENDS.*", lkSpace, BtDependency, "builtin.mk: append, use-loadtime; *: append")
+	acl("BUILDLINK_CONTENTS_FILTER", lkNone, BtShellCommand, "")
+	sys("BUILDLINK_CFLAGS", lkShell, BtCFlag)
+	bl3list("BUILDLINK_CFLAGS.*", lkShell, BtCFlag)
+	sys("BUILDLINK_CPPFLAGS", lkShell, BtCFlag)
+	bl3list("BUILDLINK_CPPFLAGS.*", lkShell, BtCFlag)
+	acl("BUILDLINK_CONTENTS_FILTER.*", lkNone, BtShellCommand, "buildlink3.mk: set")
+	acl("BUILDLINK_DEPENDS", lkSpace, BtIdentifier, "buildlink3.mk: append")
+	acl("BUILDLINK_DEPMETHOD.*", lkShell, BtBuildlinkDepmethod, "buildlink3.mk: default, append, use; Makefile: set, append; Makefile.common, *.mk: append")
+	acl("BUILDLINK_DIR", lkNone, BtPathname, "*: use")
+	bl3list("BUILDLINK_FILES.*", lkShell, BtPathmask)
+	acl("BUILDLINK_FILES_CMD.*", lkNone, BtShellCommand, "")
+	acl("BUILDLINK_INCDIRS.*", lkShell, BtPathname, "buildlink3.mk: default, append; Makefile, Makefile.common, *.mk: use")
+	acl("BUILDLINK_JAVA_PREFIX.*", lkNone, BtPathname, "buildlink3.mk: set, use")
+	acl("BUILDLINK_LDADD.*", lkShell, BtLdFlag, "builtin.mk: set, default, append, use; buildlink3.mk: append, use; Makefile, Makefile.common, *.mk: use")
+	acl("BUILDLINK_LDFLAGS", lkShell, BtLdFlag, "*: use")
+	bl3list("BUILDLINK_LDFLAGS.*", lkShell, BtLdFlag)
+	acl("BUILDLINK_LIBDIRS.*", lkShell, BtPathname, "buildlink3.mk, builtin.mk: append; Makefile, Makefile.common, *.mk: use")
+	acl("BUILDLINK_LIBS.*", lkShell, BtLdFlag, "buildlink3.mk: append")
+	acl("BUILDLINK_PASSTHRU_DIRS", lkShell, BtPathname, "Makefile, Makefile.common, buildlink3.mk, hacks.mk: append")
+	acl("BUILDLINK_PASSTHRU_RPATHDIRS", lkShell, BtPathname, "Makefile, Makefile.common, buildlink3.mk, hacks.mk: append")
+	acl("BUILDLINK_PKGSRCDIR.*", lkNone, BtRelativePkgDir, "buildlink3.mk: default, use-loadtime")
+	acl("BUILDLINK_PREFIX.*", lkNone, BtPathname, "builtin.mk: set, use; Makefile, Makefile.common, *.mk: use")
+	acl("BUILDLINK_RPATHDIRS.*", lkShell, BtPathname, "buildlink3.mk: append")
+	acl("BUILDLINK_TARGETS", lkShell, BtIdentifier, "")
+	acl("BUILDLINK_FNAME_TRANSFORM.*", lkNone, BtSedCommands, "Makefile, buildlink3.mk, builtin.mk, hacks.mk: append")
+	acl("BUILDLINK_TRANSFORM", lkShell, BtWrapperTransform, "*: append")
+	acl("BUILDLINK_TRANSFORM.*", lkShell, BtWrapperTransform, "*: append")
+	acl("BUILDLINK_TREE", lkShell, BtIdentifier, "buildlink3.mk: append")
+	acl("BUILD_DEFS", lkShell, BtVariableName, "Makefile, Makefile.common, options.mk: append")
+	pkglist("BUILD_DEFS_EFFECTS", lkShell, BtVariableName)
+	acl("BUILD_DEPENDS", lkSpace, BtDependencyWithPath, "Makefile, Makefile.common, *.mk: append")
+	pkglist("BUILD_DIRS", lkShell, BtWrksrcSubdirectory)
+	pkglist("BUILD_ENV", lkShell, BtShellWord)
+	sys("BUILD_MAKE_CMD", lkNone, BtShellCommand)
+	pkglist("BUILD_MAKE_FLAGS", lkShell, BtShellWord)
+	pkglist("BUILD_TARGET", lkShell, BtIdentifier)
+	pkglist("BUILD_TARGET.*", lkShell, BtIdentifier)
+	pkg("BUILD_USES_MSGFMT", lkNone, BtYes)
+	acl("BUILTIN_PKG", lkNone, BtIdentifier, "builtin.mk: set, use-loadtime, use")
+	acl("BUILTIN_PKG.*", lkNone, BtPkgName, "builtin.mk: set, use-loadtime, use")
+	acl("BUILTIN_FIND_FILES_VAR", lkShell, BtVariableName, "builtin.mk: set")
+	acl("BUILTIN_FIND_FILES.*", lkShell, BtPathname, "builtin.mk: set")
+	acl("BUILTIN_FIND_GREP.*", lkNone, BtUnknown, "builtin.mk: set")
+	acl("BUILTIN_FIND_HEADERS_VAR", lkShell, BtVariableName, "builtin.mk: set")
+	acl("BUILTIN_FIND_HEADERS.*", lkShell, BtPathname, "builtin.mk: set")
+	acl("BUILTIN_FIND_LIBS", lkShell, BtPathname, "builtin.mk: set")
+	acl("BUILTIN_IMAKE_CHECK", lkShell, BtUnknown, "builtin.mk: set")
+	acl("BUILTIN_IMAKE_CHECK.*", lkNone, BtYesNo, "")
+	sys("BUILTIN_X11_TYPE", lkNone, BtUnknown)
+	sys("BUILTIN_X11_VERSION", lkNone, BtUnknown)
+	acl("CATEGORIES", lkShell, BtCategory, "Makefile: set, append; Makefile.common: set, default, append")
+	sys("CC_VERSION", lkNone, BtMessage)
+	sys("CC", lkNone, BtShellCommand)
+	pkglist("CFLAGS", lkShell, BtCFlag)   // may also be changed by the user
+	pkglist("CFLAGS.*", lkShell, BtCFlag) // may also be changed by the user
+	acl("CHECK_BUILTIN", lkNone, BtYesNo, "builtin.mk: default; Makefile: set")
+	acl("CHECK_BUILTIN.*", lkNone, BtYesNo, "Makefile, options.mk, buildlink3.mk: set; builtin.mk: default; *: use-loadtime")
+	acl("CHECK_FILES_SKIP", lkShell, BtBasicRegularExpression, "Makefile, Makefile.common: append")
+	pkg("CHECK_FILES_SUPPORTED", lkNone, BtYesNo)
+	usr("CHECK_HEADERS", lkNone, BtYesNo)
+	pkglist("CHECK_HEADERS_SKIP", lkShell, BtPathmask)
+	usr("CHECK_INTERPRETER", lkNone, BtYesNo)
+	pkglist("CHECK_INTERPRETER_SKIP", lkShell, BtPathmask)
+	usr("CHECK_PERMS", lkNone, BtYesNo)
+	pkglist("CHECK_PERMS_SKIP", lkShell, BtPathmask)
+	usr("CHECK_PORTABILITY", lkNone, BtYesNo)
+	pkglist("CHECK_PORTABILITY_SKIP", lkShell, BtPathmask)
+	acl("CHECK_SHLIBS", lkNone, BtYesNo, "Makefile: set")
+	pkglist("CHECK_SHLIBS_SKIP", lkShell, BtPathmask)
+	acl("CHECK_SHLIBS_SUPPORTED", lkNone, BtYesNo, "Makefile: set")
+	pkglist("CHECK_WRKREF_SKIP", lkShell, BtPathmask)
+	pkg("CMAKE_ARG_PATH", lkNone, BtPathname)
+	pkglist("CMAKE_ARGS", lkShell, BtShellWord)
+	pkglist("CMAKE_ARGS.*", lkShell, BtShellWord)
+	acl("COMMENT", lkNone, BtComment, "Makefile, Makefile.common: set, append")
 	acl("COMPILER_RPATH_FLAG", lkNone, enum("-Wl,-rpath"), "*: use")
-	pkglist("CONFIGURE_ARGS", lkShell, CheckvarShellWord)
-	pkglist("CONFIGURE_ARGS.*", lkShell, CheckvarShellWord)
-	pkglist("CONFIGURE_DIRS", lkShell, CheckvarWrksrcSubdirectory)
-	acl("CONFIGURE_ENV", lkShell, CheckvarShellWord, "Makefile, Makefile.common: append, set, use; buildlink3.mk, builtin.mk: append; *.mk: append, use")
-	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)
+	pkglist("CONFIGURE_ARGS", lkShell, BtShellWord)
+	pkglist("CONFIGURE_ARGS.*", lkShell, BtShellWord)
+	pkglist("CONFIGURE_DIRS", lkShell, BtWrksrcSubdirectory)
+	acl("CONFIGURE_ENV", lkShell, BtShellWord, "Makefile, Makefile.common: append, set, use; buildlink3.mk, builtin.mk: append; *.mk: append, use")
+	acl("CONFIGURE_ENV.*", lkShell, BtShellWord, "Makefile, Makefile.common: append, set, use; buildlink3.mk, builtin.mk: append; *.mk: append, use")
+	pkg("CONFIGURE_HAS_INFODIR", lkNone, BtYesNo)
+	pkg("CONFIGURE_HAS_LIBDIR", lkNone, BtYesNo)
+	pkg("CONFIGURE_HAS_MANDIR", lkNone, BtYesNo)
+	pkg("CONFIGURE_SCRIPT", lkNone, BtPathname)
+	acl("CONFIG_GUESS_OVERRIDE", lkShell, BtPathmask, "Makefile, Makefile.common: set, append")
+	acl("CONFIG_STATUS_OVERRIDE", lkShell, BtPathmask, "Makefile, Makefile.common: set, append")
+	acl("CONFIG_SHELL", lkNone, BtPathname, "Makefile, Makefile.common: set")
+	acl("CONFIG_SUB_OVERRIDE", lkShell, BtPathmask, "Makefile, Makefile.common: set, append")
+	pkglist("CONFLICTS", lkSpace, BtDependency)
+	pkglist("CONF_FILES", lkShell, BtShellWord)
 	pkg("CONF_FILES_MODE", lkNone, enum("0644 0640 0600 0400"))
-	pkglist("CONF_FILES_PERMS", lkShell, CheckvarPerms)
+	pkglist("CONF_FILES_PERMS", lkShell, BtPerms)
 	sys("COPY", lkNone, enum("-c")) // The flag that tells ${INSTALL} to copy a file
-	sys("CPP", lkNone, CheckvarShellCommand)
-	pkglist("CPPFLAGS", lkShell, CheckvarCFlag)
-	pkglist("CPPFLAGS.*", lkShell, CheckvarCFlag)
-	acl("CRYPTO", lkNone, CheckvarYes, "Makefile: set")
-	sys("CXX", lkNone, CheckvarShellCommand)
-	pkglist("CXXFLAGS", lkShell, CheckvarCFlag)
-	pkglist("CXXFLAGS.*", lkShell, CheckvarCFlag)
-	pkglist("CWRAPPERS_APPEND.*", lkShell, CheckvarShellWord)
-	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)
-	acl("DESCR_SRC", lkShell, CheckvarPathname, "Makefile: set, append; Makefile.common: default, set")
-	sys("DESTDIR", lkNone, CheckvarPathname)
-	acl("DESTDIR_VARNAME", lkNone, CheckvarVariableName, "Makefile, Makefile.common: set")
-	sys("DEVOSSAUDIO", lkNone, CheckvarPathname)
-	sys("DEVOSSSOUND", lkNone, CheckvarPathname)
-	pkglist("DISTFILES", lkShell, CheckvarFilename)
-	pkg("DISTINFO_FILE", lkNone, CheckvarRelativePkgPath)
-	pkg("DISTNAME", lkNone, CheckvarFilename)
-	pkg("DIST_SUBDIR", lkNone, CheckvarPathname)
-	acl("DJB_BUILD_ARGS", lkShell, CheckvarShellWord, "")
-	acl("DJB_BUILD_TARGETS", lkShell, CheckvarIdentifier, "")
-	acl("DJB_CONFIG_CMDS", lkNone, CheckvarShellCommands, "options.mk: set")
-	acl("DJB_CONFIG_DIRS", lkShell, CheckvarWrksrcSubdirectory, "")
-	acl("DJB_CONFIG_HOME", lkNone, CheckvarFilename, "")
-	acl("DJB_CONFIG_PREFIX", lkNone, CheckvarPathname, "")
-	acl("DJB_INSTALL_TARGETS", lkShell, CheckvarIdentifier, "")
-	acl("DJB_MAKE_TARGETS", lkNone, CheckvarYesNo, "")
-	acl("DJB_RESTRICTED", lkNone, CheckvarYesNo, "Makefile: set")
-	acl("DJB_SLASHPACKAGE", lkNone, CheckvarYesNo, "")
-	acl("DLOPEN_REQUIRE_PTHREADS", lkNone, CheckvarYesNo, "")
-	acl("DL_AUTO_VARS", lkNone, CheckvarYes, "Makefile, Makefile.common, options.mk: set")
-	acl("DL_LIBS", lkShell, CheckvarLdFlag, "")
-	sys("DOCOWN", lkNone, CheckvarUserGroupName)
-	sys("DOCGRP", lkNone, CheckvarUserGroupName)
-	sys("DOCMODE", lkNone, CheckvarFileMode)
-	sys("DOWNLOADED_DISTFILE", lkNone, CheckvarPathname)
-	sys("DO_NADA", lkNone, CheckvarShellCommand)
-	pkg("DYNAMIC_SITES_CMD", lkNone, CheckvarShellCommand)
-	pkg("DYNAMIC_SITES_SCRIPT", lkNone, CheckvarPathname)
-	acl("ECHO", lkNone, CheckvarShellCommand, "*: use")
-	sys("ECHO_MSG", lkNone, CheckvarShellCommand)
-	sys("ECHO_N", lkNone, CheckvarShellCommand)
-	pkg("EGDIR", lkNone, CheckvarPathname) // Not defined anywhere, but used in many places like this.
-	sys("EMACS_BIN", lkNone, CheckvarPathname)
-	sys("EMACS_ETCPREFIX", lkNone, CheckvarPathname)
+	sys("CPP", lkNone, BtShellCommand)
+	pkglist("CPPFLAGS", lkShell, BtCFlag)
+	pkglist("CPPFLAGS.*", lkShell, BtCFlag)
+	acl("CRYPTO", lkNone, BtYes, "Makefile: set")
+	sys("CXX", lkNone, BtShellCommand)
+	pkglist("CXXFLAGS", lkShell, BtCFlag)
+	pkglist("CXXFLAGS.*", lkShell, BtCFlag)
+	pkglist("CWRAPPERS_APPEND.*", lkShell, BtShellWord)
+	acl("DEINSTALL_FILE", lkNone, BtPathname, "Makefile: set")
+	acl("DEINSTALL_SRC", lkShell, BtPathname, "Makefile: set; Makefile.common: default, set")
+	acl("DEINSTALL_TEMPLATES", lkShell, BtPathname, "Makefile: set, append; Makefile.common: set, default, append")
+	sys("DELAYED_ERROR_MSG", lkNone, BtShellCommand)
+	sys("DELAYED_WARNING_MSG", lkNone, BtShellCommand)
+	pkglist("DEPENDS", lkSpace, BtDependencyWithPath)
+	usr("DEPENDS_TARGET", lkShell, BtIdentifier)
+	acl("DESCR_SRC", lkShell, BtPathname, "Makefile: set, append; Makefile.common: default, set")
+	sys("DESTDIR", lkNone, BtPathname)
+	acl("DESTDIR_VARNAME", lkNone, BtVariableName, "Makefile, Makefile.common: set")
+	sys("DEVOSSAUDIO", lkNone, BtPathname)
+	sys("DEVOSSSOUND", lkNone, BtPathname)
+	pkglist("DISTFILES", lkShell, BtFilename)
+	pkg("DISTINFO_FILE", lkNone, BtRelativePkgPath)
+	pkg("DISTNAME", lkNone, BtFilename)
+	pkg("DIST_SUBDIR", lkNone, BtPathname)
+	acl("DJB_BUILD_ARGS", lkShell, BtShellWord, "")
+	acl("DJB_BUILD_TARGETS", lkShell, BtIdentifier, "")
+	acl("DJB_CONFIG_CMDS", lkNone, BtShellCommands, "options.mk: set")
+	acl("DJB_CONFIG_DIRS", lkShell, BtWrksrcSubdirectory, "")
+	acl("DJB_CONFIG_HOME", lkNone, BtFilename, "")
+	acl("DJB_CONFIG_PREFIX", lkNone, BtPathname, "")
+	acl("DJB_INSTALL_TARGETS", lkShell, BtIdentifier, "")
+	acl("DJB_MAKE_TARGETS", lkNone, BtYesNo, "")
+	acl("DJB_RESTRICTED", lkNone, BtYesNo, "Makefile: set")
+	acl("DJB_SLASHPACKAGE", lkNone, BtYesNo, "")
+	acl("DLOPEN_REQUIRE_PTHREADS", lkNone, BtYesNo, "")
+	acl("DL_AUTO_VARS", lkNone, BtYes, "Makefile, Makefile.common, options.mk: set")
+	acl("DL_LIBS", lkShell, BtLdFlag, "")
+	sys("DOCOWN", lkNone, BtUserGroupName)
+	sys("DOCGRP", lkNone, BtUserGroupName)
+	sys("DOCMODE", lkNone, BtFileMode)
+	sys("DOWNLOADED_DISTFILE", lkNone, BtPathname)
+	sys("DO_NADA", lkNone, BtShellCommand)
+	pkg("DYNAMIC_SITES_CMD", lkNone, BtShellCommand)
+	pkg("DYNAMIC_SITES_SCRIPT", lkNone, BtPathname)
+	acl("ECHO", lkNone, BtShellCommand, "*: use")
+	sys("ECHO_MSG", lkNone, BtShellCommand)
+	sys("ECHO_N", lkNone, BtShellCommand)
+	pkg("EGDIR", lkNone, BtPathname) // Not defined anywhere, but used in many places like this.
+	sys("EMACS_BIN", lkNone, BtPathname)
+	sys("EMACS_ETCPREFIX", lkNone, BtPathname)
 	sys("EMACS_FLAVOR", lkNone, enum("emacs xemacs"))
-	sys("EMACS_INFOPREFIX", lkNone, CheckvarPathname)
-	sys("EMACS_LISPPREFIX", lkNone, CheckvarPathname)
-	acl("EMACS_MODULES", lkShell, CheckvarIdentifier, "Makefile, Makefile.common: set, append")
-	sys("EMACS_PKGNAME_PREFIX", lkNone, CheckvarIdentifier) // Or the empty string.
+	sys("EMACS_INFOPREFIX", lkNone, BtPathname)
+	sys("EMACS_LISPPREFIX", lkNone, BtPathname)
+	acl("EMACS_MODULES", lkShell, BtIdentifier, "Makefile, Makefile.common: set, append")
+	sys("EMACS_PKGNAME_PREFIX", lkNone, BtIdentifier) // Or the empty string.
 	sys("EMACS_TYPE", lkNone, enum("emacs xemacs"))
-	acl("EMACS_USE_LEIM", lkNone, CheckvarYes, "")
+	acl("EMACS_USE_LEIM", lkNone, BtYes, "")
 	acl("EMACS_VERSIONS_ACCEPTED", lkShell, enum("emacs25 emacs24 emacs24nox emacs23 emacs23nox emacs22 emacs22nox emacs21 emacs21nox emacs20 xemacs215 xemacs215nox xemacs214 xemacs214nox"), "Makefile: set")
-	sys("EMACS_VERSION_MAJOR", lkNone, CheckvarInteger)
-	sys("EMACS_VERSION_MINOR", lkNone, CheckvarInteger)
+	sys("EMACS_VERSION_MAJOR", lkNone, BtInteger)
+	sys("EMACS_VERSION_MINOR", lkNone, BtInteger)
 	acl("EMACS_VERSION_REQD", lkShell, enum("emacs24 emacs24nox emacs23 emacs23nox emacs22 emacs22nox emacs21 emacs21nox emacs20 xemacs215 xemacs214"), "Makefile: set, append")
-	sys("EMULDIR", lkNone, CheckvarPathname)
-	sys("EMULSUBDIR", lkNone, CheckvarPathname)
-	sys("OPSYS_EMULDIR", lkNone, CheckvarPathname)
-	sys("EMULSUBDIRSLASH", lkNone, CheckvarPathname)
+	sys("EMULDIR", lkNone, BtPathname)
+	sys("EMULSUBDIR", lkNone, BtPathname)
+	sys("OPSYS_EMULDIR", lkNone, BtPathname)
+	sys("EMULSUBDIRSLASH", lkNone, BtPathname)
 	sys("EMUL_ARCH", lkNone, enum("arm i386 m68k none ns32k sparc vax x86_64"))
-	sys("EMUL_DISTRO", lkNone, CheckvarIdentifier)
-	sys("EMUL_IS_NATIVE", lkNone, CheckvarYes)
-	pkg("EMUL_MODULES.*", lkShell, CheckvarIdentifier)
+	sys("EMUL_DISTRO", lkNone, BtIdentifier)
+	sys("EMUL_IS_NATIVE", lkNone, BtYes)
+	pkg("EMUL_MODULES.*", lkShell, BtIdentifier)
 	sys("EMUL_OPSYS", lkNone, enum("darwin freebsd hpux irix linux osf1 solaris sunos none"))
 	pkg("EMUL_PKG_FMT", lkNone, enum("plain rpm"))
-	usr("EMUL_PLATFORM", lkNone, CheckvarEmulPlatform)
-	pkg("EMUL_PLATFORMS", lkShell, CheckvarEmulPlatform)
-	usr("EMUL_PREFER", lkShell, CheckvarEmulPlatform)
-	pkg("EMUL_REQD", lkSpace, CheckvarDependency)
+	usr("EMUL_PLATFORM", lkNone, BtEmulPlatform)
+	pkg("EMUL_PLATFORMS", lkShell, BtEmulPlatform)
+	usr("EMUL_PREFER", lkShell, BtEmulPlatform)
+	pkg("EMUL_REQD", lkSpace, BtDependency)
 	usr("EMUL_TYPE.*", lkNone, enum("native builtin suse suse-9.1 suse-9.x suse-10.0 suse-10.x"))
-	sys("ERROR_CAT", lkNone, CheckvarShellCommand)
-	sys("ERROR_MSG", lkNone, CheckvarShellCommand)
-	acl("EVAL_PREFIX", lkSpace, CheckvarShellWord, "Makefile, Makefile.common: append") // XXX: Combining ShellWord with lkSpace looks weird.
-	sys("EXPORT_SYMBOLS_LDFLAGS", lkShell, CheckvarLdFlag)
-	sys("EXTRACT_CMD", lkNone, CheckvarShellCommand)
-	pkg("EXTRACT_DIR", lkNone, CheckvarPathname)
-	pkg("EXTRACT_DIR.*", lkNone, CheckvarPathname)
-	pkglist("EXTRACT_ELEMENTS", lkShell, CheckvarPathmask)
-	pkglist("EXTRACT_ENV", lkShell, CheckvarShellWord)
-	pkglist("EXTRACT_ONLY", lkShell, CheckvarPathname)
-	acl("EXTRACT_OPTS", lkShell, CheckvarShellWord, "Makefile, Makefile.common: set, append")
-	acl("EXTRACT_OPTS_BIN", lkShell, CheckvarShellWord, "Makefile, Makefile.common: set, append")
-	acl("EXTRACT_OPTS_LHA", lkShell, CheckvarShellWord, "Makefile, Makefile.common: set, append")
-	acl("EXTRACT_OPTS_PAX", lkShell, CheckvarShellWord, "Makefile, Makefile.common: set, append")
-	acl("EXTRACT_OPTS_RAR", lkShell, CheckvarShellWord, "Makefile, Makefile.common: set, append")
-	acl("EXTRACT_OPTS_TAR", lkShell, CheckvarShellWord, "Makefile, Makefile.common: set, append")
-	acl("EXTRACT_OPTS_ZIP", lkShell, CheckvarShellWord, "Makefile, Makefile.common: set, append")
-	acl("EXTRACT_OPTS_ZOO", lkShell, CheckvarShellWord, "Makefile, Makefile.common: set, append")
-	pkg("EXTRACT_SUFX", lkNone, CheckvarDistSuffix)
+	sys("ERROR_CAT", lkNone, BtShellCommand)
+	sys("ERROR_MSG", lkNone, BtShellCommand)
+	acl("EVAL_PREFIX", lkSpace, BtShellWord, "Makefile, Makefile.common: append") // XXX: Combining ShellWord with lkSpace looks weird.
+	sys("EXPORT_SYMBOLS_LDFLAGS", lkShell, BtLdFlag)
+	sys("EXTRACT_CMD", lkNone, BtShellCommand)
+	pkg("EXTRACT_DIR", lkNone, BtPathname)
+	pkg("EXTRACT_DIR.*", lkNone, BtPathname)
+	pkglist("EXTRACT_ELEMENTS", lkShell, BtPathmask)
+	pkglist("EXTRACT_ENV", lkShell, BtShellWord)
+	pkglist("EXTRACT_ONLY", lkShell, BtPathname)
+	acl("EXTRACT_OPTS", lkShell, BtShellWord, "Makefile, Makefile.common: set, append")
+	acl("EXTRACT_OPTS_BIN", lkShell, BtShellWord, "Makefile, Makefile.common: set, append")
+	acl("EXTRACT_OPTS_LHA", lkShell, BtShellWord, "Makefile, Makefile.common: set, append")
+	acl("EXTRACT_OPTS_PAX", lkShell, BtShellWord, "Makefile, Makefile.common: set, append")
+	acl("EXTRACT_OPTS_RAR", lkShell, BtShellWord, "Makefile, Makefile.common: set, append")
+	acl("EXTRACT_OPTS_TAR", lkShell, BtShellWord, "Makefile, Makefile.common: set, append")
+	acl("EXTRACT_OPTS_ZIP", lkShell, BtShellWord, "Makefile, Makefile.common: set, append")
+	acl("EXTRACT_OPTS_ZOO", lkShell, BtShellWord, "Makefile, Makefile.common: set, append")
+	pkg("EXTRACT_SUFX", lkNone, BtDistSuffix)
 	pkg("EXTRACT_USING", lkNone, enum("bsdtar gtar nbtar pax"))
-	sys("FAIL_MSG", lkNone, CheckvarShellCommand)
-	sys("FAMBASE", lkNone, CheckvarPathname)
+	sys("FAIL_MSG", lkNone, BtShellCommand)
+	sys("FAMBASE", lkNone, BtPathname)
 	pkg("FAM_ACCEPTED", lkShell, enum("fam gamin"))
 	usr("FAM_DEFAULT", lkNone, enum("fam gamin"))
 	sys("FAM_TYPE", lkNone, enum("fam gamin"))
-	acl("FETCH_BEFORE_ARGS", lkShell, CheckvarShellWord, "Makefile: set, append")
-	pkglist("FETCH_MESSAGE", lkShell, CheckvarShellWord)
-	pkg("FILESDIR", lkNone, CheckvarRelativePkgPath)
-	pkglist("FILES_SUBST", lkShell, CheckvarShellWord)
-	acl("FILES_SUBST_SED", lkShell, CheckvarShellWord, "")
-	pkglist("FIX_RPATH", lkShell, CheckvarVariableName)
-	pkglist("FLEX_REQD", lkShell, CheckvarVersion)
-	acl("FONTS_DIRS.*", lkShell, CheckvarPathname, "Makefile: set, append, use; Makefile.common: append, use")
-	sys("GAMEDATAMODE", lkNone, CheckvarFileMode)
-	sys("GAMES_GROUP", lkNone, CheckvarUserGroupName)
-	sys("GAMEMODE", lkNone, CheckvarFileMode)
-	sys("GAMES_USER", lkNone, CheckvarUserGroupName)
-	pkglist("GCC_REQD", lkShell, CheckvarVersion)
-	pkglist("GENERATE_PLIST", lkNone, CheckvarShellCommands)
-	pkg("GITHUB_PROJECT", lkNone, CheckvarIdentifier)
-	pkg("GITHUB_TAG", lkNone, CheckvarIdentifier)
-	pkg("GITHUB_RELEASE", lkNone, CheckvarFilename)
+	acl("FETCH_BEFORE_ARGS", lkShell, BtShellWord, "Makefile: set, append")
+	pkglist("FETCH_MESSAGE", lkShell, BtShellWord)
+	pkg("FILESDIR", lkNone, BtRelativePkgPath)
+	pkglist("FILES_SUBST", lkShell, BtShellWord)
+	acl("FILES_SUBST_SED", lkShell, BtShellWord, "")
+	pkglist("FIX_RPATH", lkShell, BtVariableName)
+	pkglist("FLEX_REQD", lkShell, BtVersion)
+	acl("FONTS_DIRS.*", lkShell, BtPathname, "Makefile: set, append, use; Makefile.common: append, use")
+	sys("GAMEDATAMODE", lkNone, BtFileMode)
+	sys("GAMES_GROUP", lkNone, BtUserGroupName)
+	sys("GAMEMODE", lkNone, BtFileMode)
+	sys("GAMES_USER", lkNone, BtUserGroupName)
+	pkglist("GCC_REQD", lkShell, BtVersion)
+	pkglist("GENERATE_PLIST", lkNone, BtShellCommands)
+	pkg("GITHUB_PROJECT", lkNone, BtIdentifier)
+	pkg("GITHUB_TAG", lkNone, BtIdentifier)
+	pkg("GITHUB_RELEASE", lkNone, BtFilename)
 	pkg("GITHUB_TYPE", lkNone, enum("tag release"))
-	pkg("GMAKE_REQD", lkNone, CheckvarVersion)
+	pkg("GMAKE_REQD", lkNone, BtVersion)
 	acl("GNU_ARCH", lkNone, enum("mips"), "")
-	acl("GNU_CONFIGURE", lkNone, CheckvarYes, "Makefile, Makefile.common: set")
-	acl("GNU_CONFIGURE_INFODIR", lkNone, CheckvarPathname, "Makefile, Makefile.common: set")
-	acl("GNU_CONFIGURE_LIBDIR", lkNone, CheckvarPathname, "Makefile, Makefile.common: set")
-	pkg("GNU_CONFIGURE_LIBSUBDIR", lkNone, CheckvarPathname)
-	acl("GNU_CONFIGURE_MANDIR", lkNone, CheckvarPathname, "Makefile, Makefile.common: set")
-	acl("GNU_CONFIGURE_PREFIX", lkNone, CheckvarPathname, "Makefile: set")
-	acl("HAS_CONFIGURE", lkNone, CheckvarYes, "Makefile, Makefile.common: set")
-	pkglist("HEADER_TEMPLATES", lkShell, CheckvarPathname)
-	pkg("HOMEPAGE", lkNone, CheckvarHomepage)
-	acl("IGNORE_PKG.*", lkNone, CheckvarYes, "*: set, use-loadtime")
-	acl("INCOMPAT_CURSES", lkSpace, CheckvarMachinePlatformPattern, "Makefile: set, append")
-	acl("INCOMPAT_ICONV", lkSpace, CheckvarMachinePlatformPattern, "")
-	acl("INFO_DIR", lkNone, CheckvarPathname, "") // relative to PREFIX
-	pkg("INFO_FILES", lkNone, CheckvarYes)
-	sys("INSTALL", lkNone, CheckvarShellCommand)
-	pkglist("INSTALLATION_DIRS", lkShell, CheckvarPrefixPathname)
-	pkg("INSTALLATION_DIRS_FROM_PLIST", lkNone, CheckvarYes)
-	sys("INSTALL_DATA", lkNone, CheckvarShellCommand)
-	sys("INSTALL_DATA_DIR", lkNone, CheckvarShellCommand)
-	pkglist("INSTALL_DIRS", lkShell, CheckvarWrksrcSubdirectory)
-	pkglist("INSTALL_ENV", lkShell, CheckvarShellWord)
-	acl("INSTALL_FILE", lkNone, CheckvarPathname, "Makefile: set")
-	sys("INSTALL_GAME", lkNone, CheckvarShellCommand)
-	sys("INSTALL_GAME_DATA", lkNone, CheckvarShellCommand)
-	sys("INSTALL_LIB", lkNone, CheckvarShellCommand)
-	sys("INSTALL_LIB_DIR", lkNone, CheckvarShellCommand)
-	pkglist("INSTALL_MAKE_FLAGS", lkShell, CheckvarShellWord)
-	sys("INSTALL_MAN", lkNone, CheckvarShellCommand)
-	sys("INSTALL_MAN_DIR", lkNone, CheckvarShellCommand)
-	sys("INSTALL_PROGRAM", lkNone, CheckvarShellCommand)
-	sys("INSTALL_PROGRAM_DIR", lkNone, CheckvarShellCommand)
-	sys("INSTALL_SCRIPT", lkNone, CheckvarShellCommand)
-	acl("INSTALL_SCRIPTS_ENV", lkShell, CheckvarShellWord, "")
-	sys("INSTALL_SCRIPT_DIR", lkNone, CheckvarShellCommand)
-	acl("INSTALL_SRC", lkShell, CheckvarPathname, "Makefile: set; Makefile.common: default, set")
-	pkg("INSTALL_TARGET", lkShell, CheckvarIdentifier)
-	acl("INSTALL_TEMPLATES", lkShell, CheckvarPathname, "Makefile: set, append; Makefile.common: set, default, append")
-	acl("INSTALL_UNSTRIPPED", lkNone, CheckvarYesNo, "Makefile, Makefile.common: set")
+	acl("GNU_CONFIGURE", lkNone, BtYes, "Makefile, Makefile.common: set")
+	acl("GNU_CONFIGURE_INFODIR", lkNone, BtPathname, "Makefile, Makefile.common: set")
+	acl("GNU_CONFIGURE_LIBDIR", lkNone, BtPathname, "Makefile, Makefile.common: set")
+	pkg("GNU_CONFIGURE_LIBSUBDIR", lkNone, BtPathname)
+	acl("GNU_CONFIGURE_MANDIR", lkNone, BtPathname, "Makefile, Makefile.common: set")
+	acl("GNU_CONFIGURE_PREFIX", lkNone, BtPathname, "Makefile: set")
+	acl("HAS_CONFIGURE", lkNone, BtYes, "Makefile, Makefile.common: set")
+	pkglist("HEADER_TEMPLATES", lkShell, BtPathname)
+	pkg("HOMEPAGE", lkNone, BtHomepage)
+	acl("IGNORE_PKG.*", lkNone, BtYes, "*: set, use-loadtime")
+	acl("INCOMPAT_CURSES", lkSpace, BtMachinePlatformPattern, "Makefile: set, append")
+	acl("INCOMPAT_ICONV", lkSpace, BtMachinePlatformPattern, "")
+	acl("INFO_DIR", lkNone, BtPathname, "") // relative to PREFIX
+	pkg("INFO_FILES", lkNone, BtYes)
+	sys("INSTALL", lkNone, BtShellCommand)
+	pkglist("INSTALLATION_DIRS", lkShell, BtPrefixPathname)
+	pkg("INSTALLATION_DIRS_FROM_PLIST", lkNone, BtYes)
+	sys("INSTALL_DATA", lkNone, BtShellCommand)
+	sys("INSTALL_DATA_DIR", lkNone, BtShellCommand)
+	pkglist("INSTALL_DIRS", lkShell, BtWrksrcSubdirectory)
+	pkglist("INSTALL_ENV", lkShell, BtShellWord)
+	acl("INSTALL_FILE", lkNone, BtPathname, "Makefile: set")
+	sys("INSTALL_GAME", lkNone, BtShellCommand)
+	sys("INSTALL_GAME_DATA", lkNone, BtShellCommand)
+	sys("INSTALL_LIB", lkNone, BtShellCommand)
+	sys("INSTALL_LIB_DIR", lkNone, BtShellCommand)
+	pkglist("INSTALL_MAKE_FLAGS", lkShell, BtShellWord)
+	sys("INSTALL_MAN", lkNone, BtShellCommand)
+	sys("INSTALL_MAN_DIR", lkNone, BtShellCommand)
+	sys("INSTALL_PROGRAM", lkNone, BtShellCommand)
+	sys("INSTALL_PROGRAM_DIR", lkNone, BtShellCommand)
+	sys("INSTALL_SCRIPT", lkNone, BtShellCommand)
+	acl("INSTALL_SCRIPTS_ENV", lkShell, BtShellWord, "")
+	sys("INSTALL_SCRIPT_DIR", lkNone, BtShellCommand)
+	acl("INSTALL_SRC", lkShell, BtPathname, "Makefile: set; Makefile.common: default, set")
+	pkg("INSTALL_TARGET", lkShell, BtIdentifier)
+	acl("INSTALL_TEMPLATES", lkShell, BtPathname, "Makefile: set, append; Makefile.common: set, default, append")
+	acl("INSTALL_UNSTRIPPED", lkNone, BtYesNo, "Makefile, Makefile.common: set")
 	pkg("INTERACTIVE_STAGE", lkShell, enum("fetch extract configure build test install"))
-	acl("IS_BUILTIN.*", lkNone, CheckvarYesNoIndirectly, "builtin.mk: set, use-loadtime, use")
-	sys("JAVA_BINPREFIX", lkNone, CheckvarPathname)
-	pkg("JAVA_CLASSPATH", lkNone, CheckvarShellWord)
-	pkg("JAVA_HOME", lkNone, CheckvarPathname)
-	pkg("JAVA_NAME", lkNone, CheckvarFilename)
+	acl("IS_BUILTIN.*", lkNone, BtYesNoIndirectly, "builtin.mk: set, use-loadtime, use")
+	sys("JAVA_BINPREFIX", lkNone, BtPathname)
+	pkg("JAVA_CLASSPATH", lkNone, BtShellWord)
+	pkg("JAVA_HOME", lkNone, BtPathname)
+	pkg("JAVA_NAME", lkNone, BtFilename)
 	pkglist("JAVA_UNLIMIT", lkShell, enum("cmdsize datasize stacksize"))
-	pkglist("JAVA_WRAPPERS", lkSpace, CheckvarFilename)
-	pkg("JAVA_WRAPPER_BIN.*", lkNone, CheckvarPathname)
-	sys("KRB5BASE", lkNone, CheckvarPathname)
+	pkglist("JAVA_WRAPPERS", lkSpace, BtFilename)
+	pkg("JAVA_WRAPPER_BIN.*", lkNone, BtPathname)
+	sys("KRB5BASE", lkNone, BtPathname)
 	acl("KRB5_ACCEPTED", lkShell, enum("heimdal mit-krb5"), "")
 	usr("KRB5_DEFAULT", lkNone, enum("heimdal mit-krb5"))
-	sys("KRB5_TYPE", lkNone, CheckvarIdentifier)
-	sys("LD", lkNone, CheckvarShellCommand)
-	pkglist("LDFLAGS", lkShell, CheckvarLdFlag)
-	pkglist("LDFLAGS.*", lkShell, CheckvarLdFlag)
-	sys("LIBGRP", lkNone, CheckvarUserGroupName)
-	sys("LIBMODE", lkNone, CheckvarFileMode)
-	sys("LIBOWN", lkNone, CheckvarUserGroupName)
-	sys("LIBOSSAUDIO", lkNone, CheckvarPathname)
-	pkglist("LIBS", lkShell, CheckvarLdFlag)
-	pkglist("LIBS.*", lkShell, CheckvarLdFlag)
-	sys("LIBTOOL", lkNone, CheckvarShellCommand)
-	acl("LIBTOOL_OVERRIDE", lkShell, CheckvarPathmask, "Makefile: set, append")
-	pkglist("LIBTOOL_REQD", lkShell, CheckvarVersion)
-	acl("LICENCE", lkNone, CheckvarLicense, "Makefile, Makefile.common, options.mk: set")
-	acl("LICENSE", lkNone, CheckvarLicense, "Makefile, Makefile.common, options.mk: set")
-	pkg("LICENSE_FILE", lkNone, CheckvarPathname)
-	sys("LINKER_RPATH_FLAG", lkNone, CheckvarShellWord)
-	sys("LOWER_OPSYS", lkNone, CheckvarIdentifier)
-	sys("LOWER_VENDOR", lkNone, CheckvarIdentifier)
-	acl("LTCONFIG_OVERRIDE", lkShell, CheckvarPathmask, "Makefile: set, append; Makefile.common: append")
+	sys("KRB5_TYPE", lkNone, BtIdentifier)
+	sys("LD", lkNone, BtShellCommand)
+	pkglist("LDFLAGS", lkShell, BtLdFlag)
+	pkglist("LDFLAGS.*", lkShell, BtLdFlag)
+	sys("LIBGRP", lkNone, BtUserGroupName)
+	sys("LIBMODE", lkNone, BtFileMode)
+	sys("LIBOWN", lkNone, BtUserGroupName)
+	sys("LIBOSSAUDIO", lkNone, BtPathname)
+	pkglist("LIBS", lkShell, BtLdFlag)
+	pkglist("LIBS.*", lkShell, BtLdFlag)
+	sys("LIBTOOL", lkNone, BtShellCommand)
+	acl("LIBTOOL_OVERRIDE", lkShell, BtPathmask, "Makefile: set, append")
+	pkglist("LIBTOOL_REQD", lkShell, BtVersion)
+	acl("LICENCE", lkNone, BtLicense, "Makefile, Makefile.common, options.mk: set, append")
+	acl("LICENSE", lkNone, BtLicense, "Makefile, Makefile.common, options.mk: set, append")
+	pkg("LICENSE_FILE", lkNone, BtPathname)
+	sys("LINKER_RPATH_FLAG", lkNone, BtShellWord)
+	sys("LOWER_OPSYS", lkNone, BtIdentifier)
+	sys("LOWER_VENDOR", lkNone, BtIdentifier)
+	acl("LTCONFIG_OVERRIDE", lkShell, BtPathmask, "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, CheckvarVariableName, "buildlink3.mk, builtin.mk, hacks.mk: append")
-	pkglist("MAKE_DIRS", lkShell, CheckvarPathname)
-	pkglist("MAKE_DIRS_PERMS", lkShell, CheckvarPerms)
-	acl("MAKE_ENV", lkShell, CheckvarShellWord, "Makefile, Makefile.common: append, set, use; buildlink3.mk, builtin.mk: append; *.mk: append, use")
-	acl("MAKE_ENV.*", lkShell, CheckvarShellWord, "Makefile, Makefile.common: append, set, use; buildlink3.mk, builtin.mk: append; *.mk: append, use")
-	pkg("MAKE_FILE", lkNone, CheckvarPathname)
-	pkglist("MAKE_FLAGS", lkShell, CheckvarShellWord)
-	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)
-	sys("MASTER_SITE_BACKUP", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_CYGWIN", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_DEBIAN", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_FREEBSD", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_FREEBSD_LOCAL", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_GENTOO", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_GITHUB", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_GNOME", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_GNU", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_GNUSTEP", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_IFARCHIVE", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_HASKELL_HACKAGE", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_KDE", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_LOCAL", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_MOZILLA", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_MOZILLA_ALL", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_MOZILLA_ESR", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_MYSQL", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_NETLIB", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_OPENOFFICE", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_OSDN", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_PERL_CPAN", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_R_CRAN", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_RUBYGEMS", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_SOURCEFORGE", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_SUNSITE", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_SUSE", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_TEX_CTAN", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_XCONTRIB", lkShell, CheckvarFetchURL)
-	sys("MASTER_SITE_XEMACS", lkShell, CheckvarFetchURL)
-	pkglist("MESSAGE_SRC", lkShell, CheckvarPathname)
-	acl("MESSAGE_SUBST", lkShell, CheckvarShellWord, "Makefile, Makefile.common, options.mk: append")
-	pkg("META_PACKAGE", lkNone, CheckvarYes)
-	sys("MISSING_FEATURES", lkShell, CheckvarIdentifier)
+	sys("MACHINE_GNU_PLATFORM", lkNone, BtMachineGnuPlatform)
+	sys("MACHINE_PLATFORM", lkNone, BtMachinePlatform)
+	acl("MAINTAINER", lkNone, BtMailAddress, "Makefile: set; Makefile.common: default")
+	sys("MAKE", lkNone, BtShellCommand)
+	pkglist("MAKEFLAGS", lkShell, BtShellWord)
+	acl("MAKEVARS", lkShell, BtVariableName, "buildlink3.mk, builtin.mk, hacks.mk: append")
+	pkglist("MAKE_DIRS", lkShell, BtPathname)
+	pkglist("MAKE_DIRS_PERMS", lkShell, BtPerms)
+	acl("MAKE_ENV", lkShell, BtShellWord, "Makefile, Makefile.common: append, set, use; buildlink3.mk, builtin.mk: append; *.mk: append, use")
+	acl("MAKE_ENV.*", lkShell, BtShellWord, "Makefile, Makefile.common: append, set, use; buildlink3.mk, builtin.mk: append; *.mk: append, use")
+	pkg("MAKE_FILE", lkNone, BtPathname)
+	pkglist("MAKE_FLAGS", lkShell, BtShellWord)
+	pkglist("MAKE_FLAGS.*", lkShell, BtShellWord)
+	usr("MAKE_JOBS", lkNone, BtInteger)
+	pkg("MAKE_JOBS_SAFE", lkNone, BtYesNo)
+	pkg("MAKE_PROGRAM", lkNone, BtShellCommand)
+	acl("MANCOMPRESSED", lkNone, BtYesNo, "Makefile: set; Makefile.common: default, set")
+	acl("MANCOMPRESSED_IF_MANZ", lkNone, BtYes, "Makefile: set; Makefile.common: default, set")
+	sys("MANGRP", lkNone, BtUserGroupName)
+	sys("MANMODE", lkNone, BtFileMode)
+	sys("MANOWN", lkNone, BtUserGroupName)
+	pkglist("MASTER_SITES", lkShell, BtFetchURL)
+	sys("MASTER_SITE_APACHE", lkShell, BtFetchURL)
+	sys("MASTER_SITE_BACKUP", lkShell, BtFetchURL)
+	sys("MASTER_SITE_CYGWIN", lkShell, BtFetchURL)
+	sys("MASTER_SITE_DEBIAN", lkShell, BtFetchURL)
+	sys("MASTER_SITE_FREEBSD", lkShell, BtFetchURL)
+	sys("MASTER_SITE_FREEBSD_LOCAL", lkShell, BtFetchURL)
+	sys("MASTER_SITE_GENTOO", lkShell, BtFetchURL)
+	sys("MASTER_SITE_GITHUB", lkShell, BtFetchURL)
+	sys("MASTER_SITE_GNOME", lkShell, BtFetchURL)
+	sys("MASTER_SITE_GNU", lkShell, BtFetchURL)
+	sys("MASTER_SITE_GNUSTEP", lkShell, BtFetchURL)
+	sys("MASTER_SITE_IFARCHIVE", lkShell, BtFetchURL)
+	sys("MASTER_SITE_HASKELL_HACKAGE", lkShell, BtFetchURL)
+	sys("MASTER_SITE_KDE", lkShell, BtFetchURL)
+	sys("MASTER_SITE_LOCAL", lkShell, BtFetchURL)
+	sys("MASTER_SITE_MOZILLA", lkShell, BtFetchURL)
+	sys("MASTER_SITE_MOZILLA_ALL", lkShell, BtFetchURL)
+	sys("MASTER_SITE_MOZILLA_ESR", lkShell, BtFetchURL)
+	sys("MASTER_SITE_MYSQL", lkShell, BtFetchURL)
+	sys("MASTER_SITE_NETLIB", lkShell, BtFetchURL)
+	sys("MASTER_SITE_OPENOFFICE", lkShell, BtFetchURL)
+	sys("MASTER_SITE_OSDN", lkShell, BtFetchURL)
+	sys("MASTER_SITE_PERL_CPAN", lkShell, BtFetchURL)
+	sys("MASTER_SITE_R_CRAN", lkShell, BtFetchURL)
+	sys("MASTER_SITE_RUBYGEMS", lkShell, BtFetchURL)
+	sys("MASTER_SITE_SOURCEFORGE", lkShell, BtFetchURL)
+	sys("MASTER_SITE_SUNSITE", lkShell, BtFetchURL)
+	sys("MASTER_SITE_SUSE", lkShell, BtFetchURL)
+	sys("MASTER_SITE_TEX_CTAN", lkShell, BtFetchURL)
+	sys("MASTER_SITE_XCONTRIB", lkShell, BtFetchURL)
+	sys("MASTER_SITE_XEMACS", lkShell, BtFetchURL)
+	pkglist("MESSAGE_SRC", lkShell, BtPathname)
+	acl("MESSAGE_SUBST", lkShell, BtShellWord, "Makefile, Makefile.common, options.mk: append")
+	pkg("META_PACKAGE", lkNone, BtYes)
+	sys("MISSING_FEATURES", lkShell, BtIdentifier)
 	acl("MYSQL_VERSIONS_ACCEPTED", lkShell, enum("51 55 56"), "Makefile: set")
-	usr("MYSQL_VERSION_DEFAULT", lkNone, CheckvarVersion)
-	sys("NM", lkNone, CheckvarShellCommand)
-	sys("NONBINMODE", lkNone, CheckvarFileMode)
+	usr("MYSQL_VERSION_DEFAULT", lkNone, BtVersion)
+	sys("NM", lkNone, BtShellCommand)
+	sys("NONBINMODE", lkNone, BtFileMode)
 	pkg("NOT_FOR_COMPILER", lkShell, enum("ccache ccc clang distcc f2c gcc hp icc ido mipspro mipspro-ucode pcc sunpro xlc"))
-	pkglist("NOT_FOR_BULK_PLATFORM", lkSpace, CheckvarMachinePlatformPattern)
-	pkglist("NOT_FOR_PLATFORM", lkSpace, CheckvarMachinePlatformPattern)
-	pkg("NOT_FOR_UNPRIVILEGED", lkNone, CheckvarYesNo)
-	acl("NO_BIN_ON_CDROM", lkNone, CheckvarRestricted, "Makefile, Makefile.common: set")
-	acl("NO_BIN_ON_FTP", lkNone, CheckvarRestricted, "Makefile, Makefile.common: set")
-	acl("NO_BUILD", lkNone, CheckvarYes, "Makefile, Makefile.common: set; Makefile.*: default, set")
-	pkg("NO_CHECKSUM", lkNone, CheckvarYes)
-	pkg("NO_CONFIGURE", lkNone, CheckvarYes)
-	acl("NO_EXPORT_CPP", lkNone, CheckvarYes, "Makefile: set")
-	pkg("NO_EXTRACT", lkNone, CheckvarYes)
-	pkg("NO_INSTALL_MANPAGES", lkNone, CheckvarYes) // only has an effect for Imake packages.
-	acl("NO_PKGTOOLS_REQD_CHECK", lkNone, CheckvarYes, "Makefile: set")
-	acl("NO_SRC_ON_CDROM", lkNone, CheckvarRestricted, "Makefile, Makefile.common: set")
-	acl("NO_SRC_ON_FTP", lkNone, CheckvarRestricted, "Makefile, Makefile.common: set")
+	pkglist("NOT_FOR_BULK_PLATFORM", lkSpace, BtMachinePlatformPattern)
+	pkglist("NOT_FOR_PLATFORM", lkSpace, BtMachinePlatformPattern)
+	pkg("NOT_FOR_UNPRIVILEGED", lkNone, BtYesNo)
+	acl("NO_BIN_ON_CDROM", lkNone, BtRestricted, "Makefile, Makefile.common: set")
+	acl("NO_BIN_ON_FTP", lkNone, BtRestricted, "Makefile, Makefile.common: set")
+	acl("NO_BUILD", lkNone, BtYes, "Makefile, Makefile.common: set; Makefile.*: default, set")
+	pkg("NO_CHECKSUM", lkNone, BtYes)
+	pkg("NO_CONFIGURE", lkNone, BtYes)
+	acl("NO_EXPORT_CPP", lkNone, BtYes, "Makefile: set")
+	pkg("NO_EXTRACT", lkNone, BtYes)
+	pkg("NO_INSTALL_MANPAGES", lkNone, BtYes) // only has an effect for Imake packages.
+	acl("NO_PKGTOOLS_REQD_CHECK", lkNone, BtYes, "Makefile: set")
+	acl("NO_SRC_ON_CDROM", lkNone, BtRestricted, "Makefile, Makefile.common: set")
+	acl("NO_SRC_ON_FTP", lkNone, BtRestricted, "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, CheckvarVariableName, "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, CheckvarPerms)
-	sys("PAMBASE", lkNone, CheckvarPathname)
+	pkglist("ONLY_FOR_PLATFORM", lkSpace, BtMachinePlatformPattern)
+	pkg("ONLY_FOR_UNPRIVILEGED", lkNone, BtYesNo)
+	sys("OPSYS", lkNone, BtIdentifier)
+	acl("OPSYSVARS", lkShell, BtVariableName, "Makefile, Makefile.common: append")
+	acl("OSVERSION_SPECIFIC", lkNone, BtYes, "Makefile, Makefile.common: set")
+	sys("OS_VERSION", lkNone, BtVersion)
+	pkg("OVERRIDE_DIRDEPTH*", lkNone, BtInteger)
+	pkg("OVERRIDE_GNU_CONFIG_SCRIPTS", lkNone, BtYes)
+	acl("OWNER", lkNone, BtMailAddress, "Makefile: set; Makefile.common: default")
+	pkglist("OWN_DIRS", lkShell, BtPathname)
+	pkglist("OWN_DIRS_PERMS", lkShell, BtPerms)
+	sys("PAMBASE", lkNone, BtPathname)
 	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, "buildlink3.mk, builtin.mk:; Makefile, Makefile.common, *.mk: set")
-	acl("PATCH_SITES", lkShell, CheckvarFetchURL, "Makefile, Makefile.common, options.mk: set")
-	acl("PATCH_STRIP", lkNone, CheckvarShellWord, "")
-	acl("PERL5_PACKLIST", lkShell, CheckvarPerl5Packlist, "Makefile: set; options.mk: set, append")
-	acl("PERL5_PACKLIST_DIR", lkNone, CheckvarPathname, "")
-	pkg("PERL5_REQD", lkShell, CheckvarVersion)
-	pkg("PERL5_USE_PACKLIST", lkNone, CheckvarYesNo)
-	sys("PGSQL_PREFIX", lkNone, CheckvarPathname)
+	acl("PATCHDIR", lkNone, BtRelativePkgPath, "Makefile: set; Makefile.common: default, set")
+	pkglist("PATCHFILES", lkShell, BtFilename)
+	acl("PATCH_ARGS", lkShell, BtShellWord, "")
+	acl("PATCH_DIST_ARGS", lkShell, BtShellWord, "Makefile: set, append")
+	acl("PATCH_DIST_CAT", lkNone, BtShellCommand, "")
+	acl("PATCH_DIST_STRIP*", lkNone, BtShellWord, "buildlink3.mk, builtin.mk:; Makefile, Makefile.common, *.mk: set")
+	acl("PATCH_SITES", lkShell, BtFetchURL, "Makefile, Makefile.common, options.mk: set")
+	acl("PATCH_STRIP", lkNone, BtShellWord, "")
+	acl("PERL5_PACKLIST", lkShell, BtPerl5Packlist, "Makefile: set; options.mk: set, append")
+	acl("PERL5_PACKLIST_DIR", lkNone, BtPathname, "")
+	pkg("PERL5_REQD", lkShell, BtVersion)
+	pkg("PERL5_USE_PACKLIST", lkNone, BtYesNo)
+	sys("PGSQL_PREFIX", lkNone, BtPathname)
 	acl("PGSQL_VERSIONS_ACCEPTED", lkShell, enum("91 92 93 94"), "")
-	usr("PGSQL_VERSION_DEFAULT", lkNone, CheckvarVersion)
+	usr("PGSQL_VERSION_DEFAULT", lkNone, BtVersion)
 	sys("PG_LIB_EXT", lkNone, enum("dylib so"))
 	sys("PGSQL_TYPE", lkNone, enum("postgresql81-client postgresql80-client"))
-	sys("PGPKGSRCDIR", lkNone, CheckvarPathname)
-	sys("PHASE_MSG", lkNone, CheckvarShellCommand)
-	usr("PHP_VERSION_REQD", lkNone, CheckvarVersion)
-	sys("PKGBASE", lkNone, CheckvarIdentifier)
-	acl("PKGCONFIG_FILE.*", lkShell, CheckvarPathname, "builtin.mk: set, append; pkgconfig-builtin.mk: use-loadtime")
-	acl("PKGCONFIG_OVERRIDE", lkShell, CheckvarPathmask, "Makefile: set, append; Makefile.common: append")
-	pkg("PKGCONFIG_OVERRIDE_STAGE", lkNone, CheckvarStage)
-	pkg("PKGDIR", lkNone, CheckvarRelativePkgDir)
-	sys("PKGDIRMODE", lkNone, CheckvarFileMode)
-	sys("PKGLOCALEDIR", lkNone, CheckvarPathname)
-	pkg("PKGNAME", lkNone, CheckvarPkgName)
-	sys("PKGNAME_NOREV", lkNone, CheckvarPkgName)
-	sys("PKGPATH", lkNone, CheckvarPathname)
-	acl("PKGREPOSITORY", lkNone, CheckvarUnchecked, "")
-	acl("PKGREVISION", lkNone, CheckvarPkgRevision, "Makefile: set")
-	sys("PKGSRCDIR", lkNone, CheckvarPathname)
-	acl("PKGSRCTOP", lkNone, CheckvarYes, "Makefile: set")
-	acl("PKGTOOLS_ENV", lkShell, CheckvarShellWord, "")
-	sys("PKGVERSION", lkNone, CheckvarVersion)
-	sys("PKGWILDCARD", lkNone, CheckvarFilemask)
-	sys("PKG_ADMIN", lkNone, CheckvarShellCommand)
+	sys("PGPKGSRCDIR", lkNone, BtPathname)
+	sys("PHASE_MSG", lkNone, BtShellCommand)
+	usr("PHP_VERSION_REQD", lkNone, BtVersion)
+	sys("PKGBASE", lkNone, BtIdentifier)
+	acl("PKGCONFIG_FILE.*", lkShell, BtPathname, "builtin.mk: set, append; pkgconfig-builtin.mk: use-loadtime")
+	acl("PKGCONFIG_OVERRIDE", lkShell, BtPathmask, "Makefile: set, append; Makefile.common: append")
+	pkg("PKGCONFIG_OVERRIDE_STAGE", lkNone, BtStage)
+	pkg("PKGDIR", lkNone, BtRelativePkgDir)
+	sys("PKGDIRMODE", lkNone, BtFileMode)
+	sys("PKGLOCALEDIR", lkNone, BtPathname)
+	pkg("PKGNAME", lkNone, BtPkgName)
+	sys("PKGNAME_NOREV", lkNone, BtPkgName)
+	sys("PKGPATH", lkNone, BtPathname)
+	acl("PKGREPOSITORY", lkNone, BtUnknown, "")
+	acl("PKGREVISION", lkNone, BtPkgRevision, "Makefile: set")
+	sys("PKGSRCDIR", lkNone, BtPathname)
+	acl("PKGSRCTOP", lkNone, BtYes, "Makefile: set")
+	acl("PKGTOOLS_ENV", lkShell, BtShellWord, "")
+	sys("PKGVERSION", lkNone, BtVersion)
+	sys("PKGWILDCARD", lkNone, BtFilemask)
+	sys("PKG_ADMIN", lkNone, BtShellCommand)
 	sys("PKG_APACHE", lkNone, enum("apache22 apache24"))
 	pkg("PKG_APACHE_ACCEPTED", lkShell, enum("apache22 apache24"))
 	usr("PKG_APACHE_DEFAULT", lkNone, enum("apache22 apache24"))
-	usr("PKG_CONFIG", lkNone, CheckvarYes)
+	usr("PKG_CONFIG", lkNone, BtYes)
 	// ^^ No, this is not the popular command from GNOME, but the setting
 	// whether the pkgsrc user wants configuration files automatically
 	// installed or not.
-	sys("PKG_CREATE", lkNone, CheckvarShellCommand)
-	sys("PKG_DBDIR", lkNone, CheckvarPathname)
-	cmdline("PKG_DEBUG_LEVEL", lkNone, CheckvarInteger)
-	usr("PKG_DEFAULT_OPTIONS", lkShell, CheckvarOption)
-	sys("PKG_DELETE", lkNone, CheckvarShellCommand)
+	sys("PKG_CREATE", lkNone, BtShellCommand)
+	sys("PKG_DBDIR", lkNone, BtPathname)
+	cmdline("PKG_DEBUG_LEVEL", lkNone, BtInteger)
+	usr("PKG_DEFAULT_OPTIONS", lkShell, BtOption)
+	sys("PKG_DELETE", lkNone, BtShellCommand)
 	acl("PKG_DESTDIR_SUPPORT", lkShell, enum("destdir user-destdir"), "Makefile, Makefile.common: set")
-	pkglist("PKG_FAIL_REASON", lkShell, CheckvarShellWord)
-	acl("PKG_GECOS.*", lkNone, CheckvarMessage, "Makefile: set")
-	acl("PKG_GID.*", lkNone, CheckvarInteger, "Makefile: set")
-	acl("PKG_GROUPS", lkShell, CheckvarShellWord, "Makefile: set, append")
-	pkglist("PKG_GROUPS_VARS", lkShell, CheckvarVariableName)
-	acl("PKG_HOME.*", lkNone, CheckvarPathname, "Makefile: set")
-	acl("PKG_HACKS", lkShell, CheckvarIdentifier, "hacks.mk: append")
-	sys("PKG_INFO", lkNone, CheckvarShellCommand)
-	sys("PKG_JAVA_HOME", lkNone, CheckvarPathname)
+	pkglist("PKG_FAIL_REASON", lkShell, BtShellWord)
+	acl("PKG_GECOS.*", lkNone, BtMessage, "Makefile: set")
+	acl("PKG_GID.*", lkNone, BtInteger, "Makefile: set")
+	acl("PKG_GROUPS", lkShell, BtShellWord, "Makefile: set, append")
+	pkglist("PKG_GROUPS_VARS", lkShell, BtVariableName)
+	acl("PKG_HOME.*", lkNone, BtPathname, "Makefile: set")
+	acl("PKG_HACKS", lkShell, BtIdentifier, "hacks.mk: append")
+	sys("PKG_INFO", lkNone, BtShellCommand)
+	sys("PKG_JAVA_HOME", lkNone, BtPathname)
 	jvms := enum("openjdk8 oracle-jdk8 openjdk7 sun-jdk7 sun-jdk6 jdk16 jdk15 kaffe") // See mk/java-vm.mk:/_PKG_JVMS/
 	sys("PKG_JVM", lkNone, jvms)
 	acl("PKG_JVMS_ACCEPTED", lkShell, jvms, "Makefile: set; Makefile.common: default, set")
 	usr("PKG_JVM_DEFAULT", lkNone, jvms)
-	acl("PKG_LEGACY_OPTIONS", lkShell, CheckvarOption, "")
-	acl("PKG_LIBTOOL", lkNone, CheckvarPathname, "Makefile: set")
-	acl("PKG_OPTIONS", lkSpace, CheckvarOption, "bsd.options.mk: set; *: use-loadtime, use")
-	usr("PKG_OPTIONS.*", lkSpace, CheckvarOption)
-	acl("PKG_OPTIONS_DEPRECATED_WARNINGS", lkShell, CheckvarShellWord, "")
-	acl("PKG_OPTIONS_GROUP.*", lkSpace, CheckvarOption, "Makefile, options.mk: set, append")
-	acl("PKG_OPTIONS_LEGACY_OPTS", lkSpace, CheckvarUnchecked, "Makefile, Makefile.common, options.mk: append")
-	acl("PKG_OPTIONS_LEGACY_VARS", lkSpace, CheckvarUnchecked, "Makefile, Makefile.common, options.mk: append")
-	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, "Makefile, options.mk: set")
-	acl("PKG_OPTIONS_SET.*", lkSpace, CheckvarOption, "")
-	acl("PKG_OPTIONS_VAR", lkNone, CheckvarPkgOptionsVar, "Makefile, Makefile.common, options.mk: 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, "Makefile, Makefile.common, options.mk: set, append")
-	acl("PKG_SUGGESTED_OPTIONS.*", lkShell, CheckvarOption, "Makefile, Makefile.common, options.mk: set, append")
-	acl("PKG_SUPPORTED_OPTIONS", lkShell, CheckvarOption, "Makefile: set, append; Makefile.common: set; options.mk: set, append, use")
-	pkg("PKG_SYSCONFDIR*", lkNone, CheckvarPathname)
-	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, CheckvarVariableName)
-	acl("PKG_USE_KERBEROS", lkNone, CheckvarYes, "Makefile, Makefile.common: set")
+	acl("PKG_LEGACY_OPTIONS", lkShell, BtOption, "")
+	acl("PKG_LIBTOOL", lkNone, BtPathname, "Makefile: set")
+	acl("PKG_OPTIONS", lkSpace, BtOption, "bsd.options.mk: set; *: use-loadtime, use")
+	usr("PKG_OPTIONS.*", lkSpace, BtOption)
+	acl("PKG_OPTIONS_DEPRECATED_WARNINGS", lkShell, BtShellWord, "")
+	acl("PKG_OPTIONS_GROUP.*", lkSpace, BtOption, "Makefile, options.mk: set, append")
+	acl("PKG_OPTIONS_LEGACY_OPTS", lkSpace, BtUnknown, "Makefile, Makefile.common, options.mk: append")
+	acl("PKG_OPTIONS_LEGACY_VARS", lkSpace, BtUnknown, "Makefile, Makefile.common, options.mk: append")
+	acl("PKG_OPTIONS_NONEMPTY_SETS", lkSpace, BtIdentifier, "")
+	acl("PKG_OPTIONS_OPTIONAL_GROUPS", lkSpace, BtIdentifier, "options.mk: set, append")
+	acl("PKG_OPTIONS_REQUIRED_GROUPS", lkSpace, BtIdentifier, "Makefile, options.mk: set")
+	acl("PKG_OPTIONS_SET.*", lkSpace, BtOption, "")
+	acl("PKG_OPTIONS_VAR", lkNone, BtPkgOptionsVar, "Makefile, Makefile.common, options.mk: set; bsd.options.mk: use-loadtime")
+	acl("PKG_PRESERVE", lkNone, BtYes, "Makefile: set")
+	acl("PKG_SHELL", lkNone, BtPathname, "Makefile, Makefile.common: set")
+	acl("PKG_SHELL.*", lkNone, BtPathname, "Makefile, Makefile.common: set")
+	acl("PKG_SHLIBTOOL", lkNone, BtPathname, "")
+	pkglist("PKG_SKIP_REASON", lkShell, BtShellWord)
+	acl("PKG_SUGGESTED_OPTIONS", lkShell, BtOption, "Makefile, Makefile.common, options.mk: set, append")
+	acl("PKG_SUGGESTED_OPTIONS.*", lkShell, BtOption, "Makefile, Makefile.common, options.mk: set, append")
+	acl("PKG_SUPPORTED_OPTIONS", lkShell, BtOption, "Makefile: set, append; Makefile.common: set; options.mk: set, append, use")
+	pkg("PKG_SYSCONFDIR*", lkNone, BtPathname)
+	pkglist("PKG_SYSCONFDIR_PERMS", lkShell, BtPerms)
+	sys("PKG_SYSCONFBASEDIR", lkNone, BtPathname)
+	pkg("PKG_SYSCONFSUBDIR", lkNone, BtPathname)
+	acl("PKG_SYSCONFVAR", lkNone, BtIdentifier, "") // FIXME: name/type mismatch.
+	acl("PKG_UID", lkNone, BtInteger, "Makefile: set")
+	acl("PKG_USERS", lkShell, BtShellWord, "Makefile: set, append")
+	pkg("PKG_USERS_VARS", lkShell, BtVariableName)
+	acl("PKG_USE_KERBEROS", lkNone, BtYes, "Makefile, Makefile.common: set")
 	// PLIST.* has special handling code
-	pkglist("PLIST_VARS", lkShell, CheckvarIdentifier)
-	pkglist("PLIST_SRC", lkShell, CheckvarRelativePkgPath)
-	pkglist("PLIST_SUBST", lkShell, CheckvarShellWord)
+	pkglist("PLIST_VARS", lkShell, BtIdentifier)
+	pkglist("PLIST_SRC", lkShell, BtRelativePkgPath)
+	pkglist("PLIST_SUBST", lkShell, BtShellWord)
 	acl("PLIST_TYPE", lkNone, enum("dynamic static"), "")
-	acl("PREPEND_PATH", lkShell, CheckvarPathname, "")
-	acl("PREFIX", lkNone, CheckvarPathname, "*: use")
-	acl("PREV_PKGPATH", lkNone, CheckvarPathname, "*: use") // doesn't exist any longer
-	acl("PRINT_PLIST_AWK", lkNone, CheckvarAwkCommand, "*: append")
+	acl("PREPEND_PATH", lkShell, BtPathname, "")
+	acl("PREFIX", lkNone, BtPathname, "*: use")
+	acl("PREV_PKGPATH", lkNone, BtPathname, "*: use") // doesn't exist any longer
+	acl("PRINT_PLIST_AWK", lkNone, BtAwkCommand, "*: append")
 	acl("PRIVILEGED_STAGES", lkShell, enum("install package clean"), "")
-	acl("PTHREAD_AUTO_VARS", lkNone, CheckvarYesNo, "Makefile: set")
-	sys("PTHREAD_CFLAGS", lkShell, CheckvarCFlag)
-	sys("PTHREAD_LDFLAGS", lkShell, CheckvarLdFlag)
-	sys("PTHREAD_LIBS", lkShell, CheckvarLdFlag)
+	acl("PTHREAD_AUTO_VARS", lkNone, BtYesNo, "Makefile: set")
+	sys("PTHREAD_CFLAGS", lkShell, BtCFlag)
+	sys("PTHREAD_LDFLAGS", lkShell, BtLdFlag)
+	sys("PTHREAD_LIBS", lkShell, BtLdFlag)
 	acl("PTHREAD_OPTS", lkShell, enum("native optional require"), "Makefile: set, append; Makefile.common, buildlink3.mk: append")
-	sys("PTHREAD_TYPE", lkNone, CheckvarIdentifier) // Or "native" or "none".
-	pkg("PY_PATCHPLIST", lkNone, CheckvarYes)
+	sys("PTHREAD_TYPE", lkNone, BtIdentifier) // Or "native" or "none".
+	pkg("PY_PATCHPLIST", lkNone, BtYes)
 	acl("PYPKGPREFIX", lkNone, enum("py27 py33 py34 py35"), "pyversion.mk: set; *: use-loadtime, use")
-	pkg("PYTHON_FOR_BUILD_ONLY", lkNone, CheckvarYes)
-	pkglist("REPLACE_PYTHON", lkShell, CheckvarPathmask)
-	pkg("PYTHON_VERSIONS_ACCEPTED", lkShell, CheckvarVersion)
-	pkg("PYTHON_VERSIONS_INCOMPATIBLE", lkShell, CheckvarVersion)
-	usr("PYTHON_VERSION_DEFAULT", lkNone, CheckvarVersion)
-	usr("PYTHON_VERSION_REQD", lkNone, CheckvarVersion)
-	pkglist("PYTHON_VERSIONED_DEPENDENCIES", lkShell, CheckvarPythonDependency)
-	sys("RANLIB", lkNone, CheckvarShellCommand)
-	pkglist("RCD_SCRIPTS", lkShell, CheckvarFilename)
-	acl("RCD_SCRIPT_SRC.*", lkNone, CheckvarPathname, "Makefile: set")
-	acl("RCD_SCRIPT_WRK.*", lkNone, CheckvarPathname, "Makefile: set")
-	acl("REPLACE.*", lkNone, CheckvarString, "Makefile: set")
-	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, CheckvarPerms)
-	pkglist("REQD_FILES", lkShell, CheckvarPathname)
+	pkg("PYTHON_FOR_BUILD_ONLY", lkNone, BtYes)
+	pkglist("REPLACE_PYTHON", lkShell, BtPathmask)
+	pkg("PYTHON_VERSIONS_ACCEPTED", lkShell, BtVersion)
+	pkg("PYTHON_VERSIONS_INCOMPATIBLE", lkShell, BtVersion)
+	usr("PYTHON_VERSION_DEFAULT", lkNone, BtVersion)
+	usr("PYTHON_VERSION_REQD", lkNone, BtVersion)
+	pkglist("PYTHON_VERSIONED_DEPENDENCIES", lkShell, BtPythonDependency)
+	sys("RANLIB", lkNone, BtShellCommand)
+	pkglist("RCD_SCRIPTS", lkShell, BtFilename)
+	acl("RCD_SCRIPT_SRC.*", lkNone, BtPathname, "Makefile: set")
+	acl("RCD_SCRIPT_WRK.*", lkNone, BtPathname, "Makefile: set")
+	acl("REPLACE.*", lkNone, BtUnknown, "Makefile: set")
+	pkglist("REPLACE_AWK", lkShell, BtPathmask)
+	pkglist("REPLACE_BASH", lkShell, BtPathmask)
+	pkglist("REPLACE_CSH", lkShell, BtPathmask)
+	acl("REPLACE_EMACS", lkShell, BtPathmask, "")
+	acl("REPLACE_FILES.*", lkShell, BtPathmask, "Makefile, Makefile.common: set, append")
+	acl("REPLACE_INTERPRETER", lkShell, BtIdentifier, "Makefile, Makefile.common: append")
+	pkglist("REPLACE_KSH", lkShell, BtPathmask)
+	pkglist("REPLACE_LOCALEDIR_PATTERNS", lkShell, BtFilemask)
+	pkglist("REPLACE_LUA", lkShell, BtPathmask)
+	pkglist("REPLACE_PERL", lkShell, BtPathmask)
+	pkglist("REPLACE_PYTHON", lkShell, BtPathmask)
+	pkglist("REPLACE_SH", lkShell, BtPathmask)
+	pkglist("REQD_DIRS", lkShell, BtPathname)
+	pkglist("REQD_DIRS_PERMS", lkShell, BtPerms)
+	pkglist("REQD_FILES", lkShell, BtPathname)
 	pkg("REQD_FILES_MODE", lkNone, enum("0644 0640 0600 0400"))
-	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)
-	pkg("SET_LIBDIR", lkNone, CheckvarYes)
-	sys("SHAREGRP", lkNone, CheckvarUserGroupName)
-	sys("SHAREMODE", lkNone, CheckvarFileMode)
-	sys("SHAREOWN", lkNone, CheckvarUserGroupName)
-	sys("SHCOMMENT", lkNone, CheckvarShellCommand)
+	pkglist("REQD_FILES_PERMS", lkShell, BtPerms)
+	pkg("RESTRICTED", lkNone, BtMessage)
+	usr("ROOT_USER", lkNone, BtUserGroupName)
+	usr("ROOT_GROUP", lkNone, BtUserGroupName)
+	usr("RUBY_VERSION_REQD", lkNone, BtVersion)
+	sys("RUN", lkNone, BtShellCommand)
+	sys("RUN_LDCONFIG", lkNone, BtYesNo)
+	acl("SCRIPTS_ENV", lkShell, BtShellWord, "Makefile, Makefile.common: append")
+	usr("SETUID_ROOT_PERMS", lkShell, BtShellWord)
+	pkg("SET_LIBDIR", lkNone, BtYes)
+	sys("SHAREGRP", lkNone, BtUserGroupName)
+	sys("SHAREMODE", lkNone, BtFileMode)
+	sys("SHAREOWN", lkNone, BtUserGroupName)
+	sys("SHCOMMENT", lkNone, BtShellCommand)
 	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")
-	usr("SMF_PREFIS", lkNone, CheckvarPathname)
-	pkg("SMF_SRCDIR", lkNone, CheckvarPathname)
-	pkg("SMF_NAME", lkNone, CheckvarFilename)
-	pkg("SMF_MANIFEST", lkNone, CheckvarPathname)
-	pkg("SMF_INSTANCES", lkShell, CheckvarIdentifier)
-	pkg("SMF_METHODS", lkShell, CheckvarFilename)
-	pkg("SMF_METHOD_SRC.*", lkNone, CheckvarPathname)
-	pkg("SMF_METHOD_SHELL", lkNone, CheckvarShellCommand)
-	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_CLASSES.*", lkShell, CheckvarIdentifier, "Makefile: set, append; *: append")
-	acl("SUBST_FILES.*", lkShell, CheckvarPathmask, "Makefile, 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, CheckvarVariableName)
-	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")
+	acl("SHLIBTOOL", lkNone, BtShellCommand, "Makefile: use")
+	acl("SHLIBTOOL_OVERRIDE", lkShell, BtPathmask, "Makefile: set, append; Makefile.common: append")
+	acl("SITES.*", lkShell, BtFetchURL, "Makefile, Makefile.common, options.mk: set, append, use")
+	usr("SMF_PREFIS", lkNone, BtPathname)
+	pkg("SMF_SRCDIR", lkNone, BtPathname)
+	pkg("SMF_NAME", lkNone, BtFilename)
+	pkg("SMF_MANIFEST", lkNone, BtPathname)
+	pkg("SMF_INSTANCES", lkShell, BtIdentifier)
+	pkg("SMF_METHODS", lkShell, BtFilename)
+	pkg("SMF_METHOD_SRC.*", lkNone, BtPathname)
+	pkg("SMF_METHOD_SHELL", lkNone, BtShellCommand)
+	pkglist("SPECIAL_PERMS", lkShell, BtPerms)
+	sys("STEP_MSG", lkNone, BtShellCommand)
+	acl("SUBDIR", lkShell, BtFilename, "Makefile: append; *:")
+	acl("SUBST_CLASSES", lkShell, BtIdentifier, "Makefile: set, append; *: append")
+	acl("SUBST_CLASSES.*", lkShell, BtIdentifier, "Makefile: set, append; *: append")
+	acl("SUBST_FILES.*", lkShell, BtPathmask, "Makefile, Makefile.*, *.mk: set, append")
+	acl("SUBST_FILTER_CMD.*", lkNone, BtShellCommand, "Makefile, Makefile.*, *.mk: set")
+	acl("SUBST_MESSAGE.*", lkNone, BtMessage, "Makefile, Makefile.*, *.mk: set")
+	acl("SUBST_SED.*", lkNone, BtSedCommands, "Makefile, Makefile.*, *.mk: set, append")
+	pkg("SUBST_STAGE.*", lkNone, BtStage)
+	pkglist("SUBST_VARS.*", lkShell, BtVariableName)
+	pkglist("SUPERSEDES", lkSpace, BtDependency)
+	pkglist("TEST_DIRS", lkShell, BtWrksrcSubdirectory)
+	pkglist("TEST_ENV", lkShell, BtShellWord)
+	acl("TEST_TARGET", lkShell, BtIdentifier, "Makefile: set; Makefile.common: default, set; options.mk: set, append")
 	acl("TEX_ACCEPTED", lkShell, enum("teTeX1 teTeX2 teTeX3"), "Makefile, Makefile.common: set")
 	acl("TEX_DEPMETHOD", lkNone, enum("build run"), "Makefile, Makefile.common: set")
-	pkglist("TEXINFO_REQD", lkShell, CheckvarVersion)
-	acl("TOOL_DEPENDS", lkSpace, CheckvarDependencyWithPath, "Makefile, Makefile.common, *.mk: append")
-	sys("TOOLS_ALIASES", lkShell, CheckvarFilename)
-	sys("TOOLS_BROKEN", lkShell, CheckvarTool)
-	sys("TOOLS_CMD.*", lkNone, CheckvarPathname)
-	sys("TOOLS_CREATE", lkShell, CheckvarTool)
-	acl("TOOLS_DEPENDS.*", lkSpace, CheckvarDependencyWithPath, "buildlink3.mk:; Makefile, Makefile.*: set, default; *: use")
-	sys("TOOLS_GNU_MISSING", lkShell, CheckvarTool)
-	sys("TOOLS_NOOP", lkShell, CheckvarTool)
-	sys("TOOLS_PATH.*", lkNone, CheckvarPathname)
-	sys("TOOLS_PLATFORM.*", lkNone, CheckvarShellCommand)
-	sys("TOUCH_FLAGS", lkShell, CheckvarShellWord)
-	pkglist("UAC_REQD_EXECS", lkShell, CheckvarPrefixPathname)
+	pkglist("TEXINFO_REQD", lkShell, BtVersion)
+	acl("TOOL_DEPENDS", lkSpace, BtDependencyWithPath, "Makefile, Makefile.common, *.mk: append")
+	sys("TOOLS_ALIASES", lkShell, BtFilename)
+	sys("TOOLS_BROKEN", lkShell, BtTool)
+	sys("TOOLS_CMD.*", lkNone, BtPathname)
+	sys("TOOLS_CREATE", lkShell, BtTool)
+	acl("TOOLS_DEPENDS.*", lkSpace, BtDependencyWithPath, "buildlink3.mk:; Makefile, Makefile.*: set, default; *: use")
+	sys("TOOLS_GNU_MISSING", lkShell, BtTool)
+	sys("TOOLS_NOOP", lkShell, BtTool)
+	sys("TOOLS_PATH.*", lkNone, BtPathname)
+	sys("TOOLS_PLATFORM.*", lkNone, BtShellCommand)
+	sys("TOUCH_FLAGS", lkShell, BtShellWord)
+	pkglist("UAC_REQD_EXECS", lkShell, BtPrefixPathname)
 	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)
+	usr("UNPRIVILEGED_USER", lkNone, BtUserGroupName)
+	usr("UNPRIVILEGED_GROUP", lkNone, BtUserGroupName)
+	pkglist("UNWRAP_FILES", lkShell, BtPathmask)
+	usr("UPDATE_TARGET", lkShell, BtIdentifier)
 	pkg("USERGROUP_PHASE", lkNone, enum("configure build pre-install"))
-	pkg("USE_BSD_MAKEFILE", lkNone, CheckvarYes)
-	acl("USE_BUILTIN.*", lkNone, CheckvarYesNoIndirectly, "builtin.mk: set")
-	pkg("USE_CMAKE", lkNone, CheckvarYes)
-	usr("USE_DESTDIR", lkNone, CheckvarYes)
-	pkglist("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, options.mk: set")
-	acl("USE_IMAKE", lkNone, CheckvarYes, "Makefile: set")
+	pkg("USE_BSD_MAKEFILE", lkNone, BtYes)
+	acl("USE_BUILTIN.*", lkNone, BtYesNoIndirectly, "builtin.mk: set")
+	pkg("USE_CMAKE", lkNone, BtYes)
+	usr("USE_DESTDIR", lkNone, BtYes)
+	pkglist("USE_FEATURES", lkShell, BtIdentifier)
+	pkg("USE_GCC_RUNTIME", lkNone, BtYesNo)
+	pkg("USE_GNU_CONFIGURE_HOST", lkNone, BtYesNo)
+	acl("USE_GNU_ICONV", lkNone, BtYes, "Makefile, Makefile.common, options.mk: set")
+	acl("USE_IMAKE", lkNone, BtYes, "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)
-	pkg("USE_PKGINSTALL", lkNone, CheckvarYes)
-	pkg("USE_PKGLOCALEDIR", lkNone, CheckvarYesNo)
-	usr("USE_PKGSRC_GCC", lkNone, CheckvarYes)
-	acl("USE_TOOLS", lkShell, CheckvarTool, "*: append")
-	acl("USE_TOOLS.*", lkShell, CheckvarTool, "*: append")
-	pkg("USE_X11", lkNone, CheckvarYes)
-	sys("WARNING_MSG", lkNone, CheckvarShellCommand)
-	sys("WARNING_CAT", lkNone, CheckvarShellCommand)
-	acl("WRAPPER_REORDER_CMDS", lkShell, CheckvarWrapperReorder, "Makefile, Makefile.common, buildlink3.mk: append")
-	pkg("WRAPPER_SHELL", lkNone, CheckvarShellCommand)
-	acl("WRAPPER_TRANSFORM_CMDS", lkShell, CheckvarWrapperTransform, "Makefile, Makefile.common, buildlink3.mk: append")
-	sys("WRKDIR", lkNone, CheckvarPathname)
-	pkg("WRKSRC", lkNone, CheckvarWrkdirSubdirectory)
-	sys("X11_PKGSRCDIR.*", lkNone, CheckvarPathname)
+	pkg("USE_LIBTOOL", lkNone, BtYes)
+	pkg("USE_MAKEINFO", lkNone, BtYes)
+	pkg("USE_MSGFMT_PLURALS", lkNone, BtYes)
+	pkg("USE_NCURSES", lkNone, BtYes)
+	pkg("USE_OLD_DES_API", lkNone, BtYesNo)
+	pkg("USE_PKGINSTALL", lkNone, BtYes)
+	pkg("USE_PKGLOCALEDIR", lkNone, BtYesNo)
+	usr("USE_PKGSRC_GCC", lkNone, BtYes)
+	acl("USE_TOOLS", lkShell, BtTool, "*: append")
+	acl("USE_TOOLS.*", lkShell, BtTool, "*: append")
+	pkg("USE_X11", lkNone, BtYes)
+	sys("WARNING_MSG", lkNone, BtShellCommand)
+	sys("WARNING_CAT", lkNone, BtShellCommand)
+	acl("WRAPPER_REORDER_CMDS", lkShell, BtWrapperReorder, "Makefile, Makefile.common, buildlink3.mk: append")
+	pkg("WRAPPER_SHELL", lkNone, BtShellCommand)
+	acl("WRAPPER_TRANSFORM_CMDS", lkShell, BtWrapperTransform, "Makefile, Makefile.common, buildlink3.mk: append")
+	sys("WRKDIR", lkNone, BtPathname)
+	pkg("WRKSRC", lkNone, BtWrkdirSubdirectory)
+	sys("X11_PKGSRCDIR.*", lkNone, BtPathname)
 	usr("XAW_TYPE", lkNone, enum("3d neXtaw standard xpm"))
-	acl("XMKMF_FLAGS", lkShell, CheckvarShellWord, "")
-	pkglist("_WRAP_EXTRA_ARGS.*", lkShell, CheckvarShellWord)
+	acl("XMKMF_FLAGS", lkShell, BtShellWord, "")
+	pkglist("_WRAP_EXTRA_ARGS.*", lkShell, BtShellWord)
 }
 
-func enum(values string) *VarChecker {
+func enum(values string) *BasicType {
 	vmap := make(map[string]bool)
 	for _, value := range splitOnSpace(values) {
 		vmap[value] = true
 	}
 	name := "enum: " + values + " " // See IsEnum
-	return &VarChecker{name, func(cv *VartypeCheck) {
+	return &BasicType{name, func(cv *VartypeCheck) {
 		if cv.Op == opUseMatch {
 			if !vmap[cv.Value] && cv.Value == cv.ValueNoVar {
 				canMatch := false
@@ -768,7 +768,7 @@ func enum(values string) *VarChecker {
 	}}
 }
 
-func acl(varname string, kindOfList KindOfList, checker *VarChecker, aclentries string) {
+func acl(varname string, kindOfList KindOfList, checker *BasicType, aclentries string) {
 	m := mustMatch(varname, `^([A-Z_.][A-Z0-9_]*)(|\*|\.\*)$`)
 	varbase, varparam := m[1], m[2]
 
@@ -843,13 +843,13 @@ func parseAclEntries(varname string, aclentries string) []AclEntry {
 }
 
 // A package-defined variable may be set in all Makefiles except buildlink3.mk and builtin.mk.
-func pkg(varname string, kindOfList KindOfList, checker *VarChecker) {
+func pkg(varname string, kindOfList KindOfList, checker *BasicType) {
 	acl(varname, kindOfList, checker, "Makefile: set, use; buildlink3.mk, builtin.mk:; Makefile.*, *.mk: default, set, use")
 }
 
 // A package-defined list may be appended to in all Makefiles except buildlink3.mk and builtin.mk.
 // Simple assignment (instead of appending) is only allowed in Makefile and Makefile.common.
-func pkglist(varname string, kindOfList KindOfList, checker *VarChecker) {
+func pkglist(varname string, kindOfList KindOfList, checker *BasicType) {
 	acl(varname, kindOfList, checker, "Makefile, Makefile.common, options.mk: append, default, set, use; buildlink3.mk, builtin.mk:; *.mk: append, default, use")
 }
 
@@ -857,15 +857,15 @@ func pkglist(varname string, kindOfList KindOfList, checker *VarChecker) {
 // package file. It also must not be used in buildlink3.mk and
 // builtin.mk files or at load-time, since the system/user preferences
 // may not have been loaded when these files are included.
-func sys(varname string, kindOfList KindOfList, checker *VarChecker) {
+func sys(varname string, kindOfList KindOfList, checker *BasicType) {
 	acl(varname, kindOfList, checker, "buildlink3.mk:; *: use")
 }
-func usr(varname string, kindOfList KindOfList, checker *VarChecker) {
+func usr(varname string, kindOfList KindOfList, checker *BasicType) {
 	acl(varname, kindOfList, checker, "buildlink3.mk:; *: use-loadtime, use")
 }
-func bl3list(varname string, kindOfList KindOfList, checker *VarChecker) {
+func bl3list(varname string, kindOfList KindOfList, checker *BasicType) {
 	acl(varname, kindOfList, checker, "buildlink3.mk, builtin.mk: append")
 }
-func cmdline(varname string, kindOfList KindOfList, checker *VarChecker) {
+func cmdline(varname string, kindOfList KindOfList, checker *BasicType) {
 	acl(varname, kindOfList, checker, "buildlink3.mk, builtin.mk:; *: use-loadtime, use")
 }
diff --git a/pkgtools/pkglint/files/vartype.go b/pkgtools/pkglint/files/vartype.go
index a5f8bd52959..d5ef2dbb8a9 100644
--- a/pkgtools/pkglint/files/vartype.go
+++ b/pkgtools/pkglint/files/vartype.go
@@ -9,7 +9,7 @@ import (
 // See vardefs.go for examples, and vartypecheck.go for the implementation.
 type Vartype struct {
 	kindOfList KindOfList
-	checker    *VarChecker
+	basicType  *BasicType
 	aclEntries []AclEntry
 	guessed    bool
 }
@@ -110,8 +110,8 @@ func (vt *Vartype) IsConsideredList() bool {
 	case lkSpace:
 		return false
 	}
-	switch vt.checker {
-	case CheckvarAwkCommand, CheckvarSedCommands, CheckvarShellCommand, CheckvarShellCommands:
+	switch vt.basicType {
+	case BtAwkCommand, BtSedCommands, BtShellCommand, BtShellCommands, BtLicense:
 		return true
 	}
 	return false
@@ -124,24 +124,24 @@ func (vt *Vartype) MayBeAppendedTo() bool {
 func (vt *Vartype) String() string {
 	switch vt.kindOfList {
 	case lkNone:
-		return vt.checker.name
+		return vt.basicType.name
 	case lkSpace:
-		return "SpaceList of " + vt.checker.name
+		return "SpaceList of " + vt.basicType.name
 	case lkShell:
-		return "ShellList of " + vt.checker.name
+		return "ShellList of " + vt.basicType.name
 	default:
 		panic("Unknown list type")
 	}
 }
 
 func (vt *Vartype) IsShell() bool {
-	switch vt.checker {
-	case CheckvarCFlag, // Subtype of ShellWord
-		CheckvarLdFlag, // Subtype of ShellWord
-		CheckvarSedCommands,
-		CheckvarShellCommand,
-		CheckvarShellCommands,
-		CheckvarShellWord:
+	switch vt.basicType {
+	case BtCFlag, // Subtype of ShellWord
+		BtLdFlag, // Subtype of ShellWord
+		BtSedCommands,
+		BtShellCommand,
+		BtShellCommands,
+		BtShellWord:
 		return true
 	}
 	return false
@@ -150,127 +150,125 @@ func (vt *Vartype) IsShell() bool {
 // The basic vartype consists only of characters that don’t
 // need escaping in most contexts, like A-Za-z0-9-_.
 func (vt *Vartype) IsBasicSafe() bool {
-	switch vt.checker {
-	case CheckvarBuildlinkDepmethod,
-		CheckvarCategory,
-		CheckvarDistSuffix,
-		CheckvarEmulPlatform,
-		CheckvarFileMode,
-		CheckvarFilename,
-		CheckvarIdentifier,
-		CheckvarInteger,
-		CheckvarMachineGnuPlatform,
-		CheckvarMachinePlatform,
-		CheckvarOption,
-		CheckvarPathname,
-		CheckvarPerl5Packlist,
-		CheckvarPkgName,
-		CheckvarPkgOptionsVar,
-		CheckvarPkgPath,
-		CheckvarPkgRevision,
-		CheckvarPrefixPathname,
-		CheckvarPythonDependency,
-		CheckvarRelativePkgDir,
-		CheckvarRelativePkgPath,
-		CheckvarStage,
-		CheckvarUserGroupName,
-		CheckvarVersion,
-		CheckvarWrkdirSubdirectory,
-		CheckvarYesNo,
-		CheckvarYesNoIndirectly:
+	switch vt.basicType {
+	case BtBuildlinkDepmethod,
+		BtCategory,
+		BtDistSuffix,
+		BtEmulPlatform,
+		BtFileMode,
+		BtFilename,
+		BtIdentifier,
+		BtInteger,
+		BtMachineGnuPlatform,
+		BtMachinePlatform,
+		BtOption,
+		BtPathname,
+		BtPerl5Packlist,
+		BtPkgName,
+		BtPkgOptionsVar,
+		BtPkgPath,
+		BtPkgRevision,
+		BtPrefixPathname,
+		BtPythonDependency,
+		BtRelativePkgDir,
+		BtRelativePkgPath,
+		BtStage,
+		BtUserGroupName,
+		BtVersion,
+		BtWrkdirSubdirectory,
+		BtYesNo,
+		BtYesNoIndirectly:
 		return true
 	}
 	return false
 }
 
 func (vt *Vartype) IsPlainString() bool {
-	switch vt.checker {
-	case CheckvarComment, CheckvarMessage, CheckvarString:
+	switch vt.basicType {
+	case BtComment, BtMessage, BtUnknown:
 		return true
 	}
 	return false
 }
 
-type VarChecker struct {
+type BasicType struct {
 	name    string
 	checker func(*VartypeCheck)
 }
 
-func (vc *VarChecker) IsEnum() bool {
-	return hasPrefix(vc.name, "enum: ")
+func (bt *BasicType) IsEnum() bool {
+	return hasPrefix(bt.name, "enum: ")
 }
-func (vc *VarChecker) HasEnum(value string) bool {
-	return !contains(value, " ") && contains(vc.name, " "+value+" ")
+func (bt *BasicType) HasEnum(value string) bool {
+	return !contains(value, " ") && contains(bt.name, " "+value+" ")
 }
-func (vc *VarChecker) AllowedEnums() string {
-	return vc.name[6 : len(vc.name)-1]
+func (bt *BasicType) AllowedEnums() string {
+	return bt.name[6 : len(bt.name)-1]
 }
 
 var (
-	CheckvarAwkCommand             = &VarChecker{"AwkCommand", (*VartypeCheck).AwkCommand}
-	CheckvarBasicRegularExpression = &VarChecker{"BasicRegularExpression", (*VartypeCheck).BasicRegularExpression}
-	CheckvarBuildlinkDepmethod     = &VarChecker{"BuildlinkDepmethod", (*VartypeCheck).BuildlinkDepmethod}
-	CheckvarCategory               = &VarChecker{"Category", (*VartypeCheck).Category}
-	CheckvarCFlag                  = &VarChecker{"CFlag", (*VartypeCheck).CFlag}
-	CheckvarComment                = &VarChecker{"Comment", (*VartypeCheck).Comment}
-	CheckvarDependency             = &VarChecker{"Dependency", (*VartypeCheck).Dependency}
-	CheckvarDependencyWithPath     = &VarChecker{"DependencyWithPath", (*VartypeCheck).DependencyWithPath}
-	CheckvarDistSuffix             = &VarChecker{"DistSuffix", (*VartypeCheck).DistSuffix}
-	CheckvarEmulPlatform           = &VarChecker{"EmulPlatform", (*VartypeCheck).EmulPlatform}
-	CheckvarFetchURL               = &VarChecker{"FetchURL", (*VartypeCheck).FetchURL}
-	CheckvarFilename               = &VarChecker{"Filename", (*VartypeCheck).Filename}
-	CheckvarFilemask               = &VarChecker{"Filemask", (*VartypeCheck).Filemask}
-	CheckvarFileMode               = &VarChecker{"FileMode", (*VartypeCheck).FileMode}
-	CheckvarHomepage               = &VarChecker{"Homepage", (*VartypeCheck).Homepage}
-	CheckvarIdentifier             = &VarChecker{"Identifier", (*VartypeCheck).Identifier}
-	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}
-	CheckvarShellWord              = &VarChecker{"ShellWord", nil}
-	CheckvarStage                  = &VarChecker{"Stage", (*VartypeCheck).Stage}
-	CheckvarString                 = &VarChecker{"String", (*VartypeCheck).String}
-	CheckvarTool                   = &VarChecker{"Tool", (*VartypeCheck).Tool}
-	CheckvarUnchecked              = &VarChecker{"Unchecked", (*VartypeCheck).Unchecked}
-	CheckvarURL                    = &VarChecker{"URL", (*VartypeCheck).URL}
-	CheckvarUserGroupName          = &VarChecker{"UserGroupName", (*VartypeCheck).UserGroupName}
-	CheckvarVariableName           = &VarChecker{"VariableName", (*VartypeCheck).VariableName}
-	CheckvarVersion                = &VarChecker{"Version", (*VartypeCheck).Version}
-	CheckvarWrapperReorder         = &VarChecker{"WrapperReorder", (*VartypeCheck).WrapperReorder}
-	CheckvarWrapperTransform       = &VarChecker{"WrapperTransform", (*VartypeCheck).WrapperTransform}
-	CheckvarWrkdirSubdirectory     = &VarChecker{"WrkdirSubdirectory", (*VartypeCheck).WrkdirSubdirectory}
-	CheckvarWrksrcSubdirectory     = &VarChecker{"WrksrcSubdirectory", (*VartypeCheck).WrksrcSubdirectory}
-	CheckvarYes                    = &VarChecker{"Yes", (*VartypeCheck).Yes}
-	CheckvarYesNo                  = &VarChecker{"YesNo", (*VartypeCheck).YesNo}
-	CheckvarYesNoIndirectly        = &VarChecker{"YesNoIndirectly", (*VartypeCheck).YesNoIndirectly}
+	BtAwkCommand             = &BasicType{"AwkCommand", (*VartypeCheck).AwkCommand}
+	BtBasicRegularExpression = &BasicType{"BasicRegularExpression", (*VartypeCheck).BasicRegularExpression}
+	BtBuildlinkDepmethod     = &BasicType{"BuildlinkDepmethod", (*VartypeCheck).BuildlinkDepmethod}
+	BtCategory               = &BasicType{"Category", (*VartypeCheck).Category}
+	BtCFlag                  = &BasicType{"CFlag", (*VartypeCheck).CFlag}
+	BtComment                = &BasicType{"Comment", (*VartypeCheck).Comment}
+	BtDependency             = &BasicType{"Dependency", (*VartypeCheck).Dependency}
+	BtDependencyWithPath     = &BasicType{"DependencyWithPath", (*VartypeCheck).DependencyWithPath}
+	BtDistSuffix             = &BasicType{"DistSuffix", (*VartypeCheck).DistSuffix}
+	BtEmulPlatform           = &BasicType{"EmulPlatform", (*VartypeCheck).EmulPlatform}
+	BtFetchURL               = &BasicType{"FetchURL", (*VartypeCheck).FetchURL}
+	BtFilename               = &BasicType{"Filename", (*VartypeCheck).Filename}
+	BtFilemask               = &BasicType{"Filemask", (*VartypeCheck).Filemask}
+	BtFileMode               = &BasicType{"FileMode", (*VartypeCheck).FileMode}
+	BtHomepage               = &BasicType{"Homepage", (*VartypeCheck).Homepage}
+	BtIdentifier             = &BasicType{"Identifier", (*VartypeCheck).Identifier}
+	BtInteger                = &BasicType{"Integer", (*VartypeCheck).Integer}
+	BtLdFlag                 = &BasicType{"LdFlag", (*VartypeCheck).LdFlag}
+	BtLicense                = &BasicType{"License", (*VartypeCheck).License}
+	BtMachineGnuPlatform     = &BasicType{"MachineGnuPlatform", (*VartypeCheck).MachineGnuPlatform}
+	BtMachinePlatform        = &BasicType{"MachinePlatform", (*VartypeCheck).MachinePlatform}
+	BtMachinePlatformPattern = &BasicType{"MachinePlatformPattern", (*VartypeCheck).MachinePlatformPattern}
+	BtMailAddress            = &BasicType{"MailAddress", (*VartypeCheck).MailAddress}
+	BtMessage                = &BasicType{"Message", (*VartypeCheck).Message}
+	BtOption                 = &BasicType{"Option", (*VartypeCheck).Option}
+	BtPathlist               = &BasicType{"Pathlist", (*VartypeCheck).Pathlist}
+	BtPathmask               = &BasicType{"Pathmask", (*VartypeCheck).Pathmask}
+	BtPathname               = &BasicType{"Pathname", (*VartypeCheck).Pathname}
+	BtPerl5Packlist          = &BasicType{"Perl5Packlist", (*VartypeCheck).Perl5Packlist}
+	BtPerms                  = &BasicType{"Perms", (*VartypeCheck).Perms}
+	BtPkgName                = &BasicType{"PkgName", (*VartypeCheck).PkgName}
+	BtPkgPath                = &BasicType{"PkgPath", (*VartypeCheck).PkgPath}
+	BtPkgOptionsVar          = &BasicType{"PkgOptionsVar", (*VartypeCheck).PkgOptionsVar}
+	BtPkgRevision            = &BasicType{"PkgRevision", (*VartypeCheck).PkgRevision}
+	BtPrefixPathname         = &BasicType{"PrefixPathname", (*VartypeCheck).PrefixPathname}
+	BtPythonDependency       = &BasicType{"PythonDependency", (*VartypeCheck).PythonDependency}
+	BtRelativePkgDir         = &BasicType{"RelativePkgDir", (*VartypeCheck).RelativePkgDir}
+	BtRelativePkgPath        = &BasicType{"RelativePkgPath", (*VartypeCheck).RelativePkgPath}
+	BtRestricted             = &BasicType{"Restricted", (*VartypeCheck).Restricted}
+	BtSedCommand             = &BasicType{"SedCommand", (*VartypeCheck).SedCommand}
+	BtSedCommands            = &BasicType{"SedCommands", (*VartypeCheck).SedCommands}
+	BtShellCommand           = &BasicType{"ShellCommand", nil}
+	BtShellCommands          = &BasicType{"ShellCommands", nil}
+	BtShellWord              = &BasicType{"ShellWord", nil}
+	BtStage                  = &BasicType{"Stage", (*VartypeCheck).Stage}
+	BtTool                   = &BasicType{"Tool", (*VartypeCheck).Tool}
+	BtUnknown                = &BasicType{"Unknown", (*VartypeCheck).Unknown}
+	BtURL                    = &BasicType{"URL", (*VartypeCheck).URL}
+	BtUserGroupName          = &BasicType{"UserGroupName", (*VartypeCheck).UserGroupName}
+	BtVariableName           = &BasicType{"VariableName", (*VartypeCheck).VariableName}
+	BtVersion                = &BasicType{"Version", (*VartypeCheck).Version}
+	BtWrapperReorder         = &BasicType{"WrapperReorder", (*VartypeCheck).WrapperReorder}
+	BtWrapperTransform       = &BasicType{"WrapperTransform", (*VartypeCheck).WrapperTransform}
+	BtWrkdirSubdirectory     = &BasicType{"WrkdirSubdirectory", (*VartypeCheck).WrkdirSubdirectory}
+	BtWrksrcSubdirectory     = &BasicType{"WrksrcSubdirectory", (*VartypeCheck).WrksrcSubdirectory}
+	BtYes                    = &BasicType{"Yes", (*VartypeCheck).Yes}
+	BtYesNo                  = &BasicType{"YesNo", (*VartypeCheck).YesNo}
+	BtYesNoIndirectly        = &BasicType{"YesNoIndirectly", (*VartypeCheck).YesNoIndirectly}
 )
 
 func init() { // Necessary due to circular dependency
-	CheckvarSedCommands.checker = (*VartypeCheck).SedCommands
-	CheckvarShellCommand.checker = (*VartypeCheck).ShellCommand
-	CheckvarShellCommands.checker = (*VartypeCheck).ShellCommands
-	CheckvarShellWord.checker = (*VartypeCheck).ShellWord
+	BtShellCommand.checker = (*VartypeCheck).ShellCommand
+	BtShellCommands.checker = (*VartypeCheck).ShellCommands
+	BtShellWord.checker = (*VartypeCheck).ShellWord
 }
diff --git a/pkgtools/pkglint/files/vartype_test.go b/pkgtools/pkglint/files/vartype_test.go
index 027590c2a3d..c2afd2a58f0 100644
--- a/pkgtools/pkglint/files/vartype_test.go
+++ b/pkgtools/pkglint/files/vartype_test.go
@@ -8,13 +8,13 @@ func (s *Suite) Test_Vartype_EffectivePermissions(c *check.C) {
 	G.globalData.InitVartypes()
 
 	if t := G.globalData.vartypes["PREFIX"]; c.Check(t, check.NotNil) {
-		c.Check(t.checker.name, equals, "Pathname")
+		c.Check(t.basicType.name, equals, "Pathname")
 		c.Check(t.aclEntries, check.DeepEquals, []AclEntry{{glob: "*", permissions: aclpUse}})
 		c.Check(t.EffectivePermissions("Makefile"), equals, aclpUse)
 	}
 
 	if t := G.globalData.vartypes["EXTRACT_OPTS"]; c.Check(t, check.NotNil) {
-		c.Check(t.checker.name, equals, "ShellWord")
+		c.Check(t.basicType.name, equals, "ShellWord")
 		c.Check(t.EffectivePermissions("Makefile"), equals, aclpAppend|aclpSet)
 		c.Check(t.EffectivePermissions("../Makefile"), equals, aclpAppend|aclpSet)
 		c.Check(t.EffectivePermissions("options.mk"), equals, aclpUnknown)
diff --git a/pkgtools/pkglint/files/vartypecheck.go b/pkgtools/pkglint/files/vartypecheck.go
index cde5676f6b0..16fefc09152 100644
--- a/pkgtools/pkglint/files/vartypecheck.go
+++ b/pkgtools/pkglint/files/vartypecheck.go
@@ -83,7 +83,7 @@ const (
 	reEmulArch = reMachineArch // Just a wild guess.
 )
 
-func enumFromRe(re string) *VarChecker {
+func enumFromRe(re string) *BasicType {
 	values := strings.Split(re, "|")
 	sort.Strings(values)
 	seen := make(map[string]bool)
@@ -274,7 +274,7 @@ func (cv *VartypeCheck) DependencyWithPath() {
 			line.Warn0("Please use USE_TOOLS+=gmake instead of this dependency.")
 		}
 
-		cv.MkLine.CheckVartypePrimitive(cv.Varname, CheckvarDependency, cv.Op, pattern, cv.MkComment, cv.Guessed)
+		cv.MkLine.CheckVartypePrimitive(cv.Varname, BtDependency, cv.Op, pattern, cv.MkComment, cv.Guessed)
 		return
 	}
 
@@ -339,7 +339,7 @@ func (cv *VartypeCheck) EmulPlatform() {
 }
 
 func (cv *VartypeCheck) FetchURL() {
-	cv.MkLine.CheckVartypePrimitive(cv.Varname, CheckvarURL, cv.Op, cv.Value, cv.MkComment, cv.Guessed)
+	cv.MkLine.CheckVartypePrimitive(cv.Varname, BtURL, cv.Op, cv.Value, cv.MkComment, cv.Guessed)
 
 	for siteURL, siteName := range G.globalData.MasterSiteURLToVar {
 		if hasPrefix(cv.Value, siteURL) {
@@ -399,7 +399,7 @@ func (cv *VartypeCheck) FileMode() {
 }
 
 func (cv *VartypeCheck) Homepage() {
-	cv.MkLine.CheckVartypePrimitive(cv.Varname, CheckvarURL, cv.Op, cv.Value, cv.MkComment, cv.Guessed)
+	cv.MkLine.CheckVartypePrimitive(cv.Varname, BtURL, cv.Op, cv.Value, cv.MkComment, cv.Guessed)
 
 	if m, wrong, sitename, subdir := match3(cv.Value, `^(\$\{(MASTER_SITE\w+)(?::=([\w\-/]+))?\})`); m {
 		baseURL := G.globalData.MasterSiteVarToURL[sitename]
@@ -486,7 +486,8 @@ func (cv *VartypeCheck) LdFlag() {
 }
 
 func (cv *VartypeCheck) License() {
-	checklineLicense(cv.MkLine, cv.Value)
+	licenseChecker := &LicenseChecker{cv.MkLine}
+	licenseChecker.Check(cv.Value, cv.Op)
 }
 
 func (cv *VartypeCheck) MachineGnuPlatform() {
@@ -608,7 +609,7 @@ func (cv *VartypeCheck) Option() {
 // The PATH environment variable
 func (cv *VartypeCheck) Pathlist() {
 	if !contains(cv.Value, ":") && cv.Guessed {
-		cv.MkLine.CheckVartypePrimitive(cv.Varname, CheckvarPathname, cv.Op, cv.Value, cv.MkComment, cv.Guessed)
+		cv.MkLine.CheckVartypePrimitive(cv.Varname, BtPathname, cv.Op, cv.Value, cv.MkComment, cv.Guessed)
 		return
 	}
 
@@ -671,7 +672,7 @@ func (cv *VartypeCheck) PkgName() {
 }
 
 func (cv *VartypeCheck) PkgOptionsVar() {
-	cv.MkLine.CheckVartypePrimitive(cv.Varname, CheckvarVariableName, cv.Op, cv.Value, cv.MkComment, cv.Guessed)
+	cv.MkLine.CheckVartypePrimitive(cv.Varname, BtVariableName, cv.Op, cv.Value, cv.MkComment, cv.Guessed)
 	if matches(cv.Value, `\$\{PKGBASE[:\}]`) {
 		cv.Line.Error0("PKGBASE must not be used in PKG_OPTIONS_VAR.")
 		Explain3(
@@ -846,7 +847,7 @@ func (cv *VartypeCheck) SedCommands() {
 						"",
 						"This way, short sed commands cannot be hidden at the end of a line.")
 				}
-				mkline.CheckVartypePrimitive(cv.Varname, CheckvarSedCommand, cv.Op, tokens[i], cv.MkComment, cv.Guessed)
+				mkline.CheckVartypePrimitive(cv.Varname, BtSedCommand, cv.Op, tokens[i], cv.MkComment, cv.Guessed)
 			} else {
 				line.Error0("The -e option to sed requires an argument.")
 			}
@@ -888,10 +889,6 @@ func (cv *VartypeCheck) Stage() {
 	}
 }
 
-func (cv *VartypeCheck) String() {
-	// No further checks possible.
-}
-
 func (cv *VartypeCheck) Tool() {
 	if cv.Varname == "TOOLS_NOOP" && cv.Op == opAssignAppend {
 		// no warning for package-defined tool definitions
@@ -910,8 +907,8 @@ func (cv *VartypeCheck) Tool() {
 	}
 }
 
-func (cv *VartypeCheck) Unchecked() {
-	// Do nothing, as the name says.
+func (cv *VartypeCheck) Unknown() {
+	// Do nothing.
 }
 
 func (cv *VartypeCheck) URL() {
@@ -994,7 +991,7 @@ func (cv *VartypeCheck) WrapperTransform() {
 }
 
 func (cv *VartypeCheck) WrkdirSubdirectory() {
-	cv.MkLine.CheckVartypePrimitive(cv.Varname, CheckvarPathname, cv.Op, cv.Value, cv.MkComment, cv.Guessed)
+	cv.MkLine.CheckVartypePrimitive(cv.Varname, BtPathname, cv.Op, cv.Value, cv.MkComment, cv.Guessed)
 }
 
 // A directory relative to ${WRKSRC}, for use in CONFIGURE_DIRS and similar variables.
diff --git a/pkgtools/pkglint/files/vartypecheck_test.go b/pkgtools/pkglint/files/vartypecheck_test.go
index 780eee026b3..e338f924341 100644
--- a/pkgtools/pkglint/files/vartypecheck_test.go
+++ b/pkgtools/pkglint/files/vartypecheck_test.go
@@ -231,6 +231,24 @@ func (s *Suite) Test_VartypeCheck_LdFlag(c *check.C) {
 	c.Check(s.Output(), equals, "WARN: fname:4: Unknown linker flag \"-unknown\".\n")
 }
 
+func (s *Suite) Test_VartypeCheck_License(c *check.C) {
+	runVartypeChecks("LICENSE", opAssign, (*VartypeCheck).License,
+		"gnu-gpl-v2",
+		"AND mit")
+
+	c.Check(s.Output(), equals, ""+
+		"WARN: fname:1: License file /licenses/gnu-gpl-v2 does not exist.\n"+
+		"ERROR: fname:2: Parse error for license condition \"AND mit\".\n")
+
+	runVartypeChecks("LICENSE", opAssignAppend, (*VartypeCheck).License,
+		"gnu-gpl-v2",
+		"AND mit")
+
+	c.Check(s.Output(), equals, ""+
+		"ERROR: fname:1: Parse error for appended license condition \"gnu-gpl-v2\".\n"+
+		"WARN: fname:2: License file /licenses/mit does not exist.\n")
+}
+
 func (s *Suite) Test_VartypeCheck_MachineGnuPlatform(c *check.C) {
 	runVartypeMatchChecks("MACHINE_GNU_PLATFORM", (*VartypeCheck).MachineGnuPlatform,
 		"x86_64-pc-cygwin",