Sun Dec 2 23:12:43 2018 UTC ()

pkgtools/pkglint: update to 5.6.8

Changes since 5.6.7:

In pkgsrc-wip, if the first line of a file contains an expanded CVS Id,
it is not an error but only a note that it should be an unexpanded CVS
Id. The autofix for this no longer inserts a new line but replaces the
existing line.

Several refactorings and small improvements to the existing diagnostics.


(rillig)

--- pkgsrc/pkgtools/pkglint/Makefile 2018/12/02 01:57:48 1.559
+++ pkgsrc/pkgtools/pkglint/Makefile 2018/12/02 23:12:43 1.560

 @@ -1,16 +1,16 @@
-# $NetBSD: Makefile,v 1.559 2018/12/02 01:57:48 rillig Exp $
+# $NetBSD: Makefile,v 1.560 2018/12/02 23:12:43 rillig Exp $
-PKGNAME=	pkglint-5.6.7
+PKGNAME=	pkglint-5.6.8
 CATEGORIES=	pkgtools
 DISTNAME=	tools
 MASTER_SITES=	${MASTER_SITE_GITHUB:=golang/}
 GITHUB_PROJECT=	tools
 GITHUB_TAG=	92d8274bd7b8a4c65f24bafe401a029e58392704
 MAINTAINER=	rillig@NetBSD.org
 HOMEPAGE=	https://github.com/rillig/pkglint
 COMMENT=	Verifier for NetBSD packages
 LICENSE=	2-clause-bsd
 CONFLICTS+=	pkglint4-[0-9]*
 USE_TOOLS+=		pax

