NAME

       shellexp - match string against a cruft filter pattern

SYNOPSIS

       extern int shellexp(const char *string, const char *pattern);

DESCRIPTION

       The shellexp() function is similar to fnmatch(3), but works with cruft patterns instead of
       standard glob(7) patterns.  The function returns a true value if string matches the  cruft
       pattern  pattern,  and  a  false value (0) otherwise. Returns -1 in case of pattern syntax
       error.

       Cruft patterns are similar  to  glob(7)  patterns,  but  are  not  fully  compatible.  The
       following special characters are supported:

       ? (a question mark)
              matches exacly one character of string other than a slash.

       *      matches zero or more characters of string other than a slash.

       /** or /**/
              matches  zero or more path components in string.  Please note that you can only use
              ** when directly following a slash, and  furthermore,  only  when  either  directly
              preceding  a  slash or at the very end of pattern.  A ** followed by anything other
              than a slash makes pattern invalid. A **  following  anything  else  than  a  slash
              reduces it to having the same effect as *.

       [character-class]
              Matches  any  character  between the brackets exactly once. Named character classes
              are NOT supported. If the first character of the class is !  or ^, then the meaning
              is  inverted  (matches any character NOT listed between the brackets).  If you want
              to specify a literal closing bracket in the class, then specify it as the first (or
              second,  if  you want to negate) character after the opening bracket.  Also, simple
              ASCII-order ranges are supported using a dash character (see examples section).

       Any other character matches itself.

EXAMPLES

       /a/b*/*c
              matches /a/b/xyz.c, as well as /a/bcd/.c, but not /a/b/c/d.c.

       /a/**/*.c
              matches all of the following: /a/a.c, /a/b/a.c, /a/b/c/a.c and /a/b/c/d/a.c.

       /a/[0-9][^0-9]*
              matches /a/1abc, but not /a/12bc.

BUGS

       Uses constant-length 1000 byte buffers to hold filenames.  Also  uses  recursive  function
       calls, which are not very efficient. Does not validate the pattern before matching, so any
       pattern errors (unbalanced brackets or misplaced **) are only reported  when  and  if  the
       matching algorithm reaches them.

SEE ALSO

       fnmatch(3), glob(3), cruft(8) and dash-search(1).

AUTHOR

       This  manual  page  was  written  by  Marcin Owsiany <porridge@debian.org>, for the Debian
       GNU/Linux system (but may be used by others).

                                         October 17, 2007                             SHELLEXP(3)