X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=plocate.cpp;h=9f3928b1a8349e8db0e57d82bb31fd8df59171ef;hb=8c40d71acb262d9efe84af89e28a448bddadbabe;hp=7a0067be5dfb0d36b936ca01456a6d7a88fb309f;hpb=c28d24e937196869416aa0bf653ef0a5d92ffda7;p=plocate diff --git a/plocate.cpp b/plocate.cpp index 7a0067b..9f3928b 100644 --- a/plocate.cpp +++ b/plocate.cpp @@ -1,12 +1,14 @@ #include "db.h" #include "io_uring_engine.h" #include "parse_trigrams.h" +#include "turbopfor.h" #include "unique_sort.h" #include #include #include #include +#include #include #include #include @@ -31,15 +33,22 @@ using namespace std; using namespace std::chrono; -#define dprintf(...) -//#define dprintf(...) fprintf(stderr, __VA_ARGS__); +#define dprintf(...) \ + do { \ + if (use_debug) { \ + fprintf(stderr, __VA_ARGS__); \ + } \ + } while (false) -#include "turbopfor.h" +#define DEFAULT_DBPATH "/var/lib/mlocate/plocate.db" -const char *dbpath = "/var/lib/mlocate/plocate.db"; +const char *dbpath = DEFAULT_DBPATH; bool ignore_case = false; bool only_count = false; bool print_nul = false; +bool use_debug = false; +bool patterns_are_regex = false; +bool use_extended_regex = false; int64_t limit_matches = numeric_limits::max(); class Serializer { @@ -89,7 +98,8 @@ void Serializer::release_current() struct Needle { enum { STRSTR, - REGEX } type; + REGEX, + GLOB } type; string str; // Filled in no matter what. regex_t re; // For REGEX. }; @@ -98,6 +108,9 @@ bool matches(const Needle &needle, const char *haystack) { if (needle.type == Needle::STRSTR) { return strstr(haystack, needle.str.c_str()) != nullptr; + } else if (needle.type == Needle::GLOB) { + int flags = ignore_case ? FNM_CASEFOLD : 0; + return fnmatch(needle.str.c_str(), haystack, flags) == 0; } else { assert(needle.type == Needle::REGEX); return regexec(&needle.re, haystack, /*nmatch=*/0, /*pmatch=*/nullptr, /*flags=*/0) == 0; @@ -389,11 +402,17 @@ void do_search_file(const vector &needles, const char *filename) dprintf("Corpus init done after %.1f ms.\n", 1e3 * duration(steady_clock::now() - start).count()); vector trigram_groups; - for (const Needle &needle : needles) { - if (needle.str.size() < 3) - continue; - parse_trigrams(needle.str, ignore_case, &trigram_groups); + if (patterns_are_regex) { + // We could parse the regex to find trigrams that have to be there + // (there are actually known algorithms to deal with disjunctions + // and such, too), but for now, we just go brute force. + // Using locate with regexes is pretty niche. + } else { + for (const Needle &needle : needles) { + parse_trigrams(needle.str, ignore_case, &trigram_groups); + } } + unique_sort( &trigram_groups, [](const TrigramDisjunction &a, const TrigramDisjunction &b) { return a.trigram_alternatives < b.trigram_alternatives; }, @@ -547,41 +566,36 @@ void do_search_file(const vector &needles, const char *filename) } } -regex_t needle_to_regex(const string &needle) +string unescape_glob_to_plain_string(const string &needle) { - string escaped_needle; - for (char ch : needle) { - switch (ch) { - // Directly from what regex(7) considers an “atom”. - case '^': - case '.': - case '[': - case '$': - case '(': - case ')': - case '|': - case '*': - case '+': - case '?': - case '{': - case '\\': - escaped_needle.push_back('\\'); - // Fall through. - default: - escaped_needle.push_back(ch); + string unescaped; + for (size_t i = 0; i < needle.size(); i += read_unigram(needle, i).second) { + uint32_t ch = read_unigram(needle, i).first; + assert(ch != WILDCARD_UNIGRAM); + if (ch == PREMATURE_END_UNIGRAM) { + fprintf(stderr, "Pattern '%s' ended prematurely\n", needle.c_str()); + exit(1); } + unescaped.push_back(ch); } + return unescaped; +} + +regex_t compile_regex(const string &needle) +{ regex_t re; - int err; + int flags = REG_NOSUB; if (ignore_case) { - err = regcomp(&re, escaped_needle.c_str(), REG_NOSUB | REG_ICASE); - } else { - err = regcomp(&re, escaped_needle.c_str(), REG_NOSUB); + flags |= REG_ICASE; } + if (use_extended_regex) { + flags |= REG_EXTENDED; + } + int err = regcomp(&re, needle.c_str(), flags); if (err != 0) { char errbuf[256]; regerror(err, &re, errbuf, sizeof(errbuf)); - fprintf(stderr, "Error when compiling regex for '%s': %s\n", needle.c_str(), errbuf); + fprintf(stderr, "Error when compiling regex '%s': %s\n", needle.c_str(), errbuf); exit(1); } return re; @@ -589,35 +603,52 @@ regex_t needle_to_regex(const string &needle) void usage() { - // The help text comes from mlocate. - printf("Usage: plocate [OPTION]... PATTERN...\n"); - printf("\n"); - printf(" -c, --count only print number of found entries\n"); - printf(" -d, --database DBPATH use DBPATH instead of default database (which is\n"); - printf(" %s)\n", dbpath); - printf(" -h, --help print this help\n"); - printf(" -i, --ignore-case ignore case distinctions when matching patterns\n"); - printf(" -l, --limit, -n LIMIT limit output (or counting) to LIMIT entries\n"); - printf(" -0, --null separate entries with NUL on output\n"); + printf( + "Usage: plocate [OPTION]... PATTERN...\n" + "\n" + " -c, --count print number of matches instead of the matches\n" + " -d, --database DBPATH search for files in DBPATH\n" + " (default is " DEFAULT_DBPATH ")\n" + " -i, --ignore-case search case-insensitively\n" + " -l, --limit LIMIT stop after LIMIT matches\n" + " -0, --null delimit matches by NUL instead of newline\n" + " -r, --regexp interpret patterns as basic regexps (slow)\n" + " --regex interpret patterns as extended regexps (slow)\n" + " --help print this help\n" + " --version print version information\n"); +} + +void version() +{ + printf("plocate %s\n", PLOCATE_VERSION); + printf("Copyright 2020 Steinar H. Gunderson\n"); + printf("License GPLv2+: GNU GPL version 2 or later .\n"); + printf("This is free software: you are free to change and redistribute it.\n"); + printf("There is NO WARRANTY, to the extent permitted by law.\n"); + exit(0); } int main(int argc, char **argv) { + constexpr int EXTENDED_REGEX = 1000; static const struct option long_options[] = { { "help", no_argument, 0, 'h' }, { "count", no_argument, 0, 'c' }, { "database", required_argument, 0, 'd' }, { "ignore-case", no_argument, 0, 'i' }, { "limit", required_argument, 0, 'l' }, - { nullptr, required_argument, 0, 'n' }, { "null", no_argument, 0, '0' }, + { "version", no_argument, 0, 'V' }, + { "regexp", no_argument, 0, 'r' }, + { "regex", no_argument, 0, EXTENDED_REGEX }, + { "debug", no_argument, 0, 'D' }, // Not documented. { 0, 0, 0, 0 } }; setlocale(LC_ALL, ""); for (;;) { int option_index = 0; - int c = getopt_long(argc, argv, "cd:hil:n:0", long_options, &option_index); + int c = getopt_long(argc, argv, "cd:hil:n:0VD", long_options, &option_index); if (c == -1) { break; } @@ -641,25 +672,64 @@ int main(int argc, char **argv) case '0': print_nul = true; break; + case 'r': + patterns_are_regex = true; + break; + case EXTENDED_REGEX: + patterns_are_regex = true; + use_extended_regex = true; + break; + case 'D': + use_debug = true; + break; + case 'V': + version(); + break; default: exit(1); } } + if (use_debug) { + // Debug information would leak information about which files exist, + // so drop setgid before we open the file; one would either need to run + // as root, or use a locally-built file. + if (setgid(getgid()) != 0) { + perror("setgid"); + exit(EXIT_FAILURE); + } + } + vector needles; for (int i = optind; i < argc; ++i) { Needle needle; needle.str = argv[i]; - if (ignore_case) { - // strcasestr() doesn't handle locales correctly (even though LSB - // claims it should), but somehow, the glibc regex engine does. - // It's much slower than strstr() for non-case-sensitive searches, though - // (even though it really ought to be faster, since it can precompile), - // so only use it for that. + + + // See if there are any wildcard characters, which indicates we should treat it + // as an (anchored) glob. + bool any_wildcard = false; + for (size_t i = 0; i < needle.str.size(); i += read_unigram(needle.str, i).second) { + if (read_unigram(needle.str, i).first == WILDCARD_UNIGRAM) { + any_wildcard = true; + break; + } + } + + if (patterns_are_regex) { needle.type = Needle::REGEX; - needle.re = needle_to_regex(argv[i]); + needle.re = compile_regex(needle.str); + } else if (any_wildcard) { + needle.type = Needle::GLOB; + } else if (ignore_case) { + // strcasestr() doesn't handle locales correctly (even though LSB + // claims it should), but somehow, fnmatch() does, and it's about + // the same speed as using a regex. + needle.type = Needle::GLOB; + needle.str = "*" + needle.str + "*"; } else { needle.type = Needle::STRSTR; + needle.str = unescape_glob_to_plain_string(needle.str); } needles.push_back(move(needle)); }