 @@ -249,26 +249,65 @@ func (s *Suite) Test_Pkgsrc_loadDocChang
 	t.SetUpPkgsrc()
 	t.CreateFileLines("doc/CHANGES-2018",
 		CvsID,
 		"",
 		"\tUpdated pkgpath to 1.0 [author 2018-01-01]",
 		"\tRenamed pkgpath to new-pkg [author 2018-02-01]",
 		"\tMoved pkgpath to category/new-pkg [author 2018-03-01]")
 	t.FinishSetUp()
 	t.Check(G.Pkgsrc.LastChange["pkgpath"].Action, equals, Moved)
+}
 func (s *Suite) Test_Pkgsrc_checkRemovedAfterLastFreeze(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wall", "--source")
 	t.SetUpPkgsrc()
 	t.CreateFileLines("doc/CHANGES-2019",
 		CvsID,
 		"",
 		"\tUpdated category/updated-before to 1.0 [updater 2019-04-01]",
 		"\tmk/bsd.pkg.mk: started freeze for pkgsrc-2019Q1 branch [freezer 2019-06-21]",
 		"\tmk/bsd.pkg.mk: freeze ended for pkgsrc-2019Q1 branch [freezer 2019-06-25]",
 		"\tUpdated category/updated-after to 1.0 [updater 2019-07-01]",
 		"\tAdded category/added-after version 1.0 [updater 2019-07-01]",
 		"\tMoved category/moved-from to category/moved-to [author 2019-07-02]",
 		"\tDowngraded category/downgraded to 1.0 [author 2019-07-03]")
 	t.FinishSetUp()
 	// It doesn't matter whether the last visible package change was before
 	// or after the latest freeze. The crucial point is that the most
 	// interesting change is the invisible one, which is the removal.
 	// And for finding the removal reliably, it doesn't matter how long ago
 	// the last package change was.
 	// The empty lines in the following output demonstrate the cheating
 	// by creating fake lines from Change.Location.
 	t.CheckOutputLines(
 		"ERROR: ~/doc/CHANGES-2019:3: Package category/updated-before "+
 			"must either exist or be marked as removed.",
 		"",
 		"ERROR: ~/doc/CHANGES-2019:6: Package category/updated-after "+
 			"must either exist or be marked as removed.",
 		"",
 		"ERROR: ~/doc/CHANGES-2019:7: Package category/added-after "+
 			"must either exist or be marked as removed.",
 		"",
 		"ERROR: ~/doc/CHANGES-2019:9: Package category/downgraded "+
 			"must either exist or be marked as removed.")
+}
 func (s *Suite) Test_Pkgsrc_loadDocChanges__not_found(c *check.C) {
 	t := s.Init(c)
 	t.SetUpPkgsrc()
 	t.Remove("doc/CHANGES-2018")
 	t.Remove("doc/TODO")
 	t.Remove("doc")
 	t.ExpectFatal(
 		t.FinishSetUp,
 		"FATAL: ~/doc: Cannot be read for loading the package changes.")
+}
 @@ -915,51 +954,52 @@ func (s *Suite) Test_Pkgsrc_guessVariabl
 	t.CheckOutputLines(
 		"WARN: filename.mk:2: The pathname pattern \"\\\"bad*pathname\\\"\" " +
 			"contains the invalid characters \"\\\"\\\"\".")
