match(1)                      Mail Avenger 0.8.1                      match(1)



NAME
       match - Match strings against glob paterns

SYNOPSIS
       match [-gilrqs] [-n <n>] [-c cmd] [-x code] {[-p] pattern | -f <file>}
       str1 [str2 ...]

DESCRIPTION
       match checks strings against pattern, which should be a shell-like glob
       pattern.  pattern may contain the following special characters:

       ?   A "?" character in pattern matches any single character in the
           string, except that the "/" character is only matched if match was
           given the -s option.

       *   A "*" character in pattern matches zero or more characters in the
           string.  The exception is that it will only match "/" characters if
           match was given the -s option.

       [...]
           A set of characters between square brackets matches any character
           in the set.  In addition, the "-" character can be used to specify
           a range.  For example "[+e0-3]" would match any of the characters
           "+", "e", 0, 1, 2, or 3 in the input string.  To include a hyphen
           ("-") in the set of characters matched, either include the hyphen
           first or last, or escape it with a "\".

       [!...]
           A character class preceded by a "!" matches any character but those
           specified in the class.  The exception is that the negated
           character class will match a "/" only if match was given the -s
           option.

       \c  The backslash character escapes the next character c.  Thus, to
           match a literal "*", you would use the pattern "\*".

       match prints each string that matches pattern, one per line, and exits
       0 if one or more strings matched.  If no string matches, match exits
       with status 67 (or whatever alternate status was specified by the -x
       flag).  If the -n n flag was specified, match prints only the text that
       matched the nth occurrence of "*" in the patten.

       OPTIONS

       -f file
           Specifies that the pattern should be read from file.  match will
           read each line of the file and consider it as pattern to match
           against the argument strings.  For each argument string, match
           stops when it hits the first matching line of the file.  If file
           does not exist, match exits 67, or whatever code was specified by
           -x.

       -g  Normally, the -n option selects text matching particular "*"
           characters in the patern.  -g changes this behavior to use
           parentheses for grouping.  Thus, for instance, the text "foo.c"
           would match pattern "*(.[ch])", and the output with option -n 1
           would be ".c".  To include a literal "(" or ")" in the pattern with
           the -g option, you must precede the character with a "\".

       -i  Makes the match case insensitive.  str will be considered to match
           if any variation on its capitalization would match.  For example,
           string "G" would match pattern "[f-h]".

       -l  When a pattern matches the string in more than one way, the -l flag
           says to assign as much text as possible to the leftmost "*"s in the
           pattern.  For example, pattern "*+*" would match text "a+b+c", and
           the first "*" would match "a+b".  This behavior is the default,
           thus -l's effect is only to undo a previous -r flag.

       -n n
           With this flag, match prints the text that matched the nth "*" in
           the pattern, as opposed to printing the whole string.  The leftmost
           "*" corresponds to -n 1.  Specifying -n 0 causes match to print the
           whole matching string.  Specifying -n -1 or using a value greater
           than the number of "*"s in the pattern causes match not to print
           anything, in which case you can still use the exit status to see if
           there is a match.  The default value for n is 0, unless -g has also
           been specified, in which case the default is 1.

       -c command
           When -c is specified, match runs command with the system shell
           (/bin/sh), giving it as argument $0 the full string that matched,
           and as arguments $1, $2, etc., the parts of the string that matched
           any "*"s in pattern.  If the command does not exit with status 0,
           match will exit immediately, before processing further matches,
           with whatever status command returned.  The -c and -n flags are
           mutually exclusive.

       -p pattern
           Specifies the pattern to match against.  The -p flag is optional;
           you can specify pattern as the first argument following the
           options.  However, if you want to try matching the same input
           string against multiple patterns, then you must specify each
           pattern with a -p flag.

       -q  This option is synonymous with -n -1; it suppresses output when
           there is a match.  You can still determine whether a match occurred
           by the exit status.

       -r  When a pattern matches the string in more than one way, the -r flag
           says to assign as much text as possible to the rightmost "*"s in
           the pattern.  For example, with -r, pattern "*+*" would match text
           "a+b+c" with the "*" matching "a", and the second matching "b+c".

       -s  Ordinarily, "*", "?", and negated character classes ("[!...]") do
           not match "/" characters.  -s changes this behavior to match
           slashes.

       -x code
           By default, when there is no match, match exits with status 67.
           With this option, match exits with status code, instead.

EXAMPLES
       Suppose you have a directory with a bunch of files ending .c and .o.
       If, for each file named foo.c you want to attempt to delete the file
       foo.o, you can run the following command:

            match -p '*.c' -c 'rm -f $1.o' *.c

       Servers running the mailman list manager often send mail from bounce
       addresses of the form listname-bounces@host.com.  If you subscribe to
       multiple lists on the same server, the mailman interface makes it
       easier if you subscribe under the same address.  To split the mail into
       multiple folders based on the bounce address in the environment
       variable SENDER, you might chose a mailbox with the following shell
       code:

            name=`match -n1 "*-bounces@host.com" "$SENDER"` \
                 && echo "$HOME/Mail/incoming/host-$name.spool"

SEE ALSO
       avenger(1), avenger.local(8)

       The Mail Avenger home page: <http://www.mailavenger.org/>.

AUTHOR
       David Mazieres



Mail Avenger 0.8.1                2010-04-12                          match(1)
