No OneTemporary
Actions

Size

26 KB

Referenced Files

None

Subscribers

None

View Options

	Index: stable/11/contrib/netbsd-tests/usr.bin/grep/t_grep.sh
	===================================================================
	--- stable/11/contrib/netbsd-tests/usr.bin/grep/t_grep.sh (revision 322582)
	+++ stable/11/contrib/netbsd-tests/usr.bin/grep/t_grep.sh (revision 322583)
	@@ -1,474 +1,498 @@
	# $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_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 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 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
	+}
	# 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 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 wv_combo_break
	atf_add_test_case fgrep_sanity
	atf_add_test_case egrep_sanity
	atf_add_test_case grep_sanity
	# End FreeBSD
	}
	Index: stable/11/usr.bin/grep/util.c
	===================================================================
	--- stable/11/usr.bin/grep/util.c (revision 322582)
	+++ stable/11/usr.bin/grep/util.c (revision 322583)
	@@ -1,567 +1,588 @@
	/* $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 $ */

	/*-
	* Copyright (c) 1999 James Howard and Dag-Erling Coïdan Smørgrav
	* Copyright (C) 2008-2010 Gabor Kovesdan <gabor@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>

	#ifndef WITHOUT_FASTMATCH
	#include "fastmatch.h"
	#endif
	#include "grep.h"

	static int linesqueued;
	static int procline(struct str *l, int);

	static int lasta;
	static bool ctxover;

	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) {
	if (fpattern[i].mode == EXCL_PAT) {
	ret = false;
	break;
	} else
	ret = true;
	}
	}
	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) {
	if (dpattern[i].mode == EXCL_PAT)
	return (false);
	else
	ret = true;
	}
	}
	return (ret);
	}

	/*
	* Processes a directory when a recursive search is performed with
	* the -R option. Each appropriate file is passed to procfile().
	*/
	int
	grep_tree(char **argv)
	{
	FTS *fts;
	FTSENT *p;
	int c, fts_flags;
	bool ok;
	const char *wd[] = { ".", NULL };

	c = fts_flags = 0;

	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 ((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)
	c += procfile(p->fts_path);
	break;
	}
	}

	fts_close(fts);
	return (c);
	}

	/*
	* Opens a file and processes it. Each file is processed line-by-line
	* passing the lines to procline().
	*/
	int
	procfile(const char *fn)
	{
	struct file *f;
	struct stat sb;
	struct str ln;
	mode_t s;
	int c, t;

	mcount = mlimit;

	if (strcmp(fn, "-") == 0) {
	fn = label != NULL ? label : getstr(1);
	f = grep_open(NULL);
	} else {
	if (!stat(fn, &sb)) {
	/* Check if we need to process the file */
	s = sb.st_mode & S_IFMT;
	if (s == S_IFDIR && dirbehave == DIR_SKIP)
	return (0);
	if ((s == S_IFIFO \|\| s == S_IFCHR \|\| s == S_IFBLK
	\|\| s == S_IFSOCK) && devbehave == DEV_SKIP)
	return (0);
	}
	f = grep_open(fn);
	}
	if (f == NULL) {
	file_err = true;
	if (!sflag)
	warn("%s", fn);
	return (0);
	}

	ln.file = grep_malloc(strlen(fn) + 1);
	strcpy(ln.file, fn);
	ln.line_no = 0;
	ln.len = 0;
	ctxover = false;
	linesqueued = 0;
	tail = 0;
	lasta = 0;
	ln.off = -1;

	for (c = 0; c == 0 \|\| !(lflag \|\| qflag); ) {
	ln.off += ln.len + 1;
	if ((ln.dat = grep_fgetln(f, &ln.len)) == NULL \|\| ln.len == 0) {
	if (ln.line_no == 0 && matchall)
	exit(0);
	else
	break;
	}
	if (ln.len > 0 && ln.dat[ln.len - 1] == fileeol)
	--ln.len;
	ln.line_no++;

	/* Return if we need to skip a binary file */
	if (f->binary && binbehave == BINFILE_SKIP) {
	grep_close(f);
	free(ln.file);
	free(f);
	return (0);
	}

	/* Process the file line-by-line, enqueue non-matching lines */
	if ((t = procline(&ln, f->binary)) == 0 && Bflag > 0) {
	/* Except don't enqueue lines that appear in -A ctx */
	if (ln.line_no == 0 \|\| lasta != ln.line_no) {
	/* queue is maxed to Bflag number of lines */
	enqueue(&ln);
	linesqueued++;
	ctxover = false;
	} else {
	/*
	* Indicate to procline() that we have ctx
	* overlap and make sure queue is empty.
	*/
	if (!ctxover)
	clearqueue();
	ctxover = true;
	}
	}
	c += t;
	if (mflag && mcount <= 0)
	break;
	}
	if (Bflag > 0)
	clearqueue();
	grep_close(f);

	if (cflag) {
	if (!hflag)
	printf("%s:", ln.file);
	printf("%u\n", c);
	}
	if (lflag && !qflag && c != 0)
	printf("%s%c", fn, nullflag ? 0 : '\n');
	if (Lflag && !qflag && c == 0)
	printf("%s%c", fn, nullflag ? 0 : '\n');
	if (c && !cflag && !lflag && !Lflag &&
	binbehave == BINFILE_BIN && f->binary && !qflag)
	printf(getstr(8), fn);

	free(ln.file);
	free(f);
	return (c);
	}

	#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 int
	procline(struct str *l, int nottext)
	{
	regmatch_t matches[MAX_LINE_MATCHES];
	regmatch_t pmatch, lastmatch;
	size_t st = 0, nst = 0;
	unsigned int i;
	int c = 0, m = 0, r = 0, lastmatches = 0, leflags = eflags;
	int startm = 0;
	+ int retry;

	/* Initialize to avoid a false positive warning from GCC. */
	lastmatch.rm_so = lastmatch.rm_eo = 0;

	/* Loop to process the whole line */
	while (st <= l->len) {
	lastmatches = 0;
	startm = m;
	+ retry = 0;
	if (st > 0)
	leflags \|= REG_NOTBOL;
	/* Loop to compare with all the patterns */
	for (i = 0; i < patterns; i++) {
	pmatch.rm_so = st;
	pmatch.rm_eo = l->len;
	#ifndef WITHOUT_FASTMATCH
	if (fg_pattern[i].pattern)
	r = fastexec(&fg_pattern[i],
	l->dat, 1, &pmatch, leflags);
	else
	#endif
	r = regexec(&r_pattern[i], l->dat, 1,
	&pmatch, leflags);
	r = (r == 0) ? 0 : REG_NOMATCH;
	if (r == REG_NOMATCH)
	continue;
	/* Check for full match */
	if (r == 0 && xflag)
	if (pmatch.rm_so != 0 \|\|
	(size_t)pmatch.rm_eo != l->len)
	r = REG_NOMATCH;
	/* Check for whole word match */
	#ifndef WITHOUT_FASTMATCH
	if (r == 0 && (wflag \|\| fg_pattern[i].word)) {
	#else
	if (r == 0 && wflag) {
	#endif
	wchar_t wbegin, wend;

	wbegin = wend = L' ';
	if (pmatch.rm_so != 0 &&
	sscanf(&l->dat[pmatch.rm_so - 1],
	"%lc", &wbegin) != 1)
	r = REG_NOMATCH;
	else if ((size_t)pmatch.rm_eo !=
	l->len &&
	sscanf(&l->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 == 0 \|\| pmatch.rm_so + 1 < retry))
	+ retry = pmatch.rm_so + 1;
	}
	if (r == 0) {
	lastmatches++;
	lastmatch = pmatch;
	if (m == 0)
	c++;

	if (m < MAX_LINE_MATCHES) {
	/* Replace previous match if the new one is earlier and/or longer */
	if (m > startm) {
	if (pmatch.rm_so < matches[m-1].rm_so \|\|
	(pmatch.rm_so == matches[m-1].rm_so && (pmatch.rm_eo - pmatch.rm_so) > (matches[m-1].rm_eo - matches[m-1].rm_so))) {
	matches[m-1] = pmatch;
	nst = pmatch.rm_eo;
	}
	} else {
	/* Advance as normal if not */
	matches[m++] = pmatch;
	nst = pmatch.rm_eo;
	}
	}

	/* matches - skip further patterns */
	if ((color == NULL && !oflag) \|\|
	qflag \|\| lflag)
	break;
	}
	}

	- if (vflag) {
	- c = !c;
	- 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 (lastmatches == 0 && retry > 0) {
	+ st = retry;
	+ continue;
	}

	/* 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 (lastmatches == 0 \|\| (cflags & REG_NOSUB))
	nst = l->len;

	if (lastmatches == 0)
	/* 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;
	}

	+
	+ if (vflag)
	+ c = !c;

	/* Count the matches if we have a match limit */
	if (mflag)
	mcount -= c;

	if (c && binbehave == BINFILE_BIN && nottext)
	return (c); /* Binary file */

	/* Dealing with the context */
	if ((tail \|\| c) && !cflag && !qflag && !lflag && !Lflag) {
	if (c) {
	if (!first && !prev && !tail && (Bflag \|\| Aflag) &&
	!ctxover)
	printf("--\n");
	tail = Aflag;
	if (Bflag > 0) {
	printqueue();
	ctxover = false;
	}
	linesqueued = 0;
	printline(l, ':', matches, m);
	} else {
	/* Print -A lines following matches */
	lasta = l->line_no;
	printline(l, '-', matches, m);
	tail--;
	}
	}

	if (c) {
	prev = true;
	first = false;
	} else
	prev = false;

	return (c);
	}

	/*
	* 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);
	}

	/*
	* Prints a matching line according to the command line options.
	*/
	void
	printline(struct str line, int sep, regmatch_t matches, int m)
	{
	size_t a = 0;
	int i, n = 0;

	/* If matchall, everything matches but don't actually print for -o */
	if (oflag && matchall)
	return;

	if (!hflag) {
	if (!nullflag) {
	fputs(line->file, stdout);
	++n;
	} else {
	printf("%s", line->file);
	putchar(0);
	}
	}
	if (nflag) {
	if (n > 0)
	putchar(sep);
	printf("%d", line->line_no);
	++n;
	}
	if (bflag) {
	if (n > 0)
	putchar(sep);
	printf("%lld", (long long)line->off);
	++n;
	}
	if (n)
	putchar(sep);
	/* --color and -o */
	if ((oflag \|\| color) && m > 0) {
	for (i = 0; i < m; i++) {
	/* Don't output zero length matches */
	if (matches[i].rm_so == matches[i].rm_eo)
	continue;
	if (!oflag)
	fwrite(line->dat + a, matches[i].rm_so - a, 1,
	stdout);
	if (color)
	fprintf(stdout, "\33[%sm\33[K", color);

	fwrite(line->dat + matches[i].rm_so,
	matches[i].rm_eo - matches[i].rm_so, 1,
	stdout);
	if (color)
	fprintf(stdout, "\33[m\33[K");
	a = matches[i].rm_eo;
	if (oflag)
	putchar('\n');
	}
	if (!oflag) {
	if (line->len - a > 0)
	fwrite(line->dat + a, line->len - a, 1, stdout);
	putchar('\n');
	}
	} else {
	fwrite(line->dat, line->len, 1, stdout);
	putchar(fileeol);
	}
	}
	Index: stable/11
	===================================================================
	--- stable/11 (revision 322582)
	+++ stable/11 (revision 322583)

	Property changes on: stable/11
	___________________________________________________________________
	Modified: svn:mergeinfo
	## -0,0 +0,1 ##
	Merged /head:r317665

File Metadata

Mime Type: text/x-diff
Expires: Sun, Dec 21, 4:00 PM (1 d, 3 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 27098619
Default Alt Text: (26 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions