/* * Copyright (C) 2023 Linux Studio Plugins Project * (C) 2023 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 15 окт. 2020 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #ifndef LSP_PLUG_IN_IO_PATHPATTERN_H_ #define LSP_PLUG_IN_IO_PATHPATTERN_H_ #include #include #include #include #include #include namespace lsp { namespace io { // // The pattern for the file name. // // Syntax: // * - Any character sequence except '/' or '\' // ? - Any character except '/' or '\' // / or \ - Path separator // `/ - Escaped character '/' (Available for escaping: '*', '?', '`', '/', '\', '&', '|', '(', ')' ) // name.ext - Strict match of characters to 'name.ext' // ... & ... - Conjunction of two conditions // ... | ... - Disjunction of two conditions // ! ... - Negotation of match // **/ or **\ - Any path // ( ... ) - Pattern group // // Example: // **/((*.c|*.h)&(test-*)) - matches any source/header C files for any subdirectory starting with 'test-' prefix class PathPattern { public: enum flags { INVERSE = 1 << 0, MATCH_CASE = 1 << 1, FULL_PATH = 1 << 2, NONE = 0 }; protected: enum command_t { CMD_SEQUENCE, // cmd1 cmd2 ... CMD_AND, // ... & ... CMD_OR, // ... | ... CMD_PATTERN, // ... text ... CMD_ANY, // ... * ... CMD_ANYPATH, // ... **/ ... }; enum matcher_type_t { M_PATTERN, M_ANY, M_ANYPATH, M_BOOL, M_SEQUENCE, M_BRUTE }; enum token_type_t { T_GROUP_START, // ( T_IGROUP_START, // !( T_GROUP_END, // ) T_OR, // | T_AND, // & T_NOT, // ! T_TEXT, // text T_ANY, // * T_ANYPATH, // **/ T_EOF // }; typedef struct cmd_t { command_t nCommand; // Command size_t nStart; // Start of character sequence size_t nLength; // Length of character sequence ssize_t nChars; // Actual length in characters (without escaping) bool bInverse; // Inverse condition flag lltl::parray sChildren; } cmd_t; typedef struct tokenizer_t { ssize_t nToken; const LSPString *pMask; size_t nPosition; size_t nStart; // Start position of token data size_t nLength; // Length of character sequence ssize_t nChars; // Actual length in characters (without escaping) } token_t; protected: struct matcher_t; typedef struct pos_t { size_t start; size_t count; } pos_t; typedef bool (*match_match_t)(matcher_t *m, size_t start, size_t count); typedef struct matcher_t { matcher_type_t type; // Type of matcher match_match_t match; const cmd_t *cmd; // Command const LSPString *pat; // Pattern data const LSPString *str; // Destination string to match size_t flags; // Flags } matcher_t; typedef struct any_matcher_t : public matcher_t { ssize_t bad; // Index of last bad character ssize_t good; // Index of last good match } any_matcher_t; typedef struct bool_matcher_t : public matcher_t { lltl::parray cond; // List of additionally checked conditions } bool_matcher_t; typedef struct mregion_t { size_t start; // Start of the region matcher_t *matcher; // Matcher assigned to the region const cmd_t *cmd; // Command } mregion_t; typedef struct sequence_matcher_t: public matcher_t { size_t prefix; // Number of fixed prefixes size_t postfix; // Number of fixed postfixes lltl::darray fixed; // Fixed text regions lltl::parray var; // Variable text regions } sequence_matcher_t; typedef struct brute_matcher_t: public matcher_t { lltl::darray items; // Matching regions } brute_matcher_t; protected: LSPString sMask; cmd_t *pRoot; size_t nFlags; protected: status_t parse(const LSPString *pattern, size_t flags = NONE); bool match_full(const LSPString *path) const; static ssize_t get_token(tokenizer_t *it); static inline void next_token(tokenizer_t *it); static status_t parse_not(cmd_t **dst, tokenizer_t *it); static status_t parse_and(cmd_t **dst, tokenizer_t *it); static status_t parse_or(cmd_t **dst, tokenizer_t *it); static status_t parse_sequence(cmd_t **dst, tokenizer_t *it); static void destroy_cmd(cmd_t *cmd); static status_t merge_simple(cmd_t **out, command_t type, command_t cmd, tokenizer_t *it); static status_t merge_step(cmd_t **out, cmd_t *next, command_t type); static status_t merge_last(cmd_t **dst, cmd_t *out, cmd_t *next, ssize_t tok); static matcher_t *create_matcher(const matcher_t *src, const cmd_t *cmd); static bool add_range_matcher(sequence_matcher_t *sm, const pos_t *pos); static void destroy_matcher(matcher_t *match); static bool pattern_matcher_match(matcher_t *m, size_t start, size_t count); static bool any_matcher_match(matcher_t *m, size_t start, size_t count); static bool anypath_matcher_match(matcher_t *m, size_t start, size_t count); static bool and_matcher_match(matcher_t *m, size_t start, size_t count); static bool or_matcher_match(matcher_t *m, size_t start, size_t count); static bool sequence_matcher_match(matcher_t *m, size_t start, size_t count); static bool brute_matcher_match(matcher_t *m, size_t start, size_t count); static bool check_pattern_case(const lsp_wchar_t *pat, const lsp_wchar_t *s, size_t len); static bool check_pattern_nocase(const lsp_wchar_t *pat, const lsp_wchar_t *s, size_t len); static ssize_t seek_pattern_case(const lsp_wchar_t *pat, const lsp_wchar_t *s, size_t len, ssize_t rounds); static ssize_t seek_pattern_nocase(const lsp_wchar_t *pat, const lsp_wchar_t *s, size_t len, ssize_t rounds); static ssize_t sequence_check_prefix(sequence_matcher_t *sm, size_t start, size_t count); static ssize_t sequence_check_postfix(sequence_matcher_t *sm, size_t start, size_t count); static bool sequence_alloc_fixed(sequence_matcher_t *sm, size_t idx, size_t start, size_t count); static bool sequence_next_fixed(sequence_matcher_t *sm, size_t start, size_t count); static bool sequence_match_variable(sequence_matcher_t *sm, size_t start, size_t count); static bool brute_match_variable(brute_matcher_t *bm, size_t start, size_t count); static bool brute_next_variable(brute_matcher_t *bm, size_t start, size_t count); public: explicit PathPattern(); PathPattern(const PathPattern &) = delete; PathPattern(PathPattern &&) = delete; ~PathPattern(); PathPattern & operator = (const PathPattern &) = delete; PathPattern & operator = (PathPattern &&) = delete; public: status_t set(const PathPattern *src) { return parse(&src->sMask, src->nFlags); } status_t set(const Path *pattern, size_t flags = NONE) { return parse(pattern->as_string(), flags);} status_t set(const LSPString *pattern, size_t flags = NONE) { return parse(pattern, flags); } status_t set(const char *pattern, size_t flags = NONE); inline const char *get_utf8() const { return sMask.get_utf8(); } inline const LSPString *get() const { return &sMask; } inline status_t get(LSPString *mask) const { return (mask != NULL) ? mask->set(&sMask) : STATUS_BAD_ARGUMENTS; } inline status_t get(Path *mask) const { return (mask != NULL) ? mask->set(&sMask) : STATUS_BAD_ARGUMENTS; } inline size_t flags() const { return nFlags; } size_t set_flags(size_t flags); inline status_t set_pattern(const PathPattern *src) { return set(&src->sMask, nFlags); } inline status_t set_pattern(const LSPString *pattern) { return set(pattern, nFlags); } inline status_t set_pattern(const Path *pattern) { return set(pattern, nFlags); } inline status_t set_pattern(const char *pattern) { return set(pattern, nFlags); } bool test(const char *path) const; bool test(const LSPString *path) const; bool test(const Path *path) const; void swap(PathPattern *dst); inline void swap(PathPattern &dst) { swap(&dst); } }; } /* namespace io */ } /* namespace lsp */ #endif /* LSP_PLUG_IN_IO_PATHPATTERN_H_ */