static GRegex * create_regex ( const char *input, int case_sensitive ) { #define R( s ) g_regex_new ( s, G_REGEX_OPTIMIZE | ( ( case_sensitive ) ? 0 : G_REGEX_CASELESS ), 0, NULL ) GRegex * retv = NULL; if ( config.glob ) { gchar *r = glob_to_regex ( input ); retv = R ( r ); g_free ( r ); } else if ( config.regex ) { retv = R ( input ); if ( retv == NULL ) { gchar *r = g_regex_escape_string ( input, -1 ); retv = R ( r ); g_free ( r ); } } else{ // TODO; regex should be default? gchar *r = g_regex_escape_string ( input, -1 ); retv = R ( r ); g_free ( r ); } return retv; }
static gboolean test_glob_to_regex(void) { gboolean ok = TRUE; struct { char *glob, *regex; } tests[] = { { "abc", "^abc$" }, { "*.txt", "^[^/]*\\.txt$" }, { "?.txt", "^[^/]\\.txt$" }, { "?*.txt", "^[^/][^/]*\\.txt$" }, { "foo.[tT][xX][tT]", "^foo\\.[tT][xX][tT]$" }, { "foo.[tT][!yY][tT]", "^foo\\.[tT][^yY][tT]$" }, { "foo\\\\", "^foo\\\\$" }, { "(){}+.^$|", "^\\(\\)\\{\\}\\+\\.\\^\\$\\|$" }, { "/usr/bin/*", "^/usr/bin/[^/]*$" }, { NULL, NULL }, }, *t; for (t = tests; t->glob; t++) { char *regex = glob_to_regex(t->glob); if (!g_str_equal(regex, t->regex)) { ok = FALSE; g_fprintf(stderr, "glob_to_regex(\"%s\") returned \"%s\"; expected \"%s\"\n", t->glob, regex, t->regex); } } return ok; }
int cd_glob( char * glob, int verbose) { char *regex; char *regex_path; char *s; char *uqglob; int result; char *tpath_on_disk = NULL; if (disk_name == NULL) { g_printf(_("Must select disk before changing directory\n")); return 0; } uqglob = unquote_string(glob); regex = glob_to_regex(uqglob); dbprintf(_("cd_glob (%s) -> %s\n"), uqglob, regex); if ((s = validate_regexp(regex)) != NULL) { g_printf(_("\"%s\" is not a valid shell wildcard pattern: "), glob); puts(s); amfree(regex); amfree(uqglob); return 0; } /* * glob_to_regex() anchors the beginning of the pattern with ^, * but we will be tacking it onto the end of the current directory * in add_file, so strip that off. Also, it anchors the end with * $, but we need to match a trailing /, add it if it is not there */ regex_path = g_strdup(regex + 1); amfree(regex); if(regex_path[strlen(regex_path) - 2] != '/' ) { regex_path[strlen(regex_path) - 1] = '\0'; strappend(regex_path, "/$"); } /* convert path (assumed in cwd) to one on disk */ if (g_str_equal(disk_path, "/")) tpath_on_disk = g_strconcat("/", regex_path, NULL); else { char *clean_disk_tpath = clean_regex(disk_tpath, 0); tpath_on_disk = g_strjoin(NULL, clean_disk_tpath, "/", regex_path, NULL); amfree(clean_disk_tpath); } result = cd_dir(tpath_on_disk, uqglob, verbose); amfree(regex_path); amfree(tpath_on_disk); amfree(uqglob); return result; }
LLDirIterator::Impl::Impl(const std::string &dirname, const std::string &mask) : mIsValid(false) { fs::path dir_path(dirname); bool is_dir = false; // Check if path is a directory. try { is_dir = fs::is_directory(dir_path); } catch (const fs::filesystem_error& e) { LL_WARNS() << e.what() << LL_ENDL; return; } if (!is_dir) { LL_WARNS() << "Invalid path: \"" << dir_path.string() << "\"" << LL_ENDL; return; } // Initialize the directory iterator for the given path. try { mIter = fs::directory_iterator(dir_path); } catch (const fs::filesystem_error& e) { LL_WARNS() << e.what() << LL_ENDL; return; } // Convert the glob mask to a regular expression std::string exp = glob_to_regex(mask); // Initialize boost::regex with the expression converted from // the glob mask. // An exception is thrown if the expression is not valid. try { mFilterExp.assign(exp); } catch (boost::regex_error& e) { LL_WARNS() << "\"" << exp << "\" is not a valid regular expression: " << e.what() << LL_ENDL; return; } mIsValid = true; }
/* Registers action handler for a particular combination of event and path * pattern. Event name is case insensitive. Returns zero on successful * registration or non-zero on error. */ static int add_aucmd(const char event[], const char pattern[], int negated, const char action[], vle_aucmd_handler handler) { char canonic_path[PATH_MAX]; aucmd_info_t *autocmd; char *regexp; autocmd = DA_EXTEND(autocmds); if(autocmd == NULL) { return 1; } if(strchr(pattern, '/') != NULL) { canonicalize_path(pattern, canonic_path, sizeof(canonic_path)); if(!is_root_dir(canonic_path)) { chosp(canonic_path); } pattern = canonic_path; } regexp = glob_to_regex(pattern, 1); if(regexp == NULL) { return 1; } if(regcomp(&autocmd->regex, regexp, REG_EXTENDED | REG_ICASE) != 0) { free(regexp); return 1; } free(regexp); autocmd->event = strdup(event); autocmd->pattern = strdup(pattern); autocmd->negated = negated; autocmd->action = strdup(action); autocmd->handler = handler; if(autocmd->event == NULL || autocmd->pattern == NULL || autocmd->action == NULL) { free_autocmd_data(autocmd); return 1; } DA_COMMIT(autocmds); /* TODO: sort by event name (case insensitive) and then by pattern? */ return 0; }
char *validate_glob(const char *glob) { char *regex, *ret = NULL; regex_t regc; static regex_errbuf errmsg; regex = glob_to_regex(glob); if (!do_regex_compile(regex, ®c, &errmsg, TRUE)) ret = errmsg; regfree(®c); g_free(regex); return ret; }
LLDirIterator::Impl::Impl(const std::string &dirname, const std::string &mask) : mIsValid(false) { fs::path dir_path(dirname); // Check if path exists. if (!fs::exists(dir_path)) { llwarns << "Invalid path: \"" << dir_path.string() << "\"" << llendl; return; } // Initialize the directory iterator for the given path. try { mIter = fs::directory_iterator(dir_path); } catch (fs::basic_filesystem_error<fs::path>& e) { llerrs << e.what() << llendl; return; } // Convert the glob mask to a regular expression std::string exp = glob_to_regex(mask); // Initialize boost::regex with the expression converted from // the glob mask. // An exception is thrown if the expression is not valid. try { mFilterExp.assign(exp); } catch (boost::regex_error& e) { llerrs << "\"" << exp << "\" is not a valid regular expression: " << e.what() << llendl; return; } mIsValid = true; }
int match_glob(const char *glob, const char *str) { char *regex; regex_t *re; int result; regex_errbuf errmsg; regex = glob_to_regex(glob); re = get_regex_from_cache(regex, &errmsg, TRUE); if (!re) error("glob \"%s\" -> regex \"%s\": %s", glob, regex, errmsg); /*NOTREACHED*/ result = try_match(re, str, &errmsg); if (result == MATCH_ERROR) error("glob \"%s\" -> regex \"%s\": %s", glob, regex, errmsg); /*NOTREACHED*/ g_free(regex); return result; }
bool impl::matches_glob(const std::string& glob, const std::string& candidate) { return tools::text::match(candidate, glob_to_regex(glob)); }