 @@ -114,26 +114,31 @@ func (t *Tester) SetupVartypes() {
 func (t *Tester) SetupMasterSite(varname string, urls ...string) {
 	name2url := &G.Pkgsrc.MasterSiteVarToURL
 	url2name := &G.Pkgsrc.MasterSiteURLToVar
 	if *name2url == nil {
 		*name2url = make(map[string]string)
 		*url2name = make(map[string]string)
+	}
 	(*name2url)[varname] = urls[0]
 	for _, url := range urls {
 		(*url2name)[url] = varname
+	}
+}
 // SetupOption pretends that the package option is defined in mk/defaults/options.description.
 func (t *Tester) SetupOption(name, description string) {
 	G.Pkgsrc.PkgOptions[name] = description
+}
 func (t *Tester) SetupTool(tool *Tool) {
 	reg := G.Pkgsrc.Tools
 	if len(reg.byName) == 0 && len(reg.byVarname) == 0 {
 		reg = NewToolRegistry()
 		G.Pkgsrc.Tools = reg
+	}
 	if tool.Name != "" {
 		reg.byName[tool.Name] = tool
+	}
 	if tool.Varname != "" {
 		reg.byVarname[tool.Varname] = tool
+	}
 @@ -244,27 +249,31 @@ func (t *Tester) NewLines(fileName strin
 // i.e. each logical line has exactly one physical line.
 // To work with line continuations like in Makefiles,
 // use Suite.CreateFileLines together with Suite.LoadExistingLines.
 func (t *Tester) NewLinesAt(fileName string, firstLine int, texts ...string) []Line {
 	result := make([]Line, len(texts))
 	for i, text := range texts {
 		textnl := text + "\n"
 		result[i] = NewLine(fileName, i+firstLine, text, t.NewRawLines(i+firstLine, textnl))
+	}
 	return result
+}
 func (t *Tester) NewMkLines(fileName string, lines ...string) *MkLines {
-	return NewMkLines(t.NewLines(fileName, lines...))
+	rawText := ""
 	for _, line := range lines {
 		rawText += line + "\n"
+	}
 	return NewMkLines(convertToLogicalLines(fileName, rawText, true))
+}
 // Returns and consumes the output from both stdout and stderr.
 // The temporary directory is replaced with a tilde (~).
 func (t *Tester) Output() string {
 	stdout := t.stdout.String()
 	stderr := t.stderr.String()
 	t.stdout.Reset()
 	t.stderr.Reset()
 	output := stdout + stderr
 	if t.tmpdir != "" {

 @@ -9,53 +9,55 @@ import (
 // MkLines contains data for the Makefile (or *.mk) that is currently checked.
 type MkLines struct {
 	mklines        []MkLine
 	lines          []Line
 	forVars        map[string]bool // The variables currently used in .for loops
 	target         string          // Current make(1) target
 	vars           Scope
 	buildDefs      map[string]bool // Variables that are registered in BUILD_DEFS, to ensure that all user-defined variables are added to it.
 	plistVars      map[string]bool // Variables that are registered in PLIST_VARS, to ensure that all user-defined variables are added to it.
 	tools          map[string]bool // Set of tools that are declared to be used.
 	toolRegistry   ToolRegistry    // Tools defined in file scope.
 	SeenBsdPrefsMk bool
 	indentation    Indentation // Indentation depth of preprocessing directives
 	Once
 	// XXX: Why both tools and toolRegistry?
+}
 func NewMkLines(lines []Line) *MkLines {
 	mklines := make([]MkLine, len(lines))
 	for i, line := range lines {
 		mklines[i] = NewMkLine(line)
+	}
 	tools := make(map[string]bool)
 	G.Pkgsrc.Tools.ForEach(func(tool *Tool) {
 		if tool.Predefined {
 			tools[tool.Name] = true
+		}
 	})
 	return &MkLines{
 		mklines,
 		lines,
 		make(map[string]bool),
 		"",
 		NewScope(),
 		make(map[string]bool),
 		make(map[string]bool),
 		tools,
 		NewToolRegistry(),
 		false,
-		Indentation{}}
+		Indentation{},
 		Once{}}
+}
 func (mklines *MkLines) UseVar(mkline MkLine, varname string) {
 	mklines.vars.Use(varname, mkline)
 	if G.Pkg != nil {
 		G.Pkg.vars.Use(varname, mkline)
+	}
+}
 func (mklines *MkLines) VarValue(varname string) (value string, found bool) {
 	if mkline := mklines.vars.FirstDefinition(varname); mkline != nil {
 		return mkline.Value(), true
+	}

 @@ -111,26 +111,37 @@ func (src *Pkgsrc) InitVartypes() {
+				}
+			}
 			for _, language := range splitOnSpace("ada c c99 c++ c++11 fortran fortran77 java objc obj-c++") {
 				languages[language] = true
+			}
 			joined := keysJoined(languages)
 			if trace.Tracing {
 				trace.Stepf("Languages from mk/compiler.mk: %s", joined)
+			}
 			return joined
 		}())
 	enumFrom := func(fileName, varname, defval string) *BasicType {
 		lines, _ := readLines(src.File(fileName), true)
 		mklines := NewMkLines(lines)
 		for _, mkline := range mklines.mklines {
 			if mkline.IsVarassign() && mkline.Varname() == varname {
 				return enum(mkline.Value())
+			}
+		}
 		return enum(defval)
+	}
 	// Last synced with mk/defaults/mk.conf revision 1.269
 	usr("USE_CWRAPPERS", lkNone, enum("yes no auto"))
 	usr("ALLOW_VULNERABLE_PACKAGES", lkNone, BtYes)
 	usr("AUDIT_PACKAGES_FLAGS", lkShell, BtShellWord)
 	usr("MANINSTALL", lkShell, enum("maninstall catinstall"))
 	usr("MANZ", lkNone, BtYes)
 	usr("GZIP", lkShell, BtShellWord)
 	usr("MAKE_JOBS", lkNone, BtInteger)
 	usr("OBJHOSTNAME", lkNone, BtYes)
 	usr("OBJMACHINE", lkNone, BtYes)
 	usr("SIGN_PACKAGES", lkNone, enum("gpg x509"))
 	usr("X509_KEY", lkNone, BtPathname)
 	usr("X509_CERTIFICATE", lkNone, BtPathname)
 @@ -578,27 +589,27 @@ func (src *Pkgsrc) InitVartypes() {
 	acl("ECHO", lkNone, BtShellCommand, "*: use")
 	sys("ECHO_MSG", lkNone, BtShellCommand)
 	sys("ECHO_N", lkNone, BtShellCommand)
 	pkg("EGDIR", lkNone, BtPathname) // Not defined anywhere, but used in many places like this.
 	sys("EMACS_BIN", lkNone, BtPathname)
 	sys("EMACS_ETCPREFIX", lkNone, BtPathname)
 	sys("EMACS_FLAVOR", lkNone, enum("emacs xemacs"))
 	sys("EMACS_INFOPREFIX", lkNone, BtPathname)
 	sys("EMACS_LISPPREFIX", lkNone, BtPathname)
 	acl("EMACS_MODULES", lkShell, BtIdentifier, "Makefile, Makefile.common: set, append")
 	sys("EMACS_PKGNAME_PREFIX", lkNone, BtIdentifier) // Or the empty string.
 	sys("EMACS_TYPE", lkNone, enum("emacs xemacs"))
 	acl("EMACS_USE_LEIM", lkNone, BtYes, "")
-	acl("EMACS_VERSIONS_ACCEPTED", lkShell, enum("emacs25 emacs21 emacs21nox emacs20 xemacs215 xemacs215nox xemacs214 xemacs214nox"), "Makefile: set")
+	acl("EMACS_VERSIONS_ACCEPTED", lkShell, enumFrom("editors/emacs/modules.mk", "_EMACS_VERSIONS_ALL", "emacs25 emacs21 emacs21nox emacs20 xemacs215 xemacs215nox xemacs214 xemacs214nox"), "Makefile: set")
 	sys("EMACS_VERSION_MAJOR", lkNone, BtInteger)
 	sys("EMACS_VERSION_MINOR", lkNone, BtInteger)
 	acl("EMACS_VERSION_REQD", lkShell, enum("emacs25 emacs25nox emacs21 emacs21nox emacs20 xemacs215 xemacs214"), "Makefile: set, append")
 	sys("EMULDIR", lkNone, BtPathname)
 	sys("EMULSUBDIR", lkNone, BtPathname)
 	sys("OPSYS_EMULDIR", lkNone, BtPathname)
 	sys("EMULSUBDIRSLASH", lkNone, BtPathname)
 	sys("EMUL_ARCH", lkNone, enum("arm i386 m68k none ns32k sparc vax x86_64"))
 	sys("EMUL_DISTRO", lkNone, BtIdentifier)
 	sys("EMUL_IS_NATIVE", lkNone, BtYes)
 	pkg("EMUL_MODULES.*", lkShell, BtIdentifier)
 	sys("EMUL_OPSYS", lkNone, enum("darwin freebsd hpux irix linux osf1 solaris sunos none"))
 	pkg("EMUL_PKG_FMT", lkNone, enum("plain rpm"))
 @@ -775,27 +786,27 @@ func (src *Pkgsrc) InitVartypes() {
 	sys("MASTER_SITE_PERL_CPAN", lkShell, BtFetchURL)
 	sys("MASTER_SITE_R_CRAN", lkShell, BtFetchURL)
 	sys("MASTER_SITE_RUBYGEMS", lkShell, BtFetchURL)
 	sys("MASTER_SITE_SOURCEFORGE", lkShell, BtFetchURL)
 	sys("MASTER_SITE_SUNSITE", lkShell, BtFetchURL)
 	sys("MASTER_SITE_SUSE", lkShell, BtFetchURL)
 	sys("MASTER_SITE_TEX_CTAN", lkShell, BtFetchURL)
 	sys("MASTER_SITE_XCONTRIB", lkShell, BtFetchURL)
 	sys("MASTER_SITE_XEMACS", lkShell, BtFetchURL)
 	pkglist("MESSAGE_SRC", lkShell, BtPathname)
 	acl("MESSAGE_SUBST", lkShell, BtShellWord, "Makefile, Makefile.common, options.mk: append")
 	pkg("META_PACKAGE", lkNone, BtYes)
 	sys("MISSING_FEATURES", lkShell, BtIdentifier)
-	acl("MYSQL_VERSIONS_ACCEPTED", lkShell, enum("51 55 56"), "Makefile: set")
+	acl("MYSQL_VERSIONS_ACCEPTED", lkShell, enumFrom("mk/mysql.buildlink3.mk", "MYSQL_VERSIONS_ACCEPTED", "57 56 55 51 MARIADB55"), "Makefile: set")
 	usr("MYSQL_VERSION_DEFAULT", lkNone, BtVersion)
 	sys("NM", lkNone, BtShellCommand)
 	sys("NONBINMODE", lkNone, BtFileMode)
 	pkg("NOT_FOR_COMPILER", lkShell, enum("ccache ccc clang distcc f2c gcc hp icc ido mipspro mipspro-ucode pcc sunpro xlc"))
 	pkglist("NOT_FOR_BULK_PLATFORM", lkSpace, BtMachinePlatformPattern)
 	pkglist("NOT_FOR_PLATFORM", lkSpace, BtMachinePlatformPattern)
 	pkg("NOT_FOR_UNPRIVILEGED", lkNone, BtYesNo)
 	pkglist("NOT_PAX_ASLR_SAFE", lkShell, BtPathmask)
 	pkglist("NOT_PAX_MPROTECT_SAFE", lkShell, BtPathmask)
 	acl("NO_BIN_ON_CDROM", lkNone, BtRestricted, "Makefile, Makefile.common: set")
 	acl("NO_BIN_ON_FTP", lkNone, BtRestricted, "Makefile, Makefile.common: set")
 	acl("NO_BUILD", lkNone, BtYes, "Makefile, Makefile.common: set; Makefile.*: default, set")
 	pkg("NO_CHECKSUM", lkNone, BtYes)
 @@ -823,27 +834,27 @@ func (src *Pkgsrc) InitVartypes() {
 	acl("PATCHDIR", lkNone, BtRelativePkgPath, "Makefile: set; Makefile.common: default, set")
 	pkglist("PATCHFILES", lkShell, BtFilename)
 	acl("PATCH_ARGS", lkShell, BtShellWord, "")
 	acl("PATCH_DIST_ARGS", lkShell, BtShellWord, "Makefile: set, append")
 	acl("PATCH_DIST_CAT", lkNone, BtShellCommand, "")
 	acl("PATCH_DIST_STRIP*", lkNone, BtShellWord, "buildlink3.mk, builtin.mk:; Makefile, Makefile.common, *.mk: set")
 	acl("PATCH_SITES", lkShell, BtFetchURL, "Makefile, Makefile.common, options.mk: set")
 	acl("PATCH_STRIP", lkNone, BtShellWord, "")
 	acl("PERL5_PACKLIST", lkShell, BtPerl5Packlist, "Makefile: set; options.mk: set, append")
 	acl("PERL5_PACKLIST_DIR", lkNone, BtPathname, "")
 	pkg("PERL5_REQD", lkShell, BtVersion)
 	pkg("PERL5_USE_PACKLIST", lkNone, BtYesNo)
 	sys("PGSQL_PREFIX", lkNone, BtPathname)
-	acl("PGSQL_VERSIONS_ACCEPTED", lkShell, enum("10 93 94 95 96"), "")
+	acl("PGSQL_VERSIONS_ACCEPTED", lkShell, enumFrom("mk/pgsql.buildlink3.mk", "PGSQL_VERSIONS_ACCEPTED", "10 96 95 94 93"), "")
 	usr("PGSQL_VERSION_DEFAULT", lkNone, BtVersion)
 	sys("PG_LIB_EXT", lkNone, enum("dylib so"))
 	sys("PGSQL_TYPE", lkNone, enum("postgresql81-client postgresql80-client"))
 	sys("PGPKGSRCDIR", lkNone, BtPathname)
 	sys("PHASE_MSG", lkNone, BtShellCommand)
 	usr("PHP_VERSION_REQD", lkNone, BtVersion)
 	sys("PKGBASE", lkNone, BtIdentifier)
 	acl("PKGCONFIG_FILE.*", lkShell, BtPathname, "builtin.mk: set, append; pkgconfig-builtin.mk: use-loadtime")
 	acl("PKGCONFIG_OVERRIDE", lkShell, BtPathmask, "Makefile: set, append; Makefile.common: append")
 	pkg("PKGCONFIG_OVERRIDE_STAGE", lkNone, BtStage)
 	pkg("PKGDIR", lkNone, BtRelativePkgDir)
 	sys("PKGDIRMODE", lkNone, BtFileMode)
 	sys("PKGLOCALEDIR", lkNone, BtPathname)

 @@ -616,40 +616,44 @@ func (cv *VartypeCheck) Message() {
 	if matches(value, `^[\"'].*[\"']$`) {
 		line.Warnf("%s should not be quoted.", varname)
 		Explain(
 			"The quoting is only needed for variables which are interpreted as",
 			"multiple words (or, generally speaking, a list of something).  A",
 			"single text message does not belong to this class, since it is only",
 			"printed as a whole.",
 			"",
 			"On the other hand, PKG_FAIL_REASON is a _list_ of text messages, so",
 			"in that case, the quoting has to be done.")
+	}
+}
-// A package option from options.mk
+// Option checks whether a single package option from options.mk conforms to the naming conventions.
 func (cv *VartypeCheck) Option() {
 	line, value, valueNovar := cv.Line, cv.Value, cv.ValueNoVar
 	if value != valueNovar {
 		if trace.Tracing {
 			trace.Step1("Unchecked option name: %q", value)
+		}
 		return
+	}
 	if m, optname := match1(value, `^-?([a-z][-0-9a-z+]*)$`); m {
 		if G.Mk != nil && !G.Mk.FirstTime("option:"+optname) {
 			return
+		}
 		if _, found := G.Pkgsrc.PkgOptions[optname]; !found { // There's a difference between empty and absent here.
-			line.Warnf("Unknown option \"%s\".", optname)
+			line.Warnf("Unknown option %q.", optname)
 			Explain(
 				"This option is not documented in the mk/defaults/options.description",
 				"file.  Please think of a brief but precise description and either",
 				"update that file yourself or suggest a description for this option",
 				"on the tech-pkg@NetBSD.org mailing list.")
+		}
 		return
+	}
 	if matches(value, `^-?([a-z][-0-9a-z_\+]*)$`) {
 		line.Warnf("Use of the underscore character in option names is deprecated.")
 		return
+	}

 @@ -1,16 +1,16 @@
-# $NetBSD: Makefile,v 1.541 2018/07/12 16:23:36 rillig Exp $
+# $NetBSD: Makefile,v 1.542 2018/07/19 06:38:15 rillig Exp $
-PKGNAME=	pkglint-5.5.13
+PKGNAME=	pkglint-5.5.14
 DISTFILES=	# none
 CATEGORIES=	pkgtools
 MAINTAINER=	rillig@NetBSD.org
 HOMEPAGE=	https://github.com/rillig/pkglint
 COMMENT=	Verifier for NetBSD packages
 LICENSE=	2-clause-bsd
 CONFLICTS+=	pkglint4-[0-9]*
 NO_CHECKSUM=	yes
 USE_TOOLS+=	pax
 AUTO_MKDIRS=	yes
 GO_SRCPATH=	netbsd.org/pkglint

 @@ -16,26 +16,39 @@ type MkLineChecker struct {
 func (ck MkLineChecker) Check() {
 	mkline := ck.MkLine
 	CheckLineTrailingWhitespace(mkline.Line)
 	CheckLineValidCharacters(mkline.Line, `[\t -~]`)
 	switch {
 	case mkline.IsVarassign():
 		ck.checkVarassign()
 	case mkline.IsShellCommand():
 		shellCommand := mkline.ShellCommand()
 		if G.opts.WarnSpace && hasPrefix(mkline.Text, "\t\t") {
 			fix := mkline.Autofix()
 			fix.Notef("Shell programs should be indented with a single tab.")
 			fix.Explain(
 				"The first tab in the line marks the line as a shell command.  Since",
 				"every line of shell commands starts with a completely new shell",
 				"environment, there is no need to indent some of the commands, or to",
 				"use more horizontal space than necessary.")
 			fix.ReplaceRegex(`^\t\t+`, "\t", 1)
 			fix.Apply()
+		}
 		ck.checkText(shellCommand)
 		NewShellLine(mkline).CheckShellCommandLine(shellCommand)
 	case mkline.IsComment():
 		if hasPrefix(mkline.Text, "# url2pkg-marker") {
 			mkline.Errorf("This comment indicates unfinished work (url2pkg).")
+		}
 	case mkline.IsInclude():
 		ck.checkInclude()
+	}
+}

 @@ -483,13 +483,52 @@ func (s *Suite) Test_MkLines_ExtractDocu
 		varnames = append(varnames, fmt.Sprintf("%s (line %s)", varname, mkline.Linenos()))
+	}
 	sort.Strings(varnames)
 	expected := []string{
 		"PKG_DEBUG_LEVEL (line 5)",
 		"PKG_VERBOSE (line 10)",
 		"VARBASE1.* (line 17)",
 		"VARBASE2.* (line 18)",
 		"VARBASE3.${id} (line 19)",
 		"VARBASE3.* (line 19)"}
 	c.Check(varnames, deepEquals, expected)
+}
 func (s *Suite) Test_MkLines__shell_command_indentation(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wall")
 	t.SetupVartypes()
 	mklines := t.NewMkLines("Makefile",
 		MkRcsID,
 		"#",
 		"pre-configure:",
 		"\tcd 'indented correctly'",
 		"\t\tcd 'indented needlessly'",
 		"\tcd 'indented correctly' \\",
 		"\t\t&& cd 'with indented continuation'")
 	mklines.Check()
 	t.CheckOutputLines(
 		"NOTE: Makefile:5: Shell programs should be indented with a single tab.")
+}
 func (s *Suite) Test_MkLines__unknown_options(c *check.C) {
 	t := s.Init(c)
 	t.SetupCommandLine("-Wall")
 	t.SetupVartypes()
 	t.SetupOption("known", "")
 	mklines := t.NewMkLines("options.mk",
 		MkRcsID,
 		"#",
 		"PKG_OPTIONS_VAR=\tPKG_OPTIONS.pkgbase",
 		"PKG_SUPPORTED_OPTIONS=\tknown unknown",
 		"PKG_SUGGESTED_OPTIONS=\tknown unknown")
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: options.mk:4: Unknown option \"unknown\".")
+}