 @@ -285,13 +285,52 @@ func (s *Suite) Test_ChecklinesBuildlink
 		"BUILDLINK_API_DEPENDS.${LICENSE}-wxWidgets+=\t${PYPKGPREFIX}-wxWidgets>=2.6.1.0",
 		"BUILDLINK_ABI_DEPENDS.${LICENSE}-wxWidgets+=\t${PYPKGPREFIX}-wxWidgets>=2.8.10.1nb26",
 		"",
 		".endif",
 		"",
 		"BUILDLINK_TREE+=\t-${PYPKGPREFIX}-wxWidgets")
 	ChecklinesBuildlink3Mk(mklines)
 	s.CheckOutputLines(
 		"WARN: buildlink3.mk:3: Please replace \"${LICENSE}\" with a simple string (also in other variables in this file).",
 		"WARN: buildlink3.mk:13: This line should contain the following text: BUILDLINK_TREE+=\t-${LICENSE}-wxWidgets")
+}
 // Those .include lines that are not indented at all may stay as-is.
 // This special exception might have been for backwards-compatibility,
 // but ideally should be handled like everywhere else.
 // See MkLineChecker.checkInclude.
 func (s *Suite) Test_ChecklinesBuildlink3Mk_indentation(c *check.C) {
 	s.Init(c)
 	s.UseCommandLine("-Wall")
 	G.globalData.InitVartypes()
 	mklines := s.NewMkLines("buildlink3.mk",
 		mkrcsid,
 		"",
 		".if ${VAAPI_AVAILABLE} == \"yes\"",
 		"",
 		"BUILDLINK_TREE+=	libva",
 		"",
 		".  if !defined(LIBVA_BUILDLINK3_MK)",
 		"LIBVA_BUILDLINK3_MK:=",
 		"",
 		"BUILDLINK_API_DEPENDS.libva+=	libva>=1.0.6",
 		"BUILDLINK_PKGSRCDIR.libva?=	../../multimedia/libva",
 		"",
 		".include \"../../x11/libX11/buildlink3.mk\"",
 		"",
 		".  endif	# LIBVA_BUILDLINK3_MK",
 		"",
 		"BUILDLINK_TREE+=	-libva",
 		"",
 		".endif # VAAPI_AVAILABLE")
 	ChecklinesBuildlink3Mk(mklines)
 	// No warning about the indentation of the .include lines.
 	s.CheckOutputLines(
 		"ERROR: buildlink3.mk:11: \"/multimedia/libva\" does not exist.",
 		"ERROR: buildlink3.mk:11: There is no package in \"multimedia/libva\".",
 		"ERROR: buildlink3.mk:13: \"/x11/libX11/buildlink3.mk\" does not exist.",
 		"WARN: buildlink3.mk:3: Expected a BUILDLINK_TREE line.")
+}

	@@ -96,41 +96,48 @@ func (ck *distinfoLinesChecker) onFilena		@@ -96,41 +96,48 @@ func (ck *distinfoLinesChecker) onFilena
