Thu Jul 7 12:09:27 2016 UTC ()

Updated pkglint to 5.4.3.

Changes since 5.4.2:

* Variables like ${VAR_${OTHER_VAR}} are no longer checked for
  use/define mismatch
* The check for plural variable names has been removed
* The type of variables called *DESTDIR is no longer guessed to be a
  directory name
* The check for unknown shell commands is disabled in Makefile
  sections that depend on OPSYS
* The experimental hand-written shell parser has been replaced with
  a Yacc-generated one
* Meta packages don't need a LICENSE
* When PKGNAME is defined in terms of ${DISTNAME:S/from/to/:tl}, more
  modifiers (like :tl) are handled properly
* When the MAINTAINER or OWNER of a package is not the current user,
  a warning is printed for modified files
* The check for share/applications/*.desktop has been disabled, since
  pkglint would need to inspect the file's actual contents to see
  whether desktopdb.mk must be included or not
* SUBST_CLASSES may also be SUBST_CLASSES.NetBSD
* Loosened the usage restrictions for several variables, e.g. many
  variables that may be appended in a Makefile may also be set
  unconditionally
* PKG_OPTIONS_VAR must be of the form PKG_OPTIONS.*


(rillig)

--- pkgsrc/pkgtools/pkglint/Makefile 2016/06/19 18:03:29 1.487
+++ pkgsrc/pkgtools/pkglint/Makefile 2016/07/07 12:09:26 1.488

 @@ -1,41 +1,44 @@
-# $NetBSD: Makefile,v 1.487 2016/06/19 18:03:29 wiz Exp $
+# $NetBSD: Makefile,v 1.488 2016/07/07 12:09:26 rillig Exp $
-PKGNAME=	pkglint-5.4.2
+PKGNAME=	pkglint-5.4.3
 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
 AUTO_MKDIRS=	yes
 GO_SRCPATH=	netbsd.org/pkglint
 SUBST_CLASSES+=		pkglint
 SUBST_STAGE.pkglint=	post-configure
 SUBST_FILES.pkglint+=	main.go package_test.go
 SUBST_SED.pkglint+=	-e s\|@VERSION@\|${PKGNAME:S/pkglint-//}\|g
 SUBST_SED.pkglint+=	-e s\|@BMAKE@\|${MAKE:Q}\|g
 do-extract:
 	${RUN} mkdir -p ${WRKDIR}/pkglint/plist-clash
-	${RUN} cd ${FILESDIR} && ${PAX} -rw *.go */*.go pkglint.[01] ${WRKDIR}/pkglint
+	${RUN} cd ${FILESDIR} && ${PAX} -rw *.go *.y */*.go pkglint.[01] ${WRKDIR}/pkglint
 pre-build:
 	${RUN} env GOPATH=${WRKDIR}:${BUILDLINK_DIR}/gopkg go generate ${GO_BUILD_PATTERN}
 do-install: do-install-man
 .include "../../mk/bsd.prefs.mk"
 do-install-man: .PHONY
 .if !empty(MANINSTALL:Mcatinstall)
 .  if defined(CATMAN_SECTION_SUFFIX) && !empty(CATMAN_SECTION_SUFFIX:M[Yy][Ee][Ss])
 	${INSTALL_MAN} ${WRKSRC}/pkglint.0 ${DESTDIR}${PREFIX}/${PKGMANDIR}/cat1/pkglint.1
 .  else
 	${INSTALL_MAN} ${WRKSRC}/pkglint.0 ${DESTDIR}${PREFIX}/${PKGMANDIR}/cat1
 .  endif
 .endif

--- pkgsrc/pkgtools/pkglint/files/Attic/check_test.go 2016/06/05 11:24:32 1.9
+++ pkgsrc/pkgtools/pkglint/files/Attic/check_test.go 2016/07/07 12:09:27 1.10

 @@ -65,32 +65,38 @@ func (s *Suite) NewRawLines(args ...inte
 func (s *Suite) NewLines(fname string, texts ...string) []*Line {
 	result := make([]*Line, len(texts))
 	for i, text := range texts {
 		textnl := text + "\n"
 		result[i] = NewLine(fname, i+1, text, s.NewRawLines(i+1, textnl))
+	}
 	return result
+}
 func (s *Suite) NewMkLines(fname string, lines ...string) *MkLines {
 	return NewMkLines(s.NewLines(fname, lines...))
+}
-func (s *Suite) DebugToStdout() {
+func (s *Suite) BeginDebugToStdout() {
 	G.debugOut = os.Stdout
 	G.logOut = os.Stdout
 	G.opts.Debug = true
+}
 func (s *Suite) EndDebugToStdout() {
 	G.debugOut = &s.stdout
 	G.logOut = &s.stdout
 	G.opts.Debug = false
+}
 func (s *Suite) UseCommandLine(c *check.C, args ...string) {
 	exitcode := new(Pkglint).ParseCommandLine(append([]string{"pkglint"}, args...))
 	if exitcode != nil && *exitcode != 0 {
 		c.Fatalf("Cannot parse command line: %#v", args)
+	}
 	G.opts.LogVerbose = true // See SetUpTest
+}
 func (s *Suite) RegisterMasterSite(varname string, urls ...string) {
 	name2url := &G.globalData.MasterSiteVarToURL
 	url2name := &G.globalData.MasterSiteURLToVar
 	if *name2url == nil {
 		*name2url = make(map[string]string)

--- pkgsrc/pkgtools/pkglint/files/Attic/shell.go 2016/06/05 11:24:32 1.9
+++ pkgsrc/pkgtools/pkglint/files/Attic/shell.go 2016/07/07 12:09:27 1.10

 @@ -1,115 +1,30 @@
 package main
 // Parsing and checking shell commands embedded in Makefiles
 import (
 	"path"
 	"strings"
+)
 const (
 	reShellToken = `^\s*(` +
 		`#.*` + // shell comment
 		`|(?:` +
 		`'[^']*'` + // single quoted string
 		"|\"`[^`]+`\"" + // backticks command execution in double quotes
 		`|"(?:\\.|[^"])*"` + // double quoted string
 		"|`[^`]*`" + // backticks command execution (very simple case)
 		`|\\\$\$` + // a shell-escaped dollar sign
 		`|\\[^\$]` + // other escaped characters
 		`|\$[\w_]` + // one-character make(1) variable
 		`|\$\$[0-9A-Z_a-z]+` + // shell variable
 		`|\$\$[!#?@]` + // special shell variables
 		`|\$\$[./]` + // unescaped dollar in shell, followed by punctuation
 		`|\$\$\$\$` + // the special pid shell variable
 		`|\$\$\{[0-9A-Z_a-z]+[#%:]?[^}]*\}` + // shell variable in braces
 		`|[^\(\)'\"\\\s;&\|<>` + "`" + `\$]` + // non-special character
 		`|\$\{[^\s\"'` + "`" + `]+` + // HACK: nested make(1) variables
 		`)+` + // any of the above may be repeated
 		`|\$\$\(` + // POSIX-style backticks replacement
 		`|;;?` +
 		`|&&?` +
 		`|\|\|?` +
 		`|\(` +
 		`|\)` +
 		`|>&` +
 		`|<<?` +
 		`|>>?` +
 		`|#.*)`
 	reShVarassign    = `^([A-Z_a-z]\w*)=`
 	reShVarname      = `(?:[!#*\-\d?@]|\$\$|[A-Za-z_]\w*)`
 	reShVarexpansion = `(?:(?:#|##|%|%%|:-|:=|:\?|:\+|\+)[^$\\{}]*)`
 	reShVaruse       = `\$\$` + `(?:` + reShVarname + `|` + `\{` + reShVarname + `(?:` + reShVarexpansion + `)?` + `\})`
 	reShDollar       = `\\\$\$|` + reShVaruse + `|\$\$[,\-/|]`
+)
 // ShellCommandState
 type scState uint8
 const (
 	scstStart scState = iota
 	scstCont
 	scstInstall
 	scstInstallD
 	scstMkdir
 	scstPax
 	scstPaxS
 	scstSed
 	scstSedE
 	scstSet
 	scstSetCont
 	scstCond
 	scstCondCont
 	scstCase
 	scstCaseIn
 	scstCaseLabel
 	scstCaseLabelCont
 	scstFor
 	scstForIn
 	scstForCont
 	scstEcho
 	scstInstallDir
 	scstInstallDir2
 func (st scState) String() string {
 	return [...]string{
 		"start",
 		"continuation",
 		"install",
 		"install -d",
 		"mkdir",
 		"pax",
 		"pax -s",
 		"sed",
 		"sed -e",
 		"set",
 		"set-continuation",
 		"cond",
 		"cond-continuation",
 		"case",
 		"case in",
 		"case label",
 		"case-label-continuation",
 		"for",
 		"for-in",
 		"for-continuation",
 		"echo",
 		"install-dir",
 		"install-dir2",
 	}[st]
 type ShellLine struct {
 	line   *Line
 	mkline *MkLine
+}
 func NewShellLine(mkline *MkLine) *ShellLine {
 	return &ShellLine{mkline.Line, mkline}
+}
 var shellcommandsContextType = &Vartype{lkNone, CheckvarShellCommands, []AclEntry{{"*", aclpAllRuntime}}, false}
 var shellwordVuc = &VarUseContext{shellcommandsContextType, vucTimeUnknown, vucQuotPlain, vucExtentWord}
 func (shline *ShellLine) CheckWord(token string, checkQuoting bool) {
 @@ -345,32 +260,26 @@ func (shline *ShellLine) unescapeBacktic
 	return unescaped, quoting
+}
 func (shline *ShellLine) variableNeedsQuoting(shvarname string) bool {
 	switch shvarname {
 	case "#", "?":
 		return false // Definitely ok
 	case "d", "f", "i", "dir", "file", "src", "dst":
 		return false // Probably ok
+	}
 	return true
+}
 type ShelltextContext struct {
 	shline    *ShellLine
 	state     scState
 	shellword string
 func (shline *ShellLine) CheckShellCommandLine(shelltext string) {
 	if G.opts.Debug {
 		defer tracecall1(shelltext)()
+	}
 	line := shline.line
 	if contains(shelltext, "${SED}") && contains(shelltext, "${MV}") {
 		line.Note0("Please use the SUBST framework instead of ${SED} and ${MV}.")
 		Explain(
 			"Using the SUBST framework instead of explicit commands is easier",
 			"to understand, since all the complexity of using sed and mv is",
 			"hidden behind the scenes.",
 @@ -401,109 +310,93 @@ func (shline *ShellLine) CheckShellComma
 		shline.checkHiddenAndSuppress(repl.m[0], repl.rest)
+	}
 	setE := false
 	if repl.AdvanceStr("${RUN}") {
 		setE = true
 	} else {
 		repl.AdvanceStr("${_PKG_SILENT}${_PKG_DEBUG}")
+	}
 	shline.CheckShellCommand(repl.rest, &setE)
+}
 func (shline *ShellLine) CheckShellCommand(shellcmd string, pSetE *bool) {
-	if false {
+	if G.opts.Debug {
-		p := NewMkShParser(shline.line, shellcmd, false)
+		defer tracecall()()
 		cmds := p.Program()
 		rest := p.tok.parser.Rest()
 		if rest != "" {
 			traceStep("shellcmd=%q", shellcmd)
 			if cmds != nil {
 				for _, andor := range cmds.AndOrs {
 					traceStep("AndOr %v", andor)
 			shline.line.Warnf("Pkglint parse error in ShellLine.CheckShellCommand at %q", p.peekText()+rest)
+	}
-	state := scstStart
+	program, err := parseShellProgram(shline.line, shellcmd)
-	tokens, rest := splitIntoShellTokens(shline.line, shellcmd)
+	if err != nil && contains(shellcmd, "$$(") { // Hack until the shell parser can handle subshells.
-	if rest != "" {
+		shline.line.Warn0("Invoking subshells via $(...) is not portable enough.")
-		shline.line.Warnf("Pkglint parse error in ShellLine.CheckShellCommand at %q (state=%s)", rest, state)
+		return
+	}
 	if err != nil {
 		shline.line.Warnf("Pkglint ShellLine.CheckShellCommand: %s", err)
 		return
+	}
-	prevToken := ""
+	spc := &ShellProgramChecker{shline}
-	for _, token := range tokens {
+	spc.checkConditionalCd(program)
 		if G.opts.Debug {
 			traceStep("checkShellCommand state=%v token=%q", state, token)
 	(*MkShWalker).Walk(nil, program, func(node interface{}) {
-			noQuotingNeeded := state == scstCase ||
+		if cmd, ok := node.(*MkShSimpleCommand); ok {
-				state == scstForCont ||
+			scc := NewSimpleCommandChecker(shline, cmd)
-				state == scstSetCont ||
+			scc.Check()
-				(state == scstStart && matches(token, reShVarassign))
+			if scc.strcmd.Name == "set" && scc.strcmd.AnyArgMatches(`^-.*e`) {
-			shline.CheckWord(token, !noQuotingNeeded)
+				*pSetE = true
+			}
+		}
-		st := &ShelltextContext{shline, state, token}
+		if cmd, ok := node.(*MkShList); ok {
-		st.checkCommandStart()
+			spc.checkSetE(cmd, pSetE)
 		st.checkConditionalCd()
 		if state != scstPaxS && state != scstSedE && state != scstCaseLabel {
 			shline.line.CheckAbsolutePathname(token)
+		}
 		st.checkAutoMkdirs()
 		st.checkInstallMulti()
 		st.checkPaxPe()
 		st.checkQuoteSubstitution()
 		st.checkEchoN()
 		st.checkPipeExitcode()
 		st.checkSetE(pSetE, prevToken)
-		if state == scstSet && hasPrefix(token, "-") && contains(token, "e") || state == scstStart && token == "${RUN}" {
+		if cmd, ok := node.(*MkShPipeline); ok {
-			*pSetE = true
+			spc.checkPipeExitcode(shline.line, cmd)
+		}
-		state = shline.nextState(state, token)
+		if word, ok := node.(*ShToken); ok {
-		prevToken = token
+			spc.checkWord(word, false)
+		}
 	})
+}
 func (shline *ShellLine) CheckShellCommands(shellcmds string) {
 	setE := true
 	shline.CheckShellCommand(shellcmds, &setE)
 	if !hasSuffix(shellcmds, ";") {
 		shline.line.Warn0("This shell command list should end with a semicolon.")
+	}
+}
 func (shline *ShellLine) checkHiddenAndSuppress(hiddenAndSuppress, rest string) {
 	if G.opts.Debug {
 		defer tracecall(hiddenAndSuppress, rest)()
+	}
 	switch {
 	case !contains(hiddenAndSuppress, "@"):
 		// Nothing is hidden at all.
 	case hasPrefix(G.Mk.target, "show-") || hasSuffix(G.Mk.target, "-message"):
 		// In these targets, all commands may be hidden.
 	case hasPrefix(rest, "#"):
 		// Shell comments may be hidden, since they cannot have side effects.
 	default:
-		if m, cmd := match1(rest, reShellToken); m {
+		tokens, _ := splitIntoShellTokens(shline.line, rest)
 		if len(tokens) > 0 {
 			cmd := tokens[0]
 			switch cmd {
 			case "${DELAYED_ERROR_MSG}", "${DELAYED_WARNING_MSG}",
 				"${DO_NADA}",
 				"${ECHO}", "${ECHO_MSG}", "${ECHO_N}", "${ERROR_CAT}", "${ERROR_MSG}",
 				"${FAIL_MSG}",
 				"${PHASE_MSG}", "${PRINTF}",
 				"${SHCOMMENT}", "${STEP_MSG}",
 				"${WARNING_CAT}", "${WARNING_MSG}":
 				break
 			default:
 				shline.line.Warn1("The shell command %q should not be hidden.", cmd)
 				Explain(
 					"Hidden shell commands do not appear on the terminal or in the log",
 @@ -515,129 +408,158 @@ func (shline *ShellLine) checkHiddenAndS
 					"PKG_DEBUG_LEVEL is set.")
+			}
+		}
+	}
 	if contains(hiddenAndSuppress, "-") {
 		shline.line.Warn0("Using a leading \"-\" to suppress errors is deprecated.")
 		Explain2(
 			"If you really want to ignore any errors from this command, append",
 			"\"|| ${TRUE}\" to the command.")
+	}
+}
-func (ctx *ShelltextContext) checkCommandStart() {
+type SimpleCommandChecker struct {
 	shline *ShellLine
 	cmd    *MkShSimpleCommand
 	strcmd *StrCommand
+}
 func NewSimpleCommandChecker(shline *ShellLine, cmd *MkShSimpleCommand) *SimpleCommandChecker {
 	strcmd := NewStrCommand(cmd)
 	return &SimpleCommandChecker{shline, cmd, strcmd}
+}
 func (c *SimpleCommandChecker) Check() {
 	if G.opts.Debug {
-		defer tracecall2(ctx.state.String(), ctx.shellword)()
+		defer tracecall(c.strcmd)()
+	}
-	state, shellword := ctx.state, ctx.shellword
+	c.checkCommandStart()
-	if state != scstStart && state != scstCond {
+	c.checkAbsolutePathnames()
-		return
+	c.checkAutoMkdirs()
 	c.checkInstallMulti()
 	c.checkPaxPe()
 	c.checkEchoN()
+}
 func (ctx *SimpleCommandChecker) checkCommandStart() {
 	if G.opts.Debug {
 		defer tracecall()()
+	}
 	shellword := ctx.strcmd.Name
 	switch {
-	case shellword == "${RUN}":
+	case shellword == "${RUN}" || shellword == "":
 	case ctx.handleForbiddenCommand():
 	case ctx.handleTool():
 	case ctx.handleCommandVariable():
-	case matches(shellword, `^(?:\$\$\(|\(|\)|:|;|;;|&&|\|\||\{|\}|break|case|cd|continue|do|done|elif|else|esac|eval|exec|exit|export|fi|for|if|read|set|shift|then|umask|unset|while)$`):
+	case matches(shellword, `^(?::|break|cd|continue|eval|exec|exit|export|read|set|shift|umask|unset)$`):
 	case matches(shellword, `^\w+=`): // Variable assignment
 	case hasPrefix(shellword, "./"): // All commands from the current directory are fine.
 	case hasPrefix(shellword, "${PKGSRCDIR"): // With or without the :Q modifier
 	case ctx.handleComment():
 	default:
-		if G.opts.WarnExtra {
+		if G.opts.WarnExtra && !(G.Mk != nil && G.Mk.indentation.DependsOn("OPSYS")) {
 			ctx.shline.line.Warn1("Unknown shell command %q.", shellword)
 			Explain3(
 				"If you want your package to be portable to all platforms that pkgsrc",
 				"supports, you should only use shell commands that are covered by the",
 				"tools framework.")
+		}
+	}
+}
-func (ctx *ShelltextContext) handleTool() bool {
+func (ctx *SimpleCommandChecker) handleTool() bool {
 	if G.opts.Debug {
-		defer tracecall1(ctx.shellword)()
+		defer tracecall()()
+	}
-	shellword := ctx.shellword
+	shellword := ctx.strcmd.Name
 	tool := G.globalData.Tools.byName[shellword]
 	if tool == nil {
 		return false
+	}
 	if !G.Mk.tools[shellword] && !G.Mk.tools["g"+shellword] {
 		ctx.shline.line.Warn1("The %q tool is used but not added to USE_TOOLS.", shellword)
+	}
 	if tool.MustUseVarForm {
 		ctx.shline.line.Warn2("Please use \"${%s}\" instead of %q.", tool.Varname, shellword)
+	}
 	ctx.shline.checkCommandUse(shellword)
 	return true
+}
-func (ctx *ShelltextContext) handleForbiddenCommand() bool {
+func (ctx *SimpleCommandChecker) handleForbiddenCommand() bool {
-	switch path.Base(ctx.shellword) {
+	if G.opts.Debug {
 		defer tracecall()()
+	}
 	shellword := ctx.strcmd.Name
 	switch path.Base(shellword) {
 	case "ktrace", "mktexlsr", "strace", "texconfig", "truss":
-		ctx.shline.line.Error1("%q must not be used in Makefiles.", ctx.shellword)
+		ctx.shline.line.Error1("%q must not be used in Makefiles.", shellword)
 		Explain3(
 			"This command must appear in INSTALL scripts, not in the package",
 			"Makefile, so that the package also works if it is installed as a binary",
 			"package via pkg_add.")
 		return true
+	}
 	return false
+}
-func (ctx *ShelltextContext) handleCommandVariable() bool {
+func (ctx *SimpleCommandChecker) handleCommandVariable() bool {
 	if G.opts.Debug {
-		defer tracecall1(ctx.shellword)()
+		defer tracecall()()
+	}
-	shellword := ctx.shellword
+	shellword := ctx.strcmd.Name
 	if m, varname := match1(shellword, `^\$\{([\w_]+)\}$`); m {
 		if tool := G.globalData.Tools.byVarname[varname]; tool != nil {
 			if !G.Mk.tools[tool.Name] {
 				ctx.shline.line.Warn1("The %q tool is used but not added to USE_TOOLS.", tool.Name)
+			}
 			ctx.shline.checkCommandUse(shellword)
 			return true
+		}
 		if vartype := ctx.shline.mkline.getVariableType(varname); vartype != nil && vartype.checker.name == "ShellCommand" {
 			ctx.shline.checkCommandUse(shellword)
 			return true
+		}
 		// When the package author has explicitly defined a command
 		// variable, assume it to be valid.
 		if G.Pkg != nil && G.Pkg.vardef[varname] != nil {
 			return true
+		}
+	}
 	return false
+}
-func (ctx *ShelltextContext) handleComment() bool {
+func (ctx *SimpleCommandChecker) handleComment() bool {
 	if G.opts.Debug {
-		defer tracecall1(ctx.shellword)()
+		defer tracecall()()
+	}
 	shellword := ctx.strcmd.Name
 	if G.opts.Debug {
 		defer tracecall1(shellword)()
+	}
 	shellword := ctx.shellword
 	if !hasPrefix(shellword, "#") {
 		return false
+	}
 	semicolon := contains(shellword, ";")
 	multiline := ctx.shline.line.IsMultiline()
 	if semicolon {
 		ctx.shline.line.Warn0("A shell comment should not contain semicolons.")
+	}
 	if multiline {
 		ctx.shline.line.Warn0("A shell comment does not stop at the end of line.")
+	}
 @@ -650,143 +572,249 @@ func (ctx *ShelltextContext) handleComme
 			"it _looks_ like that the comment only spans one line in the",
 			"Makefile, in fact it spans until the end of the whole shell command.",
 			"",
 			"To insert a comment into shell code, you can write it like this:",
 			"",
 			"\t"+"${SHCOMMENT} \"The following command might fail; this is ok.\"",
 			"",
 			"Note that any special characters in the comment are still",
 			"interpreted by the shell.")
+	}
 	return true
+}
-func (ctx *ShelltextContext) checkConditionalCd() {
+type ShellProgramChecker struct {
-	if ctx.state == scstCond && ctx.shellword == "cd" {
+	shline *ShellLine
 		ctx.shline.line.Error0("The Solaris /bin/sh cannot handle \"cd\" inside conditionals.")
 		Explain3(
 			"When the Solaris shell is in \"set -e\" mode and \"cd\" fails, the",
 			"shell will exit, no matter if it is protected by an \"if\" or the",
 			"\"||\" operator.")
+}
-func (ctx *ShelltextContext) checkAutoMkdirs() {
+func (c *ShellProgramChecker) checkConditionalCd(list *MkShList) {
-	state, shellword := ctx.state, ctx.shellword
+	if G.opts.Debug {
 		defer tracecall()()
+	}
-	line := ctx.shline.line
+	getSimple := func(list *MkShList) *MkShSimpleCommand {
-	if (state == scstInstallD || state == scstMkdir) && matches(shellword, `^(?:\$\{DESTDIR\})?\$\{PREFIX(?:|:Q)\}/`) {
+		if len(list.AndOrs) == 1 {
-		line.Warn1("Please use AUTO_MKDIRS instead of %q.",
+			if len(list.AndOrs[0].Pipes) == 1 {
-			ifelseStr(state == scstMkdir, "${MKDIR}", "${INSTALL} -d"))
+				if len(list.AndOrs[0].Pipes[0].Cmds) == 1 {
-		Explain4(
+					return list.AndOrs[0].Pipes[0].Cmds[0].Simple
 			"Setting AUTO_MKDIRS=yes automatically creates all directories that",
 			"are mentioned in the PLIST.  If you need additional directories,",
 			"specify them in INSTALLATION_DIRS, which is a list of directories",
-			"relative to ${PREFIX}.")
+		return nil
+	}
-	if (state == scstInstallDir || state == scstInstallDir2) && !contains(shellword, "$$") {
+	checkConditionalCd := func(cmd *MkShSimpleCommand) {
-		if m, dirname := match1(shellword, `^(?:\$\{DESTDIR\})?\$\{PREFIX(?:|:Q)\}/(.*)`); m {
+		if NewStrCommand(cmd).Name == "cd" {
-			line.Note1("You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= %s\" instead of this command.", dirname)
+			c.shline.line.Error0("The Solaris /bin/sh cannot handle \"cd\" inside conditionals.")
-			Explain(
+			Explain3(
-				"Many packages include a list of all needed directories in their",
+				"When the Solaris shell is in \"set -e\" mode and \"cd\" fails, the",
-				"PLIST file.  In such a case, you can just set AUTO_MKDIRS=yes and",
+				"shell will exit, no matter if it is protected by an \"if\" or the",
-				"be done.  The pkgsrc infrastructure will then create all directories",
+				"\"||\" operator.")
 				"in advance.",
 				"",
 				"To create directories that are not mentioned in the PLIST file, it",
 				"is easier to just list them in INSTALLATION_DIRS than to execute the",
 				"commands explicitly.  That way, you don't have to think about which",
 				"of the many INSTALL_*_DIR variables is appropriate, since",
 				"INSTALLATION_DIRS takes care of that.")
+		}
+	}
 	(*MkShWalker).Walk(nil, list, func(node interface{}) {
 		if cmd, ok := node.(*MkShIfClause); ok {
 			for _, cond := range cmd.Conds {
 				if simple := getSimple(cond); simple != nil {
 					checkConditionalCd(simple)
+				}
+			}
+		}
 		if cmd, ok := node.(*MkShLoopClause); ok {
 			if simple := getSimple(cmd.Cond); simple != nil {
 				checkConditionalCd(simple)
+			}
+		}
 	})
+}
-func (ctx *ShelltextContext) checkInstallMulti() {
+func (c *ShellProgramChecker) checkWords(words []*ShToken, checkQuoting bool) {
-	if ctx.state == scstInstallDir2 && hasPrefix(ctx.shellword, "$") {
+	if G.opts.Debug {
-		line := ctx.shline.line
+		defer tracecall()()
 		line.Warn0("The INSTALL_*_DIR commands can only handle one directory at a time.")
 		Explain2(
-			"Many implementations of install(1) can handle more, but pkgsrc aims",
+	for _, word := range words {
-			"at maximum portability.")
+		c.checkWord(word, checkQuoting)
+	}
+}
-func (ctx *ShelltextContext) checkPaxPe() {
+func (c *ShellProgramChecker) checkWord(word *ShToken, checkQuoting bool) {
-	if ctx.state == scstPax && ctx.shellword == "-pe" {
+	if G.opts.Debug {
-		line := ctx.shline.line
+		defer tracecall(word.MkText)()
 		line.Warn0("Please use the -pp option to pax(1) instead of -pe.")
 		Explain3(
 			"The -pe option tells pax to preserve the ownership of the files, which",
 			"means that the installed files will belong to the user that has built",
 			"the package.")
+	}
 	c.shline.CheckWord(word.MkText, checkQuoting)
+}
-func (ctx *ShelltextContext) checkQuoteSubstitution() {
+func (c *SimpleCommandChecker) checkAbsolutePathnames() {
-	if ctx.state == scstPaxS || ctx.state == scstSedE {
+	if G.opts.Debug {
-		if false && !matches(ctx.shellword, `"^[\"\'].*[\"\']$`) {
+		defer tracecall()()
 			line := ctx.shline.line
 			line.Warn1("Substitution commands like %q should always be quoted.", ctx.shellword)
 	cmdname := c.strcmd.Name
 	isSubst := false
 	for _, arg := range c.strcmd.Args {
 		if !isSubst {
 			c.shline.line.CheckAbsolutePathname(arg)
+		}
 		if false && isSubst && !matches(arg, `"^[\"\'].*[\"\']$`) {
 			c.shline.line.Warn1("Substitution commands like %q should always be quoted.", arg)
 			Explain3(
 				"Usually these substitution commands contain characters like '*' or",
 				"other shell metacharacters that might lead to lookup of matching",
 				"filenames and then expand to more than one word.")
+		}
 		isSubst = cmdname == "${PAX}" && arg == "-s" || cmdname == "${SED}" && arg == "-e"
+	}
+}
 func (ctx *SimpleCommandChecker) checkAutoMkdirs() {
 	if G.opts.Debug {
 		defer tracecall()()
+	}
 	cmdname := ctx.strcmd.Name
 	switch {
 	case cmdname == "${MKDIR}":
 		break
 	case cmdname == "${INSTALL}" && ctx.strcmd.HasOption("-d"):
 		cmdname = "${INSTALL} -d"
 	case matches(cmdname, `^\$\{INSTALL_.*_DIR\}$`):
 		break
 	default:
 		return
+	}
 	for _, arg := range ctx.strcmd.Args {
 		if !contains(arg, "$$") && !matches(arg, `\$\{[_.]*[a-z]`) {
 			if m, dirname := match1(arg, `^(?:\$\{DESTDIR\})?\$\{PREFIX(?:|:Q)\}/(.*)`); m {
 				ctx.shline.line.Note2("You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= %s\" instead of %q.", dirname, cmdname)
 				Explain(
 					"Many packages include a list of all needed directories in their",
 					"PLIST file.  In such a case, you can just set AUTO_MKDIRS=yes and",
 					"be done.  The pkgsrc infrastructure will then create all directories",
 					"in advance.",
 					"",
 					"To create directories that are not mentioned in the PLIST file, it",
 					"is easier to just list them in INSTALLATION_DIRS than to execute the",
 					"commands explicitly.  That way, you don't have to think about which",
 					"of the many INSTALL_*_DIR variables is appropriate, since",
 					"INSTALLATION_DIRS takes care of that.")
+			}
+		}
+	}
+}
 func (ctx *SimpleCommandChecker) checkInstallMulti() {
 	if G.opts.Debug {
 		defer tracecall()()
+	}
 	cmd := ctx.strcmd
 	if hasPrefix(cmd.Name, "${INSTALL_") && hasSuffix(cmd.Name, "_DIR}") {
 		prevdir := ""
 		for i, arg := range cmd.Args {
 			switch {
 			case hasPrefix(arg, "-"):
 				break
 			case i > 0 && (cmd.Args[i-1] == "-m" || cmd.Args[i-1] == "-o" || cmd.Args[i-1] == "-g"):
 				break
 			default:
 				if prevdir != "" {
 					ctx.shline.line.Warn0("The INSTALL_*_DIR commands can only handle one directory at a time.")
 					Explain2(
 						"Many implementations of install(1) can handle more, but pkgsrc aims",
 						"at maximum portability.")
 					return
+				}
 				prevdir = arg
+			}
+		}
+	}
+}
 func (ctx *SimpleCommandChecker) checkPaxPe() {
 	if G.opts.Debug {
 		defer tracecall()()
+	}
 	if ctx.strcmd.Name == "${PAX}" && ctx.strcmd.HasOption("-pe") {
 		ctx.shline.line.Warn0("Please use the -pp option to pax(1) instead of -pe.")
 		Explain3(
 			"The -pe option tells pax to preserve the ownership of the files, which",
 			"means that the installed files will belong to the user that has built",
 			"the package.")
+	}
+}
-func (ctx *ShelltextContext) checkEchoN() {
+func (ctx *SimpleCommandChecker) checkEchoN() {
-	if ctx.state == scstEcho && ctx.shellword == "-n" {
+	if G.opts.Debug {
 		defer tracecall()()
+	}
 	if ctx.strcmd.Name == "${ECHO}" && ctx.strcmd.HasOption("-n") {
 		ctx.shline.line.Warn0("Please use ${ECHO_N} instead of \"echo -n\".")
+	}
+}
-func (ctx *ShelltextContext) checkPipeExitcode() {
+func (ctx *ShellProgramChecker) checkPipeExitcode(line *Line, pipeline *MkShPipeline) {
-	if G.opts.WarnExtra && ctx.state != scstCaseLabelCont && ctx.shellword == "|" {
+	if G.opts.Debug {
-		line := ctx.shline.line
+		defer tracecall()()
+	}
 	if G.opts.WarnExtra && len(pipeline.Cmds) > 1 {
 		line.Warn0("The exitcode of the left-hand-side command of the pipe operator is ignored.")
 		Explain(
 			"In a shell command like \"cat *.txt | grep keyword\", if the command",
 			"on the left side of the \"|\" fails, this failure is ignored.",
 			"",
 			"If you need to detect the failure of the left-hand-side command, use",
 			"temporary files to save the output of the command.")
+	}
+}
-func (ctx *ShelltextContext) checkSetE(eflag *bool, prevToken string) {
+func (ctx *ShellProgramChecker) checkSetE(list *MkShList, eflag *bool) {
-	if G.opts.WarnExtra && ctx.shellword == ";" && ctx.state != scstCondCont && ctx.state != scstForCont && !*eflag {
+	if G.opts.Debug {
 		defer tracecall()()
+	}
 	// Disabled until the shell parser can recognize "command || exit 1" reliably.
 	if false && G.opts.WarnExtra && !*eflag && "the current token" == ";" {
 		*eflag = true
-		ctx.shline.line.Warn1("Please switch to \"set -e\" mode before using a semicolon (the one after %q) to separate commands.", prevToken)
+		ctx.shline.line.Warn1("Please switch to \"set -e\" mode before using a semicolon (the one after %q) to separate commands.", "previous token")
 		Explain(
 			"Normally, when a shell command fails (returns non-zero), the",
 			"remaining commands are still executed.  For example, the following",
 			"commands would remove all files from the HOME directory:",
 			"",
 			"\tcd \"$HOME\"; cd /nonexistent; rm -rf *",
 			"",
 			"To fix this warning, you can:",
 			"",
 			"* insert ${RUN} at the beginning of the line",
 			"  (which among other things does \"set -e\")",
 			"* insert \"set -e\" explicitly at the beginning of the line",
 			"* use \"&&\" instead of \";\" to separate the commands")
+	}
+}
 // Some shell commands should not be used in the install phase.
 func (shline *ShellLine) checkCommandUse(shellcmd string) {
 	if G.opts.Debug {
 		defer tracecall()()
+	}
 	if G.Mk == nil || !matches(G.Mk.target, `^(?:pre|do|post)-install$`) {
 		return
+	}
 	line := shline.line
 	switch shellcmd {
 	case "${INSTALL}",
 		"${INSTALL_DATA}", "${INSTALL_DATA_DIR}",
 		"${INSTALL_LIB}", "${INSTALL_LIB_DIR}",
 		"${INSTALL_MAN}", "${INSTALL_MAN_DIR}",
 		"${INSTALL_PROGRAM}", "${INSTALL_PROGRAM_DIR}",
 		"${INSTALL_SCRIPT}",
 		"${LIBTOOL}",
 @@ -805,180 +833,73 @@ func (shline *ShellLine) checkCommandUse
 	case "cp", "${CP}":
 		line.Warn0("${CP} should not be used to install files.")
 		Explain(
 			"The ${CP} command is highly platform dependent and cannot overwrite",
 			"read-only files.  Please use ${PAX} instead.",
 			"",
 			"For example, instead of",
 			"\t${CP} -R ${WRKSRC}/* ${PREFIX}/foodir",
 			"you should use",
 			"\tcd ${WRKSRC} && ${PAX} -wr * ${PREFIX}/foodir")
+	}
+}
 func (shline *ShellLine) nextState(state scState, shellword string) scState {
 	switch {
 	case shellword == ";;":
 		return scstCaseLabel
 	case state == scstCaseLabelCont && shellword == "|":
 		return scstCaseLabel
 	case matches(shellword, `^[;&\|]+$`):
 		return scstStart
 	case state == scstStart:
 		switch shellword {
 		case "${INSTALL}":
 			return scstInstall
 		case "${MKDIR}":
 			return scstMkdir
 		case "${PAX}":
 			return scstPax
 		case "${SED}":
 			return scstSed
 		case "${ECHO}", "echo":
 			return scstEcho
 		case "${RUN}", "then", "else", "do", "(":
 			return scstStart
 		case "set":
 			return scstSet
 		case "if", "elif", "while":
 			return scstCond
 		case "case":
 			return scstCase
 		case "for":
 			return scstFor
 		default:
 			switch {
 			case matches(shellword, `^\$\{INSTALL_[A-Z]+_DIR\}$`):
 				return scstInstallDir
 			case matches(shellword, reShVarassign):
 				return scstStart
 			default:
 				return scstCont
 	case state == scstMkdir:
 		return scstMkdir
 	case state == scstInstall && shellword == "-d":
 		return scstInstallD
 	case state == scstInstall, state == scstInstallD:
 		if matches(shellword, `^-[ogm]$`) {
 			return scstCont // XXX: why not keep the state?
 		return state
 	case state == scstInstallDir && hasPrefix(shellword, "-"):
 		return scstCont
 	case state == scstInstallDir && hasPrefix(shellword, "$"):
 		return scstInstallDir2
 	case state == scstInstallDir || state == scstInstallDir2:
 		return state
 	case state == scstPax && shellword == "-s":
 		return scstPaxS
 	case state == scstPax && hasPrefix(shellword, "-"):
 		return scstPax
 	case state == scstPax:
 		return scstCont
 	case state == scstPaxS:
 		return scstPax
 	case state == scstSed && shellword == "-e":
 		return scstSedE
 	case state == scstSed && hasPrefix(shellword, "-"):
 		return scstSed
 	case state == scstSed:
 		return scstCont
 	case state == scstSedE:
 		return scstSed
 	case state == scstSet:
 		return scstSetCont
 	case state == scstSetCont:
 		return scstSetCont
 	case state == scstCase:
 		return scstCaseIn
 	case state == scstCaseIn && shellword == "in":
 		return scstCaseLabel
 	case state == scstCaseLabel && shellword == "esac":
 		return scstCont
 	case state == scstCaseLabel:
 		return scstCaseLabelCont
 	case state == scstCaseLabelCont && shellword == ")":
 		return scstStart
 	case state == scstCont:
 		return scstCont
 	case state == scstCond:
 		return scstCondCont
 	case state == scstCondCont:
 		return scstCondCont
 	case state == scstFor:
 		return scstForIn
 	case state == scstForIn && shellword == "in":
 		return scstForCont
 	case state == scstForCont:
 		return scstForCont
 	case state == scstEcho:
 		return scstCont
 	default:
 		if G.opts.Debug {
 			traceStep("Internal pkglint error: shellword.nextState state=%s shellword=%q", state, shellword)
 		return scstStart
 // Example: "word1 word2;;;" => "word1", "word2", ";;", ";"
 func splitIntoShellTokens(line *Line, text string) (tokens []string, rest string) {
 	if G.opts.Debug {
 		defer tracecall(line, text)()
+	}
 	word := ""
 	emit := func() {
 		if word != "" {
 			tokens = append(tokens, word)
 			word = ""
+		}
+	}
 	p := NewShTokenizer(line, text, false)
 	atoms := p.ShAtoms()
 	q := shqPlain
 	for _, atom := range atoms {
 		q = atom.Quoting
 		if atom.Type == shtSpace && q == shqPlain {
 			emit()
 		} else if atom.Type == shtWord || atom.Type == shtVaruse || atom.Quoting != shqPlain {
-			word += atom.Text
+			word += atom.MkText
 		} else {
 			emit()
-			tokens = append(tokens, atom.Text)
+			tokens = append(tokens, atom.MkText)
+		}
+	}
 	emit()
 	return tokens, word + p.mkp.Rest()
+}
 // Example: "word1 word2;;;" => "word1", "word2;;;"
 // Compare devel/bmake/files/str.c, function brk_string.
 func splitIntoMkWords(line *Line, text string) (words []string, rest string) {
 	if G.opts.Debug {
 		defer tracecall(line, text)()
+	}
 	p := NewShTokenizer(line, text, false)
 	atoms := p.ShAtoms()
 	word := ""
 	for _, atom := range atoms {
 		if atom.Type == shtSpace && atom.Quoting == shqPlain {
 			words = append(words, word)
 			word = ""
 		} else {
-			word += atom.Text
+			word += atom.MkText
+		}
+	}
 	if word != "" && atoms[len(atoms)-1].Quoting == shqPlain {
 		words = append(words, word)
 		word = ""
+	}
 	return words, word + p.mkp.Rest()
+}
 type ShQuote struct {
 	repl *PrefixReplacer
 	q    ShQuoting
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/shell_test.go 2016/06/05 11:24:32 1.9
+++ pkgsrc/pkgtools/pkglint/files/Attic/shell_test.go 2016/07/07 12:09:27 1.10

 @@ -1,38 +1,21 @@
 package main
 import (
 	"strings"
 	check "gopkg.in/check.v1"
+)
 func (s *Suite) TestReShellToken(c *check.C) {
 	re := `^(?:` + reShellToken + `)$`
 	matches := check.NotNil
 	doesntMatch := check.IsNil
 	c.Check(match("", re), doesntMatch)
 	c.Check(match("$var", re), matches)
 	c.Check(match("$var$var", re), matches)
 	c.Check(match("$var;;", re), doesntMatch) // More than one token
 	c.Check(match("'single-quoted'", re), matches)
 	c.Check(match("\"", re), doesntMatch)       // Incomplete string
 	c.Check(match("'...'\"...\"", re), matches) // Mixed strings
 	c.Check(match("\"...\"", re), matches)
 	c.Check(match("`cat file`", re), matches)
 	c.Check(match("${file%.c}.o", re), matches)
 func (s *Suite) Test_SplitIntoShellTokens_LineContinuation(c *check.C) {
 	words, rest := splitIntoShellTokens(dummyLine, "if true; then \\")
 	c.Check(words, check.DeepEquals, []string{"if", "true", ";", "then"})
 	c.Check(rest, equals, "\\")
 	c.Check(s.Output(), equals, "WARN: Pkglint parse error in ShTokenizer.ShAtom at \"\\\\\" (quoting=plain)\n")
+}
 func (s *Suite) Test_SplitIntoShellTokens_DollarSlash(c *check.C) {
 	words, rest := splitIntoShellTokens(dummyLine, "pax -s /.*~$$//g")
 	c.Check(words, check.DeepEquals, []string{"pax", "-s", "/.*~$$//g"})
 @@ -84,140 +67,176 @@ func (s *Suite) Test_SplitIntoShellToken
 	words, rest := splitIntoShellTokens(dummyLine, "${VAR:S/ /_/g}")
 	c.Check(words, deepEquals, []string{"${VAR:S/ /_/g}"})
 	c.Check(rest, equals, "")
+}
 func (s *Suite) Test_SplitIntoMkWords_VaruseSpace(c *check.C) {
 	words, rest := splitIntoMkWords(dummyLine, "${VAR:S/ /_/g}")
 	c.Check(words, deepEquals, []string{"${VAR:S/ /_/g}"})
 	c.Check(rest, equals, "")
+}
 func (s *Suite) Test_splitIntoShellTokens_Redirect(c *check.C) {
 	words, rest := splitIntoShellTokens(dummyLine, "echo 1>output 2>>append 3>|clobber 4>&5 6<input >>append")
 	c.Check(words, deepEquals, []string{
 		"echo",
 		"1>", "output",
 		"2>>", "append",
 		"3>|", "clobber",
 		"4>&", "5",
 		"6<", "input",
 		">>", "append"})
 	c.Check(rest, equals, "")
 	words, rest = splitIntoShellTokens(dummyLine, "echo 1> output 2>> append 3>| clobber 4>& 5 6< input >> append")
 	c.Check(words, deepEquals, []string{
 		"echo",
 		"1>", "output",
 		"2>>", "append",
 		"3>|", "clobber",
 		"4>&", "5",
 		"6<", "input",
 		">>", "append"})
 	c.Check(rest, equals, "")
+}
 func (s *Suite) TestChecklineMkShellCommandLine(c *check.C) {
 	s.UseCommandLine(c, "-Wall")
 	G.Mk = s.NewMkLines("fname",
 		"# dummy")
 	shline := NewShellLine(G.Mk.mklines[0])
 	shline.CheckShellCommandLine("@# Comment")
 	c.Check(s.Output(), equals, "")
 	shline.CheckShellCommandLine("uname=`uname`; echo $$uname; echo")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: Unknown shell command \"uname\".\n"+
 		"WARN: fname:1: Please switch to \"set -e\" mode before using a semicolon (the one after \"uname=`uname`\") to separate commands.\n"+
 		"WARN: fname:1: Unknown shell command \"echo\".\n"+
 		"WARN: fname:1: Unquoted shell variable \"uname\".\n"+
 		"WARN: fname:1: Unknown shell command \"echo\".\n")
 	s.RegisterTool(&Tool{Name: "echo", Predefined: true})
 	G.Mk = s.NewMkLines("fname",
 		"# dummy")
 	G.globalData.InitVartypes()
 	shline.CheckShellCommandLine("echo ${PKGNAME:Q}") // vucQuotPlain
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: PKGNAME may not be used in this file; it would be ok in Makefile, Makefile.*, *.mk.\n"+
 		"NOTE: fname:1: The :Q operator isn't necessary for ${PKGNAME} here.\n")
 	shline.CheckShellCommandLine("echo \"${CFLAGS:Q}\"") // vucQuotDquot
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: Please don't use the :Q operator in double quotes.\n"+
 		"WARN: fname:1: CFLAGS may not be used in this file; it would be ok in Makefile, Makefile.common, options.mk, *.mk.\n"+
 		"WARN: fname:1: Please use ${CFLAGS:M*:Q} instead of ${CFLAGS:Q} and make sure the variable appears outside of any quoting characters.\n")
 	shline.CheckShellCommandLine("echo '${COMMENT:Q}'") // vucQuotSquot
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: COMMENT may not be used in any file; it is a write-only variable.\n"+
 		"WARN: fname:1: Please move ${COMMENT:Q} outside of any quoting characters.\n")
 	shline.CheckShellCommandLine("echo target=$@ exitcode=$$? '$$' \"\\$$\"")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: Please use \"${.TARGET}\" instead of \"$@\".\n"+
 		"WARN: fname:1: The $? shell variable is often not available in \"set -e\" mode.\n")
 	shline.CheckShellCommandLine("echo $$@")
 	c.Check(s.Output(), equals, "WARN: fname:1: The $@ shell variable should only be used in double quotes.\n")
 	shline.CheckShellCommandLine("echo \"$$\"") // As seen by make(1); the shell sees: echo "$"
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: Pkglint parse error in ShTokenizer.ShAtom at \"$$\\\"\" (quoting=d)\n"+
-		"WARN: fname:1: Pkglint parse error in ShellLine.CheckShellCommand at \"$$\\\"\" (state=start)\n")
+		"WARN: fname:1: Pkglint ShellLine.CheckShellCommand: parse error at [\"]\n")
-	shline.CheckShellCommandLine("echo \"\\n\"") // As seen by make(1); the shell sees: echo "\n"
+	shline.CheckShellCommandLine("echo \"\\n\"")
 	c.Check(s.Output(), equals, "")
 	shline.CheckShellCommandLine("${RUN} for f in *.c; do echo $${f%.c}; done")
 	c.Check(s.Output(), equals, "")
 	shline.CheckShellCommandLine("${RUN} echo $${variable+set}")
 	c.Check(s.Output(), equals, "")
 	// Based on mail/thunderbird/Makefile, rev. 1.159
 	shline.CheckShellCommandLine("${RUN} subdir=\"`unzip -c \"$$e\" install.rdf | awk '/re/ { print \"hello\" }'`\"")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: Unknown shell command \"unzip\".\n"+
 		"WARN: fname:1: The exitcode of the left-hand-side command of the pipe operator is ignored.\n"+
 		"WARN: fname:1: Unknown shell command \"unzip\".\n"+
 		"WARN: fname:1: Unknown shell command \"awk\".\n")
 	// From mail/thunderbird/Makefile, rev. 1.159
 	shline.CheckShellCommandLine("" +
 		"${RUN} for e in ${XPI_FILES}; do " +
 		"  subdir=\"`${UNZIP_CMD} -c \"$$e\" install.rdf | awk '/^    <em:id>/ {sub(\".*<em:id>\",\"\");sub(\"</em:id>.*\",\"\");print;exit;}'`\" && " +
 		"  ${MKDIR} \"${WRKDIR}/extensions/$$subdir\" && " +
 		"  cd \"${WRKDIR}/extensions/$$subdir\" && " +
 		"  ${UNZIP_CMD} -aqo $$e; " +
 		"done")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: XPI_FILES is used but not defined. Spelling mistake?\n"+
 		"WARN: fname:1: UNZIP_CMD is used but not defined. Spelling mistake?\n"+
 		"WARN: fname:1: The exitcode of the left-hand-side command of the pipe operator is ignored.\n"+
 		"WARN: fname:1: UNZIP_CMD is used but not defined. Spelling mistake?\n"+
 		"WARN: fname:1: Unknown shell command \"awk\".\n"+
 		"WARN: fname:1: MKDIR is used but not defined. Spelling mistake?\n"+
 		"WARN: fname:1: Unknown shell command \"${MKDIR}\".\n"+
-		"WARN: fname:1: UNZIP_CMD is used but not defined. Spelling mistake?\n"+
+		"WARN: fname:1: MKDIR is used but not defined. Spelling mistake?\n"+
-		"WARN: fname:1: Unquoted shell variable \"e\".\n")
+		"WARN: fname:1: UNZIP_CMD is used but not defined. Spelling mistake?\n")
 	// From x11/wxGTK28/Makefile
 	shline.CheckShellCommandLine("" +
 		"set -e; cd ${WRKSRC}/locale; " +
 		"for lang in *.po; do " +
 		"  [ \"$${lang}\" = \"wxstd.po\" ] && continue; " +
 		"  ${TOOLS_PATH.msgfmt} -c -o \"$${lang%.po}.mo\" \"$${lang}\"; " +
 		"done")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: WRKSRC may not be used in this file; it would be ok in Makefile, Makefile.*, *.mk.\n"+
 		"WARN: fname:1: Unknown shell command \"[\".\n"+
 		"WARN: fname:1: Unknown shell command \"${TOOLS_PATH.msgfmt}\".\n")
 	shline.CheckShellCommandLine("@cp from to")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: The shell command \"cp\" should not be hidden.\n"+
 		"WARN: fname:1: Unknown shell command \"cp\".\n")
 	shline.CheckShellCommandLine("${RUN} ${INSTALL_DATA_DIR} share/pkgbase ${PREFIX}/share/pkgbase")
-	c.Check(s.Output(), equals, "NOTE: fname:1: You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= share/pkgbase\" instead of this command.\n")
+	c.Check(s.Output(), equals, ""+
 		"NOTE: fname:1: You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= share/pkgbase\" instead of \"${INSTALL_DATA_DIR}\".\n"+
 		"WARN: fname:1: The INSTALL_*_DIR commands can only handle one directory at a time.\n")
 	// See PR 46570, item "1. It does not"
 	shline.CheckShellCommandLine("for x in 1 2 3; do echo \"$$x\" || exit 1; done")
 	c.Check(s.Output(), equals, "") // No warning about missing error checking.
+}
 func (s *Suite) TestShellLine_CheckShelltext_nofix(c *check.C) {
 	s.UseCommandLine(c, "-Wall")
 	G.globalData.InitVartypes()
 	s.RegisterTool(&Tool{Name: "echo", Predefined: true})
 	G.Mk = s.NewMkLines("Makefile",
 		"\techo ${PKGNAME:Q}")
 	shline := NewShellLine(G.Mk.mklines[0])
 	c.Check(shline.line.raw[0].textnl, equals, "\techo ${PKGNAME:Q}\n")
 	c.Check(shline.line.raw[0].Lineno, equals, 1)
 @@ -261,26 +280,30 @@ func (s *Suite) TestShellLine_CheckShell
 	G.globalData.InitVartypes()
 	G.Mk = s.NewMkLines("fname",
 		"# dummy")
 	shline := NewShellLine(G.Mk.mklines[0])
 	// foobar="`echo \"foo   bar\"`"
 	text := "foobar=\"`echo \\\"foo   bar\\\"`\""
 	tokens, rest := splitIntoShellTokens(dummyLine, text)
 	c.Check(tokens, deepEquals, []string{text})
 	c.Check(rest, equals, "")
 	shline.CheckWord(text, false)
 	c.Check(s.Output(), equals, "WARN: fname:1: Unknown shell command \"echo\".\n")
 	shline.CheckShellCommandLine(text)
 	c.Check(s.Output(), equals, ""+ // No parse errors
 		"WARN: fname:1: Unknown shell command \"echo\".\n")
+}
 func (s *Suite) TestShellLine_CheckShelltext_DollarWithoutVariable(c *check.C) {
 	G.globalData.InitVartypes()
 	G.Mk = s.NewMkLines("fname",
 		"# dummy")
 	shline := NewShellLine(G.Mk.mklines[0])
 	s.RegisterTool(&Tool{Name: "pax", Varname: "PAX"})
 	G.Mk.tools["pax"] = true
 @@ -291,27 +314,27 @@ func (s *Suite) TestShellLine_CheckShell
+}
 func (s *Suite) Test_ShellLine_CheckWord(c *check.C) {
 	s.UseCommandLine(c, "-Wall")
 	G.globalData.InitVartypes()
 	shline := NewShellLine(NewMkLine(NewLine("fname", 1, "# dummy", nil)))
 	shline.CheckWord("${${list}}", false)
 	c.Check(s.Output(), equals, "") // No warning for variables that are completely indirect.
 	shline.CheckWord("${SED_FILE.${id}}", false)
-	c.Check(s.Output(), equals, "WARN: fname:1: SED_FILE.${id} is used but not defined. Spelling mistake?\n")
+	c.Check(s.Output(), equals, "") // No warning for variables that are partly indirect.
 	shline.CheckWord("\"$@\"", false)
 	c.Check(s.Output(), equals, "WARN: fname:1: Please use \"${.TARGET}\" instead of \"$@\".\n")
 	shline.CheckWord("${COMMENT:Q}", true)
 	c.Check(s.Output(), equals, "WARN: fname:1: COMMENT may not be used in any file; it is a write-only variable.\n")
 	shline.CheckWord("\"${DISTINFO_FILE:Q}\"", true)
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: DISTINFO_FILE may not be used in this file; it would be ok in Makefile, Makefile.*, *.mk.\n"+
 @@ -426,39 +449,52 @@ func (s *Suite) TestShellLine_CheckShell
 	shline := NewShellLine(NewMkLine(NewLine("Makefile", 85, "\t${RUN} uname=$$(uname)", nil)))
 	shline.CheckShellCommandLine(shline.mkline.Shellcmd())
 	c.Check(s.Output(), equals, "WARN: Makefile:85: Invoking subshells via $(...) is not portable enough.\n")
+}
 func (s *Suite) TestShellLine_CheckShellCommandLine_InstallDirs(c *check.C) {
 	shline := NewShellLine(NewMkLine(NewLine("Makefile", 85, "\t${RUN} ${INSTALL_DATA_DIR} ${DESTDIR}${PREFIX}/dir1 ${DESTDIR}${PREFIX}/dir2", nil)))
 	shline.CheckShellCommandLine(shline.mkline.Shellcmd())
 	c.Check(s.Output(), equals, ""+
-		"NOTE: Makefile:85: You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= dir1\" instead of this command.\n"+
+		"NOTE: Makefile:85: You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= dir1\" instead of \"${INSTALL_DATA_DIR}\".\n"+
-		"NOTE: Makefile:85: You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= dir2\" instead of this command.\n"+
+		"NOTE: Makefile:85: You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= dir2\" instead of \"${INSTALL_DATA_DIR}\".\n"+
 		"WARN: Makefile:85: The INSTALL_*_DIR commands can only handle one directory at a time.\n")
 	shline.CheckShellCommandLine("${INSTALL_DATA_DIR} -d -m 0755 ${DESTDIR}${PREFIX}/share/examples/gdchart")
 	// No warning about multiple directories, since 0755 is an option, not an argument.
 	c.Check(s.Output(), equals, ""+
 		"NOTE: Makefile:85: You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= share/examples/gdchart\" instead of \"${INSTALL_DATA_DIR}\".\n")
 	shline.CheckShellCommandLine("${INSTALL_DATA_DIR} -d -m 0755 ${DESTDIR}${PREFIX}/dir1 ${PREFIX}/dir2")
 	c.Check(s.Output(), equals, ""+
 		"NOTE: Makefile:85: You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= dir1\" instead of \"${INSTALL_DATA_DIR}\".\n"+
 		"NOTE: Makefile:85: You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= dir2\" instead of \"${INSTALL_DATA_DIR}\".\n"+
 		"WARN: Makefile:85: The INSTALL_*_DIR commands can only handle one directory at a time.\n")
+}
 func (s *Suite) TestShellLine_CheckShellCommandLine_InstallD(c *check.C) {
 	shline := NewShellLine(NewMkLine(NewLine("Makefile", 85, "\t${RUN} ${INSTALL} -d ${DESTDIR}${PREFIX}/dir1 ${DESTDIR}${PREFIX}/dir2", nil)))
 	shline.CheckShellCommandLine(shline.mkline.Shellcmd())
 	c.Check(s.Output(), equals, ""+
-		"WARN: Makefile:85: Please use AUTO_MKDIRS instead of \"${INSTALL} -d\".\n"+
+		"NOTE: Makefile:85: You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= dir1\" instead of \"${INSTALL} -d\".\n"+
-		"WARN: Makefile:85: Please use AUTO_MKDIRS instead of \"${INSTALL} -d\".\n")
+		"NOTE: Makefile:85: You can use AUTO_MKDIRS=yes or \"INSTALLATION_DIRS+= dir2\" instead of \"${INSTALL} -d\".\n")
+}
 func (s *Suite) TestShellLine_(c *check.C) {
 	tmpfile := s.CreateTmpFile(c, "Makefile", ""+
 		"# $"+"NetBSD$\n"+
 		"pre-install:\n"+
 		"\t"+"# comment\\\n"+
 		"\t"+"echo \"hello\"\n")
 	lines := LoadNonemptyLines(tmpfile, true)
 	NewMkLines(lines).Check()
 	c.Check(s.Output(), equals, "WARN: ~/Makefile:3--4: A shell comment does not stop at the end of line.\n")

--- pkgsrc/pkgtools/pkglint/files/Attic/globaldata.go 2016/06/10 19:42:42 1.10
+++ pkgsrc/pkgtools/pkglint/files/Attic/globaldata.go 2016/07/07 12:09:27 1.11

 @@ -506,26 +506,29 @@ func (gd *GlobalData) loadDeprecatedVars
 		"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.",
 		// June 2016
 		"USE_CROSSBASE": "Has been removed.",
+	}
+}
 // See `mk/tools/`.
 type Tool struct {
 	Name             string // e.g. "sed", "gzip"
 	Varname          string // e.g. "SED", "GZIP_CMD"
 	MustUseVarForm   bool   // True for `echo`, because of many differing implementations.
 	Predefined       bool   // This tool is used by the pkgsrc infrastructure, therefore the package does not need to add it to `USE_TOOLS` explicitly.
 	UsableAtLoadtime bool   // May be used after including `bsd.prefs.mk`.
+}
 type ToolRegistry struct {

--- pkgsrc/pkgtools/pkglint/files/Attic/vardefs.go 2016/06/19 18:03:29 1.10
+++ pkgsrc/pkgtools/pkglint/files/Attic/vardefs.go 2016/07/07 12:09:27 1.11

 @@ -134,103 +134,113 @@ func (gd *GlobalData) InitVartypes() {
 	acl("BUILDLINK_DIR", lkNone, CheckvarPathname, "*: use")
 	bl3list("BUILDLINK_FILES.*", lkShell, CheckvarPathmask)
 	acl("BUILDLINK_FILES_CMD.*", lkNone, CheckvarShellCommand, "")
 	acl("BUILDLINK_INCDIRS.*", lkShell, CheckvarPathname, "buildlink3.mk: default, append; Makefile, Makefile.common, *.mk: use")
 	acl("BUILDLINK_JAVA_PREFIX.*", lkNone, CheckvarPathname, "buildlink3.mk: set, use")
 	acl("BUILDLINK_LDADD.*", lkShell, CheckvarLdFlag, "builtin.mk: set, default, append, use; buildlink3.mk: append, use; Makefile, Makefile.common, *.mk: use")
 	acl("BUILDLINK_LDFLAGS", lkShell, CheckvarLdFlag, "*: use")
 	bl3list("BUILDLINK_LDFLAGS.*", lkShell, CheckvarLdFlag)
 	acl("BUILDLINK_LIBDIRS.*", lkShell, CheckvarPathname, "buildlink3.mk, builtin.mk: append; Makefile, Makefile.common, *.mk: use")
 	acl("BUILDLINK_LIBS.*", lkShell, CheckvarLdFlag, "buildlink3.mk: append")
 	acl("BUILDLINK_PASSTHRU_DIRS", lkShell, CheckvarPathname, "Makefile, Makefile.common, buildlink3.mk, hacks.mk: append")
 	acl("BUILDLINK_PASSTHRU_RPATHDIRS", lkShell, CheckvarPathname, "Makefile, Makefile.common, buildlink3.mk, hacks.mk: append")
 	acl("BUILDLINK_PKGSRCDIR.*", lkNone, CheckvarRelativePkgDir, "buildlink3.mk: default, use-loadtime")
-	acl("BUILDLINK_PREFIX.*", lkNone, CheckvarPathname, "builtin.mk: set, use; buildlink3.mk: use; Makefile, Makefile.common, *.mk: use")
+	acl("BUILDLINK_PREFIX.*", lkNone, CheckvarPathname, "builtin.mk: set, use; Makefile, Makefile.common, *.mk: use")
 	acl("BUILDLINK_RPATHDIRS.*", lkShell, CheckvarPathname, "buildlink3.mk: append")
 	acl("BUILDLINK_TARGETS", lkShell, CheckvarIdentifier, "")
 	acl("BUILDLINK_FNAME_TRANSFORM.*", lkNone, CheckvarSedCommands, "Makefile, buildlink3.mk, builtin.mk, hacks.mk: append")
 	acl("BUILDLINK_TRANSFORM", lkShell, CheckvarWrapperTransform, "*: append")
 	acl("BUILDLINK_TRANSFORM.*", lkShell, CheckvarWrapperTransform, "*: append")
 	acl("BUILDLINK_TREE", lkShell, CheckvarIdentifier, "buildlink3.mk: append")
 	acl("BUILD_DEFS", lkShell, CheckvarVarname, "Makefile, Makefile.common, options.mk: append")
 	acl("BUILD_DEPENDS", lkSpace, CheckvarDependencyWithPath, "Makefile, Makefile.common, *.mk: append")
 	pkglist("BUILD_DIRS", lkShell, CheckvarWrksrcSubdirectory)
 	pkglist("BUILD_ENV", lkShell, CheckvarShellWord)
 	sys("BUILD_MAKE_CMD", lkNone, CheckvarShellCommand)
 	pkglist("BUILD_MAKE_FLAGS", lkShell, CheckvarShellWord)
 	pkglist("BUILD_TARGET", lkShell, CheckvarIdentifier)
 	pkglist("BUILD_TARGET.*", lkShell, CheckvarIdentifier)
 	pkg("BUILD_USES_MSGFMT", lkNone, CheckvarYes)
 	acl("BUILTIN_PKG", lkNone, CheckvarIdentifier, "builtin.mk: set, use-loadtime, use")
 	acl("BUILTIN_PKG.*", lkNone, CheckvarPkgName, "builtin.mk: set, use-loadtime, use")
 	acl("BUILTIN_FIND_FILES_VAR", lkShell, CheckvarVarname, "builtin.mk: set")
 	acl("BUILTIN_FIND_FILES.*", lkShell, CheckvarPathname, "builtin.mk: set")
 	acl("BUILTIN_FIND_GREP.*", lkNone, CheckvarString, "builtin.mk: set")
 	acl("BUILTIN_FIND_HEADERS_VAR", lkShell, CheckvarVarname, "builtin.mk: set")
 	acl("BUILTIN_FIND_HEADERS.*", lkShell, CheckvarPathname, "builtin.mk: set")
 	acl("BUILTIN_FIND_LIBS", lkShell, CheckvarPathname, "builtin.mk: set")
 	acl("BUILTIN_IMAKE_CHECK", lkShell, CheckvarUnchecked, "builtin.mk: set")
 	acl("BUILTIN_IMAKE_CHECK.*", lkNone, CheckvarYesNo, "")
 	sys("BUILTIN_X11_TYPE", lkNone, CheckvarUnchecked)
 	sys("BUILTIN_X11_VERSION", lkNone, CheckvarUnchecked)
 	acl("CATEGORIES", lkShell, CheckvarCategory, "Makefile: set, append; Makefile.common: set, default, append")
 	sys("CC_VERSION", lkNone, CheckvarMessage)
 	sys("CC", lkNone, CheckvarShellCommand)
-	pkglist("CFLAGS*", lkShell, CheckvarCFlag) // may also be changed by the user
+	pkglist("CFLAGS", lkShell, CheckvarCFlag)   // may also be changed by the user
 	pkglist("CFLAGS.*", lkShell, CheckvarCFlag) // may also be changed by the user
 	acl("CHECK_BUILTIN", lkNone, CheckvarYesNo, "builtin.mk: default; Makefile: set")
-	acl("CHECK_BUILTIN.*", lkNone, CheckvarYesNo, "buildlink3.mk: set; builtin.mk: default; *: use-loadtime")
+	acl("CHECK_BUILTIN.*", lkNone, CheckvarYesNo, "Makefile, options.mk, buildlink3.mk: set; builtin.mk: default; *: use-loadtime")
 	acl("CHECK_FILES_SKIP", lkShell, CheckvarBasicRegularExpression, "Makefile, Makefile.common: append")
 	pkg("CHECK_FILES_SUPPORTED", lkNone, CheckvarYesNo)
 	usr("CHECK_HEADERS", lkNone, CheckvarYesNo)
 	pkglist("CHECK_HEADERS_SKIP", lkShell, CheckvarPathmask)
 	usr("CHECK_INTERPRETER", lkNone, CheckvarYesNo)
 	pkglist("CHECK_INTERPRETER_SKIP", lkShell, CheckvarPathmask)
 	usr("CHECK_PERMS", lkNone, CheckvarYesNo)
 	pkglist("CHECK_PERMS_SKIP", lkShell, CheckvarPathmask)
 	usr("CHECK_PORTABILITY", lkNone, CheckvarYesNo)
 	pkglist("CHECK_PORTABILITY_SKIP", lkShell, CheckvarPathmask)
 	acl("CHECK_SHLIBS", lkNone, CheckvarYesNo, "Makefile: set")
 	pkglist("CHECK_SHLIBS_SKIP", lkShell, CheckvarPathmask)
 	acl("CHECK_SHLIBS_SUPPORTED", lkNone, CheckvarYesNo, "Makefile: set")
 	pkglist("CHECK_WRKREF_SKIP", lkShell, CheckvarPathmask)
 	pkg("CMAKE_ARG_PATH", lkNone, CheckvarPathname)
 	pkglist("CMAKE_ARGS", lkShell, CheckvarShellWord)
 	pkglist("CMAKE_ARGS.*", lkShell, CheckvarShellWord)
 	acl("COMMENT", lkNone, CheckvarComment, "Makefile, Makefile.common: set, append")
 	acl("COMPILER_RPATH_FLAG", lkNone, enum("-Wl,-rpath"), "*: use")
 	pkglist("CONFIGURE_ARGS", lkShell, CheckvarShellWord)
 	pkglist("CONFIGURE_ARGS.*", lkShell, CheckvarShellWord)
 	pkglist("CONFIGURE_DIRS", lkShell, CheckvarWrksrcSubdirectory)
 	acl("CONFIGURE_ENV", lkShell, CheckvarShellWord, "Makefile, Makefile.common: append, set, use; buildlink3.mk, builtin.mk: append; *.mk: append, use")
 	acl("CONFIGURE_ENV.*", lkShell, CheckvarShellWord, "Makefile, Makefile.common: append, set, use; buildlink3.mk, builtin.mk: append; *.mk: append, use")
 	pkg("CONFIGURE_HAS_INFODIR", lkNone, CheckvarYesNo)
 	pkg("CONFIGURE_HAS_LIBDIR", lkNone, CheckvarYesNo)
 	pkg("CONFIGURE_HAS_MANDIR", lkNone, CheckvarYesNo)
 	pkg("CONFIGURE_SCRIPT", lkNone, CheckvarPathname)
 	acl("CONFIG_GUESS_OVERRIDE", lkShell, CheckvarPathmask, "Makefile, Makefile.common: set, append")
 	acl("CONFIG_STATUS_OVERRIDE", lkShell, CheckvarPathmask, "Makefile, Makefile.common: set, append")
 	acl("CONFIG_SHELL", lkNone, CheckvarPathname, "Makefile, Makefile.common: set")
 	acl("CONFIG_SUB_OVERRIDE", lkShell, CheckvarPathmask, "Makefile, Makefile.common: set, append")
 	pkglist("CONFLICTS", lkSpace, CheckvarDependency)
 	pkglist("CONF_FILES", lkShell, CheckvarShellWord)
 	pkg("CONF_FILES_MODE", lkNone, enum("0644 0640 0600 0400"))
 	pkglist("CONF_FILES_PERMS", lkShell, CheckvarPerms)
 	sys("COPY", lkNone, enum("-c")) // The flag that tells ${INSTALL} to copy a file
 	sys("CPP", lkNone, CheckvarShellCommand)
-	pkglist("CPPFLAGS*", lkShell, CheckvarCFlag)
+	pkglist("CPPFLAGS", lkShell, CheckvarCFlag)
 	pkglist("CPPFLAGS.*", lkShell, CheckvarCFlag)
 	acl("CRYPTO", lkNone, CheckvarYes, "Makefile: set")
 	sys("CXX", lkNone, CheckvarShellCommand)
-	pkglist("CXXFLAGS*", lkShell, CheckvarCFlag)
+	pkglist("CXXFLAGS", lkShell, CheckvarCFlag)
 	pkglist("CXXFLAGS.*", lkShell, CheckvarCFlag)
 	acl("DEINSTALL_FILE", lkNone, CheckvarPathname, "Makefile: set")
 	acl("DEINSTALL_SRC", lkShell, CheckvarPathname, "Makefile: set; Makefile.common: default, set")
 	acl("DEINSTALL_TEMPLATES", lkShell, CheckvarPathname, "Makefile: set, append; Makefile.common: set, default, append")
 	sys("DELAYED_ERROR_MSG", lkNone, CheckvarShellCommand)
 	sys("DELAYED_WARNING_MSG", lkNone, CheckvarShellCommand)
 	pkglist("DEPENDS", lkSpace, CheckvarDependencyWithPath)
 	usr("DEPENDS_TARGET", lkShell, CheckvarIdentifier)
-	acl("DESCR_SRC", lkShell, CheckvarPathname, "Makefile: set; Makefile.common: default, set")
+	acl("DESCR_SRC", lkShell, CheckvarPathname, "Makefile: set, append; Makefile.common: default, set")
 	sys("DESTDIR", lkNone, CheckvarPathname)
 	acl("DESTDIR_VARNAME", lkNone, CheckvarVarname, "Makefile, Makefile.common: set")
 	sys("DEVOSSAUDIO", lkNone, CheckvarPathname)
 	sys("DEVOSSSOUND", lkNone, CheckvarPathname)
 	pkglist("DISTFILES", lkShell, CheckvarFilename)
 	pkg("DISTINFO_FILE", lkNone, CheckvarRelativePkgPath)
 	pkg("DISTNAME", lkNone, CheckvarFilename)
 	pkg("DIST_SUBDIR", lkNone, CheckvarPathname)
 	acl("DJB_BUILD_ARGS", lkShell, CheckvarShellWord, "")
 	acl("DJB_BUILD_TARGETS", lkShell, CheckvarIdentifier, "")
 	acl("DJB_CONFIG_CMDS", lkNone, CheckvarShellCommands, "options.mk: set")
 	acl("DJB_CONFIG_DIRS", lkShell, CheckvarWrksrcSubdirectory, "")
 	acl("DJB_CONFIG_HOME", lkNone, CheckvarFilename, "")
 @@ -366,54 +376,58 @@ func (gd *GlobalData) InitVartypes() {
 	acl("IS_BUILTIN.*", lkNone, CheckvarYesNoIndirectly, "builtin.mk: set, use-loadtime, use")
 	sys("JAVA_BINPREFIX", lkNone, CheckvarPathname)
 	pkg("JAVA_CLASSPATH", lkNone, CheckvarShellWord)
 	pkg("JAVA_HOME", lkNone, CheckvarPathname)
 	pkg("JAVA_NAME", lkNone, CheckvarFilename)
 	pkglist("JAVA_UNLIMIT", lkShell, enum("cmdsize datasize stacksize"))
 	pkglist("JAVA_WRAPPERS", lkSpace, CheckvarFilename)
 	pkg("JAVA_WRAPPER_BIN.*", lkNone, CheckvarPathname)
 	sys("KRB5BASE", lkNone, CheckvarPathname)
 	acl("KRB5_ACCEPTED", lkShell, enum("heimdal mit-krb5"), "")
 	usr("KRB5_DEFAULT", lkNone, enum("heimdal mit-krb5"))
 	sys("KRB5_TYPE", lkNone, CheckvarIdentifier)
 	sys("LD", lkNone, CheckvarShellCommand)
-	pkglist("LDFLAGS*", lkShell, CheckvarLdFlag)
+	pkglist("LDFLAGS", lkShell, CheckvarLdFlag)
 	pkglist("LDFLAGS.*", lkShell, CheckvarLdFlag)
 	sys("LIBGRP", lkNone, CheckvarUserGroupName)
 	sys("LIBMODE", lkNone, CheckvarFileMode)
 	sys("LIBOWN", lkNone, CheckvarUserGroupName)
 	sys("LIBOSSAUDIO", lkNone, CheckvarPathname)
-	pkglist("LIBS*", lkShell, CheckvarLdFlag)
+	pkglist("LIBS", lkShell, CheckvarLdFlag)
 	pkglist("LIBS.*", lkShell, CheckvarLdFlag)
 	sys("LIBTOOL", lkNone, CheckvarShellCommand)
 	acl("LIBTOOL_OVERRIDE", lkShell, CheckvarPathmask, "Makefile: set, append")
 	pkglist("LIBTOOL_REQD", lkShell, CheckvarVersion)
-	acl("LICENCE", lkNone, CheckvarLicense, "Makefile, Makefile.common: set; options.mk: set")
+	acl("LICENCE", lkNone, CheckvarLicense, "Makefile, Makefile.common, options.mk: set")
-	acl("LICENSE", lkNone, CheckvarLicense, "Makefile, Makefile.common: set; options.mk: set")
+	acl("LICENSE", lkNone, CheckvarLicense, "Makefile, Makefile.common, options.mk: set")
 	pkg("LICENSE_FILE", lkNone, CheckvarPathname)
 	sys("LINKER_RPATH_FLAG", lkNone, CheckvarShellWord)
 	sys("LOWER_OPSYS", lkNone, CheckvarIdentifier)
 	acl("LTCONFIG_OVERRIDE", lkShell, CheckvarPathmask, "Makefile: set, append; Makefile.common: append")
 	sys("MACHINE_ARCH", lkNone, enumMachineArch)
 	sys("MACHINE_GNU_ARCH", lkNone, enumMachineGnuArch)
 	sys("MACHINE_GNU_PLATFORM", lkNone, CheckvarMachineGnuPlatform)
 	sys("MACHINE_PLATFORM", lkNone, CheckvarMachinePlatform)
 	acl("MAINTAINER", lkNone, CheckvarMailAddress, "Makefile: set; Makefile.common: default")
 	sys("MAKE", lkNone, CheckvarShellCommand)
 	pkglist("MAKEFLAGS", lkShell, CheckvarShellWord)
-	acl("MAKEVARS", lkShell, CheckvarVarname, "builtin.mk: append; buildlink3.mk: append; hacks.mk: append")
+	acl("MAKEVARS", lkShell, CheckvarVarname, "buildlink3.mk, builtin.mk, hacks.mk: append")
 	pkglist("MAKE_DIRS", lkShell, CheckvarPathname)
 	pkglist("MAKE_DIRS_PERMS", lkShell, CheckvarPerms)
-	acl("MAKE_ENV", lkShell, CheckvarShellWord, "Makefile: append, set, use; Makefile.common: append, set, use; buildlink3.mk: append; builtin.mk: append; *.mk: append, use")
+	acl("MAKE_ENV", lkShell, CheckvarShellWord, "Makefile, Makefile.common: append, set, use; buildlink3.mk, builtin.mk: append; *.mk: append, use")
 	acl("MAKE_ENV.*", lkShell, CheckvarShellWord, "Makefile, Makefile.common: append, set, use; buildlink3.mk, builtin.mk: append; *.mk: append, use")
 	pkg("MAKE_FILE", lkNone, CheckvarPathname)
 	pkglist("MAKE_FLAGS", lkShell, CheckvarShellWord)
 	pkglist("MAKE_FLAGS.*", lkShell, CheckvarShellWord)
 	usr("MAKE_JOBS", lkNone, CheckvarInteger)
 	pkg("MAKE_JOBS_SAFE", lkNone, CheckvarYesNo)
 	pkg("MAKE_PROGRAM", lkNone, CheckvarShellCommand)
 	acl("MANCOMPRESSED", lkNone, CheckvarYesNo, "Makefile: set; Makefile.common: default, set")
 	acl("MANCOMPRESSED_IF_MANZ", lkNone, CheckvarYes, "Makefile: set; Makefile.common: default, set")
 	sys("MANGRP", lkNone, CheckvarUserGroupName)
 	sys("MANMODE", lkNone, CheckvarFileMode)
 	sys("MANOWN", lkNone, CheckvarUserGroupName)
 	pkglist("MASTER_SITES", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_APACHE", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_BACKUP", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_CYGWIN", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_DEBIAN", lkShell, CheckvarFetchURL)
 @@ -435,27 +449,27 @@ func (gd *GlobalData) InitVartypes() {
 	sys("MASTER_SITE_NETLIB", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_OPENOFFICE", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_OSDN", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_PERL_CPAN", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_R_CRAN", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_RUBYGEMS", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_SOURCEFORGE", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_SUNSITE", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_SUSE", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_TEX_CTAN", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_XCONTRIB", lkShell, CheckvarFetchURL)
 	sys("MASTER_SITE_XEMACS", lkShell, CheckvarFetchURL)
 	pkglist("MESSAGE_SRC", lkShell, CheckvarPathname)
-	acl("MESSAGE_SUBST", lkShell, CheckvarShellWord, "Makefile.common: append; Makefile: append; options.mk: append")
+	acl("MESSAGE_SUBST", lkShell, CheckvarShellWord, "Makefile, Makefile.common, options.mk: append")
 	pkg("META_PACKAGE", lkNone, CheckvarYes)
 	sys("MISSING_FEATURES", lkShell, CheckvarIdentifier)
 	acl("MYSQL_VERSIONS_ACCEPTED", lkShell, enum("51 55 56"), "Makefile: set")
 	usr("MYSQL_VERSION_DEFAULT", lkNone, CheckvarVersion)
 	sys("NM", lkNone, CheckvarShellCommand)
 	sys("NONBINMODE", lkNone, CheckvarFileMode)
 	pkg("NOT_FOR_COMPILER", lkShell, enum("ccache ccc clang distcc f2c gcc hp icc ido mipspro mipspro-ucode pcc sunpro xlc"))
 	pkglist("NOT_FOR_PLATFORM", lkSpace, CheckvarMachinePlatformPattern)
 	pkg("NOT_FOR_UNPRIVILEGED", lkNone, CheckvarYesNo)
 	acl("NO_BIN_ON_CDROM", lkNone, CheckvarRestricted, "Makefile, Makefile.common: set")
 	acl("NO_BIN_ON_FTP", lkNone, CheckvarRestricted, "Makefile, Makefile.common: set")
 	acl("NO_BUILD", lkNone, CheckvarYes, "Makefile, Makefile.common: set; Makefile.*: default, set")
 	pkg("NO_CHECKSUM", lkNone, CheckvarYes)
 @@ -475,28 +489,28 @@ func (gd *GlobalData) InitVartypes() {
 	sys("OS_VERSION", lkNone, CheckvarVersion)
 	pkg("OVERRIDE_DIRDEPTH*", lkNone, CheckvarInteger)
 	pkg("OVERRIDE_GNU_CONFIG_SCRIPTS", lkNone, CheckvarYes)
 	acl("OWNER", lkNone, CheckvarMailAddress, "Makefile: set; Makefile.common: default")
 	pkglist("OWN_DIRS", lkShell, CheckvarPathname)
 	pkglist("OWN_DIRS_PERMS", lkShell, CheckvarPerms)
 	sys("PAMBASE", lkNone, CheckvarPathname)
 	usr("PAM_DEFAULT", lkNone, enum("linux-pam openpam solaris-pam"))
 	acl("PATCHDIR", lkNone, CheckvarRelativePkgPath, "Makefile: set; Makefile.common: default, set")
 	pkglist("PATCHFILES", lkShell, CheckvarFilename)
 	acl("PATCH_ARGS", lkShell, CheckvarShellWord, "")
 	acl("PATCH_DIST_ARGS", lkShell, CheckvarShellWord, "Makefile: set, append")
 	acl("PATCH_DIST_CAT", lkNone, CheckvarShellCommand, "")
-	acl("PATCH_DIST_STRIP*", lkNone, CheckvarShellWord, "Makefile, Makefile.common: set; buildlink3.mk:; builtin.mk:; *.mk: set")
+	acl("PATCH_DIST_STRIP*", lkNone, CheckvarShellWord, "buildlink3.mk, builtin.mk:; Makefile, Makefile.common, *.mk: set")
-	acl("PATCH_SITES", lkShell, CheckvarFetchURL, "Makefile: set; options.mk: set; Makefile.common: set")
+	acl("PATCH_SITES", lkShell, CheckvarFetchURL, "Makefile, Makefile.common, options.mk: set")
 	acl("PATCH_STRIP", lkNone, CheckvarShellWord, "")
 	pkg("PERL5_USE_PACKLIST", lkNone, CheckvarYesNo)
 	acl("PERL5_PACKLIST", lkShell, CheckvarPerl5Packlist, "Makefile: set; options.mk: set, append")
 	acl("PERL5_PACKLIST_DIR", lkNone, CheckvarPathname, "")
 	sys("PGSQL_PREFIX", lkNone, CheckvarPathname)
 	acl("PGSQL_VERSIONS_ACCEPTED", lkShell, enum("91 92 93 94"), "")
 	usr("PGSQL_VERSION_DEFAULT", lkNone, CheckvarVersion)
 	sys("PG_LIB_EXT", lkNone, enum("dylib so"))
 	sys("PGSQL_TYPE", lkNone, enum("postgresql81-client postgresql80-client"))
 	sys("PGPKGSRCDIR", lkNone, CheckvarPathname)
 	sys("PHASE_MSG", lkNone, CheckvarShellCommand)
 	usr("PHP_VERSION_REQD", lkNone, CheckvarVersion)
 	sys("PKGBASE", lkNone, CheckvarIdentifier)
 @@ -538,65 +552,65 @@ func (gd *GlobalData) InitVartypes() {
 	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("openjdk8 oracle-jdk8 openjdk7 sun-jdk7 sun-jdk6 jdk16 jdk15 kaffe") // See mk/java-vm.mk:/_PKG_JVMS/
 	sys("PKG_JVM", lkNone, jvms)
 	acl("PKG_JVMS_ACCEPTED", lkShell, jvms, "Makefile: set; Makefile.common: default, set")
 	usr("PKG_JVM_DEFAULT", lkNone, jvms)
 	acl("PKG_LEGACY_OPTIONS", lkShell, CheckvarOption, "")
 	acl("PKG_LIBTOOL", lkNone, CheckvarPathname, "Makefile: set")
 	acl("PKG_OPTIONS", lkSpace, CheckvarOption, "bsd.options.mk: set; *: use-loadtime, use")
 	usr("PKG_OPTIONS.*", lkSpace, CheckvarOption)
 	acl("PKG_OPTIONS_DEPRECATED_WARNINGS", lkShell, CheckvarShellWord, "")
-	acl("PKG_OPTIONS_GROUP.*", lkSpace, CheckvarOption, "options.mk: set; Makefile: set")
+	acl("PKG_OPTIONS_GROUP.*", lkSpace, CheckvarOption, "Makefile, options.mk: set, append")
-	acl("PKG_OPTIONS_LEGACY_OPTS", lkSpace, CheckvarUnchecked, "Makefile, Makefile.common: append; options.mk: append")
+	acl("PKG_OPTIONS_LEGACY_OPTS", lkSpace, CheckvarUnchecked, "Makefile, Makefile.common, options.mk: append")
-	acl("PKG_OPTIONS_LEGACY_VARS", lkSpace, CheckvarUnchecked, "Makefile, Makefile.common: append; options.mk: append")
+	acl("PKG_OPTIONS_LEGACY_VARS", lkSpace, CheckvarUnchecked, "Makefile, Makefile.common, options.mk: append")
 	acl("PKG_OPTIONS_NONEMPTY_SETS", lkSpace, CheckvarIdentifier, "")
 	acl("PKG_OPTIONS_OPTIONAL_GROUPS", lkSpace, CheckvarIdentifier, "options.mk: set, append")
-	acl("PKG_OPTIONS_REQUIRED_GROUPS", lkSpace, CheckvarIdentifier, "options.mk: set; Makefile: set")
+	acl("PKG_OPTIONS_REQUIRED_GROUPS", lkSpace, CheckvarIdentifier, "Makefile, options.mk: set")
 	acl("PKG_OPTIONS_SET.*", lkSpace, CheckvarOption, "")
-	acl("PKG_OPTIONS_VAR", lkNone, CheckvarPkgOptionsVar, "options.mk: set; Makefile, Makefile.common: set; bsd.options.mk: use-loadtime")
+	acl("PKG_OPTIONS_VAR", lkNone, CheckvarPkgOptionsVar, "Makefile, Makefile.common, options.mk: set; bsd.options.mk: use-loadtime")
 	acl("PKG_PRESERVE", lkNone, CheckvarYes, "Makefile: set")
 	acl("PKG_SHELL", lkNone, CheckvarPathname, "Makefile, Makefile.common: set")
 	acl("PKG_SHELL.*", lkNone, CheckvarPathname, "Makefile, Makefile.common: set")
 	acl("PKG_SHLIBTOOL", lkNone, CheckvarPathname, "")
 	pkglist("PKG_SKIP_REASON", lkShell, CheckvarShellWord)
-	acl("PKG_SUGGESTED_OPTIONS", lkShell, CheckvarOption, "options.mk: set, append; Makefile: set, append; Makefile.common: set")
+	acl("PKG_SUGGESTED_OPTIONS", lkShell, CheckvarOption, "Makefile, Makefile.common, options.mk: set, append")
-	acl("PKG_SUPPORTED_OPTIONS", lkShell, CheckvarOption, "options.mk: set, append, use; Makefile: set, append; Makefile.common: set")
+	acl("PKG_SUPPORTED_OPTIONS", lkShell, CheckvarOption, "Makefile: set, append; Makefile.common: set; options.mk: set, append, use")
 	pkg("PKG_SYSCONFDIR*", lkNone, CheckvarPathname)
 	pkglist("PKG_SYSCONFDIR_PERMS", lkShell, CheckvarPerms)
 	sys("PKG_SYSCONFBASEDIR", lkNone, CheckvarPathname)
 	pkg("PKG_SYSCONFSUBDIR", lkNone, CheckvarPathname)
 	acl("PKG_SYSCONFVAR", lkNone, CheckvarIdentifier, "") // FIXME: name/type mismatch.
 	acl("PKG_UID", lkNone, CheckvarInteger, "Makefile: set")
 	acl("PKG_USERS", lkShell, CheckvarShellWord, "Makefile: set, append")
 	pkg("PKG_USERS_VARS", lkShell, CheckvarVarname)
 	acl("PKG_USE_KERBEROS", lkNone, CheckvarYes, "Makefile, Makefile.common: set")
 	// PLIST.* has special handling code
 	pkglist("PLIST_VARS", lkShell, CheckvarIdentifier)
 	pkglist("PLIST_SRC", lkShell, CheckvarRelativePkgPath)
 	pkglist("PLIST_SUBST", lkShell, CheckvarShellWord)
 	acl("PLIST_TYPE", lkNone, enum("dynamic static"), "")
 	acl("PREPEND_PATH", lkShell, CheckvarPathname, "")
 	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")
+	acl("PTHREAD_OPTS", lkShell, enum("native optional require"), "Makefile: set, append; Makefile.common, buildlink3.mk: append")
 	sys("PTHREAD_TYPE", lkNone, CheckvarIdentifier) // Or "native" or "none".
 	pkg("PY_PATCHPLIST", lkNone, CheckvarYes)
 	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")
 @@ -628,27 +642,28 @@ func (gd *GlobalData) InitVartypes() {
 	usr("SETUID_ROOT_PERMS", lkShell, CheckvarShellWord)
 	sys("SHAREGRP", lkNone, CheckvarUserGroupName)
 	sys("SHAREMODE", lkNone, CheckvarFileMode)
 	sys("SHAREOWN", lkNone, CheckvarUserGroupName)
 	sys("SHCOMMENT", lkNone, CheckvarShellCommand)
 	acl("SHLIB_HANDLING", lkNone, enum("YES NO no"), "")
 	acl("SHLIBTOOL", lkNone, CheckvarShellCommand, "Makefile: use")
 	acl("SHLIBTOOL_OVERRIDE", lkShell, CheckvarPathmask, "Makefile: set, append; Makefile.common: append")
 	acl("SITES.*", lkShell, CheckvarFetchURL, "Makefile, Makefile.common, options.mk: set, append, use")
 	pkglist("SPECIAL_PERMS", lkShell, CheckvarPerms)
 	sys("STEP_MSG", lkNone, CheckvarShellCommand)
 	acl("SUBDIR", lkShell, CheckvarFilename, "Makefile: append; *:")
 	acl("SUBST_CLASSES", lkShell, CheckvarIdentifier, "Makefile: set, append; *: append")
-	acl("SUBST_FILES.*", lkShell, CheckvarPathmask, "Makefile: set, append; Makefile.*, *.mk: set, append")
+	acl("SUBST_CLASSES.*", lkShell, CheckvarIdentifier, "Makefile: set, append; *: append")
 	acl("SUBST_FILES.*", lkShell, CheckvarPathmask, "Makefile, Makefile.*, *.mk: set, append")
 	acl("SUBST_FILTER_CMD.*", lkNone, CheckvarShellCommand, "Makefile, Makefile.*, *.mk: set")
 	acl("SUBST_MESSAGE.*", lkNone, CheckvarMessage, "Makefile, Makefile.*, *.mk: set")
 	acl("SUBST_SED.*", lkNone, CheckvarSedCommands, "Makefile, Makefile.*, *.mk: set, append")
 	pkg("SUBST_STAGE.*", lkNone, CheckvarStage)
 	pkglist("SUBST_VARS.*", lkShell, CheckvarVarname)
 	pkglist("SUPERSEDES", lkSpace, CheckvarDependency)
 	pkglist("TEST_DIRS", lkShell, CheckvarWrksrcSubdirectory)
 	pkglist("TEST_ENV", lkShell, CheckvarShellWord)
 	acl("TEST_TARGET", lkShell, CheckvarIdentifier, "Makefile: set; Makefile.common: default, set; options.mk: set, append")
 	acl("TEX_ACCEPTED", lkShell, enum("teTeX1 teTeX2 teTeX3"), "Makefile, Makefile.common: set")
 	acl("TEX_DEPMETHOD", lkNone, enum("build run"), "Makefile, Makefile.common: set")
 	pkglist("TEXINFO_REQD", lkShell, CheckvarVersion)
 	acl("TOOL_DEPENDS", lkSpace, CheckvarDependencyWithPath, "Makefile, Makefile.common, *.mk: append")
 @@ -662,43 +677,44 @@ 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)
 	usr("USE_DESTDIR", lkNone, CheckvarYes)
-	pkg("USE_FEATURES", lkShell, CheckvarIdentifier)
+	pkglist("USE_FEATURES", lkShell, CheckvarIdentifier)
 	pkg("USE_GCC_RUNTIME", lkNone, CheckvarYesNo)
 	pkg("USE_GNU_CONFIGURE_HOST", lkNone, CheckvarYesNo)
-	acl("USE_GNU_ICONV", lkNone, CheckvarYes, "Makefile, Makefile.common: set; options.mk: set")
+	acl("USE_GNU_ICONV", lkNone, CheckvarYes, "Makefile, Makefile.common, options.mk: set")
 	acl("USE_IMAKE", lkNone, CheckvarYes, "Makefile: set")
 	pkg("USE_JAVA", lkNone, enum("run yes build"))
 	pkg("USE_JAVA2", lkNone, enum("YES yes no 1.4 1.5 6 7 8"))
 	acl("USE_LANGUAGES", lkShell, enum("ada c c99 c++ fortran fortran77 java objc"), "Makefile, Makefile.common, options.mk: set, append")
 	pkg("USE_LIBTOOL", lkNone, CheckvarYes)
 	pkg("USE_MAKEINFO", lkNone, CheckvarYes)
 	pkg("USE_MSGFMT_PLURALS", lkNone, CheckvarYes)
 	pkg("USE_NCURSES", lkNone, CheckvarYes)
 	pkg("USE_OLD_DES_API", lkNone, CheckvarYesNo)
 	pkg("USE_PKGINSTALL", lkNone, CheckvarYes)
 	pkg("USE_PKGLOCALEDIR", lkNone, CheckvarYesNo)
 	usr("USE_PKGSRC_GCC", lkNone, CheckvarYes)
 	acl("USE_TOOLS", lkShell, CheckvarTool, "*: append")
 	acl("USE_TOOLS.*", lkShell, CheckvarTool, "*: append")
 	pkg("USE_X11", lkNone, CheckvarYes)
 	sys("WARNING_MSG", lkNone, CheckvarShellCommand)
 	sys("WARNING_CAT", lkNone, CheckvarShellCommand)
 	acl("WRAPPER_REORDER_CMDS", lkShell, CheckvarWrapperReorder, "Makefile, Makefile.common, buildlink3.mk: append")
 	acl("WRAPPER_TRANSFORM_CMDS", lkShell, CheckvarWrapperTransform, "Makefile, Makefile.common, buildlink3.mk: append")
 	sys("WRKDIR", lkNone, CheckvarPathname)
 	pkg("WRKSRC", lkNone, CheckvarWrkdirSubdirectory)
 	sys("X11_PKGSRCDIR.*", lkNone, CheckvarPathname)
 	usr("XAW_TYPE", lkNone, enum("3d neXtaw standard xpm"))
 	acl("XMKMF_FLAGS", lkShell, CheckvarShellWord, "")
+}
 func enum(values string) *VarChecker {
 @@ -743,33 +759,38 @@ func acl(varname string, kindOfList Kind
 	if varparam == "" || varparam == "*" {
 		G.globalData.vartypes[varbase] = vtype
+	}
 	if varparam == "*" || varparam == ".*" {
 		G.globalData.vartypes[varbase+".*"] = vtype
+	}
+}
 func parseAclEntries(varname string, aclentries string) []AclEntry {
 	if aclentries == "" {
 		return nil
+	}
 	var result []AclEntry
 	prevperms := "(first)"
 	for _, arg := range strings.Split(aclentries, "; ") {
 		var globs, perms string
 		if fields := strings.SplitN(arg, ": ", 2); len(fields) == 2 {
 			globs, perms = fields[0], fields[1]
 		} else {
 			globs = strings.TrimSuffix(arg, ":")
+		}
 		if perms == prevperms {
 			fmt.Printf("Repeated permissions for %s: %s\n", varname, perms)
+		}
 		prevperms = perms
 		var permissions AclPermissions
 		for _, perm := range strings.Split(perms, ", ") {
 			switch perm {
 			case "append":
 				permissions |= aclpAppend
 			case "default":
 				permissions |= aclpSetDefault
 			case "set":
 				permissions |= aclpSet
 			case "use":
 				permissions |= aclpUse
 			case "use-loadtime":
 				permissions |= aclpUseLoadtime

--- pkgsrc/pkgtools/pkglint/files/Attic/vartypecheck_test.go 2016/06/10 19:42:42 1.10
+++ pkgsrc/pkgtools/pkglint/files/Attic/vartypecheck_test.go 2016/07/07 12:09:27 1.11

 @@ -279,29 +279,31 @@ func (s *Suite) TestVartypeCheck_Pathlis
 func (s *Suite) Test_VartypeCheck_Perms(c *check.C) {
 	runVartypeChecks("CONF_FILES_PERMS", opAssignAppend, (*VartypeCheck).Perms,
 		"root",
 		"${ROOT_USER}",
 		"ROOT_USER",
 		"${REAL_ROOT_USER}")
 	c.Check(s.Output(), equals, "ERROR: fname:2: ROOT_USER must not be used in permission definitions. Use REAL_ROOT_USER instead.\n")
+}
 func (s *Suite) TestVartypeCheck_PkgOptionsVar(c *check.C) {
 	runVartypeChecks("PKG_OPTIONS_VAR.screen", opAssign, (*VartypeCheck).PkgOptionsVar,
-		"PKG_OPTIONS.${PKGBASE}")
+		"PKG_OPTIONS.${PKGBASE}",
 		"PKG_OPTIONS.anypkgbase")
-	c.Check(s.Output(), equals, "ERROR: fname:1: PKGBASE must not be used in PKG_OPTIONS_VAR.\n")
+	c.Check(s.Output(), equals, ""+
 		"ERROR: fname:1: PKGBASE must not be used in PKG_OPTIONS_VAR.\n")
+}
 func (s *Suite) TestVartypeCheck_PkgRevision(c *check.C) {
 	runVartypeChecks("PKGREVISION", opAssign, (*VartypeCheck).PkgRevision,
 		"3a")
 	c.Check(s.Output(), equals, ""+
 		"WARN: fname:1: PKGREVISION must be a positive integer number.\n"+
 		"ERROR: fname:1: PKGREVISION only makes sense directly in the package Makefile.\n")
 	runVartypeChecksFname("Makefile", "PKGREVISION", opAssign, (*VartypeCheck).PkgRevision,
 		"3")

--- pkgsrc/pkgtools/pkglint/files/Attic/licenses.go 2016/06/05 11:24:32 1.4
+++ pkgsrc/pkgtools/pkglint/files/Attic/licenses.go 2016/07/07 12:09:27 1.5

	@@ -46,16 +46,21 @@ func checklineLicense(line *MkLine, valu		@@ -46,16 +46,21 @@ func checklineLicense(line *MkLine, valu
46	}	46	}
47		47
48	if !fileExists(licenseFile) {	48	if !fileExists(licenseFile) {
49	line.Warn1("License file %s does not exist.", cleanpath(licenseFile))	49	line.Warn1("License file %s does not exist.", cleanpath(licenseFile))
50	}	50	}
51		51
52	switch license {	52	switch license {
53	case "fee-based-commercial-use",	53	case "fee-based-commercial-use",
54	"no-commercial-use",	54	"no-commercial-use",
55	"no-profit",	55	"no-profit",
56	"no-redistribution",	56	"no-redistribution",
57	"shareware":	57	"shareware":
58	line.Warn1("License %q is deprecated.", license)	58	line.Warn1("License %q is deprecated.", license)
		59	Explain(
		60	"Instead of using these deprecated licenses, extract the actual",
		61	"license from the package into the pkgsrc/licenses/ directory",
		62	"and define LICENSE to that file name. See the pkgsrc guide,",
		63	"keyword LICENSE, for more information.")
59	}	64	}
60	}	65	}
61	}	66	}

--- pkgsrc/pkgtools/pkglint/files/Attic/substcontext_test.go 2016/01/12 01:02:49 1.4
+++ pkgsrc/pkgtools/pkglint/files/Attic/substcontext_test.go 2016/07/07 12:09:27 1.5

 @@ -39,26 +39,43 @@ func (s *Suite) TestSubstContext_Complet
 	ctx.Varassign(newSubstLine(13, "SUBST_SED.p=s,@PREFIX@,${PREFIX},g"))
 	c.Check(ctx.IsComplete(), equals, false)
 	ctx.Varassign(newSubstLine(14, "SUBST_STAGE.p=post-configure"))
 	c.Check(ctx.IsComplete(), equals, true)
 	ctx.Finish(newSubstLine(15, ""))
 	c.Check(s.Output(), equals, "")
+}
 func (s *Suite) Test_SubstContext_OPSYSVARS(c *check.C) {
 	G.opts.WarnExtra = true
 	ctx := new(SubstContext)
 	ctx.Varassign(newSubstLine(11, "SUBST_CLASSES.SunOS+=prefix"))
 	ctx.Varassign(newSubstLine(12, "SUBST_CLASSES.NetBSD+=prefix"))
 	ctx.Varassign(newSubstLine(13, "SUBST_FILES.prefix=Makefile"))
 	ctx.Varassign(newSubstLine(14, "SUBST_SED.prefix=s,@PREFIX@,${PREFIX},g"))
 	ctx.Varassign(newSubstLine(15, "SUBST_STAGE.prefix=post-configure"))
 	c.Check(ctx.IsComplete(), equals, true)
 	ctx.Finish(newSubstLine(15, ""))
 	c.Check(s.Output(), equals, "")
+}
 func (s *Suite) TestSubstContext_NoClass(c *check.C) {
 	s.UseCommandLine(c, "-Wextra")
 	ctx := new(SubstContext)
 	ctx.Varassign(newSubstLine(10, "UNRELATED=anything"))
 	ctx.Varassign(newSubstLine(11, "SUBST_FILES.repl+=Makefile.in"))
 	ctx.Varassign(newSubstLine(12, "SUBST_SED.repl+=-e s,from,to,g"))
 	ctx.Finish(newSubstLine(13, ""))
 	c.Check(s.Output(), equals, ""+
 		"WARN: Makefile:11: SUBST_CLASSES should come before the definition of \"SUBST_FILES.repl\".\n"+
 		"WARN: Makefile:13: Incomplete SUBST block: SUBST_STAGE.repl missing.\n")
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/mkline.go 2016/06/10 19:42:42 1.12
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkline.go 2016/07/07 12:09:27 1.13

 @@ -420,27 +420,27 @@ func (mkline *MkLine) CheckVaruse(varuse
 		defer tracecall(mkline, varuse, vuc)()
+	}
 	if varuse.IsExpression() {
 		return
+	}
 	varname := varuse.varname
 	vartype := mkline.getVariableType(varname)
 	if G.opts.WarnExtra &&
 		(vartype == nil || vartype.guessed) &&
 		!varIsUsed(varname) &&
 		!(G.Mk != nil && G.Mk.forVars[varname]) &&
-		!hasPrefix(varname, "${") {
+		!containsVarRef(varname) {
 		mkline.Warn1("%s is used but not defined. Spelling mistake?", varname)
+	}
 	mkline.CheckVarusePermissions(varname, vartype, vuc)
 	if varname == "LOCALBASE" && !G.Infrastructure {
 		mkline.WarnVaruseLocalbase()
+	}
 	needsQuoting := mkline.variableNeedsQuoting(varname, vartype, vuc)
 	if vuc.quoting == vucQuotFor {
 		mkline.checkVaruseFor(varname, vartype, needsQuoting)
 @@ -989,106 +989,45 @@ func (mkline *MkLine) checkVarassignPlis
 			"\t.if ...",
 			"\tMY_VAR?=\tyes",
 			"\t.endif")
+	}
 	// Mark the variable as PLIST condition. This is later used in checkfile_PLIST.
 	if G.Pkg != nil {
 		if m, plistVarname := match1(value, `(.+)=.*@comment.*`); m {
 			G.Pkg.plistSubstCond[plistVarname] = true
+		}
+	}
+}
 const reVarnamePlural = `^(?:` +
 	`.*[Ss]` +
 	`|.*LIST` +
 	`|.*_AWK` +
 	`|.*_ENV` +
 	`|.*_OVERRIDE` +
 	`|.*_PREREQ` +
 	`|.*_REQD` +
 	`|.*_SED` +
 	`|.*_SKIP` +
 	`|.*_SRC` +
 	`|.*_SUBST` +
 	`|.*_TARGET` +
 	`|.*_TMPL` +
 	`|BROKEN_EXCEPT_ON_PLATFORM` +
 	`|BROKEN_ON_PLATFORM` +
 	`|BUILDLINK_DEPMETHOD` +
 	`|BUILDLINK_LDADD` +
 	`|BUILDLINK_TRANSFORM` +
 	`|COMMENT` +
 	`|CRYPTO` +
 	`|DEINSTALL_TEMPLATE` +
 	`|EVAL_PREFIX` +
 	`|EXTRACT_ONLY` +
 	`|FETCH_MESSAGE` +
 	`|FIX_RPATH` +
 	`|GENERATE_PLIST` +
 	`|INSTALL_TEMPLATE` +
 	`|INTERACTIVE_STAGE` +
 	`|LICENSE` +
 	`|MASTER_SITE_.*` +
 	`|MASTER_SORT_REGEX` +
 	`|NOT_FOR_COMPILER` +
 	`|NOT_FOR_PLATFORM` +
 	`|ONLY_FOR_COMPILER` +
 	`|ONLY_FOR_PLATFORM` +
 	`|PERL5_PACKLIST` +
 	`|PLIST_CAT` +
 	`|PLIST_PRE` +
 	`|PKG_FAIL_REASON` +
 	`|PKG_SKIP_REASON` +
 	`|PREPEND_PATH` +
 	`|PYTHON_VERSIONS_INCOMPATIBLE` +
 	`|REPLACE_INTERPRETER` +
 	`|REPLACE_PERL` +
 	`|REPLACE_RUBY` +
 	`|RESTRICTED` +
 	`|SITES_.+` +
 	`|TOOLS_ALIASES\..+` +
 	`|TOOLS_BROKEN` +
 	`|TOOLS_CREATE` +
 	`|TOOLS_GNU_MISSING` +
 	`|TOOLS_NOOP` +
 	`)$`
 func (mkline *MkLine) CheckVartype(varname string, op MkOperator, value, comment string) {
 	if G.opts.Debug {
 		defer tracecall(varname, op, value, comment)()
+	}
 	if !G.opts.WarnTypes {
 		return
+	}
 	varbase := varnameBase(varname)
 	vartype := mkline.getVariableType(varname)
 	if op == opAssignAppend {
-		if vartype != nil {
+		if vartype != nil && !vartype.MayBeAppendedTo() {
-			if !vartype.MayBeAppendedTo() {
+			mkline.Warn0("The \"+=\" operator should only be used with lists.")
 				mkline.Warn0("The \"+=\" operator should only be used with lists.")
 		} else if !hasPrefix(varbase, "_") && !matches(varbase, reVarnamePlural) {
 			mkline.Warn1("As %s is modified using \"+=\", its name should indicate plural.", varname)
+		}
+	}
 	switch {
 	case vartype == nil:
 		// Cannot check anything if the type is not known.
 		if G.opts.Debug {
 			traceStep1("Unchecked variable assignment for %s.", varname)
+		}
 	case op == opAssignShell:
 		if G.opts.Debug {
 			traceStep1("Unchecked use of !=: %q", value)
+		}
 	case vartype.kindOfList == lkNone:
 		mkline.CheckVartypePrimitive(varname, vartype.checker, op, value, comment, vartype.IsConsideredList(), vartype.guessed)
 	case value == "":
 @@ -1370,27 +1309,27 @@ func matchMkCond(text string) (m bool, i
 	return
+}
 type NeedsQuoting uint8
 const (
 	nqNo NeedsQuoting = iota
 	nqYes
 	nqDoesntMatter
 	nqDontKnow
+)
 func (nq NeedsQuoting) String() string {
-	return [...]string{"no", "yes", "doesn't matter", "don't known"}[nq]
+	return [...]string{"no", "yes", "doesn't matter", "don't know"}[nq]
+}
 func (mkline *MkLine) variableNeedsQuoting(varname string, vartype *Vartype, vuc *VarUseContext) (needsQuoting NeedsQuoting) {
 	if G.opts.Debug {
 		defer tracecall(varname, vartype, vuc, "=>", &needsQuoting)()
+	}
 	if vartype == nil || vuc.vartype == nil {
 		return nqDontKnow
+	}
 	if vartype.checker.IsEnum() || vartype.IsBasicSafe() {
 		if vartype.kindOfList == lkNone {
 @@ -1520,27 +1459,27 @@ func (mkline *MkLine) getVariableType(va
 	if m, toolvarname := match1(varname, `^TOOLS_(.*)`); m && G.globalData.Tools.byVarname[toolvarname] != nil {
 		return &Vartype{lkNone, CheckvarPathname, []AclEntry{{"*", aclpUse}}, false}
+	}
 	allowAll := []AclEntry{{"*", aclpAll}}
 	allowRuntime := []AclEntry{{"*", aclpAllRuntime}}
 	// Guess the datatype of the variable based on naming conventions.
 	varbase := varnameBase(varname)
 	var gtype *Vartype
 	switch {
 	case hasSuffix(varbase, "DIRS"):
 		gtype = &Vartype{lkShell, CheckvarPathmask, allowRuntime, true}
-	case hasSuffix(varbase, "DIR"), hasSuffix(varname, "_HOME"):
+	case hasSuffix(varbase, "DIR") && !hasSuffix(varbase, "DESTDIR"), hasSuffix(varname, "_HOME"):
 		gtype = &Vartype{lkNone, CheckvarPathname, allowRuntime, true}
 	case hasSuffix(varbase, "FILES"):
 		gtype = &Vartype{lkShell, CheckvarPathmask, allowRuntime, true}
 	case hasSuffix(varbase, "FILE"):
 		gtype = &Vartype{lkNone, CheckvarPathname, allowRuntime, true}
 	case hasSuffix(varbase, "PATH"):
 		gtype = &Vartype{lkNone, CheckvarPathlist, allowRuntime, true}
 	case hasSuffix(varbase, "PATHS"):
 		gtype = &Vartype{lkShell, CheckvarPathname, allowRuntime, true}
 	case hasSuffix(varbase, "_USER"):
 		gtype = &Vartype{lkNone, CheckvarUserGroupName, allowAll, true}
 	case hasSuffix(varbase, "_GROUP"):
 		gtype = &Vartype{lkNone, CheckvarUserGroupName, allowAll, true}

--- pkgsrc/pkgtools/pkglint/files/Attic/mkline_test.go 2016/06/05 11:24:32 1.12
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkline_test.go 2016/07/07 12:09:27 1.13

 @@ -282,36 +282,31 @@ func (s *Suite) TestVarUseContext_ToStri
 	G.globalData.InitVartypes()
 	mkline := NewMkLine(NewLine("fname", 1, "# dummy", nil))
 	vartype := mkline.getVariableType("PKGNAME")
 	vuc := &VarUseContext{vartype, vucTimeUnknown, vucQuotBackt, vucExtentWord}
 	c.Check(vuc.String(), equals, "(PkgName time:unknown quoting:backt extent:word)")
+}
 func (s *Suite) TestMkLine_(c *check.C) {
 	G.globalData.InitVartypes()
 	G.Mk = s.NewMkLines("Makefile",
 		"# $"+"NetBSD$",
-		"ac_cv_libpari_libs+=\t-L${BUILDLINK_PREFIX.pari}/lib", // From math/clisp-pari/Makefile, rev. 1.8
+		"ac_cv_libpari_libs+=\t-L${BUILDLINK_PREFIX.pari}/lib") // From math/clisp-pari/Makefile, rev. 1.8
 		"var+=value")
 	G.Mk.mklines[1].checkVarassign()
 	G.Mk.mklines[2].checkVarassign()
-	c.Check(s.Output(), equals, ""+
+	c.Check(s.Output(), equals, "WARN: Makefile:2: ac_cv_libpari_libs is defined but not used. Spelling mistake?\n")
 		"WARN: Makefile:2: ac_cv_libpari_libs is defined but not used. Spelling mistake?\n"+
 		"WARN: Makefile:3: As var is modified using \"+=\", its name should indicate plural.\n"+
 		"WARN: Makefile:3: var is defined but not used. Spelling mistake?\n")
+}
 // In variable assignments, a plain '#' introduces a line comment, unless
 // it is escaped by a backslash. In shell commands, on the other hand, it
 // is interpreted literally.
 func (s *Suite) TestParselineMk(c *check.C) {
 	line1 := NewMkLine(NewLine("fname", 1, "SED_CMD=\t's,\\#,hash,g'", nil))
 	c.Check(line1.Varname(), equals, "SED_CMD")
 	c.Check(line1.Value(), equals, "'s,#,hash,g'")
 	line2 := NewMkLine(NewLine("fname", 1, "\tsed -e 's,\\#,hash,g'", nil))
 @@ -669,26 +664,44 @@ func (s *Suite) TestMkLine_variableNeeds
 func (s *Suite) TestMkLine_variableNeedsQuoting_18(c *check.C) {
 	s.UseCommandLine(c, "-Wall")
 	s.RegisterMasterSite("MASTER_SITE_GNOME", "http://ftp.gnome.org/")
 	G.globalData.InitVartypes()
 	G.Mk = s.NewMkLines("x11/gtk3/Makefile",
 		"# $"+"NetBSD$",
 		"MASTER_SITES=\tftp://ftp.gtk.org/${PKGNAME}/ ${MASTER_SITE_GNOME:=subdir/}")
 	G.Mk.mklines[1].checkVarassignVaruse()
 	c.Check(s.Output(), equals, "") // Don’t warn about missing :Q operators.
+}
 func (s *Suite) Test_MkLine_variableNeedsQuoting_tool_in_CONFIGURE_ENV(c *check.C) {
 	s.UseCommandLine(c, "-Wall")
 	G.globalData.InitVartypes()
 	G.globalData.Tools = NewToolRegistry()
 	G.globalData.Tools.RegisterVarname("tar", "TAR")
 	mklines := s.NewMkLines("Makefile",
 		"# $"+"NetBSD$",
 		"",
 		"CONFIGURE_ENV+=\tSYS_TAR_COMMAND_PATH=${TOOLS_TAR:Q}")
 	mklines.mklines[2].checkVarassignVaruse()
 	// The TOOLS_* variables only contain the path to the tool,
 	// without any additional arguments that might be necessary.
 	c.Check(s.Output(), equals, "NOTE: Makefile:3: The :Q operator isn't necessary for ${TOOLS_TAR} here.\n")
+}
 func (s *Suite) Test_MkLine_Varuse_Modifier_L(c *check.C) {
 	s.UseCommandLine(c, "-Wall")
 	G.globalData.InitVartypes()
 	G.Mk = s.NewMkLines("x11/xkeyboard-config/Makefile",
 		"FILES_SUBST+=XKBCOMP_SYMLINK=${${XKBBASE}/xkbcomp:L:Q}")
 	G.Mk.mklines[0].Check()
 	c.Check(s.Output(), equals, "") // Don’t warn that ${XKBBASE}/xkbcomp is used but not defined.
+}
 func (s *Suite) Test_MkLine_Cond_ShellCommand(c *check.C) {
 	s.UseCommandLine(c, "-Wall")
 @@ -761,13 +774,38 @@ func (s *Suite) Test_MkLine_ShellCommand
 func (s *Suite) Test_MkLine_shell_varuse_in_backt_dquot(c *check.C) {
 	s.UseCommandLine(c, "-Wall")
 	G.globalData.InitVartypes()
 	mklines := s.NewMkLines("x11/motif/Makefile",
 		"# $"+"NetBSD$",
 		"post-patch:",
 		"\tfiles=`${GREP} -l \".fB$${name}.fP(3)\" *.3`")
 	mklines.Check()
 	c.Check(s.Output(), equals, "WARN: x11/motif/Makefile:3: Unknown shell command \"${GREP}\".\n") // No parse errors.
+}
 // See PR 46570, Ctrl+F "3. In lang/perl5".
 func (s *Suite) Test_MkLine_getVariableType(c *check.C) {
 	mkline := NewMkLine(dummyLine)
 	c.Check(mkline.getVariableType("_PERL5_PACKLIST_AWK_STRIP_DESTDIR"), check.IsNil)
 	c.Check(mkline.getVariableType("SOME_DIR").guessed, equals, true)
 	c.Check(mkline.getVariableType("SOMEDIR").guessed, equals, true)
+}
 // See PR 46570, Ctrl+F "4. Shell quoting".
 // Pkglint is correct, since this definition for CPPFLAGS should be
 // seen by the shell as three words, not one word.
 func (s *Suite) Test_MkLine_Cflags(c *check.C) {
 	G.globalData.InitVartypes()
 	mklines := s.NewMkLines("Makefile",
 		"# $"+"NetBSD$",
 		"CPPFLAGS.SunOS+=\t-DPIPECOMMAND=\\\"/usr/sbin/sendmail -bs %s\\\"")
 	mklines.Check()
 	c.Check(s.Output(), equals, ""+
 		"WARN: Makefile:2: Unknown compiler flag \"-bs\".\n"+
 		"WARN: Makefile:2: Compiler flag \"%s\\\\\\\"\" should start with a hyphen.\n")
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/mklines_test.go 2016/06/10 19:42:42 1.5
+++ pkgsrc/pkgtools/pkglint/files/Attic/mklines_test.go 2016/07/07 12:09:27 1.6

 @@ -1,19 +1,21 @@
 package main
 import (
 	check "gopkg.in/check.v1"
+)
 const mkrcsid = "# $" + "NetBSD$"
 func (s *Suite) TestMkLines_AutofixConditionalIndentation(c *check.C) {
 	s.UseCommandLine(c, "--autofix", "-Wspace")
 	tmpfile := s.CreateTmpFile(c, "fname.mk", "")
 	mklines := s.NewMkLines(tmpfile,
 		"# $"+"NetBSD$",
 		".if defined(A)",
 		".for a in ${A}",
 		".if defined(C)",
 		".endif",
 		".endfor",
 		".endif")
 	mklines.Check()
 @@ -248,13 +250,64 @@ func (s *Suite) Test_MkLines_LoopModifie
 func (s *Suite) Test_MkLines_Indentation_DependsOn(c *check.C) {
 	G.globalData.InitVartypes()
 	mklines := s.NewMkLines("Makefile",
 		"# $"+"NetBSD$",
 		"PKG_SKIP_REASON+=\t\"Fails everywhere\"",
 		".if ${OPSYS} == \"Cygwin\"",
 		"PKG_SKIP_REASON+=\t\"Fails on Cygwin\"",
 		".endif")
 	mklines.Check()
 	c.Check(s.Output(), equals, "NOTE: Makefile:4: Consider defining NOT_FOR_PLATFORM instead of setting PKG_SKIP_REASON depending on ${OPSYS}.\n")
+}
 // PR 46570, item "15. net/uucp/Makefile has a make loop"
 func (s *Suite) Test_MkLines_indirect_variables(c *check.C) {
 	s.UseCommandLine(c, "-Wall")
 	mklines := s.NewMkLines("net/uucp/Makefile",
 		"# $"+"NetBSD$",
 		"",
 		"post-configure:",
 		".for var in MAIL_PROGRAM CMDPATH",
 		"\t"+`${RUN} ${ECHO} "#define ${var} \""${UUCP_${var}}"\"`,
 		".endfor")
 	mklines.Check()
 	// No warning about UUCP_${var} being used but not defined.
 	c.Check(s.Output(), equals, ""+
 		"WARN: net/uucp/Makefile:5: Unknown shell command \"${ECHO}\".\n")
+}
 func (s *Suite) Test_MkLines_Check_list_variable_as_part_of_word(c *check.C) {
 	s.UseCommandLine(c, "-Wall")
 	mklines := s.NewMkLines("converters/chef/Makefile",
 		mkrcsid,
 		"\tcd ${WRKSRC} && tr '\\r' '\\n' < ${DISTDIR}/${DIST_SUBDIR}/${DISTFILES} > chef.l")
 	mklines.Check()
 	c.Check(s.Output(), equals, ""+
 		"WARN: converters/chef/Makefile:2: Unknown shell command \"tr\".\n"+
 		"WARN: converters/chef/Makefile:2: The list variable DISTFILES should not be embedded in a word.\n")
+}
 func (s *Suite) Test_MkLines_Check_absolute_pathname_depending_on_OPSYS(c *check.C) {
 	s.UseCommandLine(c, "-Wall")
 	G.globalData.InitVartypes()
 	mklines := s.NewMkLines("games/heretic2-demo/Makefile",
 		mkrcsid,
 		".if ${OPSYS} == \"DragonFly\"",
 		"TOOLS_PLATFORM.gtar=\t/usr/bin/bsdtar",
 		".endif",
 		"TOOLS_PLATFORM.gtar=\t/usr/bin/bsdtar")
 	mklines.Check()
 	// No warning about an unknown shell command in line 3,
 	// since that line depends on OPSYS.
 	c.Check(s.Output(), equals, ""+
 		"WARN: games/heretic2-demo/Makefile:3: The variable TOOLS_PLATFORM.gtar may not be set by any package.\n"+
 		"WARN: games/heretic2-demo/Makefile:5: The variable TOOLS_PLATFORM.gtar may not be set by any package.\n"+
 		"WARN: games/heretic2-demo/Makefile:5: Unknown shell command \"/usr/bin/bsdtar\".\n")
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/plist.go 2016/06/05 11:24:32 1.5
+++ pkgsrc/pkgtools/pkglint/files/Attic/plist.go 2016/07/07 12:09:27 1.6

 @@ -316,27 +316,28 @@ func (ck *PlistChecker) checkpathSbin(pl
 		pline.line.Warn1("Manual page missing for sbin/%s.", binname)
 		Explain(
 			"All programs that can be run directly by the user should have a",
 			"manual page for quick reference.  The programs in the sbin/",
 			"directory should have corresponding manual pages in section 8",
 			"(filename program.8), while the programs in the bin/ directory",
 			"have their manual pages in section 1.")
+	}
+}
 func (ck *PlistChecker) checkpathShare(pline *PlistLine) {
 	line, text := pline.line, pline.text
 	switch {
-	case hasPrefix(text, "share/applications/") && hasSuffix(text, ".desktop"):
+	// Disabled due to PR 46570, item "10. It should stop".
 	case false && hasPrefix(text, "share/applications/") && hasSuffix(text, ".desktop"):
 		f := "../../sysutils/desktop-file-utils/desktopdb.mk"
 		if G.opts.WarnExtra && G.Pkg != nil && G.Pkg.included[f] == nil {
 			line.Warn1("Packages that install a .desktop entry should .include %q.", f)
 			Explain3(
 				"If *.desktop files contain MimeType keys, the global MIME type",
 				"registry must be updated by desktop-file-utils.  Otherwise, this",
 				"warning is harmless.")
+		}
 	case hasPrefix(text, "share/icons/hicolor/") && G.Pkg != nil && G.Pkg.Pkgpath != "graphics/hicolor-icon-theme":
 		f := "../../graphics/hicolor-icon-theme/buildlink3.mk"
 		if G.Pkg.included[f] == nil {
 			line.Error1("Packages that install hicolor icons must include %q in the Makefile.", f)

--- pkgsrc/pkgtools/pkglint/files/Attic/plist_test.go 2016/01/27 21:55:51 1.5
+++ pkgsrc/pkgtools/pkglint/files/Attic/plist_test.go 2016/07/07 12:09:27 1.6

 @@ -135,26 +135,29 @@ func (s *Suite) TestPlistChecker_sort(c
 		"b\n"+
 		"${PLIST.one}bin/program\n"+ // Conditionals are ignored while sorting
 		"${PKGMANDIR}/man1/program.1\n"+ // Stays below the previous line
 		"${PLIST.two}bin/program2\n"+
 		"ddd\n"+
 		"@exec echo \"after ddd\"\n"+ // Stays below the previous line
 		"lib/after.la\n"+
 		"@exec echo \"after lib/after.la\"\n"+
 		"lib/before.la\n"+
 		"sbin/program\n")
+}
 func (s *Suite) TestPlistChecker_checkpathShare_Desktop(c *check.C) {
 	// Disabled due to PR 46570, item "10. It should stop".
 	return
 	s.UseCommandLine(c, "-Wextra")
 	G.Pkg = NewPackage("category/pkgpath")
 	ChecklinesPlist(s.NewLines("PLIST",
 		"@comment $"+"NetBSD$",
 		"share/applications/pkgbase.desktop"))
 	c.Check(s.Output(), equals, "WARN: PLIST:2: Packages that install a .desktop entry should .include \"../../sysutils/desktop-file-utils/desktopdb.mk\".\n")
+}
 func (s *Suite) TestPlistChecker_checkpathMan_gz(c *check.C) {
 	G.Pkg = NewPackage("category/pkgbase")

--- pkgsrc/pkgtools/pkglint/files/Attic/substcontext.go 2016/01/12 01:02:49 1.5
+++ pkgsrc/pkgtools/pkglint/files/Attic/substcontext.go 2016/07/07 12:09:27 1.6

	@@ -10,32 +10,32 @@ type SubstContext struct {		@@ -10,32 +10,32 @@ type SubstContext struct {
10	sed []string	10	sed []string
11	vars []string	11	vars []string
12	filterCmd string	12	filterCmd string
13	}	13	}
14		14
15	func (ctx SubstContext) Varassign(mkline MkLine) {	15	func (ctx SubstContext) Varassign(mkline MkLine) {
16	if !G.opts.WarnExtra {	16	if !G.opts.WarnExtra {
17	return	17	return
18	}	18	}
19		19
20	varname := mkline.Varname()	20	varname := mkline.Varname()
21	op := mkline.Op()	21	op := mkline.Op()
22	value := mkline.Value()	22	value := mkline.Value()
23	if varname == "SUBST_CLASSES" {	23	if varname == "SUBST_CLASSES" \|\| hasPrefix(varname, "SUBST_CLASSES.") {
24	classes := splitOnSpace(value)	24	classes := splitOnSpace(value)
25	if len(classes) > 1 {	25	if len(classes) > 1 {
26	mkline.Warn0("Please add only one class at a time to SUBST_CLASSES.")	26	mkline.Warn0("Please add only one class at a time to SUBST_CLASSES.")
27	}	27	}
28	if ctx.id != "" {	28	if ctx.id != "" && ctx.id != classes[0] {
29	mkline.Warn0("SUBST_CLASSES should only appear once in a SUBST block.")	29	mkline.Warn0("SUBST_CLASSES should only appear once in a SUBST block.")
30	}	30	}
31	ctx.id = classes[0]	31	ctx.id = classes[0]
32	return	32	return
33	}	33	}
34		34
35	m, varbase, varparam := match2(varname, `^(SUBST_(?:STAGE\|MESSAGE\|FILES\|SED\|VARS\|FILTER_CMD))\.([\-\w_]+)$`)	35	m, varbase, varparam := match2(varname, `^(SUBST_(?:STAGE\|MESSAGE\|FILES\|SED\|VARS\|FILTER_CMD))\.([\-\w_]+)$`)
36	if !m {	36	if !m {
37	if ctx.id != "" {	37	if ctx.id != "" {
38	mkline.Warn1("Foreign variable %q in SUBST block.", varname)	38	mkline.Warn1("Foreign variable %q in SUBST block.", varname)
39	}	39	}
40	return	40	return
41	}	41	}

--- pkgsrc/pkgtools/pkglint/files/Attic/mkparser.go 2016/06/05 11:24:32 1.1
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkparser.go 2016/07/07 12:09:27 1.2

	@@ -17,41 +17,36 @@ func (p MkParser) MkTokens() []MkToken		@@ -17,41 +17,36 @@ func (p MkParser) MkTokens() []MkToken
17		17
18	var tokens []*MkToken	18	var tokens []*MkToken
19	for !p.EOF() {	19	for !p.EOF() {
20	if repl.AdvanceStr("#") {	20	if repl.AdvanceStr("#") {
21	repl.AdvanceRest()	21	repl.AdvanceRest()
22	}	22	}
23		23
24	mark := repl.Mark()	24	mark := repl.Mark()
25	if varuse := p.VarUse(); varuse != nil {	25	if varuse := p.VarUse(); varuse != nil {
26	tokens = append(tokens, &MkToken{Text: repl.Since(mark), Varuse: varuse})	26	tokens = append(tokens, &MkToken{Text: repl.Since(mark), Varuse: varuse})
27	continue	27	continue
28	}	28	}
29		29
30	needsReplace := false
31	again:	30	again:
32	dollar := strings.IndexByte(repl.rest, '$')	31	dollar := strings.IndexByte(repl.rest, '$')
33	if dollar == -1 {	32	if dollar == -1 {
34	dollar = len(repl.rest)	33	dollar = len(repl.rest)
35	}	34	}
36	repl.Skip(dollar)	35	repl.Skip(dollar)
37	if repl.AdvanceStr("$$") {	36	if repl.AdvanceStr("$$") {
38	needsReplace = true
39	goto again	37	goto again
40	}	38	}
41	text := repl.Since(mark)	39	text := repl.Since(mark)
42	if needsReplace {
43	text = strings.Replace(text, "$$", "$", -1)
44	}
45	if text != "" {	40	if text != "" {
46	tokens = append(tokens, &MkToken{Text: text})	41	tokens = append(tokens, &MkToken{Text: text})
47	continue	42	continue
48	}	43	}
49		44
50	break	45	break
51	}	46	}
52	return tokens	47	return tokens
53	}	48	}
54		49
55	func (p MkParser) VarUse() MkVarUse {	50	func (p MkParser) VarUse() MkVarUse {
56	repl := p.repl	51	repl := p.repl
57		52
	@@ -81,27 +76,27 @@ func (p MkParser) VarUse() MkVarUse {		@@ -81,27 +76,27 @@ func (p MkParser) VarUse() MkVarUse {
81	if repl.AdvanceStr(closing) {	76	if repl.AdvanceStr(closing) {
82	return &MkVarUse{varexpr, modifiers}	77	return &MkVarUse{varexpr, modifiers}
83	}	78	}
84	}	79	}
85	repl.Reset(mark)	80	repl.Reset(mark)
86	}	81	}
87		82
88	if repl.AdvanceStr("$@") {	83	if repl.AdvanceStr("$@") {
89	return &MkVarUse{"@", nil}	84	return &MkVarUse{"@", nil}
90	}	85	}
91	if repl.AdvanceStr("$<") {	86	if repl.AdvanceStr("$<") {
92	return &MkVarUse{"<", nil}	87	return &MkVarUse{"<", nil}
93	}	88	}
94	if repl.AdvanceRegexp(`^\$(\w)`) {	89	if repl.PeekByte() == '$' && repl.AdvanceRegexp(`^\$(\w)`) {
95	varname := repl.m[1]	90	varname := repl.m[1]
96	if p.EmitWarnings {	91	if p.EmitWarnings {
97	p.Line.Warn1("$%[1]s is ambiguous. Use ${%[1]s} if you mean a Makefile variable or $$%[1]s if you mean a shell variable.", varname)	92	p.Line.Warn1("$%[1]s is ambiguous. Use ${%[1]s} if you mean a Makefile variable or $$%[1]s if you mean a shell variable.", varname)
98	}	93	}
99	return &MkVarUse{varname, nil}	94	return &MkVarUse{varname, nil}
100	}	95	}
101	return nil	96	return nil
102	}	97	}
103		98
104	func (p *MkParser) VarUseModifiers(varname, closing string) []string {	99	func (p *MkParser) VarUseModifiers(varname, closing string) []string {
105	repl := p.repl	100	repl := p.repl
106		101
107	var modifiers []string	102	var modifiers []string

--- pkgsrc/pkgtools/pkglint/files/Attic/mkparser_test.go 2016/06/05 11:24:32 1.1
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkparser_test.go 2016/07/07 12:09:27 1.2

 @@ -27,27 +27,27 @@ func (s *Suite) Test_MkParser_MkTokens(c
 		for _, modifier := range modifiers {
 			text += ":" + modifier
+		}
 		text += "}"
 		return &MkToken{Text: text, Varuse: &MkVarUse{varname: varname, modifiers: modifiers}}
+	}
 	varuseText := func(text, varname string, modifiers ...string) *MkToken {
 		return &MkToken{Text: text, Varuse: &MkVarUse{varname: varname, modifiers: modifiers}}
+	}
 	check("literal", literal("literal"))
 	check("\\/share\\/ { print \"share directory\" }", literal("\\/share\\/ { print \"share directory\" }"))
 	check("find . -name \\*.orig -o -name \\*.pre", literal("find . -name \\*.orig -o -name \\*.pre"))
-	check("-e 's|\\$${EC2_HOME.*}|EC2_HOME}|g'", literal("-e 's|\\${EC2_HOME.*}|EC2_HOME}|g'"))
+	check("-e 's|\\$${EC2_HOME.*}|EC2_HOME}|g'", literal("-e 's|\\$${EC2_HOME.*}|EC2_HOME}|g'"))
 	check("${VARIABLE}", varuse("VARIABLE"))
 	check("${VARIABLE.param}", varuse("VARIABLE.param"))
 	check("${VARIABLE.${param}}", varuse("VARIABLE.${param}"))
 	check("${VARIABLE.hicolor-icon-theme}", varuse("VARIABLE.hicolor-icon-theme"))
 	check("${VARIABLE.gtk+extra}", varuse("VARIABLE.gtk+extra"))
 	check("${VARIABLE:S/old/new/}", varuse("VARIABLE", "S/old/new/"))
 	check("${GNUSTEP_LFLAGS:S/-L//g}", varuse("GNUSTEP_LFLAGS", "S/-L//g"))
 	check("${SUSE_VERSION:S/.//}", varuse("SUSE_VERSION", "S/.//"))
 	check("${MASTER_SITE_GNOME:=sources/alacarte/0.13/}", varuse("MASTER_SITE_GNOME", "=sources/alacarte/0.13/"))
 	check("${INCLUDE_DIRS:H:T}", varuse("INCLUDE_DIRS", "H", "T"))
 	check("${A.${B.${C.${D}}}}", varuse("A.${B.${C.${D}}}"))
 	check("${RUBY_VERSION:C/([0-9]+)\\.([0-9]+)\\.([0-9]+)/\\1/}", varuse("RUBY_VERSION", "C/([0-9]+)\\.([0-9]+)\\.([0-9]+)/\\1/"))

--- pkgsrc/pkgtools/pkglint/files/Attic/mkshparser.go 2016/06/05 11:24:32 1.1
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkshparser.go 2016/07/07 12:09:27 1.2

 @@ -1,655 +1,224 @@
 package main
 import (
 	"fmt"
 	"strconv"
+)
-type MkShParser struct {
+func parseShellProgram(line *Line, program string) (list *MkShList, err error) {
-	tok  *ShTokenizer
+	if G.opts.Debug {
-	curr *ShToken
+		defer tracecall(program)()
 func NewMkShParser(line *Line, text string, emitWarnings bool) *MkShParser {
 	shp := NewShTokenizer(line, text, emitWarnings)
 	return &MkShParser{shp, nil}
 func (p *MkShParser) Program() (retval *MkShList) {
 	defer p.trace(&retval)()
 	list := p.List()
 	if list == nil {
 		return nil
 	separator := p.Separator()
 	if separator == nil {
 		return list
 	return &MkShList{list.AndOrs, append(list.Separators, *separator)}
 // ::= AndOr (SeparatorOp AndOr)*
 func (p *MkShParser) List() (retval *MkShList) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	var andors []*MkShAndOr
 	var seps []MkShSeparator
 	if andor := p.AndOr(); andor != nil {
 		andors = append(andors, andor)
 	} else {
 		return nil
 next:
 	mark := p.mark()
 	if sep := p.SeparatorOp(); sep != nil {
 		if andor := p.AndOr(); andor != nil {
 			andors = append(andors, andor)
 			seps = append(seps, *sep)
 			goto next
 	p.reset(mark)
 	ok = true
 	return &MkShList{andors, seps}
 func (p *MkShParser) AndOr() (retval *MkShAndOr) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)
 	var pipes []*MkShPipeline
 	var ops []string
 nextpipe:
 	if pipe := p.Pipeline(); pipe != nil {
 		pipes = append(pipes, pipe)
 		switch op := p.peekText(); op {
 		case "&&", "||":
 			p.skip()
 			p.Linebreak()
 			ops = append(ops, op)
 			goto nextpipe
 	if len(pipes) == len(ops) {
 		return nil
 	ok = true
 	return &MkShAndOr{pipes, ops}
 // ::= Command (msttPipe Linebreak Command)*
 func (p *MkShParser) Pipeline() (retval *MkShPipeline) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	bang := p.eat("!")
 	var cmds []*MkShCommand
 nextcmd:
 	cmd := p.Command()
 	if cmd == nil {
 		return nil
 	cmds = append(cmds, cmd)
 	if p.eat("|") {
 		p.Linebreak()
 		goto nextcmd
 	ok = true
 	return &MkShPipeline{bang, cmds}
 func (p *MkShParser) Command() (retval *MkShCommand) {
 	defer p.trace(&retval)()
 	if simple := p.SimpleCommand(); simple != nil {
 		return &MkShCommand{Simple: simple}
 	if compound := p.CompoundCommand(); compound != nil {
 		redirects := p.RedirectList()
 		return &MkShCommand{Compound: compound, Redirects: redirects}
 	if funcdef := p.FunctionDefinition(); funcdef != nil {
 		return &MkShCommand{FuncDef: funcdef}
 	return nil
 func (p *MkShParser) CompoundCommand() (retval *MkShCompoundCommand) {
 	defer p.trace(&retval)()
 	if brace := p.BraceGroup(); brace != nil {
 		return &MkShCompoundCommand{Brace: brace}
 	if subshell := p.Subshell(); subshell != nil {
 		return &MkShCompoundCommand{Subshell: subshell}
 	if forclause := p.ForClause(); forclause != nil {
 		return &MkShCompoundCommand{For: forclause}
 	if caseclause := p.CaseClause(); caseclause != nil {
 		return &MkShCompoundCommand{Case: caseclause}
 	if ifclause := p.IfClause(); ifclause != nil {
 		return &MkShCompoundCommand{If: ifclause}
 	if whileclause := p.WhileClause(); whileclause != nil {
 		return &MkShCompoundCommand{While: whileclause}
 	if untilclause := p.UntilClause(); untilclause != nil {
 		return &MkShCompoundCommand{Until: untilclause}
 	return nil
 func (p *MkShParser) Subshell() (retval *MkShList) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	if !p.eat("(") {
 		return nil
 	list := p.CompoundList()
 	if list == nil {
 		return nil
 	if !p.eat(")") {
 		return nil
 	ok = true
 	return list
 // ::= Newline* AndOr (Separator AndOr)* Separator?
 func (p *MkShParser) CompoundList() (retval *MkShList) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	p.Linebreak()
 	var andors []*MkShAndOr
 	var separators []MkShSeparator
 nextandor:
 	if andor := p.AndOr(); andor != nil {
 		andors = append(andors, andor)
 		if sep := p.Separator(); sep != nil {
 			separators = append(separators, *sep)
 			goto nextandor
 	if len(andors) == 0 {
 		return nil
 	ok = true
 	return &MkShList{andors, separators}
 // ::= "for" msttWORD Linebreak DoGroup
 // ::= "for" msttWORD Linebreak "in" SequentialSep DoGroup
 // ::= "for" msttWORD Linebreak "in" Wordlist SequentialSep DoGroup
 func (p *MkShParser) ForClause() (retval *MkShForClause) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	if !p.eat("for") {
 		return nil
 	varword := p.Word(false)
 	if varword == nil || !matches(varword.MkText, `^[A-Z_a-z][0-9A-Za-z]*`) {
 		return nil
 	varname := varword.MkText
 	var values []*ShToken
 	if p.eat("in") {
 		values = p.Wordlist()
 	} else {
 		values = []*ShToken{NewShToken("\"$$@\"",
 			NewShAtom(shtWord, "\"", shqDquot),
 			NewShAtom(shtWord, "$$@", shqDquot),
 			NewShAtom(shtWord, "\"", shqPlain))}
 	if values == nil || !p.SequentialSep() {
 		return nil
 	p.Linebreak()
 	body := p.DoGroup()
 	if body == nil {
 		return nil
 	ok = true
 	return &MkShForClause{varname, values, body}
 func (p *MkShParser) Wordlist() (retval []*ShToken) {
 	defer p.trace(&retval)()
 	var words []*ShToken
 nextword:
 	word := p.Word(false)
 	if word != nil {
 		words = append(words, word)
 		goto nextword
 	return words
 // ::= "case" msttWORD Linebreak "in" Linebreak CaseItem* "esac"
 func (p *MkShParser) CaseClause() (retval *MkShCaseClause) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	if !p.eat("case") {
 		return nil
 	panic("CaseClause")
 	p.Linebreak()
 	p.CaseItem()
 	return nil
 // ::= "("? Pattern ")" (CompoundList | Linebreak) msttDSEMI? Linebreak
 func (p *MkShParser) CaseItem() (retval *MkShCaseItem) {
 	defer p.trace(&retval)()
 	panic("CaseItem")
 	p.Pattern()
 	p.Linebreak()
 	p.CompoundList()
 	return nil
 // ::= msttWORD
 // ::= Pattern "|" msttWORD
 func (p *MkShParser) Pattern() (retval []*ShToken) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	var words []*ShToken
 nextword:
 	word := p.Word(false)
 	if word == nil {
 		return nil
 	words = append(words, word)
 	if p.eat("|") {
 		goto nextword
 	ok = true
 	return words
 func (p *MkShParser) IfClause() (retval *MkShIfClause) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	var conds []*MkShList
 	var actions []*MkShList
 	var elseaction *MkShList
 	if !p.eat("if") {
 		return nil
 nextcond:
 	cond := p.CompoundList()
 	if cond == nil || !p.eat("then") {
 		return nil
 	action := p.CompoundList()
 	if action == nil {
 		return nil
 	conds = append(conds, cond)
 	actions = append(actions, action)
 	if p.eat("elif") {
 		goto nextcond
 	if p.eat("else") {
 		elseaction = p.CompoundList()
 		if elseaction == nil {
 			return nil
 	if !p.eat("fi") {
 		return nil
 	ok = true
 	return &MkShIfClause{conds, actions, elseaction}
 // ::= "while" CompoundList DoGroup
 func (p *MkShParser) WhileClause() (retval *MkShLoopClause) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	if !p.eat("while") {
 		return nil
 	panic("WhileClause")
 	p.CompoundList()
 	p.DoGroup()
 	return nil
 // ::= "until" CompoundList DoGroup
 func (p *MkShParser) UntilClause() (retval *MkShLoopClause) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	if !p.eat("until") {
 		return nil
 	panic("UntilClause")
 	p.CompoundList()
 	p.DoGroup()
 	return nil
 // ::= msttNAME "(" ")" Linebreak CompoundCommand Redirect*
 func (p *MkShParser) FunctionDefinition() (retval *MkShFunctionDefinition) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	funcname := p.Word(true)
 	if funcname == nil || !matches(funcname.MkText, `^[A-Z_a-z][0-9A-Z_a-z]*$`) {
 		return nil
 	if !p.eat("(") || !p.eat(")") {
 		return nil
 	p.Linebreak()
 	body := p.CompoundCommand()
 	if body == nil {
 		return nil
 	redirects := p.RedirectList()
 	ok = true
 	return &MkShFunctionDefinition{funcname.MkText, body, redirects}
 func (p *MkShParser) BraceGroup() (retval *MkShList) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	if !p.eat("{") {
 		return nil
 	list := p.CompoundList()
 	if list == nil {
 		return nil
 	if !p.eat("}") {
 		return nil
 	ok = true
 	return list
 func (p *MkShParser) DoGroup() (retval *MkShList) {
 	defer p.trace(&retval)()
 	ok := false
 	defer p.rollback(&ok)()
 	if !p.eat("do") {
 		return nil
 	list := p.CompoundList()
 	if list == nil {
 		return nil
 	if !p.eat("done") {
 		return nil
+	}
 	ok = true
 	return list
-func (p *MkShParser) SimpleCommand() (retval *MkShSimpleCommand) {
+	tokens, rest := splitIntoShellTokens(line, program)
-	defer p.trace(&retval)()
+	lexer := NewShellLexer(tokens, rest)
-	ok := false
+	parser := &shyyParserImpl{}
 	defer p.rollback(&ok)()
 	var assignments []*ShToken
 	var name *ShToken
 	var args []*ShToken
 	var redirections []*MkShRedirection
 	first := true
 	seenName := false
 nextword:
 	if word := p.Word(first); word != nil {
 		first = false
 		if !seenName && word.IsAssignment() {
 			assignments = append(assignments, word)
 		} else if !seenName {
 			name = word
 			seenName = true
 		} else {
 			args = append(args, word)
 		goto nextword
 	if len(assignments) == 0 && name == nil && len(args) == 0 && len(redirections) == 0 {
 		return nil
 	ok = true
 	return &MkShSimpleCommand{assignments, name, args, redirections}
-func (p *MkShParser) RedirectList() (retval []*MkShRedirection) {
+	succeeded := parser.Parse(lexer)
 	defer p.trace(&retval)()
-nextredirect:
+	if succeeded == 0 && lexer.error == "" {
-	if redirect := p.IoRedirect(); redirect != nil {
+		return lexer.result, nil
 		retval = append(retval, redirect)
 		goto nextredirect
+	}
-	return nil
+	return nil, &ParseError{append([]string{lexer.current}, lexer.remaining...)}
+}
-func (p *MkShParser) IoRedirect() (retval *MkShRedirection) {
+type ParseError struct {
-	defer p.trace(&retval)()
+	RemainingTokens []string
 	if m, redirect, fdstr, op := match3(p.peekText(), `^((\d*)\s*(<|<&|>|>&|>>|<>|>\||<<|<<-))`); m {
 		target := p.peekText()[len(redirect):]
 		_, _, _ = fdstr, op, target
 		fd, err := strconv.ParseInt(fdstr, 10, 32)
 		if err != nil {
 			fd = -1
 		p.skip()
 		targetToken := NewShTokenizer(p.tok.mkp.Line, target, false).ShToken()
 		return &MkShRedirection{int(fd), op, targetToken}
 	return nil
+}
-func (p *MkShParser) NewlineList() (retval bool) {
+func (e *ParseError) Error() string {
-	defer p.trace(&retval)()
+	return fmt.Sprintf("parse error at %v", e.RemainingTokens)
 	ok := false
 	for p.eat("\n") {
 		ok = true
 	return ok
+}
-func (p *MkShParser) Linebreak() {
+type ShellLexer struct {
-	for p.eat("\n") {
+	current        string
 	ioredirect     string
 	remaining      []string
 	atCommandStart bool
 	sinceFor       int
 	sinceCase      int
 	error          string
 	result         *MkShList
+}
-func (p *MkShParser) SeparatorOp() (retval *MkShSeparator) {
+func NewShellLexer(tokens []string, rest string) *ShellLexer {
-	defer p.trace(&retval)()
+	return &ShellLexer{
 		current:        "",
-	if p.eat(";") {
+		ioredirect:     "",
-		op := MkShSeparator(";")
+		remaining:      tokens,
-		return &op
+		atCommandStart: true,
 		error:          rest}
 	if p.eat("&") {
 		op := MkShSeparator("&")
 		return &op
 	return nil
+}
 func (lex *ShellLexer) Lex(lval *shyySymType) (ttype int) {
-func (p *MkShParser) Separator() (retval *MkShSeparator) {
+	if len(lex.remaining) == 0 {
-	defer p.trace(&retval)()
+		return 0
 	op := p.SeparatorOp()
 	if op == nil && p.eat("\n") {
 		sep := MkShSeparator('\n')
 		op = &sep
+	}
 	if op != nil {
 		p.Linebreak()
 	return op
-func (p *MkShParser) SequentialSep() (retval bool) {
+	if G.opts.Debug {
-	defer p.trace(&retval)()
+		defer func() {
 			tname := shyyTokname(shyyTok2[ttype-shyyPrivate])
-	if p.peekText() == ";" {
+			switch ttype {
-		p.skip()
+			case tkWORD, tkASSIGNMENT_WORD:
-		p.Linebreak()
+				traceStep("lex %v %q", tname, lval.Word.MkText)
-		return true
+			case tkIO_NUMBER:
-	} else {
+				traceStep("lex %v %v", tname, lval.IONum)
-		return p.NewlineList()
+			default:
 				traceStep("lex %v", tname)
 func (p *MkShParser) Word(cmdstart bool) (retval *ShToken) {
 	defer p.trace(&retval)()
 	if token := p.peek(); token != nil && token.IsWord() {
 		if cmdstart {
 			switch token.MkText {
 			case "while", "until", "for", "do", "done",
 				"if", "then", "else", "elif", "fi",
 				"{", "}":
 				return nil
+			}
 		}()
 		p.skip()
 		return token
+	}
 	return nil
 func (p *MkShParser) EOF() bool {
 	return p.peek() == nil
-func (p *MkShParser) peek() *ShToken {
+	token := lex.ioredirect
-	if p.curr == nil {
+	lex.ioredirect = ""
-	nexttoken:
+	if token == "" {
-		p.curr = p.tok.ShToken()
+		token = lex.remaining[0]
-		if p.curr == nil && !p.tok.parser.EOF() {
+		lex.current = token
-			p.tok.mkp.Line.Warnf("Pkglint tokenize error at " + p.tok.parser.Rest())
+		lex.remaining = lex.remaining[1:]
 			p.tok.mkp.Parser.repl.AdvanceRest()
 			return nil
 	switch token {
-		if p.curr != nil && hasPrefix(p.curr.MkText, "#") {
+	case ";":
-			goto nexttoken
+		lex.atCommandStart = true
 		return tkSEMI
 	case ";;":
 		lex.atCommandStart = true
 		return tkSEMISEMI
 	case "\n":
 		lex.atCommandStart = true
 		return tkNEWLINE
 	case "&":
 		lex.atCommandStart = true
 		return tkBACKGROUND
 	case "|":
 		lex.atCommandStart = true
 		return tkPIPE
 	case "(":
 		lex.atCommandStart = true
 		return tkLPAREN
 	case ")":
 		lex.atCommandStart = true
 		return tkRPAREN
 	case "&&":
 		lex.atCommandStart = true
 		return tkAND
 	case "||":
 		lex.atCommandStart = true
 		return tkOR
 	case ">":
 		lex.atCommandStart = false
 		return tkGT
 	case ">&":
 		lex.atCommandStart = false
 		return tkGTAND
 	case "<":
 		lex.atCommandStart = false
 		return tkLT
 	case "<&":
 		lex.atCommandStart = false
 		return tkLTAND
 	case "<>":
 		lex.atCommandStart = false
 		return tkLTGT
 	case ">>":
 		lex.atCommandStart = false
 		return tkGTGT
 	case "<<":
 		lex.atCommandStart = false
 		return tkLTLT
 	case "<<-":
 		lex.atCommandStart = false
 		return tkLTLTDASH
 	case ">|":
 		lex.atCommandStart = false
 		return tkGTPIPE
+	}
 	if m, fdstr, op := match2(token, `^(\d+)(<<-|<<|<>|<&|>>|>&|>\||<|>)$`); m {
 		fd, _ := strconv.Atoi(fdstr)
 		lval.IONum = fd
 		lex.ioredirect = op
 		return tkIO_NUMBER
+	}
 	if lex.atCommandStart {
 		lex.sinceCase = -1
 		lex.sinceFor = -1
 		switch token {
 		case "if":
 			return tkIF
 		case "then":
 			return tkTHEN
 		case "elif":
 			return tkELIF
 		case "else":
 			return tkELSE
 		case "fi":
 			return tkFI
 		case "for":
 			lex.atCommandStart = false
 			lex.sinceFor = 0
 			return tkFOR
 		case "while":
 			return tkWHILE
 		case "until":
 			return tkUNTIL
 		case "do":
 			return tkDO
 		case "done":
 			return tkDONE
 		case "in":
 			lex.atCommandStart = false
 			return tkIN
 		case "case":
 			lex.atCommandStart = false
 			lex.sinceCase = 0
 			return tkCASE
 		case "{":
 			return tkLBRACE
 		case "}":
 			return tkRBRACE
 		case "!":
 			return tkEXCLAM
+		}
+	}
 	if lex.sinceFor >= 0 {
 		lex.sinceFor++
+	}
 	if lex.sinceCase >= 0 {
 		lex.sinceCase++
+	}
 	switch {
 	case matches(token, `^\d+$`) && len(lex.remaining) != 0 && matches(lex.remaining[0], `^[<>]`):
 		ttype = tkIO_NUMBER
 		lval.IONum, _ = strconv.Atoi(token)
 	case lex.sinceFor == 2 && token == "in":
 		ttype = tkIN
 		lex.atCommandStart = false
 	case lex.sinceFor == 2 && token == "do":
 		ttype = tkDO
 		lex.atCommandStart = true
 	case lex.sinceCase == 2 && token == "in":
 		ttype = tkIN
 		lex.atCommandStart = false
 	case (lex.atCommandStart || lex.sinceCase == 3) && token == "esac":
 		ttype = tkESAC
 		lex.atCommandStart = false
 	case lex.atCommandStart && matches(token, `^[A-Za-z_]\w*=`):
 		ttype = tkASSIGNMENT_WORD
 		p := NewShTokenizer(dummyLine, token, false)
 		lval.Word = p.ShToken()
 	default:
 		ttype = tkWORD
 		p := NewShTokenizer(dummyLine, token, false)
 		lval.Word = p.ShToken()
 		lex.atCommandStart = false
+	}
 	//traceStep("MkShParser.peek %v rest=%q", p.curr, p.tok.mkp.repl.rest)
 	return p.curr
 func (p *MkShParser) peekText() string {
 	if next := p.peek(); next != nil {
 		return next.MkText
 	return ""
 func (p *MkShParser) skip() {
 	p.curr = nil
 func (p *MkShParser) eat(s string) bool {
 	if p.peek() == nil {
 		return false
 	if p.peek().MkText == s {
 		p.skip()
 		return true
 	return false
 func (p *MkShParser) rollback(pok *bool) func() {
 	mark := p.mark()
 	return func() {
 		if !*pok {
 			p.reset(mark)
 func (p *MkShParser) trace(retval interface{}) func() {
 	if G.opts.Debug {
 		return tracecallInternal(p.peek(), p.restref(), "=>", ref(retval))
 	} else {
 		return func() {}
 func (p *MkShParser) mark() MkShParserMark {
 	return MkShParserMark{p.tok.parser.repl.Mark(), p.curr}
 func (p *MkShParser) reset(mark MkShParserMark) {
 	p.tok.parser.repl.Reset(mark.rest)
 	p.curr = mark.curr
 func (p *MkShParser) restref() MkShParserRest {
 	return MkShParserRest{&p.tok.mkp.repl.rest}
 func (p *MkShParser) Rest() string {
 	return p.peekText() + p.tok.mkp.repl.AdvanceRest()
 type MkShParserMark struct {
 	rest PrefixReplacerMark
 	curr *ShToken
-type MkShParserRest struct {
+	return ttype
 	restref *string
+}
-func (rest MkShParserRest) String() string {
+func (lex *ShellLexer) Error(s string) {
-	return fmt.Sprintf("rest=%q", *rest.restref)
+	lex.error = s
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/mkshparser_test.go 2016/06/05 11:24:32 1.1
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkshparser_test.go 2016/07/07 12:09:27 1.2

 @@ -1,352 +1,595 @@
 package main
 import (
-	check "gopkg.in/check.v1"
+	"encoding/json"
 	"gopkg.in/check.v1"
 	"strconv"
+)
-func (s *Suite) Test_MkShParser_Program(c *check.C) {
+type ShSuite struct {
-	parse := func(cmd string, expected *MkShList) {
+	c *check.C
 		p := NewMkShParser(dummyLine, cmd, false)
 		program := p.Program()
 		c.Check(program, deepEquals, expected)
 		c.Check(p.tok.parser.Rest(), equals, "")
 		c.Check(s.Output(), equals, "")
 	if false {
 		parse(""+
 			"\tcd ${WRKSRC} && ${FIND} ${${_list_}} -type f ! -name '*.orig' 2>/dev/null "+
 			"| pax -rw -pm ${DESTDIR}${PREFIX}/${${_dir_}}",
 			NewMkShList())
 func (s *Suite) Test_MkShParser_List(c *check.C) {
 func (s *Suite) Test_MkShParser_AndOr(c *check.C) {
 	parse := func(cmd string, expected *MkShAndOr) {
 		p := NewMkShParser(dummyLine, cmd, false)
 		andor := p.AndOr()
 		c.Check(andor, deepEquals, expected)
 		c.Check(p.tok.parser.Rest(), equals, "")
 		c.Check(s.Output(), equals, "")
 	tester := &MkShTester{c}
 	parse("simplecmd",
 		NewMkShAndOr(NewMkShPipeline(false, tester.ParseCommand("simplecmd"))))
 	expected := NewMkShAndOr(NewMkShPipeline(false, tester.ParseCommand("simplecmd1")))
 	expected.Add("&&", NewMkShPipeline(false, tester.ParseCommand("simplecmd2")))
 	parse("simplecmd1 && simplecmd2", expected)
 func (s *Suite) Test_MkShParser_Pipeline(c *check.C) {
 func (s *Suite) Test_MkShParser_Command(c *check.C) {
 	parse := func(cmd string, expected *MkShCommand) {
 		p := NewMkShParser(dummyLine, cmd, false)
 		command := p.Command()
 		c.Check(command, deepEquals, expected)
 		c.Check(p.tok.parser.Rest(), equals, "")
 		c.Check(s.Output(), equals, "")
 	tester := &MkShTester{c}
 	parse("simple",
 		&MkShCommand{Simple: tester.ParseSimpleCommand("simple")})
 func (s *Suite) Test_MkShParser_CompoundCommand(c *check.C) {
+}
-func (s *Suite) Test_MkShParser_Subshell(c *check.C) {
+var _ = check.Suite(&ShSuite{})
-func (s *Suite) Test_MkShParser_CompoundList(c *check.C) {
+func (s *ShSuite) Test_ShellParser_program(c *check.C) {
-	parse := func(cmd string, expected *MkShList) {
+	b := s.init(c)
 		p := NewMkShParser(dummyLine, cmd, false)
 		compoundList := p.CompoundList()
 		c.Check(compoundList, deepEquals, expected)
 		c.Check(p.tok.parser.Rest(), equals, "")
 		c.Check(s.Output(), equals, "")
 	tester := &MkShTester{c}
-	parse("simplecmd",
+	s.test("",
-		NewMkShList().AddAndOr(NewMkShAndOr(NewMkShPipeline(false, tester.ParseCommand("simplecmd")))))
+		b.List())
-	simplecmd1 := NewMkShPipeline(false, tester.ParseCommand("simplecmd1"))
+	s.test("echo ;",
-	simplecmd2 := NewMkShPipeline(false, tester.ParseCommand("simplecmd2"))
+		b.List().AddCommand(b.SimpleCommand("echo")).AddSeparator(";"))
 	expected := NewMkShList().AddAndOr(NewMkShAndOr(simplecmd1).Add("&&", simplecmd2))
-	parse("simplecmd1 && simplecmd2", expected)
+	s.test("echo",
 		b.List().AddCommand(b.SimpleCommand("echo")))
-func (s *Suite) Test_MkShParser_ForClause(c *check.C) {
+	s.test(""+
-	parse := func(cmd string, expected *MkShForClause) {
+		"cd ${WRKSRC} && ${FIND} ${${_list_}} -type f ! -name '*.orig' 2 > /dev/null "+
-		p := NewMkShParser(dummyLine, cmd, false)
+		"| pax -rw -pm ${DESTDIR}${PREFIX}/${${_dir_}}",
-		forclause := p.ForClause()
+		b.List().AddAndOr(b.AndOr(
-		c.Check(forclause, deepEquals, expected)
+			b.Pipeline(false, b.SimpleCommand("cd", "${WRKSRC}"))).Add("&&",
-		c.Check(p.tok.parser.Rest(), equals, "")
+			b.Pipeline(false,
-		c.Check(s.Output(), equals, "")
+				b.SimpleCommand("${FIND}", "${${_list_}}", "-type", "f", "!", "-name", "'*.orig'", "2>/dev/null"),
 				b.SimpleCommand("pax", "-rw", "-pm", "${DESTDIR}${PREFIX}/${${_dir_}}")))))
 	s.test("${CAT} ${PKGDIR}/PLIST | while read entry ; do : ; done",
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false,
 			b.SimpleCommand("${CAT}", "${PKGDIR}/PLIST"),
 			b.While(
 				b.List().AddCommand(b.SimpleCommand("read", "entry")).AddSeparator(";"),
 				b.List().AddCommand(b.SimpleCommand(":")).AddSeparator(";"))))))
 	s.test("while read entry ; do case \"$$entry\" in include/c-client/* ) ${INSTALL_DATA} $$src $$dest ; esac ; done",
 		b.List().AddCommand(b.While(
 			b.List().AddCommand(b.SimpleCommand("read", "entry")).AddSeparator(";"),
 			b.List().AddCommand(b.Case(
 				b.Token("\"$$entry\""),
 				b.CaseItem(
 					b.Words("include/c-client/*"),
 					b.List().AddCommand(b.SimpleCommand("${INSTALL_DATA}", "$$src", "$$dest")),
 					&SEP_SEMI))).AddSeparator(";"))))
 	s.test("command | while condition ; do case selector in pattern ) : ; esac ; done",
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false,
 			b.SimpleCommand("command"),
 			b.While(
 				b.List().AddCommand(b.SimpleCommand("condition")).AddSeparator(";"),
 				b.List().AddCommand(b.Case(
 					b.Token("selector"),
 					b.CaseItem(
 						b.Words("pattern"),
 						b.List().AddCommand(b.SimpleCommand(":")),
 						&SEP_SEMI))).AddSeparator(";"))))))
 	s.test("command1 \n command2 \n command3",
 		b.List().
 			AddCommand(b.SimpleCommand("command1")).
 			AddSeparator(SEP_NEWLINE).
 			AddCommand(b.SimpleCommand("command2")).
 			AddSeparator(SEP_NEWLINE).
 			AddCommand(b.SimpleCommand("command3")))
 	s.test("if condition; then action; else case selector in pattern) case-item-action ;; esac; fi",
 		b.List().AddCommand(b.If(
 			b.List().AddCommand(b.SimpleCommand("condition")).AddSeparator(";"),
 			b.List().AddCommand(b.SimpleCommand("action")).AddSeparator(";"),
 			b.List().AddCommand(b.Case(
 				b.Token("selector"),
 				b.CaseItem(
 					b.Words("pattern"),
 					b.List().AddCommand(b.SimpleCommand("case-item-action")), nil))).AddSeparator(";"))))
+}
 func (s *ShSuite) Test_ShellParser_list(c *check.C) {
 	b := s.init(c)
 	s.test("echo1 && echo2",
 		b.List().AddAndOr(
 			b.AndOr(b.Pipeline(false, b.SimpleCommand("echo1"))).
 				Add("&&", b.Pipeline(false, b.SimpleCommand("echo2")))))
 	s.test("echo1 ; echo2",
 		b.List().
 			AddCommand(b.SimpleCommand("echo1")).
 			AddSeparator(";").
 			AddCommand(b.SimpleCommand("echo2")))
 	s.test("echo1 ; echo2 &",
 		b.List().
 			AddCommand(b.SimpleCommand("echo1")).
 			AddSeparator(";").
 			AddCommand(b.SimpleCommand("echo2")).
 			AddSeparator("&"))
+}
 func (s *ShSuite) Test_ShellParser_and_or(c *check.C) {
 	b := s.init(c)
 	s.test("echo1 | echo2",
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false,
 			b.SimpleCommand("echo1"),
 			b.SimpleCommand("echo2")))))
 	s.test("echo1 | echo2 && echo3 | echo4",
 		b.List().AddAndOr(b.AndOr(
 			b.Pipeline(false,
 				b.SimpleCommand("echo1"),
 				b.SimpleCommand("echo2")),
 		).Add("&&",
 			b.Pipeline(false,
 				b.SimpleCommand("echo3"),
 				b.SimpleCommand("echo4")))))
 	s.test("echo1 | echo2 || ! echo3 | echo4",
 		b.List().AddAndOr(b.AndOr(
 			b.Pipeline(false,
 				b.SimpleCommand("echo1"),
 				b.SimpleCommand("echo2")),
 		).Add("||",
 			b.Pipeline(true,
 				b.SimpleCommand("echo3"),
 				b.SimpleCommand("echo4")))))
+}
 func (s *ShSuite) Test_ShellParser_pipeline(c *check.C) {
 	b := s.init(c)
 	s.test("command1 | command2",
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false,
 			b.SimpleCommand("command1"),
 			b.SimpleCommand("command2")))))
 	s.test("! command1 | command2",
 		b.List().AddAndOr(b.AndOr(b.Pipeline(true,
 			b.SimpleCommand("command1"),
 			b.SimpleCommand("command2")))))
+}
 func (s *ShSuite) Test_ShellParser_pipe_sequence(c *check.C) {
 	b := s.init(c)
 	s.test("command1 | if true ; then : ; fi",
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false,
 			b.SimpleCommand("command1"),
 			b.If(
 				b.List().AddCommand(b.SimpleCommand("true")).AddSeparator(";"),
 				b.List().AddCommand(b.SimpleCommand(":")).AddSeparator(";"))))))
+}
 func (s *ShSuite) Test_ShellParser_command(c *check.C) {
 	b := s.init(c)
 	s.test("simple_command",
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false, b.SimpleCommand("simple_command")))))
 	s.test("while 1 ; do 2 ; done",
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false,
 			b.While(
 				b.List().AddCommand(b.SimpleCommand("1")).AddSeparator(";"),
 				b.List().AddCommand(b.SimpleCommand("2")).AddSeparator(";"))))))
 	s.test("while 1 ; do 2 ; done 1 >& 2",
 		b.List().AddAndOr(b.AndOr(b.Pipeline(false,
 			b.While(
 				b.List().AddCommand(b.SimpleCommand("1")).AddSeparator(";"),
 				b.List().AddCommand(b.SimpleCommand("2")).AddSeparator(";"),
 				b.Redirection(1, ">&", "2"))))))
 	s.test("func ( ) { echo hello ; } 2 >& 1",
 		b.List().AddCommand(b.Function(
 			"func",
 			b.Brace(b.List().AddCommand(b.SimpleCommand("echo", "hello")).AddSeparator(";")).Compound,
 			b.Redirection(2, ">&", "1"))))
+}
 func (s *ShSuite) Test_ShellParser_compound_command(c *check.C) {
 	b := s.init(c)
 	s.test("{ brace ; }",
 		b.List().AddCommand(b.Brace(
 			b.List().AddCommand(b.SimpleCommand("brace")).AddSeparator(";"))))
 	s.test("( subshell )",
 		b.List().AddCommand(b.Subshell(
 			b.List().AddCommand(b.SimpleCommand("subshell")))))
 	s.test("for i in * ; do echo $i ; done",
 		b.List().AddCommand(b.For(
 			"i",
 			b.Words("*"),
 			b.List().AddCommand(b.SimpleCommand("echo", "$i")).AddSeparator(";"))))
 	s.test("case $i in esac",
 		b.List().AddCommand(b.Case(
 			b.Token("$i"))))
+}
 func (s *ShSuite) Test_ShellParser_subshell(c *check.C) {
 	b := s.init(c)
 	sub3 := b.Subshell(b.List().AddCommand(b.SimpleCommand("sub3")))
 	sub2 := b.Subshell(b.List().AddCommand(sub3).AddSeparator(";").AddCommand(b.SimpleCommand("sub2")))
 	sub1 := b.Subshell(b.List().AddCommand(sub2).AddSeparator(";").AddCommand(b.SimpleCommand("sub1")))
 	s.test("( ( ( sub3 ) ; sub2 ) ; sub1 )", b.List().AddCommand(sub1))
+}
 func (s *ShSuite) Test_ShellParser_compound_list(c *check.C) {
 	b := s.init(c)
 	s.test("( \n echo )",
 		b.List().AddCommand(b.Subshell(
 			b.List().AddCommand(b.SimpleCommand("echo")))))
+}
 func (s *ShSuite) Test_ShellParser_term(c *check.C) {
 	b := s.init(c)
 	_ = b
+}
 func (s *ShSuite) Test_ShellParser_for_clause(c *check.C) {
 	b := s.init(c)
 	s.test("for var do echo $var ; done",
 		b.List().AddCommand(b.For(
 			"var",
 			b.Words("\"$$@\""),
 			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSeparator(";"))))
 	// Only linebreak is allowed, but not semicolon.
 	s.test("for var \n do echo $var ; done",
 		b.List().AddCommand(b.For(
 			"var",
 			b.Words("\"$$@\""),
 			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSeparator(";"))))
 	s.test("for var in a b c ; do echo $var ; done",
 		b.List().AddCommand(b.For(
 			"var",
 			b.Words("a", "b", "c"),
 			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSeparator(";"))))
 	s.test("for var \n \n \n in a b c ; do echo $var ; done",
 		b.List().AddCommand(b.For(
 			"var",
 			b.Words("a", "b", "c"),
 			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSeparator(";"))))
 	s.test("for var in in esac ; do echo $var ; done",
 		b.List().AddCommand(b.For(
 			"var",
 			b.Words("in", "esac"),
 			b.List().AddCommand(b.SimpleCommand("echo", "$var")).AddSeparator(";"))))
 	// No semicolon necessary between the two “done”.
 	s.test("for i in 1; do for j in 1; do echo $$i$$j; done done",
 		b.List().AddCommand(b.For(
 			"i",
 			b.Words("1"),
 			b.List().AddCommand(b.For(
 				"j",
 				b.Words("1"),
 				b.List().AddCommand(b.SimpleCommand("echo", "$$i$$j")).AddSeparator(";"))))))
+}
 func (s *ShSuite) Test_ShellParser_case_clause(c *check.C) {
 	b := s.init(c)
 	s.test("case $var in esac",
 		b.List().AddCommand(b.Case(b.Token("$var"))))
 	s.test("case selector in pattern) ;; pattern) esac",
 		b.List().AddCommand(b.Case(
 			b.Token("selector"),
 			b.CaseItem(b.Words("pattern"), b.List(), nil),
 			b.CaseItem(b.Words("pattern"), b.List(), nil))))
 	s.test("case $$i in *.c | *.h ) echo C ;; * ) echo Other ; esac",
 		b.List().AddCommand(b.Case(
 			b.Token("$$i"),
 			b.CaseItem(b.Words("*.c", "*.h"), b.List().AddCommand(b.SimpleCommand("echo", "C")), nil),
 			b.CaseItem(b.Words("*"), b.List().AddCommand(b.SimpleCommand("echo", "Other")), &SEP_SEMI))))
 	s.test("case $$i in *.c ) echo ; esac",
 		b.List().AddCommand(b.Case(
 			b.Token("$$i"),
 			b.CaseItem(b.Words("*.c"), b.List().AddCommand(b.SimpleCommand("echo")), &SEP_SEMI))))
 	s.test("case selector in pattern) case-item-action ; esac",
 		b.List().AddCommand(b.Case(
 			b.Token("selector"),
 			b.CaseItem(
 				b.Words("pattern"),
 				b.List().AddCommand(b.SimpleCommand("case-item-action")), &SEP_SEMI))))
 	s.test("case selector in pattern) case-item-action ;; esac",
 		b.List().AddCommand(b.Case(
 			b.Token("selector"),
 			b.CaseItem(
 				b.Words("pattern"),
 				b.List().AddCommand(b.SimpleCommand("case-item-action")), nil))))
+}
 func (s *ShSuite) Test_ShellParser_if_clause(c *check.C) {
 	b := s.init(c)
 	s.test(
 		"if true ; then echo yes ; else echo no ; fi",
 		b.List().AddCommand(b.If(
 			b.List().AddCommand(b.SimpleCommand("true")).AddSeparator(";"),
 			b.List().AddCommand(b.SimpleCommand("echo", "yes")).AddSeparator(";"),
 			b.List().AddCommand(b.SimpleCommand("echo", "no")).AddSeparator(";"))))
 	// No semicolon necessary between the two “fi”.
 	s.test("if cond1; then if cond2; then action; fi fi",
 		b.List().AddCommand(b.If(
 			b.List().AddCommand(b.SimpleCommand("cond1")).AddSeparator(";"),
 			b.List().AddCommand(b.If(
 				b.List().AddCommand(b.SimpleCommand("cond2")).AddSeparator(";"),
 				b.List().AddCommand(b.SimpleCommand("action")).AddSeparator(";"))))))
+}
 func (s *ShSuite) Test_ShellParser_while_clause(c *check.C) {
 	b := s.init(c)
 	s.test("while condition ; do action ; done",
 		b.List().AddCommand(b.While(
 			b.List().AddCommand(b.SimpleCommand("condition")).AddSeparator(";"),
 			b.List().AddCommand(b.SimpleCommand("action")).AddSeparator(";"))))
+}
 func (s *ShSuite) Test_ShellParser_until_clause(c *check.C) {
 	b := s.init(c)
 	s.test("until condition ; do action ; done",
 		b.List().AddCommand(b.Until(
 			b.List().AddCommand(b.SimpleCommand("condition")).AddSeparator(";"),
 			b.List().AddCommand(b.SimpleCommand("action")).AddSeparator(";"))))
+}
 func (s *ShSuite) Test_ShellParser_function_definition(c *check.C) {
 	b := s.init(c)
 	_ = b
+}
 func (s *ShSuite) Test_ShellParser_brace_group(c *check.C) {
 	b := s.init(c)
 	// No semicolon necessary after the closing brace.
 	s.test("if true; then { echo yes; } fi",
 		b.List().AddCommand(b.If(
 			b.List().AddCommand(b.SimpleCommand("true")).AddSeparator(";"),
 			b.List().AddCommand(b.Brace(
 				b.List().AddCommand(b.SimpleCommand("echo", "yes")).AddSeparator(";"))))))
+}
 func (s *ShSuite) Test_ShellParser_simple_command(c *check.C) {
 	b := s.init(c)
 	s.test(
 		"echo hello, world",
 		b.List().AddCommand(b.SimpleCommand("echo", "hello,", "world")))
 	s.test("echo ${PKGNAME:Q}",
 		b.List().AddCommand(b.SimpleCommand("echo", "${PKGNAME:Q}")))
 	s.test("${ECHO} \"Double-quoted\" 'Single-quoted'",
 		b.List().AddCommand(b.SimpleCommand("${ECHO}", "\"Double-quoted\"", "'Single-quoted'")))
 	s.test("`cat plain` \"`cat double`\" '`cat single`'",
 		b.List().AddCommand(b.SimpleCommand("`cat plain`", "\"`cat double`\"", "'`cat single`'")))
 	s.test("`\"one word\"`",
 		b.List().AddCommand(b.SimpleCommand("`\"one word\"`")))
 	s.test("PAGES=\"`ls -1 | ${SED} -e 's,3qt$$,3,'`\"",
 		b.List().AddCommand(b.SimpleCommand("PAGES=\"`ls -1 | ${SED} -e 's,3qt$$,3,'`\"")))
 	s.test("var=Plain var=\"Dquot\" var='Squot' var=Plain\"Dquot\"'Squot'",
 		b.List().AddCommand(b.SimpleCommand("var=Plain", "var=\"Dquot\"", "var='Squot'", "var=Plain\"Dquot\"'Squot'")))
 	// RUN is a special Make variable since it ends with a semicolon;
 	// therefore it needs to be split off before passing the rest of
 	// the command to the shell command parser.
 	s.test("${RUN} subdir=\"`unzip -c \"$$e\" install.rdf | awk '/re/ { print \"hello\" }'`\"",
 		b.List().AddCommand(b.SimpleCommand("${RUN}", "subdir=\"`unzip -c \"$$e\" install.rdf | awk '/re/ { print \"hello\" }'`\"")))
 	s.test("PATH=/nonexistent env PATH=${PATH:Q} true",
 		b.List().AddCommand(b.SimpleCommand("PATH=/nonexistent", "env", "PATH=${PATH:Q}", "true")))
 	s.test("{OpenGrok args",
 		b.List().AddCommand(b.SimpleCommand("{OpenGrok", "args")))
+}
 func (s *ShSuite) Test_ShellParser_io_redirect(c *check.C) {
 	b := s.init(c)
 	s.test("echo >> ${PLIST_SRC}",
 		b.List().AddCommand(b.SimpleCommand("echo", ">>${PLIST_SRC}")))
 	s.test("echo >> ${PLIST_SRC}",
 		b.List().AddCommand(b.SimpleCommand("echo", ">>${PLIST_SRC}")))
 	s.test("echo 1>output 2>>append 3>|clobber 4>&5 6<input >>append",
 		b.List().AddCommand(&MkShCommand{Simple: &MkShSimpleCommand{
 			Assignments: nil,
 			Name:        b.Token("echo"),
 			Args:        nil,
 			Redirections: []*MkShRedirection{
 				{1, ">", b.Token("output")},
 				{2, ">>", b.Token("append")},
 				{3, ">|", b.Token("clobber")},
 				{4, ">&", b.Token("5")},
 				{6, "<", b.Token("input")},
 				{-1, ">>", b.Token("append")}}}}))
 	s.test("echo 1> output 2>> append 3>| clobber 4>& 5 6< input >> append",
 		b.List().AddCommand(&MkShCommand{Simple: &MkShSimpleCommand{
 			Assignments: nil,
 			Name:        b.Token("echo"),
 			Args:        nil,
 			Redirections: []*MkShRedirection{
 				{1, ">", b.Token("output")},
 				{2, ">>", b.Token("append")},
 				{3, ">|", b.Token("clobber")},
 				{4, ">&", b.Token("5")},
 				{6, "<", b.Token("input")},
 				{-1, ">>", b.Token("append")}}}}))
+}
 func (s *ShSuite) Test_ShellParser_io_here(c *check.C) {
 	b := s.init(c)
 	_ = b
+}
 func (s *ShSuite) init(c *check.C) *MkShBuilder {
 	s.c = c
 	return NewMkShBuilder()
+}
 func (s *ShSuite) test(program string, expected *MkShList) {
 	tokens, rest := splitIntoShellTokens(dummyLine, program)
 	s.c.Check(rest, equals, "")
 	lexer := &ShellLexer{
 		current:        "",
 		remaining:      tokens,
 		atCommandStart: true,
 		error:          ""}
 	parser := &shyyParserImpl{}
 	succeeded := parser.Parse(lexer)
 	c := s.c
 	if ok1, ok2 := c.Check(succeeded, equals, 0), c.Check(lexer.error, equals, ""); ok1 && ok2 {
 		if !c.Check(lexer.result, deepEquals, expected) {
 			actualJson, actualErr := json.MarshalIndent(lexer.result, "", "  ")
 			expectedJson, expectedErr := json.MarshalIndent(expected, "", "  ")
 			if c.Check(actualErr, check.IsNil) && c.Check(expectedErr, check.IsNil) {
 				c.Check(string(actualJson), deepEquals, string(expectedJson))
+			}
+		}
 	} else {
 		c.Check(lexer.remaining, deepEquals, []string{})
+	}
 	tester := &MkShTester{c}
 	params := []*ShToken{tester.Token("\"$$@\"")}
 	action := tester.ParseCompoundList("action;")
 	parse("for var; do action; done",
 		&MkShForClause{"var", params, action})
 	abc := []*ShToken{tester.Token("a"), tester.Token("b"), tester.Token("c")}
 	parse("for var in a b c; do action; done",
 		&MkShForClause{"var", abc, action})
 	actions := tester.ParseCompoundList("action1 && action2;")
 	parse("for var in a b c; do action1 && action2; done",
 		&MkShForClause{"var", abc, actions})
 func (s *Suite) Test_MkShParser_Wordlist(c *check.C) {
 func (s *Suite) Test_MkShParser_CaseClause(c *check.C) {
 func (s *Suite) Test_MkShParser_CaseItem(c *check.C) {
 func (s *Suite) Test_MkShParser_Pattern(c *check.C) {
+}
-func (s *Suite) Test_MkShParser_IfClause(c *check.C) {
+type MkShBuilder struct {
+}
-func (s *Suite) Test_MkShParser_WhileClause(c *check.C) {
+func NewMkShBuilder() *MkShBuilder {
 	return &MkShBuilder{}
+}
-func (s *Suite) Test_MkShParser_UntilClause(c *check.C) {
+func (b *MkShBuilder) List() *MkShList {
 	return NewMkShList()
+}
-func (s *Suite) Test_MkShParser_FunctionDefinition(c *check.C) {
+func (b *MkShBuilder) AndOr(pipeline *MkShPipeline) *MkShAndOr {
 	return NewMkShAndOr(pipeline)
+}
-func (s *Suite) Test_MkShParser_BraceGroup(c *check.C) {
+func (b *MkShBuilder) Pipeline(negated bool, cmds ...*MkShCommand) *MkShPipeline {
 	return NewMkShPipeline(negated, cmds...)
+}
-func (s *Suite) Test_MkShParser_DoGroup(c *check.C) {
+func (b *MkShBuilder) SimpleCommand(words ...string) *MkShCommand {
-	tester := &MkShTester{c}
+	cmd := &MkShSimpleCommand{}
-	check := func(str string, expected *MkShList) {
+	assignments := true
-		p := NewMkShParser(dummyLine, str, false)
+	for _, word := range words {
-		dogroup := p.DoGroup()
+		if assignments && matches(word, `^\w+=`) {
-		if c.Check(dogroup, check.NotNil) {
+			cmd.Assignments = append(cmd.Assignments, b.Token(word))
-			if !c.Check(dogroup, deepEquals, expected) {
+		} else if m, fdstr, op, rest := match3(word, `^(\d*)(<<-|<<|<&|>>|>&|>\||<|>)(.*)$`); m {
-				for i, andor := range dogroup.AndOrs {
+			fd, err := strconv.Atoi(fdstr)
-					c.Check(andor, deepEquals, expected.AndOrs[i])
+			if err != nil {
 				fd = -1
+			}
 			cmd.Redirections = append(cmd.Redirections, b.Redirection(fd, op, rest))
-		c.Check(p.tok.parser.Rest(), equals, "")
+		} else {
-		c.Check(s.Output(), equals, "")
+			assignments = false
 			if cmd.Name == nil {
 				cmd.Name = b.Token(word)
-	andor := NewMkShAndOr(NewMkShPipeline(false, tester.ParseCommand("action")))
+			} else {
-	check("do action; done",
+				cmd.Args = append(cmd.Args, b.Token(word))
 		&MkShList{[]*MkShAndOr{andor}, []MkShSeparator{";"}})
 func (s *Suite) Test_MkShParser_SimpleCommand(c *check.C) {
 	parse := func(cmd string, builder *SimpleCommandBuilder) {
 		expected := builder.Cmd
 		p := NewMkShParser(dummyLine, cmd, false)
 		shcmd := p.SimpleCommand()
 		if c.Check(shcmd, check.NotNil) {
 			if !c.Check(shcmd, deepEquals, expected) {
 				for i, assignment := range shcmd.Assignments {
 					c.Check(assignment, deepEquals, expected.Assignments[i])
 				c.Check(shcmd.Name, deepEquals, expected.Name)
 				for i, word := range shcmd.Args {
 					c.Check(word, deepEquals, expected.Args[i])
 				for i, redirection := range shcmd.Redirections {
 					c.Check(redirection, deepEquals, expected.Redirections[i])
+			}
+		}
 		c.Check(p.tok.parser.Rest(), equals, "")
 		c.Check(s.Output(), equals, "")
 	fail := func(noncmd string, expectedRest string) {
 		p := NewMkShParser(dummyLine, noncmd, false)
 		shcmd := p.SimpleCommand()
 		c.Check(shcmd, check.IsNil)
 		c.Check(p.tok.parser.Rest(), equals, expectedRest)
 		c.Check(s.Output(), equals, "")
+	}
-	tester := &MkShTester{c}
+	return &MkShCommand{Simple: cmd}
 	parse("echo ${PKGNAME:Q}",
 		NewSimpleCommandBuilder().
 			Name(tester.Token("echo")).
 			Arg(tester.Token("${PKGNAME:Q}")))
 	parse("${ECHO} \"Double-quoted\" 'Single-quoted'",
 		NewSimpleCommandBuilder().
 			Name(tester.Token("${ECHO}")).
 			Arg(tester.Token("\"Double-quoted\"")).
 			Arg(tester.Token("'Single-quoted'")))
 	parse("`cat plain` \"`cat double`\" '`cat single`'",
 		NewSimpleCommandBuilder().
 			Name(tester.Token("`cat plain`")).
 			Arg(tester.Token("\"`cat double`\"")).
 			Arg(tester.Token("'`cat single`'")))
 	parse("`\"one word\"`",
 		NewSimpleCommandBuilder().
 			Name(tester.Token("`\"one word\"`")))
 	parse("PAGES=\"`ls -1 | ${SED} -e 's,3qt$$,3,'`\"",
 		NewSimpleCommandBuilder().
 			Assignment(tester.Token("PAGES=\"`ls -1 | ${SED} -e 's,3qt$$,3,'`\"")))
 	parse("var=Plain var=\"Dquot\" var='Squot' var=Plain\"Dquot\"'Squot'",
 		NewSimpleCommandBuilder().
 			Assignment(tester.Token("var=Plain")).
 			Assignment(tester.Token("var=\"Dquot\"")).
 			Assignment(tester.Token("var='Squot'")).
 			Assignment(tester.Token("var=Plain\"Dquot\"'Squot'")))
 	parse("${RUN} subdir=\"`unzip -c \"$$e\" install.rdf | awk '/re/ { print \"hello\" }'`\"",
 		NewSimpleCommandBuilder().
 			Name(tester.Token("${RUN}")).
 			Arg(tester.Token("subdir=\"`unzip -c \"$$e\" install.rdf | awk '/re/ { print \"hello\" }'`\"")))
 	parse("PATH=/nonexistent env PATH=${PATH:Q} true",
 		NewSimpleCommandBuilder().
 			Assignment(tester.Token("PATH=/nonexistent")).
 			Name(tester.Token("env")).
 			Arg(tester.Token("PATH=${PATH:Q}")).
 			Arg(tester.Token("true")))
 	parse("{OpenGrok args",
 		NewSimpleCommandBuilder().
 			Name(tester.Token("{OpenGrok")).
 			Arg(tester.Token("args")))
 	fail("if clause", "if clause")
 	fail("{ group; }", "{ group; }")
 func (s *Suite) Test_MkShParser_RedirectList(c *check.C) {
 func (s *Suite) Test_MkShParser_IoRedirect(c *check.C) {
 func (s *Suite) Test_MkShParser_IoFile(c *check.C) {
 func (s *Suite) Test_MkShParser_IoHere(c *check.C) {
 func (s *Suite) Test_MkShParser_NewlineList(c *check.C) {
+}
-func (s *Suite) Test_MkShParser_Linebreak(c *check.C) {
+func (b *MkShBuilder) If(condActionElse ...*MkShList) *MkShCommand {
 	ifclause := &MkShIfClause{}
 	for i, part := range condActionElse {
 		if i%2 == 0 && i != len(condActionElse)-1 {
 			ifclause.Conds = append(ifclause.Conds, part)
 		} else if i%2 == 1 {
 			ifclause.Actions = append(ifclause.Actions, part)
 		} else {
 			ifclause.Else = part
+		}
+	}
 	return &MkShCommand{Compound: &MkShCompoundCommand{If: ifclause}}
+}
-func (s *Suite) Test_MkShParser_SeparatorOp(c *check.C) {
+func (b *MkShBuilder) For(varname string, items []*ShToken, action *MkShList) *MkShCommand {
 	return &MkShCommand{Compound: &MkShCompoundCommand{For: &MkShForClause{varname, items, action}}}
+}
-func (s *Suite) Test_MkShParser_Separator(c *check.C) {
+func (b *MkShBuilder) Case(selector *ShToken, items ...*MkShCaseItem) *MkShCommand {
 	return &MkShCommand{Compound: &MkShCompoundCommand{Case: &MkShCaseClause{selector, items}}}
+}
-func (s *Suite) Test_MkShParser_SequentialSep(c *check.C) {
+func (b *MkShBuilder) CaseItem(patterns []*ShToken, action *MkShList, separator *MkShSeparator) *MkShCaseItem {
 	return &MkShCaseItem{patterns, action, separator}
+}
-func (s *Suite) Test_MkShParser_Word(c *check.C) {
+func (b *MkShBuilder) While(cond, action *MkShList, redirects ...*MkShRedirection) *MkShCommand {
 	return &MkShCommand{
 		Compound: &MkShCompoundCommand{
 			Loop: &MkShLoopClause{cond, action, false}},
 		Redirects: redirects}
+}
-type MkShTester struct {
+func (b *MkShBuilder) Until(cond, action *MkShList, redirects ...*MkShRedirection) *MkShCommand {
-	c *check.C
+	return &MkShCommand{
 		Compound: &MkShCompoundCommand{
 			Loop: &MkShLoopClause{cond, action, true}},
 		Redirects: redirects}
+}
-func (t *MkShTester) ParseCommand(str string) *MkShCommand {
+func (b *MkShBuilder) Function(name string, body *MkShCompoundCommand, redirects ...*MkShRedirection) *MkShCommand {
-	p := NewMkShParser(dummyLine, str, false)
+	return &MkShCommand{
-	cmd := p.Command()
+		FuncDef:   &MkShFunctionDefinition{name, body},
-	t.c.Check(cmd, check.NotNil)
+		Redirects: redirects}
 	t.c.Check(p.Rest(), equals, "")
 	return cmd
+}
-func (t *MkShTester) ParseSimpleCommand(str string) *MkShSimpleCommand {
+func (b *MkShBuilder) Brace(list *MkShList) *MkShCommand {
-	p := NewMkShParser(dummyLine, str, false)
+	return &MkShCommand{Compound: &MkShCompoundCommand{Brace: list}}
 	parsed := p.SimpleCommand()
 	t.c.Check(parsed, check.NotNil)
 	t.c.Check(p.Rest(), equals, "")
 	return parsed
+}
-func (t *MkShTester) ParseCompoundList(str string) *MkShList {
+func (b *MkShBuilder) Subshell(list *MkShList) *MkShCommand {
-	p := NewMkShParser(dummyLine, str, false)
+	return &MkShCommand{Compound: &MkShCompoundCommand{Subshell: list}}
 	parsed := p.CompoundList()
 	t.c.Check(parsed, check.NotNil)
 	t.c.Check(p.Rest(), equals, "")
 	return parsed
+}
-func (t *MkShTester) Token(str string) *ShToken {
+func (b *MkShBuilder) Token(mktext string) *ShToken {
-	p := NewMkShParser(dummyLine, str, false)
+	tokenizer := NewShTokenizer(dummyLine, mktext, false)
-	parsed := p.peek()
+	token := tokenizer.ShToken()
-	p.skip()
+	return token
 	t.c.Check(parsed, check.NotNil)
 	t.c.Check(p.Rest(), equals, "")
 	return parsed
+}
-type SimpleCommandBuilder struct {
+func (b *MkShBuilder) Words(words ...string) []*ShToken {
-	Cmd *MkShSimpleCommand
+	tokens := make([]*ShToken, len(words))
 	for i, word := range words {
 		tokens[i] = b.Token(word)
+	}
 	return tokens
+}
-func NewSimpleCommandBuilder() *SimpleCommandBuilder {
+func (b *MkShBuilder) Redirection(fd int, op string, target string) *MkShRedirection {
-	cmd := &MkShSimpleCommand{}
+	return &MkShRedirection{fd, op, b.Token(target)}
 	return &SimpleCommandBuilder{cmd}
 func (b *SimpleCommandBuilder) Name(name *ShToken) *SimpleCommandBuilder {
 	b.Cmd.Name = name
 	return b
 func (b *SimpleCommandBuilder) Assignment(assignment *ShToken) *SimpleCommandBuilder {
 	b.Cmd.Assignments = append(b.Cmd.Assignments, assignment)
 	return b
 func (b *SimpleCommandBuilder) Arg(arg *ShToken) *SimpleCommandBuilder {
 	b.Cmd.Args = append(b.Cmd.Args, arg)
 	return b
 func (b *SimpleCommandBuilder) Redirection(redirection *MkShRedirection) *SimpleCommandBuilder {
 	b.Cmd.Redirections = append(b.Cmd.Redirections, redirection)
 	return b
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/mkshtypes.go 2016/06/05 11:24:32 1.1
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkshtypes.go 2016/07/07 12:09:27 1.2

 @@ -1,231 +1,173 @@
 package main
-import (
+import "fmt"
 	"fmt"
 type MkShList struct {
 	AndOrs     []*MkShAndOr
 	Separators []MkShSeparator
+}
 func NewMkShList() *MkShList {
 	return &MkShList{nil, nil}
+}
 func (list *MkShList) String() string {
 	return fmt.Sprintf("MkShList(%v)", list.AndOrs)
 func (list *MkShList) AddAndOr(andor *MkShAndOr) *MkShList {
 	list.AndOrs = append(list.AndOrs, andor)
 	return list
+}
 func (list *MkShList) AddSeparator(separator MkShSeparator) *MkShList {
 	list.Separators = append(list.Separators, separator)
 	return list
+}
 type MkShAndOr struct {
 	Pipes []*MkShPipeline
 	Ops   []string // Either "&&" or "||"
+}
 func NewMkShAndOr(pipeline *MkShPipeline) *MkShAndOr {
 	return &MkShAndOr{[]*MkShPipeline{pipeline}, nil}
+}
 func (andor *MkShAndOr) String() string {
 	return fmt.Sprintf("MkShAndOr(%v)", andor.Pipes)
 func (andor *MkShAndOr) Add(op string, pipeline *MkShPipeline) *MkShAndOr {
 	andor.Pipes = append(andor.Pipes, pipeline)
 	andor.Ops = append(andor.Ops, op)
 	return andor
+}
 type MkShPipeline struct {
 	Negated bool
 	Cmds    []*MkShCommand
+}
 func NewMkShPipeline(negated bool, cmds ...*MkShCommand) *MkShPipeline {
 	return &MkShPipeline{negated, cmds}
+}
 func (pipe *MkShPipeline) String() string {
 	return fmt.Sprintf("MkShPipeline(%v)", pipe.Cmds)
 func (pipe *MkShPipeline) Add(cmd *MkShCommand) *MkShPipeline {
 	pipe.Cmds = append(pipe.Cmds, cmd)
 	return pipe
+}
 type MkShCommand struct {
 	Simple    *MkShSimpleCommand
 	Compound  *MkShCompoundCommand
 	FuncDef   *MkShFunctionDefinition
 	Redirects []*MkShRedirection // For Compound and FuncDef
+}
 func (cmd *MkShCommand) String() string {
 	switch {
 	case cmd.Simple != nil:
 		return cmd.Simple.String()
 	case cmd.Compound != nil:
 		return cmd.Compound.String()
 	case cmd.FuncDef != nil:
 		return cmd.FuncDef.String()
 	return "MkShCommand(?)"
 type MkShCompoundCommand struct {
 	Brace    *MkShList
 	Subshell *MkShList
 	For      *MkShForClause
 	Case     *MkShCaseClause
 	If       *MkShIfClause
-	While    *MkShLoopClause
+	Loop     *MkShLoopClause
 	Until    *MkShLoopClause
 func (cmd *MkShCompoundCommand) String() string {
 	switch {
 	case cmd.Brace != nil:
 		return cmd.Brace.String()
 	case cmd.Subshell != nil:
 		return cmd.Subshell.String()
 	case cmd.For != nil:
 		return cmd.For.String()
 	case cmd.Case != nil:
 		return cmd.Case.String()
 	case cmd.If != nil:
 		return cmd.If.String()
 	case cmd.While != nil:
 		return cmd.While.String()
 	case cmd.Until != nil:
 		return cmd.Until.String()
 	return "MkShCompoundCommand(?)"
+}
 type MkShForClause struct {
 	Varname string
 	Values  []*ShToken
 	Body    *MkShList
+}
 func (cl *MkShForClause) String() string {
 	return fmt.Sprintf("MkShForClause(%v, %v, %v)", cl.Varname, cl.Values, cl.Body)
 type MkShCaseClause struct {
 	Word  *ShToken
 	Cases []*MkShCaseItem
+}
 func (cl *MkShCaseClause) String() string {
 	return fmt.Sprintf("MkShCaseClause(...)")
 type MkShCaseItem struct {
-	Patterns []*ShToken
+	Patterns  []*ShToken
-	Action   *MkShList
+	Action    *MkShList
 	Separator *MkShSeparator
+}
 type MkShIfClause struct {
 	Conds   []*MkShList
 	Actions []*MkShList
 	Else    *MkShList
+}
 func (cl *MkShIfClause) String() string {
 	return "MkShIf(...)"
 func (cl *MkShIfClause) Prepend(cond *MkShList, action *MkShList) {
 	cl.Conds = append([]*MkShList{cond}, cl.Conds...)
 	cl.Actions = append([]*MkShList{action}, cl.Actions...)
+}
 type MkShLoopClause struct {
 	Cond   *MkShList
 	Action *MkShList
 	Until  bool
+}
 func (cl *MkShLoopClause) String() string {
 	return "MkShLoop(...)"
 type MkShFunctionDefinition struct {
-	Name      string
+	Name string
-	Body      *MkShCompoundCommand
+	Body *MkShCompoundCommand
 	Redirects []*MkShRedirection
 func (def *MkShFunctionDefinition) String() string {
 	return "MkShFunctionDef(...)"
+}
 type MkShSimpleCommand struct {
 	Assignments  []*ShToken
 	Name         *ShToken
 	Args         []*ShToken
 	Redirections []*MkShRedirection
+}
-func (scmd *MkShSimpleCommand) String() string {
+func NewStrCommand(cmd *MkShSimpleCommand) *StrCommand {
-	str := "SimpleCommand("
+	strcmd := &StrCommand{
-	first := true
+		make([]string, len(cmd.Assignments)),
-	sep := func() {
+		"",
-		if first {
+		make([]string, len(cmd.Args))}
-			first = false
+	for i, assignment := range cmd.Assignments {
-		} else {
+		strcmd.Assignments[i] = assignment.MkText
 			str += ", "
+	}
-	for _, word := range scmd.Assignments {
+	if cmd.Name != nil {
-		sep()
+		strcmd.Name = cmd.Name.MkText
 		str += word.MkText
+	}
-	if word := scmd.Name; word != nil {
+	for i, arg := range cmd.Args {
-		sep()
+		strcmd.Args[i] = arg.MkText
 		str += word.MkText
+	}
-	for _, word := range scmd.Args {
+	return strcmd
 		sep()
 		str += word.MkText
 type StrCommand struct {
 	Assignments []string
 	Name        string
 	Args        []string
+}
 func (c *StrCommand) HasOption(opt string) bool {
 	for _, arg := range c.Args {
 		if arg == opt {
 			return true
+		}
+	}
-	for _, redirection := range scmd.Redirections {
+	return false
 		sep()
 		str += redirection.String()
 func (c *StrCommand) AnyArgMatches(pattern string) bool {
 	for _, arg := range c.Args {
 		if matches(arg, pattern) {
 			return true
+		}
+	}
-	return str + ")"
+	return false
+}
 func (c *StrCommand) String() string {
 	return fmt.Sprintf("%v %v %v", c.Assignments, c.Name, c.Args)
+}
 type MkShRedirection struct {
 	Fd     int // Or -1
 	Op     string
 	Target *ShToken
+}
 func (r *MkShRedirection) String() string {
 	if r.Fd != -1 {
 		return fmt.Sprintf("%d%s%s", r.Fd, r.Op, r.Target.MkText)
 	} else {
 		return r.Op + r.Target.MkText
 // One of ";", "&", "\n"
 type MkShSeparator string
-func (sep *MkShSeparator) String() string {
+var (
-	return fmt.Sprintf("%q", sep)
+	SEP_SEMI       MkShSeparator = ";"
 	SEP_BACKGROUND MkShSeparator = "&"
 	SEP_NEWLINE    MkShSeparator = "\n"
+)

--- pkgsrc/pkgtools/pkglint/files/Attic/mktypes_test.go 2016/06/05 11:24:32 1.1
+++ pkgsrc/pkgtools/pkglint/files/Attic/mktypes_test.go 2016/07/07 12:09:27 1.2

 @@ -1,11 +1,17 @@
 package main
 import (
 	check "gopkg.in/check.v1"
+)
 func (s *Suite) Test_MkVarUse_Mod(c *check.C) {
 	varuse := &MkVarUse{"varname", []string{"Q"}}
 	c.Check(varuse.Mod(), equals, ":Q")
+}
 func (list *MkShList) AddCommand(command *MkShCommand) *MkShList {
 	pipeline := NewMkShPipeline(false, command)
 	andOr := NewMkShAndOr(pipeline)
 	return list.AddAndOr(andOr)
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/shtokenizer.go 2016/06/05 11:24:32 1.1
+++ pkgsrc/pkgtools/pkglint/files/Attic/shtokenizer.go 2016/07/07 12:09:27 1.2

 @@ -24,74 +24,80 @@ func (p *ShTokenizer) ShAtom(quoting ShQ
 		return &ShAtom{shtVaruse, repl.Since(mark), quoting, varuse}
+	}
 	var atom *ShAtom
 	switch quoting {
 	case shqPlain:
 		atom = p.shAtomPlain()
 	case shqDquot:
 		atom = p.shAtomDquot()
 	case shqSquot:
 		atom = p.shAtomSquot()
 	case shqBackt:
 		atom = p.shAtomBackt()
 	case shqSubsh:
 		atom = p.shAtomSub()
 	case shqDquotBackt:
 		atom = p.shAtomDquotBackt()
 	case shqBacktDquot:
 		atom = p.shAtomBacktDquot()
 	case shqBacktSquot:
 		atom = p.shAtomBacktSquot()
 	case shqSubshSquot:
 		atom = p.shAtomSubshSquot()
 	case shqDquotBacktDquot:
 		atom = p.shAtomDquotBacktDquot()
 	case shqDquotBacktSquot:
 		atom = p.shAtomDquotBacktSquot()
+	}
 	if atom == nil {
 		repl.Reset(mark)
 		p.parser.Line.Warnf("Pkglint parse error in ShTokenizer.ShAtom at %q (quoting=%s)", repl.rest, quoting)
+	}
 	return atom
+}
 func (p *ShTokenizer) shAtomPlain() *ShAtom {
 	q := shqPlain
 	repl := p.parser.repl
 	switch {
 	case repl.AdvanceHspace():
 		return &ShAtom{shtSpace, repl.s, q, nil}
 	case repl.AdvanceStr("\n"):
 		return &ShAtom{shtNewline, repl.s, q, nil}
 	case repl.AdvanceStr(";;"):
 		return &ShAtom{shtCaseSeparator, repl.s, q, nil}
 	case repl.AdvanceStr(";"):
 		return &ShAtom{shtSemicolon, repl.s, q, nil}
 	case repl.AdvanceStr("("):
 		return &ShAtom{shtParenOpen, repl.s, q, nil}
 	case repl.AdvanceStr(")"):
 		return &ShAtom{shtParenClose, repl.s, q, nil}
 	case repl.AdvanceStr("||"):
 		return &ShAtom{shtOr, repl.s, q, nil}
 	case repl.AdvanceStr("&&"):
 		return &ShAtom{shtAnd, repl.s, q, nil}
 	case repl.AdvanceStr("|"):
 		return &ShAtom{shtPipe, repl.s, q, nil}
 	case repl.AdvanceStr("&"):
 		return &ShAtom{shtBackground, repl.s, q, nil}
 	case repl.AdvanceStr("\""):
 		return &ShAtom{shtWord, repl.s, shqDquot, nil}
 	case repl.AdvanceStr("'"):
 		return &ShAtom{shtWord, repl.s, shqSquot, nil}
 	case repl.AdvanceStr("`"):
 		return &ShAtom{shtWord, repl.s, shqBackt, nil}
-	case repl.AdvanceRegexp(`^(?:<|<<|>|>>|>&)`):
+	case repl.AdvanceRegexp(`^\d*(?:<<-|<<|<&|<>|>>|>&|>\||<|>)`):
 		return &ShAtom{shtRedirect, repl.m[0], q, nil}
 	case repl.AdvanceRegexp(`^#.*`):
 		return &ShAtom{shtComment, repl.m[0], q, nil}
 	case repl.AdvanceStr("$$("):
 		return &ShAtom{shtSubshell, repl.s, q, nil}
 	case repl.AdvanceRegexp(`^(?:[!#%*+,\-./0-9:=?@A-Z\[\]^_a-z{}~]+|\\[^$]|` + reShDollar + `)+`):
 		return &ShAtom{shtWord, repl.m[0], q, nil}
+	}
 	return nil
+}
 func (p *ShTokenizer) shAtomDquot() *ShAtom {
 	repl := p.parser.repl
 @@ -145,26 +151,66 @@ func (p *ShTokenizer) shAtomBackt() *ShA
 		return &ShAtom{shtPipe, repl.s, q, nil}
 	case repl.AdvanceStr("&"):
 		return &ShAtom{shtBackground, repl.s, q, nil}
 	case repl.AdvanceRegexp(`^(?:<|<<|>|>>|>&)`):
 		return &ShAtom{shtRedirect, repl.s, q, nil}
 	case repl.AdvanceRegexp("^#[^`]*"):
 		return &ShAtom{shtComment, repl.s, q, nil}
 	case repl.AdvanceRegexp(`^(?:[!#%*+,\-./0-9:=?@A-Z\[\]_a-z~]+|\\[^$]|` + reShDollar + `)+`):
 		return &ShAtom{shtWord, repl.s, q, nil}
+	}
 	return nil
+}
 func (p *ShTokenizer) shAtomSub() *ShAtom {
 	const q = shqSubsh
 	repl := p.parser.repl
 	mark := repl.Mark()
 	atom := func(typ ShAtomType) *ShAtom {
 		return NewShAtom(typ, repl.Since(mark), shqSubsh)
+	}
 	switch {
 	case repl.AdvanceHspace():
 		return atom(shtSpace)
 	case repl.AdvanceStr(";;"):
 		return atom(shtCaseSeparator)
 	case repl.AdvanceStr(";"):
 		return atom(shtSemicolon)
 	case repl.AdvanceStr("||"):
 		return atom(shtOr)
 	case repl.AdvanceStr("&&"):
 		return atom(shtAnd)
 	case repl.AdvanceStr("|"):
 		return atom(shtPipe)
 	case repl.AdvanceStr("&"):
 		return atom(shtBackground)
 	case repl.AdvanceStr("\""):
 		//return &ShAtom{shtWord, repl.s, shqDquot, nil}
 	case repl.AdvanceStr("'"):
 		return &ShAtom{shtWord, repl.s, shqSubshSquot, nil}
 	case repl.AdvanceStr("`"):
 		//return &ShAtom{shtWord, repl.s, shqBackt, nil}
 	case repl.AdvanceRegexp(`^\d*(?:<<-|<<|<&|<>|>>|>&|>\||<|>)`):
 		return &ShAtom{shtRedirect, repl.m[0], q, nil}
 	case repl.AdvanceRegexp(`^#.*`):
 		return &ShAtom{shtComment, repl.m[0], q, nil}
 	case repl.AdvanceStr(")"):
 		return NewShAtom(shtWord, repl.s, shqPlain)
 	case repl.AdvanceRegexp(`^(?:[!#%*+,\-./0-9:=?@A-Z\[\]^_a-z{}~]+|\\[^$]|` + reShDollar + `)+`):
 		return &ShAtom{shtWord, repl.m[0], q, nil}
+	}
 	return nil
+}
 func (p *ShTokenizer) shAtomDquotBackt() *ShAtom {
 	const q = shqDquotBackt
 	repl := p.parser.repl
 	switch {
 	case repl.AdvanceStr("`"):
 		return &ShAtom{shtWord, repl.s, shqDquot, nil}
 	case repl.AdvanceStr("\""):
 		return &ShAtom{shtWord, repl.s, shqDquotBacktDquot, nil}
 	case repl.AdvanceStr("'"):
 		return &ShAtom{shtWord, repl.s, shqDquotBacktSquot, nil}
 	case repl.AdvanceRegexp("^#[^`]*"):
 		return &ShAtom{shtComment, repl.s, q, nil}
 	case repl.AdvanceStr(";;"):
 @@ -206,26 +252,38 @@ func (p *ShTokenizer) shAtomBacktDquot()
 func (p *ShTokenizer) shAtomBacktSquot() *ShAtom {
 	const q = shqBacktSquot
 	repl := p.parser.repl
 	switch {
 	case repl.AdvanceStr("'"):
 		return &ShAtom{shtWord, repl.s, shqBackt, nil}
 	case repl.AdvanceRegexp(`^([\t !"#%&()*+,\-./0-9:;<=>?@A-Z\[\\\]^_` + "`" + `a-z{|}~]+|\$\$)+`):
 		return &ShAtom{shtWord, repl.m[0], q, nil}
+	}
 	return nil
+}
 func (p *ShTokenizer) shAtomSubshSquot() *ShAtom {
 	const q = shqSubshSquot
 	repl := p.parser.repl
 	switch {
 	case repl.AdvanceStr("'"):
 		return &ShAtom{shtWord, repl.s, shqSubsh, nil}
 	case repl.AdvanceRegexp(`^([\t !"#%&()*+,\-./0-9:;<=>?@A-Z\[\\\]^_` + "`" + `a-z{|}~]+|\$\$)+`):
 		return &ShAtom{shtWord, repl.m[0], q, nil}
+	}
 	return nil
+}
 func (p *ShTokenizer) shAtomDquotBacktDquot() *ShAtom {
 	const q = shqDquotBacktDquot
 	repl := p.parser.repl
 	switch {
 	case repl.AdvanceStr("\""):
 		return &ShAtom{shtWord, repl.s, shqDquotBackt, nil}
 	case repl.AdvanceRegexp(`^(?:[\t !%&()*+,\-./0-9:;<=>?@A-Z\[\]^_a-z{|}~]+|\\[^$]|` + reShDollar + `)+`):
 		return &ShAtom{shtWord, repl.m[0], q, nil}
+	}
 	return nil
+}
 func (p *ShTokenizer) shAtomDquotBacktSquot() *ShAtom {
 @@ -271,27 +329,27 @@ func (p *ShTokenizer) ShToken() *ShToken
 	repl := p.parser.repl
 	inimark := repl.Mark()
 	var atoms []*ShAtom
 	for peek() != nil && peek().Type == shtSpace {
 		skip()
 		inimark = repl.Mark()
+	}
 	if peek() == nil {
 		return nil
+	}
 	if atom := peek(); !atom.Type.IsWord() {
-		return NewShToken(atom.Text, atom)
+		return NewShToken(atom.MkText, atom)
+	}
 nextatom:
 	mark := repl.Mark()
 	atom := peek()
 	if atom != nil && (atom.Type.IsWord() || atom.Quoting != shqPlain) {
 		skip()
 		atoms = append(atoms, atom)
 		goto nextatom
+	}
 	repl.Reset(mark)
 	if len(atoms) == 0 {

--- pkgsrc/pkgtools/pkglint/files/Attic/shtokenizer_test.go 2016/06/05 11:24:32 1.1
+++ pkgsrc/pkgtools/pkglint/files/Attic/shtokenizer_test.go 2016/07/07 12:09:27 1.2

 @@ -5,49 +5,50 @@ import (
+)
 // @Beta
 func (s *Suite) Test_ShTokenizer_ShAtom(c *check.C) {
 	checkRest := func(s string, expected ...*ShAtom) string {
 		p := NewShTokenizer(dummyLine, s, false)
 		q := shqPlain
 		for _, exp := range expected {
 			c.Check(p.ShAtom(q), deepEquals, exp)
 			q = exp.Quoting
+		}
 		return p.Rest()
+	}
-	check := func(s string, expected ...*ShAtom) {
+	check := func(str string, expected ...*ShAtom) {
-		rest := checkRest(s, expected...)
+		rest := checkRest(str, expected...)
 		c.Check(rest, equals, "")
 		c.Check(s.Output(), equals, "")
+	}
 	token := func(typ ShAtomType, text string, quoting ShQuoting) *ShAtom {
 		return &ShAtom{typ, text, quoting, nil}
+	}
 	word := func(s string) *ShAtom { return token(shtWord, s, shqPlain) }
 	dquot := func(s string) *ShAtom { return token(shtWord, s, shqDquot) }
 	squot := func(s string) *ShAtom { return token(shtWord, s, shqSquot) }
 	backt := func(s string) *ShAtom { return token(shtWord, s, shqBackt) }
 	varuse := func(varname string, modifiers ...string) *ShAtom {
 		text := "${" + varname
 		for _, modifier := range modifiers {
 			text += ":" + modifier
+		}
 		text += "}"
 		varuse := &MkVarUse{varname: varname, modifiers: modifiers}
 		return &ShAtom{shtVaruse, text, shqPlain, varuse}
+	}
 	q := func(q ShQuoting, token *ShAtom) *ShAtom {
-		return &ShAtom{token.Type, token.Text, q, token.Data}
+		return &ShAtom{token.Type, token.MkText, q, token.Data}
+	}
 	whitespace := func(s string) *ShAtom { return token(shtSpace, s, shqPlain) }
 	space := token(shtSpace, " ", shqPlain)
 	semicolon := token(shtSemicolon, ";", shqPlain)
 	pipe := token(shtPipe, "|", shqPlain)
 	check("" /* none */)
 	check("$$var",
 		word("$$var"))
 	check("$$var$$var",
 		word("$$var$$var"))
 @@ -292,39 +293,55 @@ func (s *Suite) Test_ShTokenizer_ShAtom(
 		token(shtWord, "\"", shqDquotBacktDquot),
 		token(shtWord, "\\`echo foo\\`", shqDquotBacktDquot), // One token, since it doesn’t influence parsing.
 		token(shtWord, "\"", shqDquotBackt),
 		token(shtWord, "`", shqDquot),
 		token(shtWord, "\"", shqPlain))
 	check("if cond1; then action1; elif cond2; then action2; else action3; fi",
 		word("if"), space, word("cond1"), semicolon, space,
 		word("then"), space, word("action1"), semicolon, space,
 		word("elif"), space, word("cond2"), semicolon, space,
 		word("then"), space, word("action2"), semicolon, space,
 		word("else"), space, word("action3"), semicolon, space,
 		word("fi"))
 	if false {
 		check("$$(cat)",
 			token(shtWord, "$$(", shqSubsh),
 			token(shtWord, "cat", shqSubsh),
 			token(shtWord, ")", shqPlain))
 		check("$$(cat 'file')",
 			token(shtWord, "$$(", shqSubsh),
 			token(shtWord, "cat", shqSubsh),
 			token(shtSpace, " ", shqSubsh),
 			token(shtWord, "'", shqSubshSquot),
 			token(shtWord, "file", shqSubshSquot),
 			token(shtWord, "'", shqSubsh),
 			token(shtWord, ")", shqPlain))
+	}
+}
 func (s *Suite) Test_Shtokenizer_ShAtom_Quoting(c *check.C) {
 	checkQuotingChange := func(input, expectedOutput string) {
 		p := NewShTokenizer(dummyLine, input, false)
 		q := shqPlain
 		result := ""
 		for {
 			token := p.ShAtom(q)
 			if token == nil {
 				break
+			}
-			result += token.Text
+			result += token.MkText
 			if token.Quoting != q {
 				q = token.Quoting
 				result += "[" + q.String() + "]"
+			}
+		}
 		c.Check(result, equals, expectedOutput)
 		c.Check(p.Rest(), equals, "")
+	}
 	checkQuotingChange("hello, world", "hello, world")
 	checkQuotingChange("hello, \"world\"", "hello, \"[d]world\"[plain]")
 	checkQuotingChange("1 \"\" 2 '' 3 `` 4", "1 \"[d]\"[plain] 2 '[s]'[plain] 3 `[b]`[plain] 4")
 	checkQuotingChange("\"\"", "\"[d]\"[plain]")

--- pkgsrc/pkgtools/pkglint/files/Attic/shtypes.go 2016/06/05 11:24:32 1.1
+++ pkgsrc/pkgtools/pkglint/files/Attic/shtypes.go 2016/07/07 12:09:27 1.2

 @@ -13,108 +13,112 @@ const (
 	shtVaruse                   // ${PREFIX}
 	shtWord                     //
 	shtSemicolon                // ;
 	shtCaseSeparator            // ;;
 	shtParenOpen                // (
 	shtParenClose               // )
 	shtPipe                     // |
 	shtBackground               // &
 	shtOr                       // ||
 	shtAnd                      // &&
 	shtRedirect                 // >, <, >>
 	shtComment                  // # ...
 	shtSubshell                 // $$(
 	shtNewline                  // \n
+)
 func (t ShAtomType) String() string {
 	return [...]string{
 		"space",
 		"varuse",
 		"word",
 		"semicolon",
 		"caseSeparator",
 		"parenOpen", "parenClose",
 		"pipe", "background",
 		"or", "and",
 		"redirect",
 		"comment",
 		"newline",
 	}[t]
+}
 func (t ShAtomType) IsWord() bool {
 	switch t {
 	case shtVaruse, shtWord, shtRedirect:
 		return true
+	}
 	return false
+}
 func (t ShAtomType) IsCommandDelimiter() bool {
 	switch t {
-	case shtSemicolon, shtPipe, shtBackground, shtAnd, shtOr, shtCaseSeparator:
+	case shtSemicolon, shtNewline, shtPipe, shtBackground, shtAnd, shtOr, shtCaseSeparator:
 		return true
+	}
 	return false
+}
 // @Beta
 type ShAtom struct {
 	Type    ShAtomType
-	Text    string
+	MkText  string
 	Quoting ShQuoting
 	Data    interface{}
+}
 func NewShAtom(typ ShAtomType, text string, quoting ShQuoting) *ShAtom {
 	return &ShAtom{typ, text, quoting, nil}
+}
 func NewShAtomVaruse(text string, quoting ShQuoting, varname string, modifiers ...string) *ShAtom {
 	return &ShAtom{shtVaruse, text, quoting, NewMkVarUse(varname, modifiers...)}
+}
 func (token *ShAtom) String() string {
 	if token.Type == shtWord && token.Quoting == shqPlain && token.Data == nil {
-		return fmt.Sprintf("%q", token.Text)
+		return fmt.Sprintf("%q", token.MkText)
+	}
 	if token.Type == shtVaruse {
 		varuse := token.Data.(*MkVarUse)
 		return fmt.Sprintf("varuse(%q)", varuse.varname+varuse.Mod())
+	}
-	return fmt.Sprintf("ShAtom(%v, %q, %s)", token.Type, token.Text, token.Quoting)
+	return fmt.Sprintf("ShAtom(%v, %q, %s)", token.Type, token.MkText, token.Quoting)
+}
 // ShQuoting describes the context in which a string appears
 // and how it must be unescaped to get its literal value.
 type ShQuoting uint8
 const (
 	shqPlain ShQuoting = iota
 	shqDquot
 	shqSquot
 	shqBackt
 	shqSubsh
 	shqDquotBackt
 	shqBacktDquot
 	shqBacktSquot
 	shqSubshSquot
 	shqDquotBacktDquot
 	shqDquotBacktSquot
 	shqUnknown
+)
 func (q ShQuoting) String() string {
 	return [...]string{
 		"plain",
-		"d", "s", "b",
+		"d", "s", "b", "S",
-		"db", "bd", "bs",
+		"db", "bd", "bs", "Ss",
 		"dbd", "dbs",
 		"unknown",
 	}[q]
+}
 func (q ShQuoting) ToVarUseContext() vucQuoting {
 	switch q {
 	case shqPlain:
 		return vucQuotPlain
 	case shqDquot:
 		return vucQuotDquot
 	case shqSquot:
 		return vucQuotSquot

package main

type MkShWalker struct {
}

func (w *MkShWalker) Walk(list *MkShList, callback func(node interface{})) {
	for element := range w.iterate(list) {
		callback(element)
	}
}

func (w *MkShWalker) iterate(list *MkShList) chan interface{} {
	elements := make(chan interface{})

	go func() {
		w.walkList(list, elements)
		close(elements)
	}()

	return elements
}

func (w *MkShWalker) walkList(list *MkShList, collector chan interface{}) {
	collector <- list

	for _, andor := range list.AndOrs {
		w.walkAndOr(andor, collector)
	}
}

func (w *MkShWalker) walkAndOr(andor *MkShAndOr, collector chan interface{}) {
	collector <- andor

	for _, pipeline := range andor.Pipes {
		w.walkPipeline(pipeline, collector)
	}
}

func (w *MkShWalker) walkPipeline(pipeline *MkShPipeline, collector chan interface{}) {
	collector <- pipeline

	for _, command := range pipeline.Cmds {
		w.walkCommand(command, collector)
	}
}

func (w *MkShWalker) walkCommand(command *MkShCommand, collector chan interface{}) {
	collector <- command

	switch {
	case command.Simple != nil:
		w.walkSimpleCommand(command.Simple, collector)
	case command.Compound != nil:
		w.walkCompoundCommand(command.Compound, collector)
		w.walkRedirects(command.Redirects, collector)
	case command.FuncDef != nil:
		w.walkFunctionDefinition(command.FuncDef, collector)
		w.walkRedirects(command.Redirects, collector)
	}
}

func (w *MkShWalker) walkSimpleCommand(command *MkShSimpleCommand, collector chan interface{}) {
	collector <- command

	w.walkWords(command.Assignments, collector)
	if command.Name != nil {
		w.walkWord(command.Name, collector)
	}
	w.walkWords(command.Args, collector)
	w.walkRedirects(command.Redirections, collector)
}

func (w *MkShWalker) walkCompoundCommand(command *MkShCompoundCommand, collector chan interface{}) {
	collector <- command

	switch {
	case command.Brace != nil:
		w.walkList(command.Brace, collector)
	case command.Case != nil:
		w.walkCase(command.Case, collector)
	case command.For != nil:
		w.walkFor(command.For, collector)
	case command.If != nil:
		w.walkIf(command.If, collector)
	case command.Loop != nil:
		w.walkLoop(command.Loop, collector)
	case command.Subshell != nil:
		w.walkList(command.Subshell, collector)
	}
}

func (w *MkShWalker) walkCase(caseClause *MkShCaseClause, collector chan interface{}) {
	collector <- caseClause

	w.walkWord(caseClause.Word, collector)
	for _, caseItem := range caseClause.Cases {
		collector <- caseItem
		w.walkWords(caseItem.Patterns, collector)
		w.walkList(caseItem.Action, collector)
	}
}

func (w *MkShWalker) walkFunctionDefinition(funcdef *MkShFunctionDefinition, collector chan interface{}) {
	collector <- funcdef

	w.walkCompoundCommand(funcdef.Body, collector)
}

func (w *MkShWalker) walkIf(ifClause *MkShIfClause, collector chan interface{}) {
	collector <- ifClause
	for i, cond := range ifClause.Conds {
		w.walkList(cond, collector)
		w.walkList(ifClause.Actions[i], collector)
	}
	if ifClause.Else != nil {
		w.walkList(ifClause.Else, collector)
	}
}

func (w *MkShWalker) walkLoop(loop *MkShLoopClause, collector chan interface{}) {
	collector <- loop
	w.walkList(loop.Cond, collector)
	w.walkList(loop.Action, collector)
}

func (w *MkShWalker) walkWords(words []*ShToken, collector chan interface{}) {
	collector <- words

	for _, word := range words {
		w.walkWord(word, collector)
	}
}

func (w *MkShWalker) walkWord(word *ShToken, collector chan interface{}) {
	collector <- word
}

func (w *MkShWalker) walkRedirects(redirects []*MkShRedirection, collector chan interface{}) {
	collector <- redirects

	for _, redirect := range redirects {
		collector <- redirect
		w.walkWord(redirect.Target, collector)
	}
}

func (w *MkShWalker) walkFor(forClause *MkShForClause, collector chan interface{}) {
	collector <- forClause

	collector <- forClause.Varname
	w.walkWords(forClause.Values, collector)
	w.walkList(forClause.Body, collector)
}

package main

import (
	"gopkg.in/check.v1"
)

func (s *Suite) Test_MkShWalker_Walk(c *check.C) {
	list, err := parseShellProgram(dummyLine, ""+
		"if condition; then action; else case selector in pattern) case-item-action ;; esac; fi; "+
		"set -e; cd ${WRKSRC}/locale; "+
		"for lang in *.po; do "+
		"  [ \"$${lang}\" = \"wxstd.po\" ] && continue; "+
		"  ${TOOLS_PATH.msgfmt} -c -o \"$${lang%.po}.mo\" \"$${lang}\"; "+
		"done")
	if c.Check(err, check.IsNil) && c.Check(list, check.NotNil) {
		var commands []string
		(*MkShWalker).Walk(nil, list, func(node interface{}) {
			if cmd, ok := node.(*MkShSimpleCommand); ok {
				commands = append(commands, NewStrCommand(cmd).String())
			}
		})
		c.Check(commands, deepEquals, []string{
			"[] condition []",
			"[] action []",
			"[] case-item-action []",
			"[] set [-e]",
			"[] cd [${WRKSRC}/locale]",
			"[] [ [\"$${lang}\" = \"wxstd.po\" ]]",
			"[] continue []",
			"[] ${TOOLS_PATH.msgfmt} [-c -o \"$${lang%.po}.mo\" \"$${lang}\"]"})
	}
}

%{
package main
%}

%token <Word> tkWORD
%token <Word> tkASSIGNMENT_WORD
%token tkNEWLINE
%token <IONum> tkIO_NUMBER
%token tkBACKGROUND
%token tkPIPE tkSEMI
%token tkAND tkOR tkSEMISEMI
%token tkLT tkGT tkLTLT tkGTGT tkLTAND tkGTAND  tkLTGT tkLTLTDASH tkGTPIPE
%token tkIF tkTHEN tkELSE tkELIF tkFI tkDO tkDONE
%token tkCASE tkESAC tkWHILE tkUNTIL tkFOR
%token tkLPAREN tkRPAREN tkLBRACE tkRBRACE tkEXCLAM
%token tkIN

%union {
	IONum int
	List *MkShList
	AndOr *MkShAndOr
	Pipeline *MkShPipeline
	Command *MkShCommand
	CompoundCommand *MkShCompoundCommand
	Separator MkShSeparator
	Simple *MkShSimpleCommand
	FuncDef *MkShFunctionDefinition
	For *MkShForClause
	If *MkShIfClause
	Case *MkShCaseClause
	CaseItem *MkShCaseItem
	Loop *MkShLoopClause
	Words []*ShToken
	Word *ShToken
	Redirections []*MkShRedirection
	Redirection *MkShRedirection
}

%type <List> start program compound_list brace_group subshell term do_group
%type <AndOr> and_or
%type <Pipeline> pipeline pipe_sequence
%type <Command> command
%type <CompoundCommand> compound_command
%type <Separator> separator separator_op sequential_sep
%type <Simple> simple_command cmd_prefix cmd_suffix
%type <FuncDef> function_definition
%type <For> for_clause
%type <If> if_clause else_part
%type <Case> case_clause case_list case_list_ns
%type <CaseItem> case_item case_item_ns
%type <Loop> while_clause until_clause
%type <Words> wordlist case_selector pattern
%type <Word> filename cmd_word here_end
%type <Redirections> redirect_list
%type <Redirection> io_redirect io_file io_here

%%

start : program {
	shyylex.(*ShellLexer).result = $$
}

program : compound_list {
	$$ = $1
}
program : /* empty */ {
	$$ = &MkShList{}
}

and_or : pipeline {
	$$ = NewMkShAndOr($1)
}
and_or : and_or tkAND linebreak pipeline {
	$$.Add("&&", $4)
}
and_or : and_or tkOR linebreak pipeline {
	$$.Add("||", $4)
}

pipeline : pipe_sequence {
	/* empty */
}
pipeline : tkEXCLAM pipe_sequence {
	$$ = $2
	$$.Negated = true
}

pipe_sequence : command {
	$$ = NewMkShPipeline(false, $1)
}
pipe_sequence : pipe_sequence tkPIPE linebreak command {
	$$.Add($4)
}

command : simple_command {
	$$ = &MkShCommand{Simple: $1}
}
command : compound_command {
	$$ = &MkShCommand{Compound: $1}
}
command : compound_command redirect_list {
	$$ = &MkShCommand{Compound: $1, Redirects: $2}
}
command : function_definition {
	$$ = &MkShCommand{FuncDef: $1}
}
command : function_definition redirect_list {
	$$ = &MkShCommand{FuncDef: $1, Redirects: $2}
}

compound_command : brace_group {
	$$ = &MkShCompoundCommand{Brace: $1}
}
compound_command : subshell {
	$$ = &MkShCompoundCommand{Subshell: $1}
}
compound_command : for_clause {
	$$ = &MkShCompoundCommand{For: $1}
}
compound_command : case_clause {
	$$ = &MkShCompoundCommand{Case: $1}
}
compound_command : if_clause {
	$$ = &MkShCompoundCommand{If: $1}
}
compound_command : while_clause {
	$$ = &MkShCompoundCommand{Loop: $1}
}
compound_command : until_clause {
	$$ = &MkShCompoundCommand{Loop: $1}
}

subshell : tkLPAREN compound_list tkRPAREN {
	$$ = $2
}

compound_list : linebreak term {
	$$ = $2
}
compound_list : linebreak term separator {
	$$ = $2
	$$.AddSeparator($3)
}

term : and_or {
	$$ = NewMkShList()
	$$.AddAndOr($1)
}
term : term separator and_or {
	$$.AddSeparator($2)
	$$.AddAndOr($3)
}

for_clause : tkFOR tkWORD linebreak do_group {
	args := NewShToken("\"$$@\"",
		NewShAtom(shtWord, "\"",shqDquot),
		NewShAtom(shtWord, "$$@",shqDquot),
		NewShAtom(shtWord,"\"",shqPlain))
	$$ = &MkShForClause{$2.MkText, []*ShToken{args}, $4}
}
for_clause : tkFOR tkWORD linebreak tkIN sequential_sep do_group {
	$$ = &MkShForClause{$2.MkText, nil, $6}
}
for_clause : tkFOR tkWORD linebreak tkIN wordlist sequential_sep do_group {
	$$ = &MkShForClause{$2.MkText, $5, $7}
}

wordlist : tkWORD {
	$$ = append($$, $1)
}
wordlist : wordlist tkWORD {
	$$ = append($$, $2)
}

case_clause : tkCASE tkWORD linebreak tkIN linebreak case_list tkESAC {
	$$ = $6
	$$.Word = $2
}
case_clause : tkCASE tkWORD linebreak tkIN linebreak case_list_ns tkESAC {
	$$ = $6
	$$.Word = $2
}
case_clause : tkCASE tkWORD linebreak tkIN linebreak tkESAC {
	$$ = &MkShCaseClause{$2, nil}
}

case_list_ns : case_item_ns {
	$$ = &MkShCaseClause{nil, nil}
	$$.Cases = append($$.Cases, $1)
}
case_list_ns : case_list case_item_ns {
	$$.Cases = append($$.Cases, $2)
}

case_list : case_item {
	$$ = &MkShCaseClause{nil, nil}
	$$.Cases = append($$.Cases, $1)
}
case_list : case_list case_item {
	$$.Cases = append($$.Cases, $2)
}

case_selector : tkLPAREN pattern tkRPAREN {
	$$ = $2
}
case_selector : pattern tkRPAREN {
	/* empty */
}

case_item_ns : case_selector linebreak {
	$$ = &MkShCaseItem{$1, &MkShList{}, nil}
}
case_item_ns : case_selector linebreak term linebreak {
	$$ = &MkShCaseItem{$1, $3, nil}
}
case_item_ns : case_selector linebreak term separator_op linebreak {
	$$ = &MkShCaseItem{$1, $3, &$4}
}

case_item : case_selector linebreak tkSEMISEMI linebreak {
	$$ = &MkShCaseItem{$1, &MkShList{}, nil}
}
case_item : case_selector compound_list tkSEMISEMI linebreak {
	$$ = &MkShCaseItem{$1, $2, nil}
}

pattern : tkWORD {
	$$ = nil
	$$ = append($$, $1)
}
pattern : pattern tkPIPE tkWORD {
	$$ = append($$, $3)
}

if_clause : tkIF compound_list tkTHEN compound_list else_part tkFI {
	$$ = $5
	$$.Prepend($2, $4)
}
if_clause : tkIF compound_list tkTHEN compound_list tkFI {
	$$ = &MkShIfClause{}
	$$.Prepend($2, $4)
}

else_part : tkELIF compound_list tkTHEN compound_list {
	$$ = &MkShIfClause{}
	$$.Prepend($2, $4)
}
else_part : tkELIF compound_list tkTHEN compound_list else_part {
	$$ = $5
	$$.Prepend($2, $4)
}
else_part : tkELSE compound_list {
	$$ = &MkShIfClause{nil, nil, $2}
}

while_clause : tkWHILE compound_list do_group {
	$$ = &MkShLoopClause{$2, $3, false}
}
until_clause : tkUNTIL compound_list do_group {
	$$ = &MkShLoopClause{$2, $3, true}
}

function_definition : tkWORD tkLPAREN tkRPAREN linebreak compound_command { /* Apply rule 9 */
	$$ = &MkShFunctionDefinition{$1.MkText, $5}
}

brace_group : tkLBRACE compound_list tkRBRACE {
	$$ = $2
}

do_group : tkDO compound_list tkDONE {
	$$ = $2
}

simple_command : cmd_prefix cmd_word cmd_suffix {
	$$.Name = $2
	$$.Args = append($$.Args, $3.Args...)
	$$.Redirections = append($$.Redirections, $3.Redirections...)
}
simple_command : cmd_prefix cmd_word {
	$$.Name = $2
}
simple_command : cmd_prefix {
	/* empty */
}
simple_command : tkWORD cmd_suffix {
	$$ = $2
	$$.Name = $1
}
simple_command : tkWORD {
	$$ = &MkShSimpleCommand{Name: $1}
}

cmd_word : tkWORD { /* Apply rule 7b */
	/* empty */
}

cmd_prefix : io_redirect {
	$$ = &MkShSimpleCommand{}
	$$.Redirections = append($$.Redirections, $1)
}
cmd_prefix : tkASSIGNMENT_WORD {
	$$ = &MkShSimpleCommand{}
	$$.Assignments = append($$.Assignments, $1)
}
cmd_prefix : cmd_prefix io_redirect {
	$$.Redirections = append($$.Redirections, $2)
}
cmd_prefix : cmd_prefix tkASSIGNMENT_WORD {
	$$.Assignments = append($$.Assignments, $2)
}

cmd_suffix : io_redirect {
	$$ = &MkShSimpleCommand{}
	$$.Redirections = append($$.Redirections, $1)
}
cmd_suffix : tkWORD {
	$$ = &MkShSimpleCommand{}
	$$.Args = append($$.Args, $1)
}
cmd_suffix : cmd_suffix io_redirect {
	$$.Redirections = append($$.Redirections, $2)
}
cmd_suffix : cmd_suffix tkWORD {
	$$.Args = append($$.Args, $2)
}

redirect_list : io_redirect {
	$$ = nil
	$$ = append($$, $1)
}
redirect_list : redirect_list io_redirect {
	$$ = append($$, $2)
}

io_redirect : io_file {
	/* empty */
}
io_redirect : tkIO_NUMBER io_file {
	$$ = $2
	$$.Fd = $1
}

io_redirect : io_here {
	/* empty */
}
io_redirect : tkIO_NUMBER io_here {
	$$ = $2
	$$.Fd = $1
}

io_file : tkLT filename {
	$$ = &MkShRedirection{-1, "<", $2}
}
io_file : tkLTAND filename {
	$$ = &MkShRedirection{-1, "<&", $2}
}
io_file : tkGT filename {
	$$ = &MkShRedirection{-1, ">", $2}
}
io_file : tkGTAND filename {
	$$ = &MkShRedirection{-1, ">&", $2}
}
io_file : tkGTGT filename {
	$$ = &MkShRedirection{-1, ">>", $2}
}
io_file : tkLTGT filename {
	$$ = &MkShRedirection{-1, "<>", $2}
}
io_file : tkGTPIPE filename {
	$$ = &MkShRedirection{-1, ">|", $2}
}

filename : tkWORD { /* Apply rule 2 */
	/* empty */
}

io_here : tkLTLT here_end {
	$$ = &MkShRedirection{-1, "<<", $2}
}
io_here : tkLTLTDASH here_end {
	$$ = &MkShRedirection{-1, "<<-", $2}
}

here_end : tkWORD { /* Apply rule 3 */
	/* empty */
}

newline_list : tkNEWLINE {
	/* empty */
}
newline_list : newline_list tkNEWLINE {
	/* empty */
}

linebreak : newline_list {
	/* empty */
}
linebreak : /* empty */ {
	/* empty */
}

separator_op : tkBACKGROUND {
	$$ = "&"
}
separator_op : tkSEMI {
	$$ = ";"
}

separator : separator_op linebreak {
	/* empty */
}
separator : newline_list {
	$$ = "\n"
}

sequential_sep : tkSEMI linebreak {
	$$ = ";"
}
sequential_sep : tkNEWLINE linebreak {
	$$ = "\n"
}

--- pkgsrc/pkgtools/pkglint/files/Attic/package.go 2016/06/05 11:24:32 1.8
+++ pkgsrc/pkgtools/pkglint/files/Attic/package.go 2016/07/07 12:09:27 1.9

 @@ -1,17 +1,18 @@
 package main
 import (
 	"fmt"
 	"os/user"
 	"path"
 	"regexp"
 	"strconv"
 	"strings"
+)
 // Package contains data for the pkgsrc package that is currently checked.
 type Package struct {
 	Pkgpath              string  // e.g. "category/pkgdir"
 	Pkgdir               string  // PKGDIR from the package Makefile
 	Filesdir             string  // FILESDIR from the package Makefile
 	Patchdir             string  // PATCHDIR from the package Makefile
 	DistinfoFile         string  // DISTINFO_FILE from the package Makefile
 @@ -186,26 +187,27 @@ func checkdirPackage(pkgpath string) {
+		}
 		if fname == G.CurrentDir+"/Makefile" {
 			if G.opts.CheckMakefile {
 				pkg.checkfilePackageMakefile(fname, lines)
+			}
 		} else {
 			Checkfile(fname)
+		}
 		if contains(fname, "/patches/patch-") {
 			havePatches = true
 		} else if hasSuffix(fname, "/distinfo") {
 			haveDistinfo = true
+		}
 		pkg.checkLocallyModified(fname)
+	}
 	if G.opts.CheckDistinfo && G.opts.CheckPatches {
 		if havePatches && !haveDistinfo {
 			NewLineWhole(G.CurrentDir+"/"+pkg.DistinfoFile).Warn1("File not found. Please run \"%s makepatchsum\".", confMake)
+		}
+	}
 	if !isEmptyDir(G.CurrentDir + "/scripts") {
 		NewLineWhole(G.CurrentDir + "/scripts").Warn0("This directory and its contents are deprecated! Please call the script(s) explicitly from the corresponding target(s) in the pkg's Makefile.")
+	}
+}
 @@ -377,27 +379,27 @@ func (pkg *Package) checkfilePackageMake
 		if distinfoFile := G.CurrentDir + "/" + pkg.DistinfoFile; fileExists(distinfoFile) {
 			NewLineWhole(distinfoFile).Warn0("This file should not exist if NO_CHECKSUM or META_PACKAGE is set.")
+		}
 	} else {
 		if distinfoFile := G.CurrentDir + "/" + pkg.DistinfoFile; !containsVarRef(distinfoFile) && !fileExists(distinfoFile) {
 			NewLineWhole(distinfoFile).Warn1("File not found. Please run \"%s makesum\".", confMake)
+		}
+	}
 	if perlLine, noconfLine := vardef["REPLACE_PERL"], vardef["NO_CONFIGURE"]; perlLine != nil && noconfLine != nil {
 		perlLine.Warn1("REPLACE_PERL is ignored when NO_CONFIGURE is set (in %s)", noconfLine.Line.ReferenceFrom(perlLine.Line))
+	}
-	if vardef["LICENSE"] == nil {
+	if vardef["LICENSE"] == nil && vardef["META_PACKAGE"] == nil {
 		NewLineWhole(fname).Error0("Each package must define its LICENSE.")
+	}
 	if gnuLine, useLine := vardef["GNU_CONFIGURE"], vardef["USE_LANGUAGES"]; gnuLine != nil && useLine != nil {
 		if matches(useLine.Comment(), `(?-i)\b(?:c|empty|none)\b`) {
 			// Don't emit a warning, since the comment
 			// probably contains a statement that C is
 			// really not needed.
 		} else if !matches(useLine.Value(), `(?:^|\s+)(?:c|c99|objc)(?:\s+|$)`) {
 			gnuLine.Warn1("GNU_CONFIGURE almost always needs a C compiler, but \"c\" is not added to USE_LANGUAGES in %s.",
 				useLine.Line.ReferenceFrom(gnuLine.Line))
+		}
 @@ -474,39 +476,63 @@ func (pkg *Package) determineEffectivePk
 			pkg.EffectivePkgbase = m1
 			pkg.EffectivePkgversion = m2
+		}
+	}
 	if pkg.EffectivePkgnameLine != nil {
 		if G.opts.Debug {
 			traceStep("Effective name=%q base=%q version=%q",
 				pkg.EffectivePkgname, pkg.EffectivePkgbase, pkg.EffectivePkgversion)
+		}
+	}
+}
 func (pkg *Package) pkgnameFromDistname(pkgname, distname string) string {
-	pkgname = strings.Replace(pkgname, "${DISTNAME}", distname, -1)
+	tokens := NewMkParser(dummyLine, pkgname, false).MkTokens()
-	if m, before, sep, subst, after := match4(pkgname, `^(.*)\$\{DISTNAME:S(.)([^\\}:]+)\}(.*)$`); m {
+	subst := func(str, smod string) (result string) {
-		qsep := regexp.QuoteMeta(sep)
+		if G.opts.Debug {
-		if m, left, from, right, to, mod := match5(subst, `^(\^?)([^:]*)(\$?)`+qsep+`([^:]*)`+qsep+`(g?)$`); m {
+			defer tracecall(str, smod, ref(result))()
 			newPkgname := before + mkopSubst(distname, left != "", from, right != "", to, mod != "") + after
 		qsep := regexp.QuoteMeta(smod[1:2])
 		if m, left, from, right, to, flags := match5(smod, `^S`+qsep+`(\^?)([^:]*?)(\$?)`+qsep+`([^:]*)`+qsep+`([1g]*)$`); m {
 			result := mkopSubst(str, left != "", from, right != "", to, flags)
 			if G.opts.Debug {
-				traceStep("%s: pkgnameFromDistname %q => %q", pkg.vardef["PKGNAME"], pkgname, newPkgname)
+				traceStep("subst %q %q => %q", str, smod, result)
+			}
-			pkgname = newPkgname
+			return result
+		}
 		return str
+	}
 	return pkgname
 	result := ""
 	for _, token := range tokens {
 		if token.Varuse != nil && token.Varuse.varname == "DISTNAME" {
 			newDistname := distname
 			for _, mod := range token.Varuse.modifiers {
 				if mod == "tl" {
 					newDistname = strings.ToLower(newDistname)
 				} else if hasPrefix(mod, "S") {
 					newDistname = subst(newDistname, mod)
 				} else {
 					newDistname = token.Text
 					break
+				}
+			}
 			result += newDistname
 		} else {
 			result += token.Text
+		}
+	}
 	return result
+}
 func (pkg *Package) checkUpdate() {
 	if pkg.EffectivePkgbase != "" {
 		for _, sugg := range G.globalData.GetSuggestedPackageUpdates() {
 			if pkg.EffectivePkgbase != sugg.Pkgname {
 				continue
+			}
 			suggver, comment := sugg.Version, sugg.Comment
 			if comment != "" {
 				comment = " (" + comment + ")"
+			}
 @@ -748,13 +774,63 @@ func (mklines *MkLines) checkForUsedComm
 		insertLine.Warn1("Please add a line %q here.", expected)
 		Explain(
 			"Since Makefile.common files usually don't have any comments and",
 			"therefore not a clearly defined interface, they should at least",
 			"contain references to all files that include them, so that it is",
 			"easier to see what effects future changes may have.",
 			"",
 			"If there are more than five packages that use a Makefile.common,",
 			"you should think about giving it a proper name (maybe plugin.mk) and",
 			"documenting its interface.")
+	}
 	SaveAutofixChanges(lines)
+}
 func (pkg *Package) checkLocallyModified(fname string) {
 	if G.opts.Debug {
 		defer tracecall(fname)()
+	}
 	ownerLine := pkg.vardef["OWNER"]
 	maintainerLine := pkg.vardef["MAINTAINER"]
 	owner := ""
 	maintainer := ""
 	if ownerLine != nil && !containsVarRef(ownerLine.Value()) {
 		owner = ownerLine.Value()
+	}
 	if maintainerLine != nil && !containsVarRef(maintainerLine.Value()) && maintainerLine.Value() != "pkgsrc-users@NetBSD.org" {
 		maintainer = maintainerLine.Value()
+	}
 	if owner == "" && maintainer == "" {
 		return
+	}
 	user, err := user.Current()
 	if err != nil || user.Username == "" {
 		return
+	}
 	// On Windows, this is `Computername\Username`.
 	username := regcomp(`^.*\\`).ReplaceAllString(user.Username, "")
 	if G.opts.Debug {
 		traceStep("user=%q owner=%q maintainer=%q", username, owner, maintainer)
+	}
 	if username == strings.Split(owner, "@")[0] || username == strings.Split(maintainer, "@")[0] {
 		return
+	}
 	if isLocallyModified(fname) {
 		if owner != "" {
 			NewLineWhole(fname).Warn1("Don't commit changes to this file without asking the OWNER, %s.", owner)
 			Explain2(
 				"See the pkgsrc guide, section \"Package components\",",
 				"keyword \"owner\", for more information.")
+		}
 		if maintainer != "" {
 			NewLineWhole(fname).Note1("Please only commit changes that %s would approve.", maintainer)
 			Explain2(
 				"See the pkgsrc guide, section \"Package components\",",
 				"keyword \"maintainer\", for more information.")
+		}
+	}
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/pkglint.go 2016/06/05 11:24:32 1.8
+++ pkgsrc/pkgtools/pkglint/files/Attic/pkglint.go 2016/07/07 12:09:27 1.9

 @@ -192,27 +192,27 @@ func Checkfile(fname string) {
 	switch {
 	case st.Mode().IsDir():
 		switch {
 		case basename == "files" || basename == "patches" || basename == "CVS":
 			// Ok
 		case matches(fname, `(?:^|/)files/[^/]*$`):
 			// Ok
 		case !isEmptyDir(fname):
 			NewLineWhole(fname).Warn0("Unknown directory name.")
+		}
 	case st.Mode()&os.ModeSymlink != 0:
-		if !matches(basename, `^work`) {
+		if !hasPrefix(basename, "work") {
 			NewLineWhole(fname).Warn0("Unknown symlink name.")
+		}
 	case !st.Mode().IsRegular():
 		NewLineWhole(fname).Error0("Only files and directories are allowed in pkgsrc.")
 	case basename == "ALTERNATIVES":
 		if G.opts.CheckAlternatives {
 			CheckfileExtra(fname)
+		}
 	case basename == "buildlink3.mk":
 		if G.opts.CheckBuildlink3 {
 @@ -274,26 +274,29 @@ func Checkfile(fname string) {
+			}
+		}
 	case basename == "TODO" || basename == "README":
 		// Ok
 	case hasPrefix(basename, "CHANGES-"):
 		// This only checks the file, but doesn’t register the changes globally.
 		G.globalData.loadDocChangesFromFile(fname)
 	case matches(fname, `(?:^|/)files/[^/]*$`):
 		// Skip
 	case basename == "spec":
 		// Ok in regression tests
 	default:
 		NewLineWhole(fname).Warn0("Unexpected file found.")
 		if G.opts.CheckExtra {
 			CheckfileExtra(fname)
+		}
+	}
+}
 func ChecklinesTrailingEmptyLines(lines []*Line) {
 	max := len(lines)
 	last := max
 	for last > 1 && lines[last-1].Text == "" {
 		last--

--- pkgsrc/pkgtools/pkglint/files/Attic/package_test.go 2016/06/05 11:24:32 1.7
+++ pkgsrc/pkgtools/pkglint/files/Attic/package_test.go 2016/07/07 12:09:27 1.8

 @@ -4,26 +4,29 @@ import (
 	check "gopkg.in/check.v1"
+)
 func (s *Suite) TestPkgnameFromDistname(c *check.C) {
 	pkg := NewPackage("dummy")
 	pkg.vardef["PKGNAME"] = NewMkLine(NewLine("Makefile", 5, "PKGNAME=dummy", nil))
 	c.Check(pkg.pkgnameFromDistname("pkgname-1.0", "whatever"), equals, "pkgname-1.0")
 	c.Check(pkg.pkgnameFromDistname("${DISTNAME}", "distname-1.0"), equals, "distname-1.0")
 	c.Check(pkg.pkgnameFromDistname("${DISTNAME:S/dist/pkg/}", "distname-1.0"), equals, "pkgname-1.0")
 	c.Check(pkg.pkgnameFromDistname("${DISTNAME:S|a|b|g}", "panama-0.13"), equals, "pbnbmb-0.13")
 	c.Check(pkg.pkgnameFromDistname("${DISTNAME:S|^lib||}", "libncurses"), equals, "ncurses")
 	c.Check(pkg.pkgnameFromDistname("${DISTNAME:S|^lib||}", "mylib"), equals, "mylib")
 	c.Check(pkg.pkgnameFromDistname("${DISTNAME:tl:S/-/./g:S/he/-/1}", "SaxonHE9-5-0-1J"), equals, "saxon-9.5.0.1j")
 	c.Check(pkg.pkgnameFromDistname("${DISTNAME:C/beta/.0./}", "fspanel-0.8beta1"), equals, "${DISTNAME:C/beta/.0./}")
 	c.Check(pkg.pkgnameFromDistname("${DISTNAME:S/-0$/.0/1}", "aspell-af-0.50-0"), equals, "aspell-af-0.50.0")
 	c.Check(s.Output(), equals, "")
+}
 func (s *Suite) TestChecklinesPackageMakefileVarorder(c *check.C) {
 	s.UseCommandLine(c, "-Worder")
 	pkg := NewPackage("x11/9term")
 	pkg.ChecklinesPackageMakefileVarorder(s.NewMkLines("Makefile",
 		"# $"+"NetBSD$",
 		"",
 		"DISTNAME=9term",
 		"CATEGORIES=x11"))
 @@ -147,26 +150,39 @@ func (s *Suite) TestCheckdirPackage(c *c
 	s.CreateTmpFile(c, "Makefile", ""+
 		"# $"+"NetBSD$\n")
 	G.CurrentDir = s.tmpdir
 	checkdirPackage(s.tmpdir)
 	c.Check(s.Output(), equals, ""+
 		"WARN: ~/Makefile: Neither PLIST nor PLIST.common exist, and PLIST_SRC is unset. Are you sure PLIST handling is ok?\n"+
 		"WARN: ~/distinfo: File not found. Please run \"@BMAKE@ makesum\".\n"+
 		"ERROR: ~/Makefile: Each package must define its LICENSE.\n"+
 		"WARN: ~/Makefile: No COMMENT given.\n")
+}
 func (s *Suite) Test_Package_Meta_package_License(c *check.C) {
 	s.CreateTmpFileLines(c, "Makefile",
 		"# $"+"NetBSD$",
 		"",
 		"META_PACKAGE=\tyes")
 	G.CurrentDir = s.tmpdir
 	G.globalData.InitVartypes()
 	checkdirPackage(s.tmpdir)
 	c.Check(s.Output(), equals, "WARN: ~/Makefile: No COMMENT given.\n") // No error about missing LICENSE.
+}
 func (s *Suite) Test_Package_Varuse_LoadTime(c *check.C) {
 	s.CreateTmpFileLines(c, "doc/CHANGES-2016",
 		"# dummy")
 	s.CreateTmpFileLines(c, "doc/TODO",
 		"# dummy")
 	s.CreateTmpFileLines(c, "licenses/bsd-2",
 		"# dummy")
 	s.CreateTmpFileLines(c, "mk/fetch/sites.mk",
 		"# dummy")
 	s.CreateTmpFileLines(c, "mk/bsd.pkg.mk",
 		"# dummy")
 	s.CreateTmpFileLines(c, "mk/defaults/options.description",
 		"option Description")

--- pkgsrc/pkgtools/pkglint/files/Attic/util.go 2016/06/05 11:24:32 1.7
+++ pkgsrc/pkgtools/pkglint/files/Attic/util.go 2016/07/07 12:09:27 1.8

 @@ -74,26 +74,54 @@ func isCommitted(fname string) bool {
 	basename := path.Base(fname)
 	lines, err := readLines(path.Dir(fname)+"/CVS/Entries", false)
 	if err != nil {
 		return false
+	}
 	for _, line := range lines {
 		if hasPrefix(line.Text, "/"+basename+"/") {
 			return true
+		}
+	}
 	return false
+}
 func isLocallyModified(fname string) bool {
 	basename := path.Base(fname)
 	lines, err := readLines(path.Dir(fname)+"/CVS/Entries", false)
 	if err != nil {
 		return false
+	}
 	for _, line := range lines {
 		if hasPrefix(line.Text, "/"+basename+"/") {
 			cvsModTime, err := time.Parse(time.ANSIC, strings.Split(line.Text, "/")[3])
 			if err != nil {
 				return false
+			}
 			st, err := os.Stat(fname)
 			if err != nil {
 				return false
+			}
 			// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724290(v=vs.85).aspx
 			delta := cvsModTime.Unix() - st.ModTime().Unix()
 			if G.opts.Debug {
 				traceStep("cvs.time=%v fs.time=%v delta=%v", cvsModTime, st.ModTime(), delta)
+			}
 			return !(-2 <= delta && delta <= 2)
+		}
+	}
 	return false
+}
 // Returns the number of columns that a string occupies when printed with
 // a tabulator size of 8.
 func tabLength(s string) int {
 	length := 0
 	for _, r := range s {
 		if r == '\t' {
 			length = length - length%8 + 8
 		} else {
 			length++
+		}
+	}
 	return length
+}
 @@ -488,32 +516,36 @@ type Ref struct {
+}
 func ref(rv interface{}) Ref {
 	return Ref{rv}
+}
 func (r Ref) String() string {
 	ptr := reflect.ValueOf(r.intf)
 	ref := reflect.Indirect(ptr)
 	return fmt.Sprintf("%v", ref)
+}
 // Emulates make(1)’s :S substitution operator.
-func mkopSubst(s string, left bool, from string, right bool, to string, all bool) string {
+func mkopSubst(s string, left bool, from string, right bool, to string, flags string) string {
 	if G.opts.Debug {
 		defer tracecall(s, left, from, right, to, flags)()
+	}
 	re := ifelseStr(left, "^", "") + regexp.QuoteMeta(from) + ifelseStr(right, "$", "")
 	done := false
 	gflag := contains(flags, "g")
 	return regcomp(re).ReplaceAllStringFunc(s, func(match string) string {
-		if all || !done {
+		if gflag || !done {
-			done = !all
+			done = !gflag
 			return to
+		}
 		return match
 	})
+}
 func relpath(from, to string) string {
 	absFrom, err1 := filepath.Abs(from)
 	absTo, err2 := filepath.Abs(to)
 	rel, err3 := filepath.Rel(absFrom, absTo)
 	if err1 != nil || err2 != nil || err3 != nil {
 		panic("relpath" + argsStr(from, to, err1, err2, err3))
+	}

--- pkgsrc/pkgtools/pkglint/files/Attic/util_test.go 2016/01/12 01:02:49 1.3
+++ pkgsrc/pkgtools/pkglint/files/Attic/util_test.go 2016/07/07 12:09:27 1.4

 @@ -1,44 +1,44 @@
 package main
 import (
 	check "gopkg.in/check.v1"
+)
 func (s *Suite) TestMkopSubst_middle(c *check.C) {
-	c.Check(mkopSubst("pkgname", false, "kgna", false, "ri", false), equals, "prime")
+	c.Check(mkopSubst("pkgname", false, "kgna", false, "ri", ""), equals, "prime")
-	c.Check(mkopSubst("pkgname", false, "pkgname", false, "replacement", false), equals, "replacement")
+	c.Check(mkopSubst("pkgname", false, "pkgname", false, "replacement", ""), equals, "replacement")
+}
 func (s *Suite) TestMkopSubst_left(c *check.C) {
-	c.Check(mkopSubst("pkgname", true, "kgna", false, "ri", false), equals, "pkgname")
+	c.Check(mkopSubst("pkgname", true, "kgna", false, "ri", ""), equals, "pkgname")
-	c.Check(mkopSubst("pkgname", true, "pkgname", false, "replacement", false), equals, "replacement")
+	c.Check(mkopSubst("pkgname", true, "pkgname", false, "replacement", ""), equals, "replacement")
+}
 func (s *Suite) TestMkopSubst_right(c *check.C) {
-	c.Check(mkopSubst("pkgname", false, "kgna", true, "ri", false), equals, "pkgname")
+	c.Check(mkopSubst("pkgname", false, "kgna", true, "ri", ""), equals, "pkgname")
-	c.Check(mkopSubst("pkgname", false, "pkgname", true, "replacement", false), equals, "replacement")
+	c.Check(mkopSubst("pkgname", false, "pkgname", true, "replacement", ""), equals, "replacement")
+}
 func (s *Suite) TestMkopSubst_leftRight(c *check.C) {
-	c.Check(mkopSubst("pkgname", true, "kgna", true, "ri", false), equals, "pkgname")
+	c.Check(mkopSubst("pkgname", true, "kgna", true, "ri", ""), equals, "pkgname")
-	c.Check(mkopSubst("pkgname", false, "pkgname", false, "replacement", false), equals, "replacement")
+	c.Check(mkopSubst("pkgname", false, "pkgname", false, "replacement", ""), equals, "replacement")
+}
-func (s *Suite) TestMkopSubst_all(c *check.C) {
+func (s *Suite) TestMkopSubst_gflag(c *check.C) {
-	c.Check(mkopSubst("aaaaa", false, "a", false, "b", true), equals, "bbbbb")
+	c.Check(mkopSubst("aaaaa", false, "a", false, "b", "g"), equals, "bbbbb")
-	c.Check(mkopSubst("aaaaa", true, "a", false, "b", true), equals, "baaaa")
+	c.Check(mkopSubst("aaaaa", true, "a", false, "b", "g"), equals, "baaaa")
-	c.Check(mkopSubst("aaaaa", false, "a", true, "b", true), equals, "aaaab")
+	c.Check(mkopSubst("aaaaa", false, "a", true, "b", "g"), equals, "aaaab")
-	c.Check(mkopSubst("aaaaa", true, "a", true, "b", true), equals, "aaaaa")
+	c.Check(mkopSubst("aaaaa", true, "a", true, "b", "g"), equals, "aaaaa")
+}
 func (s *Suite) TestReplaceFirst(c *check.C) {
 	m, rest := replaceFirst("a+b+c+d", `(\w)(.)(\w)`, "X")
 	c.Assert(m, check.NotNil)
 	c.Check(m, check.DeepEquals, []string{"a+b", "a", "+", "b"})
 	c.Check(rest, equals, "X+c+d")
+}
 func (s *Suite) TestTabLength(c *check.C) {
 	c.Check(tabLength("12345"), equals, 5)
 	c.Check(tabLength("\t"), equals, 8)

--- pkgsrc/pkgtools/pkglint/files/Attic/vartypecheck.go 2016/06/10 19:42:42 1.14
+++ pkgsrc/pkgtools/pkglint/files/Attic/vartypecheck.go 2016/07/07 12:09:27 1.15

--- pkgsrc/pkgtools/pkglint/files/Attic/vercmp_test.go 2016/01/12 01:02:49 1.2
+++ pkgsrc/pkgtools/pkglint/files/Attic/vercmp_test.go 2016/07/07 12:09:27 1.3

 @@ -5,25 +5,60 @@ import (
+)
 func (s *Suite) TestMkversion(c *check.C) {
 	c.Check(newVersion("5.0"), check.DeepEquals, &version{[]int{5, 0, 0}, 0})
 	c.Check(newVersion("5.0nb5"), check.DeepEquals, &version{[]int{5, 0, 0}, 5})
 	c.Check(newVersion("0.0.1-SNAPSHOT"), check.DeepEquals, &version{[]int{0, 0, 0, 0, 1, 19, 14, 1, 16, 19, 8, 15, 20}, 0})
 	c.Check(newVersion("1.0alpha3"), check.DeepEquals, &version{[]int{1, 0, 0, -3, 3}, 0})
 	c.Check(newVersion("2.5beta"), check.DeepEquals, &version{[]int{2, 0, 5, -2}, 0})
 	c.Check(newVersion("20151110"), check.DeepEquals, &version{[]int{20151110}, 0})
 	c.Check(newVersion("0"), check.DeepEquals, &version{[]int{0}, 0})
 	c.Check(newVersion("nb1"), check.DeepEquals, &version{nil, 1})
 	c.Check(newVersion("1.0.1a"), deepEquals, &version{[]int{1, 0, 0, 0, 1, 1}, 0})
 	c.Check(newVersion("1.0.1z"), deepEquals, &version{[]int{1, 0, 0, 0, 1, 26}, 0})
 	c.Check(newVersion("0pre20160620"), deepEquals, &version{[]int{0, -1, 20160620}, 0})
+}
 func (s *Suite) TestPkgverCmp(c *check.C) {
-	c.Check(pkgverCmp("1.0", "1.0alpha"), equals, 1)
+	var versions = [][]string{
-	c.Check(pkgverCmp("1.0alpha", "1.0"), equals, -1)
+		{"0pre20160620"},
-	c.Check(pkgverCmp("1.0nb1", "1.0"), equals, 1)
+		{"0"},
-	c.Check(pkgverCmp("1.0nb2", "1.0nb1"), equals, 1)
+		{"nb1"},
-	c.Check(pkgverCmp("2.0.1nb17", "2.0.1nb4"), equals, 1)
+		{"0.0.1-SNAPSHOT"},
-	c.Check(pkgverCmp("2.0.1nb4", "2.0.1nb17"), equals, -1)
+		{"1.0alpha"},
-	c.Check(pkgverCmp("2.0pre", "2.0rc"), equals, 0)
+		{"1.0alpha3"},
-	c.Check(pkgverCmp("2.0pre", "2.0pl"), equals, -1)
+		{"1", "1.0", "1.0.0"},
 		{"1.0nb1"},
 		{"1.0nb2"},
 		{"1.0.1a"},
 		{"1.0.1z"},
 		{"2.0pre", "2.0rc"},
 		{"2.0", "2.0pl"},
 		{"2.0.1nb4"},
 		{"2.0.1nb17"},
 		{"2.5beta"},
 		{"5.0"},
 		{"5.0nb5"},
 		{"5.5", "5.005"},
 		{"20151110"},
+	}
 	for i, iversions := range versions {
 		for _, iversion := range iversions {
 			for j, jversions := range versions {
 				for _, jversion := range jversions {
 					actual := pkgverCmp(iversion, jversion)
 					if i < j && !(actual < 0) {
 						c.Check([]interface{}{i, iversion, j, jversion, "<0"}, deepEquals, []interface{}{i, iversion, j, jversion, actual})
+					}
 					if i == j && !(actual == 0) {
 						c.Check([]interface{}{i, iversion, j, jversion, "==0"}, deepEquals, []interface{}{i, iversion, j, jversion, actual})
+					}
 					if i > j && !(actual > 0) {
 						c.Check([]interface{}{i, iversion, j, jversion, ">0"}, deepEquals, []interface{}{i, iversion, j, jversion, actual})
+					}
+				}
+			}
+		}
+	}
+}

	@@ -674,26 +674,31 @@ func (cv *VartypeCheck) PkgName() {		@@ -674,26 +674,31 @@ func (cv *VartypeCheck) PkgName() {
674	cv.line.Warn1("%q is not a valid package name. A valid package name has the form packagename-version, where version consists only of digits, letters and dots.", cv.value)	674	cv.line.Warn1("%q is not a valid package name. A valid package name has the form packagename-version, where version consists only of digits, letters and dots.", cv.value)
675	}	675	}
676	}	676	}
677		677
678	func (cv *VartypeCheck) PkgOptionsVar() {	678	func (cv *VartypeCheck) PkgOptionsVar() {
679	cv.mkline.CheckVartypePrimitive(cv.varname, CheckvarVarname, cv.op, cv.value, cv.comment, false, cv.guessed)	679	cv.mkline.CheckVartypePrimitive(cv.varname, CheckvarVarname, cv.op, cv.value, cv.comment, false, cv.guessed)
680	if matches(cv.value, `\$\{PKGBASE[:\}]`) {	680	if matches(cv.value, `\$\{PKGBASE[:\}]`) {
681	cv.line.Error0("PKGBASE must not be used in PKG_OPTIONS_VAR.")	681	cv.line.Error0("PKGBASE must not be used in PKG_OPTIONS_VAR.")
682	Explain3(	682	Explain3(
683	"PKGBASE is defined in bsd.pkg.mk, which is included as the",	683	"PKGBASE is defined in bsd.pkg.mk, which is included as the",
684	"very last file, but PKG_OPTIONS_VAR is evaluated earlier.",	684	"very last file, but PKG_OPTIONS_VAR is evaluated earlier.",
685	"Use ${PKGNAME:C/-[0-9].*//} instead.")	685	"Use ${PKGNAME:C/-[0-9].*//} instead.")
686	}	686	}
		687
		688	// PR 46570, item "6. It should complain in PKG_OPTIONS_VAR is wrong"
		689	if !hasPrefix(cv.value, "PKG_OPTIONS.") {
		690	cv.line.Error2("PKG_OPTIONS_VAR must be of the form %q, not %q.", "PKG_OPTIONS.*", cv.value)
		691	}
687	}	692	}
688		693
689	// A directory name relative to the top-level pkgsrc directory.	694	// A directory name relative to the top-level pkgsrc directory.
690	// Despite its name, it is more similar to RelativePkgDir than to RelativePkgPath.	695	// Despite its name, it is more similar to RelativePkgDir than to RelativePkgPath.
691	func (cv *VartypeCheck) PkgPath() {	696	func (cv *VartypeCheck) PkgPath() {
692	cv.mkline.CheckRelativePkgdir(G.CurPkgsrcdir + "/" + cv.value)	697	cv.mkline.CheckRelativePkgdir(G.CurPkgsrcdir + "/" + cv.value)
693	}	698	}
694		699
695	func (cv *VartypeCheck) PkgRevision() {	700	func (cv *VartypeCheck) PkgRevision() {
696	if !matches(cv.value, `^[1-9]\d*$`) {	701	if !matches(cv.value, `^[1-9]\d*$`) {
697	cv.line.Warn1("%s must be a positive integer number.", cv.varname)	702	cv.line.Warn1("%s must be a positive integer number.", cv.varname)
698	}	703	}
699	if path.Base(cv.line.Fname) != "Makefile" {	704	if path.Base(cv.line.Fname) != "Makefile" {