--- pkgsrc/pkgtools/pkglint/files/Attic/autofix.go 2018/12/02 01:57:48 1.13
+++ pkgsrc/pkgtools/pkglint/files/Attic/autofix.go 2018/12/02 23:12:43 1.14

	@@ -293,40 +293,43 @@ func (fix *Autofix) Apply() {		@@ -293,40 +293,43 @@ func (fix *Autofix) Apply() {
293	G.Explain(fix.explanation...)	293	G.Explain(fix.explanation...)
294	}	294	}
295	if G.Logger.Opts.ShowSource {	295	if G.Logger.Opts.ShowSource {
296	if !G.Logger.Opts.Explain \|\| !logDiagnostic \|\| len(fix.explanation) == 0 {	296	if !G.Logger.Opts.Explain \|\| !logDiagnostic \|\| len(fix.explanation) == 0 {
297	G.out.Separate()	297	G.out.Separate()
298	}	298	}
299	}	299	}
300	}	300	}
301		301
302	reset()	302	reset()
303	}	303	}
304		304
305	func (fix *Autofix) Realign(mkline MkLine, newWidth int) {	305	func (fix *Autofix) Realign(mkline MkLine, newWidth int) {
		306
		307	// XXX: Check whether this method can be implemented as Custom fix.
		308	// This complicated code should not be in the Autofix type.
		309
306	fix.assertRealLine()	310	fix.assertRealLine()
307	G.Assertf(mkline.IsMultiline(), "Line must be a multiline.")	311	G.Assertf(mkline.IsMultiline(), "Line must be a multiline.")
308	G.Assertf(mkline.IsVarassign() \|\| mkline.IsCommentedVarassign(), "Line must be a variable assignment.")	312	G.Assertf(mkline.IsVarassign() \|\| mkline.IsCommentedVarassign(), "Line must be a variable assignment.")
309		313
310	if fix.skip() {	314	if fix.skip() {
311	return	315	return
312	}	316	}
313		317
314	normalized := true // Whether all indentation is tabs, followed by spaces.	318	normalized := true // Whether all indentation is tabs, followed by spaces.
315	oldWidth := 0 // The minimum required indentation in the original lines.	319	oldWidth := 0 // The minimum required indentation in the original lines.
316		320
317	{	321	{
318	// Parsing the continuation marker as variable value	322	// Parsing the continuation marker as variable value is cheating but works well.
319	// is cheating but works well.
320	text := strings.TrimSuffix(mkline.raw[0].orignl, "\n")	323	text := strings.TrimSuffix(mkline.raw[0].orignl, "\n")
321	m, _, _, _, _, valueAlign, value, _, _ := MatchVarassign(text)	324	m, _, _, _, _, valueAlign, value, _, _ := MatchVarassign(text)
322	if m && value != "\\" {	325	if m && value != "\\" {
323	oldWidth = tabWidth(valueAlign)	326	oldWidth = tabWidth(valueAlign)
324	}	327	}
325	}	328	}
326		329
327	for _, rawLine := range fix.line.raw[1:] {	330	for _, rawLine := range fix.line.raw[1:] {
328	_, comment, space := match2(rawLine.textnl, `^(#?)([ \t]*)`)	331	_, comment, space := match2(rawLine.textnl, `^(#?)([ \t]*)`)
329	width := tabWidth(comment + space)	332	width := tabWidth(comment + space)
330	if (oldWidth == 0 \|\| width < oldWidth) && width >= 8 && rawLine.textnl != "\n" {	333	if (oldWidth == 0 \|\| width < oldWidth) && width >= 8 && rawLine.textnl != "\n" {
331	oldWidth = width	334	oldWidth = width
332	}	335	}

--- pkgsrc/pkgtools/pkglint/files/Attic/pkgsrc.go 2018/12/02 01:57:48 1.13
+++ pkgsrc/pkgtools/pkglint/files/Attic/pkgsrc.go 2018/12/02 23:12:43 1.14

	@@ -313,28 +313,28 @@ func (src *Pkgsrc) loadTools() {		@@ -313,28 +313,28 @@ func (src *Pkgsrc) loadTools() {
313	}	313	}
314		314
315	for _, relativeName := range [...]string{"mk/bsd.prefs.mk", "mk/bsd.pkg.mk"} {	315	for _, relativeName := range [...]string{"mk/bsd.prefs.mk", "mk/bsd.pkg.mk"} {
316		316
317	mklines := G.Pkgsrc.LoadMk(relativeName, MustSucceed\|NotEmpty)	317	mklines := G.Pkgsrc.LoadMk(relativeName, MustSucceed\|NotEmpty)
318	mklines.ForEach(func(mkline MkLine) {	318	mklines.ForEach(func(mkline MkLine) {
319	if mkline.IsVarassign() {	319	if mkline.IsVarassign() {
320	varname := mkline.Varname()	320	varname := mkline.Varname()
321	switch varname {	321	switch varname {
322	case "USE_TOOLS":	322	case "USE_TOOLS":
323	tools.ParseToolLine(mkline, true, !mklines.indentation.IsConditional())	323	tools.ParseToolLine(mkline, true, !mklines.indentation.IsConditional())
324		324
325	case "_BUILD_DEFS":	325	case "_BUILD_DEFS":
326	for _, bdvar := range mkline.ValueFields(mkline.Value()) {	326	for _, buildDefsVar := range mkline.Fields() {
327	src.AddBuildDefs(bdvar)	327	src.AddBuildDefs(buildDefsVar)
328	}	328	}
329	}	329	}
330	}	330	}
331	})	331	})
332	}	332	}
333		333
334	if trace.Tracing {	334	if trace.Tracing {
335	tools.Trace()	335	tools.Trace()
336	}	336	}
337	}	337	}
338		338
339	// loadUntypedVars scans all pkgsrc infrastructure files in mk/	339	// loadUntypedVars scans all pkgsrc infrastructure files in mk/
340	// to find variable definitions that are not yet covered in	340	// to find variable definitions that are not yet covered in

--- pkgsrc/pkgtools/pkglint/files/Attic/buildlink3_test.go 2018/12/02 01:57:48 1.21
+++ pkgsrc/pkgtools/pkglint/files/Attic/buildlink3_test.go 2018/12/02 23:12:43 1.22

 @@ -1,46 +1,46 @@
 package main
 import "gopkg.in/check.v1"
 func (s *Suite) Test_ChecklinesBuildlink3Mk__unfinished_url2pkg(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	t.CreateFileLines("x11/Xbae/Makefile")
 	t.CreateFileLines("mk/motif.buildlink3.mk")
-	mklines := t.SetupFileMkLines("buildlink3.mk",
+	mklines := t.SetupFileMkLines("category/package/buildlink3.mk",
 		MkRcsID,
 		"# XXX This file was created automatically using createbuildlink-@PKGVERSION@",
 		"",
 		"BUILDLINK_TREE+=\tXbae",
 		"",
 		"BUILDLINK_DEPMETHOD.Xbae?=\tfull",
 		".if !defined(XBAE_BUILDLINK3_MK)",
 		"XBAE_BUILDLINK3_MK:=",
 		"",
 		"BUILDLINK_API_DEPENDS.Xbae+=\tXbae>=4.8.4",
 		"BUILDLINK_ABI_DEPENDS.Xbae+=\tXbae>=4.51.01nb2",
 		"BUILDLINK_PKGSRCDIR.Xbae?=\t../../x11/Xbae",
 		"",
 		".include \"../../mk/motif.buildlink3.mk\"",
 		".endif # XBAE_BUILDLINK3_MK",
 		"",
 		"BUILDLINK_TREE+=\t-Xbae")
 	ChecklinesBuildlink3Mk(mklines)
 	t.CheckOutputLines(
-		"ERROR: ~/buildlink3.mk:2: This comment indicates unfinished work (url2pkg).")
+		"ERROR: ~/category/package/buildlink3.mk:2: This comment indicates unfinished work (url2pkg).")
+}
 // Before version 5.3, pkglint wrongly warned here.
 // The mk/haskell.mk file takes care of constructing the correct PKGNAME,
 // but pkglint had not looked at that file.
 //
 // Since then, pkglint also looks at files from mk/ when they are directly
 // included, and therefore finds the default definition for PKGNAME.
 func (s *Suite) Test_ChecklinesBuildlink3Mk__name_mismatch_Haskell_incomplete(c *check.C) {
 	t := s.Init(c)
 	t.SetupPackage("x11/hs-X11",
 		"DISTNAME=\tX11-1.0")

--- pkgsrc/pkgtools/pkglint/files/Attic/vartype.go 2018/12/02 01:57:48 1.21
+++ pkgsrc/pkgtools/pkglint/files/Attic/vartype.go 2018/12/02 23:12:43 1.22

 @@ -6,26 +6,27 @@ import (
+)
 // Vartype is a combination of a data type and a permission specification.
 // See vardefs.go for examples, and vartypecheck.go for the implementation.
 type Vartype struct {
 	kindOfList KindOfList
 	basicType  *BasicType
 	aclEntries []ACLEntry
 	guessed    bool
+}
 type KindOfList uint8
 // TODO: Remove lkSpace. Since 2015 the .for variables are split on shell words, like everywhere else.
 const (
 	lkNone  KindOfList = iota // Plain data type
 	lkSpace                   // List entries are separated by whitespace; used in .for loops.
 	lkShell                   // List entries are shell words; used in the :M, :S modifiers.
+)
 type ACLEntry struct {
 	glob        string // Examples: "Makefile", "*.mk"
 	permissions ACLPermissions
+}
 type ACLPermissions uint8
 @@ -193,26 +194,30 @@ type BasicType struct {
 	checker func(*VartypeCheck)
+}
 func (bt *BasicType) IsEnum() bool {
 	return hasPrefix(bt.name, "enum: ")
+}
 func (bt *BasicType) HasEnum(value string) bool {
 	return !contains(value, " ") && contains(bt.name, " "+value+" ")
+}
 func (bt *BasicType) AllowedEnums() string {
 	return bt.name[6 : len(bt.name)-1]
+}
 // TODO: Try to implement BasicType.PossibleChars()
 // TODO: Try to implement BasicType.CanBeEmpty()
 // TODO: Try to implement BasicType.PossibleWords() / PossibleValues()
 var (
 	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}
 	BtConfFiles              = &BasicType{"ConfFiles", (*VartypeCheck).ConfFiles}
 	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}

--- pkgsrc/pkgtools/pkglint/files/Attic/category_test.go 2018/11/07 20:58:22 1.14
+++ pkgsrc/pkgtools/pkglint/files/Attic/category_test.go 2018/12/02 23:12:43 1.15

 @@ -13,27 +13,27 @@ func (s *Suite) Test_CheckdirCategory__t
 		"SUBDIR-=unknown #doesn\u2019t work",
 		"",
 		".include \"../mk/category.mk\"")
 	CheckdirCategory(t.File("archivers"))
 	t.CheckOutputLines(
 		"ERROR: ~/archivers/Makefile:1: Expected \"# $"+"NetBSD$\".",
 		"WARN: ~/archivers/Makefile:4: Line contains invalid characters (U+2019).",
 		"WARN: ~/archivers/Makefile:4: SUBDIR- is defined but not used.",
 		"NOTE: ~/archivers/Makefile:2: This variable value should be aligned to column 17.",
 		"NOTE: ~/archivers/Makefile:3: This variable value should be aligned with tabs, not spaces, to column 17.",
 		"NOTE: ~/archivers/Makefile:4: This variable value should be aligned to column 17.",
-		"ERROR: ~/archivers/Makefile:6: \"../mk/category.mk\" does not exist.",
+		"ERROR: ~/archivers/Makefile:6: Relative path \"../mk/category.mk\" does not exist.",
 		"NOTE: ~/archivers/Makefile:1: Empty line expected after this line.",
 		"ERROR: ~/archivers/Makefile:2: COMMENT= line expected.",
 		"NOTE: ~/archivers/Makefile:1: Empty line expected after this line.", // XXX: Duplicate.
 		"WARN: ~/archivers/Makefile:3: \"aaaaa\" should come before \"pkg1\".",
 		"ERROR: ~/archivers/Makefile:4: SUBDIR+= line or empty line expected.",
 		"ERROR: ~/archivers/Makefile:2: \"pkg1\" exists in the Makefile but not in the file system.",
 		"ERROR: ~/archivers/Makefile:3: \"aaaaa\" exists in the Makefile but not in the file system.",
 		"NOTE: ~/archivers/Makefile:3: Empty line expected after this line.",
 		"WARN: ~/archivers/Makefile:4: This line should contain the following text: .include \"../mk/misc/category.mk\"",
 		"ERROR: ~/archivers/Makefile:4: The file should end here.")
+}
 func (s *Suite) Test_CheckdirCategory__invalid_comment(c *check.C) {

--- pkgsrc/pkgtools/pkglint/files/Attic/licenses.go 2018/12/02 01:57:48 1.17
+++ pkgsrc/pkgtools/pkglint/files/Attic/licenses.go 2018/12/02 23:12:43 1.18

	@@ -16,27 +16,27 @@ func (lc *LicenseChecker) Check(value st		@@ -16,27 +16,27 @@ func (lc *LicenseChecker) Check(value st
16	} else {	16	} else {
17	lc.MkLine.Errorf("Parse error for appended license condition %q.", value)	17	lc.MkLine.Errorf("Parse error for appended license condition %q.", value)
18	}	18	}
19	return	19	return
20	}	20	}
21		21
22	cond.Walk(lc.checkNode)	22	cond.Walk(lc.checkNode)
23	}	23	}
24		24
25	func (lc *LicenseChecker) checkName(license string) {	25	func (lc *LicenseChecker) checkName(license string) {
26	licenseFile := ""	26	licenseFile := ""
27	if G.Pkg != nil {	27	if G.Pkg != nil {
28	if mkline := G.Pkg.vars.FirstDefinition("LICENSE_FILE"); mkline != nil {	28	if mkline := G.Pkg.vars.FirstDefinition("LICENSE_FILE"); mkline != nil {
29	licenseFile = G.Pkg.File(mkline.ResolveVarsInRelativePath(mkline.Value(), false))	29	licenseFile = G.Pkg.File(mkline.ResolveVarsInRelativePath(mkline.Value()))
30	}	30	}
31	}	31	}
32	if licenseFile == "" {	32	if licenseFile == "" {
33	licenseFile = G.Pkgsrc.File("licenses/" + license)	33	licenseFile = G.Pkgsrc.File("licenses/" + license)
34	if G.Pkgsrc.UsedLicenses != nil {	34	if G.Pkgsrc.UsedLicenses != nil {
35	G.Pkgsrc.UsedLicenses[license] = true	35	G.Pkgsrc.UsedLicenses[license] = true
36	}	36	}
37	}	37	}
38		38
39	if !fileExists(licenseFile) {	39	if !fileExists(licenseFile) {
40	lc.MkLine.Warnf("License file %s does not exist.", cleanpath(licenseFile))	40	lc.MkLine.Warnf("License file %s does not exist.", cleanpath(licenseFile))
41	}	41	}
42		42

--- pkgsrc/pkgtools/pkglint/files/Attic/line.go 2018/12/02 01:57:48 1.28
+++ pkgsrc/pkgtools/pkglint/files/Attic/line.go 2018/12/02 23:12:43 1.29

 @@ -25,26 +25,28 @@ type RawLine struct {
 	// XXX: Since only Autofix needs to distinguish between orignl and textnl,
 	// one of these fields should probably be moved there.
+}
 func (rline *RawLine) String() string { return sprintf("%d:%s", rline.Lineno, rline.textnl) }
 // Line represents a line of text from a file.
 // It aliases a pointer type to reduces the number of *Line occurrences in the code.
 // Using a type alias is more efficient than an interface type, I guess.
 type Line = *LineImpl
 type LineImpl struct {
 	// TODO: Consider storing pointers to the Filename and Basename instead of strings to save memory.
 	// But first find out where and why pkglint needs so much memory (200 MB for a full recursive run over pkgsrc + wip).
 	Filename  string // uses / as directory separator on all platforms
 	Basename  string // the last component of the Filename
 	firstLine int32  // zero means the whole file, -1 means EOF
 	lastLine  int32  // usually the same as firstLine, may differ in Makefiles
 	// without the trailing newline character;
 	// in Makefiles, also contains the text from the continuation lines
 	Text    string
 	raw     []*RawLine // contains the original text including trailing newline
 	autofix *Autofix   // any changes that pkglint would like to apply to the line
 	Once
 	// XXX: Filename and Basename could be replaced with a pointer to a Lines object.
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/lines.go 2018/12/02 01:57:48 1.2
+++ pkgsrc/pkgtools/pkglint/files/Attic/lines.go 2018/12/02 23:12:43 1.3

 @@ -35,41 +35,41 @@ func (ls *LinesImpl) SaveAutofixChanges(
 	SaveAutofixChanges(ls)
+}
 func (ls *LinesImpl) CheckRcsID(index int, prefixRe regex.Pattern, suggestedPrefix string) bool {
 	if trace.Tracing {
 		defer trace.Call(prefixRe, suggestedPrefix)()
+	}
 	line := ls.Lines[index]
 	if m, expanded := match1(line.Text, `^`+prefixRe+`\$`+`NetBSD(:[^\$]+)?\$$`); m {
 		if G.Wip && expanded != "" {
 			fix := line.Autofix()
-			fix.Errorf("Expected exactly %q.", suggestedPrefix+"$"+"NetBSD$")
+			fix.Notef("Expected exactly %q.", suggestedPrefix+"$"+"NetBSD$")
 			fix.Explain(
 				"Several files in pkgsrc must contain the CVS Id, so that their",
 				"current version can be traced back later from a binary package.",
 				"This is to ensure reproducible builds, for example for finding bugs.",
 				"",
 				"These CVS Ids are specific to the CVS version control system, and",
 				"pkgsrc-wip uses Git instead.  Therefore, having the expanded CVS Ids",
 				"in those files represents the file from which they were originally",
 				"copied but not their current state.  Because of that, these markers",
 				"should be replaced with the plain, unexpanded string $"+"NetBSD$.",
 				"",
 				"To preserve the history of the CVS Id, should that ever be needed,",
 				"remove the leading $.")
-			fix.InsertBefore(suggestedPrefix + "$" + "NetBSD$")
+			fix.ReplaceRegex(`.*`, suggestedPrefix+"$"+"NetBSD$", 1)
 			fix.Apply()
+		}
 		return true
+	}
 	fix := line.Autofix()
 	fix.Errorf("Expected %q.", suggestedPrefix+"$"+"NetBSD$")
 	fix.Explain(
 		"Most files in pkgsrc contain the CVS Id, so that their current",
 		"version can be traced back later from a binary package.",
 		"This is to ensure reproducible builds, for example for finding bugs.")
 	fix.InsertBefore(suggestedPrefix + "$" + "NetBSD$")

--- pkgsrc/pkgtools/pkglint/files/Attic/lines_test.go 2018/12/02 01:57:48 1.1
+++ pkgsrc/pkgtools/pkglint/files/Attic/lines_test.go 2018/12/02 23:12:43 1.2

 @@ -37,18 +37,28 @@ func (s *Suite) Test_Lines_CheckRcsID__w
 		"# $"+"NetBSD: dummy $")
 	t.CreateFileLines("wip/package/file2.mk",
 		"# $"+"NetBSD$")
 	t.CreateFileLines("wip/package/file3.mk",
 		"# $"+"Id: dummy $")
 	t.CreateFileLines("wip/package/file4.mk",
 		"# $"+"Id$")
 	t.CreateFileLines("wip/package/file5.mk",
 		"# $"+"FreeBSD$")
 	G.CheckDirent(t.File("wip/package"))
 	t.CheckOutputLines(
-		"ERROR: ~/wip/package/file1.mk:1: Expected exactly \"# $"+"NetBSD$\".",
+		"NOTE: ~/wip/package/file1.mk:1: Expected exactly \"# $"+"NetBSD$\".",
 		"ERROR: ~/wip/package/file3.mk:1: Expected \"# $"+"NetBSD$\".",
 		"ERROR: ~/wip/package/file4.mk:1: Expected \"# $"+"NetBSD$\".",
 		"ERROR: ~/wip/package/file5.mk:1: Expected \"# $"+"NetBSD$\".")
 	G.Logger.Opts.Autofix = true
 	G.CheckDirent(t.File("wip/package"))
 	t.CheckOutputLines(
 		"AUTOFIX: ~/wip/package/file1.mk:1: Replacing \"# $NetBSD: lines_test.go,v 1.2 2018/12/02 23:12:43 rillig Exp $\" with \"# $NetBSD: lines_test.go,v 1.2 2018/12/02 23:12:43 rillig Exp $\".",
 		"AUTOFIX: ~/wip/package/file3.mk:1: Inserting a line \"# $NetBSD: lines_test.go,v 1.2 2018/12/02 23:12:43 rillig Exp $\" before this line.",
 		"AUTOFIX: ~/wip/package/file4.mk:1: Inserting a line \"# $NetBSD: lines_test.go,v 1.2 2018/12/02 23:12:43 rillig Exp $\" before this line.",
 		"AUTOFIX: ~/wip/package/file5.mk:1: Inserting a line \"# $NetBSD: lines_test.go,v 1.2 2018/12/02 23:12:43 rillig Exp $\" before this line.")
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/mkline.go 2018/12/02 01:57:48 1.41
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkline.go 2018/12/02 23:12:43 1.42

 @@ -21,41 +21,43 @@ type MkLineImpl struct {
 	data interface{} // One of the following mkLine* types
+}
 type mkLineAssign = *mkLineAssignImpl // See https://github.com/golang/go/issues/28045
 type mkLineAssignImpl struct {
 	commented   bool       // Whether the whole variable assignment is commented out
 	varname     string     // e.g. "HOMEPAGE", "SUBST_SED.perl"
 	varcanon    string     // e.g. "HOMEPAGE", "SUBST_SED.*"
 	varparam    string     // e.g. "", "perl"
 	op          MkOperator //
 	valueAlign  string     // The text up to and including the assignment operator, e.g. VARNAME+=\t
 	value       string     // The trimmed value
 	valueMk     []*MkToken // The value, sent through splitIntoMkWords
 	valueMkRest string     // nonempty in case of parse errors
 	fields      []string   // The value, space-separated according to shell quoting rules
 	comment     string
+}
 type mkLineShell struct {
 	command string
+}
 type mkLineComment struct{} // See mkLineAssignImpl.commented for another type of comment line
 type mkLineEmpty struct{}
 type mkLineDirective = *mkLineDirectiveImpl // See https://github.com/golang/go/issues/28045
 type mkLineDirectiveImpl struct {
 	indent    string // the space between the leading "." and the directive
 	directive string // "if", "else", "for", etc.
 	args      string
-	comment   string // mainly interesting for .endif and .endfor
+	comment   string   // mainly interesting for .endif and .endfor
-	elseLine  MkLine // for .if (filled in later)
+	elseLine  MkLine   // for .if (filled in later)
-	cond      MkCond // for .if and .elif (filled in later as needed)
+	cond      MkCond   // for .if and .elif (filled in on first access)
 	fields    []string // the arguments for the .for loop (filled in on first access)
+}
 type mkLineInclude = *mkLineIncludeImpl // See https://github.com/golang/go/issues/28045
 type mkLineIncludeImpl struct {
 	mustExist       bool     // for .sinclude, nonexistent files are ignored
 	sys             bool     // whether the include uses <file.mk> (very rare) instead of "file.mk"
 	indent          string   // the space between the leading "." and the directive
 	includedFile    string   // the text between the <brackets> or "quotes"
 	conditionalVars []string // variables on which this inclusion depends (filled in later, as needed)
+}
 type mkLineDependency struct {
 	targets string
 	sources string
+}
 @@ -100,45 +102,46 @@ func NewMkLine(line Line) *MkLineImpl {
 				"continues until the end of the line.  To escape the #, write \\#.")
+		}
 		return &MkLineImpl{line, &mkLineAssignImpl{
 			commented,
 			varname,
 			varnameCanon(varname),
 			varnameParam(varname),
 			NewMkOperator(op),
 			valueAlign,
 			strings.Replace(value, "\\#", "#", -1),
 			nil,
 			"",
 			nil,
 			comment}}
+	}
 	if hasPrefix(text, "\t") {
 		shellcmd := text[1:]
 		return &MkLineImpl{line, mkLineShell{shellcmd}}
+	}
 	trimmedText := trimHspace(text)
 	if strings.HasPrefix(trimmedText, "#") {
 		return &MkLineImpl{line, mkLineComment{}}
+	}
 	if trimmedText == "" {
 		return &MkLineImpl{line, mkLineEmpty{}}
+	}
 	if m, indent, directive, args, comment := matchMkDirective(text); m {
-		return &MkLineImpl{line, &mkLineDirectiveImpl{indent, directive, args, comment, nil, nil}}
+		return &MkLineImpl{line, &mkLineDirectiveImpl{indent, directive, args, comment, nil, nil, nil}}
+	}
 	if m, indent, directive, includedFile := MatchMkInclude(text); m {
 		return &MkLineImpl{line, &mkLineIncludeImpl{directive == "include", false, indent, includedFile, nil}}
+	}
 	if m, indent, directive, includedFile := match3(text, `^\.([\t ]*)(s?include)[\t ]+<([^>]+)>[\t ]*(?:#.*)?$`); m {
 		return &MkLineImpl{line, &mkLineIncludeImpl{directive == "include", true, indent, includedFile, nil}}
+	}
 	// XXX: Replace this regular expression with proper parsing.
 	// There might be a ${VAR:M*.c} in these variables, which currently confuses the "parser".
 	if m, targets, whitespace, sources := match3(text, `^([^\t :]+(?:[\t ]*[^\t :]+)*)([\t ]*):[\t ]*([^#]*?)(?:[\t ]*#.*)?$`); m {
 @@ -462,37 +465,72 @@ func (mkline *MkLineImpl) ValueTokens()
+	}
 	assign := mkline.data.(mkLineAssign)
 	if assign.valueMk != nil || assign.valueMkRest != "" {
 		return assign.valueMk
+	}
 	p := NewMkParser(mkline.Line, value, true)
 	assign.valueMk = p.MkTokens()
 	assign.valueMkRest = p.Rest()
 	return assign.valueMk
+}
 // Fields applies to variable assignments and .for loops.
 // For variable assignments, it returns the right-hand side, properly split into words.
 // For .for loops, it returns all arguments (including variable names), properly split into words.
 func (mkline *MkLineImpl) Fields() []string {
 	if mkline.IsVarassign() {
 		value := mkline.Value()
 		if value == "" {
 			return nil
+		}
 		assign := mkline.data.(mkLineAssign)
 		if assign.fields != nil {
 			return assign.fields
+		}
 		assign.fields = mkline.ValueFields(value)
 		return assign.fields
+	}
 	// For .for loops.
 	args := mkline.Args()
 	if args == "" {
 		return nil
+	}
 	directive := mkline.data.(mkLineDirective)
 	if directive.fields != nil {
 		return directive.fields
+	}
 	directive.fields = mkline.ValueFields(args)
 	return directive.fields
+}
 func (mkline *MkLineImpl) WithoutMakeVariables(value string) string {
 	valueNovar := ""
 	for _, token := range NewMkParser(nil, value, false).MkTokens() {
 		if token.Varuse == nil {
 			valueNovar += token.Text
+		}
+	}
 	return valueNovar
+}
-func (mkline *MkLineImpl) ResolveVarsInRelativePath(relativePath string, adjustDepth bool) string {
+func (mkline *MkLineImpl) ResolveVarsInRelativePath(relativePath string) string {
 	var basedir string
 	if G.Pkg != nil {
 		basedir = G.Pkg.File(".")
 	} else {
 		basedir = path.Dir(mkline.Filename)
+	}
 	pkgsrcdir := relpath(basedir, G.Pkgsrc.File("."))
 	if G.Testing {
 		// Relative pkgsrc paths usually only contain two or three levels.
 		// A possible reason for reaching this assertion is:
 		// Tests that access the file system must create their lines
 @@ -516,33 +554,26 @@ func (mkline *MkLineImpl) ResolveVarsInR
 	replaceLatest("${LUA_PKGSRCDIR}", "lang", `^lua[0-9]+$`, "../../lang/$0")
 	replaceLatest("${PHPPKGSRCDIR}", "lang", `^php[0-9]+$`, "../../lang/$0")
 	replaceLatest("${SUSE_DIR_PREFIX}", "emulators", `^(suse[0-9]+)_base$`, "$1")
 	replaceLatest("${PYPKGSRCDIR}", "lang", `^python[0-9]+$`, "../../lang/$0")
 	replaceLatest("${PYPACKAGE}", "lang", `^python[0-9]+$`, "$0")
 	if G.Pkg != nil {
 		// XXX: Even if these variables are defined indirectly,
 		// pkglint should be able to resolve them properly.
 		// There is already G.Pkg.Value, maybe that can be used here.
 		tmp = strings.Replace(tmp, "${FILESDIR}", G.Pkg.Filesdir, -1)
 		tmp = strings.Replace(tmp, "${PKGDIR}", G.Pkg.Pkgdir, -1)
+	}
 	// TODO: What is this good for, and in which cases does it make a difference?
 	if adjustDepth {
 		if hasPrefix(tmp, "../../") && !hasPrefix(tmp[6:], ".") {
 			tmp = pkgsrcdir + "/" + tmp[6:]
 	tmp = cleanpath(tmp)
 	if trace.Tracing && relativePath != tmp {
 		trace.Step2("resolveVarsInRelativePath: %q => %q", relativePath, tmp)
+	}
 	return tmp
+}
 func (mkline *MkLineImpl) ExplainRelativeDirs() {
 	G.Explain(
 		"Directories in the form \"../../category/package\" make it easier to",
 		"move a package around in pkgsrc, for example from pkgsrc-wip to the",
 		"main pkgsrc repository.")

--- pkgsrc/pkgtools/pkglint/files/Attic/pkglint.go 2018/12/02 01:57:48 1.41
+++ pkgsrc/pkgtools/pkglint/files/Attic/pkglint.go 2018/12/02 23:12:43 1.42

	@@ -349,27 +349,27 @@ func (pkglint *Pkglint) checkdirPackage(		@@ -349,27 +349,27 @@ func (pkglint *Pkglint) checkdirPackage(
349	}	349	}
350		350
351	haveDistinfo := false	351	haveDistinfo := false
352	havePatches := false	352	havePatches := false
353		353
354	// Determine the used variables and PLIST directories before checking any of the Makefile fragments.	354	// Determine the used variables and PLIST directories before checking any of the Makefile fragments.
355	for _, filename := range files {	355	for _, filename := range files {
356	basename := path.Base(filename)	356	basename := path.Base(filename)
357	if (hasPrefix(basename, "Makefile.") \|\| hasSuffix(filename, ".mk")) &&	357	if (hasPrefix(basename, "Makefile.") \|\| hasSuffix(filename, ".mk")) &&
358	!matches(filename, `patch-`) &&	358	!matches(filename, `patch-`) &&
359	!contains(filename, pkg.Pkgdir+"/") &&	359	!contains(filename, pkg.Pkgdir+"/") &&
360	!contains(filename, pkg.Filesdir+"/") {	360	!contains(filename, pkg.Filesdir+"/") {
361	if fragmentMklines := LoadMk(filename, MustSucceed); fragmentMklines != nil {	361	if fragmentMklines := LoadMk(filename, MustSucceed); fragmentMklines != nil {
362	fragmentMklines.DetermineUsedVariables()	362	fragmentMklines.collectUsedVariables()
363	}	363	}
364	}	364	}
365	if hasPrefix(basename, "PLIST") {	365	if hasPrefix(basename, "PLIST") {
366	pkg.loadPlistDirs(filename)	366	pkg.loadPlistDirs(filename)
367	}	367	}
368	}	368	}
369		369
370	for _, filename := range files {	370	for _, filename := range files {
371	if containsVarRef(filename) {	371	if containsVarRef(filename) {
372	if trace.Tracing {	372	if trace.Tracing {
373	trace.Stepf("Skipping file %q because the name contains an unresolved variable.", filename)	373	trace.Stepf("Skipping file %q because the name contains an unresolved variable.", filename)
374	}	374	}
375	continue	375	continue
	@@ -412,26 +412,28 @@ func (pkglint *Pkglint) Assertf(cond boo		@@ -412,26 +412,28 @@ func (pkglint *Pkglint) Assertf(cond boo
412	}	412	}
413		413
414	// Returns the pkgsrc top-level directory, relative to the given file or directory.	414	// Returns the pkgsrc top-level directory, relative to the given file or directory.
415	func findPkgsrcTopdir(filename string) string {	415	func findPkgsrcTopdir(filename string) string {
416	for _, dir := range [...]string{".", "..", "../..", "../../.."} {	416	for _, dir := range [...]string{".", "..", "../..", "../../.."} {
417	if fileExists(filename + "/" + dir + "/mk/bsd.pkg.mk") {	417	if fileExists(filename + "/" + dir + "/mk/bsd.pkg.mk") {
418	return dir	418	return dir
419	}	419	}
420	}	420	}
421	return ""	421	return ""
422	}	422	}
423		423
424	func resolveVariableRefs(text string) (resolved string) {	424	func resolveVariableRefs(text string) (resolved string) {
		425	// TODO: How does this fit into the Scope type, which is newer than this function?
		426
425	if !contains(text, "${") {	427	if !contains(text, "${") {
426	return text	428	return text
427	}	429	}
428		430
429	visited := make(map[string]bool) // To prevent endless loops	431	visited := make(map[string]bool) // To prevent endless loops
430		432
431	replacer := func(m string) string {	433	replacer := func(m string) string {
432	varname := m[2 : len(m)-1]	434	varname := m[2 : len(m)-1]
433	if !visited[varname] {	435	if !visited[varname] {
434	visited[varname] = true	436	visited[varname] = true
435	if G.Pkg != nil {	437	if G.Pkg != nil {
436	if value, ok := G.Pkg.vars.Value(varname); ok {	438	if value, ok := G.Pkg.vars.Value(varname); ok {
437	return value	439	return value

--- pkgsrc/pkgtools/pkglint/files/Attic/mkline_test.go 2018/12/02 01:57:48 1.45
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkline_test.go 2018/12/02 23:12:43 1.46

 @@ -385,27 +385,27 @@ func (s *Suite) Test_MkLine_VariableNeed
+}
 func (s *Suite) Test_MkLine_VariableNeedsQuoting__command_in_command(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	t.SetupTool("find", "FIND", AtRunTime)
 	t.SetupTool("sort", "SORT", AtRunTime)
 	G.Pkg = NewPackage(t.File("category/pkgbase"))
 	G.Mk = t.NewMkLines("Makefile",
 		MkRcsID,
 		"GENERATE_PLIST= cd ${DESTDIR}${PREFIX}; ${FIND} * \\( -type f -or -type l \\) | ${SORT};")
-	G.Mk.DetermineDefinedVariables()
+	G.Mk.collectDefinedVariables()
 	MkLineChecker{G.Mk.mklines[1]}.Check()
 	t.CheckOutputLines(
 		"WARN: Makefile:2: The exitcode of \"${FIND}\" at the left of the | operator is ignored.")
+}
 func (s *Suite) Test_MkLine_VariableNeedsQuoting__word_as_part_of_word(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	G.Mk = t.NewMkLines("Makefile",
 		MkRcsID,
 		"EGDIR=\t${EGDIR}/${MACHINE_GNU_PLATFORM}")
 @@ -906,27 +906,27 @@ func (s *Suite) Test_MkLine_ValueTokens_
 func (s *Suite) Test_MkLine_ResolveVarsInRelativePath(c *check.C) {
 	t := s.Init(c)
 	t.CreateFileLines("lang/lua53/Makefile")
 	t.CreateFileLines("lang/php72/Makefile")
 	t.CreateFileLines("emulators/suse100_base/Makefile")
 	t.CreateFileLines("lang/python36/Makefile")
 	mklines := t.SetupFileMkLines("Makefile",
 		MkRcsID)
 	mkline := mklines.mklines[0]
 	checkResolve := func(before string, after string) {
-		c.Check(mkline.ResolveVarsInRelativePath(before, false), equals, after)
+		c.Check(mkline.ResolveVarsInRelativePath(before), equals, after)
+	}
 	checkResolve("", ".")
 	checkResolve("${LUA_PKGSRCDIR}", "../../lang/lua53")
 	checkResolve("${PHPPKGSRCDIR}", "../../lang/php72")
 	checkResolve("${SUSE_DIR_PREFIX}", "suse100")
 	checkResolve("${PYPKGSRCDIR}", "../../lang/python36")
 	checkResolve("${PYPACKAGE}", "python36")
 	checkResolve("${FILESDIR}", "${FILESDIR}")
 	checkResolve("${PKGDIR}", "${PKGDIR}")
 	G.Pkg = NewPackage(t.File("category/package"))

--- pkgsrc/pkgtools/pkglint/files/Attic/mklinechecker.go 2018/12/02 01:57:48 1.23
+++ pkgsrc/pkgtools/pkglint/files/Attic/mklinechecker.go 2018/12/02 23:12:43 1.24

 @@ -152,27 +152,27 @@ func (ck MkLineChecker) checkDirective(f
+		}
 	case directive == "if" || directive == "elif":
 		ck.checkDirectiveCond()
 	case directive == "ifdef" || directive == "ifndef":
 		mkline.Warnf("The \".%s\" directive is deprecated. Please use \".if %sdefined(%s)\" instead.",
 			directive, ifelseStr(directive == "ifdef", "", "!"), args)
 	case directive == "for":
 		ck.checkDirectiveFor(forVars, ind)
 	case directive == "undef":
-		for _, varname := range fields(args) {
+		for _, varname := range mkline.Fields() {
 			if forVars[varname] {
 				mkline.Notef("Using \".undef\" after a \".for\" loop is unnecessary.")
+			}
+		}
+	}
+}
 func (ck MkLineChecker) checkDirectiveEnd(ind *Indentation) {
 	mkline := ck.MkLine
 	directive := mkline.Directive()
 	comment := mkline.DirectiveComment()
 	if directive == "endif" && comment != "" {
 @@ -193,28 +193,28 @@ func (ck MkLineChecker) checkDirectiveEn
 func (ck MkLineChecker) checkDirectiveFor(forVars map[string]bool, indentation *Indentation) {
 	mkline := ck.MkLine
 	args := mkline.Args()
 	if m, vars, _ := match2(args, `^([^\t ]+(?:[\t ]*[^\t ]+)*?)[\t ]+in[\t ]+(.*)$`); m {
 		for _, forvar := range fields(vars) {
 			indentation.AddVar(forvar)
 			if !G.Infrastructure && hasPrefix(forvar, "_") {
 				mkline.Warnf("Variable names starting with an underscore (%s) are reserved for internal pkgsrc use.", forvar)
+			}
 			if matches(forvar, `^[_a-z][_a-z0-9]*$`) {
 				// Fine.
-			} else if strings.IndexFunc(forvar, func(r rune) bool { return 'A' <= r && r <= 'Z' }) != -1 {
+			} else if matches(forvar, `^[A-Z_a-z][0-9A-Z_a-z]*$`) {
-				mkline.Warnf(".for variable names should not contain uppercase letters.")
+				mkline.Warnf("The variable name %q in the .for loop should not contain uppercase letters.", forvar)
 			} else {
 				mkline.Errorf("Invalid variable name %q.", forvar)
+			}
 			forVars[forvar] = true
+		}
 		// XXX: The type BtUnknown is very unspecific here. For known variables
 		// or constant values this could probably be improved.
 		//
 		// The guessed flag could also be determined more correctly. As of November 2018,
 		// running pkglint over the whole pkgsrc tree did not produce any different result
 		// whether guessed was true or false, so currently it is not worth investing
 @@ -754,46 +754,46 @@ func (ck MkLineChecker) checkVaruseDepre
 		return
+	}
 	varname := varuse.varname
 	instead := G.Pkgsrc.Deprecated[varname]
 	if instead == "" {
 		instead = G.Pkgsrc.Deprecated[varnameCanon(varname)]
+	}
 	if instead != "" {
 		ck.MkLine.Warnf("Use of %q is deprecated. %s", varname, instead)
+	}
+}
-func (ck MkLineChecker) checkVarassignDecreasingVersions(varname, value string) {
+func (ck MkLineChecker) checkVarassignDecreasingVersions() {
 	if trace.Tracing {
-		defer trace.Call2(varname, value)()
+		defer trace.Call0()()
+	}
 	mkline := ck.MkLine
-	strVersions := fields(value)
+	strVersions := mkline.Fields()
 	intVersions := make([]int, len(strVersions))
 	for i, strVersion := range strVersions {
 		iver, err := strconv.Atoi(strVersion)
 		if err != nil || !(iver > 0) {
-			mkline.Errorf("All values for %s must be positive integers.", varname)
+			mkline.Errorf("All values for %s must be positive integers.", mkline.Varname())
 			return
+		}
 		intVersions[i] = iver
+	}
 	for i, ver := range intVersions {
 		if i > 0 && ver >= intVersions[i-1] {
-			mkline.Warnf("The values for %s should be in decreasing order.", varname)
+			mkline.Warnf("The values for %s should be in decreasing order.", mkline.Varname())
 			G.Explain(
 				"If they aren't, it may be possible that needless versions of",
 				"packages are installed.")
+		}
+	}
+}
 func (ck MkLineChecker) checkVarassign() {
 	mkline := ck.MkLine
 	varname := mkline.Varname()
 	op := mkline.Op()
 	value := mkline.Value()
 	comment := mkline.VarassignComment()
 @@ -935,54 +935,54 @@ func (ck MkLineChecker) checkVarassignSp
 	mkline := ck.MkLine
 	varname := mkline.Varname()
 	value := mkline.Value()
 	if contains(value, "/etc/rc.d") && mkline.Varname() != "RPMIGNOREPATH" {
 		mkline.Warnf("Please use the RCD_SCRIPTS mechanism to install rc.d scripts automatically to ${RCD_SCRIPTS_EXAMPLEDIR}.")
+	}
 	if hasPrefix(varname, "_") && !G.Infrastructure {
 		mkline.Warnf("Variable names starting with an underscore (%s) are reserved for internal pkgsrc use.", varname)
+	}
 	if varname == "PYTHON_VERSIONS_ACCEPTED" {
-		ck.checkVarassignDecreasingVersions(varname, value)
+		ck.checkVarassignDecreasingVersions()
+	}
 	if mkline.VarassignComment() == "# defined" && !hasSuffix(varname, "_MK") && !hasSuffix(varname, "_COMMON") {
 		mkline.Notef("Please use \"# empty\", \"# none\" or \"# yes\" instead of \"# defined\".")
 		G.Explain(
 			"The value #defined says something about the state of the variable,",
 			"but not what that _means_.  In some cases a variable that is defined",
 			"means \"yes\", in other cases it is an empty list (which is also",
 			"only the state of the variable), whose meaning could be described",
 			"with \"none\".  It is this meaning that should be described.")
+	}
 	if varname == "DIST_SUBDIR" || varname == "WRKSRC" {
 		if m, revVarname := match1(value, `\$\{(PKGNAME|PKGVERSION)[:\}]`); m {
 			mkline.Warnf("%s should not be used in %s as it includes the PKGREVISION. "+
 				"Please use %[1]s_NOREV instead.", revVarname, varname)
+		}
+	}
 	if hasPrefix(varname, "SITES_") {
 		mkline.Warnf("SITES_* is deprecated. Please use SITES.* instead.")
 		// No autofix since it doesn't occur anymore.
+	}
 	if varname == "PKG_SKIP_REASON" && G.Mk.indentation.DependsOn("OPSYS") {
-		mkline.Notef("Consider defining NOT_FOR_PLATFORM instead of " +
+		mkline.Notef("Consider setting NOT_FOR_PLATFORM instead of " +
-			"setting PKG_SKIP_REASON depending on ${OPSYS}.")
+			"PKG_SKIP_REASON depending on ${OPSYS}.")
+	}
+}
 func (ck MkLineChecker) checkVarassignBsdPrefs() {
 	mkline := ck.MkLine
 	switch mkline.Varcanon() {
 	case "BUILDLINK_PKGSRCDIR.*",
 		"BUILDLINK_DEPMETHOD.*",
 		"BUILDLINK_ABI_DEPENDS.*",
 		"BUILDLINK_INCDIRS.*",
 		"BUILDLINK_LIBDIRS.*":
 		return
 @@ -1141,150 +1141,179 @@ func (ck MkLineChecker) checkTextDepreca
 func (ck MkLineChecker) checkDirectiveCond() {
 	mkline := ck.MkLine
 	if trace.Tracing {
 		defer trace.Call1(mkline.Args())()
+	}
 	p := NewMkParser(nil, mkline.Args(), false) // No emitWarnings here, see the code below.
 	cond := p.MkCond()
 	if !p.EOF() {
 		mkline.Warnf("Invalid condition, unrecognized part: %q.", p.Rest())
 		return
+	}
 	checkEmpty := func(varuse *MkVarUse) {
 		varname := varuse.varname
 		if matches(varname, `^\$.*:[MN]`) {
 			mkline.Warnf("The empty() function takes a variable name as parameter, not a variable expression.")
 			G.Explain(
 				"Instead of empty(${VARNAME:Mpattern}), you should write either",
 				"of the following:",
 				"",
 				"\tempty(VARNAME:Mpattern)",
 				"\t${VARNAME:Mpattern} == \"\"",
 				"",
 				"Instead of !empty(${VARNAME:Mpattern}), you should write either",
 				"of the following:",
 				"",
 				"\t!empty(VARNAME:Mpattern)",
 				"\t${VARNAME:Mpattern}")
 		modifiers := varuse.modifiers
 		for _, modifier := range modifiers {
 			if m, positive, pattern := modifier.MatchMatch(); m && (positive || len(modifiers) == 1) {
 				ck.checkVartype(varname, opUseMatch, pattern, "")
 				vartype := G.Pkgsrc.VariableType(varname)
 				if matches(pattern, `^[\w-/]+$`) && vartype != nil && !vartype.IsConsideredList() {
 					mkline.Notef("%s should be compared using == instead of the :M or :N modifier without wildcards.", varname)
 					G.Explain(
 						"This variable has a single value, not a list of values.  Therefore",
 						"it feels strange to apply list operators like :M and :N onto it.",
 						"A more direct approach is to use the == and != operators.",
 						"",
 						"An entirely different case is when the pattern contains wildcards",
 						"like ^, *, $.  In such a case, using the :M or :N modifiers is",
 						"useful and preferred.")
 	checkCompareVarStr := func(varuse *MkVarUse, op string, value string) {
 		varname := varuse.varname
 		varmods := varuse.modifiers
-		if len(varmods) == 0 {
+		switch len(varmods) {
 		case 0:
 			ck.checkCompareVarStr(varname, op, value)
 		} else if len(varmods) == 1 {
 		case 1:
 			if m, _, _ := varmods[0].MatchMatch(); m && value != "" {
 				ck.checkVartype(varname, opUseMatch, value, "")
+			}
 		default:
 			// This case covers ${VAR:Mfilter:O:u} or similar uses in conditions.
 			// To check these properly, pkglint first needs to know the most common modifiers and how they interact.
 			// As of November 2018, the modifiers are not modeled.
 			// The following tracing statement makes it easy to discover these cases,
 			// in order to decide whether checking them is worthwhile.
 			if trace.Tracing {
 				trace.Stepf("checkCompareVarStr ${%s%s} %s %s", varuse.varname, varuse.Mod(), op, value)
+			}
+		}
+	}
 	checkVarUse := func(varuse *MkVarUse) {
 		var vartype *Vartype // TODO: Insert a better type guess here.
 		vuc := VarUseContext{vartype, vucTimeParse, vucQuotPlain, false}
 		ck.CheckVaruse(varuse, &vuc)
+	}
 	cond.Walk(&MkCondCallback{
-		Empty:         checkEmpty,
+		Empty:         ck.checkDirectiveCondEmpty,
 		CompareVarStr: checkCompareVarStr,
 		VarUse:        checkVarUse})
+}
 // checkDirectiveCondEmpty checks a condition of the form empty(...) in an .if directive.
 func (ck MkLineChecker) checkDirectiveCondEmpty(varuse *MkVarUse) {
 	varname := varuse.varname
 	if matches(varname, `^\$.*:[MN]`) {
 		ck.MkLine.Warnf("The empty() function takes a variable name as parameter, not a variable expression.")
 		G.Explain(
 			"Instead of empty(${VARNAME:Mpattern}), you should write either",
 			"of the following:",
 			"",
 			"\tempty(VARNAME:Mpattern)",
 			"\t${VARNAME:Mpattern} == \"\"",
 			"",
 			"Instead of !empty(${VARNAME:Mpattern}), you should write either",
 			"of the following:",
 			"",
 			"\t!empty(VARNAME:Mpattern)",
 			"\t${VARNAME:Mpattern}")
+	}
 	modifiers := varuse.modifiers
 	for _, modifier := range modifiers {
 		if m, positive, pattern := modifier.MatchMatch(); m && (positive || len(modifiers) == 1) {
 			ck.checkVartype(varname, opUseMatch, pattern, "")
 			vartype := G.Pkgsrc.VariableType(varname)
 			if matches(pattern, `^[\w-/]+$`) && vartype != nil && !vartype.IsConsideredList() {
 				ck.MkLine.Notef("%s should be compared using %s instead of matching against %q.",
 					varname, ifelseStr(positive, "==", "!="), ":"+modifier.Text)
 				G.Explain(
 					"This variable has a single value, not a list of values.",
 					"Therefore it feels strange to apply list operators like :M and :N onto it.",
 					"A more direct approach is to use the == and != operators.",
 					"",
 					"An entirely different case is when the pattern contains wildcards like ^, *, $.",
 					"In such a case, using the :M or :N modifiers is useful and preferred.")
+			}
+		}
+	}
+}
 func (ck MkLineChecker) checkCompareVarStr(varname, op, value string) {
 	ck.checkVartype(varname, opUseCompare, value, "")
 	if varname == "PKGSRC_COMPILER" {
 		ck.MkLine.Warnf("Use ${PKGSRC_COMPILER:%s%s} instead of the %s operator.", ifelseStr(op == "==", "M", "N"), value, op)
 		G.Explain(
 			"The PKGSRC_COMPILER can be a list of chained compilers, e.g. \"ccache",
 			"distcc clang\".  Therefore, comparing it using == or != leads to",
 			"wrong results in these cases.")
+	}
+}
 // CheckRelativePkgdir checks a reference from one pkgsrc package to another.
 // These references should always have the form ../../category/package.
 //
 // When used in DEPENDS or similar variables, these directories could theoretically
 // also be relative to the pkgsrc root, which would save a few keystrokes.
 // This, however, is not implemented in pkgsrc and suggestions regarding this topic
 // have not been made in the last two decades on the public mailing lists.
 // While being a bit redundant, the current scheme works well.
 //
 // When used in .include directives, the relative package directories must be written
 // with the leading ../.. anyway, so the benefit might not be too big at all.
 func (ck MkLineChecker) CheckRelativePkgdir(pkgdir string) {
 	if trace.Tracing {
 		defer trace.Call1(pkgdir)()
+	}
 	mkline := ck.MkLine
 	ck.CheckRelativePath(pkgdir, true)
-	pkgdir = mkline.ResolveVarsInRelativePath(pkgdir, false)
+	pkgdir = mkline.ResolveVarsInRelativePath(pkgdir)
 	// XXX: Is the leading "./" realistic?
 	if m, otherpkgpath := match1(pkgdir, `^(?:\./)?\.\./\.\./([^/]+/[^/]+)$`); m {
 		if !fileExists(G.Pkgsrc.File(otherpkgpath + "/Makefile")) {
 			mkline.Errorf("There is no package in %q.", otherpkgpath)
+		}
 	} else if !containsVarRef(pkgdir) {
 		mkline.Warnf("%q is not a valid relative package directory.", pkgdir)
 		G.Explain(
 			"A relative pathname always starts with \"../../\", followed",
 			"by a category, a slash and a the directory name of the package.",
 			"For example, \"../../misc/screen\" is a valid relative pathname.")
+	}
+}
 // CheckRelativePath checks a relative path that leads to the directory of another package
 // or to a subdirectory thereof or a file within there.
 func (ck MkLineChecker) CheckRelativePath(relativePath string, mustExist bool) {
 	if trace.Tracing {
 		defer trace.Call(relativePath, mustExist)()
+	}
 	mkline := ck.MkLine
 	if !G.Wip && contains(relativePath, "/wip/") {
 		mkline.Errorf("A main pkgsrc package must not depend on a pkgsrc-wip package.")
+	}
-	resolvedPath := mkline.ResolveVarsInRelativePath(relativePath, true)
+	resolvedPath := mkline.ResolveVarsInRelativePath(relativePath)
 	if containsVarRef(resolvedPath) {
 		return
+	}
 	abs := resolvedPath
 	if !hasPrefix(abs, "/") {
 		abs = path.Dir(mkline.Filename) + "/" + abs
+	}
 	if _, err := os.Stat(abs); err != nil {
 		if mustExist {
-			mkline.Errorf("%q does not exist.", resolvedPath)
+			mkline.Errorf("Relative path %q does not exist.", resolvedPath)
+		}
 		return
+	}
 	switch {
 	case !hasPrefix(relativePath, "../"):
 		break
 	case hasPrefix(relativePath, "../../mk/"):
 		// From a package to the infrastructure.
 	case matches(relativePath, `^\.\./\.\./[^/]+/[^/]`):
 		// From a package to another package.
 	case hasPrefix(relativePath, "../mk/") && relpath(path.Dir(mkline.Filename), G.Pkgsrc.File(".")) == "..":
 		// For category Makefiles.
 	default:
 		mkline.Warnf("Invalid relative path %q.", relativePath)
 		// TODO: Explain this warning.
+	}
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/mklinechecker_test.go 2018/12/02 01:57:48 1.19
+++ pkgsrc/pkgtools/pkglint/files/Attic/mklinechecker_test.go 2018/12/02 23:12:43 1.20

 @@ -13,119 +13,164 @@ func (s *Suite) Test_MkLineChecker_Check
 	t.CheckOutputLines(
 		"ERROR: filename.mk:1: This comment indicates unfinished work (url2pkg).")
+}
 func (s *Suite) Test_MkLineChecker_Check__buildlink3_include_prefs(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	t.CreateFileLines("mk/bsd.prefs.mk")
 	mklines := t.SetupFileMkLines("category/package/buildlink3.mk",
 		".include \"../../mk/bsd.prefs.mk\"")
-	// If the buildlink3.mk file is not actually created, resolving the
+	// If the buildlink3.mk file doesn't actually exist, resolving the
 	// relative path fails since that depends on the actual file system,
 	// not on syntactical paths; see os.Stat in CheckRelativePath.
 	//
 	// TODO: Refactor relpath to be independent of a filesystem.
 	MkLineChecker{mklines.mklines[0]}.Check()
 	t.CheckOutputLines(
-		"NOTE: ~/category/package/buildlink3.mk:1: For efficiency reasons, please include bsd.fast.prefs.mk instead of bsd.prefs.mk.")
+		"NOTE: ~/category/package/buildlink3.mk:1: For efficiency reasons, " +
 			"please include bsd.fast.prefs.mk instead of bsd.prefs.mk.")
+}
 func (s *Suite) Test_MkLineChecker_checkInclude(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	t.CreateFileLines("pkgtools/x11-links/buildlink3.mk")
 	t.CreateFileLines("graphics/jpeg/buildlink3.mk")
 	t.CreateFileLines("devel/intltool/buildlink3.mk")
 	t.CreateFileLines("devel/intltool/builtin.mk")
 	mklines := t.SetupFileMkLines("category/package/filename.mk",
 		MkRcsID,
 		"",
 		".include \"../../pkgtools/x11-links/buildlink3.mk\"",
 		".include \"../../graphics/jpeg/buildlink3.mk\"",
 		".include \"../../devel/intltool/buildlink3.mk\"",
 		".include \"../../devel/intltool/builtin.mk\"")
 	mklines.Check()
 	t.CheckOutputLines(
-		"ERROR: ~/category/package/filename.mk:3: ../../pkgtools/x11-links/buildlink3.mk must not be included directly. "+
+		"ERROR: ~/category/package/filename.mk:3: "+
 			"../../pkgtools/x11-links/buildlink3.mk must not be included directly. "+
 			"Include \"../../mk/x11.buildlink3.mk\" instead.",
-		"ERROR: ~/category/package/filename.mk:4: ../../graphics/jpeg/buildlink3.mk must not be included directly. "+
+		"ERROR: ~/category/package/filename.mk:4: "+
 			"../../graphics/jpeg/buildlink3.mk must not be included directly. "+
 			"Include \"../../mk/jpeg.buildlink3.mk\" instead.",
-		"WARN: ~/category/package/filename.mk:5: Please write \"USE_TOOLS+= intltool\" instead of this line.",
+		"WARN: ~/category/package/filename.mk:5: "+
-		"ERROR: ~/category/package/filename.mk:6: ../../devel/intltool/builtin.mk must not be included directly. "+
+			"Please write \"USE_TOOLS+= intltool\" instead of this line.",
 		"ERROR: ~/category/package/filename.mk:6: "+
 			"../../devel/intltool/builtin.mk must not be included directly. "+
 			"Include \"../../devel/intltool/buildlink3.mk\" instead.")
+}
 func (s *Suite) Test_MkLineChecker_checkInclude__Makefile(c *check.C) {
 	t := s.Init(c)
 	mkline := t.NewMkLine(t.File("Makefile"), 2, ".include \"../../other/package/Makefile\"")
 	MkLineChecker{mkline}.checkInclude()
 	t.CheckOutputLines(
-		"ERROR: ~/Makefile:2: \"other/package/Makefile\" does not exist.",
+		"ERROR: ~/Makefile:2: Relative path \"../../other/package/Makefile\" does not exist.",
 		"ERROR: ~/Makefile:2: Other Makefiles must not be included directly.")
+}
 func (s *Suite) Test_MkLineChecker_checkInclude__Makefile_exists(c *check.C) {
 	t := s.Init(c)
 	t.CreateFileLines("other/existing/Makefile")
 	t.SetupPackage("category/package",
 		".include \"../../other/existing/Makefile\"",
 		".include \"../../other/not-found/Makefile\"")
 	G.checkdirPackage(t.File("category/package"))
 	t.CheckOutputLines(
 		"ERROR: ~/category/package/Makefile:20: Cannot read \"../../other/existing/Makefile\".")
+}
 func (s *Suite) Test_MkLineChecker_checkDirective(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	mklines := t.NewMkLines("category/package/filename.mk",
 		MkRcsID,
 		"",
 		".for",
 		".endfor",
 		"",
 		".if",
 		".else don't",
 		".endif invalid-arg",
 		"",
 		".ifdef FNAME_MK",
 		".endif",
 		".ifndef FNAME_MK",
 		".endif",
 		"",
 		".for var in a b c",
 		".endfor",
-		".undef var",
+		".undef var")
 	mklines.Check()
 	t.CheckOutputLines(
 		"ERROR: category/package/filename.mk:3: \".for\" requires arguments.",
 		"ERROR: category/package/filename.mk:6: \".if\" requires arguments.",
 		"ERROR: category/package/filename.mk:7: \".else\" does not take arguments. "+
 			"If you meant \"else if\", use \".elif\".",
 		"ERROR: category/package/filename.mk:8: \".endif\" does not take arguments.",
 		"WARN: category/package/filename.mk:10: The \".ifdef\" directive is deprecated. "+
 			"Please use \".if defined(FNAME_MK)\" instead.",
 		"WARN: category/package/filename.mk:12: The \".ifndef\" directive is deprecated. "+
 			"Please use \".if !defined(FNAME_MK)\" instead.",
 		"NOTE: category/package/filename.mk:17: Using \".undef\" after a \".for\" loop is unnecessary.")
+}
 func (s *Suite) Test_MkLineChecker_checkDirective__for_loop_varname(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	mklines := t.NewMkLines("filename.mk",
 		MkRcsID,
 		"",
 		".for VAR in a b c", // Should be lowercase.
 		".endfor",
 		"",
-		".for VAR in a b c",
+		".for _var_ in a b c", // Should be written without underscores.
 		".endfor",
 		"",
-		".for $ in a b c",
+		".for .var. in a b c", // Should be written without dots.
 		".endfor",
 		"",
 		".for ${VAR} in a b c", // The variable name really must be an identifier.
 		".endfor")
 	mklines.Check()
 	t.CheckOutputLines(
-		"ERROR: category/package/filename.mk:3: \".for\" requires arguments.",
+		"WARN: filename.mk:3: The variable name \"VAR\" in the .for loop should not contain uppercase letters.",
-		"ERROR: category/package/filename.mk:6: \".if\" requires arguments.",
+		"WARN: filename.mk:6: Variable names starting with an underscore (_var_) are reserved for internal pkgsrc use.",
-		"ERROR: category/package/filename.mk:7: \".else\" does not take arguments. If you meant \"else if\", use \".elif\".",
+		"ERROR: filename.mk:9: Invalid variable name \".var.\".",
-		"ERROR: category/package/filename.mk:8: \".endif\" does not take arguments.",
+		"ERROR: filename.mk:12: Invalid variable name \"${VAR}\".")
 		"WARN: category/package/filename.mk:10: The \".ifdef\" directive is deprecated. Please use \".if defined(FNAME_MK)\" instead.",
 		"WARN: category/package/filename.mk:12: The \".ifndef\" directive is deprecated. Please use \".if !defined(FNAME_MK)\" instead.",
 		"NOTE: category/package/filename.mk:17: Using \".undef\" after a \".for\" loop is unnecessary.",
 		"WARN: category/package/filename.mk:19: .for variable names should not contain uppercase letters.",
 		"ERROR: category/package/filename.mk:22: Invalid variable name \"$\".")
+}
 func (s *Suite) Test_MkLineChecker_checkDependencyRule(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	mklines := t.NewMkLines("category/package/filename.mk",
 		MkRcsID,
 		"",
 		".PHONY: target-1",
 		"target-2: .PHONY",
 		".ORDER: target-1 target-2",
 @@ -135,55 +180,55 @@ func (s *Suite) Test_MkLineChecker_check
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: category/package/filename.mk:8: Unusual target \"target-3\".")
+}
 func (s *Suite) Test_MkLineChecker_checkVartype__simple_type(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wtypes")
 	t.SetupVartypes()
-	vartype1 := G.Pkgsrc.vartypes["COMMENT"]
+	// Since COMMENT is defined in vardefs.go its type is certain instead of guessed.
 	c.Assert(vartype1, check.NotNil)
 	c.Check(vartype1.guessed, equals, false)
 	vartype := G.Pkgsrc.VariableType("COMMENT")
 	c.Assert(vartype, check.NotNil)
 	c.Check(vartype.basicType.name, equals, "Comment")
 	c.Check(vartype.guessed, equals, false)
 	c.Check(vartype.kindOfList, equals, lkNone)
 	mkline := t.NewMkLine("Makefile", 123, "COMMENT=\tA nice package")
 	MkLineChecker{mkline}.checkVartype(mkline.Varname(), mkline.Op(), mkline.Value(), mkline.VarassignComment())
 	t.CheckOutputLines(
 		"WARN: Makefile:123: COMMENT should not begin with \"A\".")
+}
 func (s *Suite) Test_MkLineChecker_checkVartype(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	mkline := t.NewMkLine("filename", 1, "DISTNAME=gcc-${GCC_VERSION}")
 	MkLineChecker{mkline}.checkVartype("DISTNAME", opAssign, "gcc-${GCC_VERSION}", "")
 	t.CheckOutputEmpty()
+}
 // The command line option -Wno-types can be used to suppress the type checks.
 // Suppressing it is rarely needed and comes from Feb 12 2005 when this feature was introduced.
 // Since then the type system has matured and proven effective.
 func (s *Suite) Test_MkLineChecker_checkVartype__skip(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wno-types")
 	t.SetupVartypes()
 	mkline := t.NewMkLine("filename", 1, "DISTNAME=invalid:::distname")
 	MkLineChecker{mkline}.Check()
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_MkLineChecker_checkVartype__append_to_non_list(c *check.C) {
 @@ -207,96 +252,84 @@ func (s *Suite) Test_MkLineChecker_check
 // splitting this URL at the ampersand.
 func (s *Suite) Test_MkLineChecker_checkVarassign__URL_with_shell_special_characters(c *check.C) {
 	t := s.Init(c)
 	G.Pkg = NewPackage(t.File("graphics/gimp-fix-ca"))
 	t.SetupVartypes()
 	mkline := t.NewMkLine("filename", 10, "MASTER_SITES=http://registry.gimp.org/file/fix-ca.c?action=download&id=9884&file=")
 	MkLineChecker{mkline}.checkVarassign()
 	t.CheckOutputEmpty()
+}
-func (s *Suite) Test_MkLineChecker_Check__conditions(c *check.C) {
+func (s *Suite) Test_MkLineChecker_checkDirectiveCond(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wtypes")
 	t.SetupVartypes()
 	testCond := func(cond string, output ...string) {
 		MkLineChecker{t.NewMkLine("filename", 1, cond)}.checkDirectiveCond()
 		if len(output) > 0 {
 			t.CheckOutputLines(output...)
 		} else {
 			t.CheckOutputEmpty()
+		}
+	}
 	testCond(".if !empty(PKGSRC_COMPILER:Mmycc)",
 		"WARN: filename:1: The pattern \"mycc\" cannot match any of "+
 			"{ ccache ccc clang distcc f2c gcc hp icc ido "+
 			"mipspro mipspro-ucode pcc sunpro xlc } for PKGSRC_COMPILER.")
 	testCond(".elif ${A} != ${B}")
 	testCond(".if ${HOMEPAGE} == \"mailto:someone@example.org\"",
 		"WARN: filename:1: \"mailto:someone@example.org\" is not a valid URL.")
 	testCond(".if !empty(PKGSRC_RUN_TEST:M[Y][eE][sS])",
-		"WARN: filename:1: PKGSRC_RUN_TEST should be matched against \"[yY][eE][sS]\" or \"[nN][oO]\", not \"[Y][eE][sS]\".")
+		"WARN: filename:1: PKGSRC_RUN_TEST should be matched "+
 			"against \"[yY][eE][sS]\" or \"[nN][oO]\", not \"[Y][eE][sS]\".")
 	testCond(".if !empty(IS_BUILTIN.Xfixes:M[yY][eE][sS])")
 	testCond(".if !empty(${IS_BUILTIN.Xfixes:M[yY][eE][sS]})",
-		"WARN: filename:1: The empty() function takes a variable name as parameter, not a variable expression.")
+		"WARN: filename:1: The empty() function takes a variable name as parameter, "+
 			"not a variable expression.")
-	testCond(".if ${EMUL_PLATFORM} == \"linux-x386\"",
+	testCond(".if ${PKGSRC_COMPILER} == \"msvc\"",
-		"WARN: filename:1: "+
+		"WARN: filename:1: \"msvc\" is not valid for PKGSRC_COMPILER. "+
-			"\"x386\" is not valid for the hardware architecture part of EMUL_PLATFORM. "+
+			"Use one of { ccache ccc clang distcc f2c gcc hp icc ido mipspro mipspro-ucode pcc sunpro xlc } instead.",
-			"Use one of "+
+		"WARN: filename:1: Use ${PKGSRC_COMPILER:Mmsvc} instead of the == operator.")
 			"{ aarch64 aarch64eb alpha amd64 arc arm arm26 arm32 cobalt coldfire convex "+
 			"dreamcast earm earmeb earmhf earmhfeb earmv4 earmv4eb earmv5 earmv5eb earmv6 earmv6eb "+
 			"earmv6hf earmv6hfeb earmv7 earmv7eb earmv7hf earmv7hfeb evbarm hpcmips hpcsh hppa hppa64 "+
 			"i386 i586 i686 ia64 m68000 m68k m88k mips mips64 mips64eb mips64el mipseb mipsel mipsn32 "+
 			"mlrisc ns32k pc532 pmax powerpc powerpc64 rs6000 s390 sh3eb sh3el sparc sparc64 vax x86_64 "+
 			"} instead.")
-	testCond(".if ${EMUL_PLATFORM:Mlinux-x386}",
+	testCond(".if ${PKG_LIBTOOL:Mlibtool}",
-		"WARN: filename:1: "+
+		"NOTE: filename:1: PKG_LIBTOOL should be compared using == instead of matching against \":Mlibtool\".")
 			"The pattern \"x386\" cannot match any of { aarch64 aarch64eb alpha amd64 arc arm arm26 "+
 			"arm32 cobalt coldfire convex dreamcast earm earmeb earmhf earmhfeb earmv4 earmv4eb "+
 			"earmv5 earmv5eb earmv6 earmv6eb earmv6hf earmv6hfeb earmv7 earmv7eb earmv7hf "+
 			"earmv7hfeb evbarm hpcmips hpcsh hppa hppa64 i386 i586 i686 ia64 m68000 m68k m88k "+
 			"mips mips64 mips64eb mips64el mipseb mipsel mipsn32 mlrisc ns32k pc532 pmax powerpc powerpc64 "+
 			"rs6000 s390 sh3eb sh3el sparc sparc64 vax x86_64 } "+
 			"for the hardware architecture part of EMUL_PLATFORM.",
 		"NOTE: filename:1: EMUL_PLATFORM should be compared using == instead of the :M or :N modifier without wildcards.")
 	testCond(".if ${MACHINE_PLATFORM:MUnknownOS-*-*} || ${MACHINE_ARCH:Mx86}",
 		"WARN: filename:1: "+
 			"The pattern \"UnknownOS\" cannot match any of "+
 			"{ AIX BSDOS Bitrig Cygwin Darwin DragonFly FreeBSD FreeMiNT GNUkFreeBSD HPUX Haiku "+
 			"IRIX Interix Linux Minix MirBSD NetBSD OSF1 OpenBSD QNX SCO_SV SunOS UnixWare "+
 			"} for the operating system part of MACHINE_PLATFORM.",
 		"WARN: filename:1: "+
 			"The pattern \"x86\" cannot match any of "+
 			"{ aarch64 aarch64eb alpha amd64 arc arm arm26 arm32 cobalt coldfire convex dreamcast earm "+
 			"earmeb earmhf earmhfeb earmv4 earmv4eb earmv5 earmv5eb earmv6 earmv6eb earmv6hf earmv6hfeb "+
 			"earmv7 earmv7eb earmv7hf earmv7hfeb evbarm hpcmips hpcsh hppa hppa64 i386 i586 i686 ia64 "+
 			"m68000 m68k m88k mips mips64 mips64eb mips64el mipseb mipsel mipsn32 mlrisc ns32k pc532 pmax "+
 			"powerpc powerpc64 rs6000 s390 sh3eb sh3el sparc sparc64 vax x86_64 "+
 			"} for MACHINE_ARCH.",
-		"NOTE: filename:1: MACHINE_ARCH should be compared using == instead of the :M or :N modifier without wildcards.")
+		"NOTE: filename:1: MACHINE_ARCH should be compared using == instead of matching against \":Mx86\".")
 	testCond(".if ${MASTER_SITES:Mftp://*} == \"ftp://netbsd.org/\"")
+}
 func (s *Suite) Test_MkLineChecker_checkVarassign(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	G.Mk = t.NewMkLines("Makefile",
 		MkRcsID,
 		"ac_cv_libpari_libs+=\t-L${BUILDLINK_PREFIX.pari}/lib") // From math/clisp-pari/Makefile, rev. 1.8
 @@ -376,31 +409,30 @@ func (s *Suite) Test_MkLineChecker_check
 func (s *Suite) Test_MkLineChecker_checkVarusePermissions__load_time(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	mklines := t.NewMkLines("options.mk",
 		MkRcsID,
 		"WRKSRC:=${.CURDIR}",
 		".if ${PKG_SYSCONFDIR.gdm} != \"etc\"",
 		".endif")
 	mklines.Check()
-	// Evaluating PKG_SYSCONFDIR.* at load time is probably ok, though
+	// Evaluating PKG_SYSCONFDIR.* at load time is probably ok,
-	// pkglint cannot prove anything here.
+	// though pkglint cannot prove anything here.
 	//
-	// Evaluating .CURDIR at load time is ok since it is defined from
+	// Evaluating .CURDIR at load time is definitely ok since it is defined from the beginning.
 	// the beginning.
 	t.CheckOutputLines(
 		"NOTE: options.mk:2: This variable value should be aligned to column 17.")
+}
 func (s *Suite) Test_MkLineChecker_checkVarusePermissions__load_time_guessed(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	t.SetupTool("install", "", AtRunTime)
 	mklines := t.NewMkLines("install-docfiles.mk",
 		MkRcsID,
 		"DOCFILES=\ta b c",
 		"do-install:",
 @@ -428,97 +460,155 @@ func (s *Suite) Test_MkLineChecker_check
 	mklines := t.NewMkLines("any.mk",
 		MkRcsID,
 		// PKGREVISION may only be set in Makefile, not used at load time; see vardefs.go.
 		".if defined(PKGREVISION)",
 		".endif")
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: any.mk:2: PKGREVISION should not be evaluated at load time.",
 		"WARN: any.mk:2: PKGREVISION may not be used in any file; it is a write-only variable.")
+}
-func (s *Suite) Test_MkLineChecker__warn_varuse_LOCALBASE(c *check.C) {
+func (s *Suite) Test_MkLineChecker_Check__warn_varuse_LOCALBASE(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	mkline := t.NewMkLine("options.mk", 56, "PKGNAME=${LOCALBASE}")
 	MkLineChecker{mkline}.Check()
 	t.CheckOutputLines(
 		"WARN: options.mk:56: Please use PREFIX instead of LOCALBASE.")
+}
 func (s *Suite) Test_MkLineChecker_CheckRelativePkgdir(c *check.C) {
 	t := s.Init(c)
-	mklines := t.SetupFileMkLines("Makefile",
+	t.CreateFileLines("other/package/Makefile")
 	// Must be in the filesystem because of directory references.
 	mklines := t.SetupFileMkLines("category/package/Makefile",
 		"# dummy")
 	ck := MkLineChecker{mklines.mklines[0]}
-	MkLineChecker{mklines.mklines[0]}.CheckRelativePkgdir("../pkgbase")
+	ck.CheckRelativePkgdir("../pkgbase")
 	ck.CheckRelativePkgdir("../../other/package")
-	t.CheckOutputLines(
+	ck.CheckRelativePkgdir("../../other/does-not-exist")
 		"ERROR: ~/Makefile:1: \"../pkgbase\" does not exist.",
-		"WARN: ~/Makefile:1: \"../pkgbase\" is not a valid relative package directory.")
+	// FIXME: The diagnostics for does-not-exist are redundant.
 	t.CheckOutputLines(
 		"ERROR: ~/category/package/Makefile:1: Relative path \"../pkgbase\" does not exist.",
 		"WARN: ~/category/package/Makefile:1: \"../pkgbase\" is not a valid relative package directory.",
 		"ERROR: ~/category/package/Makefile:1: Relative path \"../../other/does-not-exist\" does not exist.",
 		"ERROR: ~/category/package/Makefile:1: There is no package in \"other/does-not-exist\".")
+}
 // PR pkg/46570, item 2
 func (s *Suite) Test_MkLineChecker__unclosed_varuse(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("Makefile",
 		MkRcsID,
 		"EGDIRS=\t${EGDIR/apparmor.d ${EGDIR/dbus-1/system.d ${EGDIR/pam.d")
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: Makefile:2: Unclosed Make variable starting at \"${EGDIR/apparmor.d $...\".",
 		"WARN: Makefile:2: EGDIRS is defined but not used.",
 		// XXX: This warning is redundant because of the "Unclosed" warning above.
 		"WARN: Makefile:2: Pkglint parse error in MkLine.Tokenize at "+
 			"\"${EGDIR/apparmor.d ${EGDIR/dbus-1/system.d ${EGDIR/pam.d\".")
+}
-func (s *Suite) Test_MkLineChecker__Varuse_Modifier_L(c *check.C) {
+func (s *Suite) Test_MkLineChecker_Check__varuse_modifier_L(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
-	G.Mk = t.NewMkLines("x11/xkeyboard-config/Makefile",
+	mklines := t.NewMkLines("x11/xkeyboard-config/Makefile",
-		"FILES_SUBST+=XKBCOMP_SYMLINK=${${XKBBASE}/xkbcomp:L:Q}")
+		"FILES_SUBST+=XKBCOMP_SYMLINK=${${XKBBASE}/xkbcomp:L:Q}",
 		"FILES_SUBST+=XKBCOMP_SYMLINK=${${XKBBASE}/xkbcomp:Q}")
-	MkLineChecker{G.Mk.mklines[0]}.Check()
+	MkLineChecker{mklines.mklines[0]}.Check()
 	MkLineChecker{mklines.mklines[1]}.Check()
-	// Don't warn that ${XKBBASE}/xkbcomp is used but not defined.
+	// In line 1, don't warn that ${XKBBASE}/xkbcomp is used but not defined.
-	t.CheckOutputEmpty()
+	// This is because the :L modifier interprets everything before as an expression
 	// instead of a variable name.
 	//
 	// In line 2 the :L modifier is missing, therefore ${XKBBASE}/xkbcomp is the
 	// name of another variable, and that variable is not known. Only XKBBASE is known.
 	//
 	// FIXME: The below warnings are wrong because the MkParser does not recognize the
 	// slash as part of a variable name. Because of that, parsing stops before the $.
 	// The warning "Unclosed Make variable" wrongly assumes that any parse error from
 	// a variable use is because of unclosed braces, which it isn't in this case.h
 	t.CheckOutputLines(
 		"WARN: x11/xkeyboard-config/Makefile:2: Unclosed Make variable starting at \"${${XKBBASE}/xkbcomp...\".",
 		"WARN: x11/xkeyboard-config/Makefile:2: Unclosed Make variable starting at \"${${XKBBASE}/xkbcomp...\".")
+}
 func (s *Suite) Test_MkLineChecker_checkDirectiveCond__comparison_with_shell_command(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
-	G.Mk = t.NewMkLines("security/openssl/Makefile",
+	mklines := t.NewMkLines("security/openssl/Makefile",
 		MkRcsID,
 		".if ${PKGSRC_COMPILER} == \"gcc\" && ${CC} == \"cc\"",
 		".endif")
-	G.Mk.Check()
+	mklines.Check()
 	// Don't warn about unknown shell command "cc".
 	t.CheckOutputLines(
 		"WARN: security/openssl/Makefile:2: Use ${PKGSRC_COMPILER:Mgcc} instead of the == operator.")
+}
 func (s *Suite) Test_MkLineChecker_checkDirectiveCondEmpty(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	mkline := t.NewMkLine("module.mk", 123, ".if ${PKGPATH} == \"category/package\"")
 	ck := MkLineChecker{mkline}
 	// FIXME: checkDirectiveCondEmpty cannot know whether it is empty(...) or !empty(...).
 	// It must know that to generate the proper diagnostics.
 	ck.checkDirectiveCondEmpty(NewMkVarUse("PKGPATH", "Mpattern"))
 	// When the pattern contains placeholders, it cannot be converted to == or !=.
 	ck.checkDirectiveCondEmpty(NewMkVarUse("PKGPATH", "Mpa*n"))
 	ck.checkDirectiveCondEmpty(NewMkVarUse("PKGPATH", "tl", "Mpattern"))
 	ck.checkDirectiveCondEmpty(NewMkVarUse("PKGPATH", "Ncategory/package"))
 	// ${PKGPATH:None:Ntwo} is a short variant of ${PKGPATH} != "one" && ${PKGPATH} != "two",
 	// therefore no note is logged in this case.
 	ck.checkDirectiveCondEmpty(NewMkVarUse("PKGPATH", "None", "Ntwo"))
 	// Note: this combination doesn't make sense since the patterns "one" and "two" don't overlap.
 	ck.checkDirectiveCondEmpty(NewMkVarUse("PKGPATH", "Mone", "Mtwo"))
 	t.CheckOutputLines(
 		"NOTE: module.mk:123: PKGPATH should be compared using == instead of matching against \":Mpattern\".",
 		"NOTE: module.mk:123: PKGPATH should be compared using == instead of matching against \":Mpattern\".",
 		"NOTE: module.mk:123: PKGPATH should be compared using != instead of matching against \":Ncategory/package\".",
 		"NOTE: module.mk:123: PKGPATH should be compared using == instead of matching against \":Mone\".",
 		"NOTE: module.mk:123: PKGPATH should be compared using == instead of matching against \":Mtwo\".")
+}
 func (s *Suite) Test_MkLineChecker_checkDirectiveCond__comparing_PKGSRC_COMPILER_with_eqeq(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	G.Mk = t.NewMkLines("audio/pulseaudio/Makefile",
 		MkRcsID,
 		".if ${OPSYS} == \"Darwin\" && ${PKGSRC_COMPILER} == \"clang\"",
 		".endif")
 	G.Mk.Check()
 	t.CheckOutputLines(
 		"WARN: audio/pulseaudio/Makefile:2: Use ${PKGSRC_COMPILER:Mclang} instead of the == operator.")
 @@ -528,27 +618,28 @@ func (s *Suite) Test_MkLineChecker_check
 	t := s.Init(c)
 	t.SetupVartypes()
 	G.Mk = t.NewMkLines("chat/pidgin-icb/Makefile",
 		MkRcsID,
 		"CFLAGS+=\t`pkg-config pidgin --cflags`")
 	mkline := G.Mk.mklines[1]
 	words, rest := splitIntoMkWords(mkline.Line, mkline.Value())
 	c.Check(words, deepEquals, []string{"`pkg-config pidgin --cflags`"})
 	c.Check(rest, equals, "")
-	MkLineChecker{G.Mk.mklines[1]}.checkVartype("CFLAGS", opAssignAppend, "`pkg-config pidgin --cflags`", "")
+	ck := MkLineChecker{G.Mk.mklines[1]}
 	ck.checkVartype("CFLAGS", opAssignAppend, "`pkg-config pidgin --cflags`", "")
 	// No warning about "`pkg-config" being an unknown CFlag.
 	t.CheckOutputEmpty()
+}
 // See PR 46570, Ctrl+F "4. Shell quoting".
 // Pkglint is correct, since the shell sees this definition for
 // CPPFLAGS as three words, not one word.
 func (s *Suite) Test_MkLineChecker_checkVartype__CFLAGS(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	mklines := t.NewMkLines("Makefile",
 @@ -730,26 +821,30 @@ func (s *Suite) Test_MkLineChecker_Check
 			kindOfList: lkNone,
 			basicType:  BtPathname,
 			aclEntries: nil,
 			guessed:    true,
 		},
 		time:       vucTimeRun,
 		quoting:    vucQuotPlain,
 		IsWordPart: false,
 	})
 	t.CheckOutputEmpty()
+}
 // Any variable that is defined in the pkgsrc infrastructure in mk/**/*.mk is
 // considered defined, and no "used but not defined" warning is logged for it.
 //
 // See Pkgsrc.loadUntypedVars.
 func (s *Suite) Test_MkLineChecker_CheckVaruse__defined_in_infrastructure(c *check.C) {
 	t := s.Init(c)
 	t.SetupPkgsrc()
 	t.SetupVartypes()
 	t.CreateFileLines("mk/deeply/nested/infra.mk",
 		MkRcsID,
 		"INFRA_VAR?=\tvalue")
 	G.Pkgsrc.LoadInfrastructure()
 	mklines := t.SetupFileMkLines("category/package/module.mk",
 		MkRcsID,
 		"do-fetch:",
 		"\t: ${INFRA_VAR} ${UNDEFINED}")
 @@ -786,70 +881,72 @@ func (s *Suite) Test_MkLineChecker_Check
 func (s *Suite) Test_MkLineChecker_CheckVaruse__complicated_range(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("--show-autofix", "--source")
 	t.SetupVartypes()
 	mkline := t.NewMkLine("mk/compiler/gcc.mk", 150,
 		"CC:=\t${CC:C/^/_asdf_/1:M_asdf_*:S/^_asdf_//}")
 	MkLineChecker{mkline}.Check()
 	// FIXME: The check is called two times, even though it only produces a single NOTE.
 	t.CheckOutputLines(
-		"NOTE: mk/compiler/gcc.mk:150: The modifier \":C/^/_asdf_/1:M_asdf_*:S/^_asdf_//\" can be written as \":[1]\".",
+		"NOTE: mk/compiler/gcc.mk:150: "+
-		"AUTOFIX: mk/compiler/gcc.mk:150: Replacing \":C/^/_asdf_/1:M_asdf_*:S/^_asdf_//\" with \":[1]\".",
+			"The modifier \":C/^/_asdf_/1:M_asdf_*:S/^_asdf_//\" can be written as \":[1]\".",
 		"AUTOFIX: mk/compiler/gcc.mk:150: "+
 			"Replacing \":C/^/_asdf_/1:M_asdf_*:S/^_asdf_//\" with \":[1]\".",
 		"-\tCC:=\t${CC:C/^/_asdf_/1:M_asdf_*:S/^_asdf_//}",
 		"+\tCC:=\t${CC:[1]}")
+}
 func (s *Suite) Test_MkLineChecker_CheckVaruse__deprecated_PKG_DEBUG(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	G.Pkgsrc.initDeprecatedVars()
 	mkline := t.NewMkLine("module.mk", 123,
 		"\t${_PKG_SILENT}${_PKG_DEBUG} :")
 	MkLineChecker{mkline}.Check()
 	t.CheckOutputLines(
 		"WARN: module.mk:123: Use of \"_PKG_SILENT\" is deprecated. Use RUN (with more error checking) instead.",
 		"WARN: module.mk:123: Use of \"_PKG_DEBUG\" is deprecated. Use RUN (with more error checking) instead.")
+}
 func (s *Suite) Test_MkLineChecker_checkVarassignSpecific(c *check.C) {
 	t := s.Init(c)
 	t.SetupPkgsrc()
 	G.Pkgsrc.LoadInfrastructure()
 	t.SetupCommandLine("-Wall,no-space")
 	t.SetupVartypes()
 	mklines := t.SetupFileMkLines("module.mk",
 		MkRcsID,
 		"EGDIR=                  ${PREFIX}/etc/rc.d",
 		"_TOOLS_VARNAME.sed=     SED",
 		"DIST_SUBDIR=            ${PKGNAME}",
 		"WRKSRC=                 ${PKGNAME}",
 		"SITES_distfile.tar.gz=  ${MASTER_SITE_GITHUB:=user/}",
 		// TODO: The first of the below assignments should be flagged as redundant by RedundantScope;
 		// that check is currently only implemented for package Makefiles, not for other files.
 		"PYTHON_VERSIONS_ACCEPTED= -13",
 		"PYTHON_VERSIONS_ACCEPTED= 27 36")
 	mklines.Check()
 	// TODO: Split this test into several, one for each topic.
 	t.CheckOutputLines(
 		"WARN: ~/module.mk:2: Please use the RCD_SCRIPTS mechanism to install rc.d scripts automatically to ${RCD_SCRIPTS_EXAMPLEDIR}.",
 		"WARN: ~/module.mk:3: _TOOLS_VARNAME.sed is defined but not used.",
 		"WARN: ~/module.mk:3: Variable names starting with an underscore (_TOOLS_VARNAME.sed) are reserved for internal pkgsrc use.",
 		"WARN: ~/module.mk:4: PKGNAME should not be used in DIST_SUBDIR as it includes the PKGREVISION. Please use PKGNAME_NOREV instead.",
 		"WARN: ~/module.mk:5: PKGNAME should not be used in WRKSRC as it includes the PKGREVISION. Please use PKGNAME_NOREV instead.",
 		"WARN: ~/module.mk:6: SITES_distfile.tar.gz is defined but not used.",
 		"WARN: ~/module.mk:6: SITES_* is deprecated. Please use SITES.* instead.",
 		"WARN: ~/module.mk:7: The variable PYTHON_VERSIONS_ACCEPTED may not be set "+
 			"(only given a default value, appended to) in this file; it would be ok in Makefile, Makefile.common, options.mk.",
 		"WARN: ~/module.mk:7: Invalid version number \"-13\".",
 		"ERROR: ~/module.mk:7: All values for PYTHON_VERSIONS_ACCEPTED must be positive integers.",
 		"WARN: ~/module.mk:8: The variable PYTHON_VERSIONS_ACCEPTED may not be set "+
 @@ -922,15 +1019,16 @@ func (s *Suite) Test_MkLineChecker_Check
 		".include \"../../lang/${LATEST_PYTHON}/module.mk\"",
 		"",
 		".include \"module.mk\"",
 		".include \"../../category/../category/package/module.mk\"", // Oops
 		".include \"../../mk/bsd.prefs.mk\"",
 		".include \"../package/module.mk\"")
 	mklines.Check()
 	t.CheckOutputLines(
 		"ERROR: ~/category/package/module.mk:2: A main pkgsrc package must not depend on a pkgsrc-wip package.",
 		"ERROR: ~/category/package/module.mk:3: A main pkgsrc package must not depend on a pkgsrc-wip package.",
 		"WARN: ~/category/package/module.mk:5: LATEST_PYTHON is used but not defined.",
 		// TODO: This warning is unspecific, there is also a pkglint warning "should be ../../category/package".
 		"WARN: ~/category/package/module.mk:11: Invalid relative path \"../package/module.mk\".")
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/mklines.go 2018/12/02 01:57:48 1.35
+++ pkgsrc/pkgtools/pkglint/files/Attic/mklines.go 2018/12/02 23:12:43 1.36

 @@ -1,147 +1,165 @@
 package main
 import (
 	"strings"
+)
 // MkLines contains data for the Makefile (or *.mk) that is currently checked.
 type MkLines = *MkLinesImpl
 type MkLinesImpl struct {
 	mklines       []MkLine
 	lines         Lines
-	forVars       map[string]bool // The variables currently used in .for loops
+	target        string            // Current make(1) target; only available during checkAll
-	target        string          // Current make(1) target
+	vars          Scope             //
 	vars          Scope
 	buildDefs     map[string]bool   // Variables that are registered in BUILD_DEFS, to ensure that all user-defined variables are added to it.
 	plistVarAdded map[string]MkLine // Identifiers that are added to PLIST_VARS.
 	plistVarSet   map[string]MkLine // Identifiers for which PLIST.${id} is defined.
 	plistVarSkip  bool              // True if any of the PLIST_VARS identifiers refers to a variable.
 	Tools         *Tools            // Tools defined in file scope.
 	indentation   *Indentation      // Indentation depth of preprocessing directives; only available during MkLines.ForEach.
 	forVars       map[string]bool   // The variables currently used in .for loops; only available during MkLines.checkAll.
 	Once
 	// TODO: Consider extracting plistVarAdded, plistVarSet, plistVarSkip into an own type.
 	// TODO: Describe where each of the above fields is valid.
+}
 func NewMkLines(lines Lines) MkLines {
 	mklines := make([]MkLine, lines.Len())
 	for i, line := range lines.Lines {
 		mklines[i] = NewMkLine(line)
+	}
 	tools := NewTools(lines.FileName)
 	tools.Fallback(G.Pkgsrc.Tools)
 	return &MkLinesImpl{
 		mklines,
 		lines,
 		make(map[string]bool),
 		"",
 		NewScope(),
 		make(map[string]bool),
 		make(map[string]MkLine),
 		make(map[string]MkLine),
 		false,
 		tools,
 		nil,
 		make(map[string]bool),
 		Once{}}
+}
 // TODO: Consider defining an interface MkLinesChecker (different name, though, since this one confuses even me)
 // that checks a single topic, like:
 //
 //  * PlistVars
 //  * ForLoops
 //  * MakeTargets
 //  * Tools
 //  * Indentation
 //  * LoadTimeVarUse
 //  * Subst
 //  * VarAlign
 //
 // These could be run in parallel to get the diagnostics strictly from top to bottom.
 // Some of the checkers will probably depend on one another.
 //
 // The driving code for these checkers could look like:
 //
 //  ck.Init
 //  ck.BeforeLine
 //  ck.Line
 //  ck.AfterLine
 //  ck.Finish
 // UseVar remembers that the given variable is used in the given line.
 // This controls the "defined but not used" warning.
 func (mklines *MkLinesImpl) UseVar(mkline MkLine, varname string) {
 	mklines.vars.Use(varname, mkline)
 	if G.Pkg != nil {
 		G.Pkg.vars.Use(varname, mkline)
+	}
+}
 func (mklines *MkLinesImpl) Check() {
 	if trace.Tracing {
 		defer trace.Call1(mklines.lines.FileName)()
+	}
 	G.Mk = mklines
 	defer func() { G.Mk = nil }()
 	// In the first pass, all additions to BUILD_DEFS and USE_TOOLS
 	// are collected to make the order of the definitions irrelevant.
-	mklines.DetermineUsedVariables()
+	mklines.collectUsedVariables()
-	mklines.DetermineDefinedVariables()
+	mklines.collectDefinedVariables()
 	mklines.collectPlistVars()
 	mklines.collectElse()
 	// In the second pass, the actual checks are done.
 	mklines.checkAll()
 	SaveAutofixChanges(mklines.lines)
+}
 func (mklines *MkLinesImpl) checkAll() {
-	allowedTargets := func() map[string]bool {
+	allowedTargets := map[string]bool{
-		targets := make(map[string]bool)
+		"pre-fetch": true, "do-fetch": true, "post-fetch": true,
-		prefixes := [...]string{"pre", "do", "post"}
+		"pre-extract": true, "do-extract": true, "post-extract": true,
-		actions := [...]string{"fetch", "extract", "patch", "tools", "wrapper", "configure", "build", "test", "install", "package", "clean"}
+		"pre-patch": true, "do-patch": true, "post-patch": true,
-		for _, prefix := range prefixes {
+		"pre-tools": true, "do-tools": true, "post-tools": true,
-			for _, action := range actions {
+		"pre-wrapper": true, "do-wrapper": true, "post-wrapper": true,
-				targets[prefix+"-"+action] = true
+		"pre-configure": true, "do-configure": true, "post-configure": true,
 		"pre-build": true, "do-build": true, "post-build": true,
 		"pre-test": true, "do-test": true, "post-test": true,
-		return targets
+		"pre-install": true, "do-install": true, "post-install": true,
-	}()
+		"pre-package": true, "do-package": true, "post-package": true,
 		"pre-clean": true, "do-clean": true, "post-clean": true}
 	G.Assertf(len(allowedTargets) == 33, "Error in allowedTargets initialization")
 	mklines.lines.CheckRcsID(0, `#[\t ]+`, "# ")
 	substContext := NewSubstContext()
 	var varalign VaralignBlock
 	isHacksMk := mklines.lines.BaseName == "hacks.mk"
 	lineAction := func(mkline MkLine) bool {
 		if isHacksMk {
 			// Needs to be set here because it is reset in MkLines.ForEach.
 			mklines.Tools.SeenPrefs = true
+		}
 		ck := MkLineChecker{mkline}
 		ck.Check()
 		varalign.Check(mkline)
 		varalign.Process(mkline)
 		mklines.Tools.ParseToolLine(mkline, false, false)
 		switch {
 		case mkline.IsEmpty():
 			substContext.Finish(mkline)
 		case mkline.IsVarassign():
 			mklines.target = ""
 			mkline.Tokenize(mkline.Value(), true) // Just for the side-effect of the warnings.
 			substContext.Varassign(mkline)
-			switch mkline.Varcanon() {
+			mklines.checkVarassignPlist(mkline)
 			case "PLIST_VARS":
 				ids := mkline.ValueFields(resolveVariableRefs(mkline.Value()))
 				for _, id := range ids {
 					if !mklines.plistVarSkip && mklines.plistVarSet[id] == nil {
 						mkline.Warnf("%q is added to PLIST_VARS, but PLIST.%s is not defined in this file.", id, id)
 			case "PLIST.*":
 				id := mkline.Varparam()
 				if !mklines.plistVarSkip && mklines.plistVarAdded[id] == nil {
 					mkline.Warnf("PLIST.%s is defined, but %q is not added to PLIST_VARS in this file.", id, id)
 		case mkline.IsInclude():
 			mklines.target = ""
 			if G.Pkg != nil {
-				G.Pkg.CheckInclude(mkline, mklines.indentation)
+				G.Pkg.checkIncludeConditionally(mkline, mklines.indentation)
+			}
 		case mkline.IsDirective():
 			ck.checkDirective(mklines.forVars, mklines.indentation)
 			substContext.Directive(mkline)
 		case mkline.IsDependency():
 			ck.checkDependencyRule(allowedTargets)
 			mklines.target = mkline.Targets()
 		case mkline.IsShellCommand():
 			mkline.Tokenize(mkline.ShellCommand(), true) // Just for the side-effect of the warnings.
+		}
 @@ -155,26 +173,43 @@ func (mklines *MkLinesImpl) checkAll() {
 	// TODO: Extract this code so that it is clearly visible in the stack trace.
 	if trace.Tracing {
 		trace.Stepf("Starting main checking loop")
+	}
 	mklines.ForEachEnd(lineAction, atEnd)
 	substContext.Finish(NewMkLine(mklines.lines.EOFLine())) // TODO: mklines.EOFLine()
 	varalign.Finish()
 	ChecklinesTrailingEmptyLines(mklines.lines)
+}
 func (mklines *MkLinesImpl) checkVarassignPlist(mkline MkLine) {
 	switch mkline.Varcanon() {
 	case "PLIST_VARS":
 		for _, id := range mkline.ValueFields(resolveVariableRefs(mkline.Value())) {
 			if !mklines.plistVarSkip && mklines.plistVarSet[id] == nil {
 				mkline.Warnf("%q is added to PLIST_VARS, but PLIST.%s is not defined in this file.", id, id)
+			}
+		}
 	case "PLIST.*":
 		id := mkline.Varparam()
 		if !mklines.plistVarSkip && mklines.plistVarAdded[id] == nil {
 			mkline.Warnf("PLIST.%s is defined, but %q is not added to PLIST_VARS in this file.", id, id)
+		}
+	}
+}
 // ForEach calls the action for each line, until the action returns false.
 // It keeps track of the indentation (see MkLines.indentation)
 // and all conditional variables (see Indentation.IsConditional).
 func (mklines *MkLinesImpl) ForEach(action func(mkline MkLine)) {
 	mklines.ForEachEnd(
 		func(mkline MkLine) bool { action(mkline); return true },
 		func(mkline MkLine) {})
+}
 // ForEachEnd calls the action for each line, until the action returns false.
 // It keeps track of the indentation and all conditional variables.
 // At the end, atEnd is called with the last line as its argument.
 func (mklines *MkLinesImpl) ForEachEnd(action func(mkline MkLine) bool, atEnd func(lastMkline MkLine)) {
 @@ -189,133 +224,137 @@ func (mklines *MkLinesImpl) ForEachEnd(a
 	for _, mkline := range mklines.mklines {
 		mklines.indentation.TrackBefore(mkline)
 		if !action(mkline) {
 			break
+		}
 		mklines.indentation.TrackAfter(mkline)
+	}
 	atEnd(mklines.mklines[len(mklines.mklines)-1])
 	mklines.indentation = nil
+}
-func (mklines *MkLinesImpl) DetermineDefinedVariables() {
+func (mklines *MkLinesImpl) collectDefinedVariables() {
 	if trace.Tracing {
 		defer trace.Call0()()
+	}
 	for _, mkline := range mklines.mklines {
 		mklines.Tools.ParseToolLine(mkline, false, true)
 		if !mkline.IsVarassign() {
 			continue
+		}
 		defineVar(mkline, mkline.Varname())
 		varcanon := mkline.Varcanon()
 		switch varcanon {
 		case
 			"BUILD_DEFS",
-			"PKG_GROUPS_VARS",
+			"PKG_GROUPS_VARS", // see mk/misc/unprivileged.mk
-			"PKG_USERS_VARS":
+			"PKG_USERS_VARS":  // see mk/misc/unprivileged.mk
-			for _, varname := range fields(mkline.Value()) {
+			for _, varname := range mkline.Fields() {
 				mklines.buildDefs[varname] = true
 				if trace.Tracing {
 					trace.Step1("%q is added to BUILD_DEFS.", varname)
+				}
+			}
 		case
 			"BUILTIN_FIND_FILES_VAR",
 			"BUILTIN_FIND_HEADERS_VAR":
-			for _, varname := range fields(mkline.Value()) {
+			for _, varname := range mkline.Fields() {
 				mklines.vars.Define(varname, mkline)
+			}
 		case "PLIST_VARS":
-			ids := mkline.ValueFields(resolveVariableRefs(mkline.Value()))
+			for _, id := range mkline.ValueFields(resolveVariableRefs(mkline.Value())) {
 			for _, id := range ids {
 				if trace.Tracing {
 					trace.Step1("PLIST.%s is added to PLIST_VARS.", id)
+				}
 				if containsVarRef(id) {
 					mklines.UseVar(mkline, "PLIST.*")
 					mklines.plistVarSkip = true
 				} else {
 					mklines.UseVar(mkline, "PLIST."+id)
+				}
+			}
 		case "SUBST_VARS.*":
-			for _, svar := range fields(mkline.Value()) {
+			for _, substVar := range mkline.Fields() {
-				mklines.UseVar(mkline, varnameCanon(svar))
+				mklines.UseVar(mkline, varnameCanon(substVar))
 				if trace.Tracing {
-					trace.Step1("varuse %s", svar)
+					trace.Step1("varuse %s", substVar)
+				}
+			}
 		case "OPSYSVARS":
-			for _, osvar := range fields(mkline.Value()) {
+			for _, opsysVar := range mkline.Fields() {
-				mklines.UseVar(mkline, osvar+".*")
+				mklines.UseVar(mkline, opsysVar+".*")
-				defineVar(mkline, osvar)
+				defineVar(mkline, opsysVar)
+			}
+		}
+	}
+}
 func (mklines *MkLinesImpl) collectPlistVars() {
 	// TODO: The PLIST_VARS code above looks very similar.
 	for _, mkline := range mklines.mklines {
 		if mkline.IsVarassign() {
 			switch mkline.Varcanon() {
 			case "PLIST_VARS":
-				ids := mkline.ValueFields(resolveVariableRefs(mkline.Value()))
+				for _, id := range mkline.ValueFields(resolveVariableRefs(mkline.Value())) {
 				for _, id := range ids {
 					if containsVarRef(id) {
 						mklines.plistVarSkip = true
 					} else {
 						mklines.plistVarAdded[id] = mkline
+					}
+				}
 			case "PLIST.*":
 				id := mkline.Varparam()
 				if containsVarRef(id) {
 					mklines.plistVarSkip = true
 				} else {
 					mklines.plistVarSet[id] = mkline
+				}
+			}
+		}
+	}
+}
 func (mklines *MkLinesImpl) collectElse() {
 	// Make a dry-run over the lines, which sets data.elseLine (in mkline.go) as a side-effect.
 	mklines.ForEach(func(mkline MkLine) {})
 	// TODO: Check whether this ForEach is redundant because it is already run somewhere else.
+}
-func (mklines *MkLinesImpl) DetermineUsedVariables() {
+func (mklines *MkLinesImpl) collectUsedVariables() {
 	for _, mkline := range mklines.mklines {
 		for _, varname := range mkline.DetermineUsedVariables() {
 			mklines.UseVar(mkline, varname)
+		}
+	}
-	mklines.determineDocumentedVariables()
+	mklines.collectDocumentedVariables()
+}
-// Loosely based on mk/help/help.awk, revision 1.28
+// collectDocumentedVariables collects the variables that are mentioned in the human-readable
-func (mklines *MkLinesImpl) determineDocumentedVariables() {
+// documentation of the Makefile fragments from the pkgsrc infrastructure.
 //
 // Loosely based on mk/help/help.awk, revision 1.28, but much simpler.
 func (mklines *MkLinesImpl) collectDocumentedVariables() {
 	scope := NewScope()
 	commentLines := 0
 	relevant := true
 	finish := func() {
 		if commentLines >= 3 && relevant {
 			for varname, mkline := range scope.used {
 				mklines.vars.Use(varname, mkline)
+			}
+		}
 		scope = NewScope()
 		commentLines = 0
 @@ -347,42 +386,45 @@ func (mklines *MkLinesImpl) determineDoc
 			if 1 < len(words) && words[1] == "Copyright" {
 				relevant = false
+			}
 		case mkline.IsEmpty():
 			finish()
+		}
+	}
 	finish()
+}
-func (mklines *MkLinesImpl) CheckRedundantVariables() {
+func (mklines *MkLinesImpl) CheckRedundantAssignments() {
 	scope := NewRedundantScope()
 	isRelevant := func(old, new MkLine) bool {
 		if old.Basename != "Makefile" && new.Basename == "Makefile" {
 			return false
+		}
 		if new.Op() == opAssignEval {
 			return false
+		}
 		return true
+	}
 	scope.OnIgnore = func(old, new MkLine) {
 		if isRelevant(old, new) && old.Value() == new.Value() {
 			old.Notef("Definition of %s is redundant because of %s.", new.Varname(), old.RefTo(new))
+		}
+	}
 	scope.OnOverwrite = func(old, new MkLine) {
 		if isRelevant(old, new) {
 			old.Warnf("Variable %s is overwritten in %s.", new.Varname(), old.RefTo(new))
 			G.Explain(
 				"The variable definition in this line does not have an effect since",
 				"it is overwritten elsewhere.  This typically happens because of a",
 				"typo (writing = instead of +=) or because the line that overwrites",
 				"is in another file that is used by several packages.")
+		}
+	}
 	mklines.ForEach(scope.Handle)
+}
 @@ -438,74 +480,72 @@ type VaralignBlock struct {
 	infos []*varalignBlockInfo
 	skip  bool
+}
 type varalignBlockInfo struct {
 	mkline         MkLine
 	varnameOp      string // Variable name + assignment operator
 	varnameOpWidth int    // Screen width of varnameOp
 	space          string // Whitespace between varnameOp and the variable value
 	totalWidth     int    // Screen width of varnameOp + space
 	continuation   bool   // A continuation line with no value in the first line.
+}
-func (va *VaralignBlock) Check(mkline MkLine) {
+func (va *VaralignBlock) Process(mkline MkLine) {
 	switch {
 	case !G.Opts.WarnSpace:
 		return
 	case mkline.IsEmpty():
 		va.Finish()
 		return
-	case mkline.IsCommentedVarassign():
+	case mkline.IsVarassign(), mkline.IsCommentedVarassign():
-		break
+		va.processVarassign(mkline)
-	case mkline.IsComment():
+	case mkline.IsComment(), mkline.IsDirective():
 		return
-	case mkline.IsDirective():
+	default:
 		return
 	case !mkline.IsVarassign():
 		trace.Stepf("Skipping")
 		va.skip = true
 		return
+	}
+}
 func (va *VaralignBlock) processVarassign(mkline MkLine) {
 	switch {
 	case mkline.Op() == opAssignEval && matches(mkline.Varname(), `^[a-z]`):
 		// Arguments to procedures do not take part in block alignment.
 		//
 		// Example:
 		// pkgpath := ${PKGPATH}
 		return
 	case mkline.Value() == "" && mkline.VarassignComment() == "":
 		// Multiple-inclusion guards usually appear in a block of
 		// their own and therefore do not need alignment.
 		//
 		// Example:
 		// .if !defined(INCLUSION_GUARD_MK)
 		// INCLUSION_GUARD_MK:=
 		// # ...
 		// .endif
 		return
+	}
 	continuation := false
 	if mkline.IsMultiline() {
-		// Interpreting the continuation marker as variable value
+		// Parsing the continuation marker as variable value is cheating but works well.
 		// is cheating but works well.
 		text := strings.TrimSuffix(mkline.raw[0].orignl, "\n")
 		m, _, _, _, _, _, value, _, _ := MatchVarassign(text)
 		continuation = m && value == "\\"
+	}
 	valueAlign := mkline.ValueAlign()
 	varnameOp := strings.TrimRight(valueAlign, " \t")
 	space := valueAlign[len(varnameOp):]
 	width := tabWidth(valueAlign)
 	va.infos = append(va.infos, &varalignBlockInfo{mkline, varnameOp, tabWidth(varnameOp), space, width, continuation})
+}
 @@ -571,34 +611,34 @@ func (va *VaralignBlock) optimalWidth(in
+		}
 		if width := info.totalWidth; info.varnameOpWidth != outlier {
 			if minTotalWidth == 0 || width < minTotalWidth {
 				minTotalWidth = width
+			}
 			maxTotalWidth = imax(maxTotalWidth, width)
+		}
+	}
 	if trace.Tracing {
 		trace.Stepf("Indentation including whitespace is between %d and %d.",
 			minTotalWidth, maxTotalWidth)
-		trace.Stepf("Minimum required indentation is %d + 1.",
+		trace.Stepf("Minimum required indentation is %d + 1.", minVarnameOpWidth)
 			minVarnameOpWidth)
 		if outlier != 0 {
 			trace.Stepf("The outlier is at indentation %d.", outlier)
+		}
+	}
 	if minTotalWidth > minVarnameOpWidth && minTotalWidth == maxTotalWidth && minTotalWidth%8 == 0 {
 		// The whole paragraph is already indented to the same width.
 		return minTotalWidth
+	}
 	if minVarnameOpWidth == 0 {
 		// Only continuation lines in this paragraph.
 		return 0
+	}
 	return (minVarnameOpWidth & -8) + 8
+}
 func (va *VaralignBlock) realign(mkline MkLine, varnameOp, oldSpace string, continuation bool, newWidth int) {
 	hasSpace := contains(oldSpace, " ")
 @@ -633,35 +673,37 @@ func (va *VaralignBlock) realignInitialL
 	switch {
 	case hasSpace && wrongColumn:
 		fix.Notef("This variable value should be aligned with tabs, not spaces, to column %d.", newWidth+1)
 	case hasSpace && oldSpace != newSpace:
 		fix.Notef("Variable values should be aligned with tabs, not spaces.")
 	case wrongColumn:
 		fix.Notef("This variable value should be aligned to column %d.", newWidth+1)
 	default:
 		return
+	}
 	if wrongColumn {
 		fix.Explain(
-			"Normally, all variable values in a block should start at the same",
+			"Normally, all variable values in a block should start at the same column.",
-			"column.  There are some exceptions to this rule:",
+			"This provides orientation, especially for sequences",
 			"of variables that often appear in the same order.",
 			"For these it suffices to look at the variable values only.",
 			"",
 			"There are some exceptions to this rule:",
 			"",
-			"Definitions for long variable names may be indented with a single",
+			"Definitions for long variable names may be indented with a single space instead of tabs,",
-			"space instead of tabs, but only if they appear in a block that is",
+			"but only if they appear in a block that is otherwise indented using tabs.",
 			"otherwise indented using tabs.",
 			"",
-			"Variable definitions that span multiple lines are not checked for",
+			"Variable definitions that span multiple lines are not checked for alignment at all.",
 			"alignment at all.",
 			"",
 			"When the block contains something else than variable definitions",
 			"and directives like .if or .for, it is not checked at all.")
+	}
 	fix.ReplaceAfter(varnameOp, oldSpace, newSpace)
 	fix.Apply()
+}
 func (va *VaralignBlock) realignContinuationLines(mkline MkLine, newWidth int) {
 	indentation := strings.Repeat("\t", newWidth/8) + strings.Repeat(" ", newWidth%8)
 	fix := mkline.Autofix()
 	fix.Notef("This line should be aligned with %q.", indentation)

--- pkgsrc/pkgtools/pkglint/files/Attic/mklines_test.go 2018/12/02 01:57:48 1.31
+++ pkgsrc/pkgtools/pkglint/files/Attic/mklines_test.go 2018/12/02 23:12:43 1.32

 @@ -30,41 +30,38 @@ func (s *Suite) Test_MkLines_Check__auto
 	t.CheckFileLines("filename.mk",
 		"# $"+"NetBSD$",
 		".if defined(A)",
 		".  for a in ${A}",
 		".    if defined(C)",
 		".    endif",
 		".  endfor",
 		".endif")
+}
 func (s *Suite) Test_MkLines_Check__unusual_target(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	t.SetupTool("cc", "CC", AtRunTime)
 	mklines := t.NewMkLines("Makefile",
 		MkRcsID,
 		"",
 		"echo: echo.c",
 		"\tcc -o ${.TARGET} ${.IMPSRC}")
 	mklines.Check()
 	// FIXME: .TARGET is always defined.
 	// FIXME: .IMPSRC is always defined.
 	t.CheckOutputLines(
-		"WARN: Makefile:3: Unusual target \"echo\".",
+		"WARN: Makefile:3: Unusual target \"echo\".")
 		"WARN: Makefile:4: Unknown shell command \"cc\".",
 		"WARN: Makefile:4: .TARGET is used but not defined.",
 		"WARN: Makefile:4: .IMPSRC is used but not defined.")
+}
 func (s *Suite) Test_MkLines__quoting_LDFLAGS_for_GNU_configure(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	G.Pkg = NewPackage(t.File("category/pkgbase"))
 	mklines := t.NewMkLines("Makefile",
 		MkRcsID,
 		"GNU_CONFIGURE=\tyes",
 		"CONFIGURE_ENV+=\tX_LIBS=${X11_LDFLAGS:Q}")
 	mklines.Check()
 @@ -74,74 +71,79 @@ func (s *Suite) Test_MkLines__quoting_LD
 		"WARN: Makefile:3: Please use ${X11_LDFLAGS:M*:Q} instead of ${X11_LDFLAGS:Q}.")
+}
 func (s *Suite) Test_MkLines__for_loop_multiple_variables(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	t.SetupTool("echo", "ECHO", AtRunTime)
 	t.SetupTool("find", "FIND", AtRunTime)
 	t.SetupTool("pax", "PAX", AtRunTime)
 	mklines := t.NewMkLines("Makefile", // From audio/squeezeboxserver
 		MkRcsID,
 		"",
 		"SBS_COPY=\tsource target",
 		"",
 		".for _list_ _dir_ in ${SBS_COPY}",
 		"\tcd ${WRKSRC} && ${FIND} ${${_list_}} -type f ! -name '*.orig' 2>/dev/null "+
 			"| pax -rw -pm ${DESTDIR}${PREFIX}/${${_dir_}}",
 		".endfor")
 	mklines.Check()
 	t.CheckOutputLines(
-		"WARN: Makefile:3: Variable names starting with an underscore (_list_) are reserved for internal pkgsrc use.",
+		"WARN: Makefile:5: Variable names starting with an underscore (_list_) "+
-		"WARN: Makefile:3: Variable names starting with an underscore (_dir_) are reserved for internal pkgsrc use.",
+			"are reserved for internal pkgsrc use.",
-		"WARN: Makefile:3: SBS_COPY is used but not defined.",
+		"WARN: Makefile:5: Variable names starting with an underscore (_dir_) "+
-		"WARN: Makefile:4: The exitcode of \"${FIND}\" at the left of the | operator is ignored.")
+			"are reserved for internal pkgsrc use.",
 		"WARN: Makefile:6: The exitcode of \"${FIND}\" at the left of the | operator is ignored.")
+}
 func (s *Suite) Test_MkLines__comparing_YesNo_variable_to_string(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	mklines := t.NewMkLines("databases/gdbm_compat/builtin.mk",
 		MkRcsID,
 		".if ${USE_BUILTIN.gdbm} == \"no\"",
 		".endif",
 		".if ${USE_BUILTIN.gdbm:tu} == \"no\"", // Can never be true, since "no" is not uppercase.
 		".endif")
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: databases/gdbm_compat/builtin.mk:2: " +
-			"USE_BUILTIN.gdbm should be matched against \"[yY][eE][sS]\" or \"[nN][oO]\", not compared with \"no\".")
+			"USE_BUILTIN.gdbm should be matched against \"[yY][eE][sS]\" or \"[nN][oO]\", " +
 			"not compared with \"no\".")
+}
 func (s *Suite) Test_MkLines__varuse_sh_modifier(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	t.SetupTool("sed", "SED", AfterPrefsMk)
 	mklines := t.NewMkLines("lang/qore/module.mk",
 		MkRcsID,
 		"qore-version=\tqore --short-version | ${SED} -e s/-.*//",
 		"PLIST_SUBST+=\tQORE_VERSION=\"${qore-version:sh}\"")
 	vars2 := mklines.mklines[1].DetermineUsedVariables()
 	c.Check(vars2, deepEquals, []string{"SED"})
 	vars3 := mklines.mklines[2].DetermineUsedVariables()
 	// qore-version, despite its unusual name, is a pretty normal Make variable.
 	c.Check(vars3, deepEquals, []string{"qore-version"})
 	mklines.Check()
 	// No warnings about defined but not used or vice versa
 	t.CheckOutputEmpty()
+}
 // For parameterized variables, the "defined but not used" and
 // the "used but not defined" checks are loosened a bit.
 // When VAR.param1 is defined or used, VAR.param2 is also regarded
 // as defined or used since often in pkgsrc, parameterized variables
 // are not referred to by their exact names but by VAR.${param}.
 @@ -151,63 +153,79 @@ func (s *Suite) Test_MkLines__varuse_par
 	t.SetupVartypes()
 	mklines := t.NewMkLines("converters/wv2/Makefile",
 		MkRcsID,
 		"CONFIGURE_ARGS+=\t\t${CONFIGURE_ARGS.${ICONV_TYPE}-iconv}",
 		"CONFIGURE_ARGS.gnu-iconv=\t--with-libiconv=${BUILDLINK_PREFIX.iconv}")
 	mklines.Check()
 	// No warnings about CONFIGURE_ARGS.* being defined but not used or vice versa.
 	t.CheckOutputLines(
 		"WARN: converters/wv2/Makefile:2: ICONV_TYPE is used but not defined.")
+}
-// Even very complicated shell commands are parsed correctly.
+// When an ODE runtime loop is used to expand variables to shell commands,
-// Since the variable is defined in this same Makefile, it is
+// pkglint only understands that there is a variable that is executed as
-// assumed to be a known shell command and therefore does not need
+// shell command.
-// USE_TOOLS or a similar declaration.
+//
 // In this example, GCONF_SCHEMAS is a list of filenames, but pkglint doesn't know this
 // because there is no built-in rule saying *_SCHEMAS are filenames.
 // If the variable name had been GCONF_SCHEMA_FILES, pkglint would know.
 //
 // As of November 2018, pkglint sees GCONF_SCHEMAS as being the shell command.
 // It doesn't expand the @s@ loop to see what really happens.
 //
 // If it did that, it could notice that GCONF_SCHEMAS expands to a single shell command,
 // and in that command INSTALL_DATA is used as the command for the first time,
 // and as a regular command line argument in all other times.
 // This combination is strange enough to warrant a warning.
 //
 // The bug here is the missing semicolon just before the @}.
 //
 // Pkglint could offer to either add the missing semicolon.
 // Or, if it knows what INSTALL_DATA does, it could simply say that INSTALL_DATA
 // can handle multiple files in a single invocation.
 func (s *Suite) Test_MkLines__loop_modifier(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	mklines := t.NewMkLines("chat/xchat/Makefile",
 		MkRcsID,
 		"GCONF_SCHEMAS=\tapps_xchat_url_handler.schemas",
 		"post-install:",
-		"\t${GCONF_SCHEMAS:@.s.@"+
+		"\t${GCONF_SCHEMAS:@s@"+
-			"${INSTALL_DATA} ${WRKSRC}/src/common/dbus/${.s.} ${DESTDIR}${GCONF_SCHEMAS_DIR}/@}")
+			"${INSTALL_DATA} ${WRKSRC}/src/common/dbus/${s} ${DESTDIR}${GCONF_SCHEMAS_DIR}/@}")
 	mklines.Check()
 	// Earlier versions of pkglint warned about a missing @ at the end.
 	t.CheckOutputEmpty()
+}
 // PR 46570
 func (s *Suite) Test_MkLines__PKG_SKIP_REASON_depending_on_OPSYS(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	mklines := t.NewMkLines("Makefile",
 		MkRcsID,
 		"PKG_SKIP_REASON+=\t\"Fails everywhere\"",
 		".if ${OPSYS} == \"Cygwin\"",
 		"PKG_SKIP_REASON+=\t\"Fails on Cygwin\"",
 		".endif")
 	mklines.Check()
 	t.CheckOutputLines(
-		"NOTE: Makefile:4: Consider defining NOT_FOR_PLATFORM instead of setting PKG_SKIP_REASON depending on ${OPSYS}.")
+		"NOTE: Makefile:4: Consider setting NOT_FOR_PLATFORM instead of PKG_SKIP_REASON depending on ${OPSYS}.")
+}
 // PR 46570, item "15. net/uucp/Makefile has a make loop"
 func (s *Suite) Test_MkLines__indirect_variables(c *check.C) {
 	t := s.Init(c)
 	t.SetupTool("echo", "ECHO", AfterPrefsMk)
 	mklines := t.NewMkLines("net/uucp/Makefile",
 		MkRcsID,
 		"",
 		"post-configure:",
 		".for var in MAIL_PROGRAM CMDPATH",
 		"\t"+`${RUN} ${ECHO} "#define ${var} \""${UUCP_${var}}"\""`,
 @@ -301,27 +319,27 @@ func (s *Suite) Test_MkLines_CheckForUse
 	t.NewMkLines("Makefile.common",
 		MkRcsID,
 		"#",
 		"#",
 	).CheckForUsedComment("category/package")
 	t.CheckOutputLines(
 		"WARN: Makefile.common:3: Please add a line \"# used by category/package\" here.",
 		"AUTOFIX: Makefile.common:3: Inserting a line \"# used by category/package\" before this line.")
 	c.Check(G.autofixAvailable, equals, true)
+}
-func (s *Suite) Test_MkLines_DetermineDefinedVariables(c *check.C) {
+func (s *Suite) Test_MkLines_collectDefinedVariables(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wall,no-space")
 	t.SetupPkgsrc()
 	t.CreateFileLines("mk/tools/defaults.mk",
 		"USE_TOOLS+=     autoconf autoconf213")
 	G.Pkgsrc.LoadInfrastructure()
 	mklines := t.NewMkLines("determine-defined-variables.mk",
 		MkRcsID,
 		"",
 		"USE_TOOLS+=             autoconf213 autoconf",
 		"USE_TOOLS:=             ${USE_TOOLS:Ntbl}",
 		"",
 @@ -340,80 +358,80 @@ func (s *Suite) Test_MkLines_DetermineDe
 	mklines.Check()
 	// The tools autoreconf and autoheader213 are known at this point because of the USE_TOOLS line.
 	// The SUV variable is used implicitly by the SUBST framework, therefore no warning.
 	// The OSV.NetBSD variable is used implicitly via the OSV variable, therefore no warning.
 	t.CheckOutputLines(
 		// FIXME: the below warning is wrong; it's ok to have SUBST blocks in all files, maybe except buildlink3.mk.
 		"WARN: determine-defined-variables.mk:12: The variable SUBST_VARS.subst may not be set "+
 			"(only given a default value, appended to) in this file; it would be ok in Makefile, Makefile.common, options.mk.",
 		"WARN: determine-defined-variables.mk:16: Unknown shell command \"unknown-command\".")
+}
-func (s *Suite) Test_MkLines_DetermineDefinedVariables__BUILTIN_FIND_FILES_VAR(c *check.C) {
+func (s *Suite) Test_MkLines_collectDefinedVariables__BUILTIN_FIND_FILES_VAR(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wall,no-space")
 	t.SetupPackage("category/package")
 	t.CreateFileLines("mk/buildlink3/bsd.builtin.mk",
 		MkRcsID)
 	mklines := t.SetupFileMkLines("category/package/builtin.mk",
 		MkRcsID,
 		"",
 		"BUILTIN_FIND_FILES_VAR:=        H_XFT2",
 		"BUILTIN_FIND_FILES.H_XFT2=      ${X11BASE}/include/X11/Xft/Xft.h",
 		"",
 		".include \"../../mk/buildlink3/bsd.builtin.mk\"",
 		"",
 		".if ${H_XFT2:N__nonexistent__} && ${H_UNDEF:N__nonexistent__}",
 		".endif")
 	G.Pkgsrc.LoadInfrastructure()
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: ~/category/package/builtin.mk:8: H_UNDEF is used but not defined.")
+}
-func (s *Suite) Test_MkLines_DetermineUsedVariables__simple(c *check.C) {
+func (s *Suite) Test_MkLines_collectUsedVariables__simple(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("filename",
 		"\t${VAR}")
 	mkline := mklines.mklines[0]
 	G.Mk = mklines
-	mklines.DetermineUsedVariables()
+	mklines.collectUsedVariables()
 	c.Check(len(mklines.vars.used), equals, 1)
 	c.Check(mklines.vars.FirstUse("VAR"), equals, mkline)
+}
-func (s *Suite) Test_MkLines_DetermineUsedVariables__nested(c *check.C) {
+func (s *Suite) Test_MkLines_collectUsedVariables__nested(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("filename.mk",
 		MkRcsID,
 		"",
 		"LHS.${lparam}=\tRHS.${rparam}",
 		"",
 		"target:",
 		"\t${outer.${inner}}")
 	assignMkline := mklines.mklines[2]
 	shellMkline := mklines.mklines[5]
 	G.Mk = mklines
-	mklines.DetermineUsedVariables()
+	mklines.collectUsedVariables()
 	c.Check(len(mklines.vars.used), equals, 5)
 	c.Check(mklines.vars.FirstUse("lparam"), equals, assignMkline)
 	c.Check(mklines.vars.FirstUse("rparam"), equals, assignMkline)
 	c.Check(mklines.vars.FirstUse("inner"), equals, shellMkline)
 	c.Check(mklines.vars.FirstUse("outer.*"), equals, shellMkline)
 	c.Check(mklines.vars.FirstUse("outer.${inner}"), equals, shellMkline)
+}
 func (s *Suite) Test_MkLines__private_tool_undefined(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 @@ -628,27 +646,27 @@ func (s *Suite) Test_MkLines__wip_catego
 		"WARN: ~/wip/Makefile:14: Unusual target \"clean-tmpdir\".",
 		"",
 		"\tIf you want to define your own target, declare it like this:",
 		"",
 		"\t\t.PHONY: my-target",
 		"",
 		"\tIn the rare case that you actually want a file-based make(1) target,",
 		"\twrite it like this:",
 		"",
 		"\t\t${.CURDIR}/my-file:",
 		"")
+}
-func (s *Suite) Test_MkLines_determineDocumentedVariables(c *check.C) {
+func (s *Suite) Test_MkLines_collectDocumentedVariables(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	t.SetupTool("rm", "RM", AtRunTime)
 	mklines := t.NewMkLines("Makefile",
 		MkRcsID,
 		"#",
 		"# Copyright 2000-2018",
 		"#",
 		"# This whole comment is ignored, until the next empty line.",
 		"",
 		"# User-settable variables:",
 		"#",
 @@ -660,27 +678,27 @@ func (s *Suite) Test_MkLines_determineDo
 		"# PKG_VERBOSE",
 		"#\tWhen this variable is defined, pkgsrc gets a bit more verbose",
 		"#\t(i.e. \"-v\" option is passed to some commands ...",
 		"",
 		"# VARIABLE",
 		"#\tA paragraph of a single line is not enough to be recognized as \"relevant\".",
 		"",
 		"# VARBASE1.<param1>",
 		"# VARBASE2.*",
 		"# VARBASE3.${id}")
 	// The variables that appear in the documentation are marked as
 	// used, to prevent the "defined but not used" warnings.
-	mklines.determineDocumentedVariables()
+	mklines.collectDocumentedVariables()
 	var varnames []string
 	for varname, mkline := range mklines.vars.used {
 		varnames = append(varnames, fmt.Sprintf("%s (line %s)", varname, mkline.Linenos()))
+	}
 	sort.Strings(varnames)
 	expected := []string{
 		"PKG_DEBUG_LEVEL (line 9)",
 		"PKG_VERBOSE (line 14)",
 		"VARBASE1.* (line 21)",
 		"VARBASE2.* (line 22)",
 		"VARBASE3.${id} (line 23)",
 @@ -715,143 +733,143 @@ func (s *Suite) Test_MkLines__unknown_op
 	mklines := t.NewMkLines("options.mk",
 		MkRcsID,
 		"#",
 		"PKG_OPTIONS_VAR=\tPKG_OPTIONS.pkgbase",
 		"PKG_SUPPORTED_OPTIONS=\tknown unknown",
 		"PKG_SUGGESTED_OPTIONS=\tknown unknown")
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: options.mk:4: Unknown option \"unknown\".")
+}
-func (s *Suite) Test_MkLines_CheckRedundantVariables(c *check.C) {
+func (s *Suite) Test_MkLines_CheckRedundantAssignments(c *check.C) {
 	t := s.Init(c)
 	included := t.NewMkLines("module.mk",
 		"VAR=\tvalue ${OTHER}",
 		"VAR?=\tvalue ${OTHER}",
 		"VAR=\tnew value")
 	makefile := t.NewMkLines("Makefile",
 		"VAR=\tthe package may overwrite variables from other files")
 	allLines := append(append([]Line(nil), included.lines.Lines...), makefile.lines.Lines...)
 	mklines := NewMkLines(NewLines(included.lines.FileName, allLines))
 	// XXX: The warnings from here are not in the same order as the other warnings.
 	// XXX: There may be some warnings for the same file separated by warnings for other files.
-	mklines.CheckRedundantVariables()
+	mklines.CheckRedundantAssignments()
 	t.CheckOutputLines(
 		"NOTE: module.mk:1: Definition of VAR is redundant because of line 2.",
 		"WARN: module.mk:1: Variable VAR is overwritten in line 3.")
+}
-func (s *Suite) Test_MkLines_CheckRedundantVariables__different_value(c *check.C) {
+func (s *Suite) Test_MkLines_CheckRedundantAssignments__different_value(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("module.mk",
 		"VAR=\tvalue ${OTHER}",
 		"VAR?=\tdifferent value")
-	mklines.CheckRedundantVariables()
+	mklines.CheckRedundantAssignments()
 	t.CheckOutputEmpty()
+}
-func (s *Suite) Test_MkLines_CheckRedundantVariables__overwrite_same_value(c *check.C) {
+func (s *Suite) Test_MkLines_CheckRedundantAssignments__overwrite_same_value(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("module.mk",
 		"VAR=\tvalue ${OTHER}",
 		"VAR=\tvalue ${OTHER}")
-	mklines.CheckRedundantVariables()
+	mklines.CheckRedundantAssignments()
 	t.CheckOutputLines(
 		"NOTE: module.mk:1: Definition of VAR is redundant because of line 2.")
+}
-func (s *Suite) Test_MkLines_CheckRedundantVariables__procedure_call(c *check.C) {
+func (s *Suite) Test_MkLines_CheckRedundantAssignments__procedure_call(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("mk/pthread.buildlink3.mk",
 		"CHECK_BUILTIN.pthread:=\tyes",
 		".include \"../../mk/pthread.builtin.mk\"",
 		"CHECK_BUILTIN.pthread:=\tno")
-	mklines.CheckRedundantVariables()
+	mklines.CheckRedundantAssignments()
 	t.CheckOutputEmpty()
+}
-func (s *Suite) Test_MkLines_CheckRedundantVariables__shell_and_eval(c *check.C) {
+func (s *Suite) Test_MkLines_CheckRedundantAssignments__shell_and_eval(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("module.mk",
 		"VAR:=\tvalue ${OTHER}",
 		"VAR!=\tvalue ${OTHER}")
-	mklines.CheckRedundantVariables()
+	mklines.CheckRedundantAssignments()
 	// Combining := and != is too complicated to be analyzed by pkglint,
 	// therefore no warning.
 	t.CheckOutputEmpty()
+}
-func (s *Suite) Test_MkLines_CheckRedundantVariables__shell_and_eval_literal(c *check.C) {
+func (s *Suite) Test_MkLines_CheckRedundantAssignments__shell_and_eval_literal(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("module.mk",
 		"VAR:=\tvalue",
 		"VAR!=\tvalue")
-	mklines.CheckRedundantVariables()
+	mklines.CheckRedundantAssignments()
 	// Even when := is used with a literal value (which is usually
 	// only done for procedure calls), the shell evaluation can have
 	// so many different side effects that pkglint cannot reliably
 	// help in this situation.
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_MkLines_Check__PLIST_VARS(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wno-space")
 	t.SetupVartypes()
 	t.SetupOption("both", "")
 	t.SetupOption("only-added", "")
 	t.SetupOption("only-defined", "")
 	t.CreateFileLines("mk/bsd.options.mk")
-	mklines := t.SetupFileMkLines("options.mk",
+	mklines := t.SetupFileMkLines("category/package/options.mk",
 		MkRcsID,
 		"",
 		"PKG_OPTIONS_VAR=        PKG_OPTIONS.pkg",
 		"PKG_SUPPORTED_OPTIONS=  both only-added only-defined",
 		"PKG_SUGGESTED_OPTIONS=  # none",
 		"",
 		".include \"../../mk/bsd.options.mk\"",
 		"",
 		"PLIST_VARS+=            both only-added",
 		"",
 		".if !empty(PKG_OPTIONS:Mboth)",
 		"PLIST.both=             yes",
 		".endif",
 		"",
 		".if !empty(PKG_OPTIONS:Monly-defined)",
 		"PLIST.only-defined=     yes",
 		".endif")
 	mklines.Check()
 	t.CheckOutputLines(
-		"ERROR: ~/options.mk:7: \"mk/bsd.options.mk\" does not exist.", // Not relevant for this test.
+		"WARN: ~/category/package/options.mk:9: \"only-added\" is added to PLIST_VARS, but PLIST.only-added is not defined in this file.",
-		"WARN: ~/options.mk:9: \"only-added\" is added to PLIST_VARS, but PLIST.only-added is not defined in this file.",
+		"WARN: ~/category/package/options.mk:16: PLIST.only-defined is defined, but \"only-defined\" is not added to PLIST_VARS in this file.")
 		"WARN: ~/options.mk:16: PLIST.only-defined is defined, but \"only-defined\" is not added to PLIST_VARS in this file.")
+}
 func (s *Suite) Test_MkLines_Check__PLIST_VARS_indirect(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wno-space")
 	t.SetupVartypes()
 	t.SetupOption("option1", "")
 	t.SetupOption("option2", "")
 	mklines := t.SetupFileMkLines("module.mk",
 		MkRcsID,
 		"",
 @@ -864,27 +882,27 @@ func (s *Suite) Test_MkLines_Check__PLIS
 		".if 0",
 		"PLIST.option1=  yes",
 		".endif",
 		"",
 		".if 1",
 		"PLIST.option2=  yes",
 		".endif")
 	mklines.Check()
 	t.CheckOutputEmpty()
+}
-func (s *Suite) Test_MkLines_Check__if_else(c *check.C) {
+func (s *Suite) Test_MkLines_collectElse(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wno-space")
 	t.SetupVartypes()
 	mklines := t.NewMkLines("module.mk",
 		MkRcsID,
 		"",
 		".if 0",
 		".endif",
 		"",
 		".if 0",
 		".else",
 @@ -1080,128 +1098,149 @@ func (s *Suite) Test_MkLines_ForEach__co
 				c.Check(mklines.indentation.IsConditional(), equals, true)
 				seenDeveloper = true
 			case "USES_GETTEXT":
 				c.Check(mklines.indentation.IsConditional(), equals, true)
 				seenUsesGettext = true
+			}
+		}
 	})
 	c.Check(seenDeveloper, equals, true)
 	c.Check(seenUsesGettext, equals, true)
+}
-func (s *Suite) Test_VaralignBlock_Check__autofix(c *check.C) {
+// At 2018-12-02, pkglint had resolved ${MY_PLIST_VARS} into a single word,
 // whereas the correct behavior is to resolve it into two words.
 // It had produced warnings about mismatched PLIST_VARS IDs.
 func (s *Suite) Test_MkLines_checkVarassignPlist__indirect(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	mklines := t.SetupFileMkLines("plist.mk",
 		MkRcsID,
 		"",
 		"MY_PLIST_VARS=\tvar1 var2",
 		"PLIST_VARS+=\t${MY_PLIST_VARS}",
 		"",
 		"PLIST.var1=\tyes",
 		"PLIST.var2=\tyes")
 	mklines.Check()
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_VaralignBlock_Process__autofix(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wspace", "--show-autofix")
 	mklines := t.NewMkLines("file.mk",
 		"VAR=   value",    // Indentation 7, fixed to 8.
 		"",                //
 		"VAR=    value",   // Indentation 8, fixed to 8.
 		"",                //
 		"VAR=     value",  // Indentation 9, fixed to 8.
 		"",                //
 		"VAR= \tvalue",    // Mixed indentation 8, fixed to 8.
 		"",                //
 		"VAR=   \tvalue",  // Mixed indentation 8, fixed to 8.
 		"",                //
 		"VAR=    \tvalue", // Mixed indentation 16, fixed to 16.
 		"",                //
 		"VAR=\tvalue")     // Already aligned with tabs only, left unchanged.
 	var varalign VaralignBlock
 	for _, line := range mklines.mklines {
-		varalign.Check(line)
+		varalign.Process(line)
+	}
 	varalign.Finish()
 	t.CheckOutputLines(
 		"NOTE: file.mk:1: This variable value should be aligned with tabs, not spaces, to column 9.",
 		"AUTOFIX: file.mk:1: Replacing \"   \" with \"\\t\".",
 		"NOTE: file.mk:3: Variable values should be aligned with tabs, not spaces.",
 		"AUTOFIX: file.mk:3: Replacing \"    \" with \"\\t\".",
 		"NOTE: file.mk:5: This variable value should be aligned with tabs, not spaces, to column 9.",
 		"AUTOFIX: file.mk:5: Replacing \"     \" with \"\\t\".",
 		"NOTE: file.mk:7: Variable values should be aligned with tabs, not spaces.",
 		"AUTOFIX: file.mk:7: Replacing \" \\t\" with \"\\t\".",
 		"NOTE: file.mk:9: Variable values should be aligned with tabs, not spaces.",
 		"AUTOFIX: file.mk:9: Replacing \"   \\t\" with \"\\t\".",
 		"NOTE: file.mk:11: Variable values should be aligned with tabs, not spaces.",
 		"AUTOFIX: file.mk:11: Replacing \"    \\t\" with \"\\t\\t\".")
+}
 // When the lines of a paragraph are inconsistently aligned,
 // they are realigned to the minimum required width.
-func (s *Suite) Test_VaralignBlock_Check__reduce_indentation(c *check.C) {
+func (s *Suite) Test_VaralignBlock_Process__reduce_indentation(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("file.mk",
 		"VAR= \tvalue",
 		"VAR=    \tvalue",
 		"VAR=\t\t\t\tvalue",
 		"",
 		"VAR=\t\t\tneedlessly", // Nothing to be fixed here, since it looks good.
 		"VAR=\t\t\tdeep",
 		"VAR=\t\t\tindentation")
 	var varalign VaralignBlock
 	for _, mkline := range mklines.mklines {
-		varalign.Check(mkline)
+		varalign.Process(mkline)
+	}
 	varalign.Finish()
 	t.CheckOutputLines(
 		"NOTE: file.mk:1: Variable values should be aligned with tabs, not spaces.",
 		"NOTE: file.mk:2: This variable value should be aligned with tabs, not spaces, to column 9.",
 		"NOTE: file.mk:3: This variable value should be aligned to column 9.")
+}
 // For every variable assignment, there is at least one space or tab between the variable
 // name and the value. Even if it is the longest line, and even if the value would start
 // exactly at a tab stop.
-func (s *Suite) Test_VaralignBlock_Check__longest_line_no_space(c *check.C) {
+func (s *Suite) Test_VaralignBlock_Process__longest_line_no_space(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wspace")
 	mklines := t.NewMkLines("file.mk",
 		"SUBST_CLASSES+= aaaaaaaa",
 		"SUBST_STAGE.aaaaaaaa= pre-configure",
 		"SUBST_FILES.aaaaaaaa= *.pl",
 		"SUBST_FILTER_CMD.aaaaaa=cat")
 	var varalign VaralignBlock
 	for _, mkline := range mklines.mklines {
-		varalign.Check(mkline)
+		varalign.Process(mkline)
+	}
 	varalign.Finish()
 	t.CheckOutputLines(
 		"NOTE: file.mk:1: This variable value should be aligned with tabs, not spaces, to column 33.",
 		"NOTE: file.mk:2: This variable value should be aligned with tabs, not spaces, to column 33.",
 		"NOTE: file.mk:3: This variable value should be aligned with tabs, not spaces, to column 33.",
 		"NOTE: file.mk:4: This variable value should be aligned to column 33.")
+}
-func (s *Suite) Test_VaralignBlock_Check__only_spaces(c *check.C) {
+func (s *Suite) Test_VaralignBlock_Process__only_spaces(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wspace")
 	mklines := t.NewMkLines("file.mk",
 		"SUBST_CLASSES+= aaaaaaaa",
 		"SUBST_STAGE.aaaaaaaa= pre-configure",
 		"SUBST_FILES.aaaaaaaa= *.pl",
 		"SUBST_FILTER_CMD.aaaaaaaa= cat")
 	var varalign VaralignBlock
 	for _, mkline := range mklines.mklines {
-		varalign.Check(mkline)
+		varalign.Process(mkline)
+	}
 	varalign.Finish()
 	t.CheckOutputLines(
 		"NOTE: file.mk:1: This variable value should be aligned with tabs, not spaces, to column 33.",
 		"NOTE: file.mk:2: This variable value should be aligned with tabs, not spaces, to column 33.",
 		"NOTE: file.mk:3: This variable value should be aligned with tabs, not spaces, to column 33.",
 		"NOTE: file.mk:4: This variable value should be aligned with tabs, not spaces, to column 33.")
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/mklines_varalign_test.go 2018/11/07 20:58:23 1.5
+++ pkgsrc/pkgtools/pkglint/files/Attic/mklines_varalign_test.go 2018/12/02 23:12:43 1.6

 @@ -51,27 +51,27 @@ func (vt *VaralignTester) run(autofix bo
 	cmdline := []string{"-Wall"}
 	if autofix {
 		cmdline = append(cmdline, "--autofix")
+	}
 	if vt.source {
 		cmdline = append(cmdline, "--source")
+	}
 	t.SetupCommandLine(cmdline...)
 	mklines := t.SetupFileMkLines("Makefile", vt.input...)
 	var varalign VaralignBlock
 	for _, mkline := range mklines.mklines {
-		varalign.Check(mkline)
+		varalign.Process(mkline)
+	}
 	varalign.Finish()
 	if autofix {
 		if len(vt.autofixes) > 0 {
 			t.CheckOutputLines(vt.autofixes...)
 		} else {
 			t.CheckOutputEmpty()
+		}
 		SaveAutofixChanges(mklines.lines)
 		t.CheckFileLinesDetab("Makefile", vt.fixed...)
 	} else {

--- pkgsrc/pkgtools/pkglint/files/Attic/package.go 2018/12/02 01:57:48 1.39
+++ pkgsrc/pkgtools/pkglint/files/Attic/package.go 2018/12/02 23:12:43 1.40

 @@ -150,28 +150,28 @@ func (pkg *Package) loadPackageMakefile(
 	if G.Opts.DumpMakefile {
 		G.out.WriteLine("Whole Makefile (with all included files) follows:")
 		for _, line := range allLines.lines.Lines {
 			G.out.WriteLine(line.String())
+		}
+	}
 	if pkg.vars.Defined("USE_CMAKE") {
 		mainLines.Tools.def("cmake", "", false, AtRunTime)
 		mainLines.Tools.def("cpack", "", false, AtRunTime)
+	}
-	allLines.DetermineUsedVariables()
+	allLines.collectUsedVariables()
-	allLines.CheckRedundantVariables()
+	allLines.CheckRedundantAssignments()
 	pkg.Pkgdir, _ = pkg.vars.Value("PKGDIR")
 	pkg.DistinfoFile, _ = pkg.vars.Value("DISTINFO_FILE")
 	pkg.Filesdir, _ = pkg.vars.Value("FILESDIR")
 	pkg.Patchdir, _ = pkg.vars.Value("PATCHDIR")
 	// See lang/php/ext.mk
 	if varIsDefinedSimilar("PHPEXT_MK") {
 		if !varIsDefinedSimilar("USE_PHP_EXT_PATCHES") {
 			pkg.Patchdir = "patches"
+		}
 		if varIsDefinedSimilar("PECL_VERSION") {
 			pkg.DistinfoFile = "distinfo"
 @@ -207,27 +207,27 @@ func (pkg *Package) readMakefile(filenam
 	isMainMakefile := len(mainLines.mklines) == 0
 	result = true
 	lineAction := func(mkline MkLine) bool {
 		if isMainMakefile {
 			mainLines.mklines = append(mainLines.mklines, mkline)
 			mainLines.lines.Lines = append(mainLines.lines.Lines, mkline.Line)
+		}
 		allLines.mklines = append(allLines.mklines, mkline)
 		allLines.lines.Lines = append(allLines.lines.Lines, mkline.Line)
 		var includedFile, incDir, incBase string
 		if mkline.IsInclude() {
-			includedFile = resolveVariableRefs(mkline.ResolveVarsInRelativePath(mkline.IncludedFile(), true))
+			includedFile = resolveVariableRefs(mkline.ResolveVarsInRelativePath(mkline.IncludedFile()))
 			if containsVarRef(includedFile) {
 				if !contains(filename, "/mk/") {
 					mkline.Notef("Skipping include file %q. This may result in false warnings.", includedFile)
+				}
 				includedFile = ""
+			}
 			incDir, incBase = path.Split(includedFile)
+		}
 		if includedFile != "" {
 			if mkline.Basename != "buildlink3.mk" {
 				if m, bl3File := match1(includedFile, `^\.\./\.\./(.*)/buildlink3\.mk$`); m {
 					pkg.bl3[bl3File] = mkline.Line
 @@ -743,27 +743,27 @@ func (pkg *Package) checkLocallyModified
 			NewLineWhole(filename).Warnf("Don't commit changes to this file without asking the OWNER, %s.", owner)
 			G.Explain(
 				seeGuide("Package components, Makefile", "components.Makefile"))
+		}
 		if maintainer != "" {
 			NewLineWhole(filename).Notef("Please only commit changes that %s would approve.", maintainer)
 			G.Explain(
 				"See the pkgsrc guide, section \"Package components\",",
 				"keyword \"maintainer\", for more information.")
+		}
+	}
+}
-func (pkg *Package) CheckInclude(mkline MkLine, indentation *Indentation) {
+func (pkg *Package) checkIncludeConditionally(mkline MkLine, indentation *Indentation) {
 	conditionalVars := mkline.ConditionalVars()
 	if len(conditionalVars) == 0 {
 		conditionalVars = indentation.Varnames()
 		mkline.SetConditionalVars(conditionalVars)
+	}
 	if path.Dir(abspath(mkline.Filename)) == abspath(pkg.File(".")) {
 		includedFile := mkline.IncludedFile()
 		if indentation.IsConditional() {
 			pkg.conditionalIncludes[includedFile] = mkline
 			if other := pkg.unconditionalIncludes[includedFile]; other != nil {
 				mkline.Warnf("%q is included conditionally here (depending on %s) and unconditionally in %s.",

--- pkgsrc/pkgtools/pkglint/files/Attic/package_test.go 2018/12/02 01:57:48 1.33
+++ pkgsrc/pkgtools/pkglint/files/Attic/package_test.go 2018/12/02 23:12:43 1.34

 @@ -521,27 +521,27 @@ func (s *Suite) Test_Package_loadPackage
 		".if !defined(PECL_VERSION)",
 		"DISTINFO_FILE=  ${.CURDIR}/${PHPPKGSRCDIR}/distinfo",
 		".endif",
 		".if defined(USE_PHP_EXT_PATCHES)",
 		"PATCHDIR=       ${.CURDIR}/${PHPPKGSRCDIR}/patches",
 		".endif")
 	pkg := t.SetupPackage("category/package",
 		"PECL_VERSION=\t1.1.2",
 		".include \"../../lang/php/ext.mk\"")
 	G.CheckDirent(pkg)
+}
-func (s *Suite) Test_Package_CheckInclude__conditional_and_unconditional_include(c *check.C) {
+func (s *Suite) Test_Package_checkIncludeConditionally__conditional_and_unconditional_include(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	t.CreateFileLines("devel/zlib/buildlink3.mk", "")
 	t.CreateFileLines("licenses/gnu-gpl-v2", "")
 	t.CreateFileLines("mk/bsd.pkg.mk", "")
 	t.CreateFileLines("sysutils/coreutils/buildlink3.mk", "")
 	t.Chdir("category/package")
 	t.CreateFileLines("Makefile",
 		MkRcsID,
 		"",
 		"COMMENT=\tDescription",
 @@ -608,27 +608,27 @@ func (s *Suite) Test_Package__include_af
 		".if exists(options.mk)",
 		".  include \"options.mk\"",
 		".endif",
 		"",
 		".include \"../../mk/bsd.pkg.mk\"")
 	G.checkdirPackage(".")
 	t.CheckOutputLines(
 		"WARN: Makefile: Neither PLIST nor PLIST.common exist, and PLIST_SRC is unset.",
 		"WARN: distinfo: File not found. Please run \""+confMake+" makesum\" or define NO_CHECKSUM=yes in the package Makefile.",
 		"ERROR: Makefile: Each package must define its LICENSE.",
 		"WARN: Makefile: No COMMENT given.",
-		"ERROR: Makefile:4: \"options.mk\" does not exist.")
+		"ERROR: Makefile:4: Relative path \"options.mk\" does not exist.")
+}
 // See https://github.com/rillig/pkglint/issues/1
 func (s *Suite) Test_Package_readMakefile__include_other_after_exists(c *check.C) {
 	t := s.Init(c)
 	t.SetupVartypes()
 	t.CreateFileLines("mk/bsd.pkg.mk")
 	t.CreateFileLines("category/package/Makefile",
 		MkRcsID,
 		"",
 		".if exists(options.mk)",
 		".  include \"another.mk\"",

--- pkgsrc/pkgtools/pkglint/files/Attic/substcontext.go 2018/12/02 01:57:48 1.16
+++ pkgsrc/pkgtools/pkglint/files/Attic/substcontext.go 2018/12/02 23:12:43 1.17

 @@ -147,27 +147,27 @@ func (ctx *SubstContext) Varassign(mklin
 	case "SUBST_FILES.*":
 		ctx.dupBool(mkline, &ctx.curr.seenFiles, varname, op, value)
 	case "SUBST_SED.*":
 		ctx.dupBool(mkline, &ctx.curr.seenSed, varname, op, value)
 		ctx.curr.seenTransform = true
 		ctx.suggestSubstVars(mkline)
 	case "SUBST_VARS.*":
 		ctx.dupBool(mkline, &ctx.curr.seenVars, varname, op, value)
 		ctx.curr.seenTransform = true
-		for _, substVar := range mkline.ValueFields(value) {
+		for _, substVar := range mkline.Fields() {
 			if ctx.vars == nil {
 				ctx.vars = make(map[string]bool)
+			}
 			ctx.vars[substVar] = true
+		}
 	case "SUBST_FILTER_CMD.*":
 		ctx.dupString(mkline, &ctx.filterCmd, varname, value)
 		ctx.curr.seenTransform = true
+	}
+}
 func (ctx *SubstContext) Directive(mkline MkLine) {

--- pkgsrc/pkgtools/pkglint/files/Attic/tools_test.go 2018/12/02 01:57:48 1.8
+++ pkgsrc/pkgtools/pkglint/files/Attic/tools_test.go 2018/12/02 23:12:43 1.9

 @@ -245,52 +245,52 @@ func (s *Suite) Test_Tools__builtin_mk(c
 		"_TOOLS_VARNAME.load=                    LOAD",
 		"_TOOLS_VARNAME.run=                     RUN_CMD",
 		"_TOOLS_VARNAME.nowhere=                 NOWHERE")
 	t.CreateFileLines("mk/bsd.prefs.mk",
 		"USE_TOOLS+=     load")
 	t.CreateFileLines("mk/bsd.pkg.mk",
 		"USE_TOOLS+=     run")
 	t.CreateFileLines("mk/buildlink3/bsd.builtin.mk")
 	G.Pkgsrc.LoadInfrastructure()
 	// Tools that are defined by pkgsrc as load-time tools
 	// may be used in any file at load time.
-	mklines := t.SetupFileMkLines("builtin.mk",
+	mklines := t.SetupFileMkLines("category/package/builtin.mk",
 		MkRcsID,
 		"",
 		"VAR!=   ${ECHO} 'too early'",
 		"VAR!=   ${LOAD} 'too early'",
 		"VAR!=   ${RUN_CMD} 'never allowed'",
 		"VAR!=   ${NOWHERE} 'never allowed'",
 		"",
 		".include \"../../mk/buildlink3/bsd.builtin.mk\"",
 		"",
 		"VAR!=   ${ECHO} 'valid'",
 		"VAR!=   ${LOAD} 'valid'",
 		"VAR!=   ${RUN_CMD} 'never allowed'",
 		"VAR!=   ${NOWHERE} 'never allowed'",
 		"",
 		"VAR!=   ${VAR}")
 	mklines.Check()
 	t.CheckOutputLines(
-		"WARN: ~/builtin.mk:3: To use the tool ${ECHO} at load time, bsd.prefs.mk has to be included before.",
+		"WARN: ~/category/package/builtin.mk:3: To use the tool ${ECHO} at load time, bsd.prefs.mk has to be included before.",
-		"WARN: ~/builtin.mk:4: To use the tool ${LOAD} at load time, bsd.prefs.mk has to be included before.",
+		"WARN: ~/category/package/builtin.mk:4: To use the tool ${LOAD} at load time, bsd.prefs.mk has to be included before.",
-		"WARN: ~/builtin.mk:5: The tool ${RUN_CMD} cannot be used at load time.",
+		"WARN: ~/category/package/builtin.mk:5: The tool ${RUN_CMD} cannot be used at load time.",
-		"WARN: ~/builtin.mk:6: The tool ${NOWHERE} cannot be used at load time.",
+		"WARN: ~/category/package/builtin.mk:6: The tool ${NOWHERE} cannot be used at load time.",
-		"WARN: ~/builtin.mk:12: The tool ${RUN_CMD} cannot be used at load time.",
+		"WARN: ~/category/package/builtin.mk:12: The tool ${RUN_CMD} cannot be used at load time.",
-		"WARN: ~/builtin.mk:13: The tool ${NOWHERE} cannot be used at load time.")
+		"WARN: ~/category/package/builtin.mk:13: The tool ${NOWHERE} cannot be used at load time.")
+}
 func (s *Suite) Test_Tools__implicit_definition_in_bsd_pkg_mk(c *check.C) {
 	t := s.Init(c)
 	t.SetupPkgsrc()
 	t.SetupCommandLine("-Wall,no-space")
 	t.CreateFileLines("mk/tools/defaults.mk",
 		MkRcsID) // None
 	t.CreateFileLines("mk/bsd.prefs.mk",
 		"USE_TOOLS+=     load")
 	t.CreateFileLines("mk/bsd.pkg.mk",
 		"USE_TOOLS+=     run")

--- pkgsrc/pkgtools/pkglint/files/Attic/vardefs.go 2018/12/02 01:57:48 1.50
+++ pkgsrc/pkgtools/pkglint/files/Attic/vardefs.go 2018/12/02 23:12:43 1.51

--- pkgsrc/pkgtools/pkglint/files/Attic/vartypecheck_test.go 2018/12/02 01:57:48 1.36
+++ pkgsrc/pkgtools/pkglint/files/Attic/vartypecheck_test.go 2018/12/02 23:12:43 1.37

 @@ -206,27 +206,27 @@ func (s *Suite) Test_VartypeCheck_Depend
 		"broken[0-9]*../../x11/alacarte",
 		"broken>=:../../x11/alacarte",
 		"broken=0:../../x11/alacarte",
 		"broken=:../../x11/alacarte",
 		"broken-:../../x11/alacarte",
 		"broken>:../../x11/alacarte",
 		"gtk2+>=2.16:../../x11/alacarte",
 		"gettext-[0-9]*:../../devel/gettext",
 		"gmake-[0-9]*:../../devel/gmake")
 	vt.Output(
 		"WARN: ~/category/package/filename.mk:1: Invalid dependency pattern with path \"Perl\".",
 		"WARN: ~/category/package/filename.mk:2: Dependencies should have the form \"../../category/package\".",
-		"ERROR: ~/category/package/filename.mk:3: \"../../lang/perl5\" does not exist.",
+		"ERROR: ~/category/package/filename.mk:3: Relative path \"../../lang/perl5\" does not exist.",
 		"ERROR: ~/category/package/filename.mk:3: There is no package in \"lang/perl5\".",
 		"WARN: ~/category/package/filename.mk:3: Please use USE_TOOLS+=perl:run instead of this dependency.",
 		"WARN: ~/category/package/filename.mk:4: Invalid dependency pattern \"broken0.12.1\".",
 		"WARN: ~/category/package/filename.mk:5: Invalid dependency pattern \"broken[0-9]*\".",
 		"WARN: ~/category/package/filename.mk:6: Invalid dependency pattern with path \"broken[0-9]*../../x11/alacarte\".",
 		"WARN: ~/category/package/filename.mk:7: Invalid dependency pattern \"broken>=\".",
 		"WARN: ~/category/package/filename.mk:8: Invalid dependency pattern \"broken=0\".",
 		"WARN: ~/category/package/filename.mk:9: Invalid dependency pattern \"broken=\".",
 		"WARN: ~/category/package/filename.mk:10: Invalid dependency pattern \"broken-\".",
 		"WARN: ~/category/package/filename.mk:11: Invalid dependency pattern \"broken>\".",
 		"WARN: ~/category/package/filename.mk:13: Please use USE_TOOLS+=msgfmt instead of this dependency.",
 		"WARN: ~/category/package/filename.mk:14: Please use USE_TOOLS+=gmake instead of this dependency.")
+}
 @@ -295,27 +295,27 @@ func (s *Suite) Test_VartypeCheck_Enum__
 	mklines := t.NewMkLines("module.mk",
 		MkRcsID,
 		"",
 		".if !empty(MACHINE_ARCH:Mi386) || ${MACHINE_ARCH} == i386",
 		".endif",
 		".if !empty(PKGSRC_COMPILER:Mclang) || ${PKGSRC_COMPILER} == clang",
 		".endif",
 		".if ${MACHINE_ARCH:Ni386:Nx86_64:Nsparc64}",
 		".endif")
 	mklines.Check()
 	t.CheckOutputLines(
-		"NOTE: module.mk:3: MACHINE_ARCH should be compared using == instead of the :M or :N modifier without wildcards.",
+		"NOTE: module.mk:3: MACHINE_ARCH should be compared using == instead of matching against \":Mi386\".",
 		"WARN: module.mk:5: Use ${PKGSRC_COMPILER:Mclang} instead of the == operator.")
+}
 func (s *Suite) Test_VartypeCheck_FetchURL(c *check.C) {
 	t := s.Init(c)
 	vt := NewVartypeCheckTester(t, (*VartypeCheck).FetchURL)
 	t.SetupMasterSite("MASTER_SITE_GNU", "http://ftp.gnu.org/pub/gnu/")
 	t.SetupMasterSite("MASTER_SITE_GITHUB", "https://github.com/")
 	vt.Varname("MASTER_SITES")
 	vt.Values(
 		"https://github.com/example/project/",
 @@ -514,27 +514,27 @@ func (s *Suite) Test_VartypeCheck_LdFlag
 	vt.Output(
 		"WARN: filename:4: Unknown linker flag \"-unknown\".",
 		"WARN: filename:5: Linker flag \"no-hyphen\" should start with a hyphen.",
 		"WARN: filename:6: Please use \"${COMPILER_RPATH_FLAG}\" instead of \"-Wl,--rpath\".")
+}
 func (s *Suite) Test_VartypeCheck_License(c *check.C) {
 	t := s.Init(c)
 	t.SetupPkgsrc() // Adds the gnu-gpl-v2 and 2-clause-bsd licenses
 	G.Mk = t.NewMkLines("perl5.mk",
 		MkRcsID,
 		"PERL5_LICENSE= gnu-gpl-v2 OR artistic")
-	G.Mk.DetermineDefinedVariables()
+	G.Mk.collectDefinedVariables()
 	vt := NewVartypeCheckTester(t, (*VartypeCheck).License)
 	vt.Varname("LICENSE")
 	vt.Values(
 		"gnu-gpl-v2",
 		"AND mit",
 		"${PERL5_LICENSE}", // Is properly resolved, see perl5.mk above.
 		"${UNKNOWN_LICENSE}")
 	vt.Output(
 		"ERROR: filename:2: Parse error for license condition \"AND mit\".",
 		"WARN: filename:3: License file ~/licenses/artistic does not exist.",
 @@ -743,29 +743,29 @@ func (s *Suite) Test_VartypeCheck_PkgPat
 	vt := NewVartypeCheckTester(t, (*VartypeCheck).PkgPath)
 	t.CreateFileLines("category/other-package/Makefile")
 	t.Chdir("category/package")
 	vt.Varname("PKGPATH")
 	vt.Values(
 		"category/other-package",
 		"${OTHER_VAR}",
 		"invalid",
 		"../../invalid/relative")
 	vt.Output(
-		"ERROR: filename:3: \"../../invalid\" does not exist.",
+		"ERROR: filename:3: Relative path \"../../invalid\" does not exist.",
 		"WARN: filename:3: \"../../invalid\" is not a valid relative package directory.",
-		"ERROR: filename:4: \"../../../../invalid/relative\" does not exist.",
+		"ERROR: filename:4: Relative path \"../../../../invalid/relative\" does not exist.",
 		"WARN: filename:4: \"../../../../invalid/relative\" is not a valid relative package directory.")
+}
 func (s *Suite) Test_VartypeCheck_PkgRevision(c *check.C) {
 	vt := NewVartypeCheckTester(s.Init(c), (*VartypeCheck).PkgRevision)
 	vt.Varname("PKGREVISION")
 	vt.Values(
 		"3a")
 	vt.Output(
 		"WARN: filename:1: PKGREVISION must be a positive integer number.",
 		"ERROR: filename:1: PKGREVISION only makes sense directly in the package Makefile.")
 @@ -852,29 +852,29 @@ func (s *Suite) Test_VartypeCheck_Relati
 	t.CreateFileLines("category/other-package/Makefile")
 	t.Chdir("category/package")
 	vt.Varname("DISTINFO_FILE")
 	vt.Values(
 		"category/other-package",
 		"../../category/other-package",
 		"${OTHER_VAR}",
 		"invalid",
 		"../../invalid/relative")
 	vt.Output(
-		"ERROR: filename:1: \"category/other-package\" does not exist.",
+		"ERROR: filename:1: Relative path \"category/other-package\" does not exist.",
-		"ERROR: filename:4: \"invalid\" does not exist.",
+		"ERROR: filename:4: Relative path \"invalid\" does not exist.",
-		"ERROR: filename:5: \"../../invalid/relative\" does not exist.")
+		"ERROR: filename:5: Relative path \"../../invalid/relative\" does not exist.")
+}
 func (s *Suite) Test_VartypeCheck_Restricted(c *check.C) {
 	vt := NewVartypeCheckTester(s.Init(c), (*VartypeCheck).Restricted)
 	vt.Varname("NO_BIN_ON_CDROM")
 	vt.Values(
 		"May only be distributed free of charge")
 	vt.Output(
 		"WARN: filename:1: The only valid value for NO_BIN_ON_CDROM is ${RESTRICTED}.")
+}

	@@ -131,27 +131,27 @@ func (src *Pkgsrc) InitVartypes() {		@@ -131,27 +131,27 @@ func (src *Pkgsrc) InitVartypes() {
131	if !contains(word, "$") {	131	if !contains(word, "$") {
132	values[word] = true	132	values[word] = true
133	}	133	}
134	}	134	}
135	}	135	}
136	}	136	}
137	}	137	}
138	}	138	}
139	}	139	}
140		140
141	if len(values) > 0 {	141	if len(values) > 0 {
142	joined := keysJoined(values)	142	joined := keysJoined(values)
143	if trace.Tracing {	143	if trace.Tracing {
144	trace.Stepf("Enum from %s in: %s", strings.Join(varcanons, " "), filename, joined)	144	trace.Stepf("Enum from %s in %s with values: %s", strings.Join(varcanons, " "), filename, joined)
145	}	145	}
146	return enum(joined)	146	return enum(joined)
147	}	147	}
148		148
149	if trace.Tracing {	149	if trace.Tracing {
150	trace.Stepf("Enum from default value: %s", defval)	150	trace.Stepf("Enum from default value: %s", defval)
151	}	151	}
152	return enum(defval)	152	return enum(defval)
153	}	153	}
154		154
155	// enumFromDirs reads the directories from category, takes all	155	// enumFromDirs reads the directories from category, takes all
156	// that have a single number in them and ranks them from earliest	156	// that have a single number in them and ranks them from earliest
157	// to latest.	157	// to latest.
	@@ -477,26 +477,27 @@ func (src *Pkgsrc) InitVartypes() {		@@ -477,26 +477,27 @@ func (src *Pkgsrc) InitVartypes() {
477	usrpkg("WCALC_HTMLDIR", lkNone, BtPathname)	477	usrpkg("WCALC_HTMLDIR", lkNone, BtPathname)
478	usrpkg("WCALC_HTMLPATH", lkNone, BtPathname) // URL path	478	usrpkg("WCALC_HTMLPATH", lkNone, BtPathname) // URL path
479	usrpkg("WCALC_CGIDIR", lkNone, BtPrefixPathname)	479	usrpkg("WCALC_CGIDIR", lkNone, BtPrefixPathname)
480	usrpkg("WCALC_CGIPATH", lkNone, BtPathname) // URL path	480	usrpkg("WCALC_CGIPATH", lkNone, BtPathname) // URL path
481	usrpkg("WDM_MANAGERS", lkShell, BtIdentifier)	481	usrpkg("WDM_MANAGERS", lkShell, BtIdentifier)
482	usrpkg("X10_PORT", lkNone, BtPathname)	482	usrpkg("X10_PORT", lkNone, BtPathname)
483	usrpkg("XAW_TYPE", lkNone, enum("standard 3d xpm neXtaw"))	483	usrpkg("XAW_TYPE", lkNone, enum("standard 3d xpm neXtaw"))
484	usrpkg("XLOCK_DEFAULT_MODE", lkNone, BtIdentifier)	484	usrpkg("XLOCK_DEFAULT_MODE", lkNone, BtIdentifier)
485	usrpkg("ZSH_STATIC", lkNone, BtYes)	485	usrpkg("ZSH_STATIC", lkNone, BtYes)
486		486
487	// some other variables, sorted alphabetically	487	// some other variables, sorted alphabetically
488		488
489	acl(".CURDIR", lkNone, BtPathname, "buildlink3.mk:; *: use, use-loadtime")	489	acl(".CURDIR", lkNone, BtPathname, "buildlink3.mk:; *: use, use-loadtime")
		490	acl(".IMPSRC", lkShell, BtPathname, "buildlink3.mk:; *: use, use-loadtime")
490	acl(".TARGET", lkNone, BtPathname, "buildlink3.mk:; *: use, use-loadtime")	491	acl(".TARGET", lkNone, BtPathname, "buildlink3.mk:; *: use, use-loadtime")
491	acl("@", lkNone, BtPathname, "buildlink3.mk:; *: use, use-loadtime")	492	acl("@", lkNone, BtPathname, "buildlink3.mk:; *: use, use-loadtime")
492	acl("ALL_ENV", lkShell, BtShellWord, "")	493	acl("ALL_ENV", lkShell, BtShellWord, "")
493	acl("ALTERNATIVES_FILE", lkNone, BtFileName, "")	494	acl("ALTERNATIVES_FILE", lkNone, BtFileName, "")
494	acl("ALTERNATIVES_SRC", lkShell, BtPathname, "")	495	acl("ALTERNATIVES_SRC", lkShell, BtPathname, "")
495	pkg("APACHE_MODULE", lkNone, BtYes)	496	pkg("APACHE_MODULE", lkNone, BtYes)
496	sys("AR", lkNone, BtShellCommand)	497	sys("AR", lkNone, BtShellCommand)
497	sys("AS", lkNone, BtShellCommand)	498	sys("AS", lkNone, BtShellCommand)
498	pkglist("AUTOCONF_REQD", lkShell, BtVersion)	499	pkglist("AUTOCONF_REQD", lkShell, BtVersion)
499	acl("AUTOMAKE_OVERRIDE", lkShell, BtPathmask, "")	500	acl("AUTOMAKE_OVERRIDE", lkShell, BtPathmask, "")
500	pkglist("AUTOMAKE_REQD", lkShell, BtVersion)	501	pkglist("AUTOMAKE_REQD", lkShell, BtVersion)
501	pkg("AUTO_MKDIRS", lkNone, BtYesNo)	502	pkg("AUTO_MKDIRS", lkNone, BtYesNo)
502	usr("BATCH", lkNone, BtYes)	503	usr("BATCH", lkNone, BtYes)