GREP is a filter that searches input files, or the standard input, for lines that contain matches for one or more patterns called regular expressions and displays those matching lines.
GREP combines most features of UNIX grep and fgrep. GREP has many other advantages over FIND besides using regular expressions:
The 16-bit version, GREP16, runs under DOS 2.0 or higher, including a DOS box under Windows. The 32-bit version, GREP32, requires a DOS box under Windows 98, Win95, or Win NT 4.0. (I fully expect it to run in Windows 2000, but have not tested it.)
The two executables operate the same and have the same features, except that GREP32 supports long filenames. If you typically run GREP in a DOS box under Windows 9x or NT, GREP32 is the one you want.
There is no special installation procedure. Simply move GREP16.EXE, GREP32.EXE, or both to any convenient directory in your path.
You may wish to rename the executable you use more often to the
simpler GREP.EXE. All the examples in this user guide will assume you've
done that. Otherwise, just substitute GREP16
or
GREP32
wherever you see GREP
in the examples.
GREP is shareware. If you use it past a 30-day evaluation period, you are morally and legally bound to register and pay for it. Please see the file LICENSE.TXT for full details, including support and warranty information.
The registered version offers these improvements over the evaluation version:
/F
option to search for multiple regular
expressions in one pass through the input file(s)
/Q
option to suppress program
logo and warning messages
/S
option (The evaluation version searches only two levels.)
grep /? | moreThe full command form is either of
grep [options] [regex] [<inputfile] [>outputfile] grep [options] [regex] inputfiles [>outputfile]In the first form, GREP is a filter, taking its input from the standard input (most likely piped from some other command). In the second form, GREP takes its input from any number of input files, possibly specified with paths and wild cards.
In both forms, the optional outputfile will receive the matching lines
(or other output, depending on the output
options). For output to the screen, omit >
and
outputfile.
regex is a regular expression; see
below for how to construct one. A regex is normally required on the
command line; however, if you use the
/F
option,
regexes will be taken from a file or the keyboard instead of the
command line.
The command-line options, and the
values returned through ERRORLEVEL
,
are explained below. You can actually put options anywhere on the command line,
not just before the regex. All the options are processed before any files are
scanned, so it doesn't matter whether a given option comes before or after the
files or between two file specs.
Example:
grep /I pic[t\s] \proj\*.cob >prnwill examine every COBOL source file in the PROJ directory and print every line that contains a picture clause ("pic" followed by either "t" or a space) in caps or lower case (the
/I
option).
grep /I /S pic[t\s] \*.cob >prnwill examine every COBOL source file in all directories on the current disk (the
/S
option).
GREP can read text files just fine, whether lines are separated by the DOS-style carriage return plus line feed or the UNIX-style line feed only. See below for binary files.
When telling GREP to read input files, you can specify them in the normal way with paths and wild cards. For example:
grep regex ..\*.c *.h d:\dir1\dir2\orich?.htmThe separator between directories in a path can be a backslash "\" or forward slash "/".
If input file names or paths contains spaces, you must enclose them in double quotes. This is a DOS restriction, not a feature only of GREP. For instance,
grep regex c:\Program Files\My Office\*contains three file specs, namely c:\Program, Files\My, and Office\*. That's probably not what you meant. Double quotes preserve your intended meaning:
grep regex "c:\Program Files\My Office\*"
GREP thinks that anything that starts with a hyphen is an option. So if a file name starts with a hyphen, use the standard DOS syntax for "current directory". For example, to search file -omega.txt, type
grep regex ./-omega.txt
/R
option for details.
If a text file contains null characters (ASCII 0) or Control-Z
characters (ASCII 26), GREP cannot process it correctly in text mode
and you must use the /R
option to invoke binary mode.
When reading a very long input text line, GREP processes it in chunks.
Please see the description of the /W
option for details.
abc*
to include all
files, with any extension or none, whose names start with abc; with
GREP16 you need abc*.*
to get the same
result. This matches what you get with a DIR command in
16-bit or 32-bit DOS.
/A
option.
dirname\*
or dirname\*.*
,
depending on your operating system. Like other warnings, this one will
never appear if the /Q
option
is in effect.
/S
option, GREP will search not only
the files indicated on the command line, but also the files in
subdirectories.
For example, with the command
grep /S regex \hazax*.* *.c g:\mumble\*.htmGREP will examine all files on the entire current drive whose names start with
hazax
; then it will look at all C source files
in the current directory and all subdirectories under it; finally it
will look at all HTML files in directory g:\mumble
and
all subdirectories under it.
Perhaps a more realistic example is this: you have a document about Vandelay Industries somewhere on your disk, but you can't remember where. This command should find it:
grep Vandelay /S \*.*(You can abbreviate
\*.*
to
\*
with GREP32.) You may also want to use the
/I
option if you can't remember whether
"Vandelay" was capitalized normally.
Subdirectory search follows the normal file-searching rules: hidden
and system subdirectories are normally ignored. (Yes, you have them if
you have Windows 9x.)
The /A
option
also applies during subdirectory search:
with /S
and /A
together, GREP will search every subdirectory.
There's no way to search every subdirectory but only normal files, or
to search only normal subdirectories but to search for hidden files in
them.
You may want to know in what order GREP examines files when the
/S
option is set. Ordinarily, GREP examines all files in
the first file argument, including the subdirectory tree, then
proceeds to the second file argument, and so on. However, when you use
the /S
option and none of the file arguments contains a
path, GREP will look first for all those files in the current
directory, then for all of them in the first subdirectory, and so on.
If you give GREP a filename argument that doesn't exist, it will
normally tell you, unless you used the
/Q
option.
However, when you specify /S
(search subdirectories),
GREP can't give such a warning because the specified file may exist in
some subdirectory.
(The /S
option is fully functional in the registered
version, and will search all the way to the bottom of a directory
tree. In the evaluation version, GREP will
search the named or implied directories and all directories
immediately below them, but no further in any one execution.)
The /D
option
will show you every directory and wild-card search as GREP performs it.
The output also contains lots of other stuff, but the file visits all
contain the string "GX:".
Four sections below describe the options in detail, by functional groups: pattern-matching options, input file options, general options, and output options. Here are quick hyperlinks to all the options:
You have a lot of freedom about how you enter options: use
a leading hyphen or slash, use upper- or lower-case
letters, and leave spaces between options or combine them. For
instance, the following are just some of the different ways of turning
on the /P3
and
/B
options:
/p3 -b /b/P3 /p3B -B/P3 -P3 -bThis user guide will always use capital letters for the options, to make it easier to distinguish letter l and figure 1.
/F
, /I
, /V
, /Y
/F
file
or /F-
/F
with no intervening
space, and the filename ends at the next space.
If you use a minus sign as the filename (/F-
option),
GREP will accept regexes from standard input. Don't do this if you
are redirecting file input from a file with the < character!
/V
option and
/Y
option
modify that behavior according to the rules of logic. Specifically:
When two or more regexes are read from file | |
and these options are set | then GREP reports each line from the input files if it matches |
not /V , not /Y
| at least one of the regexes |
/V , not /Y
| none of the regexes |
/Y , not /V
| all of the regexes |
/V and /Y
| less than all of the regexes (possibly none) |
/Ffile
option is activated only in the
registered version. /F-
works in
the evaluation version and the registered version.)
/I
/I
option does not apply to 8-bit
characters (characters 128-255). Because there are many different
encoding schemes, it is ambiguous which characters above 127
correspond to each other as upper and lower case on your computer.
Therefore, if you want case-blind comparisons, you must explicitly
code any 8-bit upper and lower case in your regex.
For instance, to search for the French word "thé" in upper or
lower case, code it as th[éÉE]
since
é can be upper-cased as É or as plain E. The "th", being
7-bit ASCII characters, will be found as upper or lower case by the
/I
option. (You may need to code 8-bit characters like
éÉ
in a special way if you enter them on
the command line; see Special Rules for the
Command Line below.)
/V
/V
option with two or more regexes,
see the /F
option above.
/Y
/F
option), report as matching lines
only the lines from the input files that match all the regexes in any
order.
/F
option and enter the two
regexes brown
and fox
, then all of these
lines will match:
The quick brown fox I see a brown smudge Crazy like a fox The fox's tail is brownBut if you also use the
/Y
option, then GREP will match
only lines that contain both the regular expressions, namely the first
and fourth lines in the example. In other words, multiple regexes are
normally joined by OR, but with the /Y
option they are
joined by AND.
/Y
option, input
lines must match all the regexes, but in any order. If you want to
match all regexes in a specific order, spcify them as a single regex
connected with ".*". For instance, to match lines that contain "brown"
somewhere before "fox", use the regex brown.*fox
.
/V
option with
the /Y
option,
see the /F
option above.
/A
, /R
, /S
, /W
/A
/A
option also modifies the action of the
/S
option (if present),
determining whether subdirectories marked hidden or system will be
searched.
/R
/R
option then GREP will
treat all files as binary. There's no way to treat some input files as
text and others as binary within a single GREP command.
/W
option. Since there is
no such thing as a line, the ^
and $
characters (start and end of line) in a regex
are treated as normal characters.
/R
option, when you use the
/F
option to read the
regexes from a file, that file is read in normal
text mode.
Also, if you don't specify any input files, GREP always scans the standard input
(possibly piped with |
or redirected
with <
) in text mode.
/S
/W
width
/W
option without
/R
)
/Q
option.)
/W
option and
/R
together)
/D
, /Q
, /Z
, /0
, /1
, /?
/D
file
or /D
or /D-
D
with no intervening space, and the filename ends at the next space.
GREP will append to the file if it already exists.
/D
sends debugging information to the standard
error output (normally the screen). Be careful not to specify any
other options between /D
and the next space, or they'll
be taken as a filename.
Finally, /D-
sends debugging information to the standard
output, which you can redirect (>) or pipe (|). This intersperses
debug information with the actual output of CMP.
grep GC:
parsing the command line
grep GM:
matching regexes
against input files
grep GR:
parsing and interpreting the
regexes
grep GX:
expanding directory
and file specs, including subdirectories
/Q
/D
option).
/Q
option is activated only in the
registered version.)
/Z
/Z
option on the command line, any
options in the environment variable will be
disregarded, and so will any preceding options on the command line.
This can be useful in batch files, to make sure that the action of
GREP is controlled only by the options on the command line, and not by
any settings in the environment variable.
/Z
option is the only single-letter option whose
effect can't be reversed. If you use /Z
more than once,
GREP disregards the environment variable and all command-line options
up through the last /Z
.
/0
or /1
/0
returns 0 if there are
differences or 1 if there are no differences; /1
returns
1 for differences or 0 for no differences. For more details, see
Return values below.
/?
more
or a similar filter, like this:
grep /? | more
You can also redirect this information. For instance,
grep /? >prnwill send the help text to the printer.
/B
, /C
, /H
, /L
, /N
, /P
, /U
Before going through the output options, let's take a moment to look at some of the possible output formats. By default, GREP's output is similar to that of DOS FIND:
---------- GREP.C op_showhead = ShowNoHeads; else if (op_showhead == ShowNoHeads) op_showhead = ShowNoHeads; ---------- GREP_MAT.C op_showhead == ShowNoHeads)However, the
/U
option
produces UNIX grep-style output like this:
GREP.C: op_showhead = ShowNoHeads; GREP.C: else if (op_showhead == ShowNoHeads) GREP.C: op_showhead = ShowNoHeads; GREP_MAT.C: op_showhead == ShowNoHeads)As you can see, the main difference is that DOS-style output has the filename as a header above the group of matching lines from that file, and UNIX-style output has the name of the file on every matching line.
The output options give you a lot of control over what GREP produces, but they can be confusing. Here's the executive summary:
/P
option), just the matching lines
(default), only a count of matching lines by file
(/C
option), or just the names of
files that contain matches (/L
option).
/B
option),
only the names of files that contain matches (default),
or no filename headers at all (/H
option).
/U
option)
and/or the line number (/N
option).
Now, in alphabetical order, the options that control what GREP outputs and how it is formatted:
/B
/U
option is not set.)
/C
/H
grep /H "Directory" <inputfile | other program
/L
/V
option,
display the names of files that contain no matches. (This is
the same as the L option in UNIX grep.)
/N
/N
option looks like this:
---------- GREP.C [ 144] op_showhead = ShowNoHeads; [ 178] else if (op_showhead == ShowNoHeads) [ 366] op_showhead = ShowNoHeads; ---------- GREP_MAT.C [ 98] op_showhead == ShowNoHeads)With both
/N
and
the /U
option
together, the UNIX-style output looks like this:
GREP.C:144: op_showhead = ShowNoHeads; GREP.C:178: else if (op_showhead == ShowNoHeads) GREP.C:366: op_showhead = ShowNoHeads; GREP_MAT.C:98: op_showhead == ShowNoHeads)UNIX-style output is suitable for use with the excellent freeware editor Vim.
/P
before,after
/P0,4
if you
want to show every match and the four lines that follow it.
/P
option, you probably want to use the
/N
option as well,
to display line numbers. In that case,
the punctuation of the line numbers will distinguish which lines are
actual matches and which are displayed for context. Here is some
DOS-style output from a run with the options /P1,1N
set:
---------- GREP.C 143 if (opcount >= argc) [ 144] op_showhead = ShowNoHeads; 145 177 PRTDBG "with each matching line"); [ 178] else if (op_showhead == ShowNoHeads) 179 PRTDBG "NO"); 365 if (myToggle('L') || myToggle('U') || myToggle('H')) [ 366] op_showhead = ShowNoHeads; 367 else if (myToggle('B')) ---------- GREP_MAT.C 97 op_showwhat == ShowMatchCount || [ 98] op_showhead == ShowNoHeads) 99 headered = TRUE;As you can see, the actual matches have square brackets around the line numbers, and the context lines do not.
/P
, or use the
/W
option to reduce the line
width. (The after number has no effect on memory use.)
/U
/U
option. Neither GREP and UNIX grep
displays a filename if input comes from a file via <
redirection.
In addition to these options, the /R
option,
described in detail earlier,
makes GREP read files in binary
mode, and that has a side effect on the output format.
Some combinations of output options are logically incompatible. For
instance, /H/L
makes no sense
(don't list filenames, and
list only filenames with matches). In such cases, GREP will
turn off one of the incompatible options and tell you what it did
(unless you suppress such messages with
the /Q
option).
The incompatibilities are just common sense, but are listed here for
completeness:
/B
| overrides /H ;
ignored with /L or /U
|
/C
| overrides /H , /L , /N , /P
|
/H
| ignored with /B , /C , /L , /U
|
/L
| overrides /B , /H , /N , /P , /U ;
ignored with /C
|
/N
| ignored with /C or /L
|
/P
| ignored with /C or /L
|
/U
| overrides /B and /H ;
ignored with /L
|
If you use certain options frequently, with
the registered version of GREP you can put them in the
ORS_GREP
environment variable. You have the same freedom
as on the command line: leading slashes or hyphens, space separation
or options run together, caps or lower case.
Only options can be put in the environment variable. If you want to
"can" a regex, put it in a file and put
/F
file
in the environment variable.
If you have some options in the environment variable but you don't want one of them for a particular run of GREP, you don't have to edit the environment variable. You can make most changes on the command line, like this:
/Z
option on the
command line makes GREP disregard the environment variable (as well as
any preceding options on the command line).
/N
in the environment variable. Then if
you don't want line numbers in a particular run of GREP, just specify
/N
on the command line for that run to cancel the
/N
option set in the environment variable.
/0
and /1
, which set
return values from GREP, override each other. The latest one specified
on the command line will be effective.
/D
option and
/F
option, if set in the
environment variable, cannot be turned off on the command line.
However, you can specify different files on the command line with
either of those options.
/P
and
/W
in the environment variable can be overridden by
different setting on the command line. Use
/P0
to request no context lines.
If you're ever in doubt about the interaction of options between the command line and the environment variable, simply type
grep /dand GREP will tell you all the option settings in effect.
A regular expression or regex is a pattern of characters.
It can be a simple text string, like mother
, or something more
complex. For instance, the regex for a U.S. telephone number is
[0-9][0-9][0-9]-[0-9][0-9][0-9][0-9]
, which is three
digits, followed by a hyphen, followed by four digits. A simpler
example: the regex for any word starting with "moth" is
moth[a-z]*
, which is the letters "moth" followed by any
number of letters a through z. Yes, that regex does match "moth"
itself: see the "repetition" entry below.
A regex is essentially a string with a bunch of operators thrown in to express possibilities like "any of these characters" and "repeated".
Different utilities define regexes differently. Here is how GREP defines them.
The following characters are special if they occur in the listed contexts:
\
), always
.
), asterisk (*
), plus sign
(+
), and left square bracket ([
), anywhere
except within square brackets
^
), only at the beginning of the regex or
immediately after a left square bracket
$
), only at the end of the regex
-
), only between square
brackets
Here are the rules:
\
).
Example: to search for the string "^abc\def", you must put backslashes
before the two special characters to make GREP treat them as normal
characters and not give them special meanings, so that
\^abc\\def
is your regex.
You can use any character from space through character 255. If using 8-bit characters or certain special characters on the command line, see Special Rules for the Command Line below.
If you specify the /I
option,
any letter A-Z or a-z that you specify will match both the capital and the
lower case of that letter. Other letters are not affected by the
/I
option.
[ ]
).
Examples: [aA]
will match an upper- or lower-case letter
A; sno[wr]ing
will match "snowing" or "snoring".
You can indicate a character range with the minus sign
(-
). Examples:
[0-9]
will match any single digit, and
[a-zA-Z]
will match any English letter.
To match any Western European letter (under most recent versions of
Windows, in North America and Western Europe), use
[a-zA-ZÀ-ÖØ-öø-ÿ]
.
(That regex will work fine on the command line with GREP16 or in a file
[/F
option]
with either GREP. But to enter it on the command line with
GREP32, you must use numeric sequences for the 8-bit characters, for
example [a-zA-Z\192-\214\216-\246\248-\255]
. See
"Special Rules for the Command Line"
below.)
A character class can contain both ranges and single characters, and
the order doesn't matter as long as each range within the class is written
low-high.
^
).
Examples: [^0-9 ]
matches any character except a
digit or a space, and the[^a-z]
matches "the" followed by
anything except a lower-case letter.
Note: The negative character class matches any character not within
the square brackets, but it does match a character. For instance,
the[^a-z]
matches "the" followed by something other than a
lower-case letter; it does not match "the" at the end of a line
because then "the" is not followed by any characters. Please see the
extended example at the end of these rules for
further explanation.
+
) after a character or character
class matches one or more occurrences; an asterisk
(*
) matches zero or more occurrences.
Examples: snor+ing
matches "snoring", "snorring",
"snorrring", and so on, but not "snoing". snor*ing
matches "snoing", "snoring", and so on.
Used with a character class, the plus sign and asterisk match any
multiple characters in the class, not only multiple occurrences
of the same character. For instance, sno[rw]+ing
matches
"snowing", "snorwing", "snowrring", and so on.
Obligatory example: [A-Za-z_]+[A-Za-z0-9_]*
matches a C
or C++ identifier, which is at least one letter or underscore,
followed by any number of letters, digits, and underscores.
^
, ASCII 94) at the start of a regex
means that the pattern starts at the beginning of a line in
the file(s) being searched. A dollar sign ($
,
ASCII 36) at the end of a regex means that the pattern
ends at the end of a line in the file(s) being searched. If these
characters occur anywhere else, they are treated as normal characters.
Example: ^[wW]hereas
matches the word "Whereas" or
"whereas" at the start of a line, but not in the middle of a line.
Blanks are not ignored, so if you want to find that word whenever it's
the first word of the line, you need to use a pattern like
^ *[wW]hereas
to allow for indention.
Examples: ^$
will find lines that contain no characters at
all. ^ *$
will match lines that contain no
characters or contain only spaces. ^ +$
will match
lines that contain only spaces, but not empty lines.
Examples: ^[A-Za-z]+$
will find every line that contains
nothing but English letters. ^ *[A-Za-z]+ *$
will find every line that contains exactly one English word, possibly
preceded or followed by blanks.
These characters for start of line and end of line have no special
meaning in binary mode, which is
controlled by the /R
option. In
binary mode, the ^
and $
are treated as
normal characters.
/I
option
to make the search case blind, and concentrate
on constructing the regexes. At first glance,
[^a-z]the[^a-z]
seems adequate: anything other than a
letter, followed by "the", followed by anything but a letter. That
lets in "the" and rules out "then" and "mother". But it also rules
out "the" at the beginning or end of a line. Remember that a negative
character class does insist on matching some character. So the
solution is to have four regexes, for "the" at the
beginning, middle, or end of a line, or on a line by itself:
^the[^a-z] [^a-z]the[^a-z] [^a-z]the$ ^the$So to search for just the occurrences of the word "the", you'd put those four lines in a file and then use the
/F
option on GREP.
The cautions and special rules in this section apply
only when you enter a regex on the command line.
Please ignore this section when using either form of the
/F
option, which I recommend when
your regex is at all complicated.
When you enter a regex on the command line, you have to contend with command-line parsing, which changes the meanings of some characters before GREP ever sees them. Putting double quotes around the expression may help, but it doesn't avoid all problems.
If your regex begins with a minus (-
) or slash
(/
), GREP will try to interpret it as an option. Example:
if you're searching for the string "-in-law", GREP will think you're
trying to turn on the options /I
, /N
, and so
on. To avoid this problem, use a leading backslash
(\-in-law
).
If your regex contains certain special characters like
<
, =
, and |
, DOS will give
those characters their special DOS meaning and GREP will never see
them.
So you must use special "escape sequences" to represent those
characters in a regex on the command line:
instead of | you can use any of |
---|---|
< (less) | \l \60 \0x3C \074 |
> (greater) | \g \62 \0x3E \076 |
| (vertical bar) | \v \124 \0x7C \0174 |
" (double quote) | \" \34 \0x22 \042 |
, (comma) | \c \44 \0x2C \054 |
; (semicolon) | \i \59 \0x3B \073 |
= (equal) | \q \61 \0x3D \075 |
(space) | \s \32 \0x20 \040 |
(tab) | \t \9 \0x09 \011 |
(escape) | \e \27 \0x1B \033 |
You can enter any character as a numeric sequence, not just the
special characters in the above list. Use
decimal, hex (leading 0x
), or
octal (leading zero). Example: capital A would be
\65
, \0x41
, or \0101
.
Finally, if your regex contains 8-bit characters, Microsoft's 32-bit
startup code (not DOS) will translate these characters from a DOS
character set to a Windows character set, which is probably not what
you want. To avoid this problem, either enter the regex in a file
(/F
file),
let GREP prompt you to enter it from the keyboard
(/F-
),
or use the numeric sequences to enter characters. Example: In a regex
on the command line, instead of actually typing the character
é
, enter it as \233
or
\0xE9
or \0351
.
Remember, the rules in this section are required only to get around
parsing problems on the command line. These escape sequences are not
needed, and don't work, when you use the /F
option to enter regexes in a file or from the keyboard.
ERRORLEVEL
)By default, GREP will return one of the following values to DOS, and
you can test the return value with IF ERRORLEVEL
in
a batch file.
255 | bad option, or other error on the command line or regex |
254 | specified file not available |
253 | insufficient memory: try reducing values
specified with the /P option or
/W option, or use GREP32 if possible
|
128 | program error in expanding a regex |
2 | help message displayed
(/? option, or nothing
specified on the command line)
|
0 | program ran to completion (whether or not there were any matches) |
You might want to use GREP in a batch file or a makefile and take
different actions depending on whether matches were found or not.
To do this, use the /0
or /1
option.
With the /1
option, GREP returns these values of
ERRORLEVEL
:
0 | no matches were found |
1 | one or more matches were found |
2-255 | as above |
/0
is
the opposite: it returns these ERRORLEVEL
values:
0 | one or more matches were found |
1 | no matches were found |
2-255 | as above |
/0
or /1
option
lets you tell GREP which value to return if matches are found.
If an input line contains a NUL character (ASCII 0), GREP will ignore
any later characters on that line. A text file should never contain
a NUL character, but if it does you can read it by using
the /R
option.
GREP's regexes are slightly
different from the UNIX flavor. Specifically, to accommodate DOS
command-line parsing, GREP defines quite a few more
escape characters like \c
and
\s
, as well as numeric escapes. On the other hand, GREP
regexes do not yet include the quantifiers ?
and {m,n}
, subexpressions (...)
, and
alternatives |
. They will probably be in the
next release, which will be free to registered users.
GREP release 5.0 (May 2000) was a major overhaul. There were other improvements, but the biggest single change was the ability to search binary files. Release 5.1 (later that month) fixed a bug; release 5.2 (Jan 2001) made some minor improvements. The complete revision history is available as a separate document.
New features:
/Y
option lets you search
for lines that contain multiple regexes in any order.
/D
option now allows the pseudo
filename "-", for debugging display on standard output.
ERRORLEVEL
instead of 252.
Unfortunately, a bug was introduced in release 5.3: under certain circumstances, GREP got confused about whether it was working from standard input or input files. This release corrects that bug, with my apologies to everyone who downloaded the buggy 5.3.
If you specified current directory on another disk, such as "d:*.htm", GREP was taking that as root directory, "d:\*.htm". Apparently no one but the program author ever does such a thing!
This is a repackaging for Simtel; there are no significant functional changes.