diff --git a/contrib/netbsd-tests/usr.bin/grep/t_grep.sh b/contrib/netbsd-tests/usr.bin/grep/t_grep.sh
index ef3f0617465e..d2539a8250de 100755
--- a/contrib/netbsd-tests/usr.bin/grep/t_grep.sh
+++ b/contrib/netbsd-tests/usr.bin/grep/t_grep.sh
@@ -1,983 +1,1000 @@
 # $NetBSD: t_grep.sh,v 1.3 2017/01/14 20:43:52 christos Exp $
 #
 # Copyright (c) 2008, 2009 The NetBSD Foundation, Inc.
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 # 1. Redistributions of source code must retain the above copyright
 #    notice, this list of conditions and the following disclaimer.
 # 2. Redistributions in binary form must reproduce the above copyright
 #    notice, this list of conditions and the following disclaimer in the
 #    documentation and/or other materials provided with the distribution.
 #
 # THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 # ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 # PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 # BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 #
 
 atf_test_case basic
 basic_head()
 {
 	atf_set "descr" "Checks basic functionality"
 }
 basic_body()
 { 
 	atf_check -o file:"$(atf_get_srcdir)/d_basic.out" -x \
 	    'jot 10000 | grep 123'
 }
 
 atf_test_case binary
 binary_head()
 {
 	atf_set "descr" "Checks handling of binary files"
 }
 binary_body()
 {
 	dd if=/dev/zero count=1 of=test.file
 	echo -n "foobar" >> test.file
 	atf_check -o file:"$(atf_get_srcdir)/d_binary.out" grep foobar test.file
 }
 
 atf_test_case recurse
 recurse_head()
 {
 	atf_set "descr" "Checks recursive searching"
 }
 recurse_body()
 {
 	mkdir -p recurse/a/f recurse/d
 	echo -e "cod\ndover sole\nhaddock\nhalibut\npilchard" > recurse/d/fish
 	echo -e "cod\nhaddock\nplaice" > recurse/a/f/favourite-fish
 
 	atf_check -o file:"$(atf_get_srcdir)/d_recurse.out" -x "grep -r haddock recurse | sort"
 }
 
 atf_test_case recurse_symlink
 recurse_symlink_head()
 {
 	atf_set "descr" "Checks symbolic link recursion"
 }
 recurse_symlink_body()
 {
 	# Begin FreeBSD
 	grep_type
 	if [ $? -eq $GREP_TYPE_GNU ]; then
 		atf_expect_fail "this test doesn't pass with gnu grep from ports"
 	fi
 	# End FreeBSD
 	mkdir -p test/c/d
 	(cd test/c/d && ln -s ../d .)
 	echo "Test string" > test/c/match
 
 	atf_check -o file:"$(atf_get_srcdir)/d_recurse_symlink.out" \
 	    -e file:"$(atf_get_srcdir)/d_recurse_symlink.err" \
 	    grep -r string test
 }
 
 atf_test_case word_regexps
 word_regexps_head()
 {
 	atf_set "descr" "Checks word-regexps"
 }
 word_regexps_body()
 {
 	atf_check -o file:"$(atf_get_srcdir)/d_word_regexps.out" \
 	    grep -w separated $(atf_get_srcdir)/d_input
 
 	# Begin FreeBSD
 	printf "xmatch pmatch\n" > test1
 
 	atf_check -o inline:"pmatch\n" grep -Eow "(match )?pmatch" test1
 	# End FreeBSD
 }
 
 atf_test_case begin_end
 begin_end_head()
 {
 	atf_set "descr" "Checks handling of line beginnings and ends"
 }
 begin_end_body()
 {
 	atf_check -o file:"$(atf_get_srcdir)/d_begin_end_a.out" \
 	    grep ^Front "$(atf_get_srcdir)/d_input"
 
 	atf_check -o file:"$(atf_get_srcdir)/d_begin_end_b.out" \
 	    grep ending$ "$(atf_get_srcdir)/d_input"
 }
 
 atf_test_case ignore_case
 ignore_case_head()
 {
 	atf_set "descr" "Checks ignore-case option"
 }
 ignore_case_body()
 {
 	atf_check -o file:"$(atf_get_srcdir)/d_ignore_case.out" \
 	    grep -i Upper "$(atf_get_srcdir)/d_input"
 }
 
 atf_test_case invert
 invert_head()
 {
 	atf_set "descr" "Checks selecting non-matching lines with -v option"
 }
 invert_body()
 {
 	atf_check -o file:"$(atf_get_srcdir)/d_invert.out" \
 	    grep -v fish "$(atf_get_srcdir)/d_invert.in"
 }
 
 atf_test_case whole_line
 whole_line_head()
 {
 	atf_set "descr" "Checks whole-line matching with -x flag"
 }
 whole_line_body()
 {
 	atf_check -o file:"$(atf_get_srcdir)/d_whole_line.out" \
 	    grep -x matchme "$(atf_get_srcdir)/d_input"
 }
 
 atf_test_case negative
 negative_head()
 {
 	atf_set "descr" "Checks handling of files with no matches"
 }
 negative_body()
 {
 	atf_check -s ne:0 grep "not a hope in hell" "$(atf_get_srcdir)/d_input"
 }
 
 atf_test_case context
 context_head()
 {
 	atf_set "descr" "Checks displaying context with -A, -B and -C flags"
 }
 context_body()
 {
 	cp $(atf_get_srcdir)/d_context_*.* .
 
 	atf_check -o file:d_context_a.out grep -C2 bamboo d_context_a.in
 	atf_check -o file:d_context_b.out grep -A3 tilt d_context_a.in
 	atf_check -o file:d_context_c.out grep -B4 Whig d_context_a.in
 	atf_check -o file:d_context_d.out grep -C1 pig d_context_a.in d_context_b.in
 	atf_check -o file:d_context_e.out \
 	    grep -E -C1 '(banana|monkey)' d_context_e.in
 	atf_check -o file:d_context_f.out \
 	    grep -Ev -B2 '(banana|monkey|fruit)' d_context_e.in
 	atf_check -o file:d_context_g.out \
 	    grep -Ev -A1 '(banana|monkey|fruit)' d_context_e.in
 }
 
 atf_test_case file_exp
 file_exp_head()
 {
 	atf_set "descr" "Checks reading expressions from file"
 }
 file_exp_body()
 {
 	atf_check -o file:"$(atf_get_srcdir)/d_file_exp.out" -x \
 	    'jot 21 -1 1.00 | grep -f '"$(atf_get_srcdir)"'/d_file_exp.in'
 }
 
 atf_test_case egrep
 egrep_head()
 {
 	atf_set "descr" "Checks matching special characters with egrep"
 }
 egrep_body()
 {
 	atf_check -o file:"$(atf_get_srcdir)/d_egrep.out" \
 		egrep '\?|\*$$' "$(atf_get_srcdir)/d_input"
 }
 
 atf_test_case zgrep
 zgrep_head()
 {
 	atf_set "descr" "Checks handling of gzipped files with zgrep"
 }
 zgrep_body()
 {
 	cp "$(atf_get_srcdir)/d_input" .
 	gzip d_input || atf_fail "gzip failed"
 
 	atf_check -o file:"$(atf_get_srcdir)/d_zgrep.out" zgrep -h line d_input.gz
 }
 
 atf_test_case zgrep_combined_flags
 zgrep_combined_flags_head()
 {
 	atf_set "descr" "Checks for zgrep wrapper problems with combined flags (PR 247126)"
 }
 zgrep_combined_flags_body()
 {
 	atf_expect_fail "known but unsolved zgrep wrapper script regression"
 
 	echo 'foo bar' > test
 
 	atf_check -o inline:"foo bar\n" zgrep -we foo test
 	# Avoid hang on reading from stdin in the failure case
 	atf_check -o inline:"foo bar\n" zgrep -wefoo test < /dev/null
 }
 
 atf_test_case zgrep_eflag
 zgrep_eflag_head()
 {
 	atf_set "descr" "Checks for zgrep wrapper problems with -e PATTERN (PR 247126)"
 }
 zgrep_eflag_body()
 {
 	echo 'foo bar' > test
 
 	# Avoid hang on reading from stdin in the failure case
 	atf_check -o inline:"foo bar\n" zgrep -e 'foo bar' test < /dev/null
 	atf_check -o inline:"foo bar\n" zgrep --regexp='foo bar' test < /dev/null
 }
 
 atf_test_case zgrep_fflag
 zgrep_fflag_head()
 {
 	atf_set "descr" "Checks for zgrep wrapper problems with -f FILE (PR 247126)"
 }
 zgrep_fflag_body()
 {
 	echo foo > pattern
 	echo foobar > test
 
 	# Avoid hang on reading from stdin in the failure case
 	atf_check -o inline:"foobar\n" zgrep -f pattern test </dev/null
 	atf_check -o inline:"foobar\n" zgrep --file=pattern test </dev/null
 }
 
 atf_test_case zgrep_long_eflag
 zgrep_long_eflag_head()
 {
 	atf_set "descr" "Checks for zgrep wrapper problems with --ignore-case reading from stdin (PR 247126)"
 }
 zgrep_long_eflag_body()
 {
 	echo foobar > test
 
 	atf_check -o inline:"foobar\n" zgrep -e foo --ignore-case < test
 }
 
 atf_test_case zgrep_multiple_eflags
 zgrep_multiple_eflags_head()
 {
 	atf_set "descr" "Checks for zgrep wrapper problems with multiple -e flags (PR 247126)"
 }
 zgrep_multiple_eflags_body()
 {
 	atf_expect_fail "known but unsolved zgrep wrapper script regression"
 
 	echo foobar > test
 
 	atf_check -o inline:"foobar\n" zgrep -e foo -e xxx test
 }
 
 atf_test_case zgrep_empty_eflag
 zgrep_empty_eflag_head()
 {
 	atf_set "descr" "Checks for zgrep wrapper problems with empty -e flags pattern (PR 247126)"
 }
 zgrep_empty_eflag_body()
 {
 	echo foobar > test
 
 	atf_check -o inline:"foobar\n" zgrep -e '' test
 }
 
 atf_test_case nonexistent
 nonexistent_head()
 {
 	atf_set "descr" "Checks that -s flag suppresses error" \
 	                "messages about nonexistent files"
 }
 nonexistent_body()
 {
 	atf_check -s ne:0 grep -s foobar nonexistent
 }
 
 atf_test_case context2
 context2_head()
 {
 	atf_set "descr" "Checks displaying context with -z flag"
 }
 context2_body()
 {
 	printf "haddock\000cod\000plaice\000" > test1
 	printf "mackeral\000cod\000crab\000" > test2
 
 	atf_check -o file:"$(atf_get_srcdir)/d_context2_a.out" \
 	    grep -z -A1 cod test1 test2
 
 	atf_check -o file:"$(atf_get_srcdir)/d_context2_b.out" \
 	    grep -z -B1 cod test1 test2
 
 	atf_check -o file:"$(atf_get_srcdir)/d_context2_c.out" \
 	    grep -z -C1 cod test1 test2
 }
 # Begin FreeBSD
 
 # What grep(1) are we working with?
 # - 0 : bsdgrep
 # - 1 : gnu grep 2.51 (base)
 # - 2 : gnu grep (ports)
 GREP_TYPE_BSD=0
 GREP_TYPE_GNU_FREEBSD=1
 GREP_TYPE_GNU=2
 GREP_TYPE_UNKNOWN=3
 
 grep_type()
 {
 	local grep_version=$(grep --version)
 
 	case "$grep_version" in
 	*"BSD grep"*)
 		return $GREP_TYPE_BSD
 		;;
 	*"GNU grep"*)
 		case "$grep_version" in
 		*2.5.1-FreeBSD*)
 			return $GREP_TYPE_GNU_FREEBSD
 			;;
 		*)
 			return $GREP_TYPE_GNU
 			;;
 		esac
 		;;
 	esac
 	atf_fail "unknown grep type: $grep_version"
 }
 
 atf_test_case oflag_zerolen
 oflag_zerolen_head()
 {
 	atf_set "descr" "Check behavior of zero-length matches with -o flag (PR 195763)"
 }
 oflag_zerolen_body()
 {
 	grep_type
 	if [ $? -eq $GREP_TYPE_GNU_FREEBSD ]; then
 		atf_expect_fail "this test doesn't pass with gnu grep in base"
 	fi
 
 	atf_check -o file:"$(atf_get_srcdir)/d_oflag_zerolen_a.out" \
 	    grep -Eo '(^|:)0*' "$(atf_get_srcdir)/d_oflag_zerolen_a.in"
 
 	atf_check -o file:"$(atf_get_srcdir)/d_oflag_zerolen_b.out" \
 	    grep -Eo '(^|:)0*' "$(atf_get_srcdir)/d_oflag_zerolen_b.in"
 
 	atf_check -o file:"$(atf_get_srcdir)/d_oflag_zerolen_c.out" \
 	    grep -Eo '[[:alnum:]]*' "$(atf_get_srcdir)/d_oflag_zerolen_c.in"
 
 	atf_check -o empty grep -Eo '' "$(atf_get_srcdir)/d_oflag_zerolen_d.in"
 
 	atf_check -o file:"$(atf_get_srcdir)/d_oflag_zerolen_e.out" \
 	    grep -o -e 'ab' -e 'bc' "$(atf_get_srcdir)/d_oflag_zerolen_e.in"
 
 	atf_check -o file:"$(atf_get_srcdir)/d_oflag_zerolen_e.out" \
 	    grep -o -e 'bc' -e 'ab' "$(atf_get_srcdir)/d_oflag_zerolen_e.in"
 }
 
 atf_test_case xflag
 xflag_head()
 {
 	atf_set "descr" "Check that we actually get a match with -x flag (PR 180990)"
 }
 xflag_body()
 {
 	echo 128 > match_file
 	seq 1 128 > pattern_file
 	grep -xf pattern_file match_file
 }
 
 atf_test_case color
 color_head()
 {
 	atf_set "descr" "Check --color support"
 }
 color_body()
 {
 	grep_type
 	if [ $? -eq $GREP_TYPE_GNU_FREEBSD ]; then
 		atf_expect_fail "this test doesn't pass with gnu grep in base"
 	fi
 
 	echo 'abcd*' > grepfile
 	echo 'abc$' >> grepfile
 	echo '^abc' >> grepfile
 
 	atf_check -o file:"$(atf_get_srcdir)/d_color_a.out" \
 	    grep --color=auto -e '.*' -e 'a' "$(atf_get_srcdir)/d_color_a.in"
 
 	atf_check -o file:"$(atf_get_srcdir)/d_color_b.out" \
 	    grep --color=auto -f grepfile "$(atf_get_srcdir)/d_color_b.in"
 
 	atf_check -o file:"$(atf_get_srcdir)/d_color_c.out" \
 	    grep --color=always -f grepfile "$(atf_get_srcdir)/d_color_b.in"
 }
 
 atf_test_case f_file_empty
 f_file_empty_head()
 {
 	atf_set "descr" "Check for handling of a null byte in empty file, specified by -f (PR 202022)"
 }
 f_file_empty_body()
 {
 	printf "\0\n" > nulpat
 
 	atf_check -s exit:1 grep -f nulpat "$(atf_get_srcdir)/d_f_file_empty.in"
 }
 
 atf_test_case escmap
 escmap_head()
 {
 	atf_set "descr" "Check proper handling of escaped vs. unescaped dot expressions (PR 175314)"
 }
 escmap_body()
 {
 	atf_check -s exit:1 grep -o 'f.o\.' "$(atf_get_srcdir)/d_escmap.in"
 	atf_check -o not-empty grep -o 'f.o.' "$(atf_get_srcdir)/d_escmap.in"
 }
 
 atf_test_case egrep_empty_invalid
 egrep_empty_invalid_head()
 {
 	atf_set "descr" "Check for handling of an invalid empty pattern (PR 194823)"
 }
 egrep_empty_invalid_body()
 {
 	atf_check -e ignore -s not-exit:0 egrep '{' /dev/null
 }
 
 atf_test_case zerolen
 zerolen_head()
 {
 	atf_set "descr" "Check for successful zero-length matches with ^$"
 }
 zerolen_body()
 {
 	printf "Eggs\n\nCheese" > test1
 
 	atf_check -o inline:"\n" grep -e "^$" test1
 
 	atf_check -o inline:"Eggs\nCheese\n" grep -v -e "^$" test1
 }
 
 atf_test_case wflag_emptypat
 wflag_emptypat_head()
 {
 	atf_set "descr" "Check for proper handling of -w with an empty pattern (PR 105221)"
 }
 wflag_emptypat_body()
 {
 	printf "" > test1
 	printf "\n" > test2
 	printf "qaz" > test3
 	printf " qaz\n" > test4
 
 	atf_check -s exit:1 -o empty grep -w -e "" test1
 
 	atf_check -o file:test2 grep -vw -e "" test2
 
 	atf_check -s exit:1 -o empty grep -w -e "" test3
 
 	atf_check -o file:test4 grep -vw -e "" test4
 }
 
 atf_test_case xflag_emptypat
 xflag_emptypat_body()
 {
 	printf "" > test1
 	printf "\n" > test2
 	printf "qaz" > test3
 	printf " qaz\n" > test4
 
 	atf_check -s exit:1 -o empty grep -x -e "" test1
 
 	atf_check -o file:test2 grep -x -e "" test2
 
 	atf_check -s exit:1 -o empty grep -x -e "" test3
 
 	atf_check -s exit:1 -o empty grep -x -e "" test4
 
 	total=$(wc -l /COPYRIGHT | sed 's/[^0-9]//g')
 
 	# Simple checks that grep -x with an empty pattern isn't matching every
 	# line.  The exact counts aren't important, as long as they don't
 	# match the total line count and as long as they don't match each other.
 	atf_check -o save:xpositive.count grep -Fxc '' /COPYRIGHT
 	atf_check -o save:xnegative.count grep -Fvxc '' /COPYRIGHT
 
 	atf_check -o not-inline:"${total}" cat xpositive.count
 	atf_check -o not-inline:"${total}" cat xnegative.count
 
 	atf_check -o not-file:xnegative.count cat xpositive.count
 }
 
 atf_test_case xflag_emptypat_plus
 xflag_emptypat_plus_body()
 {
 	printf "foo\n\nbar\n\nbaz\n" > target
 	printf "foo\n \nbar\n \nbaz\n" > target_spacelines
 	printf "foo\nbar\nbaz\n" > matches
 	printf " \n \n" > spacelines
 
 	printf "foo\n\nbar\n\nbaz\n" > patlist1
 	printf "foo\n\nba\n\nbaz\n" > patlist2
 
 	sed -e '/bar/d' target > matches_not2
 
 	# Normal handling first
 	atf_check -o file:target grep -Fxf patlist1 target
 	atf_check -o file:matches grep -Fxf patlist1 target_spacelines
 	atf_check -o file:matches_not2 grep -Fxf patlist2 target
 
 	# -v handling
 	atf_check -s exit:1 -o empty grep -Fvxf patlist1 target
 	atf_check -o file:spacelines grep -Fxvf patlist1 target_spacelines
 }
 
 atf_test_case emptyfile
 emptyfile_descr()
 {
 	atf_set "descr" "Check for proper handling of empty pattern files (PR 253209)"
 }
 emptyfile_body()
 {
 	:> epatfile
 	echo "blubb" > subj
 
 	# From PR 253209, bsdgrep was short-circuiting completely on an empty
 	# file, but we should have still been processing lines.
 	atf_check -s exit:1 -o empty fgrep -f epatfile subj
 	atf_check -o file:subj fgrep -vf epatfile subj
 }
 
 atf_test_case excessive_matches
 excessive_matches_head()
 {
 	atf_set "descr" "Check for proper handling of lines with excessive matches (PR 218811)"
 }
 excessive_matches_body()
 {
 	grep_type
 	if [ $? -eq $GREP_TYPE_GNU_FREEBSD ]; then
 		atf_expect_fail "this test does not pass with GNU grep in base"
 	fi
 
 	for i in $(jot 4096); do
 		printf "x" >> test.in
 	done
 
 	atf_check -s exit:0 -x '[ $(grep -o x test.in | wc -l) -eq 4096 ]'
 	atf_check -s exit:1 -x 'grep -on x test.in | grep -v "1:x"'
 }
 
 atf_test_case fgrep_sanity
 fgrep_sanity_head()
 {
 	atf_set "descr" "Check for fgrep sanity, literal expressions only"
 }
 fgrep_sanity_body()
 {
 	printf "Foo" > test1
 
 	atf_check -o inline:"Foo\n" fgrep -e "Foo" test1
 
 	atf_check -s exit:1 -o empty fgrep -e "Fo." test1
 }
 
 atf_test_case egrep_sanity
 egrep_sanity_head()
 {
 	atf_set "descr" "Check for egrep sanity, EREs only"
 }
 egrep_sanity_body()
 {
 	printf "Foobar(ed)" > test1
 	printf "M{1}" > test2
 
 	atf_check -o inline:"Foo\n" egrep -o -e "F.." test1
 
 	atf_check -o inline:"Foobar\n" egrep -o -e "F[a-z]*" test1
 
 	atf_check -o inline:"Fo\n" egrep -o -e "F(o|p)" test1
 
 	atf_check -o inline:"(ed)\n" egrep -o -e "\(ed\)" test1
 
 	atf_check -o inline:"M\n" egrep -o -e "M{1}" test2
 
 	atf_check -o inline:"M{1}\n" egrep -o -e "M\{1\}" test2
 }
 
 atf_test_case grep_sanity
 grep_sanity_head()
 {
 	atf_set "descr" "Check for basic grep sanity, BREs only"
 }
 grep_sanity_body()
 {
 	printf "Foobar(ed)" > test1
 	printf "M{1}" > test2
 
 	atf_check -o inline:"Foo\n" grep -o -e "F.." test1
 
 	atf_check -o inline:"Foobar\n" grep -o -e "F[a-z]*" test1
 
 	atf_check -o inline:"Fo\n" grep -o -e "F\(o\)" test1
 
 	atf_check -o inline:"(ed)\n" grep -o -e "(ed)" test1
 
 	atf_check -o inline:"M{1}\n" grep -o -e "M{1}" test2
 
 	atf_check -o inline:"M\n" grep -o -e "M\{1\}" test2
 }
 
 atf_test_case wv_combo_break
 wv_combo_break_head()
 {
 	atf_set "descr" "Check for incorrectly matching lines with both -w and -v flags (PR 218467)"
 }
 wv_combo_break_body()
 {
 	printf "x xx\n" > test1
 	printf "xx x\n" > test2
 
 	atf_check -o file:test1 grep -w "x" test1
 	atf_check -o file:test2 grep -w "x" test2
 
 	atf_check -s exit:1 grep -v -w "x" test1
 	atf_check -s exit:1 grep -v -w "x" test2
 }
 
 atf_test_case ocolor_metadata
 ocolor_metadata_head()
 {
 	atf_set "descr" "Check for -n/-b producing per-line metadata output"
 }
 ocolor_metadata_body()
 {
 	grep_type
 	if [ $? -eq $GREP_TYPE_GNU_FREEBSD ]; then
 		atf_expect_fail "this test does not pass with GNU grep in base"
 	fi
 
 	printf "xxx\nyyyy\nzzz\nfoobarbaz\n" > test1
 	check_expr="^[^:]*[0-9][^:]*:[^:]+$"
 
 	atf_check -o inline:"1:1:xx\n" grep -bon "xx$" test1
 
 	atf_check -o inline:"2:4:yyyy\n" grep -bn "yy" test1
 
 	atf_check -o inline:"2:6:yy\n" grep -bon "yy$" test1
 
 	# These checks ensure that grep isn't producing bogus line numbering
 	# in the middle of a line.
 	atf_check -s exit:1 -x \
 	    "grep -Eon 'x|y|z|f' test1 | grep -Ev '${check_expr}'"
 
 	atf_check -s exit:1 -x \
 	    "grep -En 'x|y|z|f' --color=always test1 | grep -Ev '${check_expr}'"
 
 	atf_check -s exit:1 -x \
 	    "grep -Eon 'x|y|z|f' --color=always test1 | grep -Ev '${check_expr}'"
 }
 
 atf_test_case grep_nomatch_flags
 grep_nomatch_flags_head()
 {
 	atf_set "descr" "Check for no match (-c, -l, -L, -q) flags not producing line matches or context (PR 219077)"
 }
 
 grep_nomatch_flags_body()
 {
 	grep_type
 
 	if [ $? -eq $GREP_TYPE_GNU_FREEBSD ]; then
 		atf_expect_fail "this test does not pass with GNU grep in base"
 	fi
 
 	printf "A\nB\nC\n" > test1
 
 	atf_check -o inline:"1\n" grep -c -C 1 -e "B" test1
 	atf_check -o inline:"1\n" grep -c -B 1 -e "B" test1
 	atf_check -o inline:"1\n" grep -c -A 1 -e "B" test1
 	atf_check -o inline:"1\n" grep -c -C 1 -e "B" test1
 
 	atf_check -o inline:"test1\n" grep -l -e "B" test1
 	atf_check -o inline:"test1\n" grep -l -B 1 -e "B" test1
 	atf_check -o inline:"test1\n" grep -l -A 1 -e "B" test1
 	atf_check -o inline:"test1\n" grep -l -C 1 -e "B" test1
 
 	atf_check -o inline:"test1\n" grep -L -e "D" test1
 
 	atf_check -o empty grep -q -e "B" test1
 	atf_check -o empty grep -q -B 1 -e "B" test1
 	atf_check -o empty grep -q -A 1 -e "B" test1
 	atf_check -o empty grep -q -C 1 -e "B" test1
 }
 
 atf_test_case badcontext
 badcontext_head()
 {
 	atf_set "descr" "Check for handling of invalid context arguments"
 }
 badcontext_body()
 {
 	printf "A\nB\nC\n" > test1
 
 	atf_check -s not-exit:0 -e ignore grep -A "-1" "B" test1
 
 	atf_check -s not-exit:0 -e ignore grep -B "-1" "B" test1
 
 	atf_check -s not-exit:0 -e ignore grep -C "-1" "B" test1
 
 	atf_check -s not-exit:0 -e ignore grep -A "B" "B" test1
 
 	atf_check -s not-exit:0 -e ignore grep -B "B" "B" test1
 
 	atf_check -s not-exit:0 -e ignore grep -C "B" "B" test1
 }
 
 atf_test_case binary_flags
 binary_flags_head()
 {
 	atf_set "descr" "Check output for binary flags (-a, -I, -U, --binary-files)"
 }
 binary_flags_body()
 {
 	printf "A\000B\000C" > test1
 	printf "A\n\000B\n\000C" > test2
 	binmatchtext="Binary file test1 matches\n"
 
 	# Binaries not treated as text (default, -U)
 	atf_check -o inline:"${binmatchtext}" grep 'B' test1
 	atf_check -o inline:"${binmatchtext}" grep 'B' -C 1 test1
 
 	atf_check -o inline:"${binmatchtext}" grep -U 'B' test1
 	atf_check -o inline:"${binmatchtext}" grep -U 'B' -C 1 test1
 
 	# Binary, -a, no newlines
 	atf_check -o inline:"A\000B\000C\n" grep -a 'B' test1
 	atf_check -o inline:"A\000B\000C\n" grep -a 'B' -C 1 test1
 
 	# Binary, -a, newlines
 	atf_check -o inline:"\000B\n" grep -a 'B' test2
 	atf_check -o inline:"A\n\000B\n\000C\n" grep -a 'B' -C 1 test2
 
 	# Binary files ignored
 	atf_check -s exit:1 grep -I 'B' test2
 
 	# --binary-files equivalence
 	atf_check -o inline:"${binmatchtext}" grep --binary-files=binary 'B' test1
 	atf_check -o inline:"A\000B\000C\n" grep --binary-files=text 'B' test1
 	atf_check -s exit:1 grep --binary-files=without-match 'B' test2
 }
 
 atf_test_case mmap
 mmap_head()
 {
 	atf_set "descr" "Check basic matching with --mmap flag"
 }
 mmap_body()
 {
 	grep_type
 	if [ $? -eq $GREP_TYPE_GNU ]; then
 		atf_expect_fail "gnu grep from ports has no --mmap option"
 	fi
 
 	printf "A\nB\nC\n" > test1
 
 	atf_check -s exit:0 -o inline:"B\n" grep --mmap -oe "B" test1
 	atf_check -s exit:1 grep --mmap -e "Z" test1
 }
 
 atf_test_case matchall
 matchall_head()
 {
 	atf_set "descr" "Check proper behavior of matching all with an empty string"
 }
 matchall_body()
 {
 	printf "" > test1
 	printf "A" > test2
 	printf "A\nB" > test3
 
 	atf_check -o inline:"test2:A\ntest3:A\ntest3:B\n" grep "" test1 test2 test3
 	atf_check -o inline:"test3:A\ntest3:B\ntest2:A\n" grep "" test3 test1 test2
 	atf_check -o inline:"test2:A\ntest3:A\ntest3:B\n" grep "" test2 test3 test1
 
 	atf_check -s exit:1 grep "" test1
 }
 
 atf_test_case fgrep_multipattern
 fgrep_multipattern_head()
 {
 	atf_set "descr" "Check proper behavior with multiple patterns supplied to fgrep"
 }
 fgrep_multipattern_body()
 {
 	printf "Foo\nBar\nBaz" > test1
 
 	atf_check -o inline:"Foo\nBaz\n" grep -F -e "Foo" -e "Baz" test1
 	atf_check -o inline:"Foo\nBaz\n" grep -F -e "Baz" -e "Foo" test1
 	atf_check -o inline:"Bar\nBaz\n" grep -F -e "Bar" -e "Baz" test1
 }
 
 atf_test_case fgrep_icase
 fgrep_icase_head()
 {
 	atf_set "descr" "Check proper handling of -i supplied to fgrep"
 }
 fgrep_icase_body()
 {
 	printf "Foo\nBar\nBaz" > test1
 
 	atf_check -o inline:"Foo\nBaz\n" grep -Fi -e "foo" -e "baz" test1
 	atf_check -o inline:"Foo\nBaz\n" grep -Fi -e "baz" -e "foo" test1
 	atf_check -o inline:"Bar\nBaz\n" grep -Fi -e "bar" -e "baz" test1
 	atf_check -o inline:"Bar\nBaz\n" grep -Fi -e "BAR" -e "bAz" test1
 }
 
 atf_test_case fgrep_oflag
 fgrep_oflag_head()
 {
 	atf_set "descr" "Check proper handling of -o supplied to fgrep"
 }
 fgrep_oflag_body()
 {
 	printf "abcdefghi\n" > test1
 
 	atf_check -o inline:"a\n" grep -Fo "a" test1
 	atf_check -o inline:"i\n" grep -Fo "i" test1
 	atf_check -o inline:"abc\n" grep -Fo "abc" test1
 	atf_check -o inline:"fgh\n" grep -Fo "fgh" test1
 	atf_check -o inline:"cde\n" grep -Fo "cde" test1
 	atf_check -o inline:"bcd\n" grep -Fo -e "bcd" -e "cde" test1
 	atf_check -o inline:"bcd\nefg\n" grep -Fo -e "bcd" -e "efg" test1
 
 	atf_check -s exit:1 grep -Fo "xabc" test1
 	atf_check -s exit:1 grep -Fo "abcx" test1
 	atf_check -s exit:1 grep -Fo "xghi" test1
 	atf_check -s exit:1 grep -Fo "ghix" test1
 	atf_check -s exit:1 grep -Fo "abcdefghiklmnopqrstuvwxyz" test1
 }
 
 atf_test_case cflag
 cflag_head()
 {
 	atf_set "descr" "Check proper handling of -c"
 }
 cflag_body()
 {
 	printf "a\nb\nc\n" > test1
 
 	atf_check -o inline:"1\n" grep -Ec "a" test1
 	atf_check -o inline:"2\n" grep -Ec "a|b" test1
 	atf_check -o inline:"3\n" grep -Ec "a|b|c" test1
 
 	atf_check -o inline:"test1:2\n" grep -EHc "a|b" test1
 }
 
 atf_test_case mflag
 mflag_head()
 {
 	atf_set "descr" "Check proper handling of -m"
 }
 mflag_body()
 {
 	printf "a\nb\nc\nd\ne\nf\n" > test1
 
 	atf_check -o inline:"1\n" grep -m 1 -Ec "a" test1
 	atf_check -o inline:"2\n" grep -m 2 -Ec "a|b" test1
 	atf_check -o inline:"3\n" grep -m 3 -Ec "a|b|c|f" test1
 
 	atf_check -o inline:"test1:2\n" grep -m 2 -EHc "a|b|e|f" test1
 }
 
