$ brew install https://raw.githubusercontent.com/Genivia/ugrep/master/Formula/ugrep.rb

$ git clone https://github.com/Genivia/ugrep

$ cd ugrep
$ ./build.sh

$ cd ugrep
$ ./build.sh

$ cd ugrep
$ ./build.sh --enable-pager

$ sudo make install

$ autoreconf -fi
$ ./build.sh

$ ./build.sh CXXFLAGS='-fsanitize=thread -O1 -g'

paste -d'|' -s words1+1000 > pattern.txt
/usr/bin/time ./simplegrep `cat pattern.txt` enwik8 | ./null

#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
int main() { char buf[65536]; while (read(0, buf, 65536) > 0) continue; }

if executable('ugrep')
    set grepprg=ugrep\ -RInk\ -j\ -u\ --tabs=1\ --ignore-files
    set grepformat=%f:%l:%c:%m,%f+%l+%c+%m,%-G%f\\\|%l\\\|%c\\\|%m
endif

:grep PATTERN [PATH]

:grep PATTERN %

:copen

:grep -tc++ FIXME

:cclose

:grep -f c++/comments %

$ cd ~/.vim
$ git clone https://github.com/kien/ctrlp.vim.git bundle/ctrlp.vim

if executable('ugrep')
    set runtimepath^=~/.vim/bundle/ctrlp.vim
    let g:ctrlp_match_window='bottom,order:ttb'
    let g:ctrlp_user_command='ugrep %s -Rl -I --ignore-files -3'
endif

:helptags ~/.vim/bundle/ctrlp.vim/doc

:help ctrlp.txt

grep   = ugrep --sort -G -U -Y -. -Dread -dread
egrep  = ugrep --sort -E -U -Y -. -Dread -dread
fgrep  = ugrep --sort -F -U -Y -. -Dread -dread

zgrep  = ugrep --sort -G -U -Y -z -. -Dread -dread
zegrep = ugrep --sort -E -U -Y -z -. -Dread -dread
zfgrep = ugrep --sort -F -U -Y -z -. -Dread -dread

alias ug     = 'ugrep'       # short & quick text pattern search
alias uq     = 'ugrep -Q'    # short & quick query UI (interactive)
alias ux     = 'ugrep -UX'   # short & quick binary pattern search
alias uz     = 'ugrep -z'    # short & quick compressed files and archives search

alias ugit   = 'ugrep -R --ignore-files' # works like git-grep

alias grep   = 'ugrep -G'    # search with basic regular expressions (BRE)
alias egrep  = 'ugrep -E'    # search with extended regular expressions (ERE)
alias fgrep  = 'ugrep -F'    # find string(s)
alias xgrep  = 'ugrep -W'    # search (ERE) and output text or hex for binary

alias zgrep  = 'ugrep -zG'   # search compressed files and archives (BRE)
alias zegrep = 'ugrep -zE'   # search compressed files and archives (ERE)
alias zfgrep = 'ugrep -zF'   # find string(s) in compressed files and/or archives
alias zxgrep = 'ugrep -zW'   # search (ERE) compressed files/archives and output text or hex for binary

alias xdump  = 'ugrep -X ""' # hexdump files without searching

--filter="pdf:pdftotext % -,odt,doc,docx,rtf,xls,xlsx,ppt,pptx:soffice --headless --cat %"

ugrep main

ugrep -tc++ main

ugrep -Q -tc++ -e main

ugrep -tc++ '#[\t ]*define'

ugrep -r -nkw main myproject

ugrep -nkw main myproject

ugrep -2 -nkw main myproject

ugrep -tc++ -2 -nkw main myproject

ugrep -z -tc++ -2 -nkw main myproject

ugrep --ignore-files -tc++ -nkw main

ugrep --ignore-files -l ''

ugrep -tlist

ugrep -l -tShell ''

ugrep -r -nkw 'main' -N '"(\\.|\\\r?\n|[^\\\n"])*"|//.*|/\*([^*]|\n|(\*+([^*/]|\n)))*\*+\/' myproject

ugrep -r -nkw 'main' -f c/zap_strings -f c/zap_comments myproject

ugrep -R -tc,c++ -nkw 'main' -f c/zap_strings -f c/zap_comments myproject

ugrep -R -tc,c++ -nkw -e 'main' -N 'main\h*\(' -f c/zap_strings -f c/zap_comments myproject

ugrep -R -tc,c++ -nk -f c/comments myproject | ugrep -w 'FIXME'

ugrep -R -tjava -f java/names -f java/zap_strings -f java/zap_comments myproject | sort -u

ugrep -R --include='*.c' --include='*.cpp' '^([ \t]*[[:word:]:*&]+)+[ \t]+qsort[ \t]*\([^;\n]+$' myproject

ugrep -R -Oc,cpp -nk -f c/functions | ugrep 'qsort'

ugrep -R -tc++ --ignore-files -f c++/defines

alias ugit='ugrep -R --ignore-files'
ugit -tc++ -f c++/defines

ugit --color=always -tc++ -f c++/defines | ugrep -w 'FOO.*'

man ugrep

ugrep --help

ugrep -tlist

-Q[DELAY], --query[=DELAY]
        Query mode: user interface to perform interactive searches.  This
        mode requires an ANSI capable terminal.  An optional DELAY argument
        may be specified to reduce or increase the response time to execute
        searches after the last key press, in increments of 100ms, where
        the default is 5 (0.5s delay).  No whitespace may be given between
        -Q and its argument DELAY.  Initial patterns may be specified with
        -e PATTERN, i.e. a PATTERN argument requires option -e.  Press F1
        or CTRL-Z to view the help screen.  Press F2 or CTRL-Y to invoke an
        editor to edit the file displayed on screen.  The editor is taken
        from the environment variable GREP_EDIT if defined, or EDITOR if
        GREP_EDIT is not defined.  Enables --heading.
--no-confirm\n\
        Do not confirm actions in -Q query mode.  The default is confirm.

ugrep -Q

ugrep -Q -tc++ --ignore-files

ugrep -Q -g 'Makefile*' -g 'makefile*'

ugrep -Q -2 -g 'Makefile*' -g 'makefile*'

ugrep -Q -y main.cpp

ugrep -Q -C5 -e TODO main.cpp

ugrep -Q -z archive.tar.gz

unzip project.zip `zipinfo -1 project.zip | ugrep -Q`

-L, --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 ``(standard input)''
        is written.
-l, --files-with-matches
        Only the names of files containing selected lines are written to
        standard output.  ugrep 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 ``(standard input)'' is written.
-R, --dereference-recursive
        Recursively read all files under each directory.  Follow all
        symbolic links, unlike -r.  When -J1 is specified, files are
        searched in the same order as specified.  Note that when no FILE
        arguments are specified and input is read from a terminal,
        recursive searches are performed as if -R is specified.
-r, --recursive
        Recursively read all files under each directory, following symbolic
        links only if they are on the command line.  When -J1 is specified,
        files are searched in the same order as specified.
--depth=[MIN,][MAX], -1, -2 ... -9, --10, --11 ...
        Restrict recursive searches from MIN to MAX directory levels deep,
        where -1 (--depth=1) searches the specified path without recursing
        into subdirectories.  Note that -3 -5, -3-5, or -35 searches 3 to 5
        levels deep.  Enables -R if -R or -r is not specified.
-g GLOB, --glob=GLOB
        Search only files whose name matches GLOB, same as --include=GLOB.
        When GLOB is preceded by a `!' or a `^', skip files whose name
        matches GLOB, same as --exclude=GLOB.  GLOB should be quoted to
        prevent shell globbing.  This option may be repeated.
-O EXTENSIONS, --file-extensions=EXTENSIONS
        Search only files whose filename extensions match the specified
        comma-separated list of EXTENSIONS, same as --include='*.ext' for
        each `ext' in EXTENSIONS.  When `ext' is preceded by a `!' or a
        `^', skip files whose filename extensions matches `ext', same as
        --exclude='*.ext'.  This option may be repeated and may be combined
        with options -M and -t to expand the recursive search.
-t TYPES, --file-type=TYPES
        Search only files associated with TYPES, a comma-separated list of
        file types.  Each file type corresponds to a set of filename
        extensions passed to option -O.  For capitalized file types, the
        search is expanded to include files with matching file signature
        magic bytes, as if passed to option -M.  When a type is preceded
        by a `!' or a `^', excludes files of the specified type.  This
        option may be repeated.
--stats
        Display statistics on the number of files and directories searched.
        Display the inclusion and exclusion constraints applied.

ugrep -R -l ''

ugrep -l '' .

ugrep -l '' mydir

ugrep -R -l '' mydir

ugrep -2 -l '' mydir

ugrep -rl '' mydir

ugrep -l -gMakefile 'CPP'

ugrep -l -g'Makefile.*' 'bin_PROGRAMS'

ugrep -l -Osh ''

ugrep -l -tShell ''

ugrep -l -tshell ''

