| /* GLIB - Library of useful routines for C programming |
| * Copyright (C) 1995-1997, 1999 Peter Mattis, Red Hat, Inc. |
| * |
| * SPDX-License-Identifier: LGPL-2.1-or-later |
| * |
| * This library 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 2.1 of the License, or (at your option) any later version. |
| * |
| * This library 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 this library; if not, see <http://www.gnu.org/licenses/>. |
| */ |
| |
| #include "config.h" |
| |
| #include <string.h> |
| |
| #include "gpattern.h" |
| |
| #include "gmacros.h" |
| #include "gmem.h" |
| #include "gmessages.h" |
| #include "gstrfuncs.h" |
| #include "gunicode.h" |
| #include "gutils.h" |
| |
| /** |
| * GPatternSpec: |
| * |
| * A `GPatternSpec` struct is the 'compiled' form of a glob-style pattern. |
| * |
| * The [func@GLib.pattern_match_simple] and [method@GLib.PatternSpec.match] functions |
| * match a string against a pattern containing '*' and '?' wildcards with similar |
| * semantics as the standard `glob()` function: '*' matches an arbitrary, |
| * possibly empty, string, '?' matches an arbitrary character. |
| * |
| * Note that in contrast to `glob()`, the '/' character can be matched by |
| * the wildcards, there are no '[...]' character ranges and '*' and '?' |
| * can not be escaped to include them literally in a pattern. |
| * |
| * When multiple strings must be matched against the same pattern, it is better |
| * to compile the pattern to a [struct@GLib.PatternSpec] using |
| * [ctor@GLib.PatternSpec.new] and use [method@GLib.PatternSpec.match_string] |
| * instead of [func@GLib.pattern_match_simple]. This avoids the overhead of repeated |
| * pattern compilation. |
| */ |
| |
| /* keep enum and structure of gpattern.c and patterntest.c in sync */ |
| typedef enum |
| { |
| G_MATCH_ALL, /* "*A?A*" */ |
| G_MATCH_ALL_TAIL, /* "*A?AA" */ |
| G_MATCH_HEAD, /* "AAAA*" */ |
| G_MATCH_TAIL, /* "*AAAA" */ |
| G_MATCH_EXACT, /* "AAAAA" */ |
| G_MATCH_LAST |
| } GMatchType; |
| |
| struct _GPatternSpec |
| { |
| GMatchType match_type; |
| guint pattern_length; |
| guint min_length; |
| guint max_length; |
| gchar *pattern; |
| }; |
| |
| |
| /* --- functions --- */ |
| static inline gboolean |
| g_pattern_ph_match (const gchar *match_pattern, |
| const gchar *match_string, |
| gboolean *wildcard_reached_p) |
| { |
| const gchar *pattern, *string; |
| gchar ch; |
| |
| pattern = match_pattern; |
| string = match_string; |
| |
| ch = *pattern; |
| pattern++; |
| while (ch) |
| { |
| switch (ch) |
| { |
| case '?': |
| if (!*string) |
| return FALSE; |
| string = g_utf8_next_char (string); |
| break; |
| |
| case '*': |
| *wildcard_reached_p = TRUE; |
| do |
| { |
| ch = *pattern; |
| pattern++; |
| if (ch == '?') |
| { |
| if (!*string) |
| return FALSE; |
| string = g_utf8_next_char (string); |
| } |
| } |
| while (ch == '*' || ch == '?'); |
| if (!ch) |
| return TRUE; |
| do |
| { |
| gboolean next_wildcard_reached = FALSE; |
| while (ch != *string) |
| { |
| if (!*string) |
| return FALSE; |
| string = g_utf8_next_char (string); |
| } |
| string++; |
| if (g_pattern_ph_match (pattern, string, &next_wildcard_reached)) |
| return TRUE; |
| if (next_wildcard_reached) |
| /* the forthcoming pattern substring up to the next wildcard has |
| * been matched, but a mismatch occurred for the rest of the |
| * pattern, following the next wildcard. |
| * there's no need to advance the current match position any |
| * further if the rest pattern will not match. |
| */ |
| return FALSE; |
| } |
| while (*string); |
| break; |
| |
| default: |
| if (ch == *string) |
| string++; |
| else |
| return FALSE; |
| break; |
| } |
| |
| ch = *pattern; |
| pattern++; |
| } |
| |
| return *string == 0; |
| } |
| |
| /** |
| * g_pattern_spec_match: |
| * @pspec: a #GPatternSpec |
| * @string_length: the length of @string (in bytes, i.e. strlen(), |
| * not g_utf8_strlen()) |
| * @string: the UTF-8 encoded string to match |
| * @string_reversed: (nullable): the reverse of @string or %NULL |
| * |
| * Matches a string against a compiled pattern. Passing the correct |
| * length of the string given is mandatory. The reversed string can be |
| * omitted by passing %NULL, this is more efficient if the reversed |
| * version of the string to be matched is not at hand, as |
| * g_pattern_match() will only construct it if the compiled pattern |
| * requires reverse matches. |
| * |
| * Note that, if the user code will (possibly) match a string against a |
| * multitude of patterns containing wildcards, chances are high that |
| * some patterns will require a reversed string. In this case, it's |
| * more efficient to provide the reversed string to avoid multiple |
| * constructions thereof in the various calls to g_pattern_match(). |
| * |
| * Note also that the reverse of a UTF-8 encoded string can in general |
| * not be obtained by g_strreverse(). This works only if the string |
| * does not contain any multibyte characters. GLib offers the |
| * g_utf8_strreverse() function to reverse UTF-8 encoded strings. |
| * |
| * Returns: %TRUE if @string matches @pspec |
| * |
| * Since: 2.70 |
| **/ |
| gboolean |
| g_pattern_spec_match (GPatternSpec *pspec, |
| gsize string_length, |
| const gchar *string, |
| const gchar *string_reversed) |
| { |
| g_return_val_if_fail (pspec != NULL, FALSE); |
| g_return_val_if_fail (string != NULL, FALSE); |
| |
| if (string_length < pspec->min_length || |
| string_length > pspec->max_length) |
| return FALSE; |
| |
| switch (pspec->match_type) |
| { |
| gboolean dummy; |
| case G_MATCH_ALL: |
| return g_pattern_ph_match (pspec->pattern, string, &dummy); |
| case G_MATCH_ALL_TAIL: |
| if (string_reversed) |
| return g_pattern_ph_match (pspec->pattern, string_reversed, &dummy); |
| else |
| { |
| gboolean result; |
| gchar *tmp; |
| tmp = g_utf8_strreverse (string, string_length); |
| result = g_pattern_ph_match (pspec->pattern, tmp, &dummy); |
| g_free (tmp); |
| return result; |
| } |
| case G_MATCH_HEAD: |
| if (pspec->pattern_length == string_length) |
| return strcmp (pspec->pattern, string) == 0; |
| else if (pspec->pattern_length) |
| return strncmp (pspec->pattern, string, pspec->pattern_length) == 0; |
| else |
| return TRUE; |
| case G_MATCH_TAIL: |
| if (pspec->pattern_length) |
| return strcmp (pspec->pattern, string + (string_length - pspec->pattern_length)) == 0; |
| else |
| return TRUE; |
| case G_MATCH_EXACT: |
| if (pspec->pattern_length != string_length) |
| return FALSE; |
| else |
| return strcmp (pspec->pattern, string) == 0; |
| default: |
| g_return_val_if_fail (pspec->match_type < G_MATCH_LAST, FALSE); |
| return FALSE; |
| } |
| } |
| |
| /** |
| * g_pattern_match: (skip) |
| * @pspec: a #GPatternSpec |
| * @string_length: the length of @string (in bytes, i.e. strlen(), |
| * not g_utf8_strlen()) |
| * @string: the UTF-8 encoded string to match |
| * @string_reversed: (nullable): the reverse of @string or %NULL |
| * |
| * Matches a string against a compiled pattern. Passing the correct |
| * length of the string given is mandatory. The reversed string can be |
| * omitted by passing %NULL, this is more efficient if the reversed |
| * version of the string to be matched is not at hand, as |
| * g_pattern_match() will only construct it if the compiled pattern |
| * requires reverse matches. |
| * |
| * Note that, if the user code will (possibly) match a string against a |
| * multitude of patterns containing wildcards, chances are high that |
| * some patterns will require a reversed string. In this case, it's |
| * more efficient to provide the reversed string to avoid multiple |
| * constructions thereof in the various calls to g_pattern_match(). |
| * |
| * Note also that the reverse of a UTF-8 encoded string can in general |
| * not be obtained by g_strreverse(). This works only if the string |
| * does not contain any multibyte characters. GLib offers the |
| * g_utf8_strreverse() function to reverse UTF-8 encoded strings. |
| * |
| * Returns: %TRUE if @string matches @pspec |
| * Deprecated: 2.70: Use g_pattern_spec_match() instead |
| **/ |
| gboolean |
| g_pattern_match (GPatternSpec *pspec, |
| guint string_length, |
| const gchar *string, |
| const gchar *string_reversed) |
| { |
| return g_pattern_spec_match (pspec, string_length, string, string_reversed); |
| } |
| |
| /** |
| * g_pattern_spec_new: |
| * @pattern: a zero-terminated UTF-8 encoded string |
| * |
| * Compiles a pattern to a #GPatternSpec. |
| * |
| * Returns: a newly-allocated #GPatternSpec |
| **/ |
| GPatternSpec* |
| g_pattern_spec_new (const gchar *pattern) |
| { |
| GPatternSpec *pspec; |
| gboolean seen_joker = FALSE, seen_wildcard = FALSE, more_wildcards = FALSE; |
| gint hw_pos = -1, tw_pos = -1, hj_pos = -1, tj_pos = -1; |
| gboolean follows_wildcard = FALSE; |
| guint pending_jokers = 0; |
| const gchar *s; |
| gchar *d; |
| guint i; |
| |
| g_return_val_if_fail (pattern != NULL, NULL); |
| |
| /* canonicalize pattern and collect necessary stats */ |
| pspec = g_new (GPatternSpec, 1); |
| pspec->pattern_length = strlen (pattern); |
| pspec->min_length = 0; |
| pspec->max_length = 0; |
| pspec->pattern = g_new (gchar, pspec->pattern_length + 1); |
| d = pspec->pattern; |
| for (i = 0, s = pattern; *s != 0; s++) |
| { |
| switch (*s) |
| { |
| case '*': |
| if (follows_wildcard) /* compress multiple wildcards */ |
| { |
| pspec->pattern_length--; |
| continue; |
| } |
| follows_wildcard = TRUE; |
| if (hw_pos < 0) |
| hw_pos = i; |
| tw_pos = i; |
| break; |
| case '?': |
| pending_jokers++; |
| pspec->min_length++; |
| pspec->max_length += 4; /* maximum UTF-8 character length */ |
| continue; |
| default: |
| for (; pending_jokers; pending_jokers--, i++) { |
| *d++ = '?'; |
| if (hj_pos < 0) |
| hj_pos = i; |
| tj_pos = i; |
| } |
| follows_wildcard = FALSE; |
| pspec->min_length++; |
| pspec->max_length++; |
| break; |
| } |
| *d++ = *s; |
| i++; |
| } |
| for (; pending_jokers; pending_jokers--) { |
| *d++ = '?'; |
| if (hj_pos < 0) |
| hj_pos = i; |
| tj_pos = i; |
| } |
| *d++ = 0; |
| seen_joker = hj_pos >= 0; |
| seen_wildcard = hw_pos >= 0; |
| more_wildcards = seen_wildcard && hw_pos != tw_pos; |
| if (seen_wildcard) |
| pspec->max_length = G_MAXUINT; |
| |
| /* special case sole head/tail wildcard or exact matches */ |
| if (!seen_joker && !more_wildcards) |
| { |
| if (pspec->pattern[0] == '*') |
| { |
| pspec->match_type = G_MATCH_TAIL; |
| memmove (pspec->pattern, pspec->pattern + 1, --pspec->pattern_length); |
| pspec->pattern[pspec->pattern_length] = 0; |
| return pspec; |
| } |
| if (pspec->pattern_length > 0 && |
| pspec->pattern[pspec->pattern_length - 1] == '*') |
| { |
| pspec->match_type = G_MATCH_HEAD; |
| pspec->pattern[--pspec->pattern_length] = 0; |
| return pspec; |
| } |
| if (!seen_wildcard) |
| { |
| pspec->match_type = G_MATCH_EXACT; |
| return pspec; |
| } |
| } |
| |
| /* now just need to distinguish between head or tail match start */ |
| tw_pos = pspec->pattern_length - 1 - tw_pos; /* last pos to tail distance */ |
| tj_pos = pspec->pattern_length - 1 - tj_pos; /* last pos to tail distance */ |
| if (seen_wildcard) |
| pspec->match_type = tw_pos > hw_pos ? G_MATCH_ALL_TAIL : G_MATCH_ALL; |
| else /* seen_joker */ |
| pspec->match_type = tj_pos > hj_pos ? G_MATCH_ALL_TAIL : G_MATCH_ALL; |
| if (pspec->match_type == G_MATCH_ALL_TAIL) { |
| gchar *tmp = pspec->pattern; |
| pspec->pattern = g_utf8_strreverse (pspec->pattern, pspec->pattern_length); |
| g_free (tmp); |
| } |
| return pspec; |
| } |
| |
| /** |
| * g_pattern_spec_copy: |
| * @pspec: a #GPatternSpec |
| * |
| * Copies @pspec in a new #GPatternSpec. |
| * |
| * Returns: (transfer full): a copy of @pspec. |
| * |
| * Since: 2.70 |
| **/ |
| GPatternSpec * |
| g_pattern_spec_copy (GPatternSpec *pspec) |
| { |
| GPatternSpec *pspec_copy; |
| |
| g_return_val_if_fail (pspec != NULL, NULL); |
| |
| pspec_copy = g_new (GPatternSpec, 1); |
| *pspec_copy = *pspec; |
| pspec_copy->pattern = g_strndup (pspec->pattern, pspec->pattern_length); |
| |
| return pspec_copy; |
| } |
| |
| /** |
| * g_pattern_spec_free: |
| * @pspec: a #GPatternSpec |
| * |
| * Frees the memory allocated for the #GPatternSpec. |
| **/ |
| void |
| g_pattern_spec_free (GPatternSpec *pspec) |
| { |
| g_return_if_fail (pspec != NULL); |
| |
| g_free (pspec->pattern); |
| g_free (pspec); |
| } |
| |
| /** |
| * g_pattern_spec_equal: |
| * @pspec1: a #GPatternSpec |
| * @pspec2: another #GPatternSpec |
| * |
| * Compares two compiled pattern specs and returns whether they will |
| * match the same set of strings. |
| * |
| * Returns: Whether the compiled patterns are equal |
| **/ |
| gboolean |
| g_pattern_spec_equal (GPatternSpec *pspec1, |
| GPatternSpec *pspec2) |
| { |
| g_return_val_if_fail (pspec1 != NULL, FALSE); |
| g_return_val_if_fail (pspec2 != NULL, FALSE); |
| |
| return (pspec1->pattern_length == pspec2->pattern_length && |
| pspec1->match_type == pspec2->match_type && |
| strcmp (pspec1->pattern, pspec2->pattern) == 0); |
| } |
| |
| /** |
| * g_pattern_spec_match_string: |
| * @pspec: a #GPatternSpec |
| * @string: the UTF-8 encoded string to match |
| * |
| * Matches a string against a compiled pattern. If the string is to be |
| * matched against more than one pattern, consider using |
| * g_pattern_match() instead while supplying the reversed string. |
| * |
| * Returns: %TRUE if @string matches @pspec |
| * |
| * Since: 2.70 |
| **/ |
| gboolean |
| g_pattern_spec_match_string (GPatternSpec *pspec, |
| const gchar *string) |
| { |
| g_return_val_if_fail (pspec != NULL, FALSE); |
| g_return_val_if_fail (string != NULL, FALSE); |
| |
| return g_pattern_spec_match (pspec, strlen (string), string, NULL); |
| } |
| |
| /** |
| * g_pattern_match_string: (skip) |
| * @pspec: a #GPatternSpec |
| * @string: the UTF-8 encoded string to match |
| * |
| * Matches a string against a compiled pattern. If the string is to be |
| * matched against more than one pattern, consider using |
| * g_pattern_match() instead while supplying the reversed string. |
| * |
| * Returns: %TRUE if @string matches @pspec |
| * Deprecated: 2.70: Use g_pattern_spec_match_string() instead |
| **/ |
| gboolean |
| g_pattern_match_string (GPatternSpec *pspec, |
| const gchar *string) |
| { |
| return g_pattern_spec_match_string (pspec, string); |
| } |
| |
| /** |
| * g_pattern_match_simple: |
| * @pattern: the UTF-8 encoded pattern |
| * @string: the UTF-8 encoded string to match |
| * |
| * Matches a string against a pattern given as a string. If this |
| * function is to be called in a loop, it's more efficient to compile |
| * the pattern once with g_pattern_spec_new() and call |
| * g_pattern_match_string() repeatedly. |
| * |
| * Returns: %TRUE if @string matches @pspec |
| **/ |
| gboolean |
| g_pattern_match_simple (const gchar *pattern, |
| const gchar *string) |
| { |
| GPatternSpec *pspec; |
| gboolean ergo; |
| |
| g_return_val_if_fail (pattern != NULL, FALSE); |
| g_return_val_if_fail (string != NULL, FALSE); |
| |
| pspec = g_pattern_spec_new (pattern); |
| ergo = g_pattern_spec_match (pspec, strlen (string), string, NULL); |
| g_pattern_spec_free (pspec); |
| |
| return ergo; |
| } |