 The "Method" parameter determines the kind of search performed on the
 database, providing flexibilty on search times and ranges.
 
 These are the possible search methods:
 
 (1) "sub"
 
     Substring (case insensitive). A simple, everyday substring search. A
     match occurs if the the file (or directory) name in the database
     contains the user-given substring.
 
 Example:
 
     "is" will match "islington" and "this" and "poison"
 
 (2) "subcase"
 
     Substring (case sensitive). As above but the case of the
     strings involved becomes significant.
 
 Example:
 
     "TeX" will match "LaTeX" but not "Latex" or "TExTroff".
 
 
 (3) "exact"
 
     Exact match. The fastest search method of all.  The restriction is
     that the search string has to _exactly_ match (including case) the 
	 string in the database. This is provided for those of who who know 
	 just what you are looking for.
 
     For example, if you wanted to know where all the "xlock.tar.Z" files
     were, this is the kind of search to use.
 
 (4) "regex"
 
     ed(1) regular expressions. Searches the database with the user
     (search) string which is given in the form of an ed(1) regular
     expression.
 
 NOTE: Unless specifically anchored to the beginning (with ^) or end
 (with $) of a line, ed(1) regular expressions have ".*" prepended and
 appended to them. For example, it is NOT NECESSARY to say
 
                .*xnlock.*
 
 since
                xnlock
 
 will suffice. Thus the regex match becomes a simple substring match.
 
 There are also compound searches made up of combinations
 of the above search methods in sequence:
 
        exact_sub       Try "exact". If no matches found use
                        "sub".
        exact_subcase   Try "exact". If no matches found use
                        "subcase"
        exact_regex     Try "exact". If no matches found use
                        regex.
 
 
 An "ed(1) regular expression" (from here on called RE) is the particular
 type of regular expression used in the "ed" editor under Unix.
 
 A regular expression is a convenient way to search for a set of specific
 strings matching a pattern.  To be able to specify such a pattern with
 only the ordinary set of printable character we have to co-opt some of
 them.  For example in a RE the period means _any_ single character,
 while an asterisk, '*', means zero or more occurences of the *PRECEDING*
 RE.
 
 For example:
 
   knob      - matches any string containing the substring 'knob'
 
   a*splat   - matches strings that contain zero or more a's followed by the
               string 'splat'
 
   #.*#      - would match anything containing a '#' followed by zero or more
               occurences of _any_ character, followed by another '#'
 
 Other special characters that may be useful are '[' and ']', which are
 used together.  They can be used to specify either a set of characters
 to match or a set of characters to not match.  An example of the first
 case is:
 
    [abcd]
 
 which matches any of one of the four letters, while an example of the
 second case is:
 
    [^abcd]
 
 in which the '^' _in_the_first_position_ means that any character _not_
 in the list will be matched.  As well, ranges can be specified with a
 '-'.
 
    [a-z]
 
 matches any lower case letter and,
 
    [^a-z]
 
 matches any character other than a lower case letter.  Furthermore, you
 can specify multiple ranges such as:
 
    [%@a-z0-9]
 
 or
 
    [^A-Za-z]
 
 meaning: match '%' or '@' or any lower case letter or digit, and match
 any character other than a letter, respectively.
 
 When you want to match a character which has a special meaning you should
 precede it by a backslash, '\'.
 
 Some final examples of REs are:
 
    [Mm]ac\.txt         - match anything containg the string "Mac.txt" or
                          "mac.txt"
 
    [^aeiou][^aeiou]*   - match any string consisting entirely of non-vowels
 
    foo-v[0-9]\.tar\.Z  - match "foo-v0.tar.Z" through "foo-v9.tar.Z"
 
 
 Good luck, and remember that many things can be found with only a simple
 substring (e.g. latex).