96	"",	96	"",
97	"If the patches directory looks wrong, pkglint needs to be improved.")	97	"If the patches directory looks wrong, pkglint needs to be improved.")
98	} else if algorithms != "SHA1, RMD160, Size" && algorithms != "SHA1, RMD160, SHA512, Size" {	98	} else if algorithms != "SHA1, RMD160, Size" && algorithms != "SHA1, RMD160, SHA512, Size" {
99	line.Errorf("Expected SHA1, RMD160, SHA512, Size checksums for %q, got %s.", currentFname, algorithms)	99	line.Errorf("Expected SHA1, RMD160, SHA512, Size checksums for %q, got %s.", currentFname, algorithms)
100	}	100	}
101	}	101	}
102		102
103	ck.isPatch = hasPrefix(nextFname, "patch-") && fileExists(G.CurrentDir+"/"+ck.patchdir+"/"+nextFname)	103	ck.isPatch = hasPrefix(nextFname, "patch-") && fileExists(G.CurrentDir+"/"+ck.patchdir+"/"+nextFname)
104	ck.currentFilename = nextFname	104	ck.currentFilename = nextFname
105	ck.currentFirstLine = line	105	ck.currentFirstLine = line
106	ck.algorithms = nil	106	ck.algorithms = nil
107	}	107	}
108		108
109	func (ck *distinfoLinesChecker) checkPatchSha1(line Line, patchFname, distinfoSha1Hex string) {	109	func computePatchSha1Hex(patchFilename string) (string, error) {
110	patchBytes, err := ioutil.ReadFile(G.CurrentDir + "/" + patchFname)	110	patchBytes, err := ioutil.ReadFile(patchFilename)
111	if err != nil {	111	if err != nil {
112	line.Errorf("%s does not exist.", patchFname)	112	return "", err
113	return
114	}	113	}
115		114
116	h := sha1.New()	115	h := sha1.New()
117	netbsd := []byte("$" + "NetBSD")	116	netbsd := []byte("$" + "NetBSD")
118	for _, patchLine := range bytes.SplitAfter(patchBytes, []byte("\n")) {	117	for _, patchLine := range bytes.SplitAfter(patchBytes, []byte("\n")) {
119	if !bytes.Contains(patchLine, netbsd) {	118	if !bytes.Contains(patchLine, netbsd) {
120	h.Write(patchLine)	119	h.Write(patchLine)
121	}	120	}
122	}	121	}
123	fileSha1Hex := fmt.Sprintf("%x", h.Sum(nil))	122	return fmt.Sprintf("%x", h.Sum(nil)), nil
		123	}
		124
		125	func (ck *distinfoLinesChecker) checkPatchSha1(line Line, patchFname, distinfoSha1Hex string) {
		126	fileSha1Hex, err := computePatchSha1Hex(G.CurrentDir + "/" + patchFname)
		127	if err != nil {
		128	line.Errorf("%s does not exist.", patchFname)
		129	return
		130	}
124	if distinfoSha1Hex != fileSha1Hex {	131	if distinfoSha1Hex != fileSha1Hex {
125	if !line.AutofixReplace(distinfoSha1Hex, fileSha1Hex) {	132	if !line.AutofixReplace(distinfoSha1Hex, fileSha1Hex) {
126	line.Errorf("%s hash of %s differs (distinfo has %s, patch file has %s). Run \"%s makepatchsum\".", "SHA1", patchFname, distinfoSha1Hex, fileSha1Hex, confMake)	133	line.Errorf("%s hash of %s differs (distinfo has %s, patch file has %s). Run \"%s makepatchsum\".", "SHA1", patchFname, distinfoSha1Hex, fileSha1Hex, confMake)
127	}	134	}
128	}	135	}
129	}	136	}
130		137
131	func (ck *distinfoLinesChecker) checkUnrecordedPatches() {	138	func (ck *distinfoLinesChecker) checkUnrecordedPatches() {
132	files, err := ioutil.ReadDir(G.CurrentDir + "/" + ck.patchdir)	139	files, err := ioutil.ReadDir(G.CurrentDir + "/" + ck.patchdir)
133	if err != nil {	140	if err != nil {
134	if trace.Tracing {	141	if trace.Tracing {
135	trace.Stepf("Cannot read patchesDir %q: %s", ck.patchdir, err)	142	trace.Stepf("Cannot read patchesDir %q: %s", ck.patchdir, err)
136	}	143	}
	@@ -161,13 +168,23 @@ func (ck *distinfoLinesChecker) checkGlo		@@ -161,13 +168,23 @@ func (ck *distinfoLinesChecker) checkGlo
161	}	168	}
162	}	169	}
163		170
164	func (ck *distinfoLinesChecker) checkUncommittedPatch(line Line, patchName, sha1Hash string) {	171	func (ck *distinfoLinesChecker) checkUncommittedPatch(line Line, patchName, sha1Hash string) {
165	if ck.isPatch {	172	if ck.isPatch {
166	patchFname := ck.patchdir + "/" + patchName	173	patchFname := ck.patchdir + "/" + patchName
167	if ck.distinfoIsCommitted && !isCommitted(G.CurrentDir+"/"+patchFname) {	174	if ck.distinfoIsCommitted && !isCommitted(G.CurrentDir+"/"+patchFname) {
168	line.Warnf("%s is registered in distinfo but not added to CVS.", patchFname)	175	line.Warnf("%s is registered in distinfo but not added to CVS.", patchFname)
169	}	176	}
170	ck.checkPatchSha1(line, patchFname, sha1Hash)	177	ck.checkPatchSha1(line, patchFname, sha1Hash)
171	ck.patches[patchName] = true	178	ck.patches[patchName] = true
172	}	179	}
173	}	180	}
		181
		182	func AutofixDistinfo(oldSha1, newSha1 string) {
		183	distinfoFilename := G.CurrentDir + "/" + G.Pkg.DistinfoFile
		184	if lines, err := readLines(distinfoFilename, false); err == nil {
		185	for _, line := range lines {
		186	line.AutofixReplace(oldSha1, newSha1)
		187	}
		188	SaveAutofixChanges(lines)
		189	}
		190	}

 @@ -92,32 +92,33 @@ func NewMkLine(line Line) (mkline *MkLin
 			value,
 			comment}
 		mkline.Tokenize(value)
 		return
+	}
 	if hasPrefix(text, "\t") {
 		shellcmd := text[1:]
 		mkline.data = mkLineShell{shellcmd}
 		mkline.Tokenize(shellcmd)
 		return
+	}
-	if index := strings.IndexByte(text, '#'); index != -1 && strings.TrimSpace(text[:index]) == "" {
+	trimmedText := strings.TrimSpace(text)
 	if strings.HasPrefix(trimmedText, "#") {
 		mkline.data = mkLineComment{}
 		return
+	}
-	if strings.TrimSpace(text) == "" {
+	if trimmedText == "" {
 		mkline.data = mkLineEmpty{}
 		return
+	}
 	if m, indent, directive, args := matchMkCond(text); m {
 		mkline.data = mkLineConditional{indent, directive, args}
 		return
+	}
 	if m, indent, directive, includefile := MatchMkInclude(text); m {
 		mkline.data = mkLineInclude{directive == "include", false, indent, includefile, ""}
 		return
+	}
 @@ -302,37 +303,37 @@ func matchMkCond(text string) (m bool, i
 	directive = text[directiveStart:directiveEnd]
 	switch directive {
 	case "if", "ifdef", "ifndef", "else", "elif", "endif", "for", "endfor", "undef":
 		break
 	default:
 		return
+	}
 	for i < n && (text[i] == ' ' || text[i] == '\t') {
 		i++
+	}
 	argsStart := i
-	for i < n && text[i] != '#' {
+	for i < n && (text[i] != '#' || text[i-1] == '\\') {
 		i++
+	}
 	for i > argsStart && (text[i-1] == ' ' || text[i-1] == '\t') {
 		i--
+	}
 	argsEnd := i
 	m = true
 	indent = text[indentStart:indentEnd]
-	args = text[argsStart:argsEnd]
+	args = strings.Replace(text[argsStart:argsEnd], "\\#", "#", -1)
 	return
+}
 type NeedsQuoting uint8
 const (
 	nqNo NeedsQuoting = iota
 	nqYes
 	nqDoesntMatter
 	nqDontKnow
+)
 func (nq NeedsQuoting) String() string {

 @@ -123,53 +123,53 @@ func (s *Suite) Test_VaralignBlock_Check
 		"NOTE: file.mk:2: This variable value should be aligned with tabs, not spaces, to column 33.",
 		"NOTE: file.mk:3: This variable value should be aligned with tabs, not spaces, to column 33.",
 		"NOTE: file.mk:4: This variable value should be aligned with tabs, not spaces, to column 33.")
+}
 func (s *Suite) Test_NewMkLine(c *check.C) {
 	s.Init(c)
 	s.UseCommandLine("-Wspace")
 	mklines := NewMkLines(s.NewLines("test.mk",
 		"VARNAME.param?=value # varassign comment",
 		"\tshell command # shell comment",
 		"# whole line comment",
 		"",
-		".  if !empty(PKGNAME:M*-*) # cond comment",
+		".  if !empty(PKGNAME:M*-*) && ${RUBY_RAILS_SUPPORTED:[\\#]} == 1 # cond comment",
 		".    include \"../../mk/bsd.prefs.mk\" # include comment",
 		".    include <subdir.mk> # sysinclude comment",
 		"target1 target2: source1 source2",
 		"target : source",
 		"VARNAME+=value"))
 	ln := mklines.mklines
 	c.Check(ln[0].IsVarassign(), equals, true)
 	c.Check(ln[0].Varname(), equals, "VARNAME.param")
 	c.Check(ln[0].Varcanon(), equals, "VARNAME.*")
 	c.Check(ln[0].Varparam(), equals, "param")
 	c.Check(ln[0].Op(), equals, opAssignDefault)
 	c.Check(ln[0].Value(), equals, "value")
 	c.Check(ln[0].VarassignComment(), equals, "# varassign comment")
 	c.Check(ln[1].IsShellcmd(), equals, true)
 	c.Check(ln[1].Shellcmd(), equals, "shell command # shell comment")
 	c.Check(ln[2].IsComment(), equals, true)
 	c.Check(ln[3].IsEmpty(), equals, true)
 	c.Check(ln[4].IsCond(), equals, true)
 	c.Check(ln[4].Indent(), equals, "  ")
 	c.Check(ln[4].Directive(), equals, "if")
-	c.Check(ln[4].Args(), equals, "!empty(PKGNAME:M*-*)")
+	c.Check(ln[4].Args(), equals, "!empty(PKGNAME:M*-*) && ${RUBY_RAILS_SUPPORTED:[#]} == 1")
 	c.Check(ln[5].IsInclude(), equals, true)
 	c.Check(ln[5].Indent(), equals, "    ")
 	c.Check(ln[5].MustExist(), equals, true)
 	c.Check(ln[5].Includefile(), equals, "../../mk/bsd.prefs.mk")
 	c.Check(ln[6].IsSysinclude(), equals, true)
 	c.Check(ln[6].Indent(), equals, "    ")
 	c.Check(ln[6].MustExist(), equals, true)
 	c.Check(ln[6].Includefile(), equals, "subdir.mk")
 	c.Check(ln[7].IsDependency(), equals, true)
 	c.Check(ln[7].Targets(), equals, "target1 target2")
 @@ -470,26 +470,45 @@ func (s *Suite) Test_MkLine_variableNeed
 	G.globalData.InitVartypes()
 	G.Mk = s.NewMkLines("x11/mlterm/Makefile",
 		mkrcsid,
 		"SUBST_SED.link=-e 's|(LIBTOOL_LINK).*(LIBS)|& ${LDFLAGS:M*:Q}|g'",
 		"SUBST_SED.link=-e 's|(LIBTOOL_LINK).*(LIBS)|& '${LDFLAGS:M*:Q}'|g'")
 	MkLineChecker{G.Mk.mklines[1]}.Check()
 	MkLineChecker{G.Mk.mklines[2]}.Check()
 	s.CheckOutputLines(
 		"WARN: x11/mlterm/Makefile:2: Please move ${LDFLAGS:M*:Q} outside of any quoting characters.")
+}
 // No quoting is necessary here.
 // PKG_OPTIONS are declared as "lkShell" although they are processed
 // using make's .for loop, which splits them at whitespace and usually
 // requires the variable to be declared as "lkSpace".
 // In this case it doesn't matter though since each option is an identifier,
 // and these do not pose any quoting problems.
 func (s *Suite) Test_MkLine_variableNeedsQuoting__package_options(c *check.C) {
 	s.Init(c)
 	s.UseCommandLine("-Wall")
 	G.globalData.InitVartypes()
 	G.Mk = s.NewMkLines("Makefile",
 		mkrcsid,
 		"PKG_SUGGESTED_OPTIONS+=\t${PKG_DEFAULT_OPTIONS:Mcdecimal} ${PKG_OPTIONS.py-trytond:Mcdecimal}")
 	MkLineChecker{G.Mk.mklines[1]}.Check()
 	s.CheckOutputEmpty()
+}
 func (s *Suite) Test_MkLines_Check__MASTER_SITE_in_HOMEPAGE(c *check.C) {
 	s.Init(c)
 	s.UseCommandLine("-Wall")
 	s.RegisterMasterSite("MASTER_SITE_GITHUB", "https://github.com/")
 	G.globalData.InitVartypes()
 	G.Mk = s.NewMkLines("devel/catch/Makefile",
 		mkrcsid,
 		"HOMEPAGE=\t${MASTER_SITE_GITHUB:=philsquared/Catch/}",
 		"HOMEPAGE=\t${MASTER_SITE_GITHUB}",
 		"HOMEPAGE=\t${MASTER_SITES}",
 		"HOMEPAGE=\t${MASTER_SITES}${GITHUB_PROJECT}")
 	G.Mk.Check()

 @@ -82,32 +82,31 @@ func (ck MkLineChecker) checkInclude() {
 		mkline.Errorf("%s must not be included directly. Include \"../../mk/x11.buildlink3.mk\" instead.", includefile)
 	case hasSuffix(includefile, "/jpeg/buildlink3.mk"):
 		mkline.Errorf("%s must not be included directly. Include \"../../mk/jpeg.buildlink3.mk\" instead.", includefile)
 	case hasSuffix(includefile, "/intltool/buildlink3.mk"):
 		mkline.Warnf("Please write \"USE_TOOLS+= intltool\" instead of this line.")
 	case hasSuffix(includefile, "/builtin.mk"):
 		mkline.Errorf("%s must not be included directly. Include \"%s/buildlink3.mk\" instead.", includefile, path.Dir(includefile))
+	}
+}
-func (ck MkLineChecker) checkCond(forVars map[string]bool) {
+func (ck MkLineChecker) checkCond(forVars map[string]bool, indentation *Indentation) {
 	mkline := ck.MkLine
 	directive := mkline.Directive()
 	args := mkline.Args()
 	indentation := &G.Mk.indentation
 	switch directive {
 	case "endif", "endfor":
 		if indentation.Len() > 1 {
 			indentation.Pop()
 		} else {
 			mkline.Errorf("Unmatched .%s.", directive)
+		}
+	}
 	expectedDepth := indentation.Depth()
 	if directive == "elif" || directive == "else" {
 		expectedDepth = indentation.depth[len(indentation.depth)-2]

 @@ -3,26 +3,27 @@ package main
 import (
 	check "gopkg.in/check.v1"
+)
 func (s *Suite) Test_MkParser_MkTokens(c *check.C) {
 	s.Init(c)
 	checkRest := func(input string, expectedTokens []*MkToken, expectedRest string) {
 		p := NewMkParser(dummyLine, input, true)
 		actualTokens := p.MkTokens()
 		c.Check(actualTokens, deepEquals, expectedTokens)
 		for i, expectedToken := range expectedTokens {
 			if i < len(actualTokens) {
 				c.Check(*actualTokens[i], deepEquals, *expectedToken)
 				c.Check(actualTokens[i].Varuse, deepEquals, expectedToken.Varuse)
+			}
+		}
 		c.Check(p.Rest(), equals, expectedRest)
+	}
 	check := func(input string, expectedToken *MkToken) {
 		checkRest(input, []*MkToken{expectedToken}, "")
+	}
 	literal := func(text string) *MkToken {
 		return &MkToken{Text: text}
+	}
 	varuse := func(varname string, modifiers ...string) *MkToken {
 		text := "${" + varname
 		for _, modifier := range modifiers {
 @@ -70,26 +71,27 @@ func (s *Suite) Test_MkParser_MkTokens(c
 	check("${_PERL5_VARS:tl:S/^/-V:/}", varuse("_PERL5_VARS", "tl", "S/^/-V:/"))
 	check("${_PERL5_VARS_OUT:M${_var_:tl}=*:S/^${_var_:tl}=${_PERL5_PREFIX:=/}//}", varuse("_PERL5_VARS_OUT", "M${_var_:tl}=*", "S/^${_var_:tl}=${_PERL5_PREFIX:=/}//"))
 	check("${RUBY${RUBY_VER}_PATCHLEVEL}", varuse("RUBY${RUBY_VER}_PATCHLEVEL"))
 	check("${DISTFILES:M*.gem}", varuse("DISTFILES", "M*.gem"))
 	check("${LOCALBASE:S^/^_^}", varuse("LOCALBASE", "S^/^_^"))
 	check("${SOURCES:%.c=%.o}", varuse("SOURCES", "%.c=%.o"))
 	check("${GIT_TEMPLATES:@.t.@ ${EGDIR}/${GIT_TEMPLATEDIR}/${.t.} ${PREFIX}/${GIT_CORE_TEMPLATEDIR}/${.t.} @:M*}",
 		varuse("GIT_TEMPLATES", "@.t.@ ${EGDIR}/${GIT_TEMPLATEDIR}/${.t.} ${PREFIX}/${GIT_CORE_TEMPLATEDIR}/${.t.} @", "M*"))
 	check("${DISTNAME:C:_:-:}", varuse("DISTNAME", "C:_:-:"))
 	check("${CF_FILES:H:O:u:S@^@${PKG_SYSCONFDIR}/@}", varuse("CF_FILES", "H", "O", "u", "S@^@${PKG_SYSCONFDIR}/@"))
 	check("${ALT_GCC_RTS:S%${LOCALBASE}%%:S%/%%}", varuse("ALT_GCC_RTS", "S%${LOCALBASE}%%", "S%/%%"))
 	check("${PREFIX:C;///*;/;g:C;/$;;}", varuse("PREFIX", "C;///*;/;g", "C;/$;;"))
 	check("${GZIP_CMD:[1]:Q}", varuse("GZIP_CMD", "[1]", "Q"))
 	check("${RUBY_RAILS_SUPPORTED:[#]}", varuse("RUBY_RAILS_SUPPORTED", "[#]"))
 	check("${DISTNAME:C/-[0-9]+$$//:C/_/-/}", varuse("DISTNAME", "C/-[0-9]+$$//", "C/_/-/"))
 	check("${DISTNAME:slang%=slang2%}", varuse("DISTNAME", "slang%=slang2%"))
 	check("${OSMAP_SUBSTVARS:@v@-e 's,\\@${v}\\@,${${v}},g' @}", varuse("OSMAP_SUBSTVARS", "@v@-e 's,\\@${v}\\@,${${v}},g' @"))
 	check("${BRANDELF:D${BRANDELF} -t Linux ${LINUX_LDCONFIG}:U${TRUE}}", varuse("BRANDELF", "D${BRANDELF} -t Linux ${LINUX_LDCONFIG}", "U${TRUE}"))
 	check("${${_var_}.*}", varuse("${_var_}.*"))
 	check("${GCONF_SCHEMAS:@.s.@${INSTALL_DATA} ${WRKSRC}/src/common/dbus/${.s.} ${DESTDIR}${GCONF_SCHEMAS_DIR}/@}",
 		varuse("GCONF_SCHEMAS", "@.s.@${INSTALL_DATA} ${WRKSRC}/src/common/dbus/${.s.} ${DESTDIR}${GCONF_SCHEMAS_DIR}/@"))
 	/* weird features */
 	check("${${EMACS_VERSION_MAJOR}>22:?@comment :}", varuse("${EMACS_VERSION_MAJOR}>22", "?@comment :"))
 	check("${empty(CFLAGS):?:-cflags ${CFLAGS:Q}}", varuse("empty(CFLAGS)", "?:-cflags ${CFLAGS:Q}"))
 	check("${${PKGSRC_COMPILER}==gcc:?gcc:cc}", varuse("${PKGSRC_COMPILER}==gcc", "?gcc:cc"))

	@@ -161,27 +161,27 @@ func (p *MkParser) VarUseModifiers(varna		@@ -161,27 +161,27 @@ func (p *MkParser) VarUseModifiers(varna
161	case '@':	161	case '@':
162	if repl.AdvanceRegexp(`^@([\w.]+)@`) {	162	if repl.AdvanceRegexp(`^@([\w.]+)@`) {
163	loopvar := repl.Group(1)	163	loopvar := repl.Group(1)
164	for p.VarUse() != nil \|\| repl.AdvanceRegexp(regex.Pattern(`^([^$:@`+closing+`\\]\|\$\$\|\\.)+`)) {	164	for p.VarUse() != nil \|\| repl.AdvanceRegexp(regex.Pattern(`^([^$:@`+closing+`\\]\|\$\$\|\\.)+`)) {
165	}	165	}
166	if !repl.AdvanceStr("@") && p.EmitWarnings {	166	if !repl.AdvanceStr("@") && p.EmitWarnings {
167	p.Line.Warnf("Modifier ${%s:@%s@...@} is missing the final \"@\".", varname, loopvar)	167	p.Line.Warnf("Modifier ${%s:@%s@...@} is missing the final \"@\".", varname, loopvar)
168	}	168	}
169	modifiers = append(modifiers, repl.Since(modifierMark))	169	modifiers = append(modifiers, repl.Since(modifierMark))
170	continue	170	continue
171	}	171	}
172		172
173	case '[':	173	case '[':
174	if repl.AdvanceRegexp(`^\[[-.\d]+\]`) {	174	if repl.AdvanceRegexp(`^\[(?:[-.\d]+\|#)\]`) {
175	modifiers = append(modifiers, repl.Since(modifierMark))	175	modifiers = append(modifiers, repl.Since(modifierMark))
176	continue	176	continue
177	}	177	}
178		178
179	case '?':	179	case '?':
180	repl.AdvanceStr("?")	180	repl.AdvanceStr("?")
181	re := regex.Pattern(`^([^$:` + closing + `]\|\$\$)+`)	181	re := regex.Pattern(`^([^$:` + closing + `]\|\$\$)+`)
182	for p.VarUse() != nil \|\| repl.AdvanceRegexp(re) {	182	for p.VarUse() != nil \|\| repl.AdvanceRegexp(re) {
183	}	183	}
184	if repl.AdvanceStr(":") {	184	if repl.AdvanceStr(":") {
185	for p.VarUse() != nil \|\| repl.AdvanceRegexp(re) {	185	for p.VarUse() != nil \|\| repl.AdvanceRegexp(re) {
186	}	186	}
187	modifiers = append(modifiers, repl.Since(modifierMark))	187	modifiers = append(modifiers, repl.Since(modifierMark))

	@@ -80,27 +80,33 @@ func (ck *PatchChecker) Check() {		@@ -80,27 +80,33 @@ func (ck *PatchChecker) Check() {
80	ck.previousLineEmpty = ck.isEmptyLine(line.Text)	80	ck.previousLineEmpty = ck.isEmptyLine(line.Text)
81	if !ck.previousLineEmpty {	81	if !ck.previousLineEmpty {
82	ck.seenDocumentation = true	82	ck.seenDocumentation = true
83	}	83	}
84	}	84	}
85		85
86	if patchedFiles > 1 {	86	if patchedFiles > 1 {
87	NewLineWhole(ck.lines[0].Filename).Warnf("Contains patches for %d files, should be only one.", patchedFiles)	87	NewLineWhole(ck.lines[0].Filename).Warnf("Contains patches for %d files, should be only one.", patchedFiles)
88	} else if patchedFiles == 0 {	88	} else if patchedFiles == 0 {
89	NewLineWhole(ck.lines[0].Filename).Errorf("Contains no patch.")	89	NewLineWhole(ck.lines[0].Filename).Errorf("Contains no patch.")
90	}	90	}
91		91
92	ChecklinesTrailingEmptyLines(ck.lines)	92	ChecklinesTrailingEmptyLines(ck.lines)
93	SaveAutofixChanges(ck.lines)	93	sha1Before, err := computePatchSha1Hex(ck.lines[0].Filename)
		94	if SaveAutofixChanges(ck.lines) && G.Pkg != nil && err == nil {
		95	sha1After, err := computePatchSha1Hex(ck.lines[0].Filename)
		96	if err == nil {
		97	AutofixDistinfo(sha1Before, sha1After)
		98	}
		99	}
94	}	100	}
95		101
96	// See http://www.gnu.org/software/diffutils/manual/html_node/Detailed-Unified.html	102	// See http://www.gnu.org/software/diffutils/manual/html_node/Detailed-Unified.html
97	func (ck *PatchChecker) checkUnifiedDiff(patchedFile string) {	103	func (ck *PatchChecker) checkUnifiedDiff(patchedFile string) {
98	if trace.Tracing {	104	if trace.Tracing {
99	defer trace.Call0()()	105	defer trace.Call0()()
100	}	106	}
101		107
102	patchedFileType := guessFileType(ck.exp.CurrentLine(), patchedFile)	108	patchedFileType := guessFileType(ck.exp.CurrentLine(), patchedFile)
103	if trace.Tracing {	109	if trace.Tracing {
104	trace.Stepf("guessFileType(%q) = %s", patchedFile, patchedFileType)	110	trace.Stepf("guessFileType(%q) = %s", patchedFile, patchedFileType)
105	}	111	}
106		112

 @@ -23,38 +23,36 @@ func (s *Suite) Test_ChecklinesPlist(c *
 		"${PLIST.obsolete}@unexec rmdir /tmp",
 		"sbin/clockctl",
 		"share/icons/gnome/delete-icon",
 		"share/icons/hicolor/icon1.png",
 		"share/icons/hicolor/icon2.png", // No additional warning
 		"share/tzinfo",
 		"share/tzinfo")
 	ChecklinesPlist(lines)
 	s.CheckOutputLines(
 		"ERROR: PLIST:1: Expected \"@comment $"+"NetBSD$\".",
 		"WARN: PLIST:1: The bin/ directory should not have subdirectories.",
 		"WARN: PLIST:2: Manual page missing for bin/program.",
 		"ERROR: PLIST:3: Configuration files must not be registered in the PLIST. Please use the CONF_FILES framework, which is described in mk/pkginstall/bsd.pkginstall.mk.",
 		"ERROR: PLIST:4: RCD_SCRIPTS must not be registered in the PLIST. Please use the RCD_SCRIPTS framework.",
 		"ERROR: PLIST:6: \"info/dir\" must not be listed. Use install-info to add/remove an entry.",
 		"WARN: PLIST:7: Library filename \"c.so\" should start with \"lib\".",
 		"WARN: PLIST:8: Redundant library found. The libtool library is in line 9.",
 		"WARN: PLIST:9: \"lib/libc.la\" should be sorted before \"lib/libc.so.6\".",
 		"WARN: PLIST:10: Preformatted manual page without unformatted one.",
 		"WARN: PLIST:10: Preformatted manual pages should end in \".0\".",
 		"WARN: PLIST:11: IMAKE_MANNEWSUFFIX is not meant to appear in PLISTs.",
 		"WARN: PLIST:12: Please remove this line. It is no longer necessary.",
 		"WARN: PLIST:13: Manual page missing for sbin/clockctl.",
 		"ERROR: PLIST:14: The package Makefile must include \"../../graphics/gnome-icon-theme/buildlink3.mk\".",
 		"WARN: PLIST:14: Packages that install icon theme files should set ICON_THEMES.",
 		"ERROR: PLIST:15: Packages that install hicolor icons must include \"../../graphics/hicolor-icon-theme/buildlink3.mk\" in the Makefile.",
 		"ERROR: PLIST:18: Duplicate filename \"share/tzinfo\", already appeared in line 17.")
+}
 func (s *Suite) Test_ChecklinesPlist__empty(c *check.C) {
 	s.Init(c)
 	lines := s.NewLines("PLIST",
 		"@comment $"+"NetBSD$")
 	ChecklinesPlist(lines)

 @@ -17,62 +17,78 @@ func (s *Suite) Test_ChecklinesPatch__wi
 		"--- file.orig",
 		"+++ file",
 		"@@ -5,3 +5,3 @@",
 		" context before",
 		"-old line",
 		"+old line",
 		" context after")
 	ChecklinesPatch(lines)
 	s.CheckOutputEmpty()
+}
-func (s *Suite) Test_ChecklinesPatch__without_empty_line(c *check.C) {
+func (s *Suite) Test_ChecklinesPatch__without_empty_line__autofix(c *check.C) {
 	s.Init(c)
-	fname := s.CreateTmpFile("patch-WithoutEmptyLines", "dummy")
+	patchFilename := s.CreateTmpFileLines("patch-WithoutEmptyLines",
 	s.UseCommandLine("-Wall", "--autofix")
 	lines := s.NewLines(fname,
 		"$"+"NetBSD$",
 		"Text",
 		"--- file.orig",
 		"+++ file",
 		"@@ -5,3 +5,3 @@",
 		" context before",
 		"-old line",
 		"+old line",
 		" context after")
 	distinfoFilename := s.CreateTmpFileLines("distinfo",
 		"$"+"NetBSD$",
 		"",
 		"SHA1 (some patch) = 87ffcaaa0b0677ec679fff612b44df1af05f04df") // Taken from breakpoint at AutofixDistinfo
 	s.UseCommandLine("-Wall", "--autofix")
 	lines := LoadExistingLines(patchFilename, false)
 	G.CurrentDir = s.TmpDir()
 	G.Pkg = &Package{DistinfoFile: "distinfo"}
 	ChecklinesPatch(lines)
 	s.CheckOutputLines(
 		"AUTOFIX: ~/patch-WithoutEmptyLines:2: Inserting a line \"\" before this line.",
 		"AUTOFIX: ~/patch-WithoutEmptyLines:3: Inserting a line \"\" before this line.",
-		"AUTOFIX: ~/patch-WithoutEmptyLines: Has been auto-fixed. Please re-run pkglint.")
+		"AUTOFIX: ~/patch-WithoutEmptyLines: Has been auto-fixed. Please re-run pkglint.",
 		"AUTOFIX: ~/distinfo:3: Replacing \"87ffcaaa0b0677ec679fff612b44df1af05f04df\" "+
 			"with \"a7c35294b3853da0acedf8a972cb266baa9582a3\".",
 		"AUTOFIX: ~/distinfo: Has been auto-fixed. Please re-run pkglint.")
-	fixed, err := ioutil.ReadFile(fname)
+	fixed, err := ioutil.ReadFile(patchFilename)
 	c.Assert(err, check.IsNil)
 	c.Check(string(fixed), equals, ""+
 		"$"+"NetBSD$\n"+
 		"\n"+
 		"Text\n"+
 		"\n"+
 		"--- file.orig\n"+
 		"+++ file\n"+
 		"@@ -5,3 +5,3 @@\n"+
 		" context before\n"+
 		"-old line\n"+
 		"+old line\n"+
 		" context after\n")
 	fixedDistinfo, err := ioutil.ReadFile(distinfoFilename)
 	c.Assert(err, check.IsNil)
 	c.Check(string(fixedDistinfo), equals, ""+
 		"$"+"NetBSD$\n"+
 		"\n"+
 		"SHA1 (some patch) = a7c35294b3853da0acedf8a972cb266baa9582a3\n")
+}
 func (s *Suite) Test_ChecklinesPatch__without_comment(c *check.C) {
 	s.Init(c)
 	s.UseCommandLine("-Wall")
 	lines := s.NewLines("patch-WithoutComment",
 		"$"+"NetBSD$",
 		"",
 		"--- file.orig",
 		"+++ file",
 		"@@ -5,3 +5,3 @@",
 		" context before",
 		"-old line",

 @@ -165,28 +165,26 @@ func (ck *PlistChecker) checkpath(pline
 	switch topdir {
 	case "bin":
 		ck.checkpathBin(pline, dirname, basename)
 	case "doc":
 		line.Errorf("Documentation must be installed under share/doc, not doc.")
 	case "etc":
 		ck.checkpathEtc(pline, dirname, basename)
 	case "info":
 		ck.checkpathInfo(pline, dirname, basename)
 	case "lib":
 		ck.checkpathLib(pline, dirname, basename)
 	case "man":
 		ck.checkpathMan(pline)
 	case "sbin":
 		ck.checkpathSbin(pline)
 	case "share":
 		ck.checkpathShare(pline)
+	}
 	if contains(text, "${PKGLOCALEDIR}") && G.Pkg != nil && G.Pkg.vardef["USE_PKGLOCALEDIR"] == nil {
 		line.Warnf("PLIST contains ${PKGLOCALEDIR}, but USE_PKGLOCALEDIR was not found.")
+	}
 	if contains(text, "/CVS/") {
 		line.Warnf("CVS files should not be in the PLIST.")
+	}
 	if hasSuffix(text, ".orig") {
 		line.Warnf(".orig files should not be in the PLIST.")
 @@ -216,39 +214,26 @@ func (ck *PlistChecker) checkSorted(plin
 					pline.line.Errorf("Duplicate filename %q, already appeared in %s.", text, prev.line.ReferenceFrom(pline.line))
+				}
+			}
+		}
 		ck.lastFname = text
+	}
+}
 func (ck *PlistChecker) checkpathBin(pline *PlistLine, dirname, basename string) {
 	if contains(dirname, "/") {
 		pline.line.Warnf("The bin/ directory should not have subdirectories.")
 		return
+	}
 	if G.opts.WarnExtra &&
 		ck.allFiles["man/man1/"+basename+".1"] == nil &&
 		ck.allFiles["man/man6/"+basename+".6"] == nil &&
 		ck.allFiles["${IMAKE_MAN_DIR}/"+basename+".${IMAKE_MANNEWSUFFIX}"] == nil {
 		pline.line.Warnf("Manual page missing for bin/%s.", basename)
 		Explain(
 			"All programs that can be run directly by the user should have a",
 			"manual page for quick reference.  The programs in the bin/ directory",
 			"should have corresponding manual pages in section 1 (filename",
 			"program.1), while the programs in the sbin/ directory have their",
 			"manual pages in section 8.")
+}
 func (ck *PlistChecker) checkpathEtc(pline *PlistLine, dirname, basename string) {
 	if hasPrefix(pline.text, "etc/rc.d/") {
 		pline.line.Errorf("RCD_SCRIPTS must not be registered in the PLIST. Please use the RCD_SCRIPTS framework.")
 		return
+	}
 	pline.line.Errorf("Configuration files must not be registered in the PLIST. " +
 		"Please use the CONF_FILES framework, which is described in mk/pkginstall/bsd.pkginstall.mk.")
+}
 func (ck *PlistChecker) checkpathInfo(pline *PlistLine, dirname, basename string) {
 @@ -314,50 +299,36 @@ func (ck *PlistChecker) checkpathMan(pli
 		line.Warnf("Preformatted manual page without unformatted one.")
+	}
 	if catOrMan == "cat" {
 		if ext != "0" {
 			line.Warnf("Preformatted manual pages should end in \".0\".")
+		}
 	} else {
 		if !hasPrefix(ext, section) {
 			line.Warnf("Mismatch between the section (%s) and extension (%s) of the manual page.", section, ext)
+		}
+	}
-	if gz != "" {
+	if gz != "" && !line.AutofixReplaceRegexp(`\.gz$`, "") {
 		line.Notef("The .gz extension is unnecessary for manual pages.")
 		Explain(
 			"Whether the manual pages are installed in compressed form or not is",
 			"configured by the pkgsrc user.  Compression and decompression takes",
 			"place automatically, no matter if the .gz extension is mentioned in",
 			"the PLIST or not.")
+	}
+}
 func (ck *PlistChecker) checkpathSbin(pline *PlistLine) {
 	binname := pline.text[5:]
 	if ck.allFiles["man/man8/"+binname+".8"] == nil && G.opts.WarnExtra {
 		pline.line.Warnf("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 {
 	// 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.Warnf("Packages that install a .desktop entry should .include %q.", f)
 			Explain(
 				"If *.desktop files contain MimeType keys, the global MIME type",
 				"registry must be updated by desktop-file-utils.  Otherwise, this",
 				"warning is harmless.")
+		}

 @@ -797,36 +797,36 @@ func (gd *GlobalData) InitVartypes() {
 	acl("PKG_GECOS.*", lkNone, BtMessage, "Makefile: set")
 	acl("PKG_GID.*", lkNone, BtInteger, "Makefile: set")
 	acl("PKG_GROUPS", lkShell, BtShellWord, "Makefile: set, append")
 	pkglist("PKG_GROUPS_VARS", lkShell, BtVariableName)
 	acl("PKG_HOME.*", lkNone, BtPathname, "Makefile: set")
 	acl("PKG_HACKS", lkShell, BtIdentifier, "hacks.mk: append")
 	sys("PKG_INFO", lkNone, BtShellCommand)
 	sys("PKG_JAVA_HOME", lkNone, BtPathname)
 	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, BtOption, "")
 	acl("PKG_LIBTOOL", lkNone, BtPathname, "Makefile: set")
-	acl("PKG_OPTIONS", lkSpace, BtOption, "bsd.options.mk: set; *: use-loadtime, use")
+	acl("PKG_OPTIONS", lkShell, BtOption, "bsd.options.mk: set; *: use-loadtime, use")
-	usr("PKG_OPTIONS.*", lkSpace, BtOption)
+	usr("PKG_OPTIONS.*", lkShell, BtOption)
 	acl("PKG_OPTIONS_DEPRECATED_WARNINGS", lkShell, BtShellWord, "")
-	acl("PKG_OPTIONS_GROUP.*", lkSpace, BtOption, "Makefile, options.mk: set, append")
+	acl("PKG_OPTIONS_GROUP.*", lkShell, BtOption, "Makefile, options.mk: set, append")
-	acl("PKG_OPTIONS_LEGACY_OPTS", lkSpace, BtUnknown, "Makefile, Makefile.common, options.mk: append")
+	acl("PKG_OPTIONS_LEGACY_OPTS", lkShell, BtUnknown, "Makefile, Makefile.common, options.mk: append")
-	acl("PKG_OPTIONS_LEGACY_VARS", lkSpace, BtUnknown, "Makefile, Makefile.common, options.mk: append")
+	acl("PKG_OPTIONS_LEGACY_VARS", lkShell, BtUnknown, "Makefile, Makefile.common, options.mk: append")
-	acl("PKG_OPTIONS_NONEMPTY_SETS", lkSpace, BtIdentifier, "")
+	acl("PKG_OPTIONS_NONEMPTY_SETS", lkShell, BtIdentifier, "")
-	acl("PKG_OPTIONS_OPTIONAL_GROUPS", lkSpace, BtIdentifier, "options.mk: set, append")
+	acl("PKG_OPTIONS_OPTIONAL_GROUPS", lkShell, BtIdentifier, "options.mk: set, append")
-	acl("PKG_OPTIONS_REQUIRED_GROUPS", lkSpace, BtIdentifier, "Makefile, options.mk: set")
+	acl("PKG_OPTIONS_REQUIRED_GROUPS", lkShell, BtIdentifier, "Makefile, options.mk: set")
-	acl("PKG_OPTIONS_SET.*", lkSpace, BtOption, "")
+	acl("PKG_OPTIONS_SET.*", lkShell, BtOption, "")
 	acl("PKG_OPTIONS_VAR", lkNone, BtPkgOptionsVar, "Makefile, Makefile.common, options.mk: set; bsd.options.mk: use-loadtime")
 	acl("PKG_PRESERVE", lkNone, BtYes, "Makefile: set")
 	acl("PKG_SHELL", lkNone, BtPathname, "Makefile, Makefile.common: set")
 	acl("PKG_SHELL.*", lkNone, BtPathname, "Makefile, Makefile.common: set")
 	acl("PKG_SHLIBTOOL", lkNone, BtPathname, "")
 	pkglist("PKG_SKIP_REASON", lkShell, BtShellWord)
 	acl("PKG_SUGGESTED_OPTIONS", lkShell, BtOption, "Makefile, Makefile.common, options.mk: set, append")
 	acl("PKG_SUGGESTED_OPTIONS.*", lkShell, BtOption, "Makefile, Makefile.common, options.mk: set, append")
 	acl("PKG_SUPPORTED_OPTIONS", lkShell, BtOption, "Makefile: set, append; Makefile.common: set; options.mk: set, append, use")
 	pkg("PKG_SYSCONFDIR*", lkNone, BtPathname)
 	pkglist("PKG_SYSCONFDIR_PERMS", lkShell, BtPerms)
 	sys("PKG_SYSCONFBASEDIR", lkNone, BtPathname)
 	pkg("PKG_SYSCONFSUBDIR", lkNone, BtPathname)

 @@ -1,16 +1,16 @@
-# $NetBSD: Makefile,v 1.522 2018/01/07 01:13:21 rillig Exp $
+# $NetBSD: Makefile,v 1.523 2018/01/07 17:08:15 rillig Exp $
-PKGNAME=	pkglint-5.4.25
+PKGNAME=	pkglint-5.4.26
 DISTFILES=	# none
 CATEGORIES=	pkgtools
 MAINTAINER=	rillig@NetBSD.org
 HOMEPAGE=	http://www.NetBSD.org/docs/pkgsrc/
 COMMENT=	Verifier for NetBSD packages
 LICENSE=	2-clause-bsd
 CONFLICTS+=	pkglint4-[0-9]*
 NO_CHECKSUM=	yes
 USE_LANGUAGES=	c
 USE_TOOLS+=	pax
 AUTO_MKDIRS=	yes

 @@ -120,27 +120,27 @@ func (mklines *MkLines) Check() {
 			substcontext.Varassign(mkline)
 		case mkline.IsInclude():
 			mklines.target = ""
 			switch path.Base(mkline.Includefile()) {
 			case "bsd.prefs.mk", "bsd.fast.prefs.mk", "bsd.builtin.mk":
 				mklines.setSeenBsdPrefsMk()
+			}
 			if G.Pkg != nil {
 				G.Pkg.CheckInclude(mkline, indentation)
+			}
 		case mkline.IsCond():
-			ck.checkCond(mklines.forVars)
+			ck.checkCond(mklines.forVars, indentation)
 		case mkline.IsDependency():
 			ck.checkDependencyRule(allowedTargets)
 			mklines.target = mkline.Targets()
+		}
+	}
 	lastMkline := mklines.mklines[len(mklines.mklines)-1]
 	substcontext.Finish(lastMkline)
 	varalign.Finish()
 	ChecklinesTrailingEmptyLines(mklines.lines)
 	if indentation.Len() != 1 && indentation.Depth() != 0 {