 @@ -801,52 +801,57 @@ func (mkline *MkLine) CheckText(text str
 		varbase, varext := m[1], m[2]
 		varname := varbase + varext
 		varcanon := varnameCanon(varname)
 		instead := G.globalData.Deprecated[varname]
 		if instead == "" {
 			instead = G.globalData.Deprecated[varcanon]
+		}
 		if instead != "" {
 			mkline.Warn2("Use of %q is deprecated. %s", varname, instead)
+		}
+	}
+}
-func (mkline *MkLine) CheckIf() {
+func (mkline *MkLine) CheckCond() {
 	if G.opts.DebugTrace {
 		defer tracecall0()()
+	}
-	tree := mkline.parseMkCond(mkline.Args())
+	p := NewParser(mkline.Args())
 	cond := p.MkCond()
 	if !p.EOF() {
 		mkline.Warn1("Invalid conditional %q.", mkline.Args())
 		return
+	}
 	cond.Visit("empty", func(node *Tree) {
-		var pvarname, ppattern *string
+		varuse := node.args[0].(MkVarUse)
-		if tree.Match(NewTree("not", NewTree("empty", NewTree("match", &pvarname, &ppattern)))) {
+		varname := varuse.varname
-			vartype := mkline.getVariableType(*pvarname)
+		for _, modifier := range varuse.modifiers {
-			if vartype != nil && vartype.checker.IsEnum() {
+			if modifier[0] == 'M' || modifier[0] == 'N' {
-				if !matches(*ppattern, `[\$\[*]`) && !vartype.checker.HasEnum(*ppattern) {
+				mkline.CheckVartype(varname, opUseMatch, modifier[1:], "")
 					mkline.Warn2("Invalid :M value %q. Only { %s } are allowed.", *ppattern, vartype.checker.AllowedEnums())
+			}
 			return
+		}
 	})
 	cond.Visit("compareVarStr", func(node *Tree) {
-		var pop, pvarname, pvalue *string
+		varuse := node.args[0].(MkVarUse)
-		if tree.Match(NewTree("compareVarStr", &pvarname, &pop, &pvalue)) {
+		varname := varuse.varname
-			mkline.CheckVartype(*pvarname, opUse, *pvalue, "")
+		varmods := varuse.modifiers
 		value := node.args[2].(string)
 		if len(varmods) == 0 || len(varmods) == 1 && matches(varmods[0], `^[MN]`) && value != "" {
 			mkline.CheckVartype(varname, opUseMatch, value, "")
+		}
 	})
+}
 func (mkline *MkLine) CheckValidCharactersInValue(reValid string) {
 	rest := regcomp(reValid).ReplaceAllString(mkline.Value(), "")
 	if rest != "" {
 		uni := ""
 		for _, c := range rest {
 			uni += fmt.Sprintf(" %U", c)
+		}
 		mkline.Warn2("%s contains invalid characters (%s).", mkline.Varname(), uni[1:])
+	}
+}
 @@ -940,57 +945,26 @@ func matchMkCond(text string) (m bool, i
 		i++
+	}
 	for i > argsStart && (text[i-1] == ' ' || text[i-1] == '\t') {
 		i--
+	}
 	argsEnd := i
 	m = true
 	indent = text[indentStart:indentEnd]
 	args = text[argsStart:argsEnd]
 	return
+}
 func (mkline *MkLine) parseMkCond(cond string) *Tree {
 	if G.opts.DebugTrace {
 		defer tracecall1(cond)()
 	const (
 		repartVarname = `[A-Z_][A-Z0-9_]*(?:\.[\w_+\-]+)?`
 		reDefined     = `^defined\((` + repartVarname + `)\)`
 		reEmpty       = `^empty\((` + repartVarname + `)\)`
 		reEmptyMatch  = `^empty\((` + repartVarname + `):M([^\$:{})]+)\)`
 		reCompare     = `^\$\{(` + repartVarname + `)\}\s+(==|!=)\s+"([^"\$\\]*)"`
 	if m, rest := replaceFirst(cond, `^!`, ""); m != nil {
 		return NewTree("not", mkline.parseMkCond(rest))
 	if m, rest := replaceFirst(cond, reDefined, ""); m != nil {
 		return NewTree("defined", mkline.parseMkCond(rest))
 	if m, _ := replaceFirst(cond, reEmpty, ""); m != nil {
 		return NewTree("empty", m[1])
 	if m, _ := replaceFirst(cond, reEmptyMatch, ""); m != nil {
 		return NewTree("empty", NewTree("match", m[1], m[2]))
 	if m, _ := replaceFirst(cond, reCompare, ""); m != nil {
 		return NewTree("compareVarStr", m[1], m[2], m[3])
 	return NewTree("unknown", cond)
 type NeedsQuoting uint8
 const (
 	nqNo NeedsQuoting = iota
 	nqYes
 	nqDoesntMatter
 	nqDontKnow
+)
 func (mkline *MkLine) variableNeedsQuoting(varname string, vuc *VarUseContext) (needsQuoting NeedsQuoting) {
 	if G.opts.DebugTrace {
 		defer tracecall(varname, *vuc, "=>", needsQuoting)()
+	}

 @@ -295,59 +295,51 @@ func (s *Suite) TestMkLine_fields(c *che
 	c.Check(s.Output(), equals, "WARN: test.mk:9: Space before colon in dependency line.\n")
+}
 func (s *Suite) TestMkLine_checkVarassign(c *check.C) {
 	G.Pkg = NewPackage("graphics/gimp-fix-ca")
 	G.globalData.InitVartypes()
 	mkline := NewMkLine(NewLine("fname", 10, "MASTER_SITES=http://registry.gimp.org/file/fix-ca.c?action=download&id=9884&file=", nil))
 	mkline.CheckVarassign()
 	c.Check(s.Output(), equals, "")
+}
 func (s *Suite) TestParseMkCond_NotEmptyMatch(c *check.C) {
 	mkline := NewMkLine(NewLine("fname", 1, ".if !empty(USE_LIBTOOL:M[Yy][Ee][Ss])", nil))
 	cond := mkline.parseMkCond(mkline.Args())
 	c.Check(cond, check.DeepEquals, NewTree("not", NewTree("empty", NewTree("match", "USE_LIBTOOL", "[Yy][Ee][Ss]"))))
 func (s *Suite) TestParseMkCond_Compare(c *check.C) {
 	mkline := NewMkLine(NewLine("fname", 1, ".if ${VARNAME} != \"Value\"", nil))
 	cond := mkline.parseMkCond(mkline.Args())
 	c.Check(cond, check.DeepEquals, NewTree("compareVarStr", "VARNAME", "!=", "Value"))
 func (s *Suite) TestChecklineMkCondition(c *check.C) {
 	s.UseCommandLine(c, "-Wtypes")
 	G.globalData.InitVartypes()
-	NewMkLine(NewLine("fname", 1, ".if !empty(PKGSRC_COMPILER:Mmycc)", nil)).CheckIf()
+	NewMkLine(NewLine("fname", 1, ".if !empty(PKGSRC_COMPILER:Mmycc)", nil)).CheckCond()
-	c.Check(s.Stdout(), equals, "WARN: fname:1: Invalid :M value \"mycc\". "+
+	c.Check(s.Stdout(), equals, "WARN: fname:1: The pattern \"mycc\" cannot match any of "+
-		"Only { ccache ccc clang distcc f2c gcc hp icc ido gcc mipspro "+
+		"{ ccache ccc clang distcc f2c gcc hp icc ido "+
-		"mipspro-ucode pcc sunpro xlc } are allowed.\n")
+		"gcc mipspro mipspro-ucode pcc sunpro xlc } for PKGSRC_COMPILER.\n")
-	NewMkLine(NewLine("fname", 1, ".elif ${A} != ${B}", nil)).CheckIf()
+	NewMkLine(NewLine("fname", 1, ".elif ${A} != ${B}", nil)).CheckCond()
-	c.Check(s.Stdout(), equals, "") // Unknown condition types are silently ignored
+	c.Check(s.Stdout(), equals, "")
-	NewMkLine(NewLine("fname", 1, ".if ${HOMEPAGE} == \"mailto:someone@example.org\"", nil)).CheckIf()
+	NewMkLine(NewLine("fname", 1, ".if ${HOMEPAGE} == \"mailto:someone@example.org\"", nil)).CheckCond()
 	c.Check(s.Output(), equals, "WARN: fname:1: \"mailto:someone@example.org\" is not a valid URL.\n")
 	NewMkLine(NewLine("fname", 1, ".if !empty(PKGSRC_RUN_TEST:M[Y][eE][sS])", nil)).CheckCond()
 	c.Check(s.Output(), equals, "WARN: fname:1: PKGSRC_RUN_TEST should be matched against \"[yY][eE][sS]\" or \"[nN][oO]\", not \"[Y][eE][sS]\".\n")
 	NewMkLine(NewLine("fname", 1, ".if !empty(IS_BUILTIN.Xfixes:M[yY][eE][sS])", nil)).CheckCond()
 	c.Check(s.Output(), equals, "")
+}
 func (s *Suite) TestMkLine_variableNeedsQuoting(c *check.C) {
 	mkline := NewMkLine(NewLine("fname", 1, "PKGNAME := ${UNKNOWN}", nil))
 	G.globalData.InitVartypes()
 	pkgnameType := G.globalData.vartypes["PKGNAME"]
 	vuc := &VarUseContext{pkgnameType, vucTimeParse, vucQuotUnknown, vucExtentUnknown}
 	nq := mkline.variableNeedsQuoting("UNKNOWN", vuc)
 	c.Check(nq, equals, nqDontKnow)
+}
 @@ -433,27 +425,27 @@ func (s *Suite) TestMkLine_CheckVarusePe
 		"COMMENT=\t${GAMES_USER}",
 		"COMMENT:=\t${PKGBASE}",
 		"PYPKGPREFIX=${PKGBASE}")
 	G.globalData.UserDefinedVars = map[string]*MkLine{
 		"GAMES_USER": mklines.mklines[0],
+	}
 	mklines.Check()
 	c.Check(s.Output(), equals, ""+
 		"WARN: options.mk:2: The user-defined variable GAMES_USER is used but not added to BUILD_DEFS.\n"+
 		"WARN: options.mk:3: PKGBASE should not be evaluated at load time.\n"+
 		"WARN: options.mk:4: The variable PYPKGPREFIX may not be set in this file; it would be ok in pyversion.mk.\n"+
-		"WARN: options.mk:4: \"${PKGBASE}\" is not valid for PYPKGPREFIX. Use one of { py27 py33 py34 } instead.\n"+
+		"WARN: options.mk:4: \"${PKGBASE}\" is not valid for PYPKGPREFIX. Use one of { py27 py33 py34 py35 } instead.\n"+
 		"WARN: options.mk:4: PKGBASE should not be evaluated indirectly at load time.\n"+
 		"NOTE: options.mk:4: This variable value should be aligned to column 17.\n")
+}
 func (s *Suite) TestMkLine_WarnVaruseLocalbase(c *check.C) {
 	mkline := NewMkLine(NewLine("options.mk", 56, "PKGNAME=${LOCALBASE}", nil))
 	mkline.WarnVaruseLocalbase()
 	c.Check(s.Output(), equals, "WARN: options.mk:56: The LOCALBASE variable should not be used by packages.\n")
+}
 func (s *Suite) TestMkLine_Misc(c *check.C) {

 @@ -32,33 +32,33 @@ func NewMkLines(lines []*Line) *MkLines
 	return &MkLines{
 		mklines,
 		lines,
 		make(map[string]bool),
 		make([]int, 1),
 		"",
 		make(map[string]*MkLine),
 		make(map[string]*MkLine),
 		make(map[string]bool),
 		make(map[string]bool),
 		tools}
+}
-func (mklines *MkLines) IndentDepth() int {
+func (mklines *MkLines) indentDepth() int {
 	return mklines.indentation[len(mklines.indentation)-1]
+}
-func (mklines *MkLines) PopIndent() {
+func (mklines *MkLines) popIndent() {
 	mklines.indentation = mklines.indentation[:len(mklines.indentation)-1]
+}
-func (mklines *MkLines) PushIndent(indent int) {
+func (mklines *MkLines) pushIndent(indent int) {
 	mklines.indentation = append(mklines.indentation, indent)
+}
 func (mklines *MkLines) DefineVar(mkline *MkLine, varname string) {
 	if mklines.vardef[varname] == nil {
 		mklines.vardef[varname] = mkline
+	}
 	varcanon := varnameCanon(varname)
 	if mklines.vardef[varcanon] == nil {
 		mklines.vardef[varcanon] = mkline
+	}
+}
 @@ -78,45 +78,45 @@ func (mklines *MkLines) VarValue(varname
+	}
 	return "", false
+}
 func (mklines *MkLines) Check() {
 	if G.opts.DebugTrace {
 		defer tracecall1(mklines.lines[0].Fname)()
+	}
 	G.Mk = mklines
 	defer func() { G.Mk = nil }()
 	allowedTargets := make(map[string]bool)
-	prefixes := splitOnSpace("pre do post")
+	prefixes := [...]string{"pre", "do", "post"}
-	actions := splitOnSpace("fetch extract patch tools wrapper configure build test install package clean")
+	actions := [...]string{"fetch", "extract", "patch", "tools", "wrapper", "configure", "build", "test", "install", "package", "clean"}
 	for _, prefix := range prefixes {
 		for _, action := range actions {
 			allowedTargets[prefix+"-"+action] = true
+		}
+	}
 	// In the first pass, all additions to BUILD_DEFS and USE_TOOLS
 	// are collected to make the order of the definitions irrelevant.
 	mklines.DetermineUsedVariables()
 	mklines.determineDefinedVariables()
 	// In the second pass, the actual checks are done.
 	mklines.lines[0].CheckRcsid(`#\s+`, "# ")
-	substcontext := new(SubstContext)
+	var substcontext SubstContext
-	varalign := new(VaralignBlock)
+	var varalign VaralignBlock
 	for _, mkline := range mklines.mklines {
 		mkline.Line.CheckTrailingWhitespace()
 		mkline.Line.CheckValidCharacters(`[\t -~]`)
 		varalign.Check(mkline)
 		switch {
 		case mkline.IsEmpty():
 			substcontext.Finish(mkline)
 		case mkline.IsVarassign():
 			mklines.target = ""
 			mkline.CheckVarassign()
 			substcontext.Varassign(mkline)
 @@ -133,28 +133,28 @@ func (mklines *MkLines) Check() {
 		case mkline.IsCond():
 			mklines.checklineCond(mkline)
 		case mkline.IsDependency():
 			mklines.checklineDependencyRule(mkline, mkline.Targets(), mkline.Sources(), allowedTargets)
+		}
+	}
 	lastMkline := mklines.mklines[len(mklines.mklines)-1]
 	substcontext.Finish(lastMkline)
 	varalign.Finish()
 	ChecklinesTrailingEmptyLines(mklines.lines)
-	if len(mklines.indentation) != 1 && mklines.IndentDepth() != 0 {
+	if len(mklines.indentation) != 1 && mklines.indentDepth() != 0 {
-		lastMkline.Line.Errorf("Directive indentation is not 0, but %d.", mklines.IndentDepth())
+		lastMkline.Line.Errorf("Directive indentation is not 0, but %d.", mklines.indentDepth())
+	}
 	SaveAutofixChanges(mklines.lines)
+}
 func (mklines *MkLines) determineDefinedVariables() {
 	for _, mkline := range mklines.mklines {
 		if !mkline.IsVarassign() {
 			continue
+		}
 		varcanon := mkline.Varcanon()
 		switch varcanon {
 @@ -213,59 +213,59 @@ func (mklines *MkLines) DetermineUsedVar
 		varnames := mkline.determineUsedVariables()
 		for _, varname := range varnames {
 			mklines.UseVar(mkline, varname)
+		}
+	}
+}
 func (mklines *MkLines) checklineCond(mkline *MkLine) {
 	indent, directive, args := mkline.Indent(), mkline.Directive(), mkline.Args()
 	switch directive {
 	case "endif", "endfor", "elif", "else":
 		if len(mklines.indentation) > 1 {
-			mklines.PopIndent()
+			mklines.popIndent()
 		} else {
 			mkline.Error1("Unmatched .%s.", directive)
+		}
+	}
 	// Check the indentation
-	if expected := strings.Repeat(" ", mklines.IndentDepth()); indent != expected {
+	if expected := strings.Repeat(" ", mklines.indentDepth()); indent != expected {
 		if G.opts.WarnSpace && !mkline.Line.AutofixReplace("."+indent, "."+expected) {
-			mkline.Line.Notef("This directive should be indented by %d spaces.", mklines.IndentDepth())
+			mkline.Line.Notef("This directive should be indented by %d spaces.", mklines.indentDepth())
+		}
+	}
 	if directive == "if" && matches(args, `^!defined\([\w]+_MK\)$`) {
-		mklines.PushIndent(mklines.IndentDepth())
+		mklines.pushIndent(mklines.indentDepth())
 	} else if matches(directive, `^(?:if|ifdef|ifndef|for|elif|else)$`) {
-		mklines.PushIndent(mklines.IndentDepth() + 2)
+		mklines.pushIndent(mklines.indentDepth() + 2)
+	}
 	reDirectivesWithArgs := `^(?:if|ifdef|ifndef|elif|for|undef)$`
 	if matches(directive, reDirectivesWithArgs) && args == "" {
 		mkline.Error1("\".%s\" requires arguments.", directive)
 	} else if !matches(directive, reDirectivesWithArgs) && args != "" {
 		mkline.Error1("\".%s\" does not take arguments.", directive)
 		if directive == "else" {
 			mkline.Note0("If you meant \"else if\", use \".elif\".")
+		}
 	} else if directive == "if" || directive == "elif" {
-		mkline.CheckIf()
+		mkline.CheckCond()
 	} else if directive == "ifdef" || directive == "ifndef" {
 		if matches(args, `\s`) {
 			mkline.Error1("The \".%s\" directive can only handle _one_ argument.", directive)
 		} else {
 			mkline.Line.Warnf("The \".%s\" directive is deprecated. Please use \".if %sdefined(%s)\" instead.",
 				directive, ifelseStr(directive == "ifdef", "", "!"), args)
+		}
 	} else if directive == "for" {
 		if m, vars, values := match2(args, `^(\S+(?:\s*\S+)*?)\s+in\s+(.*)$`); m {
 			for _, forvar := range splitOnSpace(vars) {
 				if !G.Infrastructure && hasPrefix(forvar, "_") {

 @@ -128,13 +128,90 @@ func (s *Suite) TestParser_MkTokens(c *c
 	token("${${XKBBASE}/xkbcomp:L:Q}", varuse("${XKBBASE}/xkbcomp", "L", "Q"))
 	token("${${PKGBASE} ${PKGVERSION}:L}", varuse("${PKGBASE} ${PKGVERSION}", "L"))
 	token("${empty(CFLAGS):?:-cflags ${CFLAGS:Q}}", varuse("empty(CFLAGS)", "?:-cflags ${CFLAGS:Q}"))
 	token("${${${PKG_INFO} -E ${d} || echo:L:sh}:L:C/[^[0-9]]*/ /g:[1..3]:ts.}",
 		varuse("${${PKG_INFO} -E ${d} || echo:L:sh}", "L", "C/[^[0-9]]*/ /g", "[1..3]", "ts."))
 	token("${VAR:S/-//S/.//}", varuse("VAR", "S/-//", "S/.//")) // For :S and :C, the colon can be left out.
 	token("${VAR:ts}", varuse("VAR", "ts"))                     // The separator character can be left out.
 	token("${VAR:ts\\000012}", varuse("VAR", "ts\\000012"))     // The separator character can be a long octal number.
 	token("${VAR:ts\\124}", varuse("VAR", "ts\\124"))           // Or even decimal.
 	parse("${VAR)", nil, "${VAR)") // Opening brace, closing parenthesis
 	parse("$(VAR}", nil, "$(VAR}") // Opening parenthesis, closing brace
+}
 func (s *Suite) TestParser_MkCond_Basics(c *check.C) {
 	condrest := func(input string, expectedTree *Tree, expectedRest string) {
 		p := NewParser(input)
 		actualTree := p.MkCond()
 		c.Check(actualTree, deepEquals, expectedTree)
 		c.Check(p.Rest(), equals, expectedRest)
+	}
 	cond := func(input string, expectedTree *Tree) {
 		condrest(input, expectedTree, "")
+	}
 	literal := func(literal string) MkToken {
 		return MkToken{literal: literal}
+	}
 	varuse := func(varname string, modifiers ...string) MkVarUse {
 		return MkVarUse{varname: varname, modifiers: modifiers}
+	}
 	_, _ = literal, varuse
 	cond("${OPSYS:MNetBSD}",
 		NewTree("not", NewTree("empty", varuse("OPSYS", "MNetBSD"))))
 	cond("defined(VARNAME)",
 		NewTree("defined", "VARNAME"))
 	cond("empty(VARNAME)",
 		NewTree("empty", varuse("VARNAME")))
 	cond("!empty(VARNAME)",
 		NewTree("not", NewTree("empty", varuse("VARNAME"))))
 	cond("!empty(VARNAME:M[yY][eE][sS])",
 		NewTree("not", NewTree("empty", varuse("VARNAME", "M[yY][eE][sS]"))))
 	cond("${VARNAME} != \"Value\"",
 		NewTree("compareVarStr", varuse("VARNAME"), "!=", "Value"))
 	cond("${VARNAME:Mi386} != \"Value\"",
 		NewTree("compareVarStr", varuse("VARNAME", "Mi386"), "!=", "Value"))
 	cond("${VARNAME} != Value",
 		NewTree("compareVarStr", varuse("VARNAME"), "!=", "Value"))
 	cond("\"${VARNAME}\" != Value",
 		NewTree("compareVarStr", varuse("VARNAME"), "!=", "Value"))
 	cond("(defined(VARNAME))",
 		NewTree("defined", "VARNAME"))
 	cond("exists(/etc/hosts)",
 		NewTree("exists", "/etc/hosts"))
 	cond("exists(${PREFIX}/var)",
 		NewTree("exists", "${PREFIX}/var"))
 	cond("${OPSYS} == \"NetBSD\" || ${OPSYS} == \"OpenBSD\"",
 		NewTree("or",
 			NewTree("compareVarStr", varuse("OPSYS"), "==", "NetBSD"),
 			NewTree("compareVarStr", varuse("OPSYS"), "==", "OpenBSD")))
 	cond("${OPSYS} == \"NetBSD\" && ${MACHINE_ARCH} == \"i386\"",
 		NewTree("and",
 			NewTree("compareVarStr", varuse("OPSYS"), "==", "NetBSD"),
 			NewTree("compareVarStr", varuse("MACHINE_ARCH"), "==", "i386")))
 	cond("defined(A) && defined(B) || defined(C) && defined(D)",
 		NewTree("or",
 			NewTree("and",
 				NewTree("defined", "A"),
 				NewTree("defined", "B")),
 			NewTree("and",
 				NewTree("defined", "C"),
 				NewTree("defined", "D"))))
 	// Exotic cases
 	cond("0",
 		NewTree("literalNum", "0"))
 	cond("! ( defined(A)  && empty(VARNAME) )",
 		NewTree("not", NewTree("and", NewTree("defined", "A"), NewTree("empty", varuse("VARNAME")))))
 	cond("${REQD_MAJOR} > ${MAJOR}",
 		NewTree("compareVarVar", varuse("REQD_MAJOR"), ">", varuse("MAJOR")))
 	cond("${OS_VERSION} >= 6.5",
 		NewTree("compareVarNum", varuse("OS_VERSION"), ">=", "6.5"))
 	cond("${OS_VERSION} == 5.3",
 		NewTree("compareVarNum", varuse("OS_VERSION"), "==", "5.3"))
 	// Errors
 	condrest("!empty(PKG_OPTIONS:Msndfile) || defined(PKG_OPTIONS:Msamplerate)",
 		NewTree("not", NewTree("empty", varuse("PKG_OPTIONS", "Msndfile"))),
 		" || defined(PKG_OPTIONS:Msamplerate)")
+}

 @@ -19,27 +19,27 @@ import (
 func (gd *GlobalData) InitVartypes() {
 	usr("ALLOW_VULNERABLE_PACKAGES", lkNone, CheckvarYes)
 	usr("MANINSTALL", lkShell, enum("maninstall catinstall"))
 	usr("MANZ", lkNone, CheckvarYes)
 	usr("GZIP", lkShell, CheckvarShellWord)
 	usr("MKCRYPTO", lkNone, CheckvarYesNo)
 	usr("OBJHOSTNAME", lkNone, CheckvarYes)
 	usr("OBJMACHINE", lkNone, CheckvarYes)
 	usr("PKG_SUFX", lkNone, CheckvarFilename)
 	usr("PKGSRC_LOCKTYPE", lkNone, enum("none sleep once"))
 	usr("PKGSRC_SLEEPSECS", lkNone, CheckvarInteger)
 	usr("USETBL", lkNone, CheckvarYes)
 	usr("ABI", lkNone, enum("32 64"))
-	usr("PKG_DEVELOPER", lkNone, CheckvarYes)
+	usr("PKG_DEVELOPER", lkNone, CheckvarYesNo)
 	usr("USE_ABI_DEPENDS", lkNone, CheckvarYesNo)
 	usr("PKG_REGISTER_SHELLS", lkNone, enum("YES NO"))
 	usr("PKGSRC_COMPILER", lkShell, enum("ccache ccc clang distcc f2c gcc hp icc ido gcc mipspro mipspro-ucode pcc sunpro xlc"))
 	usr("PKGSRC_MESSAGE_RECIPIENTS", lkShell, CheckvarMailAddress)
 	usr("PKGSRC_SHOW_BUILD_DEFS", lkNone, CheckvarYesNo)
 	usr("PKGSRC_SHOW_PATCH_ERRORMSG", lkNone, CheckvarYesNo)
 	usr("PKGSRC_RUN_TEST", lkNone, CheckvarYesNo)
 	usr("PREFER_PKGSRC", lkShell, CheckvarIdentifier)
 	usr("PREFER_NATIVE", lkShell, CheckvarIdentifier)
 	usr("PREFER_NATIVE_PTHREADS", lkNone, CheckvarYesNo)
 	usr("LOCALBASE", lkNone, CheckvarPathname)
 	usr("CROSSBASE", lkNone, CheckvarPathname)
 	usr("VARBASE", lkNone, CheckvarPathname)
 @@ -260,31 +260,31 @@ func (gd *GlobalData) InitVartypes() {
 	sys("EMACS_LISPPREFIX", lkNone, CheckvarPathname)
 	acl("EMACS_MODULES", lkShell, CheckvarIdentifier, "Makefile, Makefile.common: set, append")
 	sys("EMACS_PKGNAME_PREFIX", lkNone, CheckvarIdentifier) // Or the empty string.
 	sys("EMACS_TYPE", lkNone, enum("emacs xemacs"))
 	acl("EMACS_USE_LEIM", lkNone, CheckvarYes, "")
 	acl("EMACS_VERSIONS_ACCEPTED", lkShell, enum("emacs25 emacs24 emacs24nox emacs23 emacs23nox emacs22 emacs22nox emacs21 emacs21nox emacs20 xemacs215 xemacs215nox xemacs214 xemacs214nox"), "Makefile: set")
 	sys("EMACS_VERSION_MAJOR", lkNone, CheckvarInteger)
 	sys("EMACS_VERSION_MINOR", lkNone, CheckvarInteger)
 	acl("EMACS_VERSION_REQD", lkShell, enum("emacs24 emacs24nox emacs23 emacs23nox emacs22 emacs22nox emacs21 emacs21nox emacs20 xemacs215 xemacs214"), "Makefile: set, append")
 	sys("EMULDIR", lkNone, CheckvarPathname)
 	sys("EMULSUBDIR", lkNone, CheckvarPathname)
 	sys("OPSYS_EMULDIR", lkNone, CheckvarPathname)
 	sys("EMULSUBDIRSLASH", lkNone, CheckvarPathname)
-	sys("EMUL_ARCH", lkNone, enum("i386 none x86_64"))
+	sys("EMUL_ARCH", lkNone, enum("arm i386 m68k none ns32k sparc vax x86_64"))
 	sys("EMUL_DISTRO", lkNone, CheckvarIdentifier)
 	sys("EMUL_IS_NATIVE", lkNone, CheckvarYes)
 	pkg("EMUL_MODULES.*", lkShell, CheckvarIdentifier)
-	sys("EMUL_OPSYS", lkNone, enum("freebsd hpux irix linux osf1 solaris sunos none"))
+	sys("EMUL_OPSYS", lkNone, enum("darwin freebsd hpux irix linux osf1 solaris sunos none"))
 	pkg("EMUL_PKG_FMT", lkNone, enum("plain rpm"))
 	usr("EMUL_PLATFORM", lkNone, CheckvarEmulPlatform)
 	pkg("EMUL_PLATFORMS", lkShell, CheckvarEmulPlatform)
 	usr("EMUL_PREFER", lkShell, CheckvarEmulPlatform)
 	pkg("EMUL_REQD", lkSpace, CheckvarDependency)
 	usr("EMUL_TYPE.*", lkNone, enum("native builtin suse suse-9.1 suse-9.x suse-10.0 suse-10.x"))
 	sys("ERROR_CAT", lkNone, CheckvarShellCommand)
 	sys("ERROR_MSG", lkNone, CheckvarShellCommand)
 	acl("EVAL_PREFIX", lkSpace, CheckvarShellWord, "Makefile, Makefile.common: append") // XXX: Combining ShellWord with lkSpace looks weird.
 	sys("EXPORT_SYMBOLS_LDFLAGS", lkShell, CheckvarLdFlag)
 	sys("EXTRACT_CMD", lkNone, CheckvarShellCommand)
 	pkg("EXTRACT_DIR", lkNone, CheckvarPathname)
 	pkglist("EXTRACT_ELEMENTS", lkShell, CheckvarPathmask)
 @@ -527,27 +527,27 @@ func (gd *GlobalData) InitVartypes() {
 	cmdline("PKG_DEBUG_LEVEL", lkNone, CheckvarInteger)
 	usr("PKG_DEFAULT_OPTIONS", lkShell, CheckvarOption)
 	sys("PKG_DELETE", lkNone, CheckvarShellCommand)
 	acl("PKG_DESTDIR_SUPPORT", lkShell, enum("destdir user-destdir"), "Makefile, Makefile.common: set")
 	pkglist("PKG_FAIL_REASON", lkShell, CheckvarShellWord)
 	acl("PKG_GECOS.*", lkNone, CheckvarMessage, "Makefile: set")
 	acl("PKG_GID.*", lkNone, CheckvarInteger, "Makefile: set")
 	acl("PKG_GROUPS", lkShell, CheckvarShellWord, "Makefile: set, append")
 	pkglist("PKG_GROUPS_VARS", lkShell, CheckvarVarname)
 	acl("PKG_HOME.*", lkNone, CheckvarPathname, "Makefile: set")
 	acl("PKG_HACKS", lkShell, CheckvarIdentifier, "hacks.mk: append")
 	sys("PKG_INFO", lkNone, CheckvarShellCommand)
 	sys("PKG_JAVA_HOME", lkNone, CheckvarPathname)
-	jvms := enum("blackdown-jdk13 jdk jdk14 kaffe run-jdk13 sun-jdk14 sun-jdk15 sun-jdk6 openjdk7 openjdk7-bin sun-jdk7")
+	jvms := enum("blackdown-jdk13 jdk jdk14 kaffe run-jdk13 sun-jdk14 sun-jdk15 sun-jdk6 openjdk7 openjdk7-bin sun-jdk7 openjdk8 oracle-jdk8")
 	sys("PKG_JVM", lkNone, jvms)
 	acl("PKG_JVMS_ACCEPTED", lkShell, jvms, "Makefile: set; Makefile.common: default, set")
 	usr("PKG_JVM_DEFAULT", lkNone, jvms)
 	acl("PKG_LEGACY_OPTIONS", lkShell, CheckvarOption, "")
 	acl("PKG_LIBTOOL", lkNone, CheckvarPathname, "Makefile: set")
 	acl("PKG_OPTIONS", lkSpace, CheckvarOption, "bsd.options.mk: set; *: use-loadtime, use")
 	usr("PKG_OPTIONS.*", lkSpace, CheckvarOption)
 	acl("PKG_OPTIONS_DEPRECATED_WARNINGS", lkShell, CheckvarShellWord, "")
 	acl("PKG_OPTIONS_GROUP.*", lkSpace, CheckvarOption, "options.mk: set; Makefile: set")
 	acl("PKG_OPTIONS_LEGACY_OPTS", lkSpace, CheckvarUnchecked, "Makefile, Makefile.common: append; options.mk: append")
 	acl("PKG_OPTIONS_LEGACY_VARS", lkSpace, CheckvarUnchecked, "Makefile, Makefile.common: append; options.mk: append")
 	acl("PKG_OPTIONS_NONEMPTY_SETS", lkSpace, CheckvarIdentifier, "")
 	acl("PKG_OPTIONS_OPTIONAL_GROUPS", lkSpace, CheckvarIdentifier, "options.mk: set, append")
 @@ -577,27 +577,27 @@ func (gd *GlobalData) InitVartypes() {
 	acl("PLIST_TYPE", lkNone, enum("dynamic static"), "")
 	acl("PREPEND_PATH", lkShell, CheckvarPathname, "")
 	acl("PREFIX", lkNone, CheckvarPathname, "*: use")
 	acl("PREV_PKGPATH", lkNone, CheckvarPathname, "*: use") // doesn't exist any longer
 	acl("PRINT_PLIST_AWK", lkNone, CheckvarAwkCommand, "*: append")
 	acl("PRIVILEGED_STAGES", lkShell, enum("install package clean"), "")
 	acl("PTHREAD_AUTO_VARS", lkNone, CheckvarYesNo, "Makefile: set")
 	sys("PTHREAD_CFLAGS", lkShell, CheckvarCFlag)
 	sys("PTHREAD_LDFLAGS", lkShell, CheckvarLdFlag)
 	sys("PTHREAD_LIBS", lkShell, CheckvarLdFlag)
 	acl("PTHREAD_OPTS", lkShell, enum("native optional require"), "Makefile: set, append; Makefile.common: append; buildlink3.mk: append")
 	sys("PTHREAD_TYPE", lkNone, CheckvarIdentifier) // Or "native" or "none".
 	pkg("PY_PATCHPLIST", lkNone, CheckvarYes)
-	acl("PYPKGPREFIX", lkNone, enum("py27 py33 py34"), "pyversion.mk: set; *: use-loadtime, use")
+	acl("PYPKGPREFIX", lkNone, enum("py27 py33 py34 py35"), "pyversion.mk: set; *: use-loadtime, use")
 	pkg("PYTHON_FOR_BUILD_ONLY", lkNone, CheckvarYes)
 	pkglist("REPLACE_PYTHON", lkShell, CheckvarPathmask)
 	pkg("PYTHON_VERSIONS_ACCEPTED", lkShell, CheckvarVersion)
 	pkg("PYTHON_VERSIONS_INCOMPATIBLE", lkShell, CheckvarVersion)
 	usr("PYTHON_VERSION_DEFAULT", lkNone, CheckvarVersion)
 	usr("PYTHON_VERSION_REQD", lkNone, CheckvarVersion)
 	pkglist("PYTHON_VERSIONED_DEPENDENCIES", lkShell, CheckvarPythonDependency)
 	sys("RANLIB", lkNone, CheckvarShellCommand)
 	pkglist("RCD_SCRIPTS", lkShell, CheckvarFilename)
 	acl("RCD_SCRIPT_SRC.*", lkShell, CheckvarPathname, "Makefile: set")
 	acl("REPLACE.*", lkNone, CheckvarString, "Makefile: set")
 	pkglist("REPLACE_AWK", lkShell, CheckvarPathmask)
 	pkglist("REPLACE_BASH", lkShell, CheckvarPathmask)
 @@ -660,26 +660,27 @@ func (gd *GlobalData) InitVartypes() {
 	sys("TOOLS_PATH.*", lkNone, CheckvarPathname)
 	sys("TOOLS_PLATFORM.*", lkNone, CheckvarShellCommand)
 	sys("TOUCH_FLAGS", lkShell, CheckvarShellWord)
 	pkglist("UAC_REQD_EXECS", lkShell, CheckvarPrefixPathname)
 	acl("UNLIMIT_RESOURCES", lkShell, enum("datasize stacksize memorysize"), "Makefile: set, append; Makefile.common: append")
 	usr("UNPRIVILEGED_USER", lkNone, CheckvarUserGroupName)
 	usr("UNPRIVILEGED_GROUP", lkNone, CheckvarUserGroupName)
 	pkglist("UNWRAP_FILES", lkShell, CheckvarPathmask)
 	usr("UPDATE_TARGET", lkShell, CheckvarIdentifier)
 	pkg("USE_BSD_MAKEFILE", lkNone, CheckvarYes)
 	acl("USE_BUILTIN.*", lkNone, CheckvarYesNoIndirectly, "builtin.mk: set")
 	pkg("USE_CMAKE", lkNone, CheckvarYes)
 	acl("USE_CROSSBASE", lkNone, CheckvarYes, "Makefile: set")
 	usr("USE_DESTDIR", lkNone, CheckvarYes)
 	pkg("USE_FEATURES", lkShell, CheckvarIdentifier)
 	pkg("USE_GCC_RUNTIME", lkNone, CheckvarYesNo)
 	pkg("USE_GNU_CONFIGURE_HOST", lkNone, CheckvarYesNo)
 	acl("USE_GNU_ICONV", lkNone, CheckvarYes, "Makefile, Makefile.common: set; options.mk: set")
 	acl("USE_IMAKE", lkNone, CheckvarYes, "Makefile: set")
 	pkg("USE_JAVA", lkNone, enum("run yes build"))
 	pkg("USE_JAVA2", lkNone, enum("YES yes no 1.4 1.5 6 7 8"))
 	acl("USE_LANGUAGES", lkShell, enum("ada c c99 c++ fortran fortran77 java objc"), "Makefile, Makefile.common, options.mk: set")
 	pkg("USE_LIBTOOL", lkNone, CheckvarYes)
 	pkg("USE_MAKEINFO", lkNone, CheckvarYes)
 	pkg("USE_MSGFMT_PLURALS", lkNone, CheckvarYes)
 	pkg("USE_NCURSES", lkNone, CheckvarYes)
 	pkg("USE_OLD_DES_API", lkNone, CheckvarYesNo)
 @@ -695,29 +696,46 @@ func (gd *GlobalData) InitVartypes() {
 	sys("WRKDIR", lkNone, CheckvarPathname)
 	pkg("WRKSRC", lkNone, CheckvarWrkdirSubdirectory)
 	sys("X11_PKGSRCDIR.*", lkNone, CheckvarPathname)
 	usr("XAW_TYPE", lkNone, enum("3d neXtaw standard xpm"))
 	acl("XMKMF_FLAGS", lkShell, CheckvarShellWord, "")
+}
 func enum(values string) *VarChecker {
 	vmap := make(map[string]bool)
 	for _, value := range splitOnSpace(values) {
 		vmap[value] = true
+	}
 	name := "enum: " + values + " " // See IsEnum
-	return &VarChecker{name, func(ctx *VartypeCheck) {
+	return &VarChecker{name, func(cv *VartypeCheck) {
-		if !vmap[ctx.value] {
+		if cv.op == opUseMatch {
-			ctx.line.Warnf("%q is not valid for %s. Use one of { %s } instead.", ctx.value, ctx.varname, values)
+			if !vmap[cv.value] && cv.value == cv.valueNovar {
 				canMatch := false
 				for value := range vmap {
 					if ok, err := path.Match(cv.value, value); err != nil {
 						cv.line.Warnf("Invalid match pattern %q.", cv.value)
 					} else if ok {
 						canMatch = true
+					}
+				}
 				if !canMatch {
 					cv.line.Warnf("The pattern %q cannot match any of { %s } for %s.", cv.value, values, cv.varname)
+				}
+			}
 			return
+		}
 		if !vmap[cv.value] {
 			cv.line.Warnf("%q is not valid for %s. Use one of { %s } instead.", cv.value, cv.varname, values)
+		}
 	}}
+}
 func acl(varname string, kindOfList KindOfList, checker *VarChecker, aclentries string) {
 	m := mustMatch(varname, `^([A-Z_.][A-Z0-9_]*)(|\*|\.\*)$`)
 	varbase, varparam := m[1], m[2]
 	vtype := &Vartype{kindOfList, checker, parseAclEntries(varname, aclentries), false}
 	if G.globalData.vartypes == nil {
 		G.globalData.vartypes = make(map[string]*Vartype)
+	}

 @@ -15,48 +15,49 @@ type VartypeCheck struct {
 	comment     string
 	listContext bool
 	guessed     bool // Whether the type definition is guessed (based on the variable name) or explicitly defined (see vardefs.go).
+}
 type MkOperator uint8
 const (
 	opAssign        MkOperator = iota // =
 	opAssignShell                     // !=
 	opAssignEval                      // :=
 	opAssignAppend                    // +=
 	opAssignDefault                   // ?=
-	opUseLoadtime
+	opUse                             //
-	opUse
+	opUseLoadtime                     //
 	opUseMatch                        // Used in the :M operator
+)
 func NewMkOperator(op string) MkOperator {
 	switch op {
 	case "=":
 		return opAssign
 	case "!=":
 		return opAssignShell
 	case ":=":
 		return opAssignEval
 	case "+=":
 		return opAssignAppend
 	case "?=":
 		return opAssignDefault
+	}
 	return opAssign
+}
 func (op MkOperator) String() string {
-	return [...]string{"=", "!=", ":=", "+=", "?=", "use", "use-loadtime"}[op]
+	return [...]string{"=", "!=", ":=", "+=", "?=", "use", "use-loadtime", "use-match"}[op]
+}
 func (cv *VartypeCheck) AwkCommand() {
 	if G.opts.DebugUnchecked {
 		cv.line.Debug1("Unchecked AWK command: %q", cv.value)
+	}
+}
 func (cv *VartypeCheck) BasicRegularExpression() {
 	if G.opts.DebugUnchecked {
 		cv.line.Debug1("Unchecked basic regular expression: %q", cv.value)
+	}
+}
 @@ -81,26 +82,29 @@ func (cv *VartypeCheck) Category() {
 		"packages", "perl5", "plan9", "python",
 		"ruby",
 		"scm",
 		"tcl", "tk",
 		"windowmaker",
 		"xmms":
 	default:
 		cv.line.Error1("Invalid category %q.", cv.value)
+	}
+}
 // A single option to the C/C++ compiler.
 func (cv *VartypeCheck) CFlag() {
 	if cv.op == opUseMatch {
 		return
+	}
 	cflag := cv.value
 	switch {
 	case matches(cflag, `^-[DILOUWfgm]`),
 		hasPrefix(cflag, "-std="),
 		cflag == "-c99",
 		cflag == "-c",
 		cflag == "-no-integrated-as",
 		cflag == "-pthread",
 		hasPrefix(cflag, "`") && hasSuffix(cflag, "`"),
 		containsVarRef(cflag):
 		return
 	case hasPrefix(cflag, "-"):
 		cv.line.Warn1("Unknown compiler flag %q.", cflag)
 @@ -281,71 +285,85 @@ func (cv *VartypeCheck) FetchURL() {
 		if !G.globalData.MasterSiteVars[name] {
 			cv.line.Error1("%s does not exist.", name)
+		}
 		if !hasSuffix(subdir, "/") {
 			cv.line.Error1("The subdirectory in %s must end with a slash.", name)
+		}
+	}
+}
 // See Pathname
 // See http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap03.html#tag_03_169
 func (cv *VartypeCheck) Filename() {
 	switch {
 	case cv.op == opUseMatch:
 		break
 	case contains(cv.valueNovar, "/"):
 		cv.line.Warn0("A filename should not contain a slash.")
 	case !matches(cv.valueNovar, `^[-0-9@A-Za-z.,_~+%]*$`):
 		cv.line.Warn1("%q is not a valid filename.", cv.value)
+	}
+}
 func (cv *VartypeCheck) Filemask() {
 	if cv.op == opUseMatch {
 		return
+	}
 	if !matches(cv.valueNovar, `^[-0-9A-Za-z._~+%*?]*$`) {
 		cv.line.Warn1("%q is not a valid filename mask.", cv.value)
+	}
+}
 func (cv *VartypeCheck) FileMode() {
 	switch {
 	case cv.value != "" && cv.valueNovar == "":
 		// Fine.
 	case matches(cv.value, `^[0-7]{3,4}`):
 		// Fine.
 	default:
 		cv.line.Warn1("Invalid file mode %q.", cv.value)
+	}
+}
 func (cv *VartypeCheck) Identifier() {
 	if cv.op == opUseMatch {
 		if cv.value == cv.valueNovar && !matches(cv.value, `^[\w*?]`) {
 			cv.line.Warn2("Invalid identifier pattern %q for %s.", cv.value, cv.varname)
+		}
 		return
+	}
 	if cv.value != cv.valueNovar {
 		//line.logWarning("Identifiers should be given directly.")
+	}
 	switch {
 	case matches(cv.valueNovar, `^[+\-.0-9A-Z_a-z]+$`):
 		// Fine.
 	case cv.value != "" && cv.valueNovar == "":
 		// Don't warn here.
 	default:
 		cv.line.Warn1("Invalid identifier %q.", cv.value)
+	}
+}
 func (cv *VartypeCheck) Integer() {
 	if !matches(cv.value, `^\d+$`) {
 		cv.line.Warn1("Invalid integer %q.", cv.value)
+	}
+}
 func (cv *VartypeCheck) LdFlag() {
 	if cv.op == opUseMatch {
 		return
+	}
 	ldflag := cv.value
 	if m, rpathFlag := match1(ldflag, `^(-Wl,(?:-R|-rpath|--rpath))`); m {
 		cv.line.Warn1("Please use \"${COMPILER_RPATH_FLAG}\" instead of %q.", rpathFlag)
 		return
+	}
 	switch {
 	case hasPrefix(ldflag, "-L"),
 		hasPrefix(ldflag, "-l"),
 		ldflag == "-pthread",
 		ldflag == "-static",
 		hasPrefix(ldflag, "-static-"),
 		hasPrefix(ldflag, "-Wl,-"),
 @@ -442,49 +460,55 @@ func (cv *VartypeCheck) Pathlist() {
 		if !matches(path, `^[-0-9A-Za-z._~+%/]*$`) {
 			cv.line.Warn1("%q is not a valid pathname.", path)
+		}
 		if !hasPrefix(path, "/") {
 			cv.line.Warn2("All components of %s (in this case %q) should be absolute paths.", cv.varname, path)
+		}
+	}
+}
 // Shell globbing including slashes.
 // See Filemask
 func (cv *VartypeCheck) Pathmask() {
 	if cv.op == opUseMatch {
 		return
+	}
 	if !matches(cv.valueNovar, `^[#\-0-9A-Za-z._~+%*?/\[\]]*`) {
 		cv.line.Warn1("%q is not a valid pathname mask.", cv.value)
+	}
 	cv.line.CheckAbsolutePathname(cv.value)
+}
 // Like Filename, but including slashes
 // See http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap03.html#tag_03_266
 func (cv *VartypeCheck) Pathname() {
 	if cv.op == opUseMatch {
 		return
+	}
 	if !matches(cv.valueNovar, `^[#\-0-9A-Za-z._~+%/]*$`) {
 		cv.line.Warn1("%q is not a valid pathname.", cv.value)
+	}
 	cv.line.CheckAbsolutePathname(cv.value)
+}
 func (cv *VartypeCheck) Perl5Packlist() {
 	if cv.value != cv.valueNovar {
 		cv.line.Warn1("%s should not depend on other variables.", cv.varname)
+	}
+}
 func (cv *VartypeCheck) PkgName() {
-	if cv.value == cv.valueNovar && !matches(cv.value, rePkgname) {
+	if cv.op != opUseMatch && cv.value == cv.valueNovar && !matches(cv.value, rePkgname) {
 		cv.line.Warn1("%q is not a valid package name. A valid package name has the form packagename-version, where version consists only of digits, letters and dots.", cv.value)
+	}
+}
 func (cv *VartypeCheck) PkgOptionsVar() {
 	cv.mkline.CheckVartypePrimitive(cv.varname, CheckvarVarname, cv.op, cv.value, cv.comment, false, cv.guessed)
 	if matches(cv.value, `\$\{PKGBASE[:\}]`) {
 		cv.line.Error0("PKGBASE must not be used in PKG_OPTIONS_VAR.")
 		Explain3(
 			"PKGBASE is defined in bsd.pkg.mk, which is included as the",
 			"very last file, but PKG_OPTIONS_VAR is evaluated earlier.",
 			"Use ${PKGNAME:C/-[0-9].*//} instead.")
+	}
 @@ -632,26 +656,29 @@ func (cv *VartypeCheck) SedCommands() {
 		case token == "-n":
 			// Don't print lines per default.
 		case i == 0 && matches(token, `^(["']?)(?:\d*|/.*/)s.+["']?$`):
 			line.Note0("Please always use \"-e\" in sed commands, even if there is only one substitution.")
 		default:
 			line.Warn1("Unknown sed command %q.", token)
+		}
+	}
+}
 func (cv *VartypeCheck) ShellCommand() {
 	if cv.op == opUseMatch {
 		return
+	}
 	setE := true
 	NewShellLine(cv.mkline).CheckShellCommand(cv.value, &setE)
+}
 // Zero or more shell commands, each terminated with a semicolon.
 func (cv *VartypeCheck) ShellCommands() {
 	NewShellLine(cv.mkline).CheckShellCommands(cv.value)
+}
 func (cv *VartypeCheck) ShellWord() {
 	if !cv.listContext {
 		NewShellLine(cv.mkline).CheckToken(cv.value, true)
+	}
 @@ -670,27 +697,27 @@ func (cv *VartypeCheck) String() {
 func (cv *VartypeCheck) Tool() {
 	if cv.varname == "TOOLS_NOOP" && cv.op == opAssignAppend {
 		// no warning for package-defined tool definitions
 	} else if m, toolname, tooldep := match2(cv.value, `^([-\w]+|\[)(?::(\w+))?$`); m {
 		if !G.globalData.Tools[toolname] {
 			cv.line.Error1("Unknown tool %q.", toolname)
+		}
 		switch tooldep {
 		case "", "bootstrap", "build", "pkgsrc", "run":
 		default:
 			cv.line.Error1("Unknown tool dependency %q. Use one of \"build\", \"pkgsrc\" or \"run\".", tooldep)
+		}
-	} else {
+	} else if cv.op != opUseMatch {
 		cv.line.Error1("Invalid tool syntax: %q.", cv.value)
+	}
+}
 func (cv *VartypeCheck) Unchecked() {
 	// Do nothing, as the name says.
+}
 func (cv *VartypeCheck) URL() {
 	line, value := cv.line, cv.value
 	if value == "" && hasPrefix(cv.comment, "#") {
 		// Ok
 @@ -731,27 +758,31 @@ func (cv *VartypeCheck) Varname() {
 		cv.line.Warn1("%q is not a valid variable name.", cv.value)
 		Explain(
 			"Variable names are restricted to only uppercase letters and the",
 			"underscore in the basename, and arbitrary characters in the",
 			"parameterized part, following the dot.",
 			"",
 			"Examples:",
 			"\t* PKGNAME",
 			"\t* PKG_OPTIONS.gnuchess")
+	}
+}
 func (cv *VartypeCheck) Version() {
-	if !matches(cv.value, `^([\d.])+$`) {
+	if cv.op == opUseMatch {
 		if !matches(cv.value, `^[\d?\[][\w\-.*?\[\]]+$`) {
 			cv.line.Warn1("Invalid version number pattern %q.", cv.value)
+		}
 	} else if cv.value == cv.valueNovar && !matches(cv.value, `^\d[\w.]+$`) {
 		cv.line.Warn1("Invalid version number %q.", cv.value)
+	}
+}
 func (cv *VartypeCheck) WrapperReorder() {
 	if !matches(cv.value, `^reorder:l:([\w\-]+):([\w\-]+)$`) {
 		cv.line.Warn1("Unknown wrapper reorder command %q.", cv.value)
+	}
+}
 func (cv *VartypeCheck) WrapperTransform() {
 	cmd := cv.value
 	if hasPrefix(cmd, "rm:-") ||
 @@ -776,41 +807,57 @@ func (cv *VartypeCheck) WrksrcSubdirecto
+		}
 		cv.line.Note2("You can use %q instead of %q.", rest, cv.value)
 		Explain1(
 			"These directories are interpreted relative to ${WRKSRC}.")
 	} else if cv.value != "" && cv.valueNovar == "" {
 		// The value of another variable
 	} else if !matches(cv.valueNovar, `^(?:\.|[0-9A-Za-z_@][-0-9A-Za-z_@./+]*)$`) {
 		cv.line.Warn1("%q is not a valid subdirectory of ${WRKSRC}.", cv.value)
+	}
+}
 // Used for variables that are checked using `.if defined(VAR)`.
 func (cv *VartypeCheck) Yes() {
-	if !matches(cv.value, `^(?:YES|yes)(?:\s+#.*)?$`) {
+	switch cv.op {
-		cv.line.Warn1("%s should be set to YES or yes.", cv.varname)
+	case opUseMatch:
-		Explain4(
+		cv.line.Warn1("%s should only be used in a \".if defined(...)\" conditional.", cv.varname)
-			"This variable means \"yes\" if it is defined, and \"no\" if it is",
+		Explain(
-			"undefined.  Even when it has the value \"no\", this means \"yes\".",
+			"This variable can have only two values: defined or undefined.",
-			"Therefore when it is defined, its value should correspond to its",
+			"When it is defined, it means \"yes\", even when its value is",
-			"meaning.")
+			"\"no\" or the empty string.",
 			"",
 			"Therefore, it should not be checked by comparing its value",
 			"but using \".if defined(VARNAME)\" alone.")
 	default:
 		if !matches(cv.value, `^(?:YES|yes)(?:\s+#.*)?$`) {
 			cv.line.Warn1("%s should be set to YES or yes.", cv.varname)
 			Explain4(
 				"This variable means \"yes\" if it is defined, and \"no\" if it is",
 				"undefined.  Even when it has the value \"no\", this means \"yes\".",
 				"Therefore when it is defined, its value should correspond to its",
 				"meaning.")
+		}
+	}
+}
 // The type YesNo is used for variables that are checked using
 //     .if defined(VAR) && !empty(VAR:M[Yy][Ee][Ss])
 //
 func (cv *VartypeCheck) YesNo() {
-	if !matches(cv.value, `^(?:YES|yes|NO|no)(?:\s+#.*)?$`) {
+	if cv.op == opUseMatch {
 		switch cv.value {
 		case "[yY][eE][sS]":
 		case "[Yy][Ee][Ss]":
 		case "[nN][oO]":
 		case "[Nn][Oo]":
 		default:
 			cv.line.Warnf("%s should be matched against %q or %q, not %q.", cv.varname, "[yY][eE][sS]", "[nN][oO]", cv.value)
+		}
 	} else if !matches(cv.value, `^(?:YES|yes|NO|no)(?:\s+#.*)?$`) {
 		cv.line.Warn1("%s should be set to YES, yes, NO, or no.", cv.varname)
+	}
+}
 // Like YesNo, but the value may be produced by a shell command using the
 // != operator.
 func (cv *VartypeCheck) YesNoIndirectly() {
-	if cv.valueNovar != "" && !matches(cv.value, `^(?:YES|yes|NO|no)(?:\s+#.*)?$`) {
+	if cv.valueNovar != "" {
-		cv.line.Warn1("%s should be set to YES, yes, NO, or no.", cv.varname)
+		cv.YesNo()
+	}
+}

 @@ -1,16 +1,18 @@
 package main
 import (
 	"fmt"
 	check "gopkg.in/check.v1"
+)
 func (s *Suite) TestVartypeCheck_AwkCommand(c *check.C) {
 	s.UseCommandLine(c, "-Dunchecked")
 	runVartypeChecks("PLIST_AWK", opAssignAppend, (*VartypeCheck).AwkCommand,
 		"{print $0}",
 		"{print $$0}")
 	c.Check(s.Output(), equals, ""+
 		"ERROR: fname:1: Invalid Makefile syntax at \"$0}\".\n"+
 		"DEBUG: fname:1: Unchecked AWK command: \"{print $0}\"\n"+
 		"DEBUG: fname:2: Unchecked AWK command: \"{print $$0}\"\n")
 @@ -159,26 +161,36 @@ func (s *Suite) TestVartypeCheck_DistSuf
 func (s *Suite) TestVartypeCheck_EmulPlatform(c *check.C) {
 	runVartypeChecks("EMUL_PLATFORM", opAssign, (*VartypeCheck).EmulPlatform,
 		"linux-i386",
 		"nextbsd-8087",
 		"${LINUX}")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:2: Unknown operating system: nextbsd\n"+
 		"WARN: fname:2: Unknown hardware architecture: 8087\n"+
 		"WARN: fname:3: \"${LINUX}\" is not a valid emulation platform.\n")
+}
 func (s *Suite) TestVartypeCheck_Enum(c *check.C) {
 	runVartypeMatchChecks("JDK", enum("jdk1 jdk2 jdk4").checker,
 		"*",
 		"jdk*",
 		"sun-jdk*",
 		"${JDKNAME}")
 	c.Check(s.Output(), equals, "WARN: fname:3: The pattern \"sun-jdk*\" cannot match any of { jdk1 jdk2 jdk4 } for JDK.\n")
+}
 func (s *Suite) TestVartypeCheck_FetchURL(c *check.C) {
 	G.globalData.MasterSiteUrls = map[string]string{
 		"https://github.com/":         "MASTER_SITE_GITHUB",
 		"http://ftp.gnu.org/pub/gnu/": "MASTER_SITE_GNU",
+	}
 	G.globalData.MasterSiteVars = map[string]bool{
 		"MASTER_SITE_GITHUB": true,
 		"MASTER_SITE_GNU":    true,
+	}
 	runVartypeChecks("MASTER_SITES", opAssign, (*VartypeCheck).FetchURL,
 		"https://github.com/example/project/",
 		"http://ftp.gnu.org/pub/gnu/bison", // Missing a slash at the end
 @@ -353,55 +365,78 @@ func (s *Suite) TestVartypeCheck_Varname
 	c.Check(s.Output(), equals, "WARN: fname:2: \"VarBase\" is not a valid variable name.\n")
+}
 func (s *Suite) TestVartypeCheck_Yes(c *check.C) {
 	runVartypeChecks("APACHE_MODULE", opAssign, (*VartypeCheck).Yes,
 		"yes",
 		"no",
 		"${YESVAR}")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:2: APACHE_MODULE should be set to YES or yes.\n"+
 		"WARN: fname:3: APACHE_MODULE should be set to YES or yes.\n")
 	runVartypeMatchChecks("PKG_DEVELOPER", (*VartypeCheck).Yes,
 		"yes",
 		"no",
 		"${YESVAR}")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: PKG_DEVELOPER should only be used in a \".if defined(...)\" conditional.\n"+
 		"WARN: fname:2: PKG_DEVELOPER should only be used in a \".if defined(...)\" conditional.\n"+
 		"WARN: fname:3: PKG_DEVELOPER should only be used in a \".if defined(...)\" conditional.\n")
+}
 func (s *Suite) TestVartypeCheck_YesNo(c *check.C) {
 	runVartypeChecks("GNU_CONFIGURE", opAssign, (*VartypeCheck).YesNo,
 		"yes",
 		"no",
 		"ja",
 		"${YESVAR}")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:3: GNU_CONFIGURE should be set to YES, yes, NO, or no.\n"+
 		"WARN: fname:4: GNU_CONFIGURE should be set to YES, yes, NO, or no.\n")
+}
 func (s *Suite) TestVartypeCheck_YesNoIndirectly(c *check.C) {
 	runVartypeChecks("GNU_CONFIGURE", opAssign, (*VartypeCheck).YesNoIndirectly,
 		"yes",
 		"no",
 		"ja",
 		"${YESVAR}")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:3: GNU_CONFIGURE should be set to YES, yes, NO, or no.\n")
+}
 func runVartypeChecks(varname string, op MkOperator, checker func(*VartypeCheck), values ...string) {
 	if !contains(op.String(), "=") {
 		panic("runVartypeChecks needs an assignment operator")
+	}
 	for i, value := range values {
 		mkline := NewMkLine(NewLine("fname", i+1, varname+op.String()+value, nil))
 		valueNovar := mkline.withoutMakeVariables(mkline.Value(), true)
 		vc := &VartypeCheck{mkline, mkline.Line, mkline.Varname(), mkline.Op(), mkline.Value(), valueNovar, "", true, false}
 		checker(vc)
+	}
+}
 func runVartypeMatchChecks(varname string, checker func(*VartypeCheck), values ...string) {
 	for i, value := range values {
 		text := fmt.Sprintf(".if ${%s:M%s} == \"\"", varname, value)
 		mkline := NewMkLine(NewLine("fname", i+1, text, nil))
 		valueNovar := mkline.withoutMakeVariables(value, true)
 		vc := &VartypeCheck{mkline, mkline.Line, varname, opUseMatch, value, valueNovar, "", true, false}
 		checker(vc)
+	}
+}
 func runVartypeChecksFname(fname, varname string, op MkOperator, checker func(*VartypeCheck), values ...string) {
 	for i, value := range values {
 		mkline := NewMkLine(NewLine(fname, i+1, varname+op.String()+value, nil))
 		valueNovar := mkline.withoutMakeVariables(value, true)
 		vc := &VartypeCheck{mkline, mkline.Line, varname, op, value, valueNovar, "", true, false}
 		checker(vc)
+	}
+}

 @@ -1,16 +1,16 @@
-# $NetBSD: Makefile,v 1.480 2016/01/27 21:55:50 rillig Exp $
+# $NetBSD: Makefile,v 1.481 2016/01/31 17:18:54 rillig Exp $
-PKGNAME=	pkglint-5.3.4
+PKGNAME=	pkglint-5.3.5
 DISTFILES=	# none
 CATEGORIES=	pkgtools
 OWNER=		rillig@NetBSD.org
 HOMEPAGE=	http://www.NetBSD.org/docs/pkgsrc/
 COMMENT=	Verifier for NetBSD packages
 LICENSE=	2-clause-bsd
 CONFLICTS+=	pkglint4-[0-9]*
 WRKSRC=		${WRKDIR}/netbsd.org/pkglint
 NO_CHECKSUM=	yes
 USE_LANGUAGES=	# none
 USE_TOOLS+=	pax

 @@ -1,31 +1,28 @@
-$NetBSD: TODO,v 1.83 2015/11/25 13:29:07 rillig Exp $
+$NetBSD: TODO,v 1.84 2016/01/31 17:18:54 rillig Exp $
 Please add your own entries at the bottom of this file. If possible,
 include the name of an example package where a warning should occur.
 * warn about the use of ${WRKDIR:=...}, as this construct should only
   be used with lists.
 * Add checks for binary packages. See Debian/lintian for ideas.
 * Of the user-defined variables, some may be used at load-time and some
   don't. Find out how pkglint can distinguish them.
 * Make sure that no variable is modified at load-time after it has been
   used once. This should at least flag BUILD_DEFS in bsd.pkg.mk.
 * ${MACHINE_ARCH}-${LOWER_OPSYS}elf in PLISTs etc. is a NetBSD config.guess
   problem ==> use of ${APPEND_ELF}
 * Packages including lang/python/extension.mk must follow the Python version
   scheme. Enforcing PYPKGPREFIX for those is most likely a good idea.
 * Check for parallel files/dirs whose names differ only in case.
 * If a dependency depends on an option (in options.mk), it should also
   depend on the same option in the buildlink3.mk file.
 * Complain about ${PKGSRC_COMPILER} == "sunpro", which should be
   !empty(PKGSRC_COMPILER:Msunpro).
 * If USE_TOOLS has autoconf213, and the package does stuff like
   cd ${WRKSRC} && autoconf, then an incorrect warning is issued.
 * don't complain about "procedure calls", like for pkg-build-options in
   the various buildlink3.mk files.
 * if package A conflicts with B, then B should also conflict with A.
 * When pkglint runs on a case-insensitive filesystem, it should still
   point out problems that only occur on case-sensitive filesystems. For
   example, devel/p5-Net-LDAP and devel/p5-Net-ldap should be considered
   different paths.
 * Warn about using REPLACE_PYTHON without including application.mk.

 @@ -522,15 +522,18 @@ func (gd *GlobalData) loadDeprecatedVars
 		"NO_MTREE":   "You can just remove it.",
 		// July 2012
 		"SETGIDGAME": "Use USE_GAMESGROUP instead.",
 		"GAMEGRP":    "Use GAMES_GROUP instead.",
 		"GAMEOWN":    "Use GAMES_USER instead.",
 		// July 2013
 		"USE_GNU_READLINE": "Include \"../../devel/readline/buildlink3.mk\" instead.",
 		// October 2014
 		"SVR4_PKGNAME":           "Just remove it.",
 		"PKG_INSTALLATION_TYPES": "Just remove it.",
 		// January 2016
 		"SUBST_POSTCMD.*": "Has been removed, as it seemed unused.",
+	}
+}

	@@ -673,27 +673,30 @@ func (pkg *Package) ChecklinesPackageMak		@@ -673,27 +673,30 @@ func (pkg *Package) ChecklinesPackageMak
673		673
674	default:	674	default:
675	if vars[varindex].count != many {	675	if vars[varindex].count != many {
676	below[vars[varindex].varname] = belowWhat	676	below[vars[varindex].varname] = belowWhat
677	varindex++	677	varindex++
678	}	678	}
679	lineno++	679	lineno++
680	}	680	}
681	belowWhat = varcanon	681	belowWhat = varcanon
682		682
683	default:	683	default:
684	for varindex < len(vars) {	684	for varindex < len(vars) {
685	if vars[varindex].count == once && !maySkipSection {	685	if vars[varindex].count == once && !maySkipSection {
686	line.Warn1("%s should be set here.", vars[varindex].varname)	686	line.Warn1("The canonical position for the required variable %s is here.", vars[varindex].varname)
		687	Explain(
		688	"See doc/Makefile-example or the pkgsrc guide, section",
		689	"\"Package components\", subsection \"Makefile\" for more information.")
687	}	690	}
688	below[vars[varindex].varname] = belowWhat	691	below[vars[varindex].varname] = belowWhat
689	varindex++	692	varindex++
690	}	693	}
691	nextSection = true	694	nextSection = true
692	if text == "" {	695	if text == "" {
693	belowWhat = "the previous empty line"	696	belowWhat = "the previous empty line"
694	lineno++	697	lineno++
695	}	698	}
696	}	699	}
697	}	700	}
698	}	701	}
699		702

	@@ -347,26 +347,29 @@ func (pr *PrefixReplacer) PeekByte() int		@@ -347,26 +347,29 @@ func (pr *PrefixReplacer) PeekByte() int
347	}	347	}
348	return int(rest[0])	348	return int(rest[0])
349	}	349	}
350		350
351	func (pr *PrefixReplacer) Mark() string {	351	func (pr *PrefixReplacer) Mark() string {
352	return pr.rest	352	return pr.rest
353	}	353	}
354	func (pr *PrefixReplacer) Reset(mark string) {	354	func (pr *PrefixReplacer) Reset(mark string) {
355	pr.rest = mark	355	pr.rest = mark
356	}	356	}
357	func (pr *PrefixReplacer) Skip(n int) {	357	func (pr *PrefixReplacer) Skip(n int) {
358	pr.rest = pr.rest[n:]	358	pr.rest = pr.rest[n:]
359	}	359	}
		360	func (pr *PrefixReplacer) SkipSpace() {
		361	pr.rest = strings.TrimLeft(pr.rest, " \t")
		362	}
360	func (pr *PrefixReplacer) Since(mark string) string {	363	func (pr *PrefixReplacer) Since(mark string) string {
361	return mark[:len(mark)-len(pr.rest)]	364	return mark[:len(mark)-len(pr.rest)]
362	}	365	}
363	func (pr *PrefixReplacer) AdvanceRest() string {	366	func (pr *PrefixReplacer) AdvanceRest() string {
364	rest := pr.rest	367	rest := pr.rest
365	pr.rest = ""	368	pr.rest = ""
366	return rest	369	return rest
367	}	370	}
368		371
369	func (pr *PrefixReplacer) verifyBits(bits0x00, bits0x20, bits0x40, bits0x60 uint32, re string) {	372	func (pr *PrefixReplacer) verifyBits(bits0x00, bits0x20, bits0x40, bits0x60 uint32, re string) {
370	if G.TestingData.VerifiedBits[re] {	373	if G.TestingData.VerifiedBits[re] {
371	return	374	return
372	}	375	}

 @@ -29,28 +29,28 @@ func (s *Suite) TestChecklinesPackageMak
 		"CATEGORIES=x11"))
 	c.Check(s.Output(), equals, "")
 	pkg.ChecklinesPackageMakefileVarorder(s.NewMkLines("Makefile",
 		"# $"+"NetBSD$",
 		"",
 		"DISTNAME=9term",
 		"CATEGORIES=x11",
 		"",
 		".include \"../../mk/bsd.pkg.mk\""))
 	c.Check(s.Output(), equals, ""+
-		"WARN: Makefile:6: COMMENT should be set here.\n"+
+		"WARN: Makefile:6: The canonical position for the required variable COMMENT is here.\n"+
-		"WARN: Makefile:6: LICENSE should be set here.\n")
+		"WARN: Makefile:6: The canonical position for the required variable LICENSE is here.\n")
+}
 func (s *Suite) TestGetNbpart(c *check.C) {
 	pkg := NewPackage("category/pkgbase")
 	pkg.vardef["PKGREVISION"] = NewMkLine(NewLine("Makefile", 1, "PKGREVISION=14", nil))
 	c.Check(pkg.getNbpart(), equals, "nb14")
 	pkg.vardef["PKGREVISION"] = NewMkLine(NewLine("Makefile", 1, "PKGREVISION=asdf", nil))
 	c.Check(pkg.getNbpart(), equals, "")
+}

 @@ -270,13 +270,146 @@ func (p *Parser) VarUseModifiers(closing
+			}
+		}
 		repl.Reset(modifierMark)
 		for p.VarUse() != nil || repl.AdvanceRegexp(`^([^:$`+closing+`]|\$\$)+`) {
+		}
 		if suffixSubst := repl.Since(modifierMark); contains(suffixSubst, "=") {
 			modifiers = append(modifiers, suffixSubst)
 			continue
+		}
+	}
 	return modifiers
+}
 func (p *Parser) MkCond() *Tree {
 	return p.mkCondOr()
+}
 func (p *Parser) mkCondOr() *Tree {
 	and := p.mkCondAnd()
 	if and == nil {
 		return nil
+	}
 	ands := append([]interface{}(nil), and)
 	for {
 		mark := p.repl.Mark()
 		if !p.repl.AdvanceRegexp(`^\s*\|\|\s*`) {
 			break
+		}
 		next := p.mkCondAnd()
 		if next == nil {
 			p.repl.Reset(mark)
 			break
+		}
 		ands = append(ands, next)
+	}
 	if len(ands) == 1 {
 		return and
+	}
 	return NewTree("or", ands...)
+}
 func (p *Parser) mkCondAnd() *Tree {
 	atom := p.mkCondAtom()
 	if atom == nil {
 		return nil
+	}
 	atoms := append([]interface{}(nil), atom)
 	for {
 		mark := p.repl.Mark()
 		if !p.repl.AdvanceRegexp(`^\s*&&\s*`) {
 			break
+		}
 		next := p.mkCondAtom()
 		if next == nil {
 			p.repl.Reset(mark)
 			break
+		}
 		atoms = append(atoms, next)
+	}
 	if len(atoms) == 1 {
 		return atom
+	}
 	return NewTree("and", atoms...)
+}
 func (p *Parser) mkCondAtom() *Tree {
 	if G.opts.DebugTrace {
 		defer tracecall1(p.Rest())()
+	}
 	repl := p.repl
 	mark := repl.Mark()
 	repl.SkipSpace()
 	switch {
 	case repl.AdvanceStr("!"):
 		cond := p.mkCondAtom()
 		if cond != nil {
 			return NewTree("not", cond)
+		}
 	case repl.AdvanceStr("("):
 		cond := p.MkCond()
 		if cond != nil {
 			repl.SkipSpace()
 			if repl.AdvanceStr(")") {
 				return cond
+			}
+		}
 	case repl.AdvanceRegexp(`^defined\s*\(`):
 		if varname := p.Varname(); varname != "" {
 			if repl.AdvanceStr(")") {
 				return NewTree("defined", varname)
+			}
+		}
 	case repl.AdvanceRegexp(`^empty\s*\(`):
 		if varname := p.Varname(); varname != "" {
 			modifiers := p.VarUseModifiers(")")
 			if repl.AdvanceStr(")") {
 				return NewTree("empty", MkVarUse{varname, modifiers})
+			}
+		}
 	case repl.AdvanceRegexp(`^(commands|exists|make|target)\s*\(`):
 		funcname := repl.m[1]
 		argMark := repl.Mark()
 		for p.VarUse() != nil || repl.AdvanceRegexp(`^[^$)]+`) {
+		}
 		arg := repl.Since(argMark)
 		if repl.AdvanceStr(")") {
 			return NewTree(funcname, arg)
+		}
 	default:
 		lhs := p.VarUse()
 		mark := repl.Mark()
 		if lhs == nil && repl.AdvanceStr("\"") {
 			if quotedLhs := p.VarUse(); quotedLhs != nil && repl.AdvanceStr("\"") {
 				lhs = quotedLhs
 			} else {
 				repl.Reset(mark)
+			}
+		}
 		if lhs != nil {
 			if repl.AdvanceRegexp(`^\s*(<|<=|==|!=|>=|>)\s*(\d+(?:\.\d+)?)`) {
 				return NewTree("compareVarNum", *lhs, repl.m[1], repl.m[2])
+			}
 			if repl.AdvanceRegexp(`^\s*(<|<=|==|!=|>=|>)\s*`) {
 				op := repl.m[1]
 				if (op == "!=" || op == "==") && repl.AdvanceRegexp(`^"([^"\$\\]*)"`) {
 					return NewTree("compareVarStr", *lhs, op, repl.m[1])
 				} else if repl.AdvanceRegexp(`^\w+`) {
 					return NewTree("compareVarStr", *lhs, op, repl.m[0])
 				} else if rhs := p.VarUse(); rhs != nil {
 					return NewTree("compareVarVar", *lhs, op, *rhs)
+				}
 			} else {
 				return NewTree("not", NewTree("empty", *lhs)) // See devel/bmake/files/cond.c:/\* For \.if \$/
+			}
+		}
 		if repl.AdvanceRegexp(`^\d+(?:\.\d+)?`) {
 			return NewTree("literalNum", repl.m[0])
+		}
+	}
 	repl.Reset(mark)
 	return nil
+}

 @@ -3,69 +3,39 @@ package main
 import (
 	"fmt"
+)
 type Tree struct {
 	name string
 	args []interface{}
+}
 func NewTree(name string, args ...interface{}) *Tree {
 	return &Tree{name, args}
+}
 // Checks whether this tree matches the given pattern, and if so,
 // copies the corresponding nodes from the tree to the pattern.
 // If the match is partially successful, some or all of the variables
 // may have been copied or not.
 func (t *Tree) Match(pattern *Tree) bool {
 	if G.opts.DebugTrace {
 		defer tracecall(t, pattern)()
 	if t.name != pattern.name || len(t.args) != len(pattern.args) {
 		return false
 	for i, targ := range t.args {
 		parg := pattern.args[i]
 		switch parg := parg.(type) {
 		case *Tree:
 			if targ, ok := targ.(*Tree); ok {
 				if !targ.Match(parg) {
 					return false
 			} else {
 				return false
 		case **string:
 			if targ, ok := targ.(string); ok {
 				if *parg == nil {
 					*parg = &targ
 				} else if **parg != targ {
 					return false
 			} else {
 				return false
 		default:
 			return false
 	return true
 func (t *Tree) String() string {
 	s := "(" + t.name
 	for _, arg := range t.args {
 		if arg, ok := arg.(*Tree); ok {
 			s += " " + (*arg).String()
 			continue
+		}
 		if arg, ok := arg.(string); ok {
 			s += fmt.Sprintf(" %q", arg)
 			continue
 		} else {
 			s += fmt.Sprintf(" %v", arg)
+		}
 		s += fmt.Sprintf(" %v", arg)
+	}
 	return s + ")"
+}
 func (t *Tree) Visit(nodename string, action func(t *Tree)) {
 	if t.name == nodename {
 		action(t)
+	}
 	for _, arg := range t.args {
 		if child, ok := arg.(*Tree); ok {
 			child.Visit(nodename, action)
+		}
+	}
+}

 @@ -1,28 +1,9 @@
 package main
 import (
 	check "gopkg.in/check.v1"
+)
 func (s *Suite) TestTreeMatch_successful(c *check.C) {
 	var varname *string
 	pattern := NewTree("not", NewTree("empty", &varname))
 	tree := NewTree("not", NewTree("empty", "VARNAME"))
 	c.Check(tree.Match(pattern), equals, true)
 	c.Assert(varname, check.Not(equals), nil)
 	c.Check(*varname, equals, "VARNAME")
 func (s *Suite) TestTreeMatch_fails(c *check.C) {
 	var varname *string
 	pattern := NewTree("not", NewTree("empty", &varname))
 	tree := NewTree("not", NewTree("full", "VARNAME"))
 	c.Check(tree.Match(pattern), equals, false)
 	c.Check(varname, equals, (*string)(nil))
 func (s *Suite) TestTreeString(c *check.C) {
 	c.Check(NewTree("not", NewTree("empty", "varname")).String(), equals, "(not (empty \"varname\"))")
+}