+atf_test_case mflag_trail_ctx
+mflag_trail_ctx_head()
+{
+	atf_set "descr" "Check proper handling of -m with trailing context (PR 253350)"
+}
+mflag_trail_ctx_body()
+{
+	printf "foo\nfoo\nbar\nfoo\nbar\nfoo\nbar\n" > test1
+
+	# Should pick up the next line after matching the first.
+	atf_check -o inline:"foo\nfoo\n" grep -A1 -m1 foo test1
+
+	# Make sure the trailer is picked up as a non-match!
+	atf_check -o inline:"1:foo\n2-foo\n" grep -A1 -nm1 foo test1
+}
+
 atf_test_case zgrep_multiple_files
 zgrep_multiple_files_head()
 {
 	atf_set "descr" "Ensures that zgrep functions properly with multiple files"
 }
 zgrep_multiple_files_body()
 {
 	echo foo > test1
 	echo foo > test2
 	atf_check -o inline:"test1:foo\ntest2:foo\n" zgrep foo test1 test2
 
 	echo bar > test1
 	atf_check -o inline:"test2:foo\n" zgrep foo test1 test2
 
 	echo bar > test2
 	atf_check -s exit:1 zgrep foo test1 test2
 }
 # End FreeBSD
 
 atf_init_test_cases()
 {
 	atf_add_test_case basic
 	atf_add_test_case binary
 	atf_add_test_case recurse
 	atf_add_test_case recurse_symlink
 	atf_add_test_case word_regexps
 	atf_add_test_case begin_end
 	atf_add_test_case ignore_case
 	atf_add_test_case invert
 	atf_add_test_case whole_line
 	atf_add_test_case negative
 	atf_add_test_case context
 	atf_add_test_case file_exp
 	atf_add_test_case egrep
 	atf_add_test_case zgrep
 	atf_add_test_case zgrep_combined_flags
 	atf_add_test_case zgrep_eflag
 	atf_add_test_case zgrep_empty_eflag
 	atf_add_test_case zgrep_fflag
 	atf_add_test_case zgrep_long_eflag
 	atf_add_test_case zgrep_multiple_eflags
 	atf_add_test_case nonexistent
 	atf_add_test_case context2
 # Begin FreeBSD
 	atf_add_test_case oflag_zerolen
 	atf_add_test_case xflag
 	atf_add_test_case color
 	atf_add_test_case f_file_empty
 	atf_add_test_case escmap
 	atf_add_test_case egrep_empty_invalid
 	atf_add_test_case zerolen
 	atf_add_test_case wflag_emptypat
 	atf_add_test_case xflag_emptypat
 	atf_add_test_case xflag_emptypat_plus
 	atf_add_test_case emptyfile
 	atf_add_test_case excessive_matches
 	atf_add_test_case wv_combo_break
 	atf_add_test_case fgrep_sanity
 	atf_add_test_case egrep_sanity
 	atf_add_test_case grep_sanity
 	atf_add_test_case ocolor_metadata
 	atf_add_test_case grep_nomatch_flags
 	atf_add_test_case binary_flags
 	atf_add_test_case badcontext
 	atf_add_test_case mmap
 	atf_add_test_case matchall
 	atf_add_test_case fgrep_multipattern
 	atf_add_test_case fgrep_icase
 	atf_add_test_case fgrep_oflag
 	atf_add_test_case cflag
 	atf_add_test_case mflag
+	atf_add_test_case mflag_trail_ctx
 	atf_add_test_case zgrep_multiple_files
 # End FreeBSD
 }
