/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 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 . */ #include #include #include #include namespace lsp { namespace io { static inline bool is_file_separator(lsp_wchar_t c) { return (c == '/') || (c == '\\'); } PathPattern::PathPattern() { nFlags = 0; pRoot = NULL; } PathPattern::~PathPattern() { destroy_cmd(pRoot); pRoot = NULL; } void PathPattern::destroy_cmd(cmd_t *cmd) { if (cmd == NULL) return; // Recursively delete all sub-nodes for (size_t i=0, n=cmd->sChildren.size(); isChildren.uget(i); destroy_cmd(child); } delete cmd; } void PathPattern::next_token(tokenizer_t *it) { it->nToken = -1; } ssize_t PathPattern::get_token(tokenizer_t *it) { // There is unget token? if (it->nToken >= 0) return it->nToken; const LSPString *mask = it->pMask; // End of input? if (it->nPosition >= mask->length()) return it->nToken = T_EOF; // Analyze first character it->nStart = it->nPosition; it->nLength = 0; it->nChars = -1; lsp_wchar_t c = mask->char_at(it->nPosition++); bool escape; switch (c) { case '&': // T_AND return it->nToken = T_AND; case '|': // T_OR return it->nToken = T_OR; case '!': // T_NOT, TT_IGROUP_START if (it->nPosition >= mask->length()) return it->nToken = T_NOT; if (mask->char_at(it->nPosition) != '(') return it->nToken = T_NOT; ++it->nPosition; return it->nToken = T_IGROUP_START; case ')': // T_GROUP_END return it->nToken = T_GROUP_END; case '(': // T_GROUP_START, T_IGROUP_START return it->nToken = T_GROUP_START; case '*': // T_ANY, T_ANYPATH if ((it->nPosition + 2) > mask->length()) return it->nToken = T_ANY; if (mask->char_at(it->nPosition) != '*') return it->nToken = T_ANY; c = mask->char_at(it->nPosition+1); if (!is_file_separator(c)) return it->nToken = T_ANY; it->nPosition += 2; return it->nToken = T_ANYPATH; default: // T_TEXT it->nToken = T_TEXT; escape = c == '`'; it->nChars = (escape) ? 0 : 1; break; } // Parse T_TEXT for ( ; it->nPosition < mask->length(); ++it->nPosition ) { // Lookup next character c = mask->char_at(it->nPosition); switch (c) { // Special symbols case '*': case '(': case ')': case '|': case '&': case '!': if (!escape) { it->nLength = it->nPosition - it->nStart; return it->nToken; } ++it->nChars; escape = false; break; case '`': if (escape) ++it->nChars; escape = !escape; break; default: if (escape) { ++it->nChars; escape = false; } ++it->nChars; break; } } // Escape character pending? if (escape) ++it->nChars; it->nLength = it->nPosition - it->nStart; return it->nToken; } status_t PathPattern::merge_step(cmd_t **out, cmd_t *next, command_t type) { if (*out == NULL) { cmd_t *tmp = new cmd_t(); tmp->nCommand = type; tmp->nStart = 0; tmp->nLength = 0; tmp->nChars = -1; tmp->bInverse = false; *out = tmp; } if (next == NULL) return STATUS_OK; return (*out)->sChildren.add(next) ? STATUS_OK : STATUS_NO_MEM; } status_t PathPattern::merge_simple(cmd_t **out, command_t type, command_t cmd, tokenizer_t *it) { cmd_t *tmp = new cmd_t(); tmp->nCommand = cmd; tmp->nStart = it->nStart; tmp->nLength = it->nLength; tmp->nChars = it->nChars; tmp->bInverse = false; status_t res = merge_step(out, tmp, type); if (res != STATUS_OK) destroy_cmd(tmp); return res; } status_t PathPattern::merge_last(cmd_t **dst, cmd_t *out, cmd_t *next, ssize_t tok) { // Analyze last token if (tok < 0) { destroy_cmd(next); destroy_cmd(out); return status_t(-tok); } else if (out == NULL) { *dst = next; return STATUS_OK; } else if (!out->sChildren.add(next)) { destroy_cmd(out); destroy_cmd(next); return STATUS_NO_MEM; } // Return the output expression *dst = out; return STATUS_OK; } status_t PathPattern::parse_sequence(cmd_t **dst, tokenizer_t *it) { cmd_t *out = NULL, *next = NULL; status_t res = STATUS_OK; while (true) { ssize_t tok = get_token(it); switch (tok) { case T_GROUP_START: case T_IGROUP_START: next_token(it); if ((res = parse_or(&next, it)) != STATUS_OK) break; next->bInverse ^= (tok == T_IGROUP_START); if ((next->nCommand == CMD_PATTERN) && (next->nChars <= 0) && (!next->bInverse)) { // Premature optimization: ignore empty text since it has no rational sense destroy_cmd(next); // Drop the command next = NULL; } else if ((next->nCommand == CMD_ANY) && (next->nChars < 0) && (next->bInverse)) { // Premature optimization: ignore inverse ANY match since it has no rational sense destroy_cmd(next); // Drop the command next = NULL; } else if ((next->nCommand == CMD_PATTERN) && (next->bInverse)) { next->nCommand = CMD_ANY; next->bInverse = false; // Premature optimization: replace previous ANY match with ANY EXCEPT match cmd_t *prev = (out != NULL) ? out->sChildren.last() : NULL; if ((prev != NULL) && (prev->nCommand == CMD_ANY) && (prev->nChars < 0) && (!prev->bInverse)) { // Premature optimization: replace previous ANY match with ANY EXCEPT prev->nChars = next->nChars; prev->nStart = next->nStart; prev->nLength = next->nLength; destroy_cmd(next); // Drop the command next = NULL; } } // Merge next item if (next != NULL) res = merge_step(&out, next, CMD_SEQUENCE); // Check result if (res != STATUS_OK) { destroy_cmd(next); break; } // Require END-OF-GROUP token tok = get_token(it); if (tok == T_EOF) return -STATUS_EOF; else if (tok != T_GROUP_END) return -STATUS_BAD_FORMAT; next_token(it); break; case T_TEXT: next_token(it); // Premature optimization: ignore empty text since it has no rational sense if (it->nChars == 0) break; res = merge_simple(&out, CMD_SEQUENCE, CMD_PATTERN, it); break; case T_ANY: next_token(it); // Premature optimization: Reduce sequence of multiple ANY elements to one ANY element next = (out != NULL) ? out->sChildren.last() : NULL; if ((next != NULL) && (next->nCommand == CMD_ANY)) break; res = merge_simple(&out, CMD_SEQUENCE, CMD_ANY, it); break; case T_ANYPATH: next_token(it); next = (out != NULL) ? out->sChildren.last() : NULL; // Premature optimization: Reduce sequence of **/ to one element if ((next != NULL) && (next->nCommand == CMD_ANYPATH)) break; res = merge_simple(&out, CMD_SEQUENCE, CMD_ANYPATH, it); break; default: res = merge_step(&out, NULL, CMD_SEQUENCE); if (res != STATUS_OK) break; if (out->sChildren.size() == 1) { // Premature optimization: treat sequence of one element as this element *dst = out->sChildren.uget(0); out->sChildren.clear(); destroy_cmd(out); } else { if (out->sChildren.is_empty()) { // Premature optimization: Treat empty sequence as empty text out->nCommand = CMD_PATTERN; out->nStart = 0; out->nLength = 0; out->nChars = 0; } *dst = out; } return res; } if (res != STATUS_OK) { destroy_cmd(out); return res; } } } status_t PathPattern::parse_not(cmd_t **dst, tokenizer_t *it) { bool inverse = false; // Premature optimization: treat multiple ! as valid inverse ssize_t tok = get_token(it); while (tok == T_NOT) { next_token(it); inverse = !inverse; tok = get_token(it); } status_t res = parse_sequence(dst, it); if (res == STATUS_OK) (*dst)->bInverse ^= inverse; return res; } status_t PathPattern::parse_and(cmd_t **dst, tokenizer_t *it) { cmd_t *out = NULL, *next = NULL; // Parse sub-expression status_t res = parse_not(&next, it); if (res != STATUS_OK) return res; // Get token (and move to next) ssize_t tok = get_token(it); while (tok == T_AND) { // Commit token next_token(it); // Merge command and parse next sub-expression if ((res = merge_step(&out, next, CMD_AND)) == STATUS_OK) res = parse_not(&next, it); // Parse command if (res != STATUS_OK) { destroy_cmd(out); destroy_cmd(next); return res; } // Get next token tok = get_token(it); } return merge_last(dst, out, next, tok); } status_t PathPattern::parse_or(cmd_t **dst, tokenizer_t *it) { cmd_t *out = NULL, *next = NULL; // Parse sub-expression status_t res = parse_and(&next, it); if (res != STATUS_OK) return res; // Get token (and move to next) ssize_t tok = get_token(it); while (tok == T_OR) { // Commit token next_token(it); // Merge command and parse next sub-expression if ((res = merge_step(&out, next, CMD_OR)) == STATUS_OK) res = parse_and(&next, it); // Parse command if (res != STATUS_OK) { destroy_cmd(out); destroy_cmd(next); return res; } // Get next token tok = get_token(it); } return merge_last(dst, out, next, tok); } status_t PathPattern::parse(const LSPString *pattern, size_t flags) { tokenizer_t it; PathPattern tmp; // Initialize temporary pattern if (!tmp.sMask.set(pattern)) return STATUS_NO_MEM; tmp.nFlags = flags; // Initialize tokenizer it.nToken = -1; it.pMask = &tmp.sMask; it.nPosition = 0; it.nStart = 0; it.nLength = 0; it.nChars = 0; // Parse expression status_t res = parse_or(&tmp.pRoot, &it); if (res == STATUS_OK) { ssize_t tok = get_token(&it); if (tok < 0) return status_t(-tok); else if (tok != T_EOF) return STATUS_BAD_FORMAT; tmp.swap(this); // Apply new value on success } return res; } bool PathPattern::check_pattern_case(const lsp_wchar_t *pat, const lsp_wchar_t *s, size_t len) { lsp_wchar_t c, pc; for (size_t off=0; offcmd; if (count != size_t(m->cmd->nChars)) return cmd->bInverse; const lsp_wchar_t *pat = m->pat->characters() + cmd->nStart; const lsp_wchar_t *str = m->str->characters() + start; bool match = (m->flags & MATCH_CASE) ? check_pattern_case(pat, str, cmd->nLength) : check_pattern_nocase(pat, str, cmd->nLength); return match ^ cmd->bInverse; } bool PathPattern::any_matcher_match(matcher_t *m, size_t start, size_t count) { const cmd_t *cmd = m->cmd; if ((cmd->nChars < 0) && (count == 0)) return !cmd->bInverse; // Bad match is inside of the passed range? any_matcher_t *am = static_cast(m); if ((am->bad >= ssize_t(start)) && (am->bad < ssize_t(start + count))) return cmd->bInverse; // Good match is inside of the passed range? Return immediately with unsuccess if ((am->good >= ssize_t(start)) && ((am->good + cmd->nChars) < ssize_t(start + count))) return cmd->bInverse; // We need to ensure that there are no denied items within the area const lsp_wchar_t *str = m->str->characters() + start; for (size_t i=0; ibad = start + i; // Cache last bad value return cmd->bInverse; } } // Additionally, if we have 'except' rule, lookup for the sub-string if (cmd->nChars < 0) return !cmd->bInverse; // No 'except' rule else if (cmd->nChars == 0) return (count > 0) ^ cmd->bInverse; // Empty 'except', always match ranges longer than 0 characters // Perform seek by pattern ssize_t loops = count - cmd->nChars + 1; const lsp_wchar_t *pat = m->pat->characters() + cmd->nStart; ssize_t match = (m->flags & MATCH_CASE) ? seek_pattern_case(pat, str, cmd->nLength, loops) : seek_pattern_nocase(pat, str, cmd->nLength, loops); if (match >= 0) am->good = start + match; return (match < 0) ^ cmd->bInverse; // There should be no match found for good reason } bool PathPattern::anypath_matcher_match(matcher_t *m, size_t start, size_t count) { const cmd_t *cmd = m->cmd; const lsp_wchar_t *str = m->str->characters() + start; lsp_wchar_t ch; // Not beginning of string? if (start > 0) { // Previous character in sequence should be a path separator ch = str[-1]; if (!is_file_separator(ch)) return cmd->bInverse; // Zero length, previous character is separator -> matches if (count == 0) return !cmd->bInverse; } else if (count == 0) return true; // Zero length, start of string -> matches, this is special case which always returns true // Last character in sequence should be a path separator ch = str[count-1]; if (is_file_separator(ch)) return !cmd->bInverse; // The separator is not necessary if we are at the end of line if ((start + count) >= m->str->length()) return !cmd->bInverse; return cmd->bInverse; } bool PathPattern::and_matcher_match(matcher_t *m, size_t start, size_t count) { bool_matcher_t *bm = static_cast(m); const cmd_t *cmd = bm->cmd; // If at least one matcher does not match - return result for (size_t i=0, n=bm->cond.size(); icond.uget(i); if (!m->match(m, start, count)) return cmd->bInverse; } return !cmd->bInverse; } bool PathPattern::or_matcher_match(matcher_t *m, size_t start, size_t count) { bool_matcher_t *bm = static_cast(m); const cmd_t *cmd = bm->cmd; // If at least one matcher matches - return result for (size_t i=0, n=bm->cond.size(); icond.uget(i); if (m->match(m, start, count)) return !cmd->bInverse; } return cmd->bInverse; } ssize_t PathPattern::sequence_check_prefix(sequence_matcher_t *sm, size_t start, size_t count) { const cmd_t *cmd = sm->cmd; for (size_t i=0; iprefix; ++i) { const cmd_t *xc = cmd->sChildren.uget(i); if (count < size_t(xc->nChars)) return -1; const lsp_wchar_t *src = sm->str->characters() + start; const lsp_wchar_t *pat = sm->pat->characters() + xc->nStart; bool match = (sm->flags & MATCH_CASE) ? check_pattern_case(pat, src, xc->nLength) : check_pattern_nocase(pat, src, xc->nLength); if (!match) return -1; // Update the matching range start += xc->nChars; count -= xc->nChars; } return start; } ssize_t PathPattern::sequence_check_postfix(sequence_matcher_t *sm, size_t start, size_t count) { const cmd_t *cmd = sm->cmd; start += count; for (size_t i=0, idx=cmd->sChildren.size()-1; ipostfix; ++i, --idx) { const cmd_t *xc = cmd->sChildren.uget(idx); if (count < size_t(xc->nChars)) return -1; start -= xc->nChars; const lsp_wchar_t *src = sm->str->characters() + start; const lsp_wchar_t *pat = sm->pat->characters() + xc->nStart; bool match = (sm->flags & MATCH_CASE) ? check_pattern_case(pat, src, xc->nLength) : check_pattern_nocase(pat, src, xc->nLength); if (!match) return -1; // Update the matching range count -= xc->nChars; } return start; } bool PathPattern::sequence_alloc_fixed(sequence_matcher_t *sm, size_t idx, size_t start, size_t count) { ssize_t last = start + count; for (size_t i=idx, n=sm->fixed.size(); ifixed.uget(i); const cmd_t *xc = r->cmd; const lsp_wchar_t *src = sm->str->characters() + start; const lsp_wchar_t *pat = sm->pat->characters() + xc->nStart; // Find match ssize_t loops = last - start - xc->nChars + 1; ssize_t match = (sm->flags & MATCH_CASE) ? seek_pattern_case(pat, src, xc->nLength, loops) : seek_pattern_nocase(pat, src, xc->nLength, loops); if (match < 0) // No match found? return false; r->start = start + match; start = r->start + xc->nChars; } return true; } bool PathPattern::sequence_next_fixed(sequence_matcher_t *sm, size_t start, size_t count) { // Now we need to update positions ssize_t last = start + count; for (ssize_t i = sm->fixed.size() - 1; i >= 0; --i) { mregion_t *r = sm->fixed.uget(i); const cmd_t *xc = r->cmd; ssize_t first = r->start + 1; const lsp_wchar_t *src = sm->str->characters() + first; const lsp_wchar_t *pat = sm->pat->characters() + xc->nStart; ssize_t loops = last - first; ssize_t match = (sm->flags & MATCH_CASE) ? seek_pattern_case(pat, src, xc->nLength, loops) : seek_pattern_nocase(pat, src, xc->nLength, loops); if (match >= 0) { r->start = first + match; first = r->start + xc->nChars; if (sequence_alloc_fixed(sm, i + 1, first, last - first)) return true; } } return false; } bool PathPattern::sequence_match_variable(sequence_matcher_t *sm, size_t start, size_t count) { mregion_t *r; matcher_t *m; ssize_t first = start, last = start + count; for (size_t i=0, n=sm->fixed.size(); ifixed.uget(i); m = sm->var.uget(i); if (!m->match(m, first, r->start - first)) return false; first = r->start + r->cmd->nChars; } // Perform N+1'th match m = sm->var.last(); if (!m->match(m, first, last - first)) return false; return true; } bool PathPattern::sequence_matcher_match(matcher_t *m, size_t start, size_t count) { sequence_matcher_t *sm = static_cast(m); const cmd_t *cmd = sm->cmd; // Check prefixes ssize_t last = start + count; ssize_t first = sequence_check_prefix(sm, start, count); if (first < 0) return cmd->bInverse; // Check postfixes last = sequence_check_postfix(sm, first, last - first); if (last < 0) return cmd->bInverse; count = last - first; start = first; // Now we have only N fixed and N+1 variable positions left if (sm->fixed.size() <= 0) // No fixed elements? { if (sm->var.size() <= 0) return (first == last) ^ cmd->bInverse; m = sm->var.uget(0); bool match = m->match(m, first, count); return match ^ cmd->bInverse; } // Perform initial match if (!sequence_alloc_fixed(sm, 0, start, count)) return cmd->bInverse; // Check for non-fixed match while (true) { // Perform N matches bool match = sequence_match_variable(sm, start, count); if (match) return !cmd->bInverse; // Try to search next fixed pattern if (!sequence_next_fixed(sm, start, count)) return cmd->bInverse; } return false; } bool PathPattern::brute_match_variable(brute_matcher_t *bm, size_t start, size_t count) { mregion_t *r = bm->items.first(); ssize_t last = start + count; // Check all matchers except last one for (size_t i=1, n=bm->items.size(); i < n; ++i) { mregion_t *nr = bm->items.get(i); if (!r->matcher->match(r->matcher, r->start, nr->start - r->start)) return false; r = nr; // Update current matcher } // Check last matcher return r->matcher->match(r->matcher, r->start, last - r->start); } bool PathPattern::brute_next_variable(brute_matcher_t *bm, size_t start, size_t count) { // We move all regions except the first one for (size_t i=1, n=bm->items.size(); i < n; ++i) { mregion_t *r = bm->items.get(i); // Can move current region one position left? if (r->start > start) { --r->start; while ((i--) > 1) { mregion_t *pr = bm->items.get(i); pr->start = r->start; } return true; } } return false; } bool PathPattern::brute_matcher_match(matcher_t *m, size_t start, size_t count) { brute_matcher_t *bm = static_cast(m); const cmd_t *cmd = bm->cmd; // Only one element? if (bm->items.size() <= 1) { mregion_t *r = bm->items.first(); bool match = r->matcher->match(r->matcher, start, count); return match ^ cmd->bInverse; } // Initialize positions ssize_t last = start + count; mregion_t *r = bm->items.first(); r->start = start; for (size_t i=1; iitems.size(); ++i) { r = bm->items.uget(i); r->start = last; } // Iterate over all variants while (true) { bool match = brute_match_variable(bm, start, count); if (match) return !cmd->bInverse; // Try to search next fixed pattern if (!brute_next_variable(bm, start, count)) return cmd->bInverse; } return false; } bool PathPattern::add_range_matcher(sequence_matcher_t *sm, const pos_t *pos) { // Simple case (one command) ? const cmd_t *cmd = sm->cmd; if (pos->count <= 1) { const cmd_t *xc = cmd->sChildren.uget(pos->start); matcher_t *m = create_matcher(sm, xc); if ((m != NULL) && (sm->var.add(m))) return true; destroy_matcher(m); return false; } // Create brute matcher brute_matcher_t *bm = new brute_matcher_t(); if (bm == NULL) return false; bm->type = M_BRUTE; bm->match = brute_matcher_match; bm->cmd = cmd; bm->pat = sm->pat; bm->str = sm->str; bm->flags = sm->flags; // Add matcher if (!sm->var.add(bm)) { destroy_matcher(bm); return false; } for (size_t i=0; icount; ++i) { const cmd_t *xc = cmd->sChildren.uget(pos->start + i); // Add new sub-matcher descriptor to brute matcher mregion_t *r = bm->items.add(); if (r == NULL) return false; // Create sub-matcher r->start = 0; r->matcher = create_matcher(bm, xc); r->cmd = NULL; if (r->matcher == NULL) return false; } return true; } PathPattern::matcher_t *PathPattern::create_matcher(const matcher_t *src, const cmd_t *cmd) { switch (cmd->nCommand) { case CMD_PATTERN: { matcher_t *m = new matcher_t(); if (m == NULL) return NULL; m->type = M_PATTERN; m->match = pattern_matcher_match; m->cmd = cmd; m->pat = src->pat; m->str = src->str; m->flags = src->flags; return m; } case CMD_ANY: { any_matcher_t *m = new any_matcher_t(); if (m == NULL) return NULL; m->type = M_ANY; m->match = any_matcher_match; m->cmd = cmd; m->pat = src->pat; m->str = src->str; m->flags = src->flags; m->bad = -1; m->good = -1; return m; } case CMD_ANYPATH: { matcher_t *m = new matcher_t(); if (m == NULL) return NULL; m->type = M_ANYPATH; m->match = anypath_matcher_match; m->cmd = cmd; m->pat = src->pat; m->str = src->str; m->flags = src->flags; return m; } case CMD_AND: case CMD_OR: { bool_matcher_t *m = new bool_matcher_t(); if (m == NULL) return NULL; m->type = M_BOOL; m->match = (cmd->nCommand == CMD_AND) ? and_matcher_match : or_matcher_match; m->cmd = cmd; m->pat = src->pat; m->str = src->str; m->flags = src->flags; // Create child matchers for (size_t i=0, n=cmd->sChildren.size(); isChildren.uget(i); matcher_t *cm = create_matcher(m, c); if ((cm == NULL) || (!m->cond.add(cm))) { destroy_matcher(m); return NULL; } } return m; } case CMD_SEQUENCE: { sequence_matcher_t *m = new sequence_matcher_t(); if (m == NULL) return NULL; m->type = M_SEQUENCE; m->match = sequence_matcher_match; m->cmd = cmd; m->pat = src->pat; m->str = src->str; m->flags = src->flags; m->prefix = 0; m->postfix = 0; size_t i = 0, n = cmd->sChildren.size(); // Count prefixes for ( ; i < n; ++i) { const cmd_t *xc = cmd->sChildren.uget(i); if ((xc->nCommand != CMD_PATTERN) || (xc->bInverse)) break; ++m->prefix; } // Count postfixes for ( ; i < n; --n) { const cmd_t *xc = cmd->sChildren.uget(n-1); if ((xc->nCommand != CMD_PATTERN) || (xc->bInverse)) break; ++m->postfix; } // Scan for fixed items and create additional matchers pos_t range; range.start = 0; range.count = 0; for (; isChildren.uget(i); if ((xc->nCommand == CMD_PATTERN) && (!xc->bInverse)) { mregion_t *r; // Add variable matcher if (!add_range_matcher(m, &range)) { destroy_matcher(m); return NULL; } // Add fixed range matcher if ((r = m->fixed.add()) == NULL) { destroy_matcher(m); return NULL; } // Initialize pattern matcher r->start = 0; r->matcher = NULL; r->cmd = xc; // Reset counter range.count = 0; } else { // Save range as variable-size range if (range.count == 0) range.start = i; ++range.count; } } // Last operation: add variable matcher if there is one if (range.count <= 0) return m; // Add last range if (!add_range_matcher(m, &range)) { destroy_matcher(m); return NULL; } return m; } default: break; } return NULL; } void PathPattern::destroy_matcher(matcher_t *m) { if (m == NULL) return; switch (m->type) { // Pattern matcher case M_PATTERN: case M_ANYPATH: { delete m; break; } case M_ANY: { any_matcher_t *am = static_cast(m); delete am; break; } case M_BOOL: { bool_matcher_t *bm = static_cast(m); // Destroy all child matchers for (size_t i=0, n=bm->cond.size(); icond.uget(i)); delete bm; break; } case M_SEQUENCE: { sequence_matcher_t *sm = static_cast(m); // Destroy fixed matchers for (size_t i=0, n=sm->fixed.size(); ifixed.uget(i); destroy_matcher(r->matcher); } // Destroy variable matchers for (size_t i=0, n=sm->var.size(); ivar.uget(i)); delete sm; break; } case M_BRUTE: { brute_matcher_t *bm = static_cast(m); // Destroy nested matchers for (size_t i=0, n=bm->items.size(); iitems.uget(i); destroy_matcher(r->matcher); } delete bm; break; } default: break; } } bool PathPattern::match_full(const LSPString *path) const { matcher_t root; root.cmd = NULL; root.pat = &sMask; root.str = path; root.flags = nFlags & MATCH_CASE; matcher_t *rm = create_matcher(&root, pRoot); if (rm == NULL) return false; // Seek the matcher bool match = rm->match(rm, 0, path->length()) ^ bool(nFlags & INVERSE); destroy_matcher(rm); return match; } status_t PathPattern::set(const char *pattern, size_t flags) { LSPString tmp; return (tmp.set_utf8(pattern)) ? parse(&tmp, flags) : STATUS_NO_MEM; } size_t PathPattern::set_flags(size_t flags) { size_t old = nFlags; nFlags = flags & (INVERSE | MATCH_CASE | FULL_PATH); return old; } bool PathPattern::test(const char *path) const { if (pRoot == NULL) return false; Path tmp; if (tmp.set(path) != STATUS_OK) return false; if (!(nFlags & FULL_PATH)) { if (tmp.remove_base() != STATUS_OK) return false; } return match_full(tmp.as_string()); } bool PathPattern::test(const LSPString *path) const { if (pRoot == NULL) return false; Path tmp; if (tmp.set(path) != STATUS_OK) return false; if (!(nFlags & FULL_PATH)) { if (tmp.remove_base() != STATUS_OK) return false; } return match_full(tmp.as_string()); } bool PathPattern::test(const Path *path) const { if (pRoot == NULL) return false; if (nFlags & FULL_PATH) return match_full(path->as_string()); Path tmp; if (tmp.get_last(&tmp) != STATUS_OK) return false; return match_full(tmp.as_string()); } void PathPattern::swap(PathPattern *dst) { sMask.swap(dst->sMask); lsp::swap(pRoot, dst->pRoot); lsp::swap(nFlags, dst->nFlags); } } /* namespace io */ } /* namespace lsp */