blob: bf61da36f2c43c641241924dcf685098110792b3 [file] [log] [blame]
/* 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;
}