diff --git a/usr.bin/grep/util.c b/usr.bin/grep/util.c
index f22b7abd79ef..a2520e24de8e 100644
--- a/usr.bin/grep/util.c
+++ b/usr.bin/grep/util.c
@@ -1,776 +1,795 @@
 /*	$NetBSD: util.c,v 1.9 2011/02/27 17:33:37 joerg Exp $	*/
 /*	$FreeBSD$	*/
 /*	$OpenBSD: util.c,v 1.39 2010/07/02 22:18:03 tedu Exp $	*/
 
 /*-
  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
  *
  * Copyright (c) 1999 James Howard and Dag-Erling Coïdan Smørgrav
  * Copyright (C) 2008-2010 Gabor Kovesdan <gabor@FreeBSD.org>
  * Copyright (C) 2017 Kyle Evans <kevans@FreeBSD.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <ctype.h>
 #include <err.h>
 #include <errno.h>
 #include <fnmatch.h>
 #include <fts.h>
 #include <libgen.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <wchar.h>
 #include <wctype.h>
 
 #include "grep.h"
 
 static bool	 first_match = true;
 
 /*
  * Match printing context
  */
 struct mprintc {
 	long long	tail;		/* Number of trailing lines to record */
 	int		last_outed;	/* Number of lines since last output */
 	bool		doctx;		/* Printing context? */
 	bool		printmatch;	/* Printing matches? */
 	bool		same_file;	/* Same file as previously printed? */
 };
 
 static void procmatch_match(struct mprintc *mc, struct parsec *pc);
 static void procmatch_nomatch(struct mprintc *mc, struct parsec *pc);
 static bool procmatches(struct mprintc *mc, struct parsec *pc, bool matched);
 #ifdef WITH_INTERNAL_NOSPEC
 static int litexec(const struct pat *pat, const char *string,
     size_t nmatch, regmatch_t pmatch[]);
 #endif
 static bool procline(struct parsec *pc);
 static void printline(struct parsec *pc, int sep);
 static void printline_metadata(struct str *line, int sep);
 
 bool
 file_matching(const char *fname)
 {
 	char *fname_base, *fname_buf;
 	bool ret;
 
 	ret = finclude ? false : true;
 	fname_buf = strdup(fname);
 	if (fname_buf == NULL)
 		err(2, "strdup");
 	fname_base = basename(fname_buf);
 
 	for (unsigned int i = 0; i < fpatterns; ++i) {
 		if (fnmatch(fpattern[i].pat, fname, 0) == 0 ||
 		    fnmatch(fpattern[i].pat, fname_base, 0) == 0)
 			/*
 			 * The last pattern matched wins exclusion/inclusion
 			 * rights, so we can't reasonably bail out early here.
 			 */
 			ret = (fpattern[i].mode != EXCL_PAT);
 	}
 	free(fname_buf);
 	return (ret);
 }
 
 static inline bool
 dir_matching(const char *dname)
 {
 	bool ret;
 
 	ret = dinclude ? false : true;
 
 	for (unsigned int i = 0; i < dpatterns; ++i) {
 		if (dname != NULL && fnmatch(dpattern[i].pat, dname, 0) == 0)
 			/*
 			 * The last pattern matched wins exclusion/inclusion
 			 * rights, so we can't reasonably bail out early here.
 			 */
 			ret = (dpattern[i].mode != EXCL_PAT);
 	}
 	return (ret);
 }
 
 /*
  * Processes a directory when a recursive search is performed with
  * the -R option.  Each appropriate file is passed to procfile().
  */
 bool
 grep_tree(char **argv)
 {
 	FTS *fts;
 	FTSENT *p;
 	int fts_flags;
 	bool matched, ok;
 	const char *wd[] = { ".", NULL };
 
 	matched = false;
 
 	/* This switch effectively initializes 'fts_flags' */
 	switch(linkbehave) {
 	case LINK_EXPLICIT:
 		fts_flags = FTS_COMFOLLOW;
 		break;
 	case LINK_SKIP:
 		fts_flags = FTS_PHYSICAL;
 		break;
 	default:
 		fts_flags = FTS_LOGICAL;
 	}
 
 	fts_flags |= FTS_NOSTAT | FTS_NOCHDIR;
 
 	fts = fts_open((argv[0] == NULL) ?
 	    __DECONST(char * const *, wd) : argv, fts_flags, NULL);
 	if (fts == NULL)
 		err(2, "fts_open");
 	while (errno = 0, (p = fts_read(fts)) != NULL) {
 		switch (p->fts_info) {
 		case FTS_DNR:
 			/* FALLTHROUGH */
 		case FTS_ERR:
 			file_err = true;
 			if(!sflag)
 				warnx("%s: %s", p->fts_path, strerror(p->fts_errno));
 			break;
 		case FTS_D:
 			/* FALLTHROUGH */
 		case FTS_DP:
 			if (dexclude || dinclude)
 				if (!dir_matching(p->fts_name) ||
 				    !dir_matching(p->fts_path))
 					fts_set(fts, p, FTS_SKIP);
 			break;
 		case FTS_DC:
 			/* Print a warning for recursive directory loop */
 			warnx("warning: %s: recursive directory loop",
 			    p->fts_path);
 			break;
 		default:
 			/* Check for file exclusion/inclusion */
 			ok = true;
 			if (fexclude || finclude)
 				ok &= file_matching(p->fts_path);
 
 			if (ok && procfile(p->fts_path))
 				matched = true;
 			break;
 		}
 	}
 	if (errno != 0)
 		err(2, "fts_read");
 
 	fts_close(fts);
 	return (matched);
 }
 
 static void
 procmatch_match(struct mprintc *mc, struct parsec *pc)
 {
 
 	if (mc->doctx) {
 		if (!first_match && (!mc->same_file || mc->last_outed > 0))
 			printf("--\n");
 		if (Bflag > 0)
 			printqueue();
 		mc->tail = Aflag;
 	}
 
 	/* Print the matching line, but only if not quiet/binary */
 	if (mc->printmatch) {
 		printline(pc, ':');
 		while (pc->matchidx >= MAX_MATCHES) {
 			/* Reset matchidx and try again */
 			pc->matchidx = 0;
 			if (procline(pc) == !vflag)
 				printline(pc, ':');
 			else
 				break;
 		}
 		first_match = false;
 		mc->same_file = true;
 		mc->last_outed = 0;
 	}
 }
 
 static void
 procmatch_nomatch(struct mprintc *mc, struct parsec *pc)
 {
 
 	/* Deal with any -A context as needed */
 	if (mc->tail > 0) {
 		grep_printline(&pc->ln, '-');
 		mc->tail--;
 		if (Bflag > 0)
 			clearqueue();
 	} else if (Bflag == 0 || (Bflag > 0 && enqueue(&pc->ln)))
 		/*
 		 * Enqueue non-matching lines for -B context. If we're not
 		 * actually doing -B context or if the enqueue resulted in a
 		 * line being rotated out, then go ahead and increment
 		 * last_outed to signify a gap between context/match.
 		 */
 		++mc->last_outed;
 }
 
 /*
  * Process any matches in the current parsing context, return a boolean
  * indicating whether we should halt any further processing or not. 'true' to
  * continue processing, 'false' to halt.
  */
 static bool
 procmatches(struct mprintc *mc, struct parsec *pc, bool matched)
 {
 
+	if (mflag && mcount <= 0) {
+		/*
+		 * We already hit our match count, but we need to keep dumping
+		 * lines until we've lost our tail.
+		 */
+		grep_printline(&pc->ln, '-');
+		mc->tail--;
+		return (mc->tail != 0);
+	}
+
 	/*
 	 * XXX TODO: This should loop over pc->matches and handle things on a
 	 * line-by-line basis, setting up a `struct str` as needed.
 	 */
 	/* Deal with any -B context or context separators */
 	if (matched) {
 		procmatch_match(mc, pc);
 
 		/* Count the matches if we have a match limit */
 		if (mflag) {
 			/* XXX TODO: Decrement by number of matched lines */
 			mcount -= 1;
 			if (mcount <= 0)
-				return (false);
+				return (mc->tail != 0);
 		}
 	} else if (mc->doctx)
 		procmatch_nomatch(mc, pc);
 
 	return (true);
 }
 
 /*
  * Opens a file and processes it.  Each file is processed line-by-line
  * passing the lines to procline().
  */
 bool
 procfile(const char *fn)
 {
 	struct parsec pc;
 	struct mprintc mc;
 	struct file *f;
 	struct stat sb;
 	mode_t s;
 	int lines;
 	bool line_matched;
 
 	if (strcmp(fn, "-") == 0) {
 		fn = label != NULL ? label : errstr[1];
 		f = grep_open(NULL);
 	} else {
 		if (stat(fn, &sb) == 0) {
 			/* Check if we need to process the file */
 			s = sb.st_mode & S_IFMT;
 			if (dirbehave == DIR_SKIP && s == S_IFDIR)
 				return (false);
 			if (devbehave == DEV_SKIP && (s == S_IFIFO ||
 			    s == S_IFCHR || s == S_IFBLK || s == S_IFSOCK))
 				return (false);
 		}
 		f = grep_open(fn);
 	}
 	if (f == NULL) {
 		file_err = true;
 		if (!sflag)
 			warn("%s", fn);
 		return (false);
 	}
 
 	pc.ln.file = grep_strdup(fn);
 	pc.ln.line_no = 0;
 	pc.ln.len = 0;
 	pc.ln.boff = 0;
 	pc.ln.off = -1;
 	pc.binary = f->binary;
 	pc.cntlines = false;
 	memset(&mc, 0, sizeof(mc));
 	mc.printmatch = true;
 	if ((pc.binary && binbehave == BINFILE_BIN) || cflag || qflag ||
 	    lflag || Lflag)
 		mc.printmatch = false;
 	if (mc.printmatch && (Aflag != 0 || Bflag != 0))
 		mc.doctx = true;
 	if (mc.printmatch && (Aflag != 0 || Bflag != 0 || mflag || nflag))
 		pc.cntlines = true;
 	mcount = mlimit;
 
 	for (lines = 0; lines == 0 || !(lflag || qflag); ) {
 		/*
 		 * XXX TODO: We need to revisit this in a chunking world. We're
 		 * not going to be doing per-line statistics because of the
 		 * overhead involved. procmatches can figure that stuff out as
 		 * needed. */
 		/* Reset per-line statistics */
 		pc.printed = 0;
 		pc.matchidx = 0;
 		pc.lnstart = 0;
 		pc.ln.boff = 0;
 		pc.ln.off += pc.ln.len + 1;
 		/* XXX TODO: Grab a chunk */
 		if ((pc.ln.dat = grep_fgetln(f, &pc)) == NULL ||
 		    pc.ln.len == 0)
 			break;
 
 		if (pc.ln.len > 0 && pc.ln.dat[pc.ln.len - 1] == fileeol)
 			--pc.ln.len;
 		pc.ln.line_no++;
 
 		/* Return if we need to skip a binary file */
 		if (pc.binary && binbehave == BINFILE_SKIP) {
 			grep_close(f);
 			free(pc.ln.file);
 			free(f);
 			return (0);
 		}
 
+		if (mflag && mcount <= 0) {
+			/*
+			 * Short-circuit, already hit match count and now we're
+			 * just picking up any remaining pieces.
+			 */
+			if (!procmatches(&mc, &pc, false))
+				break;
+			continue;
+		}
 		line_matched = procline(&pc) == !vflag;
 		if (line_matched)
 			++lines;
 
 		/* Halt processing if we hit our match limit */
 		if (!procmatches(&mc, &pc, line_matched))
 			break;
 	}
 	if (Bflag > 0)
 		clearqueue();
 	grep_close(f);
 
 	if (cflag) {
 		if (!hflag)
 			printf("%s:", pc.ln.file);
 		printf("%u\n", lines);
 	}
 	if (lflag && !qflag && lines != 0)
 		printf("%s%c", fn, nullflag ? 0 : '\n');
 	if (Lflag && !qflag && lines == 0)
 		printf("%s%c", fn, nullflag ? 0 : '\n');
 	if (lines != 0 && !cflag && !lflag && !Lflag &&
 	    binbehave == BINFILE_BIN && f->binary && !qflag)
 		printf(errstr[7], fn);
 
 	free(pc.ln.file);
 	free(f);
 	return (lines != 0);
 }
 
 #ifdef WITH_INTERNAL_NOSPEC
 /*
  * Internal implementation of literal string search within a string, modeled
  * after regexec(3), for use when the regex(3) implementation doesn't offer
  * either REG_NOSPEC or REG_LITERAL. This does not apply in the default FreeBSD
  * config, but in other scenarios such as building against libgnuregex or on
  * some non-FreeBSD OSes.
  */
 static int
 litexec(const struct pat *pat, const char *string, size_t nmatch,
     regmatch_t pmatch[])
 {
 	char *(*strstr_fn)(const char *, const char *);
 	char *sub, *subject;
 	const char *search;
 	size_t idx, n, ofs, stringlen;
 
 	if (cflags & REG_ICASE)
 		strstr_fn = strcasestr;
 	else
 		strstr_fn = strstr;
 	idx = 0;
 	ofs = pmatch[0].rm_so;
 	stringlen = pmatch[0].rm_eo;
 	if (ofs >= stringlen)
 		return (REG_NOMATCH);
 	subject = strndup(string, stringlen);
 	if (subject == NULL)
 		return (REG_ESPACE);
 	for (n = 0; ofs < stringlen;) {
 		search = (subject + ofs);
 		if ((unsigned long)pat->len > strlen(search))
 			break;
 		sub = strstr_fn(search, pat->pat);
 		/*
 		 * Ignoring the empty string possibility due to context: grep optimizes
 		 * for empty patterns and will never reach this point.
 		 */
 		if (sub == NULL)
 			break;
 		++n;
 		/* Fill in pmatch if necessary */
 		if (nmatch > 0) {
 			pmatch[idx].rm_so = ofs + (sub - search);
 			pmatch[idx].rm_eo = pmatch[idx].rm_so + pat->len;
 			if (++idx == nmatch)
 				break;
 			ofs = pmatch[idx].rm_so + 1;
 		} else
 			/* We only needed to know if we match or not */
 			break;
 	}
 	free(subject);
 	if (n > 0 && nmatch > 0)
 		for (n = idx; n < nmatch; ++n)
 			pmatch[n].rm_so = pmatch[n].rm_eo = -1;
 
 	return (n > 0 ? 0 : REG_NOMATCH);
 }
 #endif /* WITH_INTERNAL_NOSPEC */
 
 #define iswword(x)	(iswalnum((x)) || (x) == L'_')
 
 /*
  * Processes a line comparing it with the specified patterns.  Each pattern
  * is looped to be compared along with the full string, saving each and every
  * match, which is necessary to colorize the output and to count the
  * matches.  The matching lines are passed to printline() to display the
  * appropriate output.
  */
 static bool
 procline(struct parsec *pc)
 {
 	regmatch_t pmatch, lastmatch, chkmatch;
 	wchar_t wbegin, wend;
 	size_t st, nst;
 	unsigned int i;
 	int r = 0, leflags = eflags;
 	size_t startm = 0, matchidx;
 	unsigned int retry;
 	bool lastmatched, matched;
 
 	matchidx = pc->matchidx;
 
 	/* Null pattern shortcuts. */
 	if (matchall) {
 		if (xflag && pc->ln.len == 0) {
 			/* Matches empty lines (-x). */
 			return (true);
 		} else if (!wflag && !xflag) {
 			/* Matches every line (no -w or -x). */
 			return (true);
 		}
 
 		/*
 		 * If we only have the NULL pattern, whether we match or not
 		 * depends on if we got here with -w or -x.  If either is set,
 		 * the answer is no.  If we have other patterns, we'll defer
 		 * to them.
 		 */
 		if (patterns == 0) {
 			return (!(wflag || xflag));
 		}
 	} else if (patterns == 0) {
 		/* Pattern file with no patterns. */
 		return (false);
 	}
 
 	matched = false;
 	st = pc->lnstart;
 	nst = 0;
 	/* Initialize to avoid a false positive warning from GCC. */
 	lastmatch.rm_so = lastmatch.rm_eo = 0;
 
 	/* Loop to process the whole line */
 	while (st <= pc->ln.len) {
 		lastmatched = false;
 		startm = matchidx;
 		retry = 0;
 		if (st > 0 && pc->ln.dat[st - 1] != fileeol)
 			leflags |= REG_NOTBOL;
 		/* Loop to compare with all the patterns */
 		for (i = 0; i < patterns; i++) {
 			pmatch.rm_so = st;
 			pmatch.rm_eo = pc->ln.len;
 #ifdef WITH_INTERNAL_NOSPEC
 			if (grepbehave == GREP_FIXED)
 				r = litexec(&pattern[i], pc->ln.dat, 1, &pmatch);
 			else
 #endif
 			r = regexec(&r_pattern[i], pc->ln.dat, 1, &pmatch,
 			    leflags);
 			if (r != 0)
 				continue;
 			/* Check for full match */
 			if (xflag && (pmatch.rm_so != 0 ||
 			    (size_t)pmatch.rm_eo != pc->ln.len))
 				continue;
 			/* Check for whole word match */
 			if (wflag) {
 				wbegin = wend = L' ';
 				if (pmatch.rm_so != 0 &&
 				    sscanf(&pc->ln.dat[pmatch.rm_so - 1],
 				    "%lc", &wbegin) != 1)
 					r = REG_NOMATCH;
 				else if ((size_t)pmatch.rm_eo !=
 				    pc->ln.len &&
 				    sscanf(&pc->ln.dat[pmatch.rm_eo],
 				    "%lc", &wend) != 1)
 					r = REG_NOMATCH;
 				else if (iswword(wbegin) ||
 				    iswword(wend))
 					r = REG_NOMATCH;
 				/*
 				 * If we're doing whole word matching and we
 				 * matched once, then we should try the pattern
 				 * again after advancing just past the start of
 				 * the earliest match. This allows the pattern
 				 * to  match later on in the line and possibly
 				 * still match a whole word.
 				 */
 				if (r == REG_NOMATCH &&
 				    (retry == pc->lnstart ||
 				    (unsigned int)pmatch.rm_so + 1 < retry))
 					retry = pmatch.rm_so + 1;
 				if (r == REG_NOMATCH)
 					continue;
 			}
 			lastmatched = true;
 			lastmatch = pmatch;
 
 			if (matchidx == 0)
 				matched = true;
 
 			/*
 			 * Replace previous match if the new one is earlier
 			 * and/or longer. This will lead to some amount of
 			 * extra work if -o/--color are specified, but it's
 			 * worth it from a correctness point of view.
 			 */
 			if (matchidx > startm) {
 				chkmatch = pc->matches[matchidx - 1];
 				if (pmatch.rm_so < chkmatch.rm_so ||
 				    (pmatch.rm_so == chkmatch.rm_so &&
 				    (pmatch.rm_eo - pmatch.rm_so) >
 				    (chkmatch.rm_eo - chkmatch.rm_so))) {
 					pc->matches[matchidx - 1] = pmatch;
 					nst = pmatch.rm_eo;
 				}
 			} else {
 				/* Advance as normal if not */
 				pc->matches[matchidx++] = pmatch;
 				nst = pmatch.rm_eo;
 			}
 			/* avoid excessive matching - skip further patterns */
 			if ((color == NULL && !oflag) || qflag || lflag ||
 			    matchidx >= MAX_MATCHES) {
 				pc->lnstart = nst;
 				lastmatched = false;
 				break;
 			}
 		}
 
 		/*
 		 * Advance to just past the start of the earliest match, try
 		 * again just in case we still have a chance to match later in
 		 * the string.
 		 */
 		if (!lastmatched && retry > pc->lnstart) {
 			st = retry;
 			continue;
 		}
 
 		/* XXX TODO: We will need to keep going, since we're chunky */
 		/* One pass if we are not recording matches */
 		if (!wflag && ((color == NULL && !oflag) || qflag || lflag || Lflag))
 			break;
 
 		/* If we didn't have any matches or REG_NOSUB set */
 		if (!lastmatched || (cflags & REG_NOSUB))
 			nst = pc->ln.len;
 
 		if (!lastmatched)
 			/* No matches */
 			break;
 		else if (st == nst && lastmatch.rm_so == lastmatch.rm_eo)
 			/* Zero-length match -- advance one more so we don't get stuck */
 			nst++;
 
 		/* Advance st based on previous matches */
 		st = nst;
 		pc->lnstart = st;
 	}
 
 	/* Reflect the new matchidx in the context */
 	pc->matchidx = matchidx;
 	return matched;
 }
 
 /*
  * Safe malloc() for internal use.
  */
 void *
 grep_malloc(size_t size)
 {
 	void *ptr;
 
 	if ((ptr = malloc(size)) == NULL)
 		err(2, "malloc");
 	return (ptr);
 }
 
 /*
  * Safe calloc() for internal use.
  */
 void *
 grep_calloc(size_t nmemb, size_t size)
 {
 	void *ptr;
 
 	if ((ptr = calloc(nmemb, size)) == NULL)
 		err(2, "calloc");
 	return (ptr);
 }
 
 /*
  * Safe realloc() for internal use.
  */
 void *
 grep_realloc(void *ptr, size_t size)
 {
 
 	if ((ptr = realloc(ptr, size)) == NULL)
 		err(2, "realloc");
 	return (ptr);
 }
 
 /*
  * Safe strdup() for internal use.
  */
 char *
 grep_strdup(const char *str)
 {
 	char *ret;
 
 	if ((ret = strdup(str)) == NULL)
 		err(2, "strdup");
 	return (ret);
 }
 
 /*
  * Print an entire line as-is, there are no inline matches to consider. This is
  * used for printing context.
  */
 void grep_printline(struct str *line, int sep) {
 	printline_metadata(line, sep);
 	fwrite(line->dat, line->len, 1, stdout);
 	putchar(fileeol);
 }
 
 static void
 printline_metadata(struct str *line, int sep)
 {
 	bool printsep;
 
 	printsep = false;
 	if (!hflag) {
 		if (!nullflag) {
 			fputs(line->file, stdout);
 			printsep = true;
 		} else {
 			printf("%s", line->file);
 			putchar(0);
 		}
 	}
 	if (nflag) {
 		if (printsep)
 			putchar(sep);
 		printf("%d", line->line_no);
 		printsep = true;
 	}
 	if (bflag) {
 		if (printsep)
 			putchar(sep);
 		printf("%lld", (long long)(line->off + line->boff));
 		printsep = true;
 	}
 	if (printsep)
 		putchar(sep);
 }
 
 /*
  * Prints a matching line according to the command line options.
  */
 static void
 printline(struct parsec *pc, int sep)
 {
 	size_t a = 0;
 	size_t i, matchidx;
 	regmatch_t match;
 
 	/* If matchall, everything matches but don't actually print for -o */
 	if (oflag && matchall)
 		return;
 
 	matchidx = pc->matchidx;
 
 	/* --color and -o */
 	if ((oflag || color) && matchidx > 0) {
 		/* Only print metadata once per line if --color */
 		if (!oflag && pc->printed == 0)
 			printline_metadata(&pc->ln, sep);
 		for (i = 0; i < matchidx; i++) {
 			match = pc->matches[i];
 			/* Don't output zero length matches */
 			if (match.rm_so == match.rm_eo)
 				continue;
 			/*
 			 * Metadata is printed on a per-line basis, so every
 			 * match gets file metadata with the -o flag.
 			 */
 			if (oflag) {
 				pc->ln.boff = match.rm_so;
 				printline_metadata(&pc->ln, sep);
 			} else
 				fwrite(pc->ln.dat + a, match.rm_so - a, 1,
 				    stdout);
 			if (color)
 				fprintf(stdout, "\33[%sm\33[K", color);
 			fwrite(pc->ln.dat + match.rm_so,
 			    match.rm_eo - match.rm_so, 1, stdout);
 			if (color)
 				fprintf(stdout, "\33[m\33[K");
 			a = match.rm_eo;
 			if (oflag)
 				putchar('\n');
 		}
 		if (!oflag) {
 			if (pc->ln.len - a > 0)
 				fwrite(pc->ln.dat + a, pc->ln.len - a, 1,
 				    stdout);
 			putchar('\n');
 		}
 	} else
 		grep_printline(&pc->ln, sep);
 	pc->printed++;
 }