/* * Copyright (C) 2023 Linux Studio Plugins Project * (C) 2023 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 29 мая 2019 г. * * 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 namespace lsp { namespace osc { static size_t pattern_calc_segments(const char *address, size_t len) { // Compute number of parts if ((len <= 0) || (*(address++) != '/')) return 0; // Estimate number of parts in the address const char *s; size_t parts = 1; while (true) { if ((s = reinterpret_cast(::memchr(address, '/', len))) == NULL) break; ++parts; ++s; len -= (s - address); address = s; } return parts; } static void pattern_split_segments(char **dst, const char *format, size_t len) { const char *s; size_t idx = 0; while (true) { dst[idx++] = const_cast(format); if ((s = reinterpret_cast(::memchr(format, '/', len))) == NULL) break; ++s; len -= (s - format); format = s; } } // Non-valid characters for OSC: ' ', '#, '*', ',', '/', '?', '[', ']', '{', '}' static inline bool pattern_is_invalid(int ch) { switch (ch) { // End of part? case ' ': case '#': case '*': case ',': case '/': case '?': case '[': case ']': case '{': case '}': case '\0': return true; default: return ((ch < 0x20) || (ch >= 0x7f)); } return true; } static inline bool pattern_is_printable(int ch) { return ((ch >= 0x20) && (ch < 0x7f)); } static const char *pattern_validate_list(const char *part) { while (true) { uint8_t ch = uint8_t(*(part++)); // Check validity of character if (pattern_is_invalid(ch)) { if (ch == '}') // End of list? return part; else if (ch != ',') // Separator? return NULL; } } } static const char *pattern_validate_range(const char *part) { // Negotation mark? if (*part == '!') ++part; size_t count = 0; while (true) { uint8_t ch = uint8_t(*(part++)); // Check validity of character if (pattern_is_invalid(ch)) return ((ch == ']') && (count > 0)) ? part : NULL; // Range character occurred? ++count; if (*part == '-') { ++part; if (pattern_is_invalid(*part)) return NULL; ++part; } } } static bool pattern_validate_part(const char *part) { // Do not allow empty elements uint8_t ch = uint8_t(*(part++)); if ((ch == '\0') || (ch == '/')) return false; while (true) { switch (ch) { // Special cases? case '{': if (!(part = pattern_validate_list(part))) return false; break; case '[': if (!(part = pattern_validate_range(part))) return false; break; case '*': case '?': break; // End of part? case '/': case '\0': return true; // Not allowed characters? case ' ': case '#': case ']': case '}': case ',': return false; // Each OSC Method and each OSC Container other than the root of the tree has a symbolic name, // an ASCII string consisting of printable characters other than... default: if (!pattern_is_printable(ch)) return false; break; } ch = uint8_t(*(part++)); } } status_t pattern_create(pattern_t *pattern, const char *format) { // Check arguments if ((pattern == NULL) || (format == NULL)) return STATUS_BAD_ARGUMENTS; // Estimate number of parts size_t len = strlen(format); size_t parts = pattern_calc_segments(format, len); if (parts <= 0) return STATUS_BAD_FORMAT; // Now allocate the memory size_t fmt_size = align_size(len + 1, DEFAULT_ALIGN); size_t arg_size = align_size(sizeof(char *) * parts, DEFAULT_ALIGN); // Try to allocate the memory char *xfmt = reinterpret_cast(::malloc(fmt_size + arg_size)); if (xfmt == NULL) return STATUS_NO_MEM; ::memcpy(xfmt, format, len); // Copy string contents xfmt[len] = '\0'; char **xargs = reinterpret_cast(&xfmt[fmt_size]); // Split segments of pattern pattern_split_segments(xargs, &xfmt[1], len); // Validate pattern segments for (size_t i=0; inparts = parts; pattern->format = xfmt; pattern->parts = xargs; return STATUS_OK; } status_t pattern_destroy(pattern_t *pattern) { if (pattern == NULL) return STATUS_BAD_ARGUMENTS; if ((pattern->format == NULL) || (pattern->parts == NULL)) return STATUS_OK; ::free(pattern->format); pattern->nparts = 0; pattern->parts = NULL; pattern->format = NULL; return STATUS_OK; } static const char *pattern_match_range(const char **xpart, const char *address, const char *end) { const char *part = *xpart; bool invert = false; // Negotation mark? if (*part == '!') { ++part; invert = true; } // Immediate end of range? if ((*part == ']') || (address >= end)) return (invert) ? NULL : address; // Get character for check and validate uint8_t ch = uint8_t(*(address++)); if (pattern_is_invalid(ch)) return NULL; bool matched = false; while (true) { // Get control character uint8_t sch = uint8_t(*(part++)); if (sch == ']') { *xpart = part; return (matched ^ invert) ? address : NULL; } else if (matched) continue; // Range check ? if (*part == '-') { ++part; uint8_t dch = uint8_t(*(part++)); if (sch <= dch) matched = ((ch >= sch) && (ch <= dch)); else matched = ((ch >= dch) && (ch <= sch)); } else matched = (ch == sch); } } static const char *pattern_match_list(const char **xpart, const char *address, const char *end) { ssize_t len = 0; bool matched = false; const char *part = *xpart, *item = *xpart; while (true) { uint8_t ch = uint8_t(*(part++)); switch (ch) { // End of list? case '}': if ((!matched) && ((end - address) >= len)) { if ((matched = (::memcmp(item, address, len) == 0))) address = &address[len]; } *xpart = part; return (matched) ? address : NULL; // Next token? case ',': if (matched) break; if ((end - address) >= len) { if ((matched = (::memcmp(item, address, len) == 0))) address = &address[len]; } // Update list item parameters item = part; len = 0; break; // Another chatacter? default: ++len; break; } } } static const char *pattern_match_part(const char *part, const char *address, const char *end) { while (true) { uint8_t pch = uint8_t(*(part++)); switch (pch) { // End of segment? case '\0': case '/': pch = uint8_t(*address); return ((pch == '\0') || (pch == '/')) ? address : NULL; // Any character? case '?': if (pattern_is_invalid(*(address++))) return NULL; break; // Wildcard? case '*': { do { // Do forward lookup const char *new_address = pattern_match_part(part, address, end); if (new_address) return new_address; pch = uint8_t(*(address++)); } while ((pch != '\0') && (pch != '/')); return NULL; } // Start of character range? case '[': if ((address = pattern_match_range(&part, address, end))) break; return address; // Start of string list? case '{': if ((address = pattern_match_list(&part, address, end))) break; return address; // Simple character match? default: if (*(address++) != pch) return NULL; break; } } } bool pattern_match(const pattern_t *pattern, const char *address) { if ((pattern == NULL) || (address == NULL)) return false; uint8_t ch = uint8_t(*(address++)); if (ch != '/') return false; const char *end = address + strlen(address); for (size_t parts=0; parts < pattern->nparts; ) { const char *part = pattern->parts[parts++]; // The substring in address should be not empty ch = *address; if ((ch == '\0') || (ch == '/')) return false; // Match address string with pattern if (!(address = pattern_match_part(part, address, end))) return false; switch (*address) { case '\0': return parts == pattern->nparts; case '/': ++address; break; default: return false; } } return false; } status_t pattern_get_format(pattern_t *pattern, const char **format) { if ((pattern == NULL) || (format == NULL)) return STATUS_BAD_ARGUMENTS; *format = pattern->format; return STATUS_OK; } } /* namespace osc */ } /* namespace lsp */