-e PATTERN, --regexp=PATTERN
        Specify a PATTERN used during the search of the input: an input
        line is selected if it matches any of the specified patterns.
        Note that longer patterns take precedence over shorter patterns.
        This option is most useful when multiple -e options are used to
        specify multiple patterns, when a pattern begins with a dash (`-'),
        to specify a pattern after option -f or after the FILE arguments.
-f FILE, --file=FILE
        Read newline-separated patterns from FILE.  White space in patterns
        is significant.  Empty lines in FILE are ignored.  If FILE does not
        exist, the GREP_PATH environment variable is used as path to FILE.
        If that fails, looks for FILE in /usr/local/share/ugrep/pattern.
        When FILE is a `-', standard input is read.  This option may be
        repeated.
-L, --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 ``(standard input)''
        is written.
-N PATTERN, --not-regexp=PATTERN
        Specify a negative PATTERN used during the search of the input: an
        input line is selected only if it matches any of the specified
        patterns when PATTERN does not match.  Same as -e (?^PATTERN).
        Negative PATTERN matches are removed before any other specified
        patterns are matched.  Note that longer patterns take precedence
        over shorter patterns.  This option may be repeated.
-v, --invert-match
        Selected lines are those not matching any of the specified
        patterns.
-w, --word-regexp
        The PATTERN is searched for as a word (as if surrounded by \< and
        \>).  If a PATTERN is specified (or -e PATTERN or -N PATTERN), then
        this option does not apply to -f FILE patterns.
-x, --line-regexp
        Only input lines selected against the entire PATTERN is considered
        to be matching lines (as if surrounded by ^ and $).  If a PATTERN
        is specified (or -e PATTERN or -N PATTERN), then this option does
        not apply to -f FILE patterns.

ugrep -v '^[ \t]*#' myfile.sh

ugrep FIXME myfile.cpp | ugrep urgent | ugrep -v Scotty

ugrep FIXME -N '.*Scotty.*' myfile.cpp | ugrep urgent

ugrep '\<disp' -N '/<display\>' myfile.py

ugrep -n -w 'display' -f python/zap_strings -f python/zap_comments myfile.py

ugrep -x '.*' -N '\h*' myfile.py

ugrep -v -x '\h*' myfile.py

ugrep -RL -tPython -w 'display' -f python/zap_strings -f python/zap_comments

ugrep -e TODO -e FIXME -N '.*TODO.*FIXME.*' -N '.*FIXME.*TODO.*' myfile.cpp

--encoding=ENCODING
        The input file encoding.

ugrep -RL '[^[:ascii:]]'

ugrep -Rl '[^[:ascii:]]'

ugrep -q '[^[:ascii:]]' myfile && echo "contains Unicode"

ugrep "\p{Unicode}" --format="%o" badfile.txt

ugrep -Rl '.' -N '\p{Unicode}'

ugrep '[😀-😏]' emojis.txt

ugrep '[\x{1F600}-\x{1F60F}]' emojis.txt

ugrep 'G(ö|oe)del|Escher|Bach' GEB.txt wiki.txt

ugrep -iw 'lorem' utf16lorem.txt

ugrep --encoding=UTF-16 -iw 'lorem' utf16lorem.txt

ugrep --encoding=ISO-8859-1 -w 'año' spanish-iso.txt

-o, --only-matching
        Print only the matching part of lines.  When multiple lines match,
        the line numbers with option -n are displayed using `|' as the
        field separator for each additional line matched by the pattern.
        If -u is specified, ungroups multiple matches on the same line.
        This option cannot be combined with options -A, -B, -C, -v, and -y.

ugrep '/\*([^*]|\n|(\*+([^*/]|\n)))*\*+\/' myfile.cpp

ugrep -of c/comments myfile.cpp

ugrep -o '.*begin(.|\n)*?end.*' myfile.txt

-A NUM, --after-context=NUM
        Print NUM lines of trailing context after matching lines.  Places
        a --group-separator between contiguous groups of matches.  See also
        options -B, -C, and -y.
-B NUM, --before-context=NUM
        Print NUM lines of leading context before matching lines.  Places
        a --group-separator between contiguous groups of matches.  See also
        options -A, -C, and -y.
-C[NUM], --context[=NUM]
        Print NUM lines of leading and trailing context surrounding each
        match.  The default is 2 and is equivalent to -A 2 -B 2.  Places
        a --group-separator between contiguous groups of matches.
        No whitespace may be given between -C and its argument NUM.
-y, --any-line
        Any matching or non-matching line is output.  Non-matching lines
        are output with the `-' separator as context of the matching lines.
        See also options -A, -B, and -C.

ugrep -C2 'FIXME' myfile.cpp

ugrep -A3 'FIXME.*' myfile.cpp:

ugrep -B1 -f c/functions myfile.c

ugrep -B1 -f c++/functions myfile.cpp

ugrep -y -f c++/functions myfile.cpp

ugrep -C1 -UX '\xaa\xbb\xcc' a.out

ugrep -o -U '(\w+\h+)?pattern(\h+\w+)?' myfile.cpp

ugrep -onkTg -U '.{0,8}pattern.{0,8}' myfile.cpp | ugrep 'pattern'

-f FILE, --file=FILE
        Read newline-separated patterns from FILE.  White space in patterns
        is significant.  Empty lines in FILE are ignored.  If FILE does not
        exist, the GREP_PATH environment variable is used as path to FILE.
        If that fails, looks for FILE in /usr/local/share/ugrep/pattern.
        When FILE is a `-', standard input is read.  This option may be
        repeated.
--ignore-files[=FILE]
        Ignore files and directories matching the globs in each FILE that
        is encountered in recursive searches.  The default FILE is
        `.gitignore'.  Matching files and directories located in the
        directory tree rooted at a FILE's location are ignored by
        temporarily overriding the --exclude and --exclude-dir globs.
        Files and directories that are explicitly specified as command line
        arguments are never ignored.  This option may be repeated.
-g GLOB, --glob=GLOB
        Search only files whose name matches GLOB, same as --include=GLOB.
        When GLOB is preceded by a `!' or a `^', skip files whose name
        matches GLOB, same as --exclude=GLOB.  GLOB should be quoted to
        prevent shell globbing.  This option may be repeated.
-O EXTENSIONS, --file-extensions=EXTENSIONS
        Search only files whose filename extensions match the specified
        comma-separated list of EXTENSIONS, same as --include='*.ext' for
        each `ext' in EXTENSIONS.  When `ext' is preceded by a `!' or a
        `^', skip files whose filename extensions matches `ext', same as
        --exclude='*.ext'.  This option may be repeated and may be combined
        with options -M and -t to expand the recursive search.
-t TYPES, --file-type=TYPES
        Search only files associated with TYPES, a comma-separated list of
        file types.  Each file type corresponds to a set of filename
        extensions passed to option -O.  For capitalized file types, the
        search is expanded to include files with matching file signature
        magic bytes, as if passed to option -M.  When a type is preceded
        by a `!' or a `^', excludes files of the specified type.  This
        option may be repeated.
--stats
        Display statistics on the number of files and directories searched.
        Display the inclusion and exclusion constraints applied.

ugrep -on -tc++ -f c++/functions

ugrep -on -Oc,cpp -f c++/functions

ugrep -l -tShell -O^sh ''

ugrep -l -t^Shell ''

ugrep -l -tShell -t^shell ''

ugrep -n 'FIXME' -f c++/zap_strings myfile.cpp

ugrep -on -f - -f c++/zap_strings myfile.cpp <<END
TODO
FIXME
END

ugrep -o -f xml/tags -f xml/zap_comments myfile.xml

-z, --decompress
        Decompress files to search, when compressed.  Archives (.cpio,
        .pax, .tar, and .zip) and compressed archives (e.g. .taz, .tgz,
        .tpz, .tbz, .tbz2, .tb2, .tz2, .tlz, and .txz) are searched and
        matching pathnames of files in archives are output in braces.  If
        -g, -O, -M, or -t is specified, searches files within archives
        whose name matches globs, matches file name extensions, matches
        file signature magic bytes, or matches file types, respectively.
        Supported compression formats: gzip (.gz), compress (.Z), zip,
        bzip2 (requires suffix .bz, .bz2, .bzip2, .tbz, .tbz2, .tb2, .tz2),
        lzma and xz (requires suffix .lzma, .tlz, .xz, .txz).

ugrep -z -r -tc++ -Fw my_function -f cpp/zap_comments

cat myfile.bz2 | ugrep -z --label='stdin.bz2' 'xyz'

ugrep -z -g main.cpp -w -e 'TODO' -e 'FIXME' project.zip

ugrep -z -tc++ -w -e 'TODO' -e 'FIXME' project.tar.gz

ugrep -z -g '*.txt' -w -i 'license' project.zip

ugrep --pager -z -tc++ '' project.tgz

ugrep -z -l -g '/**/projects/project1.*' -F 'December 12' projects.tgz

ugrep -z -h -OMF,jar '' my.jar

tar xzf project.tgz `ugrep -z -l -tc++ --format='%z ' -w FIXME project.tgz`

find . -depth -print | cpio -o | ugrep -z 'xyz'

--ignore-files[=FILE]
        Ignore files and directories matching the globs in each FILE that
        is encountered in recursive searches.  The default FILE is
        `.gitignore'.  Matching files and directories located in the
        directory tree rooted at a FILE's location are ignored by
        temporarily overriding the --exclude and --exclude-dir globs.
        Files and directories that are explicitly specified as command line
        arguments are never ignored.  This option may be repeated.
-M MAGIC, --file-magic=MAGIC
        Only files matching the signature pattern MAGIC are searched.  The
        signature \"magic bytes\" at the start of a file are compared to
        the MAGIC regex pattern.  When matching, the file will be searched.
        When MAGIC is preceded by a `!' or a `^', skip files with matching
        MAGIC signatures.  This option may be repeated and may be combined
        with options -O and -t to expand the search.  Every file on the
        search path is read, making searches potentially more expensive.
-O EXTENSIONS, --file-extensions=EXTENSIONS
        Search only files whose filename extensions match the specified
        comma-separated list of EXTENSIONS, same as --include='*.ext' for
        each `ext' in EXTENSIONS.  When `ext' is preceded by a `!' or a
        `^', skip files whose filename extensions matches `ext', same as
        --exclude='*.ext'.  This option may be repeated and may be combined
        with options -M and -t to expand the recursive search.
-t TYPES, --file-type=TYPES
        Search only files associated with TYPES, a comma-separated list of
        file types.  Each file type corresponds to a set of filename
        extensions passed to option -O.  For capitalized file types, the
        search is expanded to include files with matching file signature
        magic bytes, as if passed to option -M.  When a type is preceded
        by a `!' or a `^', excludes files of the specified type.  This
        option may be repeated.
-g GLOB, --glob=GLOB
        Search only files whose name matches GLOB, same as --include=GLOB.
        When GLOB is preceded by a `!' or a `^', skip files whose name
        matches GLOB, same as --exclude=GLOB.  GLOB should be quoted to
        prevent shell globbing.  This option may be repeated.
--stats
        Display statistics on the number of files and directories searched.
        Display the inclusion and exclusion constraints applied.

ugrep -l -M'#!' ''

ugrep -l -M'#' -M'^#!' ''

ugrep -l -tPython ''

ugrep -l -t^Shell ''

ugrep -l. -tPython -f python/imports

-Z[MAX], --fuzzy[=MAX]
        Fuzzy mode: report approximate pattern matches within MAX errors.
        By default, MAX is 1: one deletion, insertion or substitution is
        allowed.  When `+' and/or `-' precede MAX, only insertions and/or
        deletions are allowed.  When `~' precedes MAX, substitution counts
        as one error.  For example, -Z+~3 allows up to three insertions or
        substitutions, but no deletions.  The first character of an
        approximate match always matches the begin of a pattern.  Option
        --sort=best orders matching files by best match.  No whitespace may
        be given between -Z and its argument.

ugrep -Z 'foobar'

ugrep -Z -wi 'foobar'

ugrep -Z+3 -wi 'foobar'

ugrep -Z+3 -wi --sort=best 'foobar'

ugrep -Z+3 -wi --format='%F%Z:%O%~' --sort=best 'foobar'

--hidden, -.
        Search hidden files and directories.

ugrep -. -tShell 'login'

--filter=COMMANDS
        Filter files through the specified COMMANDS first before searching.
        COMMANDS is a comma-separated list of `exts:command [option ...]',
        where `exts' is a comma-separated list of filename extensions and
        `command' is a filter utility.  The filter utility should read from
        standard input and write to standard output.  Files matching one of
        `exts' are filtered.  When `exts' is `*', files with non-matching
        extensions are filtered.  One or more `option' separated by spacing
        may be specified, which are passed verbatim to the command.  A `%'
        as `option' expands into the pathname to search.  For example,
        --filter='pdf:pdftotext % -' searches PDF files.  The `%' expands
        into a `-' when searching standard input.  Option --label=.ext may
        be used to specify extension `ext' when searching standard input.
--filter-magic-label=LABEL:MAGIC
        Associate LABEL with files whose signature "magic bytes" match the
        MAGIC regex pattern.  Only files that have no filename extension
        are labeled, unless +LABEL is specified.  When LABEL matches an
        extension specified in --filter=COMMANDS, the corresponding command
        is invoked.  This option may be repeated.

ugrep -r -1 --filter='pdf:pdftotext -nopgbrk % -' 'drink me'

ugrep -r -ttext --filter='txt,md:cat -v' 'eat me'

ugrep -r -ttext --filter='txt:cat -v, md:cat -v' 'eat me'

ugrep --filter='txt:head -c 8192' 'eat me' wonderland.txt

ugrep -rl -w --filter='docx,epub:pandoc --wrap=preserve -t markdown % -o -' 'Alice'

ugrep -rl -w --filter='odt,doc,docx,rtf,xls,xlsx,ppt,pptx:soffice --headless --cat %' 'Alice'

ugrep -r -Ocsv,xls,xlsx --filter='xls,xlsx:in2csv %' '10/6'

ugrep -lr -Odocx,xlsx,pptx --filter='docx,xlsx,pptx:unzip -p %' '10/6'

ugrep -z -lr -Odocx,xlsx,pptx,xml '10/6'

ugrep -r 'Not After' -Ocer,der,pem --filter='pem:openssl x509 -text,cer,crt,der:openssl x509 -text -inform der'

ugrep -r -i 'copyright' -tpng --filter='*:exiftool %'

ugrep -r -i 'copyright' -tPng --filter='png:exiftool %' --filter-magic-label='+png:\x89png\x0d\x0a\x1a\x0a'

-U, --binary
        Disables Unicode matching for binary file matching, forcing PATTERN
        to match bytes, not Unicode characters.  For example, -U '\xa3'
        matches byte A3 (hex) instead of the Unicode code point U+00A3
        represented by the two-byte UTF-8 sequence C2 A3.
-W, --with-hex
        Output binary matches in hexadecimal, leaving text matches alone.
        This option is equivalent to the --binary-files=with-hex option.
-X, --hex
        Output matches in hexadecimal.  This option is equivalent to the
        --binary-files=hex option.
--hexdump=[1-8][b][c][h]
        Output matches in 1 to 8 columns of 8 hexadecimal bytes.  The
        default is 2 columns or 16 bytes per line. Option `b' removes space
        breaks, `c' removes the character column, and `h' removes the byte
        spacing.  Enables -X if -W or -X is not specified.

ugrep -UW '\w+' myfile

ugrep -X '' myfile

ugrep -Xynb '' myfile

ugrep -UX '\x00+' myfile

ugrep -UX -y '\x00+' myfile

ugrep -U --hexdump=4bc -y '\x00+' myfile

ugrep --pager -o -UX '\xa3[\x00-\xff]{2}\xa3[\x00-\xff]' a.out

ugrep -RlU '\A\xed\xab\xee\xdb' rpm

-I      Ignore matches in binary files.  This option is equivalent to the
        --binary-files=without-match option.

ugrep -rl -I 'xyz'

ugrep -rl --exclude-from=ignore_binaries 'xyz'

alias ugs="ugrep --exclude-from=$HOME/ignore_binaries"
ugs -rl 'xyz'

--ignore-files[=FILE]
        Ignore files and directories matching the globs in each FILE that
        is encountered in recursive searches.  The default FILE is
        `.gitignore'.  Matching files and directories located in the
        directory tree rooted at a FILE's location are ignored by
        temporarily overriding the --exclude and --exclude-dir globs.
        Files and directories that are explicitly specified as command line
        arguments are never ignored.  This option may be repeated.

ugrep -rl --ignore-files 'xyz'

ugrep -rl. --ignore-files 'xyz'

ugrep -Rl '' --ignore-files

ugrep -Rl -tShell '' --ignore-files

ugrep -Rl '' --ignore-files --exclude-from=.git/info/exclude

ln -s .git/info/exclude .ignore
ugrep -Rl '' --ignore-files --ignore-files=.ignore

-g GLOB, --glob=GLOB
        Search only files whose name matches GLOB, same as --include=GLOB.
        When GLOB is preceded by a `!' or a `^', skip files whose name
        matches GLOB, same as --exclude=GLOB.  GLOB should be quoted to
        prevent shell globbing.  This option may be repeated.
--exclude=GLOB
        Skip files whose name matches GLOB using wildcard matching, same as
        -g !GLOB.  GLOB can use **, *, ?, and [...] as wildcards, and \\ to
        quote a wildcard or backslash character literally.  When GLOB
        contains a `/', full pathnames are matched.  Otherwise basenames
        are matched.  When GLOB ends with a `/', directories are excluded
        as if --exclude-dir is specified.  Otherwise files are excluded.
        Note that --exclude patterns take priority over --include patterns.
        GLOB should be quoted to prevent shell globbing.  This option may
        be repeated.
--exclude-dir=GLOB
        Exclude directories whose name matches GLOB from recursive
        searches.  GLOB can use **, *, ?, and [...] as wildcards, and \\ to
        quote a wildcard or backslash character literally.  When GLOB
        contains a `/', full pathnames are matched.  Otherwise basenames
        are matched.  Note that --exclude-dir patterns take priority over
        --include-dir patterns.  GLOB should be quoted to prevent shell
        globbing.  This option may be repeated.
--exclude-from=FILE
        Read the globs from FILE and skip files and directories whose name
        matches one or more globs (as if specified by --exclude and
        --exclude-dir).  Lines starting with a `#' and empty lines in FILE
        are ignored.  When FILE is a `-', standard input is read.  This
        option may be repeated.
--ignore-files[=FILE]
        Ignore files and directories matching the globs in each FILE that
        is encountered in recursive searches.  The default FILE is
        `.gitignore'.  Matching files and directories located in the
        directory tree rooted at a FILE's location are ignored by
        temporarily overriding the --exclude and --exclude-dir globs.
        Files and directories that are explicitly specified as command line
        arguments are never ignored.  This option may be repeated.
--include=GLOB
        Search only files whose name matches GLOB using wildcard matching,
        same as -g GLOB.  GLOB can use **, *, ?, and [...] as wildcards,
        and \\ to quote a wildcard or backslash character literally.  When
        GLOB contains a `/', full pathnames are matched.  Otherwise
        basenames are matched.  When GLOB ends with a `/', directories are
        included as if --include-dir is specified.  Otherwise files are
        included.  Note that --exclude patterns take priority over
        --include patterns.  GLOB should be quoted to prevent shell
        globbing.  This option may be repeated.
--include-dir=GLOB
        Only directories whose name matches GLOB are included in recursive
        searches.  GLOB can use **, *, ?, and [...] as wildcards, and \\ to
        quote a wildcard or backslash character literally.  When GLOB
        contains a `/', full pathnames are matched.  Otherwise basenames
        are matched.  Note that --exclude-dir patterns take priority over
        --include-dir patterns.  GLOB should be quoted to prevent shell
        globbing.  This option may be repeated.
--include-from=FILE
        Read the globs from FILE and search only files and directories
        whose name matches one or more globs (as if specified by --include
        and --include-dir).  Lines starting with a `#' and empty lines in
        FILE are ignored.  When FILE is a `-', standard input is read.
        This option may be repeated.
-O EXTENSIONS, --file-extensions=EXTENSIONS
        Search only files whose filename extensions match the specified
        comma-separated list of EXTENSIONS, same as --include='*.ext' for
        each `ext' in EXTENSIONS.  When `ext' is preceded by a `!' or a
        `^', skip files whose filename extensions matches `ext', same as
        --exclude='*.ext'.  This option may be repeated and may be combined
        with options -M and -t to expand the recursive search.
--stats
        Display statistics on the number of files and directories searched.
        Display the inclusion and exclusion constraints applied.

ugrep -sl 'xyz' foo*

ugrep -Rl 'xyz' -g'/foo*' -g'/foo*/'

ugrep -Rl 'xyz' -g'^/bak/'

ugrep -Rl 'xyz' -g'^bak/'

ugrep -Rl 'xyz' -g'/doc/'

ugrep -Rl 'xyz' -g'doc/**/html/'

ugrep -Rl 'xyz' -g'/doc/' -g'/doc/latest/'

ugrep -Rl 'xyz' -g'*.cpp'

ugrep -Rl 'xyz' -g'**/*.cpp'

ugrep -Rl -Ocpp 'xyz'

ugrep -Rl '' --exclude-from=.gitignore

ugrep -Rl '' --ignore-files

--exclude-fs=MOUNTS
        Exclude file systems specified by MOUNTS from recursive searches,
        MOUNTS is a comma-separated list of mount points or pathnames of
        directories on file systems.  Note that --exclude-fs mounts take
        priority over --include-fs mounts.  This option may be repeated.
--include-fs=MOUNTS
        Only file systems specified by MOUNTS are included in recursive
        searches.  MOUNTS is a comma-separated list of mount points or
        pathnames of directories on file systems.  --include-fs=. restricts
        recursive searches to the file system of the working directory
        only.  Note that --exclude-fs mounts take priority over
        --include-fs mounts.  This option may be repeated.

ugrep -Rl --include-fs=. 'xyz' 

ugrep -Rl --exclude-fs=/dev,/proc 'xyz' 

ugrep -Rl --include-fs=d:/ 'xyz' 

exfs=`ugrep -w -e fuse -e tmpfs /etc/mtab | ugrep -P '^\S+ (\S+)' --format='%,%1'`
ugrep -Rl --exclude-fs="$exfs" 'xyz'

-c, --count
        Only a count of selected lines is written to standard output.
        If -o or -u is specified, counts the number of patterns matched.
        If -v is specified, counts the number of non-matching lines.

ugrep -c '' myfile.txt

ugrep -c -w 'TODO' myfile.cpp

ugrep -co -w 'TODO' myfile.cpp

ugrep -co '[[:word:]]+' myfile.txt

ugrep -co '\w+' myfile.txt

ugrep -co '\p{Unicode}' myfile.txt

ugrep -UX -co '\x00' image.jpg

-b, --byte-offset
        The offset in bytes of a matched line is displayed in front of the
        respective matched line.  When used with option -u, displays the
        offset in bytes of each pattern matched.  Byte offsets are exact
        for ASCII, UTF-8, and raw binary input.  Otherwise, the byte offset
        in the UTF-8 converted input is displayed.
-H, --with-filename
        Always print the filename with output lines.  This is the default
        when there is more than one file to search.
-k, --column-number
        The column number of a matched pattern is displayed in front of the
        respective matched line, starting at column 1.  Tabs are expanded
        when columns are counted, see option --tabs.
-n, --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.
-T, --initial-tab
        Add a tab space to separate the file name, line number, column
        number, and byte offset with the matched line.

ugrep -THnk 'main' myfile.cpp

ugrep -nw 'main' myfile.cpp

ugrep -n '' myfile.cpp

ugrep -r -nk -tc++ 'main'

ugrep -r -b -tc++ 'main'

ugrep -r -nk --xml -tc++ 'main'

--color[=WHEN], --colour[=WHEN]
        Mark up the matching text with the expression stored in the
        GREP_COLOR or GREP_COLORS environment variable.  The possible
        values of WHEN can be `never', `always', or `auto', where `auto'
        marks up matches only when output on a terminal.  The default is
        `auto'.
--colors=COLORS, --colours=COLORS
        Use COLORS to mark up text.  COLORS is a colon-separated list of
        one or more parameters `sl=' (selected line), `cx=' (context line),
        `mt=' (matched text), `ms=' (match selected), `mc=' (match
        context), `fn=' (file name), `ln=' (line number), `cn=' (column
        number), `bn=' (byte offset), `se=' (separator).  Parameter values
        are ANSI SGR color codes or `k' (black), `r' (red), `g' (green),
        `y' (yellow), `b' (blue), `m' (magenta), `c' (cyan), `w' (white).
        Upper case specifies background colors.  A `+' qualifies a color as
        bright.  A foreground and a background color may be combined with
        font properties `n' (normal), `f' (faint), `h' (highlight), `i'
        (invert), `u' (underline).  Selectively overrides GREP_COLORS.
--tag[=TAG[,END]]
        Disables colors to mark up matches with TAG.  If END is specified,
        the end of a match is marked with END.  The default is `___'.
--pager[=COMMAND]
        When output is sent to the terminal, uses COMMAND to page through
        the output.  The default COMMAND is `less -R'.  Enables --heading
        and --line-buffered.
--pretty
        When output is sent to the terminal, enables --color, --heading, -T.

export GREP_COLORS='sl=1;100:cx=33:ms=1;4;32;100:mc=1;4;32:fn=1;32;100:ln=1;32:cn=1;32:bn=1;32:se=36'

export GREP_COLORS='sl=h+K:cx=y:ms=hug+K:mc=hug:fn=hg+K:ln=hg:cn=hg:bn=hg:se=c'

SET GREP_COLORS=sl=1;37:cx=33:mt=1;31:fn=1;35:ln=1;32:cn=1;32:bn=1;32:se=36

SET GREP_COLORS=""

export GREP_COLORS='mt=30;43:fn=1;32:ln=1;33:cn=1;33:bn=1;33'

ugrep --color -R -n -k -tc++ 'FIXME.*'

ugrep --pager -R -n -k -tc++ 'FIXME'

ugrep --color -y -UX 'PK\x03\x04' some.zip

ugrep --pretty -R -n -tc++ -f c++/includes -f c++/defines

ugrep --pretty --colors="ms=yi:fn=hyB" -R -n -tc++ -f c++/includes -f c++/defines

ugrep --color=always -R -n -tc++ -f c++/defines | ugrep 'FOO.*'

ugrep --color=always -R -n -Ocpp -f c++/defines | ugrep 'FOO.*'

tail -f /var/log/system.log | ugrep --color -i -w 'bug'

for tb in *.tar *.tar.gz *.tgz; do echo "$tb"; tar tfz "$tb" | ugrep '.*\.pdf$'; done

--cpp
        Output file matches in C++.  See also options --format and -u.
--csv
        Output file matches in CSV.  If -H, -n, -k, or -b is specified,
        additional values are output.  See also options --format and -u.
--json
        Output file matches in JSON.  If -H, -n, -k, or -b is specified,
        additional values are output.  See also options --format and -u.
--xml
        Output file matches in XML.  If -H, -n, -k, or -b is specified,
        additional values are output.  See also options --format and -u.

ugrep -tc++ -n --json 'TODO'

ugrep -tc++ -nk --xml 'TODO'

ugrep -tc++ --csv -Hnk 'TODO'

ugrep -o --cpp '<tr>.*</tr>' index.html > table.cpp

--format=FORMAT
        Output FORMAT-formatted matches.  See `man ugrep' section FORMAT
        for the `%' fields.  Options -A, -B, -C, -y, and -v have no effect.

ugrep --format='%O%~' 'href=' index.html

ugrep --format='%n%k: %O%~' 'href=' index.html

ugrep --format='%u%n%k: %O%~' 'href=' index.html

ugrep --format='%u%,%n' 'href=' index.html

ugrep --format='%o%~' "href=[\"'][^\"'][\"']" index.html

ugrep --format='%,%v' "href=[\"'][^\"'][\"']" index.html

ugrep --format='"%[,]$%H%N%K%B%V%~%u"' 'href=' index.html

ugrep --format-begin='[' \
       --format-open='%,%~  {%~    %[,%~    ]$%["file": ]H"matches": [' \
            --format='%,%~      { %[, ]$%["line": ]N%["column": ]K%["offset": ]B"match": %J }%u' \
      --format-close='%~    ]%~  }' \
        --format-end='%~]%~' \
      'href=' index.html

ugrep --format=":%f%~%n;%k %w:%O%~" 'href=' index.html

ugrep --format='%g: %o%~' 'foo|bar|baz' foobar.txt

ugrep -F -f foos --format='%g: %o%~' foobar.txt

ugrep --format='%[one|two|a word]g%~' '([fF]oo)|([bB]ar)|(\w+)' foobar.txt

ugrep -P --format='%[ and ]$%G%$%s%O%~' '(foo)|(ba((r)|(z)))' foobar.txt

ugrep -P --format='%[ and ]$%[foo|ba|r|z]G%$%s%O%~' '(foo)|(ba(?:(r)|(z)))' foobar.txt

ugrep -P --format='%[ and ]$%G%$%s%O%~' '(?P<foo>foo)|(?P<ba>ba(?:(?P<r>r)|(?P<z>z)))' foobar.txt

--format=FORMAT
        Output FORMAT-formatted matches.  See `man ugrep' section FORMAT
        for the `%' fields.  Options -A, -B, -C, -y, and -v have no effect.
-P, --perl-regexp
        Interpret PATTERN as a Perl regular expression.

ugrep -P '<td>(.*?)</td>' --format='%,%1' index.html

ugrep -P '<td>(.*?)</td>' --format='%1\n' index.html

ugrep -R -thtml,php -P '<[^<>]+href\h*=\h*.([^\x27"]+).' --format='%1%~' | sort -u

ugrep -R -thtml,php -P -f html/href --format='%1%~' | sort -u

ugrep -R -thtml,php -P '<script.*src\h*=\h*.(https?:[^\x27"]+).' --format='%1%~' | sort -u

--depth=[MIN,][MAX], -1, -2 ... -9, --10, --11 ...
        Restrict recursive searches from MIN to MAX directory levels deep,
        where -1 (--depth=1) searches the specified path without recursing
        into subdirectories.  Note that -3 -5, -3-5, or -35 searches 3 to 5
        levels deep.  Enables -R if -R or -r is not specified.
-m NUM, --max-count=NUM
        Stop reading the input after NUM matches for each file processed.
--max-files=NUM
        Restrict the number of files matched to NUM.  Note that --sort or
        -J1 may be specified to produce replicable results.  If --sort is
        specified, the number of threads spawned is limited to NUM.
--range=FIRST[,LAST]
        Start searching at line FIRST, stop at line LAST when specified.
--sort[=KEY]
        Displays matching files in the order specified by KEY in recursive
        searches.  KEY can be `name' to sort by pathname (default), `best'
        to sort by best match with option -Z (sort by best match requires
        two passes over the input files), `size' to sort by file size,
        `used' to sort by last access time, `changed' to sort by last
        modification time, and `created' to sort by creation time.  Sorting
        is reversed with `rname', `rbest', `rsize', `rused', `rchanged', or
        `rcreated'.  Archive contents are not sorted.  Subdirectories are
        sorted and displayed after matching files.  FILE arguments are
        searched in the same order as specified.  Normally ugrep displays
        matches in no particular order to improve performance.

ugrep -R -m10 -tc++ FIXME

ugrep -2 -m10 -tc++ FIXME

ugrep --sort -R --max-files=2 -tc++ FIXME

ugrep -n --range=2 -w make install.sh

ugrep -n --range=2,40 -w make install.sh

ugrep -y -n --range=2,40 -w make install.sh

ugrep -n -C1 --range=2 -m4 -w make install.sh

-Y, --empty
        Permits empty matches.  By default, empty matches are disabled,
        unless a pattern begins with `^' or ends with `$'.  Note that -Y
        when specified with an empty-matching pattern, such as x? and x*,
        match all input, not only lines containing the character `x'.

ugrep -l '^\h*$'

-i, --ignore-case
        Perform case insensitive matching.  By default, ugrep is case
        sensitive.  This option applies to ASCII letters only.
-j, --smart-case
        Perform case insensitive matching unless a pattern contains an
        upper case letter.  This option applies to ASCII letters only.

 ugrep -i 'todo' myfile.txt

 ugrep '(?i:todo) XXX' myfile.cpp

--sort[=KEY]
        Displays matching files in the order specified by KEY in recursive
        searches.  KEY can be `name' to sort by pathname (default), `best'
        to sort by best match with option -Z (sort by best match requires
        two passes over the input files), `size' to sort by file size,
        `used' to sort by last access time, `changed' to sort by last
        modification time, and `created' to sort by creation time.  Sorting
        is reversed with `rname', `rbest', `rsize', `rused', `rchanged', or
        `rcreated'.  Archive contents are not sorted.  Subdirectories are
        sorted and displayed after matching files.  FILE arguments are
        searched in the same order as specified.  Normally ugrep displays
        matches in no particular order to improve performance.

ugrep --sort -tc++ 'main'

ugrep --sort=rchanged -tc++ 'main'

ugrep -r -a -Ocpp -w 'int'

ugrep -r -a -u -Opython -w 'def'

ugrep -r --format='%n,%k:%o%~' '\w+'

ugrep -n -e '-o' script.sh

ugrep -n -- '-o' script.sh

ugrep -L -o -Otext '\n\z'

ugrep -o -ttext -e '^.*(?=\r?\n(===|---))' -e '^#{1,6}\h+.*'

ugrep -n -ttext -e '^```(.|\n)*?\n```' -e '^(\t|[ ]{4}).*'

ugrep -n -ttext -e '`[^`]+' -N '`[^`]*`'

UGREP(1)                         User Commands                        UGREP(1)



NAME
       ugrep -- file pattern searcher

SYNOPSIS
       ugrep [OPTIONS] [-A NUM] [-B NUM] [-C[NUM]] [PATTERN] [-e PATTERN]
             [-N PATTERN] [-f FILE] [-t TYPES] [-J [NUM]] [--sort[=KEY]]
             [--color[=WHEN]|--colour[=WHEN]] [--pager[=COMMAND]] [FILE ...]

DESCRIPTION
       The  ugrep 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) matches the input line.  A pattern
       matches multiple input lines if the RE in the pattern  matches  one  or
       more newlines in the input.  An empty pattern matches every line.  Each
       input line that matches at least one of the patterns is written to  the
       standard output.

       The ugrep utility accepts input of various encoding formats and normal-
       izes the output to UTF-8.  When a UTF byte order mark is present in the
       input,  the input is automatically normalized; otherwise, ugrep assumes
       the input is ASCII, UTF-8, or raw binary.  An input encoding format may
       be specified with option --encoding.

       The following options are available:

       -A NUM, --after-context=NUM
              Print  NUM  lines  of  trailing  context  after  matching lines.
              Places a --group-separator between contiguous groups of matches.
              See  also options -B, -C, and -y.  Disables multi-line matching.

       -a, --text
              Process a binary file as if it were text.  This is equivalent to
              the --binary-files=text option.  This option might output binary
              garbage to the terminal, which can have problematic consequences
              if the terminal driver interprets some of it as commands.

       -B NUM, --before-context=NUM
              Print  NUM  lines  of  leading  context  before  matching lines.
              Places a --group-separator between contiguous groups of matches.
              See  also options -A, -C, and -y.  Disables multi-line matching.

       -b, --byte-offset
              The offset in bytes of a matched line is displayed in  front  of
              the  respective  matched line.  If -u is specified, displays the
              offset for each pattern matched on the same line.  Byte  offsets
              are  exact  for  ASCII, UTF-8, and raw binary input.  Otherwise,
              the byte offset in the UTF-8 normalized input is displayed.

       --binary-files=TYPE
              Controls searching  and  reporting  pattern  matches  in  binary
              files.   TYPE  can  be `binary', `without-match`, `text`, `hex`,
              and `with-hex'.  The default is `binary' to search binary  files
              and  to  report  a  match  without displaying the match.  `with-
              out-match' ignores binary matches.   `text'  treats  all  binary
              files  as  text, which might output binary garbage to the termi-
              nal, which can have problematic  consequences  if  the  terminal
              driver  interprets  some  of  it as commands.  `hex' reports all
              matches in hexadecimal.  `with-hex' only reports binary  matches
              in  hexadecimal, leaving text matches alone.  A match is consid-
              ered binary when matching a zero byte  or  invalid  UTF.   Short
              options are -a, -I, -U, -W, and -X.

       --break
              Adds a line break between results from different files.

       -C[NUM], --context[=NUM]
              Print NUM lines of leading and trailing context surrounding each
              match.  The default is 2 and is equivalent to -A 2 -B 2.  Places
              a  --group-separator  between  contiguous groups of matches.  No
              whitespace may be given between -C and its argument NUM.

       -c, --count
              Only a count of selected lines is written  to  standard  output.
              If -o or -u is specified, counts the number of patterns matched.
              If -v is specified, counts the number of non-matching lines.

       --color[=WHEN], --colour[=WHEN]
              Mark up the matching text with  the  expression  stored  in  the
              GREP_COLOR  or  GREP_COLORS  environment  variable.  WHEN can be
              `never', `always', or `auto', where `auto' marks up matches only
              when output on a terminal.  The default is `auto'.

       --colors=COLORS, --colours=COLORS
              Use COLORS to mark up text.  COLORS is a colon-separated list of
              one or more parameters `sl='  (selected  line),  `cx='  (context
              line),  `mt='  (matched  text),  `ms='  (match  selected), `mc='
              (match context), `fn=' (file name), `ln=' (line  number),  `cn='
              (column number), `bn=' (byte offset), `se=' (separator).  Param-
              eter values are ANSI SGR color codes or `k' (black), `r'  (red),
              `g'  (green),  `y'  (yellow),  `b'  (blue),  `m'  (magenta), `c'
              (cyan), `w' (white).  Upper case specifies background colors.  A
              `+'  qualifies a color as bright.  A foreground and a background
              color may be combined with font  properties  `n'  (normal),  `f'
              (faint), `h' (highlight), `i' (invert), `u' (underline).  Selec-
              tively overrides GREP_COLORS.

       --no-confirm
              Do not confirm actions in -Q query mode.  The  default  is  con-
              firm.

       --cpp  Output file matches in C++.  See also options --format and -u.

       --csv  Output  file matches in CSV.  If -H, -n, -k, or -b is specified,
              additional values are output.  See also options --format and -u.

       -D ACTION, --devices=ACTION
              If  an  input  file  is  a device, FIFO or socket, use ACTION to
              process it.  By default, ACTION  is  `skip',  which  means  that
              devices are silently skipped.  If ACTION is `read', devices read
              just as if they were ordinary files.

       -d ACTION, --directories=ACTION
              If an input file is a directory, use ACTION to process  it.   By
              default,  ACTION  is  `skip',  i.e.,  silently  skip directories
              unless specified on the command line.  If ACTION is `read', warn
              when  directories  are  read  as input.  If ACTION is `recurse',
              read all files under each directory, recursively, following sym-
              bolic  links  only  if  they  are  on the command line.  This is
              equivalent  to  the  -r  option.    If   ACTION   is   `derefer-
              ence-recurse', read all files under each directory, recursively,
              following symbolic links.  This is equivalent to the -R  option.

       --depth=[MIN,][MAX], -1, -2 ... -9, --10, --11 ...
              Restrict  recursive  searches  from  MIN to MAX directory levels
              deep, where -1 (--depth=1) searches the specified  path  without
              recursing  into  subdirectories.   Note that -3 -5, -3-5, or -35
              search 3 to 5 levels deep.  Enables -R if -R or -r is not speci-
              fied.

       -E, --extended-regexp
              Interpret  patterns as extended regular expressions (EREs). This
              is the default.

       -e PATTERN, --regexp=PATTERN
              Specify a PATTERN used during the search of the input: an  input
              line  is  selected  if it matches any of the specified patterns.
              Note that longer patterns take precedence over shorter patterns.
              This  option is most useful when multiple -e options are used to
              specify multiple patterns, when a pattern  begins  with  a  dash
              (`-'),  to  specify  a pattern after option -f or after the FILE
              arguments.

       --encoding=ENCODING
              The encoding  format  of  the  input,  where  ENCODING  can  be:
              `binary',  `ASCII',  `UTF-8',  `UTF-16', `UTF-16BE', `UTF-16LE',
              `UTF-32',  `UTF-32BE',   `UTF-32LE',   `LATIN1',   `ISO-8859-1',
              `ISO-8869-2',    `ISO-8869-3',    `ISO-8869-4',    `ISO-8869-5',
              `ISO-8869-6',    `ISO-8869-7',    `ISO-8869-8',    `ISO-8869-9',
              `ISO-8869-10',   `ISO-8869-11',   `ISO-8869-13',  `ISO-8869-14',
              `ISO-8869-15',  `ISO-8869-16',  `MAC',   `MACROMAN',   `EBCDIC',
              `CP437',   `CP850',   `CP858',   `CP1250',  `CP1251',  `CP1252',
              `CP1253',  `CP1254',  `CP1255',  `CP1256',  `CP1257',  `CP1258',
              `KOI8-R', `KOI8-U', `KOI8-RU'.

       --exclude=GLOB
              Skip files whose name matches GLOB using wildcard matching, same
              as -g !GLOB.  GLOB can use **, *, ?, and [...] as wildcards, and
              \  to  quote  a wildcard or backslash character literally.  When
              GLOB contains a `/',  full  pathnames  are  matched.   Otherwise
              basenames  are  matched.  When GLOB ends with a `/', directories
              are excluded as if --exclude-dir is specified.  Otherwise  files
              are  excluded.   Note that --exclude patterns take priority over
              --include patterns.  GLOB should  be  quoted  to  prevent  shell
              globbing.  This option may be repeated.

       --exclude-dir=GLOB
              Exclude  directories  whose  name  matches  GLOB  from recursive
              searches.  GLOB can use **, *, ?, and [...] as wildcards, and  \
              to quote a wildcard or backslash character literally.  When GLOB
              contains a `/', full pathnames are matched.  Otherwise basenames
              are  matched.   Note  that  --exclude-dir patterns take priority
              over --include-dir patterns.  GLOB should be quoted  to  prevent
              shell globbing.  This option may be repeated.

       --exclude-from=FILE
              Read  the  globs  from FILE and skip files and directories whose
              name matches one or more globs (as if specified by --exclude and
              --exclude-dir).   Lines  starting  with a `#' and empty lines in
              FILE are ignored.  When FILE is a `-', standard input  is  read.
              This option may be repeated.

       --exclude-fs=MOUNTS
              Exclude   file   systems  specified  by  MOUNTS  from  recursive
              searches, MOUNTS is a comma-separated list of  mount  points  or
              pathnames   of   directories   on   file   systems.   Note  that
              --exclude-fs mounts  take  priority  over  --include-fs  mounts.
              This option may be repeated.

       -F, --fixed-strings
              Interpret  pattern  as a set of fixed strings, separated by new-
              lines, any of which is to be matched.  This makes  ugrep  behave
              as fgrep.  If PATTERN or -e PATTERN is also specified, then this
              option does not apply to -f FILE patterns.

       -f FILE, --file=FILE
              Read newline-separated patterns from FILE.  White space in  pat-
              terns is significant.  Empty lines in FILE are ignored.  If FILE
              does not exist, the GREP_PATH environment variable  is  used  as
              path   to   FILE.    If   that   fails,   looks   for   FILE  in
              /usr/local/share/ugrep/patterns.  When FILE is a  `-',  standard
              input is read.  Empty files contain no patterns; thus nothing is
              matched.  This option may be repeated.

       --filter=COMMANDS
              Filter files through the specified COMMANDS first before search-
              ing.   COMMANDS  is  a  comma-separated  list  of  `exts:command
              [option ...]', where `exts' is a comma-separated list  of  file-
              name  extensions  and `command' is a filter utility.  The filter
              utility should read from standard input and  write  to  standard
              output.  Files matching one of `exts' are filtered.  When `exts'
              is `*', files with non-matching extensions are filtered.  One or
              more  `option'  separated by spacing may be specified, which are
              passed verbatim to the command.  A `%' as `option' expands  into
              the  pathname to search.  For example, --filter='pdf:pdftotext %
              -' searches PDF files.  The `%' expands into a `-' when  search-
              ing  standard input.  Option --label=.ext may be used to specify
              extension `ext' when searching standard input.

       --filter-magic-label=LABEL:MAGIC
              Associate LABEL with files whose signature "magic  bytes"  match
              the  MAGIC  regex  pattern.   Only  files  that have no filename
              extension are labeled, unless +LABEL is specified.   When  LABEL
              matches  an extension specified in --filter=COMMANDS, the corre-
              sponding command is invoked.  This option may be repeated.

       --format=FORMAT
              Output FORMAT-formatted matches.  See `man ugrep' section FORMAT
              for the `%' fields.

       --free-space
              Spacing (blanks and tabs) in regular expressions are ignored.

       -G, --basic-regexp
              Interpret pattern as a basic regular expression, i.e. make ugrep
              behave as traditional grep.

       -g GLOB, --glob=GLOB
              Search  only  files   whose   name   matches   GLOB,   same   as
              --include=GLOB.   When  GLOB is preceded by a `!' or a `^', skip
              files whose name matches GLOB,  same  as  --exclude=GLOB.   GLOB
              should  be quoted to prevent shell globbing.  This option may be
              repeated.

       --group-separator[=SEP]
              Use SEP as a group separator for context options -A, -B, and -C.
              The default is a double hyphen (`--').

       -H, --with-filename
              Always  print  the  filename  with  output  lines.   This is the
              default when there is more than one file to search.

       -h, --no-filename
              Never print filenames with output lines.  This  is  the  default
              when  there is only one file (or only standard input) to search.

       --heading, -+
              Group matches per file.  Adds a heading and a line break between
              results from different files.

       --help Print a help message.

       --hexdump=[1-8][b][c][h]
              Output  matches  in 1 to 8 columns of 8 hexadecimal octets.  The
              default is 2 columns or 16 octets per line.  Option `b'  removes
              all  space  breaks,  `c'  hides  the  character  column, and `h'
              removes the hex spacing only.  Enables -X if -W  or  -X  is  not
              specified.

       --hidden, -.
              Search hidden files and directories.

       -I     Ignore  matches  in  binary files.  This option is equivalent to
              the --binary-files=without-match option.

       -i, --ignore-case
              Perform case insensitive matching.  By default,  ugrep  is  case
              sensitive.  This option applies to ASCII letters only.

       --ignore-files[=FILE]
              Ignore  files  and  directories  matching the globs in each FILE
              that is encountered in recursive searches.  The default FILE  is
              `.gitignore'.   Matching  files  and  directories located in the
              directory tree rooted at a FILE's location are ignored by tempo-
              rarily  overriding the --exclude and --exclude-dir globs.  Files
              and directories that are explicitly specified  as  command  line
              arguments are never ignored.  This option may be repeated.

       --include=GLOB
              Search  only files whose name matches GLOB using wildcard match-
              ing, same as -g GLOB.  GLOB can use **, *, ?, and [...] as wild-
              cards,  and  \ to quote a wildcard or backslash character liter-
              ally.  When GLOB contains a `/',  full  pathnames  are  matched.
              Otherwise  basenames  are  matched.   When GLOB ends with a `/',
              directories are included as if --include-dir is specified.  Oth-
              erwise  files  are  included.  Note that --exclude patterns take
              priority over --include patterns.  GLOB should be quoted to pre-
              vent shell globbing.  This option may be repeated.

       --include-dir=GLOB
              Only  directories whose name matches GLOB are included in recur-
              sive searches.  GLOB can use **, *, ?, and [...]  as  wildcards,
              and  \  to  quote  a  wildcard or backslash character literally.
              When GLOB contains a `/', full pathnames are matched.  Otherwise
              basenames  are  matched.   Note that --exclude-dir patterns take
              priority over --include-dir patterns.  GLOB should be quoted  to
              prevent shell globbing.  This option may be repeated.

       --include-from=FILE
              Read  the  globs from FILE and search only files and directories
              whose name matches  one  or  more  globs  (as  if  specified  by
              --include  and  --include-dir).   Lines  starting with a `#' and
              empty lines in FILE are ignored.  When FILE is a  `-',  standard
              input is read.  This option may be repeated.

       --include-fs=MOUNTS
              Only  file systems specified by MOUNTS are included in recursive
              searches.  MOUNTS is a comma-separated list of mount  points  or
              pathnames   of  directories  on  file  systems.   --include-fs=.
              restricts recursive searches to the file system of  the  working
              directory  only.   Note  that  --exclude-fs mounts take priority
              over --include-fs mounts.  This option may be repeated.

       -J NUM, --jobs=NUM
              Specifies the number of threads spawned  to  search  files.   By
              default,  or when NUM is specified as zero, an optimum number of
              threads is spawned to search files simultaneously.  -J1 disables
              threading: files are searched in the same order as specified.

       -j, --smart-case
              Perform  case  insensitive matching unless a pattern contains an
              upper case letter.  This option applies to ASCII letters only.

       --json Output file matches in JSON.  If -H, -n, -k, or -b is specified,
              additional values are output.  See also options --format and -u.

       -K FIRST[,LAST], --range=FIRST[,LAST]
              Start searching at line FIRST, stop at line LAST when specified.

       -k, --column-number
              The  column number of a matched pattern is displayed in front of
              the respective matched line, starting at  column  1.   Tabs  are
              expanded when columns are counted, see also option --tabs.

       -L, --files-without-match
              Only  the names of files not containing selected lines are writ-
              ten to standard output.  Pathnames  are  listed  once  per  file
              searched.   If  the  standard  input  is  searched,  the  string
              ``(standard input)'' is written.

       -l, --files-with-matches
              Only the names of files containing selected lines are written to
              standard  output.   ugrep  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 ``(standard input)'' is written.

       --label=LABEL
              Displays the LABEL value when input is read from standard  input
              where  a file name would normally be printed in the output.  The
              default value is `(standard input)'.

       --line-buffered
              Force output to be line buffered instead of block buffered.

       -M MAGIC, --file-magic=MAGIC
              Only files matching the signature pattern  MAGIC  are  searched.
              The  signature "magic bytes" at the start of a file are compared
              to the MAGIC regex pattern.  When matching,  the  file  will  be
              searched.   When MAGIC is preceded by a `!' or a `^', skip files
              with matching MAGIC signatures.  This option may be repeated and
              may  be  combined  with  options -O and -t to expand the search.
              Every file on the search path is read,  making  searches  poten-
              tially more expensive.

       -m NUM, --max-count=NUM
              Stop reading the input after NUM matches in each input file.

       --match
              Match all input.  Same as specifying an empty pattern to search.

       --max-files=NUM
              Restrict the number of files matched to NUM.  Note  that  --sort
              or  -J1  may  be  specified  to  produce replicable results.  If
              --sort is specified, the number of threads spawned is limited to
              NUM.

       --[no-]mmap[=MAX]
              Do  (not)  use  memory maps to search files.  By default, memory
              maps are used under certain conditions to  improve  performance.
              When MAX is specified, use up to MAX mmap memory per thread.

       -N PATTERN, --neg-regexp=PATTERN
              Specify  a negative PATTERN used during the search of the input:
              an input line is selected only if it matches any of  the  speci-
              fied  patterns  when PATTERN does not match.  Same as -e (?^PAT-
              TERN).  Negative PATTERN matches are removed  before  any  other
              specified  patterns are matched.  Note that longer patterns take
              precedence over shorter patterns.  This option may be  repeated.

       -n, --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.

       --no-group-separator
              Removes  the  group  separator  line from the output for context
              options -A, -B, and -C.

       -O EXTENSIONS, --file-extensions=EXTENSIONS
              Search only files whose filename extensions match the  specified
              comma-separated  list  of  EXTENSIONS, same as --include='*.ext'
              for each `ext' in EXTENSIONS.  When `ext' is preceded by  a  `!'
              or  a  `^',  skip files whose filename extensions matches `ext',
              same as --exclude='*.ext'.  This option may be repeated and  may
              be  combined  with  options  -M  and  -t to expand the recursive
              search.

       -o, --only-matching
              Print only the matching part  of  lines.   When  multiple  lines
              match,  the  line numbers with option -n are displayed using `|'
              as the field separator for each additional line matched  by  the
              pattern.   If  -u is specified, ungroups multiple matches on the
              same line.  This option cannot be combined with options -A,  -B,
              -C, -v, and -y.

       --only-line-number
              The line number of the matching line in the file is output with-
              out displaying the match.  The line number counter is reset  for
              each file processed.

       -P, --perl-regexp
              Interpret PATTERN as a Perl regular expression using PCRE2.

       -p, --no-dereference
              If  -R  or -r is specified, no symbolic links are followed, even
              when they are specified on the command line.

       --pager[=COMMAND]
              When output is sent  to  the  terminal,  uses  COMMAND  to  page
              through  the output.  The default COMMAND is `less -R'.  Enables
              --heading and --line-buffered.

       --pretty
              When output is sent to a terminal, enables  --color,  --heading,
              -T.

       -Q[DELAY], --query[=DELAY]
              Query  mode:  user  interface  to  perform interactive searches.
              This mode requires an ANSI capable terminal.  An optional  DELAY
              argument  may  be  specified  to reduce or increase the response
              time to execute searches after the last key press, in increments
              of  100ms,  where  the default is 5 (0.5s delay).  No whitespace
              may be given between -Q and its argument  DELAY.   Initial  pat-
              terns  may be specified with -e PATTERN, i.e. a PATTERN argument
              requires option -e.  Press F1 or CTRL-Z to view the help screen.
              Press  F2  or  CTRL-Y  to invoke an editor to edit the file dis-
              played on screen.  The editor  is  taken  from  the  environment
              variable  GREP_EDIT  if  defined,  or EDITOR if GREP_EDIT is not
              defined.  Enables --heading.

       -q, --quiet, --silent
              Quiet mode: suppress all output.  ugrep will only search until a
              match  has  been  found, making searches potentially less expen-
              sive.

       -R, --dereference-recursive
              Recursively read all files under  each  directory.   Follow  all
              symbolic  links,  unlike  -r.   When -J1 is specified, files are
              searched in the same order as specified.  Note that when no FILE
              arguments  are  specified  and  input  is  read from a terminal,
              recursive searches are performed as if -R is specified.

       -r, --recursive
              Recursively read all files under each directory, following  sym-
              bolic  links  only if they are on the command line.  When -J1 is
              specified, files are searched in the same order as specified.

       --range=FIRST[,LAST]
              Start searching at line FIRST, stop at line LAST when specified.

       -S, --dereference
              If  -r  is  specified, all symbolic links are followed, like -R.
              The default is not to follow symbolic links.

       -s, --no-messages
              Silent mode: nonexistent and unreadable files are ignored,  i.e.
              their error messages are suppressed.

       --separator[=SEP]
              Use  SEP as field separator between file name, line number, col-
              umn number, byte offset, and the matched line.  The default is a
              colon (`:').

       --sort[=KEY]
              Displays  matching files in the order specified by KEY in recur-
              sive searches.  KEY can be `name' to sort by pathname (default),
              `best'  to sort by best match with option -Z (sort by best match
              requires two passes over the input files),  `size'  to  sort  by
              file size, `used' to sort by last access time, `changed' to sort
              by last modification time, and `created'  to  sort  by  creation
              time.   Sorting  is  reversed  with  `rname',  `rbest', `rsize',
              `rused', `rchanged', or `rcreated'.  Archive  contents  are  not
              sorted.   Subdirectories are sorted and displayed after matching
              files.  FILE arguments are searched in the same order as  speci-
              fied.  Normally ugrep displays matches in no particular order to
              improve performance.

       --stats
              Display statistics  on  the  number  of  files  and  directories
              searched, and the inclusion and exclusion constraints applied.

       -T, --initial-tab
              Add  a  tab space to separate the file name, line number, column
              number, and byte offset with the matched line.

       -t TYPES, --file-type=TYPES
              Search only files associated with TYPES, a comma-separated  list
              of  file types.  Each file type corresponds to a set of filename
              extensions passed to option -O.  For capitalized file types, the
              search is expanded to include files with matching file signature
              magic bytes, as if passed to option -M.  When a type is preceded
              by  a  `!' or a `^', excludes files of the specified type.  This
              option may be repeated.  The possible file types can  be  (where
              -tlist  displays a detailed list): `actionscript', `ada', `asm',
              `asp', `aspx', `autoconf', `automake',  `awk',  `Awk',  `basic',
              `batch', `bison', `c', `c++', `clojure', `csharp', `css', `csv',
              `dart', `Dart', `delphi',  `elisp',  `elixir',  `erlang',  `for-
              tran',  `gif',  `Gif', `go', `groovy', `gsp', `haskell', `html',
              `jade', `java', `jpeg', `Jpeg', `js',  `json',  `jsp',  `julia',
              `kotlin',  `less',  `lex',  `lisp',  `lua', `m4', `make', `mark-
              down', `matlab',  `node',  `Node',  `objc',  `objc++',  `ocaml',
              `parrot',  `pascal', `pdf', `Pdf', `perl', `Perl', `php', `Php',
              `png', `Png', `prolog', `python', `Python', `r',  `rpm',  `Rpm',
              `rst',  `rtf', `Rtf', `ruby', `Ruby', `rust', `scala', `scheme',
              `shell', `Shell', `smalltalk',  `sql',  `svg',  `swift',  `tcl',
              `tex',  `text',  `tiff',  `Tiff', `tt', `typescript', `verilog',
              `vhdl', `vim', `xml', `Xml', `yacc', `yaml'.

       --tabs=NUM
              Set the tab size to NUM to expand tabs for option -k.  The value
              of NUM may be 1, 2, 4, or 8.  The default tab size is 8.

       --tag[=TAG[,END]]
              Disables  colors  to mark up matches with TAG.  If END is speci-
              fied, the end of a match is marked with  END.   The  default  is
              `___'.

       -U, --binary
              Disables Unicode matching for binary file matching, forcing PAT-
              TERN to match bytes, not Unicode characters.   For  example,  -U
              '\xa3'  matches  byte A3 (hex) instead of the Unicode code point
              U+00A3 represented by the two-byte UTF-8 sequence C2 A3.

       -u, --ungroup
              Do not group multiple pattern matches on the same matched  line.
              Output the matched line again for each additional pattern match,
              using `+' as the field separator.

       -V, --version
              Display version information and exit.

       -v, --invert-match
              Selected lines are those not matching any of the specified  pat-
              terns.

       -W, --with-hex
              Output  binary  matches  in  hexadecimal,  leaving  text matches
              alone.  This option is equivalent to the --binary-files=with-hex
              option.

       -w, --word-regexp
              The  PATTERN  is  searched for as a word (as if surrounded by \<
              and \>).  If a PATTERN is specified (or -e PATTERN  or  -N  PAT-
              TERN), then this option does not apply to -f FILE patterns.

       -X, --hex
              Output matches in hexadecimal.  This option is equivalent to the
              --binary-files=hex option.  See also option --hexdump.

       -x, --line-regexp
              Only input lines selected against the entire PATTERN is  consid-
              ered  to  be matching lines (as if surrounded by ^ and $).  If a
              PATTERN is specified (or -e PATTERN or -N  PATTERN),  then  this
              option does not apply to -f FILE patterns.

       --xml  Output  file matches in XML.  If -H, -n, -k, or -b is specified,
              additional values are output.  See also options --format and -u.

       -Y, --empty
              Permits  empty matches.  By default, empty matches are disabled,
              unless a pattern begins with `^' or ends with  `$'.   With  this
              option,  empty-matching  pattern,  such  as x? and x*, match all
              input, not only lines containing the character `x'.

       -y, --any-line
              Any matching or non-matching line is output.  Non-matching lines
              are  output  with  the  `-' separator as context of the matching
              lines.  See also options -A, -B, and  -C.   Disables  multi-line
              matching.

       -Z[MAX], --fuzzy[=MAX]
              Fuzzy  mode:  report  approximate  pattern  matches  within  MAX
              errors.  By default, MAX is 1: one deletion, insertion  or  sub-
              stitution  is  allowed.   When  `+' and/or `-' precede MAX, only
              insertions and/or deletions are allowed.  When `~' precedes MAX,
              substitution  counts as one error.  For example, -Z+~3 allows up
              to three insertions or substitutions,  but  no  deletions.   The
              first character of an approximate match always matches the begin
              of a pattern.  Option --sort=best orders matching files by  best
              match.   No whitespace may be given between -Z and its argument.

       -z, --decompress
              Decompress files to search, when compressed.   Archives  (.cpio,
              .pax,  .tar, and .zip) and compressed archives (e.g. .taz, .tgz,
              .tpz, .tbz, .tbz2, .tb2, .tz2, .tlz, and .txz) are searched  and
              matching  pathnames  of  files in archives are output in braces.
              If -g, -O, -M, or -t is specified,  searches  files  within  ar-
              chives  whose  name matches globs, matches file name extensions,
              matches file signature  magic  bytes,  or  matches  file  types,
              respectively.   Supported  compression formats: gzip (.gz), com-
              press (.Z), zip, bzip2 (requires suffix .bz, .bz2, .bzip2, .tbz,
              .tbz2,  .tb2,  .tz2),  lzma and xz (requires suffix .lzma, .tlz,
              .xz, .txz).

       -0, --null
              Prints a zero-byte (NUL) after the file name.  This  option  can
              be  used  with commands such as `find -print0' and `xargs -0' to
              process arbitrary file names.

       If no FILE arguments are specified and input is read from  a  terminal,
       recursive searches are performed as if -R is specified.  To force read-
       ing from standard input, specify `-' as the FILE argument.

       A `--' signals the end of options; the rest of the parameters are  FILE
       arguments, allowing filenames to begin with a `-' character.

       The  regular expression pattern syntax is an extended form of the POSIX
       ERE syntax.  For an overview of the syntax see README.md or visit:

              https://github.com/Genivia/ugrep

       Note that `.' matches any non-newline character.  Pattern `\n'  matches
       a  newline character.  Multiple lines may be matched with patterns that
       match newlines, unless one or more of the context options -A,  -B,  -C,
       or -y is used, or option -v is used.

EXIT STATUS
       The ugrep utility exits with one of the following values:

       0      One or more lines were selected.

       1      No lines were selected.

       >1     An error occurred.

       If  -q  or --quiet or --silent is used and a line is selected, the exit
       status is 0 even if an error occurred.

GLOBBING
       Globbing is used by options -g,  --include,  --include-dir,  --include-
       from,  --exclude,  --exclude-dir, --exclude-from to match pathnames and
       basenames in recursive searches.  Globbing  supports  gitignore  syntax
       and the corresponding matching rules.  When a glob ends in a path sepa-
       rator it matches directories as if --include-dir  or  --exclude-dir  is
       specified.   When  a glob contains a path separator `/', the full path-
       name is matched.  Otherwise the basename of  a  file  or  directory  is
       matched.   For  example,  *.h  matches  foo.h  and  bar/foo.h.  bar/*.h
       matches bar/foo.h but not foo.h and not bar/bar/foo.h.  Use  a  leading
       `/' to force /*.h to match foo.h but not bar/foo.h.

       When  a  glob starts with a `!' as specified with -g!GLOB, or specified
       in a FILE with --include-from=FILE or --exclude-from=FILE, its match is
       negated.

       Glob Syntax and Conventions

       *      Matches anything except a /.

       ?      Matches any one character except a /.

       [a-z]  Matches one character in the selected range of characters.

       [^a-z] Matches one character not in the selected range of characters.

       [!a-z] Matches one character not in the selected range of characters.

       /      When  used at the begin of a glob, matches if pathname has no /.
              When used at the end of a glob, matches directories only.

       **/    Matches zero or more directories.

       /**    When used at the end of a glob, matches everything after the  /.

       \?     Matches a ? (or any character specified after the backslash).

       Glob Matching Examples

       *      Matches a, b, x/a, x/y/b

       a      Matches a, x/a, x/y/a,       but not b, x/b, a/a/b

       /*     Matches a, b,                but not x/a, x/b, x/y/a

       /a     Matches a,                   but not x/a, x/y/a

       a?b    Matches axb, ayb,            but not a, b, ab, a/b

       a[xy]b Matches axb, ayb             but not a, b, azb

       a[a-z]b
              Matches aab, abb, acb, azb,  but not a, b, a3b, aAb, aZb

       a[^xy]b
              Matches aab, abb, acb, azb,  but not a, b, axb, ayb

       a[^a-z]b
              Matches a3b, aAb, aZb        but not a, b, aab, abb, acb, azb

       a/*/b  Matches a/x/b, a/y/b,        but not a/b, a/x/y/b

       **/a   Matches a, x/a, x/y/a,       but not b, x/b.

       a/**/b Matches a/b, a/x/b, a/x/y/b, but not x/a/b, a/b/x

       a/**   Matches a/x, a/y, a/x/y,     but not a, b/x

       a\?b   Matches a?b,                 but not a, b, ab, axb, a/b

       Lines  in  the --exclude-from and --include-from files are ignored when
       empty or start with a `#'.  When a glob is prefixed with  `!',  negates
       the match.

ENVIRONMENT
       GREP_PATH
              May  be  used to specify a file path to pattern files.  The file
              path is used by option -f to open a pattern file, when the  file
              cannot be opened.

       GREP_COLOR
              May  be used to specify ANSI SGR parameters to highlight matches
              when option --color is used, e.g. 1;35;40 shows pattern  matches
              in bold magenta text on a black background.  Deprecated in favor
              of GREP_COLORS, but still supported.

       GREP_COLORS
              May be used to specify ANSI SGR parameters to highlight  matches
              and  other attributes when option --color is used.  Its value is
              a colon-separated list of ANSI SGR parameters that  defaults  to
              cx=33:mt=1;31:fn=1;35:ln=1;32:cn=1;32:bn=1;32:se=36.   The  mt=,
              ms=, and mc= capabilities  of  GREP_COLORS  have  priority  over
              GREP_COLOR.  Option --colors has priority over GREP_COLORS.

GREP_COLORS
       Colors  are  specified as string of colon-separated ANSI SGR parameters
       of the form `what=substring', where `substring'  is  a  semicolon-sepa-
       rated  list  of  ANSI SGR codes or `k' (black), `r' (red), `g' (green),
       `y' (yellow), `b' (blue),  `m'  (magenta),  `c'  (cyan),  `w'  (white).
       Upper  case  specifies  background  colors.  A `+' qualifies a color as
       bright.  A foreground and a background color may be combined  with  one
       or more font properties `n' (normal), `f' (faint), `h' (highlight), `i'
       (invert), `u' (underline).  Substrings may be specified for:

       sl=    SGR substring for selected lines.

       cx=    SGR substring for context lines.

       rv     Swaps the sl= and cx= capabilities when -v is specified.

       mt=    SGR substring for matching text in any matching line.

       ms=    SGR substring for matching text in a selected  line.   The  sub-
              string mt= by default.

       mc=    SGR  substring  for  matching  text in a context line.  The sub-
              string mt= by default.

       fn=    SGR substring for file names.

       ln=    SGR substring for line numbers.

       cn=    SGR substring for column numbers.

       bn=    SGR substring for byte offsets.

       se=    SGR substring for separators.

FORMAT
       Option --format=FORMAT specifies an output  format  for  file  matches.
       Fields may be used in FORMAT, which expand into the following values:

       %[ARG]F
              if option -H is used: ARG, the file pathname, and separator.

       %f     the file pathname.

       %z     the file pathname in a (compressed) archive.

       %[ARG]H
              if option -H is used: ARG, the quoted pathname, and separator.

       %h     the quoted file pathname.

       %[ARG]N
              if option -n is used: ARG, the line number and separator.

       %n     the line number of the match.

       %[ARG]K
              if option -k is used: ARG, the column number and separator.

       %k     the column number of the match.

       %[ARG]B
              if option -b is used: ARG, the byte offset and separator.

       %b     the byte offset of the match.

       %[ARG]T
              if option -T is used: ARG and a tab character.

       %t     a tab character.

       %[SEP]$
              set field separator to SEP for the rest of the format fields.

       %[ARG]<
              if the first match: ARG.

       %[ARG]>
              if not the first match: ARG.

       %,     if not the first match: a comma, same as %[,]>.

       %:     if not the first match: a colon, same as %[:]>.

       %;     if not the first match: a semicolon, same as %[;]>.

       %|     if not the first match: a verical bar, same as %[|]>.

       %[ARG]S
              if not the first match: ARG and separator, see also %$.

       %s     the separator, see also %S and %$.

       %~     a newline character.

       %m     the number of matches or matched files.

       %O     the matching line is output as a raw string of bytes.

       %o     the match is output as a raw string of bytes.

       %Q     the matching line as a quoted string, \" and \\ replace " and \.

       %q     the match as a quoted string, \" and \\ replace " and \.

       %C     the matching line formatted as a quoted C/C++ string.

       %c     the match formatted as a quoted C/C++ string.

       %J     the matching line formatted as a quoted JSON string.

       %j     the match formatted as a quoted JSON string.

       %V     the matching line formatted as a quoted CSV string.

       %v     the match formatted as a quoted CSV string.

       %X     the matching line formatted as XML character data.

       %x     the match formatted as XML character data.

       %w     the width of the match, counting wide characters.

       %d     the size of the match, counting bytes.

       %e     the ending byte offset of the match.

       %Z     the edit distance cost of an approximate match with option -Z

       %u     select unique lines only, unless option -u is used.

       %1     the first regex group capture of the match,  and  so  on  up  to
              group %9, same as %[1]#; requires option -P.

       %[NUM]#
              the regex group capture NUM; requires option -P.

       %G     list of group capture indices/names of the match (option -P).

       %[NAME1|NAME2|...]G
              NAMEs corresponding to the group capture indices of the match.

       %g     the group capture index/name of the match or 1 (option -P).

       %[NAME1|NAME2|...]g
              NAME corresponding to the group capture index of the match.

       %%     the percentage sign.

       The  [ARG]  part  of  a  field  is  optional  and may be omitted.  When
       present, the argument must be placed in [] brackets, for example  %[,]F
       to output a comma, the pathname, and a separator.

       %[SEP]$ and %u are switches and do not send anything to the output.

       The  separator used by %F, %H, %N, %K, %B, %S, and %G may be changed by
       preceding the field by %[SEP]$.   When  [SEP]  is  not  provided,  this
       reverts  the separator to the default separator or the separator speci-
       fied with --separator.

       Formatted output is written for each matching pattern, which means that
       a  line may be output multiple times when patterns match more than once
       on the same line.  When field %u is found  anywhere  in  the  specified
       format  string,  matching  lines are output only once unless option -u,
       --ungroup is used or when a newline is matched.

       Additional formatting options:

       --format-begin=FORMAT
              the FORMAT when beginning the search.

       --format-open=FORMAT
              the FORMAT when opening a file and a match was found.

       --format-close=FORMAT
              the FORMAT when closing a file and a match was found.

       --format-end=FORMAT
              the FORMAT when ending the search.

       The context options -A, -B, -C, -y, and options -v, --break, --heading,
       --color, -T, and --null have no effect on the formatted output.

EXAMPLES
       Display lines containing the word `patricia' in `myfile.txt':

              $ ugrep -w 'patricia' myfile.txt

       Count the number of lines containing the word `patricia' or `Patricia`:

              $ ugrep -cw '[Pp]atricia' myfile.txt

       Count the number of words `patricia' of any mixed case:

              $ ugrep -cowi 'patricia' myfile.txt

       List all Unicode words in a file:

              $ ugrep -o '\w+' myfile.txt

       List all ASCII words in a file:

              $ ugrep -o '[[:word:]]+' myfile.txt

       List the laughing face emojis (Unicode code points U+1F600 to U+1F60F):

              $ ugrep -o '[\x{1F600}-\x{1F60F}]' myfile.txt

       Check if a file contains any non-ASCII (i.e. Unicode) characters:

              $ ugrep -q '[^[:ascii:]]' myfile.txt && echo "contains Unicode"

       Display the line and column number of `FIXME' in C++ files using recur-
       sive search, with one line of context before and after a matched line:

              $ ugrep --color -C1 -r -n -k -tc++ 'FIXME'

       List the C/C++ comments in a file with line numbers:

              $ ugrep -n -e '//.*' -e '/\*([^*]|(\*+[^*/]))*\*+\/' myfile.cpp

       The same, but using predefined pattern c++/comments:

              $ ugrep -n -f c++/comments myfile.cpp

       List the lines that need fixing in a C/C++ source file by  looking  for
       the word `FIXME' while skipping any `FIXME' in quoted strings:

              $ ugrep -e 'FIXME' -N '"(\\.|\\\r?\n|[^\\\n"])*"' myfile.cpp

       The same, but using predefined pattern cpp/zap_strings:

              $ ugrep -e 'FIXME' -f cpp/zap_strings myfile.cpp

       Find lines with `FIXME' or `TODO':

              $ ugrep -n -e 'FIXME' -e 'TODO' myfile.cpp

       Find lines with `FIXME' that also contain the word `urgent':

              $ ugrep -n 'FIXME' myfile.cpp | ugrep -w 'urgent'

       Find lines with `FIXME' but not the word `later':

              $ ugrep -n 'FIXME' myfile.cpp | ugrep -v -w 'later'

       Output a list of line numbers of lines with `FIXME' but not `later':

              $ ugrep -n 'FIXME' myfile.cpp | ugrep -vw 'later' |
                ugrep -P '^(\d+)' --format='%,%n'

       Monitor the system log for bug reports:

              $ tail -f /var/log/system.log | ugrep --color -i -w 'bug'

       Find lines with `FIXME' in the C/C++ files stored in a tarball:

              $ ugrep -z -tc++ -n 'FIXME' project.tgz

       Recursively search for the word `copyright' in cpio/jar/pax/tar/zip ar-
       chives, compressed and regular files, and in PDFs using a PDF filter:

              $ ugrep -r -z -w --filter='pdf:pdftotext % -' 'copyright'

       Match the binary pattern `A3hhhhA3hh' (hex) in a  binary  file  without
       Unicode  pattern  matching  -U (which would otherwise match `\xaf' as a
       Unicode character U+00A3 with UTF-8 byte sequence C2  A3)  and  display
       the results in hex with -X using `less -R' as a pager:

              $ ugrep --pager -UXo '\xa3[\x00-\xff]{2}\xa3[\x00-\xff]' a.out

       Hexdump an entire file in color:

              $ ugrep --color -X '' a.out

       List all files that are not ignored by one or more `.gitignore':

              $ ugrep -l '' --ignore-files

       List  all files containing a RPM signature, located in the `rpm' direc-
       tory and recursively below up to two levels deeper (3 levels):

              $ ugrep -3 -l -tRpm '' rpm/

       Display all words in a MacRoman-encoded file that has CR newlines:

              $ ugrep --encoding=MACROMAN '\w+' mac.txt

BUGS
       Report bugs at:

              https://github.com/Genivia/ugrep/issues


LICENSE
       ugrep is released under the BSD-3 license.  All parts of  the  software
       have  reasonable  copyright terms permitting free redistribution.  This
       includes the ability to reuse all or parts of the ugrep source tree.

SEE ALSO
       grep(1).



ugrep 2.2.0                      June 02, 2020                        UGREP(1)