Submit #2966 » freebsd_grep.patch
| usr.bin/Makefile | ||
|---|---|---|
|
getconf \
|
||
|
getent \
|
||
|
getopt \
|
||
|
grep \
|
||
|
gzip \
|
||
|
head \
|
||
|
hexdump \
|
||
| usr.bin/grep/Makefile | ||
|---|---|---|
|
.include <bsd.init.mk>
|
||
|
PROG= grep
|
||
|
MK_LZMA_SUPPORT?="yes"
|
||
|
MK_BZIP2_SUPPORT?="yes"
|
||
|
CFLAGS+= -I${.CURDIR}
|
||
|
SRCS= file.c grep.c queue.c util.c
|
||
|
# Extra files ported backported form some regex improvements
|
||
|
.PATH: ${.CURDIR}/regex
|
||
|
SRCS+= fastmatch.c hashtable.c tre-compile.c tre-fastmatch.c xmalloc.c
|
||
|
CFLAGS+=-I${.CURDIR}/regex
|
||
|
CFLAGS.gcc+= --param max-inline-insns-single=500
|
||
|
LINKS= ${BINDIR}/grep ${BINDIR}/egrep \
|
||
|
${BINDIR}/grep ${BINDIR}/fgrep \
|
||
|
${BINDIR}/grep ${BINDIR}/zgrep \
|
||
|
${BINDIR}/grep ${BINDIR}/zegrep \
|
||
|
${BINDIR}/grep ${BINDIR}/zfgrep
|
||
|
MLINKS= grep.1 egrep.1 \
|
||
|
grep.1 fgrep.1 \
|
||
|
grep.1 zgrep.1 \
|
||
|
grep.1 zegrep.1 \
|
||
|
grep.1 zfgrep.1
|
||
|
LDADD= -lz
|
||
|
DPADD= ${LIBZ}
|
||
|
.if ${MK_LZMA_SUPPORT} != "no"
|
||
|
LDADD+= -llzma
|
||
|
DPADD+= ${LIBZMA}
|
||
|
LINKS+= ${BINDIR}/${PROG} ${BINDIR}/xzgrep \
|
||
|
${BINDIR}/${PROG} ${BINDIR}/xzegrep \
|
||
|
${BINDIR}/${PROG} ${BINDIR}/xzfgrep \
|
||
|
${BINDIR}/${PROG} ${BINDIR}/lzgrep \
|
||
|
${BINDIR}/${PROG} ${BINDIR}/lzegrep \
|
||
|
${BINDIR}/${PROG} ${BINDIR}/lzfgrep
|
||
|
MLINKS+= grep.1 xzgrep.1 \
|
||
|
grep.1 xzegrep.1 \
|
||
|
grep.1 xzfgrep.1 \
|
||
|
grep.1 lzgrep.1 \
|
||
|
grep.1 lzegrep.1 \
|
||
|
grep.1 lzfgrep.1
|
||
|
.else
|
||
|
CFLAGS+= -DWITHOUT_LZMA
|
||
|
.endif
|
||
|
.if ${MK_BZIP2_SUPPORT} != "no"
|
||
|
LDADD+= -lbz2
|
||
|
DPADD+= ${LIBBZ2}
|
||
|
LINKS+= ${BINDIR}/grep ${BINDIR}/bzgrep \
|
||
|
${BINDIR}/grep ${BINDIR}/bzegrep \
|
||
|
${BINDIR}/grep ${BINDIR}/bzfgrep
|
||
|
MLINKS+= grep.1 bzgrep.1 \
|
||
|
grep.1 bzegrep.1 \
|
||
|
grep.1 bzfgrep.1
|
||
|
.else
|
||
|
CFLAGS+= -DWITHOUT_BZIP2
|
||
|
.endif
|
||
|
# .if ${MK_GNU_GREP_COMPAT} != "no"
|
||
|
#CFLAGS+= -I${DESTDIR}/usr/include/gnu
|
||
|
#LIBADD+= gnuregex
|
||
|
# .endif
|
||
|
.ifdef NLS
|
||
|
.include "${.CURDIR}/nls/Makefile.inc"
|
||
|
.else
|
||
|
CFLAGS+= -DWITHOUT_NLS
|
||
|
.endif
|
||
|
.include <bsd.prog.mk>
|
||
| usr.bin/grep/file.c | ||
|---|---|---|
|
/* $NetBSD: file.c,v 1.5 2011/02/16 18:35:39 joerg Exp $ */
|
||
|
/* $FreeBSD: stable/11/usr.bin/grep/file.c 277463 2015-01-21 01:11:37Z delphij $ */
|
||
|
/* $OpenBSD: file.c,v 1.11 2010/07/02 20:48:48 nicm Exp $ */
|
||
|
/*-
|
||
|
* Copyright (c) 1999 James Howard and Dag-Erling Coïdan Smørgrav
|
||
|
* Copyright (C) 2008-2010 Gabor Kovesdan <gabor@FreeBSD.org>
|
||
|
* Copyright (C) 2010 Dimitry Andric <dimitry@andric.com>
|
||
|
* 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: stable/11/usr.bin/grep/file.c 277463 2015-01-21 01:11:37Z delphij $");
|
||
|
#include <sys/param.h>
|
||
|
#include <sys/mman.h>
|
||
|
#include <sys/stat.h>
|
||
|
#include <sys/types.h>
|
||
|
#include <err.h>
|
||
|
#include <errno.h>
|
||
|
#include <fcntl.h>
|
||
|
#include <stddef.h>
|
||
|
#include <stdlib.h>
|
||
|
#include <string.h>
|
||
|
#include <unistd.h>
|
||
|
#include <wchar.h>
|
||
|
#include <wctype.h>
|
||
|
#include <zlib.h>
|
||
|
#ifndef WITHOUT_LZMA
|
||
|
#include <lzma.h>
|
||
|
#endif
|
||
|
#ifndef WITHOUT_BZIP2
|
||
|
#include <bzlib.h>
|
||
|
#endif
|
||
|
#include "grep.h"
|
||
|
#define MAXBUFSIZ (32 * 1024)
|
||
|
#define LNBUFBUMP 80
|
||
|
static gzFile gzbufdesc;
|
||
|
#ifndef WITHOUT_LZMA
|
||
|
static lzma_stream lstrm = LZMA_STREAM_INIT;
|
||
|
static lzma_action laction;
|
||
|
static uint8_t lin_buf[MAXBUFSIZ];
|
||
|
#endif
|
||
|
#ifndef WITHOUT_BZIP2
|
||
|
static BZFILE* bzbufdesc;
|
||
|
#endif
|
||
|
static unsigned char *buffer;
|
||
|
static unsigned char *bufpos;
|
||
|
static size_t bufrem;
|
||
|
static size_t fsiz;
|
||
|
static unsigned char *lnbuf;
|
||
|
static size_t lnbuflen;
|
||
|
static inline int
|
||
|
grep_refill(struct file *f)
|
||
|
{
|
||
|
ssize_t nr;
|
||
|
if (filebehave == FILE_MMAP)
|
||
|
return (0);
|
||
|
bufpos = buffer;
|
||
|
bufrem = 0;
|
||
|
if (filebehave == FILE_GZIP) {
|
||
|
nr = gzread(gzbufdesc, buffer, MAXBUFSIZ);
|
||
|
#ifndef WITHOUT_BZIP2
|
||
|
} else if (filebehave == FILE_BZIP && bzbufdesc != NULL) {
|
||
|
int bzerr;
|
||
|
nr = BZ2_bzRead(&bzerr, bzbufdesc, buffer, MAXBUFSIZ);
|
||
|
switch (bzerr) {
|
||
|
case BZ_OK:
|
||
|
case BZ_STREAM_END:
|
||
|
/* No problem, nr will be okay */
|
||
|
break;
|
||
|
case BZ_DATA_ERROR_MAGIC:
|
||
|
/*
|
||
|
* As opposed to gzread(), which simply returns the
|
||
|
* plain file data, if it is not in the correct
|
||
|
* compressed format, BZ2_bzRead() instead aborts.
|
||
|
*
|
||
|
* So, just restart at the beginning of the file again,
|
||
|
* and use plain reads from now on.
|
||
|
*/
|
||
|
BZ2_bzReadClose(&bzerr, bzbufdesc);
|
||
|
bzbufdesc = NULL;
|
||
|
if (lseek(f->fd, 0, SEEK_SET) == -1)
|
||
|
return (-1);
|
||
|
nr = read(f->fd, buffer, MAXBUFSIZ);
|
||
|
break;
|
||
|
default:
|
||
|
/* Make sure we exit with an error */
|
||
|
nr = -1;
|
||
|
}
|
||
|
#endif
|
||
|
#ifndef WITHOUT_LZMA
|
||
|
} else if ((filebehave == FILE_XZ) || (filebehave == FILE_LZMA)) {
|
||
|
lzma_ret ret;
|
||
|
lstrm.next_out = buffer;
|
||
|
do {
|
||
|
if (lstrm.avail_in == 0) {
|
||
|
lstrm.next_in = lin_buf;
|
||
|
nr = read(f->fd, lin_buf, MAXBUFSIZ);
|
||
|
if (nr < 0)
|
||
|
return (-1);
|
||
|
else if (nr == 0)
|
||
|
laction = LZMA_FINISH;
|
||
|
lstrm.avail_in = nr;
|
||
|
}
|
||
|
ret = lzma_code(&lstrm, laction);
|
||
|
if (ret != LZMA_OK && ret != LZMA_STREAM_END)
|
||
|
return (-1);
|
||
|
if (lstrm.avail_out == 0 || ret == LZMA_STREAM_END) {
|
||
|
bufrem = MAXBUFSIZ - lstrm.avail_out;
|
||
|
lstrm.next_out = buffer;
|
||
|
lstrm.avail_out = MAXBUFSIZ;
|
||
|
}
|
||
|
} while (bufrem == 0 && ret != LZMA_STREAM_END);
|
||
|
return (0);
|
||
|
#endif /* WITHOUT_LZMA */
|
||
|
} else
|
||
|
nr = read(f->fd, buffer, MAXBUFSIZ);
|
||
|
if (nr < 0)
|
||
|
return (-1);
|
||
|
bufrem = nr;
|
||
|
return (0);
|
||
|
}
|
||
|
static inline int
|
||
|
grep_lnbufgrow(size_t newlen)
|
||
|
{
|
||
|
if (lnbuflen < newlen) {
|
||
|
lnbuf = grep_realloc(lnbuf, newlen);
|
||
|
lnbuflen = newlen;
|
||
|
}
|
||
|
return (0);
|
||
|
}
|
||
|
char *
|
||
|
grep_fgetln(struct file *f, size_t *lenp)
|
||
|
{
|
||
|
unsigned char *p;
|
||
|
char *ret;
|
||
|
size_t len;
|
||
|
size_t off;
|
||
|
ptrdiff_t diff;
|
||
|
/* Fill the buffer, if necessary */
|
||
|
if (bufrem == 0 && grep_refill(f) != 0)
|
||
|
goto error;
|
||
|
if (bufrem == 0) {
|
||
|
/* Return zero length to indicate EOF */
|
||
|
*lenp = 0;
|
||
|
return (bufpos);
|
||
|
}
|
||
|
/* Look for a newline in the remaining part of the buffer */
|
||
|
if ((p = memchr(bufpos, '\n', bufrem)) != NULL) {
|
||
|
++p; /* advance over newline */
|
||
|
ret = bufpos;
|
||
|
len = p - bufpos;
|
||
|
bufrem -= len;
|
||
|
bufpos = p;
|
||
|
*lenp = len;
|
||
|
return (ret);
|
||
|
}
|
||
|
/* We have to copy the current buffered data to the line buffer */
|
||
|
for (len = bufrem, off = 0; ; len += bufrem) {
|
||
|
/* Make sure there is room for more data */
|
||
|
if (grep_lnbufgrow(len + LNBUFBUMP))
|
||
|
goto error;
|
||
|
memcpy(lnbuf + off, bufpos, len - off);
|
||
|
off = len;
|
||
|
if (grep_refill(f) != 0)
|
||
|
goto error;
|
||
|
if (bufrem == 0)
|
||
|
/* EOF: return partial line */
|
||
|
break;
|
||
|
if ((p = memchr(bufpos, '\n', bufrem)) == NULL)
|
||
|
continue;
|
||
|
/* got it: finish up the line (like code above) */
|
||
|
++p;
|
||
|
diff = p - bufpos;
|
||
|
len += diff;
|
||
|
if (grep_lnbufgrow(len))
|
||
|
goto error;
|
||
|
memcpy(lnbuf + off, bufpos, diff);
|
||
|
bufrem -= diff;
|
||
|
bufpos = p;
|
||
|
break;
|
||
|
}
|
||
|
*lenp = len;
|
||
|
return (lnbuf);
|
||
|
error:
|
||
|
*lenp = 0;
|
||
|
return (NULL);
|
||
|
}
|
||
|
/*
|
||
|
* Opens a file for processing.
|
||
|
*/
|
||
|
struct file *
|
||
|
grep_open(const char *path)
|
||
|
{
|
||
|
struct file *f;
|
||
|
f = grep_malloc(sizeof *f);
|
||
|
memset(f, 0, sizeof *f);
|
||
|
if (path == NULL) {
|
||
|
/* Processing stdin implies --line-buffered. */
|
||
|
lbflag = true;
|
||
|
f->fd = STDIN_FILENO;
|
||
|
} else if ((f->fd = open(path, O_RDONLY)) == -1)
|
||
|
goto error1;
|
||
|
if (filebehave == FILE_MMAP) {
|
||
|
struct stat st;
|
||
|
if ((fstat(f->fd, &st) == -1) || (st.st_size > OFF_MAX) ||
|
||
|
(!S_ISREG(st.st_mode)))
|
||
|
filebehave = FILE_STDIO;
|
||
|
else {
|
||
|
int flags = MAP_PRIVATE | MAP_NOCORE | MAP_NOSYNC;
|
||
|
#ifdef MAP_PREFAULT_READ
|
||
|
flags |= MAP_PREFAULT_READ;
|
||
|
#endif
|
||
|
fsiz = st.st_size;
|
||
|
buffer = mmap(NULL, fsiz, PROT_READ, flags,
|
||
|
f->fd, (off_t)0);
|
||
|
if (buffer == MAP_FAILED)
|
||
|
filebehave = FILE_STDIO;
|
||
|
else {
|
||
|
bufrem = st.st_size;
|
||
|
bufpos = buffer;
|
||
|
madvise(buffer, st.st_size, MADV_SEQUENTIAL);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if ((buffer == NULL) || (buffer == MAP_FAILED))
|
||
|
buffer = grep_malloc(MAXBUFSIZ);
|
||
|
if (filebehave == FILE_GZIP &&
|
||
|
(gzbufdesc = gzdopen(f->fd, "r")) == NULL)
|
||
|
goto error2;
|
||
|
#ifndef WITHOUT_BZIP2
|
||
|
if (filebehave == FILE_BZIP &&
|
||
|
(bzbufdesc = BZ2_bzdopen(f->fd, "r")) == NULL)
|
||
|
goto error2;
|
||
|
#endif
|
||
|
#ifndef WITHOUT_LZMA
|
||
|
else if ((filebehave == FILE_XZ) || (filebehave == FILE_LZMA)) {
|
||
|
lzma_ret ret;
|
||
|
ret = (filebehave == FILE_XZ) ?
|
||
|
lzma_stream_decoder(&lstrm, UINT64_MAX,
|
||
|
LZMA_CONCATENATED) :
|
||
|
lzma_alone_decoder(&lstrm, UINT64_MAX);
|
||
|
if (ret != LZMA_OK)
|
||
|
goto error2;
|
||
|
lstrm.avail_in = 0;
|
||
|
lstrm.avail_out = MAXBUFSIZ;
|
||
|
laction = LZMA_RUN;
|
||
|
}
|
||
|
#endif
|
||
|
/* Fill read buffer, also catches errors early */
|
||
|
if (bufrem == 0 && grep_refill(f) != 0)
|
||
|
goto error2;
|
||
|
/* Check for binary stuff, if necessary */
|
||
|
if (binbehave != BINFILE_TEXT && memchr(bufpos, '\0', bufrem) != NULL)
|
||
|
f->binary = true;
|
||
|
return (f);
|
||
|
error2:
|
||
|
close(f->fd);
|
||
|
error1:
|
||
|
free(f);
|
||
|
return (NULL);
|
||
|
}
|
||
|
/*
|
||
|
* Closes a file.
|
||
|
*/
|
||
|
void
|
||
|
grep_close(struct file *f)
|
||
|
{
|
||
|
close(f->fd);
|
||
|
/* Reset read buffer and line buffer */
|
||
|
if (filebehave == FILE_MMAP) {
|
||
|
munmap(buffer, fsiz);
|
||
|
buffer = NULL;
|
||
|
}
|
||
|
bufpos = buffer;
|
||
|
bufrem = 0;
|
||
|
free(lnbuf);
|
||
|
lnbuf = NULL;
|
||
|
lnbuflen = 0;
|
||
|
}
|
||
| usr.bin/grep/grep.1 | ||
|---|---|---|
|
.\" $NetBSD: grep.1,v 1.2 2011/02/16 01:31:33 joerg Exp $
|
||
|
.\" $FreeBSD: stable/11/usr.bin/grep/grep.1 261634 2014-02-08 13:37:02Z joel $
|
||
|
.\" $OpenBSD: grep.1,v 1.38 2010/04/05 06:30:59 jmc Exp $
|
||
|
.\" Copyright (c) 1980, 1990, 1993
|
||
|
.\" The Regents of the University of California. 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.
|
||
|
.\" 3. Neither the name of the University nor the names of its contributors
|
||
|
.\" may be used to endorse or promote products derived from this software
|
||
|
.\" without specific prior written permission.
|
||
|
.\"
|
||
|
.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||
|
.\"
|
||
|
.\" @(#)grep.1 8.3 (Berkeley) 4/18/94
|
||
|
.\"
|
||
|
.Dd July 28, 2010
|
||
|
.Dt GREP 1
|
||
|
.Os
|
||
|
.Sh NAME
|
||
|
.Nm grep , egrep , fgrep ,
|
||
|
.Nm zgrep , zegrep , zfgrep
|
||
|
.Nd file pattern searcher
|
||
|
.Sh SYNOPSIS
|
||
|
.Nm grep
|
||
|
.Bk -words
|
||
|
.Op Fl abcdDEFGHhIiJLlmnOopqRSsUVvwxZ
|
||
|
.Op Fl A Ar num
|
||
|
.Op Fl B Ar num
|
||
|
.Op Fl C Ns Op Ar num
|
||
|
.Op Fl e Ar pattern
|
||
|
.Op Fl f Ar file
|
||
|
.Op Fl Fl binary-files Ns = Ns Ar value
|
||
|
.Op Fl Fl color Ns Op = Ns Ar when
|
||
|
.Op Fl Fl colour Ns Op = Ns Ar when
|
||
|
.Op Fl Fl context Ns Op = Ns Ar num
|
||
|
.Op Fl Fl label
|
||
|
.Op Fl Fl line-buffered
|
||
|
.Op Fl Fl null
|
||
|
.Op Ar pattern
|
||
|
.Op Ar
|
||
|
.Ek
|
||
|
.Sh DESCRIPTION
|
||
|
The
|
||
|
.Nm grep
|
||
|
utility searches any given input files,
|
||
|
selecting lines that match one or more patterns.
|
||
|
By default, a pattern matches an input line if the regular expression
|
||
|
(RE) in the pattern matches the input line
|
||
|
without its trailing newline.
|
||
|
An empty expression matches every line.
|
||
|
Each input line that matches at least one of the patterns is written
|
||
|
to the standard output.
|
||
|
.Pp
|
||
|
.Nm grep
|
||
|
is used for simple patterns and
|
||
|
basic regular expressions
|
||
|
.Pq BREs ;
|
||
|
.Nm egrep
|
||
|
can handle extended regular expressions
|
||
|
.Pq EREs .
|
||
|
See
|
||
|
.Xr re_format 7
|
||
|
for more information on regular expressions.
|
||
|
.Nm fgrep
|
||
|
is quicker than both
|
||
|
.Nm grep
|
||
|
and
|
||
|
.Nm egrep ,
|
||
|
but can only handle fixed patterns
|
||
|
(i.e. it does not interpret regular expressions).
|
||
|
Patterns may consist of one or more lines,
|
||
|
allowing any of the pattern lines to match a portion of the input.
|
||
|
.Pp
|
||
|
.Nm zgrep ,
|
||
|
.Nm zegrep ,
|
||
|
and
|
||
|
.Nm zfgrep
|
||
|
act like
|
||
|
.Nm grep ,
|
||
|
.Nm egrep ,
|
||
|
and
|
||
|
.Nm fgrep ,
|
||
|
respectively, but accept input files compressed with the
|
||
|
.Xr compress 1
|
||
|
or
|
||
|
.Xr gzip 1
|
||
|
compression utilities.
|
||
|
.Pp
|
||
|
The following options are available:
|
||
|
.Bl -tag -width indent
|
||
|
.It Fl A Ar num , Fl Fl after-context Ns = Ns Ar num
|
||
|
Print
|
||
|
.Ar num
|
||
|
lines of trailing context after each match.
|
||
|
See also the
|
||
|
.Fl B
|
||
|
and
|
||
|
.Fl C
|
||
|
options.
|
||
|
.It Fl a , Fl Fl text
|
||
|
Treat all files as ASCII text.
|
||
|
Normally
|
||
|
.Nm
|
||
|
will simply print
|
||
|
.Dq Binary file ... matches
|
||
|
if files contain binary characters.
|
||
|
Use of this option forces
|
||
|
.Nm
|
||
|
to output lines matching the specified pattern.
|
||
|
.It Fl B Ar num , Fl Fl before-context Ns = Ns Ar num
|
||
|
Print
|
||
|
.Ar num
|
||
|
lines of leading context before each match.
|
||
|
See also the
|
||
|
.Fl A
|
||
|
and
|
||
|
.Fl C
|
||
|
options.
|
||
|
.It Fl b , Fl Fl byte-offset
|
||
|
The offset in bytes of a matched pattern is
|
||
|
displayed in front of the respective matched line.
|
||
|
.It Fl C Ns Op Ar num , Fl Fl context Ns = Ns Ar num
|
||
|
Print
|
||
|
.Ar num
|
||
|
lines of leading and trailing context surrounding each match.
|
||
|
The default is 2 and is equivalent to
|
||
|
.Fl A
|
||
|
.Ar 2
|
||
|
.Fl B
|
||
|
.Ar 2 .
|
||
|
Note:
|
||
|
no whitespace may be given between the option and its argument.
|
||
|
.It Fl c , Fl Fl count
|
||
|
Only a count of selected lines is written to standard output.
|
||
|
.It Fl Fl colour Ns = Ns Op Ar when , Fl Fl color Ns = Ns Op Ar when
|
||
|
Mark up the matching text with the expression stored in
|
||
|
.Ev GREP_COLOR
|
||
|
environment variable.
|
||
|
The possible values of when can be `never', `always' or `auto'.
|
||
|
.It Fl D Ar action , Fl Fl devices Ns = Ns Ar action
|
||
|
Specify the demanded action for devices, FIFOs and sockets.
|
||
|
The default action is `read', which means, that they are read
|
||
|
as if they were normal files.
|
||
|
If the action is set to `skip', devices will be silently skipped.
|
||
|
.It Fl d Ar action , Fl Fl directories Ns = Ns Ar action
|
||
|
Specify the demanded action for directories.
|
||
|
It is `read' by default, which means that the directories
|
||
|
are read in the same manner as normal files.
|
||
|
Other possible values are `skip' to silently ignore the
|
||
|
directories, and `recurse' to read them recursively, which
|
||
|
has the same effect as the
|
||
|
.Fl R
|
||
|
and
|
||
|
.Fl r
|
||
|
option.
|
||
|
.It Fl E , Fl Fl extended-regexp
|
||
|
Interpret
|
||
|
.Ar pattern
|
||
|
as an extended regular expression
|
||
|
(i.e. force
|
||
|
.Nm grep
|
||
|
to behave as
|
||
|
.Nm egrep ) .
|
||
|
.It Fl e Ar pattern , Fl Fl regexp Ns = Ns Ar pattern
|
||
|
Specify a pattern used during the search of the input:
|
||
|
an input line is selected if it matches any of the specified patterns.
|
||
|
This option is most useful when multiple
|
||
|
.Fl e
|
||
|
options are used to specify multiple patterns,
|
||
|
or when a pattern begins with a dash
|
||
|
.Pq Sq - .
|
||
|
.It Fl Fl exclude
|
||
|
If specified, it excludes files matching the given
|
||
|
filename pattern from the search.
|
||
|
Note that
|
||
|
.Fl Fl exclude
|
||
|
patterns take priority over
|
||
|
.Fl Fl include
|
||
|
patterns, and if no
|
||
|
.Fl Fl include
|
||
|
pattern is specified, all files are searched that are
|
||
|
not excluded.
|
||
|
Patterns are matched to the full path specified,
|
||
|
not only to the filename component.
|
||
|
.It Fl Fl exclude-dir
|
||
|
If
|
||
|
.Fl R
|
||
|
is specified, it excludes directories matching the
|
||
|
given filename pattern from the search.
|
||
|
Note that
|
||
|
.Fl Fl exclude-dir
|
||
|
patterns take priority over
|
||
|
.Fl Fl include-dir
|
||
|
patterns, and if no
|
||
|
.Fl Fl include-dir
|
||
|
pattern is specified, all directories are searched that are
|
||
|
not excluded.
|
||
|
.It Fl F , Fl Fl fixed-strings
|
||
|
Interpret
|
||
|
.Ar pattern
|
||
|
as a set of fixed strings
|
||
|
(i.e. force
|
||
|
.Nm grep
|
||
|
to behave as
|
||
|
.Nm fgrep ) .
|
||
|
.It Fl f Ar file , Fl Fl file Ns = Ns Ar file
|
||
|
Read one or more newline separated patterns from
|
||
|
.Ar file .
|
||
|
Empty pattern lines match every input line.
|
||
|
Newlines are not considered part of a pattern.
|
||
|
If
|
||
|
.Ar file
|
||
|
is empty, nothing is matched.
|
||
|
.It Fl G , Fl Fl basic-regexp
|
||
|
Interpret
|
||
|
.Ar pattern
|
||
|
as a basic regular expression
|
||
|
(i.e. force
|
||
|
.Nm grep
|
||
|
to behave as traditional
|
||
|
.Nm grep ) .
|
||
|
.It Fl H
|
||
|
Always print filename headers with output lines.
|
||
|
.It Fl h , Fl Fl no-filename
|
||
|
Never print filename headers
|
||
|
.Pq i.e. filenames
|
||
|
with output lines.
|
||
|
.It Fl Fl help
|
||
|
Print a brief help message.
|
||
|
.It Fl I
|
||
|
Ignore binary files.
|
||
|
This option is equivalent to
|
||
|
.Fl Fl binary-file Ns = Ns Ar without-match
|
||
|
option.
|
||
|
.It Fl i , Fl Fl ignore-case
|
||
|
Perform case insensitive matching.
|
||
|
By default,
|
||
|
.Nm grep
|
||
|
is case sensitive.
|
||
|
.It Fl Fl include
|
||
|
If specified, only files matching the
|
||
|
given filename pattern are searched.
|
||
|
Note that
|
||
|
.Fl Fl exclude
|
||
|
patterns take priority over
|
||
|
.Fl Fl include
|
||
|
patterns.
|
||
|
Patterns are matched to the full path specified,
|
||
|
not only to the filename component.
|
||
|
.It Fl Fl include-dir
|
||
|
If
|
||
|
.Fl R
|
||
|
is specified, only directories matching the
|
||
|
given filename pattern are searched.
|
||
|
Note that
|
||
|
.Fl Fl exclude-dir
|
||
|
patterns take priority over
|
||
|
.Fl Fl include-dir
|
||
|
patterns.
|
||
|
.It Fl J, Fl Fl bz2decompress
|
||
|
Decompress the
|
||
|
.Xr bzip2 1
|
||
|
compressed file before looking for the text.
|
||
|
.It Fl L , Fl Fl files-without-match
|
||
|
Only the names of files not containing selected lines are written to
|
||
|
standard output.
|
||
|
Pathnames are listed once per file searched.
|
||
|
If the standard input is searched, the string
|
||
|
.Dq (standard input)
|
||
|
is written.
|
||
|
.It Fl l , Fl Fl files-with-matches
|
||
|
Only the names of files containing selected lines are written to
|
||
|
standard output.
|
||
|
.Nm grep
|
||
|
will only search a file until a match has been found,
|
||
|
making searches potentially less expensive.
|
||
|
Pathnames are listed once per file searched.
|
||
|
If the standard input is searched, the string
|
||
|
.Dq (standard input)
|
||
|
is written.
|
||
|
.It Fl Fl mmap
|
||
|
Use
|
||
|
.Xr mmap 2
|
||
|
instead of
|
||
|
.Xr read 2
|
||
|
to read input, which can result in better performance under some
|
||
|
circumstances but can cause undefined behaviour.
|
||
|
.It Fl m Ar num, Fl Fl max-count Ns = Ns Ar num
|
||
|
Stop reading the file after
|
||
|
.Ar num
|
||
|
matches.
|
||
|
.It Fl n , Fl Fl line-number
|
||
|
Each output line is preceded by its relative line number in the file,
|
||
|
starting at line 1.
|
||
|
The line number counter is reset for each file processed.
|
||
|
This option is ignored if
|
||
|
.Fl c ,
|
||
|
.Fl L ,
|
||
|
.Fl l ,
|
||
|
or
|
||
|
.Fl q
|
||
|
is
|
||
|
specified.
|
||
|
.It Fl Fl null
|
||
|
Prints a zero-byte after the file name.
|
||
|
.It Fl O
|
||
|
If
|
||
|
.Fl R
|
||
|
is specified, follow symbolic links only if they were explicitly listed
|
||
|
on the command line.
|
||
|
The default is not to follow symbolic links.
|
||
|
.It Fl o, Fl Fl only-matching
|
||
|
Prints only the matching part of the lines.
|
||
|
.It Fl p
|
||
|
If
|
||
|
.Fl R
|
||
|
is specified, no symbolic links are followed.
|
||
|
This is the default.
|
||
|
.It Fl q , Fl Fl quiet , Fl Fl silent
|
||
|
Quiet mode:
|
||
|
suppress normal output.
|
||
|
.Nm grep
|
||
|
will only search a file until a match has been found,
|
||
|
making searches potentially less expensive.
|
||
|
.It Fl R , Fl r , Fl Fl recursive
|
||
|
Recursively search subdirectories listed.
|
||
|
.It Fl S
|
||
|
If
|
||
|
.Fl R
|
||
|
is specified, all symbolic links are followed.
|
||
|
The default is not to follow symbolic links.
|
||
|
.It Fl s , Fl Fl no-messages
|
||
|
Silent mode.
|
||
|
Nonexistent and unreadable files are ignored
|
||
|
(i.e. their error messages are suppressed).
|
||
|
.It Fl U , Fl Fl binary
|
||
|
Search binary files, but do not attempt to print them.
|
||
|
.It Fl V , Fl Fl version
|
||
|
Display version information and exit.
|
||
|
.It Fl v , Fl Fl invert-match
|
||
|
Selected lines are those
|
||
|
.Em not
|
||
|
matching any of the specified patterns.
|
||
|
.It Fl w , Fl Fl word-regexp
|
||
|
The expression is searched for as a word (as if surrounded by
|
||
|
.Sq [[:<:]]
|
||
|
and
|
||
|
.Sq [[:>:]] ;
|
||
|
see
|
||
|
.Xr re_format 7 ) .
|
||
|
.It Fl x , Fl Fl line-regexp
|
||
|
Only input lines selected against an entire fixed string or regular
|
||
|
expression are considered to be matching lines.
|
||
|
.It Fl y
|
||
|
Equivalent to
|
||
|
.Fl i .
|
||
|
Obsoleted.
|
||
|
.It Fl Z , Fl z , Fl Fl decompress
|
||
|
Force
|
||
|
.Nm grep
|
||
|
to behave as
|
||
|
.Nm zgrep .
|
||
|
.It Fl Fl binary-files Ns = Ns Ar value
|
||
|
Controls searching and printing of binary files.
|
||
|
Options are
|
||
|
.Ar binary ,
|
||
|
the default: search binary files but do not print them;
|
||
|
.Ar without-match :
|
||
|
do not search binary files;
|
||
|
and
|
||
|
.Ar text :
|
||
|
treat all files as text.
|
||
|
.Sm off
|
||
|
.It Fl Fl context Op = Ar num
|
||
|
.Sm on
|
||
|
Print
|
||
|
.Ar num
|
||
|
lines of leading and trailing context.
|
||
|
The default is 2.
|
||
|
.It Fl Fl line-buffered
|
||
|
Force output to be line buffered.
|
||
|
By default, output is line buffered when standard output is a terminal
|
||
|
and block buffered otherwise.
|
||
|
.El
|
||
|
.Pp
|
||
|
If no file arguments are specified, the standard input is used.
|
||
|
.Sh EXIT STATUS
|
||
|
The
|
||
|
.Nm grep
|
||
|
utility exits with one of the following values:
|
||
|
.Pp
|
||
|
.Bl -tag -width flag -compact
|
||
|
.It Li 0
|
||
|
One or more lines were selected.
|
||
|
.It Li 1
|
||
|
No lines were selected.
|
||
|
.It Li \*(Gt1
|
||
|
An error occurred.
|
||
|
.El
|
||
|
.Sh EXAMPLES
|
||
|
To find all occurrences of the word
|
||
|
.Sq patricia
|
||
|
in a file:
|
||
|
.Pp
|
||
|
.Dl $ grep 'patricia' myfile
|
||
|
.Pp
|
||
|
To find all occurrences of the pattern
|
||
|
.Ql .Pp
|
||
|
at the beginning of a line:
|
||
|
.Pp
|
||
|
.Dl $ grep '^\e.Pp' myfile
|
||
|
.Pp
|
||
|
The apostrophes ensure the entire expression is evaluated by
|
||
|
.Nm grep
|
||
|
instead of by the user's shell.
|
||
|
The caret
|
||
|
.Ql ^
|
||
|
matches the null string at the beginning of a line,
|
||
|
and the
|
||
|
.Ql \e
|
||
|
escapes the
|
||
|
.Ql \&. ,
|
||
|
which would otherwise match any character.
|
||
|
.Pp
|
||
|
To find all lines in a file which do not contain the words
|
||
|
.Sq foo
|
||
|
or
|
||
|
.Sq bar :
|
||
|
.Pp
|
||
|
.Dl $ grep -v -e 'foo' -e 'bar' myfile
|
||
|
.Pp
|
||
|
A simple example of an extended regular expression:
|
||
|
.Pp
|
||
|
.Dl $ egrep '19|20|25' calendar
|
||
|
.Pp
|
||
|
Peruses the file
|
||
|
.Sq calendar
|
||
|
looking for either 19, 20, or 25.
|
||
|
.Sh SEE ALSO
|
||
|
.Xr ed 1 ,
|
||
|
.Xr ex 1 ,
|
||
|
.Xr gzip 1 ,
|
||
|
.Xr sed 1 ,
|
||
|
.Xr re_format 7
|
||
|
.Sh STANDARDS
|
||
|
The
|
||
|
.Nm
|
||
|
utility is compliant with the
|
||
|
.St -p1003.1-2008
|
||
|
specification.
|
||
|
.Pp
|
||
|
The flags
|
||
|
.Op Fl AaBbCDdGHhIJLmoPRSUVwZ
|
||
|
are extensions to that specification, and the behaviour of the
|
||
|
.Fl f
|
||
|
flag when used with an empty pattern file is left undefined.
|
||
|
.Pp
|
||
|
All long options are provided for compatibility with
|
||
|
GNU versions of this utility.
|
||
|
.Pp
|
||
|
Historic versions of the
|
||
|
.Nm grep
|
||
|
utility also supported the flags
|
||
|
.Op Fl ruy .
|
||
|
This implementation supports those options;
|
||
|
however, their use is strongly discouraged.
|
||
|
.Sh HISTORY
|
||
|
The
|
||
|
.Nm grep
|
||
|
command first appeared in
|
||
|
.At v6 .
|
||
| usr.bin/grep/grep.c | ||
|---|---|---|
|
/* $NetBSD: grep.c,v 1.6 2011/04/18 03:48:23 joerg Exp $ */
|
||
|
/* $FreeBSD: stable/11/usr.bin/grep/grep.c 280307 2015-03-21 00:21:30Z pfg $ */
|
||
|
/* $OpenBSD: grep.c,v 1.42 2010/07/02 22:18:03 tedu Exp $ */
|
||
|
/*-
|
||
|
* Copyright (c) 1999 James Howard and Dag-Erling Coïdan Smørgrav
|
||
|
* Copyright (C) 2008-2009 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: stable/11/usr.bin/grep/grep.c 280307 2015-03-21 00:21:30Z pfg $");
|
||
|
#include <sys/stat.h>
|
||
|
#include <sys/types.h>
|
||
|
#include <ctype.h>
|
||
|
#include <err.h>
|
||
|
#include <errno.h>
|
||
|
#include <fcntl.h>
|
||
|
#include <getopt.h>
|
||
|
#include <limits.h>
|
||
|
#include <libgen.h>
|
||
|
#include <locale.h>
|
||
|
#include <stdbool.h>
|
||
|
#define _WITH_GETLINE
|
||
|
#include <stdio.h>
|
||
|
#include <stdlib.h>
|
||
|
#include <string.h>
|
||
|
#include <unistd.h>
|
||
|
#include "fastmatch.h"
|
||
|
#include "grep.h"
|
||
|
#ifndef WITHOUT_NLS
|
||
|
#include <nl_types.h>
|
||
|
nl_catd catalog;
|
||
|
#endif
|
||
|
/*
|
||
|
* Default messags to use when NLS is disabled or no catalogue
|
||
|
* is found.
|
||
|
*/
|
||
|
const char *errstr[] = {
|
||
|
"",
|
||
|
/* 1*/ "(standard input)",
|
||
|
/* 2*/ "cannot read bzip2 compressed file",
|
||
|
/* 3*/ "unknown %s option",
|
||
|
/* 4*/ "usage: %s [-abcDEFGHhIiJLlmnOoPqRSsUVvwxZ] [-A num] [-B num] [-C[num]]\n",
|
||
|
/* 5*/ "\t[-e pattern] [-f file] [--binary-files=value] [--color=when]\n",
|
||
|
/* 6*/ "\t[--context[=num]] [--directories=action] [--label] [--line-buffered]\n",
|
||
|
/* 7*/ "\t[--null] [pattern] [file ...]\n",
|
||
|
/* 8*/ "Binary file %s matches\n",
|
||
|
/* 9*/ "%s (BSD grep) %s\n",
|
||
|
};
|
||
|
/* Flags passed to regcomp() and regexec() */
|
||
|
int cflags = REG_NOSUB;
|
||
|
int eflags = REG_STARTEND;
|
||
|
/* Shortcut for matching all cases like empty regex */
|
||
|
bool matchall;
|
||
|
/* Searching patterns */
|
||
|
unsigned int patterns;
|
||
|
static unsigned int pattern_sz;
|
||
|
struct pat *pattern;
|
||
|
regex_t *r_pattern;
|
||
|
fastmatch_t *fg_pattern;
|
||
|
/* Filename exclusion/inclusion patterns */
|
||
|
unsigned int fpatterns, dpatterns;
|
||
|
static unsigned int fpattern_sz, dpattern_sz;
|
||
|
struct epat *dpattern, *fpattern;
|
||
|
/* For regex errors */
|
||
|
char re_error[RE_ERROR_BUF + 1];
|
||
|
/* Command-line flags */
|
||
|
unsigned long long Aflag; /* -A x: print x lines trailing each match */
|
||
|
unsigned long long Bflag; /* -B x: print x lines leading each match */
|
||
|
bool Hflag; /* -H: always print file name */
|
||
|
bool Lflag; /* -L: only show names of files with no matches */
|
||
|
bool bflag; /* -b: show block numbers for each match */
|
||
|
bool cflag; /* -c: only show a count of matching lines */
|
||
|
bool hflag; /* -h: don't print filename headers */
|
||
|
bool iflag; /* -i: ignore case */
|
||
|
bool lflag; /* -l: only show names of files with matches */
|
||
|
bool mflag; /* -m x: stop reading the files after x matches */
|
||
|
long long mcount; /* count for -m */
|
||
|
long long mlimit; /* requested value for -m */
|
||
|
bool nflag; /* -n: show line numbers in front of matching lines */
|
||
|
bool oflag; /* -o: print only matching part */
|
||
|
bool qflag; /* -q: quiet mode (don't output anything) */
|
||
|
bool sflag; /* -s: silent mode (ignore errors) */
|
||
|
bool vflag; /* -v: only show non-matching lines */
|
||
|
bool wflag; /* -w: pattern must start and end on word boundaries */
|
||
|
bool xflag; /* -x: pattern must match entire line */
|
||
|
bool lbflag; /* --line-buffered */
|
||
|
bool nullflag; /* --null */
|
||
|
char *label; /* --label */
|
||
|
const char *color; /* --color */
|
||
|
int grepbehave = GREP_BASIC; /* -EFGP: type of the regex */
|
||
|
int binbehave = BINFILE_BIN; /* -aIU: handling of binary files */
|
||
|
int filebehave = FILE_STDIO; /* -JZ: normal, gzip or bzip2 file */
|
||
|
int devbehave = DEV_READ; /* -D: handling of devices */
|
||
|
int dirbehave = DIR_READ; /* -dRr: handling of directories */
|
||
|
int linkbehave = LINK_READ; /* -OpS: handling of symlinks */
|
||
|
bool dexclude, dinclude; /* --exclude-dir and --include-dir */
|
||
|
bool fexclude, finclude; /* --exclude and --include */
|
||
|
enum {
|
||
|
BIN_OPT = CHAR_MAX + 1,
|
||
|
COLOR_OPT,
|
||
|
HELP_OPT,
|
||
|
MMAP_OPT,
|
||
|
LINEBUF_OPT,
|
||
|
LABEL_OPT,
|
||
|
NULL_OPT,
|
||
|
R_EXCLUDE_OPT,
|
||
|
R_INCLUDE_OPT,
|
||
|
R_DEXCLUDE_OPT,
|
||
|
R_DINCLUDE_OPT
|
||
|
};
|
||
|
static inline const char *init_color(const char *);
|
||
|
/* Housekeeping */
|
||
|
bool first = true; /* flag whether we are processing the first match */
|
||
|
bool prev; /* flag whether or not the previous line matched */
|
||
|
int tail; /* lines left to print */
|
||
|
bool file_err; /* file reading error */
|
||
|
/*
|
||
|
* Prints usage information and returns 2.
|
||
|
*/
|
||
|
static void
|
||
|
usage(void)
|
||
|
{
|
||
|
fprintf(stderr, getstr(4), getprogname());
|
||
|
fprintf(stderr, "%s", getstr(5));
|
||
|
fprintf(stderr, "%s", getstr(6));
|
||
|
fprintf(stderr, "%s", getstr(7));
|
||
|
exit(2);
|
||
|
}
|
||
|
static const char *optstr = "0123456789A:B:C:D:EFGHIJMLOPSRUVZabcd:e:f:hilm:nopqrsuvwxXy";
|
||
|
static const struct option long_options[] =
|
||
|
{
|
||
|
{"binary-files", required_argument, NULL, BIN_OPT},
|
||
|
{"help", no_argument, NULL, HELP_OPT},
|
||
|
{"mmap", no_argument, NULL, MMAP_OPT},
|
||
|
{"line-buffered", no_argument, NULL, LINEBUF_OPT},
|
||
|
{"label", required_argument, NULL, LABEL_OPT},
|
||
|
{"null", no_argument, NULL, NULL_OPT},
|
||
|
{"color", optional_argument, NULL, COLOR_OPT},
|
||
|
{"colour", optional_argument, NULL, COLOR_OPT},
|
||
|
{"exclude", required_argument, NULL, R_EXCLUDE_OPT},
|
||
|
{"include", required_argument, NULL, R_INCLUDE_OPT},
|
||
|
{"exclude-dir", required_argument, NULL, R_DEXCLUDE_OPT},
|
||
|
{"include-dir", required_argument, NULL, R_DINCLUDE_OPT},
|
||
|
{"after-context", required_argument, NULL, 'A'},
|
||
|
{"text", no_argument, NULL, 'a'},
|
||
|
{"before-context", required_argument, NULL, 'B'},
|
||
|
{"byte-offset", no_argument, NULL, 'b'},
|
||
|
{"context", optional_argument, NULL, 'C'},
|
||
|
{"count", no_argument, NULL, 'c'},
|
||
|
{"devices", required_argument, NULL, 'D'},
|
||
|
{"directories", required_argument, NULL, 'd'},
|
||
|
{"extended-regexp", no_argument, NULL, 'E'},
|
||
|
{"regexp", required_argument, NULL, 'e'},
|
||
|
{"fixed-strings", no_argument, NULL, 'F'},
|
||
|
{"file", required_argument, NULL, 'f'},
|
||
|
{"basic-regexp", no_argument, NULL, 'G'},
|
||
|
{"no-filename", no_argument, NULL, 'h'},
|
||
|
{"with-filename", no_argument, NULL, 'H'},
|
||
|
{"ignore-case", no_argument, NULL, 'i'},
|
||
|
{"bz2decompress", no_argument, NULL, 'J'},
|
||
|
{"files-with-matches", no_argument, NULL, 'l'},
|
||
|
{"files-without-match", no_argument, NULL, 'L'},
|
||
|
{"max-count", required_argument, NULL, 'm'},
|
||
|
{"lzma", no_argument, NULL, 'M'},
|
||
|
{"line-number", no_argument, NULL, 'n'},
|
||
|
{"only-matching", no_argument, NULL, 'o'},
|
||
|
{"quiet", no_argument, NULL, 'q'},
|
||
|
{"silent", no_argument, NULL, 'q'},
|
||
|
{"recursive", no_argument, NULL, 'r'},
|
||
|
{"no-messages", no_argument, NULL, 's'},
|
||
|
{"binary", no_argument, NULL, 'U'},
|
||
|
{"unix-byte-offsets", no_argument, NULL, 'u'},
|
||
|
{"invert-match", no_argument, NULL, 'v'},
|
||
|
{"version", no_argument, NULL, 'V'},
|
||
|
{"word-regexp", no_argument, NULL, 'w'},
|
||
|
{"line-regexp", no_argument, NULL, 'x'},
|
||
|
{"xz", no_argument, NULL, 'X'},
|
||
|
{"decompress", no_argument, NULL, 'Z'},
|
||
|
{NULL, no_argument, NULL, 0}
|
||
|
};
|
||
|
/*
|
||
|
* Adds a searching pattern to the internal array.
|
||
|
*/
|
||
|
static void
|
||
|
add_pattern(char *pat, size_t len)
|
||
|
{
|
||
|
/* Do not add further pattern is we already match everything */
|
||
|
if (matchall)
|
||
|
return;
|
||
|
/* Check if we can do a shortcut */
|
||
|
if (len == 0) {
|
||
|
matchall = true;
|
||
|
for (unsigned int i = 0; i < patterns; i++) {
|
||
|
free(pattern[i].pat);
|
||
|
}
|
||
|
pattern = grep_realloc(pattern, sizeof(struct pat));
|
||
|
pattern[0].pat = NULL;
|
||
|
pattern[0].len = 0;
|
||
|
patterns = 1;
|
||
|
return;
|
||
|
}
|
||
|
/* Increase size if necessary */
|
||
|
if (patterns == pattern_sz) {
|
||
|
pattern_sz *= 2;
|
||
|
pattern = grep_realloc(pattern, ++pattern_sz *
|
||
|
sizeof(struct pat));
|
||
|
}
|
||
|
if (len > 0 && pat[len - 1] == '\n')
|
||
|
--len;
|
||
|
/* pat may not be NUL-terminated */
|
||
|
pattern[patterns].pat = grep_malloc(len + 1);
|
||
|
memcpy(pattern[patterns].pat, pat, len);
|
||
|
pattern[patterns].len = len;
|
||
|
pattern[patterns].pat[len] = '\0';
|
||
|
++patterns;
|
||
|
}
|
||
|
/*
|
||
|
* Adds a file include/exclude pattern to the internal array.
|
||
|
*/
|
||
|
static void
|
||
|
add_fpattern(const char *pat, int mode)
|
||
|
{
|
||
|
/* Increase size if necessary */
|
||
|
if (fpatterns == fpattern_sz) {
|
||
|
fpattern_sz *= 2;
|
||
|
fpattern = grep_realloc(fpattern, ++fpattern_sz *
|
||
|
sizeof(struct epat));
|
||
|
}
|
||
|
fpattern[fpatterns].pat = grep_strdup(pat);
|
||
|
fpattern[fpatterns].mode = mode;
|
||
|
++fpatterns;
|
||
|
}
|
||
|
/*
|
||
|
* Adds a directory include/exclude pattern to the internal array.
|
||
|
*/
|
||
|
static void
|
||
|
add_dpattern(const char *pat, int mode)
|
||
|
{
|
||
|
/* Increase size if necessary */
|
||
|
if (dpatterns == dpattern_sz) {
|
||
|
dpattern_sz *= 2;
|
||
|
dpattern = grep_realloc(dpattern, ++dpattern_sz *
|
||
|
sizeof(struct epat));
|
||
|
}
|
||
|
dpattern[dpatterns].pat = grep_strdup(pat);
|
||
|
dpattern[dpatterns].mode = mode;
|
||
|
++dpatterns;
|
||
|
}
|
||
|
/*
|
||
|
* Reads searching patterns from a file and adds them with add_pattern().
|
||
|
*/
|
||
|
static void
|
||
|
read_patterns(const char *fn)
|
||
|
{
|
||
|
struct stat st;
|
||
|
FILE *f;
|
||
|
char *line;
|
||
|
size_t len;
|
||
|
ssize_t rlen;
|
||
|
if ((f = fopen(fn, "r")) == NULL)
|
||
|
err(2, "%s", fn);
|
||
|
if ((fstat(fileno(f), &st) == -1) || (S_ISDIR(st.st_mode))) {
|
||
|
fclose(f);
|
||
|
return;
|
||
|
}
|
||
|
len = 0;
|
||
|
line = NULL;
|
||
|
while ((rlen = getline(&line, &len, f)) != -1)
|
||
|
add_pattern(line, line[0] == '\n' ? 0 : (size_t)rlen);
|
||
|
free(line);
|
||
|
if (ferror(f))
|
||
|
err(2, "%s", fn);
|
||
|
fclose(f);
|
||
|
}
|
||
|
static inline const char *
|
||
|
init_color(const char *d)
|
||
|
{
|
||
|
char *c;
|
||
|
c = getenv("GREP_COLOR");
|
||
|
return (c != NULL && c[0] != '\0' ? c : d);
|
||
|
}
|
||
|
int
|
||
|
main(int argc, char *argv[])
|
||
|
{
|
||
|
char **aargv, **eargv, *eopts;
|
||
|
char *ep;
|
||
|
const char *pn;
|
||
|
unsigned long long l;
|
||
|
unsigned int aargc, eargc, i;
|
||
|
int c, lastc, needpattern, newarg, prevoptind;
|
||
|
setlocale(LC_ALL, "");
|
||
|
#ifndef WITHOUT_NLS
|
||
|
catalog = catopen("grep", NL_CAT_LOCALE);
|
||
|
#endif
|
||
|
/* Check what is the program name of the binary. In this
|
||
|
way we can have all the funcionalities in one binary
|
||
|
without the need of scripting and using ugly hacks. */
|
||
|
pn = getprogname();
|
||
|
if (pn[0] == 'b' && pn[1] == 'z') {
|
||
|
filebehave = FILE_BZIP;
|
||
|
pn += 2;
|
||
|
} else if (pn[0] == 'x' && pn[1] == 'z') {
|
||
|
filebehave = FILE_XZ;
|
||
|
pn += 2;
|
||
|
} else if (pn[0] == 'l' && pn[1] == 'z') {
|
||
|
filebehave = FILE_LZMA;
|
||
|
pn += 2;
|
||
|
} else if (pn[0] == 'z') {
|
||
|
filebehave = FILE_GZIP;
|
||
|
pn += 1;
|
||
|
}
|
||
|
switch (pn[0]) {
|
||
|
case 'e':
|
||
|
grepbehave = GREP_EXTENDED;
|
||
|
break;
|
||
|
case 'f':
|
||
|
grepbehave = GREP_FIXED;
|
||
|
break;
|
||
|
}
|
||
|
lastc = '\0';
|
||
|
newarg = 1;
|
||
|
prevoptind = 1;
|
||
|
needpattern = 1;
|
||
|
eopts = getenv("GREP_OPTIONS");
|
||
|
/* support for extra arguments in GREP_OPTIONS */
|
||
|
eargc = 0;
|
||
|
if (eopts != NULL && eopts[0] != '\0') {
|
||
|
char *str;
|
||
|
/* make an estimation of how many extra arguments we have */
|
||
|
for (unsigned int j = 0; j < strlen(eopts); j++)
|
||
|
if (eopts[j] == ' ')
|
||
|
eargc++;
|
||
|
eargv = (char **)grep_malloc(sizeof(char *) * (eargc + 1));
|
||
|
eargc = 0;
|
||
|
/* parse extra arguments */
|
||
|
while ((str = strsep(&eopts, " ")) != NULL)
|
||
|
if (str[0] != '\0')
|
||
|
eargv[eargc++] = grep_strdup(str);
|
||
|
aargv = (char **)grep_calloc(eargc + argc + 1,
|
||
|
sizeof(char *));
|
||
|
aargv[0] = argv[0];
|
||
|
for (i = 0; i < eargc; i++)
|
||
|
aargv[i + 1] = eargv[i];
|
||
|
for (int j = 1; j < argc; j++, i++)
|
||
|
aargv[i + 1] = argv[j];
|
||
|
aargc = eargc + argc;
|
||
|
} else {
|
||
|
aargv = argv;
|
||
|
aargc = argc;
|
||
|
}
|
||
|
while (((c = getopt_long(aargc, aargv, optstr, long_options, NULL)) !=
|
||
|
-1)) {
|
||
|
switch (c) {
|
||
|
case '0': case '1': case '2': case '3': case '4':
|
||
|
case '5': case '6': case '7': case '8': case '9':
|
||
|
if (newarg || !isdigit(lastc))
|
||
|
Aflag = 0;
|
||
|
else if (Aflag > LLONG_MAX / 10) {
|
||
|
errno = ERANGE;
|
||
|
err(2, NULL);
|
||
|
}
|
||
|
Aflag = Bflag = (Aflag * 10) + (c - '0');
|
||
|
break;
|
||
|
case 'C':
|
||
|
if (optarg == NULL) {
|
||
|
Aflag = Bflag = 2;
|
||
|
break;
|
||
|
}
|
||
|
/* FALLTHROUGH */
|
||
|
case 'A':
|
||
|
/* FALLTHROUGH */
|
||
|
case 'B':
|
||
|
errno = 0;
|
||
|
l = strtoull(optarg, &ep, 10);
|
||
|
if (((errno == ERANGE) && (l == ULLONG_MAX)) ||
|
||
|
((errno == EINVAL) && (l == 0)))
|
||
|
err(2, NULL);
|
||
|
else if (ep[0] != '\0') {
|
||
|
errno = EINVAL;
|
||
|
err(2, NULL);
|
||
|
}
|
||
|
if (c == 'A')
|
||
|
Aflag = l;
|
||
|
else if (c == 'B')
|
||
|
Bflag = l;
|
||
|
else
|
||
|
Aflag = Bflag = l;
|
||
|
break;
|
||
|
case 'a':
|
||
|
binbehave = BINFILE_TEXT;
|
||
|
break;
|
||
|
case 'b':
|
||
|
bflag = true;
|
||
|
break;
|
||
|
case 'c':
|
||
|
cflag = true;
|
||
|
break;
|
||
|
case 'D':
|
||
|
if (strcasecmp(optarg, "skip") == 0)
|
||
|
devbehave = DEV_SKIP;
|
||
|
else if (strcasecmp(optarg, "read") == 0)
|
||
|
devbehave = DEV_READ;
|
||
|
else
|
||
|
errx(2, getstr(3), "--devices");
|
||
|
break;
|
||
|
case 'd':
|
||
|
if (strcasecmp("recurse", optarg) == 0) {
|
||
|
Hflag = true;
|
||
|
dirbehave = DIR_RECURSE;
|
||
|
} else if (strcasecmp("skip", optarg) == 0)
|
||
|
dirbehave = DIR_SKIP;
|
||