+}
 func (s *Suite) Test_Pkgsrc__frozen(c *check.C) {
 	t := s.Init(c)
 	t.SetUpPackage("category/package")
 	t.CreateFileLines("doc/CHANGES-2018",
 		"\tmk/bsd.pkg.mk: started freeze for pkgsrc-2018Q2 branch [freezer 2018-03-25]")
 	t.FinishSetUp()
-	t.Check(G.Pkgsrc.FreezeStart, equals, "2018-03-25")
+	t.Check(G.Pkgsrc.LastFreezeStart, equals, "2018-03-25")
+}
 func (s *Suite) Test_Pkgsrc__not_frozen(c *check.C) {
 	t := s.Init(c)
 	t.SetUpPackage("category/package")
 	t.CreateFileLines("doc/CHANGES-2018",
 		"\tmk/bsd.pkg.mk: started freeze for pkgsrc-2018Q2 branch [freezer 2018-03-25]",
 		"\tmk/bsd.pkg.mk: freeze ended for pkgsrc-2018Q2 branch [freezer 2018-03-27]")
 	t.FinishSetUp()
-	t.Check(G.Pkgsrc.FreezeStart, equals, "")
+	t.Check(G.Pkgsrc.LastFreezeStart, equals, "2018-03-25")
 	t.Check(G.Pkgsrc.LastFreezeEnd, equals, "2018-03-27")
+}
 func (s *Suite) Test_Pkgsrc__frozen_with_typo(c *check.C) {
 	t := s.Init(c)
 	t.SetUpPackage("category/package")
 	t.CreateFileLines("doc/CHANGES-2018",
 		// The closing bracket is missing.
 		"\tmk/bsd.pkg.mk: started freeze for pkgsrc-2018Q2 branch [freezer 2018-03-25")
 	t.FinishSetUp()
-	t.Check(G.Pkgsrc.FreezeStart, equals, "")
+	t.Check(G.Pkgsrc.LastFreezeStart, equals, "")
+}
 func (s *Suite) Test_Change_Version(c *check.C) {
 	t := s.Init(c)
 	loc := Location{"doc/CHANGES-2019", 5, 5}
 	added := Change{loc, Added, "category/path", "1.0", "author", "2019-01-01"}
 	updated := Change{loc, Updated, "category/path", "1.0", "author", "2019-01-01"}
 	downgraded := Change{loc, Downgraded, "category/path", "1.0", "author", "2019-01-01"}
 	removed := Change{loc, Removed, "category/path", "1.0", "author", "2019-01-01"}
 	t.Check(added.Version(), equals, "1.0")
 	t.Check(updated.Version(), equals, "1.0")

	@@ -241,85 +241,85 @@ func (p *MkParser) varUseModifier(varnam		@@ -241,85 +241,85 @@ func (p *MkParser) varUseModifier(varnam
241	if p.EmitWarnings {	241	if p.EmitWarnings {
242	p.Line.Warnf("Invalid separator %q for :ts modifier of %q.", sep, varname)	242	p.Line.Warnf("Invalid separator %q for :ts modifier of %q.", sep, varname)
243	p.Line.Explain(	243	p.Line.Explain(
244	"The separator for the :ts modifier must be either a single character",	244	"The separator for the :ts modifier must be either a single character",
245	"or an escape sequence like \\t or \\n or an octal or decimal escape",	245	"or an escape sequence like \\t or \\n or an octal or decimal escape",
246	"sequence; see the bmake man page for further details.")	246	"sequence; see the bmake man page for further details.")
247	}	247	}
248	}	248	}
249	return lexer.Since(mark)	249	return lexer.Since(mark)
250	}	250	}
251		251
252	case '=', 'D', 'M', 'N', 'U':	252	case '=', 'D', 'M', 'N', 'U':
253	lexer.Skip(1)	253	lexer.Skip(1)
254	re := G.res.Compile(regex.Pattern(ifelseStr(closing == '}', `^([^$:\\}]\|\$\$\|\\.)+`, `^([^$:\\)]\|\$\$\|\\.)+`)))	254	re := regcomp(regex.Pattern(ifelseStr(closing == '}', `^([^$:\\}]\|\$\$\|\\.)+`, `^([^$:\\)]\|\$\$\|\\.)+`)))
255	for p.VarUse() != nil \|\| lexer.SkipRegexp(re) {	255	for p.VarUse() != nil \|\| lexer.SkipRegexp(re) {
256	}	256	}
257	arg := lexer.Since(mark)	257	arg := lexer.Since(mark)
258	return strings.Replace(arg, "\\:", ":", -1)	258	return strings.Replace(arg, "\\:", ":", -1)
259		259
260	case 'C', 'S':	260	case 'C', 'S':
261	if ok, _, _, _, _ := p.varUseModifierSubst(closing); ok {	261	if ok, _, _, _, _ := p.varUseModifierSubst(closing); ok {
262	return lexer.Since(mark)	262	return lexer.Since(mark)
263	}	263	}
264		264
265	case '@':	265	case '@':
266	if p.varUseModifierAt(lexer, varname) {	266	if p.varUseModifierAt(lexer, varname) {
267	return lexer.Since(mark)	267	return lexer.Since(mark)
268	}	268	}
269		269
270	case '[':	270	case '[':
271	if lexer.SkipRegexp(G.res.Compile(`^\[(?:[-.\d]+\|#)\]`)) {	271	if lexer.SkipRegexp(regcomp(`^\[(?:[-.\d]+\|#)\]`)) {
272	return lexer.Since(mark)	272	return lexer.Since(mark)
273	}	273	}
274		274
275	case '?':	275	case '?':
276	lexer.Skip(1)	276	lexer.Skip(1)
277	p.varUseText(closing)	277	p.varUseText(closing)
278	if lexer.SkipByte(':') {	278	if lexer.SkipByte(':') {
279	p.varUseText(closing)	279	p.varUseText(closing)
280	return lexer.Since(mark)	280	return lexer.Since(mark)
281	}	281	}
282	}	282	}
283		283
284	lexer.Reset(mark)	284	lexer.Reset(mark)
285		285
286	re := G.res.Compile(regex.Pattern(ifelseStr(closing == '}', `^([^:$}]\|\$\$)+`, `^([^:$)]\|\$\$)+`)))	286	re := regcomp(regex.Pattern(ifelseStr(closing == '}', `^([^:$}]\|\$\$)+`, `^([^:$)]\|\$\$)+`)))
287	for p.VarUse() != nil \|\| lexer.SkipRegexp(re) {	287	for p.VarUse() != nil \|\| lexer.SkipRegexp(re) {
288	}	288	}
289	modifier := lexer.Since(mark)	289	modifier := lexer.Since(mark)
290		290
291	// ${SOURCES:%.c=%.o} or ${:!uname -a:[2]}	291	// ${SOURCES:%.c=%.o} or ${:!uname -a:[2]}
292	if contains(modifier, "=") \|\| (hasPrefix(modifier, "!") && hasSuffix(modifier, "!")) {	292	if contains(modifier, "=") \|\| (hasPrefix(modifier, "!") && hasSuffix(modifier, "!")) {
293	return modifier	293	return modifier
294	}	294	}
295		295
296	if p.EmitWarnings && modifier != "" {	296	if p.EmitWarnings && modifier != "" {
297	p.Line.Warnf("Invalid variable modifier %q for %q.", modifier, varname)	297	p.Line.Warnf("Invalid variable modifier %q for %q.", modifier, varname)
298	}	298	}
299		299
300	return ""	300	return ""
301	}	301	}
302		302
303	// varUseText parses any text up to the next colon or closing mark.	303	// varUseText parses any text up to the next colon or closing mark.
304	// Nested variable uses are parsed as well.	304	// Nested variable uses are parsed as well.
305	//	305	//
306	// This is used for the :L and :? modifiers since they accept arbitrary	306	// This is used for the :L and :? modifiers since they accept arbitrary
307	// text as the "variable name" and effectively interpret it as the variable	307	// text as the "variable name" and effectively interpret it as the variable
308	// value instead.	308	// value instead.
309	func (p *MkParser) varUseText(closing byte) string {	309	func (p *MkParser) varUseText(closing byte) string {
310	lexer := p.lexer	310	lexer := p.lexer
311	start := lexer.Mark()	311	start := lexer.Mark()
312	re := G.res.Compile(regex.Pattern(ifelseStr(closing == '}', `^([^$:}]\|\$\$)+`, `^([^$:)]\|\$\$)+`)))	312	re := regcomp(regex.Pattern(ifelseStr(closing == '}', `^([^$:}]\|\$\$)+`, `^([^$:)]\|\$\$)+`)))
313	for p.VarUse() != nil \|\| lexer.SkipRegexp(re) {	313	for p.VarUse() != nil \|\| lexer.SkipRegexp(re) {
314	}	314	}
315	return lexer.Since(start)	315	return lexer.Since(start)
316	}	316	}
317		317
318	// varUseModifierSubst parses a :S,from,to, or a :C,from,to, modifier.	318	// varUseModifierSubst parses a :S,from,to, or a :C,from,to, modifier.
319	func (p *MkParser) varUseModifierSubst(closing byte) (ok bool, regex bool, from string, to string, options string) {	319	func (p *MkParser) varUseModifierSubst(closing byte) (ok bool, regex bool, from string, to string, options string) {
320	lexer := p.lexer	320	lexer := p.lexer
321	regex = lexer.PeekByte() == 'C'	321	regex = lexer.PeekByte() == 'C'
322	lexer.Skip(1 /* the initial S or C */)	322	lexer.Skip(1 /* the initial S or C */)
323		323
324	sep := lexer.PeekByte() // bmake allows _any_ separator, even letters.	324	sep := lexer.PeekByte() // bmake allows _any_ separator, even letters.
325	if sep == -1 \|\| byte(sep) == closing {	325	if sep == -1 \|\| byte(sep) == closing {
	@@ -381,27 +381,27 @@ func (p *MkParser) varUseModifierSubst(c		@@ -381,27 +381,27 @@ func (p *MkParser) varUseModifierSubst(c
381	return	381	return
382	}	382	}
383		383
384	// varUseModifierAt parses a variable modifier like ":@v@echo ${v};@",	384	// varUseModifierAt parses a variable modifier like ":@v@echo ${v};@",
385	// which expands the variable value in a loop.	385	// which expands the variable value in a loop.
386	func (p MkParser) varUseModifierAt(lexer textproc.Lexer, varname string) bool {	386	func (p MkParser) varUseModifierAt(lexer textproc.Lexer, varname string) bool {
387	lexer.Skip(1 /* the initial @ */)	387	lexer.Skip(1 /* the initial @ */)
388		388
389	loopVar := lexer.NextBytesSet(AlnumDot)	389	loopVar := lexer.NextBytesSet(AlnumDot)
390	if loopVar == "" \|\| !lexer.SkipByte('@') {	390	if loopVar == "" \|\| !lexer.SkipByte('@') {
391	return false	391	return false
392	}	392	}
393		393
394	re := G.res.Compile(`^([^$@\\]\|\\.)+`)	394	re := regcomp(`^([^$@\\]\|\\.)+`)
395	for p.VarUse() != nil \|\| lexer.SkipString("$$") \|\| lexer.SkipRegexp(re) {	395	for p.VarUse() != nil \|\| lexer.SkipString("$$") \|\| lexer.SkipRegexp(re) {
396	}	396	}
397		397
398	if !lexer.SkipByte('@') && p.EmitWarnings {	398	if !lexer.SkipByte('@') && p.EmitWarnings {
399	p.Line.Warnf("Modifier ${%s:@%s@...@} is missing the final \"@\".", varname, loopVar)	399	p.Line.Warnf("Modifier ${%s:@%s@...@} is missing the final \"@\".", varname, loopVar)
400	}	400	}
401		401
402	return true	402	return true
403	}	403	}
404		404
405	// MkCond parses a condition like ${OPSYS} == "NetBSD".	405	// MkCond parses a condition like ${OPSYS} == "NetBSD".
406	//	406	//
407	// See devel/bmake/files/cond.c.	407	// See devel/bmake/files/cond.c.
	@@ -488,39 +488,39 @@ func (p MkParser) mkCondAtom() MkCond		@@ -488,39 +488,39 @@ func (p MkParser) mkCondAtom() MkCond
488	lhs := p.VarUse()	488	lhs := p.VarUse()
489	mark := lexer.Mark()	489	mark := lexer.Mark()
490	if lhs == nil && lexer.SkipByte('"') {	490	if lhs == nil && lexer.SkipByte('"') {
491	if quotedLHS := p.VarUse(); quotedLHS != nil && lexer.SkipByte('"') {	491	if quotedLHS := p.VarUse(); quotedLHS != nil && lexer.SkipByte('"') {
492	lhs = quotedLHS	492	lhs = quotedLHS
493	} else {	493	} else {
494	lexer.Reset(mark)	494	lexer.Reset(mark)
495	}	495	}
496	}	496	}
497		497
498	if lhs != nil {	498	if lhs != nil {
499	lexer.SkipHspace()	499	lexer.SkipHspace()
500		500
501	if m := lexer.NextRegexp(G.res.Compile(`^(<\|<=\|==\|!=\|>=\|>)[\t ]*(0x[0-9A-Fa-f]+\|\d+(?:\.\d+)?)`)); m != nil {	501	if m := lexer.NextRegexp(regcomp(`^(<\|<=\|==\|!=\|>=\|>)[\t ]*(0x[0-9A-Fa-f]+\|\d+(?:\.\d+)?)`)); m != nil {
502	return &MkCond{CompareVarNum: &MkCondCompareVarNum{lhs, m[1], m[2]}}	502	return &MkCond{CompareVarNum: &MkCondCompareVarNum{lhs, m[1], m[2]}}
503	}	503	}
504		504
505	m := lexer.NextRegexp(G.res.Compile(`^(?:<\|<=\|==\|!=\|>=\|>)`))	505	m := lexer.NextRegexp(regcomp(`^(?:<\|<=\|==\|!=\|>=\|>)`))
506	if m == nil {	506	if m == nil {
507	return &MkCond{Var: lhs} // See devel/bmake/files/cond.c:/\* For \.if \$/	507	return &MkCond{Var: lhs} // See devel/bmake/files/cond.c:/\* For \.if \$/
508	}	508	}
509	lexer.SkipHspace()	509	lexer.SkipHspace()
510		510
511	op := m[0]	511	op := m[0]
512	if op == "==" \|\| op == "!=" {	512	if op == "==" \|\| op == "!=" {
513	if mrhs := lexer.NextRegexp(G.res.Compile(`^"([^"\$\\]*)"`)); mrhs != nil {	513	if mrhs := lexer.NextRegexp(regcomp(`^"([^"\$\\]*)"`)); mrhs != nil {
514	return &MkCond{CompareVarStr: &MkCondCompareVarStr{lhs, op, mrhs[1]}}	514	return &MkCond{CompareVarStr: &MkCondCompareVarStr{lhs, op, mrhs[1]}}
515	}	515	}
516	}	516	}
517		517
518	if str := lexer.NextBytesSet(textproc.AlnumU); str != "" {	518	if str := lexer.NextBytesSet(textproc.AlnumU); str != "" {
519	return &MkCond{CompareVarStr: &MkCondCompareVarStr{lhs, op, str}}	519	return &MkCond{CompareVarStr: &MkCondCompareVarStr{lhs, op, str}}
520	}	520	}
521		521
522	if rhs := p.VarUse(); rhs != nil {	522	if rhs := p.VarUse(); rhs != nil {
523	return &MkCond{CompareVarVar: &MkCondCompareVarVar{lhs, op, rhs}}	523	return &MkCond{CompareVarVar: &MkCondCompareVarVar{lhs, op, rhs}}
524	}	524	}
525		525
526	if lexer.PeekByte() == '"' {	526	if lexer.PeekByte() == '"' {
	@@ -549,27 +549,27 @@ func (p MkParser) mkCondAtom() MkCond		@@ -549,27 +549,27 @@ func (p MkParser) mkCondAtom() MkCond
549	rhsText.WriteByte(lexer.Since(m)[1])	549	rhsText.WriteByte(lexer.Since(m)[1])
550		550
551	case lexer.SkipByte('"'):	551	case lexer.SkipByte('"'):
552	return &MkCond{CompareVarStr: &MkCondCompareVarStr{lhs, op, rhsText.String()}}	552	return &MkCond{CompareVarStr: &MkCondCompareVarStr{lhs, op, rhsText.String()}}
553	default:	553	default:
554	break loop	554	break loop
555	}	555	}
556	}	556	}
557	lexer.Reset(mark)	557	lexer.Reset(mark)
558	}	558	}
559	}	559	}
560		560
561	// See devel/bmake/files/cond.c:/^CondCvtArg	561	// See devel/bmake/files/cond.c:/^CondCvtArg
562	if m := lexer.NextRegexp(G.res.Compile(`^(?:0x[0-9A-Fa-f]+\|\d+(?:\.\d+)?)`)); m != nil {	562	if m := lexer.NextRegexp(regcomp(`^(?:0x[0-9A-Fa-f]+\|\d+(?:\.\d+)?)`)); m != nil {
563	return &MkCond{Num: m[0]}	563	return &MkCond{Num: m[0]}
564	}	564	}
565	}	565	}
566	lexer.Reset(mark)	566	lexer.Reset(mark)
567	return nil	567	return nil
568	}	568	}
569		569
570	func (p MkParser) mkCondFunc() MkCond {	570	func (p MkParser) mkCondFunc() MkCond {
571	lexer := p.lexer	571	lexer := p.lexer
572	mark := lexer.Mark()	572	mark := lexer.Mark()
573		573
574	funcName := lexer.NextBytesSet(textproc.Lower)	574	funcName := lexer.NextBytesSet(textproc.Lower)
575	lexer.SkipHspace()	575	lexer.SkipHspace()
	@@ -642,28 +642,28 @@ func (*MkParser) isPkgbasePart(str strin		@@ -642,28 +642,28 @@ func (*MkParser) isPkgbasePart(str strin
642	return !contains(varUse.varname, "VER") && len(varUse.modifiers) == 0	642	return !contains(varUse.varname, "VER") && len(varUse.modifiers) == 0
643	}	643	}
644		644
645	return false	645	return false
646	}	646	}
647		647
648	func (p *MkParser) PkgbasePattern() string {	648	func (p *MkParser) PkgbasePattern() string {
649		649
650	lexer := p.lexer	650	lexer := p.lexer
651	start := lexer.Mark()	651	start := lexer.Mark()
652		652
653	for {	653	for {
654	if p.VarUse() != nil \|\|	654	if p.VarUse() != nil \|\|
655	lexer.SkipRegexp(G.res.Compile(`^[\w.*+,{}]+`)) \|\|	655	lexer.SkipRegexp(regcomp(`^[\w.*+,{}]+`)) \|\|
656	lexer.SkipRegexp(G.res.Compile(`^\[[\w-]+\]`)) {	656	lexer.SkipRegexp(regcomp(`^\[[\w-]+\]`)) {
657	continue	657	continue
658	}	658	}
659		659
660	if lexer.PeekByte() == '-' && p.isPkgbasePart(lexer.Rest()[1:]) {	660	if lexer.PeekByte() == '-' && p.isPkgbasePart(lexer.Rest()[1:]) {
661	lexer.Skip(1)	661	lexer.Skip(1)
662	} else {	662	} else {
663	break	663	break
664	}	664	}
665	}	665	}
666		666
667	pkgbase := lexer.Since(start)	667	pkgbase := lexer.Since(start)
668	if strings.Count(pkgbase, "{") == strings.Count(pkgbase, "}") {	668	if strings.Count(pkgbase, "{") == strings.Count(pkgbase, "}") {
669	return pkgbase	669	return pkgbase
	@@ -686,27 +686,27 @@ type DependencyPattern struct {		@@ -686,27 +686,27 @@ type DependencyPattern struct {
686	// Dependency parses a dependency pattern like "pkg>=1<2" or "pkg-[0-9]*".	686	// Dependency parses a dependency pattern like "pkg>=1<2" or "pkg-[0-9]*".
687	func (p MkParser) Dependency() DependencyPattern {	687	func (p MkParser) Dependency() DependencyPattern {
688	lexer := p.lexer	688	lexer := p.lexer
689		689
690	parseVersion := func() string {	690	parseVersion := func() string {
691	mark := lexer.Mark()	691	mark := lexer.Mark()
692		692
693	for p.VarUse() != nil {	693	for p.VarUse() != nil {
694	}	694	}
695	if lexer.Since(mark) != "" {	695	if lexer.Since(mark) != "" {
696	return lexer.Since(mark)	696	return lexer.Since(mark)
697	}	697	}
698		698
699	m := lexer.NextRegexp(G.res.Compile(`^\d[\w.]*`))	699	m := lexer.NextRegexp(regcomp(`^\d[\w.]*`))
700	if m != nil {	700	if m != nil {
701	return m[0]	701	return m[0]
702	}	702	}
703		703
704	return ""	704	return ""
705	}	705	}
706		706
707	var dp DependencyPattern	707	var dp DependencyPattern
708	mark := lexer.Mark()	708	mark := lexer.Mark()
709	dp.Pkgbase = p.PkgbasePattern()	709	dp.Pkgbase = p.PkgbasePattern()
710	if dp.Pkgbase == "" {	710	if dp.Pkgbase == "" {
711	return nil	711	return nil
712	}	712	}
	@@ -739,27 +739,27 @@ func (p MkParser) Dependency() Depende		@@ -739,27 +739,27 @@ func (p MkParser) Dependency() Depende
739	dp.Upper = version	739	dp.Upper = version
740	} else {	740	} else {
741	lexer.Reset(mark2)	741	lexer.Reset(mark2)
742	}	742	}
743	}	743	}
744		744
745	if dp.LowerOp != "" \|\| dp.UpperOp != "" {	745	if dp.LowerOp != "" \|\| dp.UpperOp != "" {
746	return &dp	746	return &dp
747	}	747	}
748		748
749	if lexer.SkipByte('-') && lexer.Rest() != "" {	749	if lexer.SkipByte('-') && lexer.Rest() != "" {
750	versionMark := lexer.Mark()	750	versionMark := lexer.Mark()
751		751
752	for p.VarUse() != nil \|\| lexer.SkipRegexp(G.res.Compile(`^[\w\[\]*_.\-]+`)) {	752	for p.VarUse() != nil \|\| lexer.SkipRegexp(regcomp(`^[\w\[\]*_.\-]+`)) {
753	}	753	}
754		754
755	if !lexer.SkipString("{,nb*}") {	755	if !lexer.SkipString("{,nb*}") {
756	lexer.SkipString("{,nb[0-9]*}")	756	lexer.SkipString("{,nb[0-9]*}")
757	}	757	}
758		758
759	dp.Wildcard = lexer.Since(versionMark)	759	dp.Wildcard = lexer.Since(versionMark)
760	return &dp	760	return &dp
761	}	761	}
762		762
763	if ToVarUse(dp.Pkgbase) != nil {	763	if ToVarUse(dp.Pkgbase) != nil {
764	return &dp	764	return &dp
765	}	765	}

 @@ -952,48 +952,48 @@ func (s *Suite) Test_Package_load__extra
 		// for collecting the used variables. And then a second time in
 		// Package.check to perform the actual checks.
 		//
 		// The above diagnostics are only those from parsing the file, to
 		// correctly classify the lines. This is because the main purpose
 		// of Package.load above is to load the files and collect some
 		// data, not to perform the actual checks.
 		//
 		// Therefore, the below lines contain two more diagnostics.
 		"WARN: gnu-style.mk:1: Please use curly braces {} instead of round parentheses () for CC.",
 		"ERROR: gnu-style.mk:1: Unknown Makefile line format: \"ifeq ($(CC),gcc)\".",
 		"ERROR: gnu-style.mk:3: Unknown Makefile line format: \"else\".",
 		"ERROR: gnu-style.mk:5: Unknown Makefile line format: \"endif\".",
-		"ERROR: gnu-style.mk:1: Expected \"# $NetBSD: package_test.go,v 1.48 2019/06/30 20:56:19 rillig Exp $\".",
+		"ERROR: gnu-style.mk:1: Expected \""+MkCvsID+"\".",
 		"WARN: gnu-style.mk:2: IS_GCC is defined but not used.",
 		// There is no warning about files/gnu-style.mk since pkglint
 		// doesn't even attempt at guessing the file type. Files placed
 		// in this directory can have an arbitrary format.
 		"ERROR: ../../category/other/distinfo: Patch \"../../category/package/patches/"+
 			"patch-Makefile.mk\" is not recorded. Run \""+confMake+" makepatchsum\".",
 		// All *.mk files from PKGDIR are loaded to see which variables
 		// they define, in order to make the check for unused variables
 		// more reliable.
 		//
 		// All files that belong to the package itself, and not to pkgsrc
 		// should therefore be placed in the files/ directory.
 		"WARN: ../../category/other/gnu-style.mk:1: "+
 			"Please use curly braces {} instead of round parentheses () for CC.",
 		"ERROR: ../../category/other/gnu-style.mk:1: Unknown Makefile line format: \"ifeq ($(CC),gcc)\".",
 		"ERROR: ../../category/other/gnu-style.mk:3: Unknown Makefile line format: \"else\".",
 		"ERROR: ../../category/other/gnu-style.mk:5: Unknown Makefile line format: \"endif\".",
-		"ERROR: ../../category/other/gnu-style.mk:1: Expected \"# $NetBSD: package_test.go,v 1.48 2019/06/30 20:56:19 rillig Exp $\".",
+		"ERROR: ../../category/other/gnu-style.mk:1: Expected \""+MkCvsID+"\".",
 		"WARN: ../../category/other/gnu-style.mk:2: IS_GCC is defined but not used.",
 		"ERROR: patches/patch-Makefile.mk: Contains no patch.",
 		"WARN: patches/readme.mk: Patch files should be named \"patch-\", followed by letters, '-', '_', '.', and digits only.")
+}
 func (s *Suite) Test_Package_loadPackageMakefile(c *check.C) {
 	t := s.Init(c)
 	t.CreateFileLines("category/package/Makefile",
 		MkCvsID,
 		"",
 		"PKGNAME=pkgname-1.67",

 @@ -26,54 +26,56 @@ type Pkgsrc struct {
 	// within the bsd.pkg.mk file.
 	buildDefs map[string]bool
 	Tools *Tools
 	MasterSiteURLToVar map[string]string // "https://github.com/" => "MASTER_SITE_GITHUB"
 	MasterSiteVarToURL map[string]string // "MASTER_SITE_GITHUB" => "https://github.com/"
 	PkgOptions map[string]string // "x11" => "Provides X11 support"
 	suggestedUpdates    []SuggestedUpdate
 	suggestedWipUpdates []SuggestedUpdate
-	LastChange  map[string]*Change
+	LastChange      map[string]*Change
-	FreezeStart string // e.g. "2018-01-01", or ""
+	LastFreezeStart string // e.g. "2018-01-01", or ""
 	LastFreezeEnd   string // e.g. "2018-01-01", or ""
 	listVersions map[string][]string // See Pkgsrc.ListVersions
 	// Variables that may be overridden by the pkgsrc user.
 	// They are typically defined in mk/defaults/mk.conf.
 	//
 	// Whenever a package uses such a variable, it must add the variable name
 	// to BUILD_DEFS.
 	UserDefinedVars Scope
 	Deprecated map[string]string
 	vartypes   VarTypeRegistry
+}
 func NewPkgsrc(dir string) Pkgsrc {
 	return Pkgsrc{
 		dir,
 		make(map[string]bool),
 		NewTools(),
 		make(map[string]string),
 		make(map[string]string),
 		make(map[string]string),
 		nil,
 		nil,
 		make(map[string]*Change),
 		"",
 		"",
 		make(map[string][]string),
 		NewScope(),
 		make(map[string]string),
 		NewVarTypeRegistry()}
+}
 func (src *Pkgsrc) loadDefaultBuildDefs() {
 	// Some user-defined variables do not influence the binary
 	// package at all and therefore do not have to be added to
 	// BUILD_DEFS; therefore they are marked as "already added".
 	src.addBuildDefs(
 		"DISTDIR",
 @@ -507,31 +509,34 @@ func (src *Pkgsrc) loadDocChangesFromFil
 	year := ""
 	if _, yyyy := match1(filename, `-(\d\d\d\d)$`); yyyy >= "2018" {
 		year = yyyy
+	}
 	infra := false
 	lines := Load(filename, MustSucceed|NotEmpty)
 	var changes []*Change
 	for _, line := range lines.Lines {
 		if hasPrefix(line.Text, "\tmk/") {
 			infra = true
 			if hasPrefix(line.Text, "\tmk/bsd.pkg.mk: started freeze for") {
-				if m, freezeDate := match1(line.Text, `(\d\d\d\d-\d\d-\d\d)\]$`); m {
+				if m, date := match1(line.Text, `(\d\d\d\d-\d\d-\d\d)\]$`); m {
-					src.FreezeStart = freezeDate
+					src.LastFreezeStart = date
 					src.LastFreezeEnd = ""
+				}
 			} else if hasPrefix(line.Text, "\tmk/bsd.pkg.mk: freeze ended for") {
-				src.FreezeStart = ""
+				if m, date := match1(line.Text, `(\d\d\d\d-\d\d-\d\d)\]$`); m {
 					src.LastFreezeEnd = date
+				}
+			}
+		}
 		if infra {
 			if hasSuffix(line.Text, "]") {
 				infra = false
+			}
 			continue
+		}
 		change := src.parseDocChange(line, warn)
 		if change == nil {
 			continue
+		}
 @@ -593,26 +598,60 @@ func (src *Pkgsrc) loadDocChanges() {
+		}
+	}
 	src.LastChange = make(map[string]*Change)
 	for _, filename := range filenames {
 		changes := src.loadDocChangesFromFile(docDir + "/" + filename)
 		for _, change := range changes {
 			src.LastChange[change.Pkgpath] = change
 			if change.Action == Renamed || change.Action == Moved {
 				src.LastChange[change.Target()] = change
+			}
+		}
+	}
 	src.checkRemovedAfterLastFreeze()
+}
 func (src *Pkgsrc) checkRemovedAfterLastFreeze() {
 	if src.LastFreezeStart == "" || G.Wip {
 		return
+	}
 	var wrong []*Change
 	for pkgpath, change := range src.LastChange {
 		switch change.Action {
 		case Added, Updated, Downgraded:
 			if !dirExists(src.File(pkgpath)) {
 				wrong = append(wrong, change)
+			}
+		}
+	}
 	sort.Slice(wrong, func(i, j int) bool {
 		ei, ej := wrong[i], wrong[j]
 		if ei.Date != ej.Date {
 			return ei.Date < ej.Date
+		}
 		return ei.Location.firstLine < ej.Location.firstLine
 	})
 	for _, change := range wrong {
 		// It's a bit cheated to construct a Line from only a Location,
 		// without the wrong text. That's only because I'm too lazy loading
 		// the file again, and the original text is not lying around anywhere.
 		line := NewLineMulti(change.Location.Filename, int(change.Location.firstLine), int(change.Location.lastLine), "", nil)
 		line.Errorf("Package %s must either exist or be marked as removed.", change.Pkgpath)
+	}
+}
 func (src *Pkgsrc) loadUserDefinedVars() {
 	mklines := src.LoadMk("mk/defaults/mk.conf", MustSucceed|NotEmpty)
 	for _, mkline := range mklines.mklines {
 		if mkline.IsVarassign() || mkline.IsCommentedVarassign() {
 			src.UserDefinedVars.Define(mkline.Varname(), mkline)
+		}
+	}
+}
 func (src *Pkgsrc) initDeprecatedVars() {

 @@ -127,48 +127,48 @@ func (p *ShTokenizer) shAtomBackt() *ShA
 		return op
+	}
 	lexer := p.parser.lexer
 	mark := lexer.Mark()
 	switch {
 	case lexer.SkipByte('"'):
 		return &ShAtom{shtText, lexer.Since(mark), shqBacktDquot, nil}
 	case lexer.SkipByte('`'):
 		return &ShAtom{shtText, lexer.Since(mark), shqPlain, nil}
 	case lexer.SkipByte('\''):
 		return &ShAtom{shtText, lexer.Since(mark), shqBacktSquot, nil}
 	case lexer.NextHspace() != "":
 		return &ShAtom{shtSpace, lexer.Since(mark), q, nil}
-	case lexer.SkipRegexp(G.res.Compile("^#[^`]*")):
+	case lexer.SkipRegexp(regcomp("^#[^`]*")):
 		return &ShAtom{shtComment, lexer.Since(mark), q, nil}
+	}
 	return p.shAtomInternal(q, false, false)
+}
 // In pkgsrc, the $(...) subshell syntax is not used, in order to preserve
 // compatibility with /bin/sh from Solaris 7.
 func (p *ShTokenizer) shAtomSubsh() *ShAtom {
 	const q = shqSubsh
 	lexer := p.parser.lexer
 	mark := lexer.Mark()
 	switch {
 	case lexer.NextHspace() != "":
 		return &ShAtom{shtSpace, lexer.Since(mark), q, nil}
 	case lexer.SkipByte('"'):
 		return &ShAtom{shtText, lexer.Since(mark), shqSubshDquot, nil}
 	case lexer.SkipByte('\''):
 		return &ShAtom{shtText, lexer.Since(mark), shqSubshSquot, nil}
 	case lexer.SkipByte('`'):
 		return &ShAtom{shtText, lexer.Since(mark), shqSubshBackt, nil}
-	case lexer.SkipRegexp(G.res.Compile(`^#[^)]*`)):
+	case lexer.SkipRegexp(regcomp(`^#[^)]*`)):
 		return &ShAtom{shtComment, lexer.Since(mark), q, nil}
 	case lexer.SkipByte(')'):
 		// The closing parenthesis can have multiple meanings:
 		// - end of a subshell, such as (echo "in a subshell")
 		// - end of a subshell variable expression, such as var=$$(echo "from a subshell")
 		// - end of a case pattern
 		// In the "subshell variable expression" case, the atom type
 		// could be shtText since it is part of a text node. On the
 		// other hand, pkglint doesn't tokenize shell programs correctly
 		// anyway. This needs to be fixed someday.
 		return &ShAtom{shtOperator, lexer.Since(mark), shqPlain, nil}
+	}
 	if op := p.shOperator(q); op != nil {
 @@ -181,27 +181,27 @@ func (p *ShTokenizer) shAtomDquotBackt()
 	const q = shqDquotBackt
 	if op := p.shOperator(q); op != nil {
 		return op
+	}
 	lexer := p.parser.lexer
 	mark := lexer.Mark()
 	switch {
 	case lexer.SkipByte('`'):
 		return &ShAtom{shtText, lexer.Since(mark), shqDquot, nil}
 	case lexer.SkipByte('"'):
 		return &ShAtom{shtText, lexer.Since(mark), shqDquotBacktDquot, nil}
 	case lexer.SkipByte('\''):
 		return &ShAtom{shtText, lexer.Since(mark), shqDquotBacktSquot, nil}
-	case lexer.SkipRegexp(G.res.Compile("^#[^`]*")):
+	case lexer.SkipRegexp(regcomp("^#[^`]*")):
 		return &ShAtom{shtComment, lexer.Since(mark), q, nil}
 	case lexer.NextHspace() != "":
 		return &ShAtom{shtSpace, lexer.Since(mark), q, nil}
+	}
 	return p.shAtomInternal(q, false, false)
+}
 func (p *ShTokenizer) shAtomBacktDquot() *ShAtom {
 	const q = shqBacktDquot
 	lexer := p.parser.lexer
 	mark := lexer.Mark()
 	switch {
 	case lexer.SkipByte('"'):
 @@ -290,41 +290,41 @@ func (p *ShTokenizer) shAtomDquotBacktSq
 func (p *ShTokenizer) shAtomInternal(q ShQuoting, dquot, squot bool) *ShAtom {
 	if shVarUse := p.shVarUse(q); shVarUse != nil {
 		return shVarUse
+	}
 	lexer := p.parser.lexer
 	mark := lexer.Mark()
 loop:
 	for {
 		_ = `^[\t "$&'();<>\\|]+` // These are not allowed in shqPlain.
 		switch {
-		case lexer.SkipRegexp(G.res.Compile(`^[!#%*+,\-./0-9:=?@A-Z\[\]^_a-z{}~]+`)):
+		case lexer.SkipRegexp(regcomp(`^[!#%*+,\-./0-9:=?@A-Z\[\]^_a-z{}~]+`)):
 			break
-		case dquot && lexer.SkipRegexp(G.res.Compile(`^[\t &'();<>|]+`)):
+		case dquot && lexer.SkipRegexp(regcomp(`^[\t &'();<>|]+`)):
 			break
 		case squot && lexer.SkipByte('`'):
 			break
-		case squot && lexer.SkipRegexp(G.res.Compile(`^[\t "&();<>\\|]+`)):
+		case squot && lexer.SkipRegexp(regcomp(`^[\t "&();<>\\|]+`)):
 			break
 		case squot && lexer.SkipString("$$"):
 			break
 		case squot:
 			break loop
 		case lexer.SkipString("\\$$"):
 			break
-		case lexer.SkipRegexp(G.res.Compile(`^\\[^$]`)):
+		case lexer.SkipRegexp(regcomp(`^\\[^$]`)):
 			break
 		case matches(lexer.Rest(), `^\$\$[^!#(*\-0-9?@A-Z_a-z{]`):
 			lexer.NextString("$$")
 		case lexer.Rest() == "$$":
 			lexer.Skip(2)
 		case lexer.Rest() == "$":
 			lexer.Skip(1)
 		default:
 			break loop
+		}
+	}
 	if token := lexer.Since(mark); token != "" {
 @@ -343,62 +343,62 @@ func (p *ShTokenizer) shVarUse(q ShQuoti
 	if !lexer.SkipString("$$") {
 		return nil
+	}
 	if lexer.TestByteSet(textproc.Digit) {
 		lexer.Skip(1)
 		text := lexer.Since(beforeDollar)
 		return &ShAtom{shtShVarUse, text, q, text[2:]}
+	}
 	brace := lexer.SkipByte('{')
 	varnameStart := lexer.Mark()
-	if !lexer.SkipRegexp(G.res.Compile(`^(?:[!#*\-?@]|\$\$|[A-Za-z_]\w*|\d+)`)) {
+	if !lexer.SkipRegexp(regcomp(`^(?:[!#*\-?@]|\$\$|[A-Za-z_]\w*|\d+)`)) {
 		lexer.Reset(beforeDollar)
 		return nil
+	}
 	shVarname := lexer.Since(varnameStart)
 	if shVarname == "$$" {
 		shVarname = "$"
+	}
 	if brace {
-		lexer.SkipRegexp(G.res.Compile(`^(?:##?|%%?|:?[+\-=?])[^$\\{}]*`))
+		lexer.SkipRegexp(regcomp(`^(?:##?|%%?|:?[+\-=?])[^$\\{}]*`))
 		if !lexer.SkipByte('}') {
 			lexer.Reset(beforeDollar)
 			return nil
+		}
+	}
 	return &ShAtom{shtShVarUse, lexer.Since(beforeDollar), q, shVarname}
+}
 func (p *ShTokenizer) shOperator(q ShQuoting) *ShAtom {
 	lexer := p.parser.lexer
 	mark := lexer.Mark()
 	switch {
 	case lexer.SkipString("||"),
 		lexer.SkipString("&&"),
 		lexer.SkipString(";;"),
 		lexer.NextBytesFunc(func(b byte) bool { return b == '\n' }) != "",
 		lexer.SkipByte(';'),
 		lexer.SkipByte('('),
 		lexer.SkipByte(')'),
 		lexer.SkipByte('|'),
 		lexer.SkipByte('&'):
 		return &ShAtom{shtOperator, lexer.Since(mark), q, nil}
-	case lexer.SkipRegexp(G.res.Compile(`^\d*(?:<<-|<<|<&|<>|>>|>&|>\||<|>)`)):
+	case lexer.SkipRegexp(regcomp(`^\d*(?:<<-|<<|<&|<>|>>|>&|>\||<|>)`)):
 		return &ShAtom{shtOperator, lexer.Since(mark), q, nil}
+	}
 	return nil
+}
 func (p *ShTokenizer) ShAtoms() []*ShAtom {
 	var atoms []*ShAtom
 	q := shqPlain
 	for {
 		atom := p.ShAtom(q)
 		if atom == nil {
 			return atoms
+		}

 @@ -684,27 +684,27 @@ func (s *Suite) Test_SubstContext_sugges
 			"can be replaced with \"SUBST_VARS.pfx+= PREFIX\".")
 	t.SetUpCommandLine("--autofix")
 	mklines.Check()
 	t.CheckOutputLines(
 		"AUTOFIX: subst.mk:6: Replacing \"SUBST_SED.pfx=\\t\\t-e s,@PREFIX@,${PREFIX},g\" "+
 			"with \"SUBST_VARS.pfx=\\t\\tPREFIX\".",
 		"AUTOFIX: subst.mk:7: Replacing \"SUBST_SED.pfx+=\\t\\t-e s,@PREFIX@,${PREFIX},g\" "+
 			"with \"SUBST_VARS.pfx+=\\tPREFIX\".")
 	t.CheckFileLinesDetab("subst.mk",
-		"# $NetBSD: substcontext_test.go,v 1.27 2019/06/30 20:56:19 rillig Exp $",
+		MkCvsID,
 		"",
 		"SUBST_CLASSES+=         pfx",
 		"SUBST_STAGE.pfx=        pre-configure",
 		"SUBST_FILES.pfx=        filename",
 		"SUBST_VARS.pfx=         PREFIX",
 		"SUBST_VARS.pfx+=        PREFIX")
+}
 func (s *Suite) Test_SubstContext_suggestSubstVars__autofix_plus_sed(c *check.C) {
 	t := s.Init(c)
 	t.SetUpVartypes()
 	t.Chdir(".")
 @@ -723,27 +723,27 @@ func (s *Suite) Test_SubstContext_sugges
 	t.CheckOutputLines(
 		"NOTE: subst.mk:6: The substitution command \"s,@PREFIX@,${PREFIX},g\" " +
 			"can be replaced with \"SUBST_VARS.pfx= PREFIX\".")
 	t.SetUpCommandLine("-Wall", "--autofix")
 	mklines.Check()
 	t.CheckOutputLines(
 		"AUTOFIX: subst.mk:6: Replacing \"SUBST_SED.pfx=\\t\\t-e s,@PREFIX@,${PREFIX},g\" " +
 			"with \"SUBST_VARS.pfx=\\t\\tPREFIX\".")
 	t.CheckFileLinesDetab("subst.mk",
-		"# $NetBSD: substcontext_test.go,v 1.27 2019/06/30 20:56:19 rillig Exp $",
+		MkCvsID,
 		"",
 		"SUBST_CLASSES+=         pfx",
 		"SUBST_STAGE.pfx=        pre-configure",
 		"SUBST_FILES.pfx=        filename",
 		"SUBST_VARS.pfx=         PREFIX",
 		// TODO: If this subst class is used nowhere else, pkglint could
 		//  replace this += with a simple =.
 		"SUBST_SED.pfx+=         -e s,@PREFIX@,other,g")
+}
 func (s *Suite) Test_SubstContext_suggestSubstVars__autofix_plus_vars(c *check.C) {
 	t := s.Init(c)
 @@ -757,27 +757,27 @@ func (s *Suite) Test_SubstContext_sugges
 		"SUBST_CLASSES+=\tid",
 		"SUBST_STAGE.id=\tpre-configure",
 		"SUBST_FILES.id=\tfilename",
 		"SUBST_SED.id=\t-e s,@PREFIX@,${PREFIX},g",
 		"SUBST_VARS.id=\tPKGMANDIR")
 	mklines.Check()
 	t.CheckOutputLines(
 		"AUTOFIX: subst.mk:6: Replacing \"SUBST_SED.id=\\t-e s,@PREFIX@,${PREFIX},g\" " +
 			"with \"SUBST_VARS.id=\\tPREFIX\".")
 	t.CheckFileLinesDetab("subst.mk",
-		"# $NetBSD: substcontext_test.go,v 1.27 2019/06/30 20:56:19 rillig Exp $",
+		MkCvsID,
 		"",
 		"SUBST_CLASSES+= id",
 		"SUBST_STAGE.id= pre-configure",
 		"SUBST_FILES.id= filename",
 		"SUBST_VARS.id=  PREFIX",
 		// FIXME: This must be += instead of = since the previous line already uses =.
 		//  Luckily the check for redundant assignments catches this already.
 		"SUBST_VARS.id=  PKGMANDIR")
+}
 func (s *Suite) Test_SubstContext_suggestSubstVars__autofix_indentation(c *check.C) {
 	t := s.Init(c)
 @@ -791,27 +791,27 @@ func (s *Suite) Test_SubstContext_sugges
 		"SUBST_CLASSES+=\t\t\tfix-paths",
 		"SUBST_STAGE.fix-paths=\t\tpre-configure",
 		"SUBST_MESSAGE.fix-paths=\tMessage",
 		"SUBST_FILES.fix-paths=\t\tfilename",
 		"SUBST_SED.fix-paths=\t\t-e s,@PREFIX@,${PREFIX},g")
 	mklines.Check()
 	t.CheckOutputLines(
 		"AUTOFIX: subst.mk:7: Replacing \"SUBST_SED.fix-paths=\\t\\t-e s,@PREFIX@,${PREFIX},g\" " +
 			"with \"SUBST_VARS.fix-paths=\\t\\tPREFIX\".")
 	t.CheckFileLinesDetab("subst.mk",
-		"# $NetBSD: substcontext_test.go,v 1.27 2019/06/30 20:56:19 rillig Exp $",
+		MkCvsID,
 		"",
 		"SUBST_CLASSES+=                 fix-paths",
 		"SUBST_STAGE.fix-paths=          pre-configure",
 		"SUBST_MESSAGE.fix-paths=        Message",
 		"SUBST_FILES.fix-paths=          filename",
 		"SUBST_VARS.fix-paths=           PREFIX")
+}
 func (s *Suite) Test_SubstContext_extractVarname(c *check.C) {
 	t := s.Init(c)
 	test := func(input, expected string) {
 		t.Check((*SubstContext).extractVarname(nil, input), equals, expected)

 @@ -1,16 +1,16 @@
-# $NetBSD: Makefile,v 1.586 2019/06/30 20:56:18 rillig Exp $
+# $NetBSD: Makefile,v 1.587 2019/07/01 22:25:52 rillig Exp $
-PKGNAME=	pkglint-5.7.14
+PKGNAME=	pkglint-5.7.15
 CATEGORIES=	pkgtools
 DISTNAME=	tools
 MASTER_SITES=	${MASTER_SITE_GITHUB:=golang/}
 GITHUB_PROJECT=	tools
 GITHUB_TAG=	92d8274bd7b8a4c65f24bafe401a029e58392704
 MAINTAINER=	rillig@NetBSD.org
 HOMEPAGE=	https://github.com/rillig/pkglint
 COMMENT=	Verifier for NetBSD packages
 LICENSE=	2-clause-bsd
 CONFLICTS+=	pkglint4-[0-9]*
 USE_TOOLS+=		pax

 @@ -978,26 +978,51 @@ func (s *Suite) Test_Autofix_Apply__anyw
 	fix := mklines.mklines[1].Autofix()
 	fix.Errorf("From must be To.")
 	fix.Replace("from", "to")
 	fix.Anyway()
 	fix.Apply()
 	mklines.SaveAutofixChanges()
 	t.Check(G.Logger.errors, equals, 0)
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_Autofix_Apply__source_autofix_no_change(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("--autofix", "--source")
 	lines := t.SetUpFileLines("filename",
 		"word word word")
 	fix := lines.Lines[0].Autofix()
 	fix.Notef("Word should be replaced, but pkglint is not sure which one.")
 	fix.Replace("word", "replacement")
 	fix.Anyway()
 	fix.Apply()
 	lines.SaveAutofixChanges()
 	// Nothing is replaced since, as of June 2019, pkglint doesn't
 	// know which of the three "word" should be replaced.
 	//
 	// The note is not logged since fix.Anyway only applies when neither
 	// --show-autofix nor --autofix is given in the command line.
 	t.CheckOutputEmpty()
 	t.CheckFileLines("filename",
 		"word word word")
+}
 // Ensures that without explanations, the separator between the individual
 // diagnostics are generated.
 func (s *Suite) Test_Autofix_Apply__source_without_explain(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("--source", "--explain", "--show-autofix")
 	line := t.NewLine("filename", 5, "text")
 	fix := line.Autofix()
 	fix.Notef("This line is quite short.")
 	fix.Replace("text", "replacement")
 	fix.Apply()

	@@ -441,27 +441,27 @@ func (mklines *MkLines) collectDocumente		@@ -441,27 +441,27 @@ func (mklines *MkLines) collectDocumente
441	words := strings.Fields(text)	441	words := strings.Fields(text)
442	if len(words) <= 1 {	442	if len(words) <= 1 {
443	break	443	break
444	}	444	}
445		445
446	commentLines++	446	commentLines++
447		447
448	parser := NewMkParser(nil, words[1], false)	448	parser := NewMkParser(nil, words[1], false)
449	varname := parser.Varname()	449	varname := parser.Varname()
450	if len(varname) < 3 {	450	if len(varname) < 3 {
451	break	451	break
452	}	452	}
453	if hasSuffix(varname, ".") {	453	if hasSuffix(varname, ".") {
454	if !parser.lexer.SkipRegexp(G.res.Compile(`^<\w+>`)) {	454	if !parser.lexer.SkipRegexp(regcomp(`^<\w+>`)) {
455	break	455	break
456	}	456	}
457	varname += "*"	457	varname += "*"
458	}	458	}
459	parser.lexer.SkipByte(':')	459	parser.lexer.SkipByte(':')
460		460
461	varcanon := varnameCanon(varname)	461	varcanon := varnameCanon(varname)
462	if varcanon == strings.ToUpper(varcanon) && matches(varcanon, `[A-Z]`) && parser.EOF() {	462	if varcanon == strings.ToUpper(varcanon) && matches(varcanon, `[A-Z]`) && parser.EOF() {
463	scope.Define(varcanon, mkline)	463	scope.Define(varcanon, mkline)
464	scope.Use(varcanon, mkline, VucRunTime)	464	scope.Use(varcanon, mkline, VucRunTime)
465	}	465	}
466		466
467	if words[1] == "Copyright" {	467	if words[1] == "Copyright" {

 @@ -42,29 +42,26 @@ type autofixAction struct {
 // autofix action is not directly related to a diagnostic.
 //
 // To prevent confusion, the code using this magic value must ensure
 // to log a diagnostic by other means.
 const SilentAutofixFormat = "SilentAutofixFormat"
 // AutofixFormat is a special value that is used for logging
 // diagnostics like "Replacing \"old\" with \"new\".".
 //
 // Since these are not really diagnostics, duplicates are not suppressed.
 const AutofixFormat = "AutofixFormat"
 func NewAutofix(line *Line) *Autofix {
 	// FIXME: replacing the returned value with
 	//  &Autofix{line: line, autofixShortTerm: autofixShortTerm{anyway: true}}
 	//  makes some tests output source code without diagnostic.
 	return &Autofix{line: line}
+}
 // Errorf remembers the error for logging it later when Apply is called.
 func (fix *Autofix) Errorf(format string, args ...interface{}) {
 	fix.setDiag(Error, format, args)
+}
 // Warnf remembers the warning for logging it later when Apply is called.
 func (fix *Autofix) Warnf(format string, args ...interface{}) {
 	fix.setDiag(Warn, format, args)
+}

	@@ -38,27 +38,27 @@ func (llex *LinesLexer) Skip() bool {		@@ -38,27 +38,27 @@ func (llex *LinesLexer) Skip() bool {
38	return true	38	return true
39	}	39	}
40		40
41	func (llex *LinesLexer) Undo() {	41	func (llex *LinesLexer) Undo() {
42	llex.index--	42	llex.index--
43	}	43	}
44		44
45	func (llex *LinesLexer) NextRegexp(re regex.Pattern) []string {	45	func (llex *LinesLexer) NextRegexp(re regex.Pattern) []string {
46	if trace.Tracing {	46	if trace.Tracing {
47	defer trace.Call(llex.CurrentLine().Text, re)()	47	defer trace.Call(llex.CurrentLine().Text, re)()
48	}	48	}
49		49
50	if !llex.EOF() {	50	if !llex.EOF() {
51	if m := G.res.Match(llex.lines.Lines[llex.index].Text, re); m != nil {	51	if m := match(llex.lines.Lines[llex.index].Text, re); m != nil {
52	llex.index++	52	llex.index++
53	return m	53	return m
54	}	54	}
55	}	55	}
56	return nil	56	return nil
57	}	57	}
58		58
59	func (llex *LinesLexer) SkipRegexp(re regex.Pattern) bool {	59	func (llex *LinesLexer) SkipRegexp(re regex.Pattern) bool {
60	return llex.NextRegexp(re) != nil	60	return llex.NextRegexp(re) != nil
61	}	61	}
62		62
63	func (llex *LinesLexer) SkipPrefix(prefix string) bool {	63	func (llex *LinesLexer) SkipPrefix(prefix string) bool {
64	if trace.Tracing {	64	if trace.Tracing {

	@@ -1204,28 +1204,28 @@ func (pkg *Package) checkOwnerMaintainer		@@ -1204,28 +1204,28 @@ func (pkg *Package) checkOwnerMaintainer
1204	seeGuide("Package components, Makefile", "components.Makefile"))	1204	seeGuide("Package components, Makefile", "components.Makefile"))
1205	}	1205	}
1206		1206
1207	if maintainer != "" {	1207	if maintainer != "" {
1208	line := NewLineWhole(filename)	1208	line := NewLineWhole(filename)
1209	line.Notef("Please only commit changes that %s would approve.", maintainer)	1209	line.Notef("Please only commit changes that %s would approve.", maintainer)
1210	line.Explain(	1210	line.Explain(
1211	"See the pkgsrc guide, section \"Package components\",",	1211	"See the pkgsrc guide, section \"Package components\",",
1212	"keyword \"maintainer\", for more information.")	1212	"keyword \"maintainer\", for more information.")
1213	}	1213	}
1214	}	1214	}
1215		1215
1216	func (pkg *Package) checkFreeze(filename string) {	1216	func (pkg *Package) checkFreeze(filename string) {
1217	freezeStart := G.Pkgsrc.FreezeStart	1217	freezeStart := G.Pkgsrc.LastFreezeStart
1218	if freezeStart == "" {	1218	if freezeStart == "" \|\| G.Pkgsrc.LastFreezeEnd != "" {
1219	return	1219	return
1220	}	1220	}
1221		1221
1222	if !isLocallyModified(filename) {	1222	if !isLocallyModified(filename) {
1223	return	1223	return
1224	}	1224	}
1225		1225
1226	line := NewLineWhole(filename)	1226	line := NewLineWhole(filename)
1227	line.Notef("Pkgsrc is frozen since %s.", freezeStart)	1227	line.Notef("Pkgsrc is frozen since %s.", freezeStart)
1228	line.Explain(	1228	line.Explain(
1229	"During a pkgsrc freeze, changes to pkgsrc should only be made very carefully.",	1229	"During a pkgsrc freeze, changes to pkgsrc should only be made very carefully.",
1230	"See https://www.netbsd.org/developers/pkgsrc/ for the exact rules.")	1230	"See https://www.netbsd.org/developers/pkgsrc/ for the exact rules.")
1231	}	1231	}

 @@ -236,27 +236,27 @@ func (s *Suite) Test_Pkglint_Main__compl
 		"(Run \"pkglint -F\" to automatically fix some issues.)")
+}
 func (s *Suite) Test_Pkglint_Main__autofix_exitcode(c *check.C) {
 	t := s.Init(c)
 	t.SetUpPkgsrc()
 	t.CreateFileLines("filename.mk",
 		"")
 	exitcode := t.Main("-Wall", "--autofix", t.File("filename.mk"))
 	t.CheckOutputLines(
-		"AUTOFIX: ~/filename.mk:1: Inserting a line \"# $NetBSD: pkglint_test.go,v 1.44 2019/06/30 20:56:19 rillig Exp $\" before this line.")
+		"AUTOFIX: ~/filename.mk:1: Inserting a line \"" + MkCvsID + "\" before this line.")
 	t.Check(exitcode, equals, 0)
+}
 // Run pkglint in a realistic environment.
 //
 //  env \
 //  PKGLINT_TESTDIR="..." \
 //  PKGLINT_TESTCMDLINE="-r" \
 //  go test -covermode=count -test.coverprofile pkglint.cov
 //
 //  go tool cover -html=pkglint.cov -o coverage.html
 //
 // To measure the branch coverage of pkglint checking a complete pkgsrc installation,

	@@ -32,26 +32,32 @@ func (ynu YesNoUnknown) String() string		@@ -32,26 +32,32 @@ func (ynu YesNoUnknown) String() string
32	// Short names for commonly used functions.	32	// Short names for commonly used functions.
33	func contains(s, substr string) bool {	33	func contains(s, substr string) bool {
34	return strings.Contains(s, substr)	34	return strings.Contains(s, substr)
35	}	35	}
36	func hasPrefix(s, prefix string) bool {	36	func hasPrefix(s, prefix string) bool {
37	return strings.HasPrefix(s, prefix)	37	return strings.HasPrefix(s, prefix)
38	}	38	}
39	func hasSuffix(s, suffix string) bool {	39	func hasSuffix(s, suffix string) bool {
40	return strings.HasSuffix(s, suffix)	40	return strings.HasSuffix(s, suffix)
41	}	41	}
42	func sprintf(format string, args ...interface{}) string {	42	func sprintf(format string, args ...interface{}) string {
43	return fmt.Sprintf(format, args...)	43	return fmt.Sprintf(format, args...)
44	}	44	}
		45	func regcomp(re regex.Pattern) *regexp.Regexp {
		46	return G.res.Compile(re)
		47	}
		48	func match(s string, re regex.Pattern) []string {
		49	return G.res.Match(s, re)
		50	}
45	func matches(s string, re regex.Pattern) bool {	51	func matches(s string, re regex.Pattern) bool {
46	return G.res.Matches(s, re)	52	return G.res.Matches(s, re)
47	}	53	}
48	func match1(s string, re regex.Pattern) (matched bool, m1 string) {	54	func match1(s string, re regex.Pattern) (matched bool, m1 string) {
49	return G.res.Match1(s, re)	55	return G.res.Match1(s, re)
50	}	56	}
51	func match2(s string, re regex.Pattern) (matched bool, m1, m2 string) {	57	func match2(s string, re regex.Pattern) (matched bool, m1, m2 string) {
52	return G.res.Match2(s, re)	58	return G.res.Match2(s, re)
53	}	59	}
54	func match3(s string, re regex.Pattern) (matched bool, m1, m2, m3 string) {	60	func match3(s string, re regex.Pattern) (matched bool, m1, m2, m3 string) {
55	return G.res.Match3(s, re)	61	return G.res.Match3(s, re)
56	}	62	}
57	func match4(s string, re regex.Pattern) (matched bool, m1, m2, m3, m4 string) {	63	func match4(s string, re regex.Pattern) (matched bool, m1, m2, m3, m4 string) {